Bug Summary

File:src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/ExprConstant.cpp
Warning:line 5966, column 57
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ExprConstant.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include/clang/AST -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangAST/../include -I /usr/src/gnu/usr.bin/clang/libclangAST/obj -I /usr/src/gnu/usr.bin/clang/libclangAST/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangAST/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/ExprConstant.cpp

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/lib/AST/ExprConstant.cpp

1//===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Expr constant evaluator.
10//
11// Constant expression evaluation produces four main results:
12//
13// * A success/failure flag indicating whether constant folding was successful.
14// This is the 'bool' return value used by most of the code in this file. A
15// 'false' return value indicates that constant folding has failed, and any
16// appropriate diagnostic has already been produced.
17//
18// * An evaluated result, valid only if constant folding has not failed.
19//
20// * A flag indicating if evaluation encountered (unevaluated) side-effects.
21// These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1),
22// where it is possible to determine the evaluated result regardless.
23//
24// * A set of notes indicating why the evaluation was not a constant expression
25// (under the C++11 / C++1y rules only, at the moment), or, if folding failed
26// too, why the expression could not be folded.
27//
28// If we are checking for a potential constant expression, failure to constant
29// fold a potential constant sub-expression will be indicated by a 'false'
30// return value (the expression could not be folded) and no diagnostic (the
31// expression is not necessarily non-constant).
32//
33//===----------------------------------------------------------------------===//
34
35#include "Interp/Context.h"
36#include "Interp/Frame.h"
37#include "Interp/State.h"
38#include "clang/AST/APValue.h"
39#include "clang/AST/ASTContext.h"
40#include "clang/AST/ASTDiagnostic.h"
41#include "clang/AST/ASTLambda.h"
42#include "clang/AST/Attr.h"
43#include "clang/AST/CXXInheritance.h"
44#include "clang/AST/CharUnits.h"
45#include "clang/AST/CurrentSourceLocExprScope.h"
46#include "clang/AST/Expr.h"
47#include "clang/AST/OSLog.h"
48#include "clang/AST/OptionalDiagnostic.h"
49#include "clang/AST/RecordLayout.h"
50#include "clang/AST/StmtVisitor.h"
51#include "clang/AST/TypeLoc.h"
52#include "clang/Basic/Builtins.h"
53#include "clang/Basic/TargetInfo.h"
54#include "llvm/ADT/APFixedPoint.h"
55#include "llvm/ADT/Optional.h"
56#include "llvm/ADT/SmallBitVector.h"
57#include "llvm/Support/Debug.h"
58#include "llvm/Support/SaveAndRestore.h"
59#include "llvm/Support/raw_ostream.h"
60#include <cstring>
61#include <functional>
62
63#define DEBUG_TYPE"exprconstant" "exprconstant"
64
65using namespace clang;
66using llvm::APFixedPoint;
67using llvm::APInt;
68using llvm::APSInt;
69using llvm::APFloat;
70using llvm::FixedPointSemantics;
71using llvm::Optional;
72
73namespace {
74 struct LValue;
75 class CallStackFrame;
76 class EvalInfo;
77
78 using SourceLocExprScopeGuard =
79 CurrentSourceLocExprScope::SourceLocExprScopeGuard;
80
81 static QualType getType(APValue::LValueBase B) {
82 return B.getType();
83 }
84
85 /// Get an LValue path entry, which is known to not be an array index, as a
86 /// field declaration.
87 static const FieldDecl *getAsField(APValue::LValuePathEntry E) {
88 return dyn_cast_or_null<FieldDecl>(E.getAsBaseOrMember().getPointer());
89 }
90 /// Get an LValue path entry, which is known to not be an array index, as a
91 /// base class declaration.
92 static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) {
93 return dyn_cast_or_null<CXXRecordDecl>(E.getAsBaseOrMember().getPointer());
94 }
95 /// Determine whether this LValue path entry for a base class names a virtual
96 /// base class.
97 static bool isVirtualBaseClass(APValue::LValuePathEntry E) {
98 return E.getAsBaseOrMember().getInt();
99 }
100
101 /// Given an expression, determine the type used to store the result of
102 /// evaluating that expression.
103 static QualType getStorageType(const ASTContext &Ctx, const Expr *E) {
104 if (E->isPRValue())
105 return E->getType();
106 return Ctx.getLValueReferenceType(E->getType());
107 }
108
109 /// Given a CallExpr, try to get the alloc_size attribute. May return null.
110 static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
111 if (const FunctionDecl *DirectCallee = CE->getDirectCallee())
112 return DirectCallee->getAttr<AllocSizeAttr>();
113 if (const Decl *IndirectCallee = CE->getCalleeDecl())
114 return IndirectCallee->getAttr<AllocSizeAttr>();
115 return 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. In exotic cases, we might also see a
129 // top-level ExprWithCleanups. Ignore them either way.
130 if (const auto *FE = dyn_cast<FullExpr>(E))
131 E = FE->getSubExpr()->IgnoreParens();
132
133 if (const auto *Cast = dyn_cast<CastExpr>(E))
134 E = Cast->getSubExpr()->IgnoreParens();
135
136 if (const auto *CE = dyn_cast<CallExpr>(E))
137 return getAllocSizeAttr(CE) ? CE : nullptr;
138 return nullptr;
139 }
140
141 /// Determines whether or not the given Base contains a call to a function
142 /// with the alloc_size attribute.
143 static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
144 const auto *E = Base.dyn_cast<const Expr *>();
145 return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
146 }
147
148 /// Determines whether the given kind of constant expression is only ever
149 /// used for name mangling. If so, it's permitted to reference things that we
150 /// can't generate code for (in particular, dllimported functions).
151 static bool isForManglingOnly(ConstantExprKind Kind) {
152 switch (Kind) {
153 case ConstantExprKind::Normal:
154 case ConstantExprKind::ClassTemplateArgument:
155 case ConstantExprKind::ImmediateInvocation:
156 // Note that non-type template arguments of class type are emitted as
157 // template parameter objects.
158 return false;
159
160 case ConstantExprKind::NonClassTemplateArgument:
161 return true;
162 }
163 llvm_unreachable("unknown ConstantExprKind")__builtin_unreachable();
164 }
165
166 static bool isTemplateArgument(ConstantExprKind Kind) {
167 switch (Kind) {
168 case ConstantExprKind::Normal:
169 case ConstantExprKind::ImmediateInvocation:
170 return false;
171
172 case ConstantExprKind::ClassTemplateArgument:
173 case ConstantExprKind::NonClassTemplateArgument:
174 return true;
175 }
176 llvm_unreachable("unknown ConstantExprKind")__builtin_unreachable();
177 }
178
179 /// The bound to claim that an array of unknown bound has.
180 /// The value in MostDerivedArraySize is undefined in this case. So, set it
181 /// to an arbitrary value that's likely to loudly break things if it's used.
182 static const uint64_t AssumedSizeForUnsizedArray =
183 std::numeric_limits<uint64_t>::max() / 2;
184
185 /// Determines if an LValue with the given LValueBase will have an unsized
186 /// array in its designator.
187 /// Find the path length and type of the most-derived subobject in the given
188 /// path, and find the size of the containing array, if any.
189 static unsigned
190 findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
191 ArrayRef<APValue::LValuePathEntry> Path,
192 uint64_t &ArraySize, QualType &Type, bool &IsArray,
193 bool &FirstEntryIsUnsizedArray) {
194 // This only accepts LValueBases from APValues, and APValues don't support
195 // arrays that lack size info.
196 assert(!isBaseAnAllocSizeCall(Base) &&((void)0)
197 "Unsized arrays shouldn't appear here")((void)0);
198 unsigned MostDerivedLength = 0;
199 Type = getType(Base);
200
201 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
202 if (Type->isArrayType()) {
203 const ArrayType *AT = Ctx.getAsArrayType(Type);
204 Type = AT->getElementType();
205 MostDerivedLength = I + 1;
206 IsArray = true;
207
208 if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
209 ArraySize = CAT->getSize().getZExtValue();
210 } else {
211 assert(I == 0 && "unexpected unsized array designator")((void)0);
212 FirstEntryIsUnsizedArray = true;
213 ArraySize = AssumedSizeForUnsizedArray;
214 }
215 } else if (Type->isAnyComplexType()) {
216 const ComplexType *CT = Type->castAs<ComplexType>();
217 Type = CT->getElementType();
218 ArraySize = 2;
219 MostDerivedLength = I + 1;
220 IsArray = true;
221 } else if (const FieldDecl *FD = getAsField(Path[I])) {
222 Type = FD->getType();
223 ArraySize = 0;
224 MostDerivedLength = I + 1;
225 IsArray = false;
226 } else {
227 // Path[I] describes a base class.
228 ArraySize = 0;
229 IsArray = false;
230 }
231 }
232 return MostDerivedLength;
233 }
234
235 /// A path from a glvalue to a subobject of that glvalue.
236 struct SubobjectDesignator {
237 /// True if the subobject was named in a manner not supported by C++11. Such
238 /// lvalues can still be folded, but they are not core constant expressions
239 /// and we cannot perform lvalue-to-rvalue conversions on them.
240 unsigned Invalid : 1;
241
242 /// Is this a pointer one past the end of an object?
243 unsigned IsOnePastTheEnd : 1;
244
245 /// Indicator of whether the first entry is an unsized array.
246 unsigned FirstEntryIsAnUnsizedArray : 1;
247
248 /// Indicator of whether the most-derived object is an array element.
249 unsigned MostDerivedIsArrayElement : 1;
250
251 /// The length of the path to the most-derived object of which this is a
252 /// subobject.
253 unsigned MostDerivedPathLength : 28;
254
255 /// The size of the array of which the most-derived object is an element.
256 /// This will always be 0 if the most-derived object is not an array
257 /// element. 0 is not an indicator of whether or not the most-derived object
258 /// is an array, however, because 0-length arrays are allowed.
259 ///
260 /// If the current array is an unsized array, the value of this is
261 /// undefined.
262 uint64_t MostDerivedArraySize;
263
264 /// The type of the most derived object referred to by this address.
265 QualType MostDerivedType;
266
267 typedef APValue::LValuePathEntry PathEntry;
268
269 /// The entries on the path from the glvalue to the designated subobject.
270 SmallVector<PathEntry, 8> Entries;
271
272 SubobjectDesignator() : Invalid(true) {}
273
274 explicit SubobjectDesignator(QualType T)
275 : Invalid(false), IsOnePastTheEnd(false),
276 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
277 MostDerivedPathLength(0), MostDerivedArraySize(0),
278 MostDerivedType(T) {}
279
280 SubobjectDesignator(ASTContext &Ctx, const APValue &V)
281 : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
282 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
283 MostDerivedPathLength(0), MostDerivedArraySize(0) {
284 assert(V.isLValue() && "Non-LValue used to make an LValue designator?")((void)0);
285 if (!Invalid) {
286 IsOnePastTheEnd = V.isLValueOnePastTheEnd();
287 ArrayRef<PathEntry> VEntries = V.getLValuePath();
288 Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
289 if (V.getLValueBase()) {
290 bool IsArray = false;
291 bool FirstIsUnsizedArray = false;
292 MostDerivedPathLength = findMostDerivedSubobject(
293 Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
294 MostDerivedType, IsArray, FirstIsUnsizedArray);
295 MostDerivedIsArrayElement = IsArray;
296 FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
297 }
298 }
299 }
300
301 void truncate(ASTContext &Ctx, APValue::LValueBase Base,
302 unsigned NewLength) {
303 if (Invalid)
304 return;
305
306 assert(Base && "cannot truncate path for null pointer")((void)0);
307 assert(NewLength <= Entries.size() && "not a truncation")((void)0);
308
309 if (NewLength == Entries.size())
310 return;
311 Entries.resize(NewLength);
312
313 bool IsArray = false;
314 bool FirstIsUnsizedArray = false;
315 MostDerivedPathLength = findMostDerivedSubobject(
316 Ctx, Base, Entries, MostDerivedArraySize, MostDerivedType, IsArray,
317 FirstIsUnsizedArray);
318 MostDerivedIsArrayElement = IsArray;
319 FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
320 }
321
322 void setInvalid() {
323 Invalid = true;
324 Entries.clear();
325 }
326
327 /// Determine whether the most derived subobject is an array without a
328 /// known bound.
329 bool isMostDerivedAnUnsizedArray() const {
330 assert(!Invalid && "Calling this makes no sense on invalid designators")((void)0);
331 return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
332 }
333
334 /// Determine what the most derived array's size is. Results in an assertion
335 /// failure if the most derived array lacks a size.
336 uint64_t getMostDerivedArraySize() const {
337 assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size")((void)0);
338 return MostDerivedArraySize;
339 }
340
341 /// Determine whether this is a one-past-the-end pointer.
342 bool isOnePastTheEnd() const {
343 assert(!Invalid)((void)0);
344 if (IsOnePastTheEnd)
345 return true;
346 if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
347 Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
348 MostDerivedArraySize)
349 return true;
350 return false;
351 }
352
353 /// Get the range of valid index adjustments in the form
354 /// {maximum value that can be subtracted from this pointer,
355 /// maximum value that can be added to this pointer}
356 std::pair<uint64_t, uint64_t> validIndexAdjustments() {
357 if (Invalid || isMostDerivedAnUnsizedArray())
358 return {0, 0};
359
360 // [expr.add]p4: For the purposes of these operators, a pointer to a
361 // nonarray object behaves the same as a pointer to the first element of
362 // an array of length one with the type of the object as its element type.
363 bool IsArray = MostDerivedPathLength == Entries.size() &&
364 MostDerivedIsArrayElement;
365 uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
366 : (uint64_t)IsOnePastTheEnd;
367 uint64_t ArraySize =
368 IsArray ? getMostDerivedArraySize() : (uint64_t)1;
369 return {ArrayIndex, ArraySize - ArrayIndex};
370 }
371
372 /// Check that this refers to a valid subobject.
373 bool isValidSubobject() const {
374 if (Invalid)
375 return false;
376 return !isOnePastTheEnd();
377 }
378 /// Check that this refers to a valid subobject, and if not, produce a
379 /// relevant diagnostic and set the designator as invalid.
380 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
381
382 /// Get the type of the designated object.
383 QualType getType(ASTContext &Ctx) const {
384 assert(!Invalid && "invalid designator has no subobject type")((void)0);
385 return MostDerivedPathLength == Entries.size()
386 ? MostDerivedType
387 : Ctx.getRecordType(getAsBaseClass(Entries.back()));
388 }
389
390 /// Update this designator to refer to the first element within this array.
391 void addArrayUnchecked(const ConstantArrayType *CAT) {
392 Entries.push_back(PathEntry::ArrayIndex(0));
393
394 // This is a most-derived object.
395 MostDerivedType = CAT->getElementType();
396 MostDerivedIsArrayElement = true;
397 MostDerivedArraySize = CAT->getSize().getZExtValue();
398 MostDerivedPathLength = Entries.size();
399 }
400 /// Update this designator to refer to the first element within the array of
401 /// elements of type T. This is an array of unknown size.
402 void addUnsizedArrayUnchecked(QualType ElemTy) {
403 Entries.push_back(PathEntry::ArrayIndex(0));
404
405 MostDerivedType = ElemTy;
406 MostDerivedIsArrayElement = true;
407 // The value in MostDerivedArraySize is undefined in this case. So, set it
408 // to an arbitrary value that's likely to loudly break things if it's
409 // used.
410 MostDerivedArraySize = AssumedSizeForUnsizedArray;
411 MostDerivedPathLength = Entries.size();
412 }
413 /// Update this designator to refer to the given base or member of this
414 /// object.
415 void addDeclUnchecked(const Decl *D, bool Virtual = false) {
416 Entries.push_back(APValue::BaseOrMemberType(D, Virtual));
417
418 // If this isn't a base class, it's a new most-derived object.
419 if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
420 MostDerivedType = FD->getType();
421 MostDerivedIsArrayElement = false;
422 MostDerivedArraySize = 0;
423 MostDerivedPathLength = Entries.size();
424 }
425 }
426 /// Update this designator to refer to the given complex component.
427 void addComplexUnchecked(QualType EltTy, bool Imag) {
428 Entries.push_back(PathEntry::ArrayIndex(Imag));
429
430 // This is technically a most-derived object, though in practice this
431 // is unlikely to matter.
432 MostDerivedType = EltTy;
433 MostDerivedIsArrayElement = true;
434 MostDerivedArraySize = 2;
435 MostDerivedPathLength = Entries.size();
436 }
437 void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
438 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
439 const APSInt &N);
440 /// Add N to the address of this subobject.
441 void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
442 if (Invalid || !N) return;
443 uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
444 if (isMostDerivedAnUnsizedArray()) {
445 diagnoseUnsizedArrayPointerArithmetic(Info, E);
446 // Can't verify -- trust that the user is doing the right thing (or if
447 // not, trust that the caller will catch the bad behavior).
448 // FIXME: Should we reject if this overflows, at least?
449 Entries.back() = PathEntry::ArrayIndex(
450 Entries.back().getAsArrayIndex() + TruncatedN);
451 return;
452 }
453
454 // [expr.add]p4: For the purposes of these operators, a pointer to a
455 // nonarray object behaves the same as a pointer to the first element of
456 // an array of length one with the type of the object as its element type.
457 bool IsArray = MostDerivedPathLength == Entries.size() &&
458 MostDerivedIsArrayElement;
459 uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
460 : (uint64_t)IsOnePastTheEnd;
461 uint64_t ArraySize =
462 IsArray ? getMostDerivedArraySize() : (uint64_t)1;
463
464 if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
465 // Calculate the actual index in a wide enough type, so we can include
466 // it in the note.
467 N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
468 (llvm::APInt&)N += ArrayIndex;
469 assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index")((void)0);
470 diagnosePointerArithmetic(Info, E, N);
471 setInvalid();
472 return;
473 }
474
475 ArrayIndex += TruncatedN;
476 assert(ArrayIndex <= ArraySize &&((void)0)
477 "bounds check succeeded for out-of-bounds index")((void)0);
478
479 if (IsArray)
480 Entries.back() = PathEntry::ArrayIndex(ArrayIndex);
481 else
482 IsOnePastTheEnd = (ArrayIndex != 0);
483 }
484 };
485
486 /// A scope at the end of which an object can need to be destroyed.
487 enum class ScopeKind {
488 Block,
489 FullExpression,
490 Call
491 };
492
493 /// A reference to a particular call and its arguments.
494 struct CallRef {
495 CallRef() : OrigCallee(), CallIndex(0), Version() {}
496 CallRef(const FunctionDecl *Callee, unsigned CallIndex, unsigned Version)
497 : OrigCallee(Callee), CallIndex(CallIndex), Version(Version) {}
498
499 explicit operator bool() const { return OrigCallee; }
500
501 /// Get the parameter that the caller initialized, corresponding to the
502 /// given parameter in the callee.
503 const ParmVarDecl *getOrigParam(const ParmVarDecl *PVD) const {
504 return OrigCallee ? OrigCallee->getParamDecl(PVD->getFunctionScopeIndex())
505 : PVD;
506 }
507
508 /// The callee at the point where the arguments were evaluated. This might
509 /// be different from the actual callee (a different redeclaration, or a
510 /// virtual override), but this function's parameters are the ones that
511 /// appear in the parameter map.
512 const FunctionDecl *OrigCallee;
513 /// The call index of the frame that holds the argument values.
514 unsigned CallIndex;
515 /// The version of the parameters corresponding to this call.
516 unsigned Version;
517 };
518
519 /// A stack frame in the constexpr call stack.
520 class CallStackFrame : public interp::Frame {
521 public:
522 EvalInfo &Info;
523
524 /// Parent - The caller of this stack frame.
525 CallStackFrame *Caller;
526
527 /// Callee - The function which was called.
528 const FunctionDecl *Callee;
529
530 /// This - The binding for the this pointer in this call, if any.
531 const LValue *This;
532
533 /// Information on how to find the arguments to this call. Our arguments
534 /// are stored in our parent's CallStackFrame, using the ParmVarDecl* as a
535 /// key and this value as the version.
536 CallRef Arguments;
537
538 /// Source location information about the default argument or default
539 /// initializer expression we're evaluating, if any.
540 CurrentSourceLocExprScope CurSourceLocExprScope;
541
542 // Note that we intentionally use std::map here so that references to
543 // values are stable.
544 typedef std::pair<const void *, unsigned> MapKeyTy;
545 typedef std::map<MapKeyTy, APValue> MapTy;
546 /// Temporaries - Temporary lvalues materialized within this stack frame.
547 MapTy Temporaries;
548
549 /// CallLoc - The location of the call expression for this call.
550 SourceLocation CallLoc;
551
552 /// Index - The call index of this call.
553 unsigned Index;
554
555 /// The stack of integers for tracking version numbers for temporaries.
556 SmallVector<unsigned, 2> TempVersionStack = {1};
557 unsigned CurTempVersion = TempVersionStack.back();
558
559 unsigned getTempVersion() const { return TempVersionStack.back(); }
560
561 void pushTempVersion() {
562 TempVersionStack.push_back(++CurTempVersion);
563 }
564
565 void popTempVersion() {
566 TempVersionStack.pop_back();
567 }
568
569 CallRef createCall(const FunctionDecl *Callee) {
570 return {Callee, Index, ++CurTempVersion};
571 }
572
573 // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
574 // on the overall stack usage of deeply-recursing constexpr evaluations.
575 // (We should cache this map rather than recomputing it repeatedly.)
576 // But let's try this and see how it goes; we can look into caching the map
577 // as a later change.
578
579 /// LambdaCaptureFields - Mapping from captured variables/this to
580 /// corresponding data members in the closure class.
581 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
582 FieldDecl *LambdaThisCaptureField;
583
584 CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
585 const FunctionDecl *Callee, const LValue *This,
586 CallRef Arguments);
587 ~CallStackFrame();
588
589 // Return the temporary for Key whose version number is Version.
590 APValue *getTemporary(const void *Key, unsigned Version) {
591 MapKeyTy KV(Key, Version);
592 auto LB = Temporaries.lower_bound(KV);
593 if (LB != Temporaries.end() && LB->first == KV)
60
Assuming the condition is true
61
Taking true branch
594 return &LB->second;
62
Returning pointer, which participates in a condition later
595 // Pair (Key,Version) wasn't found in the map. Check that no elements
596 // in the map have 'Key' as their key.
597 assert((LB == Temporaries.end() || LB->first.first != Key) &&((void)0)
598 (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&((void)0)
599 "Element with key 'Key' found in map")((void)0);
600 return nullptr;
601 }
602
603 // Return the current temporary for Key in the map.
604 APValue *getCurrentTemporary(const void *Key) {
605 auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX(2147483647 *2U +1U)));
606 if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
607 return &std::prev(UB)->second;
608 return nullptr;
609 }
610
611 // Return the version number of the current temporary for Key.
612 unsigned getCurrentTemporaryVersion(const void *Key) const {
613 auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX(2147483647 *2U +1U)));
614 if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
615 return std::prev(UB)->first.second;
616 return 0;
617 }
618
619 /// Allocate storage for an object of type T in this stack frame.
620 /// Populates LV with a handle to the created object. Key identifies
621 /// the temporary within the stack frame, and must not be reused without
622 /// bumping the temporary version number.
623 template<typename KeyT>
624 APValue &createTemporary(const KeyT *Key, QualType T,
625 ScopeKind Scope, LValue &LV);
626
627 /// Allocate storage for a parameter of a function call made in this frame.
628 APValue &createParam(CallRef Args, const ParmVarDecl *PVD, LValue &LV);
629
630 void describe(llvm::raw_ostream &OS) override;
631
632 Frame *getCaller() const override { return Caller; }
633 SourceLocation getCallLocation() const override { return CallLoc; }
634 const FunctionDecl *getCallee() const override { return Callee; }
635
636 bool isStdFunction() const {
637 for (const DeclContext *DC = Callee; DC; DC = DC->getParent())
638 if (DC->isStdNamespace())
639 return true;
640 return false;
641 }
642
643 private:
644 APValue &createLocal(APValue::LValueBase Base, const void *Key, QualType T,
645 ScopeKind Scope);
646 };
647
648 /// Temporarily override 'this'.
649 class ThisOverrideRAII {
650 public:
651 ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
652 : Frame(Frame), OldThis(Frame.This) {
653 if (Enable)
654 Frame.This = NewThis;
655 }
656 ~ThisOverrideRAII() {
657 Frame.This = OldThis;
658 }
659 private:
660 CallStackFrame &Frame;
661 const LValue *OldThis;
662 };
663}
664
665static bool HandleDestruction(EvalInfo &Info, const Expr *E,
666 const LValue &This, QualType ThisType);
667static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc,
668 APValue::LValueBase LVBase, APValue &Value,
669 QualType T);
670
671namespace {
672 /// A cleanup, and a flag indicating whether it is lifetime-extended.
673 class Cleanup {
674 llvm::PointerIntPair<APValue*, 2, ScopeKind> Value;
675 APValue::LValueBase Base;
676 QualType T;
677
678 public:
679 Cleanup(APValue *Val, APValue::LValueBase Base, QualType T,
680 ScopeKind Scope)
681 : Value(Val, Scope), Base(Base), T(T) {}
682
683 /// Determine whether this cleanup should be performed at the end of the
684 /// given kind of scope.
685 bool isDestroyedAtEndOf(ScopeKind K) const {
686 return (int)Value.getInt() >= (int)K;
687 }
688 bool endLifetime(EvalInfo &Info, bool RunDestructors) {
689 if (RunDestructors) {
690 SourceLocation Loc;
691 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
692 Loc = VD->getLocation();
693 else if (const Expr *E = Base.dyn_cast<const Expr*>())
694 Loc = E->getExprLoc();
695 return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T);
696 }
697 *Value.getPointer() = APValue();
698 return true;
699 }
700
701 bool hasSideEffect() {
702 return T.isDestructedType();
703 }
704 };
705
706 /// A reference to an object whose construction we are currently evaluating.
707 struct ObjectUnderConstruction {
708 APValue::LValueBase Base;
709 ArrayRef<APValue::LValuePathEntry> Path;
710 friend bool operator==(const ObjectUnderConstruction &LHS,
711 const ObjectUnderConstruction &RHS) {
712 return LHS.Base == RHS.Base && LHS.Path == RHS.Path;
713 }
714 friend llvm::hash_code hash_value(const ObjectUnderConstruction &Obj) {
715 return llvm::hash_combine(Obj.Base, Obj.Path);
716 }
717 };
718 enum class ConstructionPhase {
719 None,
720 Bases,
721 AfterBases,
722 AfterFields,
723 Destroying,
724 DestroyingBases
725 };
726}
727
728namespace llvm {
729template<> struct DenseMapInfo<ObjectUnderConstruction> {
730 using Base = DenseMapInfo<APValue::LValueBase>;
731 static ObjectUnderConstruction getEmptyKey() {
732 return {Base::getEmptyKey(), {}}; }
733 static ObjectUnderConstruction getTombstoneKey() {
734 return {Base::getTombstoneKey(), {}};
735 }
736 static unsigned getHashValue(const ObjectUnderConstruction &Object) {
737 return hash_value(Object);
738 }
739 static bool isEqual(const ObjectUnderConstruction &LHS,
740 const ObjectUnderConstruction &RHS) {
741 return LHS == RHS;
742 }
743};
744}
745
746namespace {
747 /// A dynamically-allocated heap object.
748 struct DynAlloc {
749 /// The value of this heap-allocated object.
750 APValue Value;
751 /// The allocating expression; used for diagnostics. Either a CXXNewExpr
752 /// or a CallExpr (the latter is for direct calls to operator new inside
753 /// std::allocator<T>::allocate).
754 const Expr *AllocExpr = nullptr;
755
756 enum Kind {
757 New,
758 ArrayNew,
759 StdAllocator
760 };
761
762 /// Get the kind of the allocation. This must match between allocation
763 /// and deallocation.
764 Kind getKind() const {
765 if (auto *NE = dyn_cast<CXXNewExpr>(AllocExpr))
766 return NE->isArray() ? ArrayNew : New;
767 assert(isa<CallExpr>(AllocExpr))((void)0);
768 return StdAllocator;
769 }
770 };
771
772 struct DynAllocOrder {
773 bool operator()(DynamicAllocLValue L, DynamicAllocLValue R) const {
774 return L.getIndex() < R.getIndex();
775 }
776 };
777
778 /// EvalInfo - This is a private struct used by the evaluator to capture
779 /// information about a subexpression as it is folded. It retains information
780 /// about the AST context, but also maintains information about the folded
781 /// expression.
782 ///
783 /// If an expression could be evaluated, it is still possible it is not a C
784 /// "integer constant expression" or constant expression. If not, this struct
785 /// captures information about how and why not.
786 ///
787 /// One bit of information passed *into* the request for constant folding
788 /// indicates whether the subexpression is "evaluated" or not according to C
789 /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can
790 /// evaluate the expression regardless of what the RHS is, but C only allows
791 /// certain things in certain situations.
792 class EvalInfo : public interp::State {
793 public:
794 ASTContext &Ctx;
795
796 /// EvalStatus - Contains information about the evaluation.
797 Expr::EvalStatus &EvalStatus;
798
799 /// CurrentCall - The top of the constexpr call stack.
800 CallStackFrame *CurrentCall;
801
802 /// CallStackDepth - The number of calls in the call stack right now.
803 unsigned CallStackDepth;
804
805 /// NextCallIndex - The next call index to assign.
806 unsigned NextCallIndex;
807
808 /// StepsLeft - The remaining number of evaluation steps we're permitted
809 /// to perform. This is essentially a limit for the number of statements
810 /// we will evaluate.
811 unsigned StepsLeft;
812
813 /// Enable the experimental new constant interpreter. If an expression is
814 /// not supported by the interpreter, an error is triggered.
815 bool EnableNewConstInterp;
816
817 /// BottomFrame - The frame in which evaluation started. This must be
818 /// initialized after CurrentCall and CallStackDepth.
819 CallStackFrame BottomFrame;
820
821 /// A stack of values whose lifetimes end at the end of some surrounding
822 /// evaluation frame.
823 llvm::SmallVector<Cleanup, 16> CleanupStack;
824
825 /// EvaluatingDecl - This is the declaration whose initializer is being
826 /// evaluated, if any.
827 APValue::LValueBase EvaluatingDecl;
828
829 enum class EvaluatingDeclKind {
830 None,
831 /// We're evaluating the construction of EvaluatingDecl.
832 Ctor,
833 /// We're evaluating the destruction of EvaluatingDecl.
834 Dtor,
835 };
836 EvaluatingDeclKind IsEvaluatingDecl = EvaluatingDeclKind::None;
837
838 /// EvaluatingDeclValue - This is the value being constructed for the
839 /// declaration whose initializer is being evaluated, if any.
840 APValue *EvaluatingDeclValue;
841
842 /// Set of objects that are currently being constructed.
843 llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase>
844 ObjectsUnderConstruction;
845
846 /// Current heap allocations, along with the location where each was
847 /// allocated. We use std::map here because we need stable addresses
848 /// for the stored APValues.
849 std::map<DynamicAllocLValue, DynAlloc, DynAllocOrder> HeapAllocs;
850
851 /// The number of heap allocations performed so far in this evaluation.
852 unsigned NumHeapAllocs = 0;
853
854 struct EvaluatingConstructorRAII {
855 EvalInfo &EI;
856 ObjectUnderConstruction Object;
857 bool DidInsert;
858 EvaluatingConstructorRAII(EvalInfo &EI, ObjectUnderConstruction Object,
859 bool HasBases)
860 : EI(EI), Object(Object) {
861 DidInsert =
862 EI.ObjectsUnderConstruction
863 .insert({Object, HasBases ? ConstructionPhase::Bases
864 : ConstructionPhase::AfterBases})
865 .second;
866 }
867 void finishedConstructingBases() {
868 EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases;
869 }
870 void finishedConstructingFields() {
871 EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterFields;
872 }
873 ~EvaluatingConstructorRAII() {
874 if (DidInsert) EI.ObjectsUnderConstruction.erase(Object);
875 }
876 };
877
878 struct EvaluatingDestructorRAII {
879 EvalInfo &EI;
880 ObjectUnderConstruction Object;
881 bool DidInsert;
882 EvaluatingDestructorRAII(EvalInfo &EI, ObjectUnderConstruction Object)
883 : EI(EI), Object(Object) {
884 DidInsert = EI.ObjectsUnderConstruction
885 .insert({Object, ConstructionPhase::Destroying})
886 .second;
887 }
888 void startedDestroyingBases() {
889 EI.ObjectsUnderConstruction[Object] =
890 ConstructionPhase::DestroyingBases;
891 }
892 ~EvaluatingDestructorRAII() {
893 if (DidInsert)
894 EI.ObjectsUnderConstruction.erase(Object);
895 }
896 };
897
898 ConstructionPhase
899 isEvaluatingCtorDtor(APValue::LValueBase Base,
900 ArrayRef<APValue::LValuePathEntry> Path) {
901 return ObjectsUnderConstruction.lookup({Base, Path});
902 }
903
904 /// If we're currently speculatively evaluating, the outermost call stack
905 /// depth at which we can mutate state, otherwise 0.
906 unsigned SpeculativeEvaluationDepth = 0;
907
908 /// The current array initialization index, if we're performing array
909 /// initialization.
910 uint64_t ArrayInitIndex = -1;
911
912 /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
913 /// notes attached to it will also be stored, otherwise they will not be.
914 bool HasActiveDiagnostic;
915
916 /// Have we emitted a diagnostic explaining why we couldn't constant
917 /// fold (not just why it's not strictly a constant expression)?
918 bool HasFoldFailureDiagnostic;
919
920 /// Whether or not we're in a context where the front end requires a
921 /// constant value.
922 bool InConstantContext;
923
924 /// Whether we're checking that an expression is a potential constant
925 /// expression. If so, do not fail on constructs that could become constant
926 /// later on (such as a use of an undefined global).
927 bool CheckingPotentialConstantExpression = false;
928
929 /// Whether we're checking for an expression that has undefined behavior.
930 /// If so, we will produce warnings if we encounter an operation that is
931 /// always undefined.
932 ///
933 /// Note that we still need to evaluate the expression normally when this
934 /// is set; this is used when evaluating ICEs in C.
935 bool CheckingForUndefinedBehavior = false;
936
937 enum EvaluationMode {
938 /// Evaluate as a constant expression. Stop if we find that the expression
939 /// is not a constant expression.
940 EM_ConstantExpression,
941
942 /// Evaluate as a constant expression. Stop if we find that the expression
943 /// is not a constant expression. Some expressions can be retried in the
944 /// optimizer if we don't constant fold them here, but in an unevaluated
945 /// context we try to fold them immediately since the optimizer never
946 /// gets a chance to look at it.
947 EM_ConstantExpressionUnevaluated,
948
949 /// Fold the expression to a constant. Stop if we hit a side-effect that
950 /// we can't model.
951 EM_ConstantFold,
952
953 /// Evaluate in any way we know how. Don't worry about side-effects that
954 /// can't be modeled.
955 EM_IgnoreSideEffects,
956 } EvalMode;
957
958 /// Are we checking whether the expression is a potential constant
959 /// expression?
960 bool checkingPotentialConstantExpression() const override {
961 return CheckingPotentialConstantExpression;
19
Returning the value 1, which participates in a condition later
962 }
963
964 /// Are we checking an expression for overflow?
965 // FIXME: We should check for any kind of undefined or suspicious behavior
966 // in such constructs, not just overflow.
967 bool checkingForUndefinedBehavior() const override {
968 return CheckingForUndefinedBehavior;
969 }
970
971 EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
972 : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
973 CallStackDepth(0), NextCallIndex(1),
974 StepsLeft(C.getLangOpts().ConstexprStepLimit),
975 EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
976 BottomFrame(*this, SourceLocation(), nullptr, nullptr, CallRef()),
4
Calling constructor for 'CallStackFrame'
5
Returning from constructor for 'CallStackFrame'
977 EvaluatingDecl((const ValueDecl *)nullptr),
978 EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
979 HasFoldFailureDiagnostic(false), InConstantContext(false),
980 EvalMode(Mode) {}
981
982 ~EvalInfo() {
983 discardCleanups();
984 }
985
986 void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value,
987 EvaluatingDeclKind EDK = EvaluatingDeclKind::Ctor) {
988 EvaluatingDecl = Base;
989 IsEvaluatingDecl = EDK;
990 EvaluatingDeclValue = &Value;
991 }
992
993 bool CheckCallLimit(SourceLocation Loc) {
994 // Don't perform any constexpr calls (other than the call we're checking)
995 // when checking a potential constant expression.
996 if (checkingPotentialConstantExpression() && CallStackDepth > 1)
18
Calling 'EvalInfo::checkingPotentialConstantExpression'
20
Returning from 'EvalInfo::checkingPotentialConstantExpression'
21
Assuming field 'CallStackDepth' is <= 1
22
Taking false branch
997 return false;
998 if (NextCallIndex == 0) {
23
Assuming field 'NextCallIndex' is not equal to 0
24
Taking false branch
999 // NextCallIndex has wrapped around.
1000 FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
1001 return false;
1002 }
1003 if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
25
Assuming field 'CallStackDepth' is <= field 'ConstexprCallDepth'
26
Taking true branch
1004 return true;
27
Returning the value 1, which participates in a condition later
1005 FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
1006 << getLangOpts().ConstexprCallDepth;
1007 return false;
1008 }
1009
1010 std::pair<CallStackFrame *, unsigned>
1011 getCallFrameAndDepth(unsigned CallIndex) {
1012 assert(CallIndex && "no call index in getCallFrameAndDepth")((void)0);
1013 // We will eventually hit BottomFrame, which has Index 1, so Frame can't
1014 // be null in this loop.
1015 unsigned Depth = CallStackDepth;
1016 CallStackFrame *Frame = CurrentCall;
1017 while (Frame->Index > CallIndex) {
1018 Frame = Frame->Caller;
1019 --Depth;
1020 }
1021 if (Frame->Index == CallIndex)
1022 return {Frame, Depth};
1023 return {nullptr, 0};
1024 }
1025
1026 bool nextStep(const Stmt *S) {
1027 if (!StepsLeft) {
1028 FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded);
1029 return false;
1030 }
1031 --StepsLeft;
1032 return true;
1033 }
1034
1035 APValue *createHeapAlloc(const Expr *E, QualType T, LValue &LV);
1036
1037 Optional<DynAlloc*> lookupDynamicAlloc(DynamicAllocLValue DA) {
1038 Optional<DynAlloc*> Result;
1039 auto It = HeapAllocs.find(DA);
1040 if (It != HeapAllocs.end())
1041 Result = &It->second;
1042 return Result;
1043 }
1044
1045 /// Get the allocated storage for the given parameter of the given call.
1046 APValue *getParamSlot(CallRef Call, const ParmVarDecl *PVD) {
1047 CallStackFrame *Frame = getCallFrameAndDepth(Call.CallIndex).first;
1048 return Frame
57.1
'Frame' is non-null
57.1
'Frame' is non-null
57.1
'Frame' is non-null
57.1
'Frame' is non-null
57.1
'Frame' is non-null
57.1
'Frame' is non-null
? Frame->getTemporary(Call.getOrigParam(PVD), Call.Version)
58
'?' condition is true
59
Calling 'CallStackFrame::getTemporary'
63
Returning from 'CallStackFrame::getTemporary'
64
Returning pointer, which participates in a condition later
1049 : nullptr;
1050 }
1051
1052 /// Information about a stack frame for std::allocator<T>::[de]allocate.
1053 struct StdAllocatorCaller {
1054 unsigned FrameIndex;
1055 QualType ElemType;
1056 explicit operator bool() const { return FrameIndex != 0; };
1057 };
1058
1059 StdAllocatorCaller getStdAllocatorCaller(StringRef FnName) const {
1060 for (const CallStackFrame *Call = CurrentCall; Call != &BottomFrame;
1061 Call = Call->Caller) {
1062 const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Call->Callee);
1063 if (!MD)
1064 continue;
1065 const IdentifierInfo *FnII = MD->getIdentifier();
1066 if (!FnII || !FnII->isStr(FnName))
1067 continue;
1068
1069 const auto *CTSD =
1070 dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent());
1071 if (!CTSD)
1072 continue;
1073
1074 const IdentifierInfo *ClassII = CTSD->getIdentifier();
1075 const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
1076 if (CTSD->isInStdNamespace() && ClassII &&
1077 ClassII->isStr("allocator") && TAL.size() >= 1 &&
1078 TAL[0].getKind() == TemplateArgument::Type)
1079 return {Call->Index, TAL[0].getAsType()};
1080 }
1081
1082 return {};
1083 }
1084
1085 void performLifetimeExtension() {
1086 // Disable the cleanups for lifetime-extended temporaries.
1087 CleanupStack.erase(std::remove_if(CleanupStack.begin(),
1088 CleanupStack.end(),
1089 [](Cleanup &C) {
1090 return !C.isDestroyedAtEndOf(
1091 ScopeKind::FullExpression);
1092 }),
1093 CleanupStack.end());
1094 }
1095
1096 /// Throw away any remaining cleanups at the end of evaluation. If any
1097 /// cleanups would have had a side-effect, note that as an unmodeled
1098 /// side-effect and return false. Otherwise, return true.
1099 bool discardCleanups() {
1100 for (Cleanup &C : CleanupStack) {
1101 if (C.hasSideEffect() && !noteSideEffect()) {
1102 CleanupStack.clear();
1103 return false;
1104 }
1105 }
1106 CleanupStack.clear();
1107 return true;
1108 }
1109
1110 private:
1111 interp::Frame *getCurrentFrame() override { return CurrentCall; }
1112 const interp::Frame *getBottomFrame() const override { return &BottomFrame; }
1113
1114 bool hasActiveDiagnostic() override { return HasActiveDiagnostic; }
1115 void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; }
1116
1117 void setFoldFailureDiagnostic(bool Flag) override {
1118 HasFoldFailureDiagnostic = Flag;
1119 }
1120
1121 Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
1122
1123 ASTContext &getCtx() const override { return Ctx; }
1124
1125 // If we have a prior diagnostic, it will be noting that the expression
1126 // isn't a constant expression. This diagnostic is more important,
1127 // unless we require this evaluation to produce a constant expression.
1128 //
1129 // FIXME: We might want to show both diagnostics to the user in
1130 // EM_ConstantFold mode.
1131 bool hasPriorDiagnostic() override {
1132 if (!EvalStatus.Diag->empty()) {
1133 switch (EvalMode) {
1134 case EM_ConstantFold:
1135 case EM_IgnoreSideEffects:
1136 if (!HasFoldFailureDiagnostic)
1137 break;
1138 // We've already failed to fold something. Keep that diagnostic.
1139 LLVM_FALLTHROUGH[[gnu::fallthrough]];
1140 case EM_ConstantExpression:
1141 case EM_ConstantExpressionUnevaluated:
1142 setActiveDiagnostic(false);
1143 return true;
1144 }
1145 }
1146 return false;
1147 }
1148
1149 unsigned getCallStackDepth() override { return CallStackDepth; }
1150
1151 public:
1152 /// Should we continue evaluation after encountering a side-effect that we
1153 /// couldn't model?
1154 bool keepEvaluatingAfterSideEffect() {
1155 switch (EvalMode) {
1156 case EM_IgnoreSideEffects:
1157 return true;
1158
1159 case EM_ConstantExpression:
1160 case EM_ConstantExpressionUnevaluated:
1161 case EM_ConstantFold:
1162 // By default, assume any side effect might be valid in some other
1163 // evaluation of this expression from a different context.
1164 return checkingPotentialConstantExpression() ||
1165 checkingForUndefinedBehavior();
1166 }
1167 llvm_unreachable("Missed EvalMode case")__builtin_unreachable();
1168 }
1169
1170 /// Note that we have had a side-effect, and determine whether we should
1171 /// keep evaluating.
1172 bool noteSideEffect() {
1173 EvalStatus.HasSideEffects = true;
1174 return keepEvaluatingAfterSideEffect();
1175 }
1176
1177 /// Should we continue evaluation after encountering undefined behavior?
1178 bool keepEvaluatingAfterUndefinedBehavior() {
1179 switch (EvalMode) {
1180 case EM_IgnoreSideEffects:
1181 case EM_ConstantFold:
1182 return true;
1183
1184 case EM_ConstantExpression:
1185 case EM_ConstantExpressionUnevaluated:
1186 return checkingForUndefinedBehavior();
1187 }
1188 llvm_unreachable("Missed EvalMode case")__builtin_unreachable();
1189 }
1190
1191 /// Note that we hit something that was technically undefined behavior, but
1192 /// that we can evaluate past it (such as signed overflow or floating-point
1193 /// division by zero.)
1194 bool noteUndefinedBehavior() override {
1195 EvalStatus.HasUndefinedBehavior = true;
1196 return keepEvaluatingAfterUndefinedBehavior();
1197 }
1198
1199 /// Should we continue evaluation as much as possible after encountering a
1200 /// construct which can't be reduced to a value?
1201 bool keepEvaluatingAfterFailure() const override {
1202 if (!StepsLeft)
1203 return false;
1204
1205 switch (EvalMode) {
1206 case EM_ConstantExpression:
1207 case EM_ConstantExpressionUnevaluated:
1208 case EM_ConstantFold:
1209 case EM_IgnoreSideEffects:
1210 return checkingPotentialConstantExpression() ||
1211 checkingForUndefinedBehavior();
1212 }
1213 llvm_unreachable("Missed EvalMode case")__builtin_unreachable();
1214 }
1215
1216 /// Notes that we failed to evaluate an expression that other expressions
1217 /// directly depend on, and determine if we should keep evaluating. This
1218 /// should only be called if we actually intend to keep evaluating.
1219 ///
1220 /// Call noteSideEffect() instead if we may be able to ignore the value that
1221 /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
1222 ///
1223 /// (Foo(), 1) // use noteSideEffect
1224 /// (Foo() || true) // use noteSideEffect
1225 /// Foo() + 1 // use noteFailure
1226 LLVM_NODISCARD[[clang::warn_unused_result]] bool noteFailure() {
1227 // Failure when evaluating some expression often means there is some
1228 // subexpression whose evaluation was skipped. Therefore, (because we
1229 // don't track whether we skipped an expression when unwinding after an
1230 // evaluation failure) every evaluation failure that bubbles up from a
1231 // subexpression implies that a side-effect has potentially happened. We
1232 // skip setting the HasSideEffects flag to true until we decide to
1233 // continue evaluating after that point, which happens here.
1234 bool KeepGoing = keepEvaluatingAfterFailure();
1235 EvalStatus.HasSideEffects |= KeepGoing;
1236 return KeepGoing;
1237 }
1238
1239 class ArrayInitLoopIndex {
1240 EvalInfo &Info;
1241 uint64_t OuterIndex;
1242
1243 public:
1244 ArrayInitLoopIndex(EvalInfo &Info)
1245 : Info(Info), OuterIndex(Info.ArrayInitIndex) {
1246 Info.ArrayInitIndex = 0;
1247 }
1248 ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
1249
1250 operator uint64_t&() { return Info.ArrayInitIndex; }
1251 };
1252 };
1253
1254 /// Object used to treat all foldable expressions as constant expressions.
1255 struct FoldConstant {
1256 EvalInfo &Info;
1257 bool Enabled;
1258 bool HadNoPriorDiags;
1259 EvalInfo::EvaluationMode OldMode;
1260
1261 explicit FoldConstant(EvalInfo &Info, bool Enabled)
1262 : Info(Info),
1263 Enabled(Enabled),
1264 HadNoPriorDiags(Info.EvalStatus.Diag &&
1265 Info.EvalStatus.Diag->empty() &&
1266 !Info.EvalStatus.HasSideEffects),
1267 OldMode(Info.EvalMode) {
1268 if (Enabled)
1269 Info.EvalMode = EvalInfo::EM_ConstantFold;
1270 }
1271 void keepDiagnostics() { Enabled = false; }
1272 ~FoldConstant() {
1273 if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
1274 !Info.EvalStatus.HasSideEffects)
1275 Info.EvalStatus.Diag->clear();
1276 Info.EvalMode = OldMode;
1277 }
1278 };
1279
1280 /// RAII object used to set the current evaluation mode to ignore
1281 /// side-effects.
1282 struct IgnoreSideEffectsRAII {
1283 EvalInfo &Info;
1284 EvalInfo::EvaluationMode OldMode;
1285 explicit IgnoreSideEffectsRAII(EvalInfo &Info)
1286 : Info(Info), OldMode(Info.EvalMode) {
1287 Info.EvalMode = EvalInfo::EM_IgnoreSideEffects;
1288 }
1289
1290 ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; }
1291 };
1292
1293 /// RAII object used to optionally suppress diagnostics and side-effects from
1294 /// a speculative evaluation.
1295 class SpeculativeEvaluationRAII {
1296 EvalInfo *Info = nullptr;
1297 Expr::EvalStatus OldStatus;
1298 unsigned OldSpeculativeEvaluationDepth;
1299
1300 void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
1301 Info = Other.Info;
1302 OldStatus = Other.OldStatus;
1303 OldSpeculativeEvaluationDepth = Other.OldSpeculativeEvaluationDepth;
1304 Other.Info = nullptr;
1305 }
1306
1307 void maybeRestoreState() {
1308 if (!Info)
1309 return;
1310
1311 Info->EvalStatus = OldStatus;
1312 Info->SpeculativeEvaluationDepth = OldSpeculativeEvaluationDepth;
1313 }
1314
1315 public:
1316 SpeculativeEvaluationRAII() = default;
1317
1318 SpeculativeEvaluationRAII(
1319 EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
1320 : Info(&Info), OldStatus(Info.EvalStatus),
1321 OldSpeculativeEvaluationDepth(Info.SpeculativeEvaluationDepth) {
1322 Info.EvalStatus.Diag = NewDiag;
1323 Info.SpeculativeEvaluationDepth = Info.CallStackDepth + 1;
1324 }
1325
1326 SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
1327 SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1328 moveFromAndCancel(std::move(Other));
1329 }
1330
1331 SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1332 maybeRestoreState();
1333 moveFromAndCancel(std::move(Other));
1334 return *this;
1335 }
1336
1337 ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1338 };
1339
1340 /// RAII object wrapping a full-expression or block scope, and handling
1341 /// the ending of the lifetime of temporaries created within it.
1342 template<ScopeKind Kind>
1343 class ScopeRAII {
1344 EvalInfo &Info;
1345 unsigned OldStackSize;
1346 public:
1347 ScopeRAII(EvalInfo &Info)
1348 : Info(Info), OldStackSize(Info.CleanupStack.size()) {
1349 // Push a new temporary version. This is needed to distinguish between
1350 // temporaries created in different iterations of a loop.
1351 Info.CurrentCall->pushTempVersion();
1352 }
1353 bool destroy(bool RunDestructors = true) {
1354 bool OK = cleanup(Info, RunDestructors, OldStackSize);
1355 OldStackSize = -1U;
1356 return OK;
1357 }
1358 ~ScopeRAII() {
1359 if (OldStackSize != -1U)
1360 destroy(false);
1361 // Body moved to a static method to encourage the compiler to inline away
1362 // instances of this class.
1363 Info.CurrentCall->popTempVersion();
1364 }
1365 private:
1366 static bool cleanup(EvalInfo &Info, bool RunDestructors,
1367 unsigned OldStackSize) {
1368 assert(OldStackSize <= Info.CleanupStack.size() &&((void)0)
1369 "running cleanups out of order?")((void)0);
1370
1371 // Run all cleanups for a block scope, and non-lifetime-extended cleanups
1372 // for a full-expression scope.
1373 bool Success = true;
1374 for (unsigned I = Info.CleanupStack.size(); I > OldStackSize; --I) {
1375 if (Info.CleanupStack[I - 1].isDestroyedAtEndOf(Kind)) {
1376 if (!Info.CleanupStack[I - 1].endLifetime(Info, RunDestructors)) {
1377 Success = false;
1378 break;
1379 }
1380 }
1381 }
1382
1383 // Compact any retained cleanups.
1384 auto NewEnd = Info.CleanupStack.begin() + OldStackSize;
1385 if (Kind != ScopeKind::Block)
1386 NewEnd =
1387 std::remove_if(NewEnd, Info.CleanupStack.end(), [](Cleanup &C) {
1388 return C.isDestroyedAtEndOf(Kind);
1389 });
1390 Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end());
1391 return Success;
1392 }
1393 };
1394 typedef ScopeRAII<ScopeKind::Block> BlockScopeRAII;
1395 typedef ScopeRAII<ScopeKind::FullExpression> FullExpressionRAII;
1396 typedef ScopeRAII<ScopeKind::Call> CallScopeRAII;
1397}
1398
1399bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
1400 CheckSubobjectKind CSK) {
1401 if (Invalid)
1402 return false;
1403 if (isOnePastTheEnd()) {
1404 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1405 << CSK;
1406 setInvalid();
1407 return false;
1408 }
1409 // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there
1410 // must actually be at least one array element; even a VLA cannot have a
1411 // bound of zero. And if our index is nonzero, we already had a CCEDiag.
1412 return true;
1413}
1414
1415void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
1416 const Expr *E) {
1417 Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
1418 // Do not set the designator as invalid: we can represent this situation,
1419 // and correct handling of __builtin_object_size requires us to do so.
1420}
1421
1422void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1423 const Expr *E,
1424 const APSInt &N) {
1425 // If we're complaining, we must be able to statically determine the size of
1426 // the most derived array.
1427 if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1428 Info.CCEDiag(E, diag::note_constexpr_array_index)
1429 << N << /*array*/ 0
1430 << static_cast<unsigned>(getMostDerivedArraySize());
1431 else
1432 Info.CCEDiag(E, diag::note_constexpr_array_index)
1433 << N << /*non-array*/ 1;
1434 setInvalid();
1435}
1436
1437CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
1438 const FunctionDecl *Callee, const LValue *This,
1439 CallRef Call)
1440 : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1441 Arguments(Call), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1442 Info.CurrentCall = this;
1443 ++Info.CallStackDepth;
1444}
1445
1446CallStackFrame::~CallStackFrame() {
1447 assert(Info.CurrentCall == this && "calls retired out of order")((void)0);
1448 --Info.CallStackDepth;
1449 Info.CurrentCall = Caller;
1450}
1451
1452static bool isRead(AccessKinds AK) {
1453 return AK == AK_Read || AK == AK_ReadObjectRepresentation;
1454}
1455
1456static bool isModification(AccessKinds AK) {
1457 switch (AK) {
1458 case AK_Read:
1459 case AK_ReadObjectRepresentation:
1460 case AK_MemberCall:
1461 case AK_DynamicCast:
1462 case AK_TypeId:
1463 return false;
1464 case AK_Assign:
1465 case AK_Increment:
1466 case AK_Decrement:
1467 case AK_Construct:
1468 case AK_Destroy:
1469 return true;
1470 }
1471 llvm_unreachable("unknown access kind")__builtin_unreachable();
1472}
1473
1474static bool isAnyAccess(AccessKinds AK) {
1475 return isRead(AK) || isModification(AK);
1476}
1477
1478/// Is this an access per the C++ definition?
1479static bool isFormalAccess(AccessKinds AK) {
1480 return isAnyAccess(AK) && AK != AK_Construct && AK != AK_Destroy;
1481}
1482
1483/// Is this kind of axcess valid on an indeterminate object value?
1484static bool isValidIndeterminateAccess(AccessKinds AK) {
1485 switch (AK) {
1486 case AK_Read:
1487 case AK_Increment:
1488 case AK_Decrement:
1489 // These need the object's value.
1490 return false;
1491
1492 case AK_ReadObjectRepresentation:
1493 case AK_Assign:
1494 case AK_Construct:
1495 case AK_Destroy:
1496 // Construction and destruction don't need the value.
1497 return true;
1498
1499 case AK_MemberCall:
1500 case AK_DynamicCast:
1501 case AK_TypeId:
1502 // These aren't really meaningful on scalars.
1503 return true;
1504 }
1505 llvm_unreachable("unknown access kind")__builtin_unreachable();
1506}
1507
1508namespace {
1509 struct ComplexValue {
1510 private:
1511 bool IsInt;
1512
1513 public:
1514 APSInt IntReal, IntImag;
1515 APFloat FloatReal, FloatImag;
1516
1517 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1518
1519 void makeComplexFloat() { IsInt = false; }
1520 bool isComplexFloat() const { return !IsInt; }
1521 APFloat &getComplexFloatReal() { return FloatReal; }
1522 APFloat &getComplexFloatImag() { return FloatImag; }
1523
1524 void makeComplexInt() { IsInt = true; }
1525 bool isComplexInt() const { return IsInt; }
1526 APSInt &getComplexIntReal() { return IntReal; }
1527 APSInt &getComplexIntImag() { return IntImag; }
1528
1529 void moveInto(APValue &v) const {
1530 if (isComplexFloat())
1531 v = APValue(FloatReal, FloatImag);
1532 else
1533 v = APValue(IntReal, IntImag);
1534 }
1535 void setFrom(const APValue &v) {
1536 assert(v.isComplexFloat() || v.isComplexInt())((void)0);
1537 if (v.isComplexFloat()) {
1538 makeComplexFloat();
1539 FloatReal = v.getComplexFloatReal();
1540 FloatImag = v.getComplexFloatImag();
1541 } else {
1542 makeComplexInt();
1543 IntReal = v.getComplexIntReal();
1544 IntImag = v.getComplexIntImag();
1545 }
1546 }
1547 };
1548
1549 struct LValue {
1550 APValue::LValueBase Base;
1551 CharUnits Offset;
1552 SubobjectDesignator Designator;
1553 bool IsNullPtr : 1;
1554 bool InvalidBase : 1;
1555
1556 const APValue::LValueBase getLValueBase() const { return Base; }
1557 CharUnits &getLValueOffset() { return Offset; }
1558 const CharUnits &getLValueOffset() const { return Offset; }
1559 SubobjectDesignator &getLValueDesignator() { return Designator; }
1560 const SubobjectDesignator &getLValueDesignator() const { return Designator;}
1561 bool isNullPointer() const { return IsNullPtr;}
1562
1563 unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
1564 unsigned getLValueVersion() const { return Base.getVersion(); }
1565
1566 void moveInto(APValue &V) const {
1567 if (Designator.Invalid)
1568 V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
1569 else {
1570 assert(!InvalidBase && "APValues can't handle invalid LValue bases")((void)0);
1571 V = APValue(Base, Offset, Designator.Entries,
1572 Designator.IsOnePastTheEnd, IsNullPtr);
1573 }
1574 }
1575 void setFrom(ASTContext &Ctx, const APValue &V) {
1576 assert(V.isLValue() && "Setting LValue from a non-LValue?")((void)0);
1577 Base = V.getLValueBase();
1578 Offset = V.getLValueOffset();
1579 InvalidBase = false;
1580 Designator = SubobjectDesignator(Ctx, V);
1581 IsNullPtr = V.isNullPointer();
1582 }
1583
1584 void set(APValue::LValueBase B, bool BInvalid = false) {
1585#ifndef NDEBUG1
1586 // We only allow a few types of invalid bases. Enforce that here.
1587 if (BInvalid) {
1588 const auto *E = B.get<const Expr *>();
1589 assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&((void)0)
1590 "Unexpected type of invalid base")((void)0);
1591 }
1592#endif
1593
1594 Base = B;
1595 Offset = CharUnits::fromQuantity(0);
1596 InvalidBase = BInvalid;
1597 Designator = SubobjectDesignator(getType(B));
1598 IsNullPtr = false;
1599 }
1600
1601 void setNull(ASTContext &Ctx, QualType PointerTy) {
1602 Base = (const ValueDecl *)nullptr;
1603 Offset =
1604 CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy));
1605 InvalidBase = false;
1606 Designator = SubobjectDesignator(PointerTy->getPointeeType());
1607 IsNullPtr = true;
1608 }
1609
1610 void setInvalid(APValue::LValueBase B, unsigned I = 0) {
1611 set(B, true);
1612 }
1613
1614 std::string toString(ASTContext &Ctx, QualType T) const {
1615 APValue Printable;
1616 moveInto(Printable);
1617 return Printable.getAsString(Ctx, T);
1618 }
1619
1620 private:
1621 // Check that this LValue is not based on a null pointer. If it is, produce
1622 // a diagnostic and mark the designator as invalid.
1623 template <typename GenDiagType>
1624 bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) {
1625 if (Designator.Invalid)
1626 return false;
1627 if (IsNullPtr) {
1628 GenDiag();
1629 Designator.setInvalid();
1630 return false;
1631 }
1632 return true;
1633 }
1634
1635 public:
1636 bool checkNullPointer(EvalInfo &Info, const Expr *E,
1637 CheckSubobjectKind CSK) {
1638 return checkNullPointerDiagnosingWith([&Info, E, CSK] {
1639 Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK;
1640 });
1641 }
1642
1643 bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E,
1644 AccessKinds AK) {
1645 return checkNullPointerDiagnosingWith([&Info, E, AK] {
1646 Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
1647 });
1648 }
1649
1650 // Check this LValue refers to an object. If not, set the designator to be
1651 // invalid and emit a diagnostic.
1652 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
1653 return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1654 Designator.checkSubobject(Info, E, CSK);
1655 }
1656
1657 void addDecl(EvalInfo &Info, const Expr *E,
1658 const Decl *D, bool Virtual = false) {
1659 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1660 Designator.addDeclUnchecked(D, Virtual);
1661 }
1662 void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
1663 if (!Designator.Entries.empty()) {
1664 Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
1665 Designator.setInvalid();
1666 return;
1667 }
1668 if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
1669 assert(getType(Base)->isPointerType() || getType(Base)->isArrayType())((void)0);
1670 Designator.FirstEntryIsAnUnsizedArray = true;
1671 Designator.addUnsizedArrayUnchecked(ElemTy);
1672 }
1673 }
1674 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
1675 if (checkSubobject(Info, E, CSK_ArrayToPointer))
1676 Designator.addArrayUnchecked(CAT);
1677 }
1678 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
1679 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1680 Designator.addComplexUnchecked(EltTy, Imag);
1681 }
1682 void clearIsNullPointer() {
1683 IsNullPtr = false;
1684 }
1685 void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
1686 const APSInt &Index, CharUnits ElementSize) {
1687 // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
1688 // but we're not required to diagnose it and it's valid in C++.)
1689 if (!Index)
1690 return;
1691
1692 // Compute the new offset in the appropriate width, wrapping at 64 bits.
1693 // FIXME: When compiling for a 32-bit target, we should use 32-bit
1694 // offsets.
1695 uint64_t Offset64 = Offset.getQuantity();
1696 uint64_t ElemSize64 = ElementSize.getQuantity();
1697 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1698 Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1699
1700 if (checkNullPointer(Info, E, CSK_ArrayIndex))
1701 Designator.adjustIndex(Info, E, Index);
1702 clearIsNullPointer();
1703 }
1704 void adjustOffset(CharUnits N) {
1705 Offset += N;
1706 if (N.getQuantity())
1707 clearIsNullPointer();
1708 }
1709 };
1710
1711 struct MemberPtr {
1712 MemberPtr() {}
1713 explicit MemberPtr(const ValueDecl *Decl) :
1714 DeclAndIsDerivedMember(Decl, false), Path() {}
1715
1716 /// The member or (direct or indirect) field referred to by this member
1717 /// pointer, or 0 if this is a null member pointer.
1718 const ValueDecl *getDecl() const {
1719 return DeclAndIsDerivedMember.getPointer();
1720 }
1721 /// Is this actually a member of some type derived from the relevant class?
1722 bool isDerivedMember() const {
1723 return DeclAndIsDerivedMember.getInt();
1724 }
1725 /// Get the class which the declaration actually lives in.
1726 const CXXRecordDecl *getContainingRecord() const {
1727 return cast<CXXRecordDecl>(
1728 DeclAndIsDerivedMember.getPointer()->getDeclContext());
1729 }
1730
1731 void moveInto(APValue &V) const {
1732 V = APValue(getDecl(), isDerivedMember(), Path);
1733 }
1734 void setFrom(const APValue &V) {
1735 assert(V.isMemberPointer())((void)0);
1736 DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
1737 DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
1738 Path.clear();
1739 ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath();
1740 Path.insert(Path.end(), P.begin(), P.end());
1741 }
1742
1743 /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
1744 /// whether the member is a member of some class derived from the class type
1745 /// of the member pointer.
1746 llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1747 /// Path - The path of base/derived classes from the member declaration's
1748 /// class (exclusive) to the class type of the member pointer (inclusive).
1749 SmallVector<const CXXRecordDecl*, 4> Path;
1750
1751 /// Perform a cast towards the class of the Decl (either up or down the
1752 /// hierarchy).
1753 bool castBack(const CXXRecordDecl *Class) {
1754 assert(!Path.empty())((void)0);
1755 const CXXRecordDecl *Expected;
1756 if (Path.size() >= 2)
1757 Expected = Path[Path.size() - 2];
1758 else
1759 Expected = getContainingRecord();
1760 if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
1761 // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
1762 // if B does not contain the original member and is not a base or
1763 // derived class of the class containing the original member, the result
1764 // of the cast is undefined.
1765 // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
1766 // (D::*). We consider that to be a language defect.
1767 return false;
1768 }
1769 Path.pop_back();
1770 return true;
1771 }
1772 /// Perform a base-to-derived member pointer cast.
1773 bool castToDerived(const CXXRecordDecl *Derived) {
1774 if (!getDecl())
1775 return true;
1776 if (!isDerivedMember()) {
1777 Path.push_back(Derived);
1778 return true;
1779 }
1780 if (!castBack(Derived))
1781 return false;
1782 if (Path.empty())
1783 DeclAndIsDerivedMember.setInt(false);
1784 return true;
1785 }
1786 /// Perform a derived-to-base member pointer cast.
1787 bool castToBase(const CXXRecordDecl *Base) {
1788 if (!getDecl())
1789 return true;
1790 if (Path.empty())
1791 DeclAndIsDerivedMember.setInt(true);
1792 if (isDerivedMember()) {
1793 Path.push_back(Base);
1794 return true;
1795 }
1796 return castBack(Base);
1797 }
1798 };
1799
1800 /// Compare two member pointers, which are assumed to be of the same type.
1801 static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
1802 if (!LHS.getDecl() || !RHS.getDecl())
1803 return !LHS.getDecl() && !RHS.getDecl();
1804 if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1805 return false;
1806 return LHS.Path == RHS.Path;
1807 }
1808}
1809
1810static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1811static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1812 const LValue &This, const Expr *E,
1813 bool AllowNonLiteralTypes = false);
1814static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
1815 bool InvalidBaseOK = false);
1816static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
1817 bool InvalidBaseOK = false);
1818static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
1819 EvalInfo &Info);
1820static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1821static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1822static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
1823 EvalInfo &Info);
1824static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1825static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1826static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
1827 EvalInfo &Info);
1828static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
1829
1830/// Evaluate an integer or fixed point expression into an APResult.
1831static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
1832 EvalInfo &Info);
1833
1834/// Evaluate only a fixed point expression into an APResult.
1835static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
1836 EvalInfo &Info);
1837
1838//===----------------------------------------------------------------------===//
1839// Misc utilities
1840//===----------------------------------------------------------------------===//
1841
1842/// Negate an APSInt in place, converting it to a signed form if necessary, and
1843/// preserving its value (by extending by up to one bit as needed).
1844static void negateAsSigned(APSInt &Int) {
1845 if (Int.isUnsigned() || Int.isMinSignedValue()) {
1846 Int = Int.extend(Int.getBitWidth() + 1);
1847 Int.setIsSigned(true);
1848 }
1849 Int = -Int;
1850}
1851
1852template<typename KeyT>
1853APValue &CallStackFrame::createTemporary(const KeyT *Key, QualType T,
1854 ScopeKind Scope, LValue &LV) {
1855 unsigned Version = getTempVersion();
1856 APValue::LValueBase Base(Key, Index, Version);
1857 LV.set(Base);
1858 return createLocal(Base, Key, T, Scope);
1859}
1860
1861/// Allocate storage for a parameter of a function call made in this frame.
1862APValue &CallStackFrame::createParam(CallRef Args, const ParmVarDecl *PVD,
1863 LValue &LV) {
1864 assert(Args.CallIndex == Index && "creating parameter in wrong frame")((void)0);
1865 APValue::LValueBase Base(PVD, Index, Args.Version);
1866 LV.set(Base);
1867 // We always destroy parameters at the end of the call, even if we'd allow
1868 // them to live to the end of the full-expression at runtime, in order to
1869 // give portable results and match other compilers.
1870 return createLocal(Base, PVD, PVD->getType(), ScopeKind::Call);
1871}
1872
1873APValue &CallStackFrame::createLocal(APValue::LValueBase Base, const void *Key,
1874 QualType T, ScopeKind Scope) {
1875 assert(Base.getCallIndex() == Index && "lvalue for wrong frame")((void)0);
1876 unsigned Version = Base.getVersion();
1877 APValue &Result = Temporaries[MapKeyTy(Key, Version)];
1878 assert(Result.isAbsent() && "local created multiple times")((void)0);
1879
1880 // If we're creating a local immediately in the operand of a speculative
1881 // evaluation, don't register a cleanup to be run outside the speculative
1882 // evaluation context, since we won't actually be able to initialize this
1883 // object.
1884 if (Index <= Info.SpeculativeEvaluationDepth) {
1885 if (T.isDestructedType())
1886 Info.noteSideEffect();
1887 } else {
1888 Info.CleanupStack.push_back(Cleanup(&Result, Base, T, Scope));
1889 }
1890 return Result;
1891}
1892
1893APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) {
1894 if (NumHeapAllocs > DynamicAllocLValue::getMaxIndex()) {
1895 FFDiag(E, diag::note_constexpr_heap_alloc_limit_exceeded);
1896 return nullptr;
1897 }
1898
1899 DynamicAllocLValue DA(NumHeapAllocs++);
1900 LV.set(APValue::LValueBase::getDynamicAlloc(DA, T));
1901 auto Result = HeapAllocs.emplace(std::piecewise_construct,
1902 std::forward_as_tuple(DA), std::tuple<>());
1903 assert(Result.second && "reused a heap alloc index?")((void)0);
1904 Result.first->second.AllocExpr = E;
1905 return &Result.first->second.Value;
1906}
1907
1908/// Produce a string describing the given constexpr call.
1909void CallStackFrame::describe(raw_ostream &Out) {
1910 unsigned ArgIndex = 0;
1911 bool IsMemberCall = isa<CXXMethodDecl>(Callee) &&
1912 !isa<CXXConstructorDecl>(Callee) &&
1913 cast<CXXMethodDecl>(Callee)->isInstance();
1914
1915 if (!IsMemberCall)
1916 Out << *Callee << '(';
1917
1918 if (This && IsMemberCall) {
1919 APValue Val;
1920 This->moveInto(Val);
1921 Val.printPretty(Out, Info.Ctx,
1922 This->Designator.MostDerivedType);
1923 // FIXME: Add parens around Val if needed.
1924 Out << "->" << *Callee << '(';
1925 IsMemberCall = false;
1926 }
1927
1928 for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
1929 E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
1930 if (ArgIndex > (unsigned)IsMemberCall)
1931 Out << ", ";
1932
1933 const ParmVarDecl *Param = *I;
1934 APValue *V = Info.getParamSlot(Arguments, Param);
1935 if (V)
1936 V->printPretty(Out, Info.Ctx, Param->getType());
1937 else
1938 Out << "<...>";
1939
1940 if (ArgIndex == 0 && IsMemberCall)
1941 Out << "->" << *Callee << '(';
1942 }
1943
1944 Out << ')';
1945}
1946
1947/// Evaluate an expression to see if it had side-effects, and discard its
1948/// result.
1949/// \return \c true if the caller should keep evaluating.
1950static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1951 assert(!E->isValueDependent())((void)0);
1952 APValue Scratch;
1953 if (!Evaluate(Scratch, Info, E))
1954 // We don't need the value, but we might have skipped a side effect here.
1955 return Info.noteSideEffect();
1956 return true;
1957}
1958
1959/// Should this call expression be treated as a string literal?
1960static bool IsStringLiteralCall(const CallExpr *E) {
1961 unsigned Builtin = E->getBuiltinCallee();
1962 return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1963 Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1964}
1965
1966static bool IsGlobalLValue(APValue::LValueBase B) {
1967 // C++11 [expr.const]p3 An address constant expression is a prvalue core
1968 // constant expression of pointer type that evaluates to...
1969
1970 // ... a null pointer value, or a prvalue core constant expression of type
1971 // std::nullptr_t.
1972 if (!B) return true;
1973
1974 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
1975 // ... the address of an object with static storage duration,
1976 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1977 return VD->hasGlobalStorage();
1978 if (isa<TemplateParamObjectDecl>(D))
1979 return true;
1980 // ... the address of a function,
1981 // ... the address of a GUID [MS extension],
1982 return isa<FunctionDecl>(D) || isa<MSGuidDecl>(D);
1983 }
1984
1985 if (B.is<TypeInfoLValue>() || B.is<DynamicAllocLValue>())
1986 return true;
1987
1988 const Expr *E = B.get<const Expr*>();
1989 switch (E->getStmtClass()) {
1990 default:
1991 return false;
1992 case Expr::CompoundLiteralExprClass: {
1993 const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
1994 return CLE->isFileScope() && CLE->isLValue();
1995 }
1996 case Expr::MaterializeTemporaryExprClass:
1997 // A materialized temporary might have been lifetime-extended to static
1998 // storage duration.
1999 return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static;
2000 // A string literal has static storage duration.
2001 case Expr::StringLiteralClass:
2002 case Expr::PredefinedExprClass:
2003 case Expr::ObjCStringLiteralClass:
2004 case Expr::ObjCEncodeExprClass:
2005 return true;
2006 case Expr::ObjCBoxedExprClass:
2007 return cast<ObjCBoxedExpr>(E)->isExpressibleAsConstantInitializer();
2008 case Expr::CallExprClass:
2009 return IsStringLiteralCall(cast<CallExpr>(E));
2010 // For GCC compatibility, &&label has static storage duration.
2011 case Expr::AddrLabelExprClass:
2012 return true;
2013 // A Block literal expression may be used as the initialization value for
2014 // Block variables at global or local static scope.
2015 case Expr::BlockExprClass:
2016 return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
2017 case Expr::ImplicitValueInitExprClass:
2018 // FIXME:
2019 // We can never form an lvalue with an implicit value initialization as its
2020 // base through expression evaluation, so these only appear in one case: the
2021 // implicit variable declaration we invent when checking whether a constexpr
2022 // constructor can produce a constant expression. We must assume that such
2023 // an expression might be a global lvalue.
2024 return true;
2025 }
2026}
2027
2028static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
2029 return LVal.Base.dyn_cast<const ValueDecl*>();
2030}
2031
2032static bool IsLiteralLValue(const LValue &Value) {
2033 if (Value.getLValueCallIndex())
2034 return false;
2035 const Expr *E = Value.Base.dyn_cast<const Expr*>();
2036 return E && !isa<MaterializeTemporaryExpr>(E);
2037}
2038
2039static bool IsWeakLValue(const LValue &Value) {
2040 const ValueDecl *Decl = GetLValueBaseDecl(Value);
2041 return Decl && Decl->isWeak();
2042}
2043
2044static bool isZeroSized(const LValue &Value) {
2045 const ValueDecl *Decl = GetLValueBaseDecl(Value);
2046 if (Decl && isa<VarDecl>(Decl)) {
2047 QualType Ty = Decl->getType();
2048 if (Ty->isArrayType())
2049 return Ty->isIncompleteType() ||
2050 Decl->getASTContext().getTypeSize(Ty) == 0;
2051 }
2052 return false;
2053}
2054
2055static bool HasSameBase(const LValue &A, const LValue &B) {
2056 if (!A.getLValueBase())
2057 return !B.getLValueBase();
2058 if (!B.getLValueBase())
2059 return false;
2060
2061 if (A.getLValueBase().getOpaqueValue() !=
2062 B.getLValueBase().getOpaqueValue())
2063 return false;
2064
2065 return A.getLValueCallIndex() == B.getLValueCallIndex() &&
2066 A.getLValueVersion() == B.getLValueVersion();
2067}
2068
2069static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
2070 assert(Base && "no location for a null lvalue")((void)0);
2071 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
2072
2073 // For a parameter, find the corresponding call stack frame (if it still
2074 // exists), and point at the parameter of the function definition we actually
2075 // invoked.
2076 if (auto *PVD = dyn_cast_or_null<ParmVarDecl>(VD)) {
2077 unsigned Idx = PVD->getFunctionScopeIndex();
2078 for (CallStackFrame *F = Info.CurrentCall; F; F = F->Caller) {
2079 if (F->Arguments.CallIndex == Base.getCallIndex() &&
2080 F->Arguments.Version == Base.getVersion() && F->Callee &&
2081 Idx < F->Callee->getNumParams()) {
2082 VD = F->Callee->getParamDecl(Idx);
2083 break;
2084 }
2085 }
2086 }
2087
2088 if (VD)
2089 Info.Note(VD->getLocation(), diag::note_declared_at);
2090 else if (const Expr *E = Base.dyn_cast<const Expr*>())
2091 Info.Note(E->getExprLoc(), diag::note_constexpr_temporary_here);
2092 else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
2093 // FIXME: Produce a note for dangling pointers too.
2094 if (Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA))
2095 Info.Note((*Alloc)->AllocExpr->getExprLoc(),
2096 diag::note_constexpr_dynamic_alloc_here);
2097 }
2098 // We have no information to show for a typeid(T) object.
2099}
2100
2101enum class CheckEvaluationResultKind {
2102 ConstantExpression,
2103 FullyInitialized,
2104};
2105
2106/// Materialized temporaries that we've already checked to determine if they're
2107/// initializsed by a constant expression.
2108using CheckedTemporaries =
2109 llvm::SmallPtrSet<const MaterializeTemporaryExpr *, 8>;
2110
2111static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
2112 EvalInfo &Info, SourceLocation DiagLoc,
2113 QualType Type, const APValue &Value,
2114 ConstantExprKind Kind,
2115 SourceLocation SubobjectLoc,
2116 CheckedTemporaries &CheckedTemps);
2117
2118/// Check that this reference or pointer core constant expression is a valid
2119/// value for an address or reference constant expression. Return true if we
2120/// can fold this expression, whether or not it's a constant expression.
2121static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
2122 QualType Type, const LValue &LVal,
2123 ConstantExprKind Kind,
2124 CheckedTemporaries &CheckedTemps) {
2125 bool IsReferenceType = Type->isReferenceType();
2126
2127 APValue::LValueBase Base = LVal.getLValueBase();
2128 const SubobjectDesignator &Designator = LVal.getLValueDesignator();
2129
2130 const Expr *BaseE = Base.dyn_cast<const Expr *>();
2131 const ValueDecl *BaseVD = Base.dyn_cast<const ValueDecl*>();
2132
2133 // Additional restrictions apply in a template argument. We only enforce the
2134 // C++20 restrictions here; additional syntactic and semantic restrictions
2135 // are applied elsewhere.
2136 if (isTemplateArgument(Kind)) {
2137 int InvalidBaseKind = -1;
2138 StringRef Ident;
2139 if (Base.is<TypeInfoLValue>())
2140 InvalidBaseKind = 0;
2141 else if (isa_and_nonnull<StringLiteral>(BaseE))
2142 InvalidBaseKind = 1;
2143 else if (isa_and_nonnull<MaterializeTemporaryExpr>(BaseE) ||
2144 isa_and_nonnull<LifetimeExtendedTemporaryDecl>(BaseVD))
2145 InvalidBaseKind = 2;
2146 else if (auto *PE = dyn_cast_or_null<PredefinedExpr>(BaseE)) {
2147 InvalidBaseKind = 3;
2148 Ident = PE->getIdentKindName();
2149 }
2150
2151 if (InvalidBaseKind != -1) {
2152 Info.FFDiag(Loc, diag::note_constexpr_invalid_template_arg)
2153 << IsReferenceType << !Designator.Entries.empty() << InvalidBaseKind
2154 << Ident;
2155 return false;
2156 }
2157 }
2158
2159 if (auto *FD = dyn_cast_or_null<FunctionDecl>(BaseVD)) {
2160 if (FD->isConsteval()) {
2161 Info.FFDiag(Loc, diag::note_consteval_address_accessible)
2162 << !Type->isAnyPointerType();
2163 Info.Note(FD->getLocation(), diag::note_declared_at);
2164 return false;
2165 }
2166 }
2167
2168 // Check that the object is a global. Note that the fake 'this' object we
2169 // manufacture when checking potential constant expressions is conservatively
2170 // assumed to be global here.
2171 if (!IsGlobalLValue(Base)) {
2172 if (Info.getLangOpts().CPlusPlus11) {
2173 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
2174 Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
2175 << IsReferenceType << !Designator.Entries.empty()
2176 << !!VD << VD;
2177
2178 auto *VarD = dyn_cast_or_null<VarDecl>(VD);
2179 if (VarD && VarD->isConstexpr()) {
2180 // Non-static local constexpr variables have unintuitive semantics:
2181 // constexpr int a = 1;
2182 // constexpr const int *p = &a;
2183 // ... is invalid because the address of 'a' is not constant. Suggest
2184 // adding a 'static' in this case.
2185 Info.Note(VarD->getLocation(), diag::note_constexpr_not_static)
2186 << VarD
2187 << FixItHint::CreateInsertion(VarD->getBeginLoc(), "static ");
2188 } else {
2189 NoteLValueLocation(Info, Base);
2190 }
2191 } else {
2192 Info.FFDiag(Loc);
2193 }
2194 // Don't allow references to temporaries to escape.
2195 return false;
2196 }
2197 assert((Info.checkingPotentialConstantExpression() ||((void)0)
2198 LVal.getLValueCallIndex() == 0) &&((void)0)
2199 "have call index for global lvalue")((void)0);
2200
2201 if (Base.is<DynamicAllocLValue>()) {
2202 Info.FFDiag(Loc, diag::note_constexpr_dynamic_alloc)
2203 << IsReferenceType << !Designator.Entries.empty();
2204 NoteLValueLocation(Info, Base);
2205 return false;
2206 }
2207
2208 if (BaseVD) {
2209 if (const VarDecl *Var = dyn_cast<const VarDecl>(BaseVD)) {
2210 // Check if this is a thread-local variable.
2211 if (Var->getTLSKind())
2212 // FIXME: Diagnostic!
2213 return false;
2214
2215 // A dllimport variable never acts like a constant, unless we're
2216 // evaluating a value for use only in name mangling.
2217 if (!isForManglingOnly(Kind) && Var->hasAttr<DLLImportAttr>())
2218 // FIXME: Diagnostic!
2219 return false;
2220 }
2221 if (const auto *FD = dyn_cast<const FunctionDecl>(BaseVD)) {
2222 // __declspec(dllimport) must be handled very carefully:
2223 // We must never initialize an expression with the thunk in C++.
2224 // Doing otherwise would allow the same id-expression to yield
2225 // different addresses for the same function in different translation
2226 // units. However, this means that we must dynamically initialize the
2227 // expression with the contents of the import address table at runtime.
2228 //
2229 // The C language has no notion of ODR; furthermore, it has no notion of
2230 // dynamic initialization. This means that we are permitted to
2231 // perform initialization with the address of the thunk.
2232 if (Info.getLangOpts().CPlusPlus && !isForManglingOnly(Kind) &&
2233 FD->hasAttr<DLLImportAttr>())
2234 // FIXME: Diagnostic!
2235 return false;
2236 }
2237 } else if (const auto *MTE =
2238 dyn_cast_or_null<MaterializeTemporaryExpr>(BaseE)) {
2239 if (CheckedTemps.insert(MTE).second) {
2240 QualType TempType = getType(Base);
2241 if (TempType.isDestructedType()) {
2242 Info.FFDiag(MTE->getExprLoc(),
2243 diag::note_constexpr_unsupported_temporary_nontrivial_dtor)
2244 << TempType;
2245 return false;
2246 }
2247
2248 APValue *V = MTE->getOrCreateValue(false);
2249 assert(V && "evasluation result refers to uninitialised temporary")((void)0);
2250 if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
2251 Info, MTE->getExprLoc(), TempType, *V,
2252 Kind, SourceLocation(), CheckedTemps))
2253 return false;
2254 }
2255 }
2256
2257 // Allow address constant expressions to be past-the-end pointers. This is
2258 // an extension: the standard requires them to point to an object.
2259 if (!IsReferenceType)
2260 return true;
2261
2262 // A reference constant expression must refer to an object.
2263 if (!Base) {
2264 // FIXME: diagnostic
2265 Info.CCEDiag(Loc);
2266 return true;
2267 }
2268
2269 // Does this refer one past the end of some object?
2270 if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
2271 Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
2272 << !Designator.Entries.empty() << !!BaseVD << BaseVD;
2273 NoteLValueLocation(Info, Base);
2274 }
2275
2276 return true;
2277}
2278
2279/// Member pointers are constant expressions unless they point to a
2280/// non-virtual dllimport member function.
2281static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
2282 SourceLocation Loc,
2283 QualType Type,
2284 const APValue &Value,
2285 ConstantExprKind Kind) {
2286 const ValueDecl *Member = Value.getMemberPointerDecl();
2287 const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
2288 if (!FD)
2289 return true;
2290 if (FD->isConsteval()) {
2291 Info.FFDiag(Loc, diag::note_consteval_address_accessible) << /*pointer*/ 0;
2292 Info.Note(FD->getLocation(), diag::note_declared_at);
2293 return false;
2294 }
2295 return isForManglingOnly(Kind) || FD->isVirtual() ||
2296 !FD->hasAttr<DLLImportAttr>();
2297}
2298
2299/// Check that this core constant expression is of literal type, and if not,
2300/// produce an appropriate diagnostic.
2301static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
2302 const LValue *This = nullptr) {
2303 if (!E->isPRValue() || E->getType()->isLiteralType(Info.Ctx))
2304 return true;
2305
2306 // C++1y: A constant initializer for an object o [...] may also invoke
2307 // constexpr constructors for o and its subobjects even if those objects
2308 // are of non-literal class types.
2309 //
2310 // C++11 missed this detail for aggregates, so classes like this:
2311 // struct foo_t { union { int i; volatile int j; } u; };
2312 // are not (obviously) initializable like so:
2313 // __attribute__((__require_constant_initialization__))
2314 // static const foo_t x = {{0}};
2315 // because "i" is a subobject with non-literal initialization (due to the
2316 // volatile member of the union). See:
2317 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677
2318 // Therefore, we use the C++1y behavior.
2319 if (This && Info.EvaluatingDecl == This->getLValueBase())
2320 return true;
2321
2322 // Prvalue constant expressions must be of literal types.
2323 if (Info.getLangOpts().CPlusPlus11)
2324 Info.FFDiag(E, diag::note_constexpr_nonliteral)
2325 << E->getType();
2326 else
2327 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2328 return false;
2329}
2330
2331static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
2332 EvalInfo &Info, SourceLocation DiagLoc,
2333 QualType Type, const APValue &Value,
2334 ConstantExprKind Kind,
2335 SourceLocation SubobjectLoc,
2336 CheckedTemporaries &CheckedTemps) {
2337 if (!Value.hasValue()) {
2338 Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
2339 << true << Type;
2340 if (SubobjectLoc.isValid())
2341 Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here);
2342 return false;
2343 }
2344
2345 // We allow _Atomic(T) to be initialized from anything that T can be
2346 // initialized from.
2347 if (const AtomicType *AT = Type->getAs<AtomicType>())
2348 Type = AT->getValueType();
2349
2350 // Core issue 1454: For a literal constant expression of array or class type,
2351 // each subobject of its value shall have been initialized by a constant
2352 // expression.
2353 if (Value.isArray()) {
2354 QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType();
2355 for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) {
2356 if (!CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
2357 Value.getArrayInitializedElt(I), Kind,
2358 SubobjectLoc, CheckedTemps))
2359 return false;
2360 }
2361 if (!Value.hasArrayFiller())
2362 return true;
2363 return CheckEvaluationResult(CERK, Info, DiagLoc, EltTy,
2364 Value.getArrayFiller(), Kind, SubobjectLoc,
2365 CheckedTemps);
2366 }
2367 if (Value.isUnion() && Value.getUnionField()) {
2368 return CheckEvaluationResult(
2369 CERK, Info, DiagLoc, Value.getUnionField()->getType(),
2370 Value.getUnionValue(), Kind, Value.getUnionField()->getLocation(),
2371 CheckedTemps);
2372 }
2373 if (Value.isStruct()) {
2374 RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
2375 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
2376 unsigned BaseIndex = 0;
2377 for (const CXXBaseSpecifier &BS : CD->bases()) {
2378 if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(),
2379 Value.getStructBase(BaseIndex), Kind,
2380 BS.getBeginLoc(), CheckedTemps))
2381 return false;
2382 ++BaseIndex;
2383 }
2384 }
2385 for (const auto *I : RD->fields()) {
2386 if (I->isUnnamedBitfield())
2387 continue;
2388
2389 if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(),
2390 Value.getStructField(I->getFieldIndex()),
2391 Kind, I->getLocation(), CheckedTemps))
2392 return false;
2393 }
2394 }
2395
2396 if (Value.isLValue() &&
2397 CERK == CheckEvaluationResultKind::ConstantExpression) {
2398 LValue LVal;
2399 LVal.setFrom(Info.Ctx, Value);
2400 return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Kind,
2401 CheckedTemps);
2402 }
2403
2404 if (Value.isMemberPointer() &&
2405 CERK == CheckEvaluationResultKind::ConstantExpression)
2406 return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Kind);
2407
2408 // Everything else is fine.
2409 return true;
2410}
2411
2412/// Check that this core constant expression value is a valid value for a
2413/// constant expression. If not, report an appropriate diagnostic. Does not
2414/// check that the expression is of literal type.
2415static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
2416 QualType Type, const APValue &Value,
2417 ConstantExprKind Kind) {
2418 // Nothing to check for a constant expression of type 'cv void'.
2419 if (Type->isVoidType())
2420 return true;
2421
2422 CheckedTemporaries CheckedTemps;
2423 return CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
2424 Info, DiagLoc, Type, Value, Kind,
2425 SourceLocation(), CheckedTemps);
2426}
2427
2428/// Check that this evaluated value is fully-initialized and can be loaded by
2429/// an lvalue-to-rvalue conversion.
2430static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc,
2431 QualType Type, const APValue &Value) {
2432 CheckedTemporaries CheckedTemps;
2433 return CheckEvaluationResult(
2434 CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value,
2435 ConstantExprKind::Normal, SourceLocation(), CheckedTemps);
2436}
2437
2438/// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless
2439/// "the allocated storage is deallocated within the evaluation".
2440static bool CheckMemoryLeaks(EvalInfo &Info) {
2441 if (!Info.HeapAllocs.empty()) {
2442 // We can still fold to a constant despite a compile-time memory leak,
2443 // so long as the heap allocation isn't referenced in the result (we check
2444 // that in CheckConstantExpression).
2445 Info.CCEDiag(Info.HeapAllocs.begin()->second.AllocExpr,
2446 diag::note_constexpr_memory_leak)
2447 << unsigned(Info.HeapAllocs.size() - 1);
2448 }
2449 return true;
2450}
2451
2452static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
2453 // A null base expression indicates a null pointer. These are always
2454 // evaluatable, and they are false unless the offset is zero.
2455 if (!Value.getLValueBase()) {
2456 Result = !Value.getLValueOffset().isZero();
2457 return true;
2458 }
2459
2460 // We have a non-null base. These are generally known to be true, but if it's
2461 // a weak declaration it can be null at runtime.
2462 Result = true;
2463 const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
2464 return !Decl || !Decl->isWeak();
2465}
2466
2467static bool HandleConversionToBool(const APValue &Val, bool &Result) {
2468 switch (Val.getKind()) {
2469 case APValue::None:
2470 case APValue::Indeterminate:
2471 return false;
2472 case APValue::Int:
2473 Result = Val.getInt().getBoolValue();
2474 return true;
2475 case APValue::FixedPoint:
2476 Result = Val.getFixedPoint().getBoolValue();
2477 return true;
2478 case APValue::Float:
2479 Result = !Val.getFloat().isZero();
2480 return true;
2481 case APValue::ComplexInt:
2482 Result = Val.getComplexIntReal().getBoolValue() ||
2483 Val.getComplexIntImag().getBoolValue();
2484 return true;
2485 case APValue::ComplexFloat:
2486 Result = !Val.getComplexFloatReal().isZero() ||
2487 !Val.getComplexFloatImag().isZero();
2488 return true;
2489 case APValue::LValue:
2490 return EvalPointerValueAsBool(Val, Result);
2491 case APValue::MemberPointer:
2492 Result = Val.getMemberPointerDecl();
2493 return true;
2494 case APValue::Vector:
2495 case APValue::Array:
2496 case APValue::Struct:
2497 case APValue::Union:
2498 case APValue::AddrLabelDiff:
2499 return false;
2500 }
2501
2502 llvm_unreachable("unknown APValue kind")__builtin_unreachable();
2503}
2504
2505static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
2506 EvalInfo &Info) {
2507 assert(!E->isValueDependent())((void)0);
2508 assert(E->isPRValue() && "missing lvalue-to-rvalue conv in bool condition")((void)0);
2509 APValue Val;
2510 if (!Evaluate(Val, Info, E))
2511 return false;
2512 return HandleConversionToBool(Val, Result);
2513}
2514
2515template<typename T>
2516static bool HandleOverflow(EvalInfo &Info, const Expr *E,
2517 const T &SrcValue, QualType DestType) {
2518 Info.CCEDiag(E, diag::note_constexpr_overflow)
2519 << SrcValue << DestType;
2520 return Info.noteUndefinedBehavior();
2521}
2522
2523static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
2524 QualType SrcType, const APFloat &Value,
2525 QualType DestType, APSInt &Result) {
2526 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2527 // Determine whether we are converting to unsigned or signed.
2528 bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
2529
2530 Result = APSInt(DestWidth, !DestSigned);
2531 bool ignored;
2532 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
2533 & APFloat::opInvalidOp)
2534 return HandleOverflow(Info, E, Value, DestType);
2535 return true;
2536}
2537
2538/// Get rounding mode used for evaluation of the specified expression.
2539/// \param[out] DynamicRM Is set to true is the requested rounding mode is
2540/// dynamic.
2541/// If rounding mode is unknown at compile time, still try to evaluate the
2542/// expression. If the result is exact, it does not depend on rounding mode.
2543/// So return "tonearest" mode instead of "dynamic".
2544static llvm::RoundingMode getActiveRoundingMode(EvalInfo &Info, const Expr *E,
2545 bool &DynamicRM) {
2546 llvm::RoundingMode RM =
2547 E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).getRoundingMode();
2548 DynamicRM = (RM == llvm::RoundingMode::Dynamic);
2549 if (DynamicRM)
2550 RM = llvm::RoundingMode::NearestTiesToEven;
2551 return RM;
2552}
2553
2554/// Check if the given evaluation result is allowed for constant evaluation.
2555static bool checkFloatingPointResult(EvalInfo &Info, const Expr *E,
2556 APFloat::opStatus St) {
2557 // In a constant context, assume that any dynamic rounding mode or FP
2558 // exception state matches the default floating-point environment.
2559 if (Info.InConstantContext)
2560 return true;
2561
2562 FPOptions FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
2563 if ((St & APFloat::opInexact) &&
2564 FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {
2565 // Inexact result means that it depends on rounding mode. If the requested
2566 // mode is dynamic, the evaluation cannot be made in compile time.
2567 Info.FFDiag(E, diag::note_constexpr_dynamic_rounding);
2568 return false;
2569 }
2570
2571 if ((St != APFloat::opOK) &&
2572 (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic ||
2573 FPO.getFPExceptionMode() != LangOptions::FPE_Ignore ||
2574 FPO.getAllowFEnvAccess())) {
2575 Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
2576 return false;
2577 }
2578
2579 if ((St & APFloat::opStatus::opInvalidOp) &&
2580 FPO.getFPExceptionMode() != LangOptions::FPE_Ignore) {
2581 // There is no usefully definable result.
2582 Info.FFDiag(E);
2583 return false;
2584 }
2585
2586 // FIXME: if:
2587 // - evaluation triggered other FP exception, and
2588 // - exception mode is not "ignore", and
2589 // - the expression being evaluated is not a part of global variable
2590 // initializer,
2591 // the evaluation probably need to be rejected.
2592 return true;
2593}
2594
2595static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
2596 QualType SrcType, QualType DestType,
2597 APFloat &Result) {
2598 assert(isa<CastExpr>(E) || isa<CompoundAssignOperator>(E))((void)0);
2599 bool DynamicRM;
2600 llvm::RoundingMode RM = getActiveRoundingMode(Info, E, DynamicRM);
2601 APFloat::opStatus St;
2602 APFloat Value = Result;
2603 bool ignored;
2604 St = Result.convert(Info.Ctx.getFloatTypeSemantics(DestType), RM, &ignored);
2605 return checkFloatingPointResult(Info, E, St);
2606}
2607
2608static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
2609 QualType DestType, QualType SrcType,
2610 const APSInt &Value) {
2611 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
2612 // Figure out if this is a truncate, extend or noop cast.
2613 // If the input is signed, do a sign extend, noop, or truncate.
2614 APSInt Result = Value.extOrTrunc(DestWidth);
2615 Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
2616 if (DestType->isBooleanType())
2617 Result = Value.getBoolValue();
2618 return Result;
2619}
2620
2621static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
2622 const FPOptions FPO,
2623 QualType SrcType, const APSInt &Value,
2624 QualType DestType, APFloat &Result) {
2625 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
2626 APFloat::opStatus St = Result.convertFromAPInt(Value, Value.isSigned(),
2627 APFloat::rmNearestTiesToEven);
2628 if (!Info.InConstantContext && St != llvm::APFloatBase::opOK &&
2629 FPO.isFPConstrained()) {
2630 Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
2631 return false;
2632 }
2633 return true;
2634}
2635
2636static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
2637 APValue &Value, const FieldDecl *FD) {
2638 assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield")((void)0);
2639
2640 if (!Value.isInt()) {
2641 // Trying to store a pointer-cast-to-integer into a bitfield.
2642 // FIXME: In this case, we should provide the diagnostic for casting
2643 // a pointer to an integer.
2644 assert(Value.isLValue() && "integral value neither int nor lvalue?")((void)0);
2645 Info.FFDiag(E);
2646 return false;
2647 }
2648
2649 APSInt &Int = Value.getInt();
2650 unsigned OldBitWidth = Int.getBitWidth();
2651 unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
2652 if (NewBitWidth < OldBitWidth)
2653 Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
2654 return true;
2655}
2656
2657static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
2658 llvm::APInt &Res) {
2659 APValue SVal;
2660 if (!Evaluate(SVal, Info, E))
2661 return false;
2662 if (SVal.isInt()) {
2663 Res = SVal.getInt();
2664 return true;
2665 }
2666 if (SVal.isFloat()) {
2667 Res = SVal.getFloat().bitcastToAPInt();
2668 return true;
2669 }
2670 if (SVal.isVector()) {
2671 QualType VecTy = E->getType();
2672 unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
2673 QualType EltTy = VecTy->castAs<VectorType>()->getElementType();
2674 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
2675 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
2676 Res = llvm::APInt::getNullValue(VecSize);
2677 for (unsigned i = 0; i < SVal.getVectorLength(); i++) {
2678 APValue &Elt = SVal.getVectorElt(i);
2679 llvm::APInt EltAsInt;
2680 if (Elt.isInt()) {
2681 EltAsInt = Elt.getInt();
2682 } else if (Elt.isFloat()) {
2683 EltAsInt = Elt.getFloat().bitcastToAPInt();
2684 } else {
2685 // Don't try to handle vectors of anything other than int or float
2686 // (not sure if it's possible to hit this case).
2687 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2688 return false;
2689 }
2690 unsigned BaseEltSize = EltAsInt.getBitWidth();
2691 if (BigEndian)
2692 Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
2693 else
2694 Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
2695 }
2696 return true;
2697 }
2698 // Give up if the input isn't an int, float, or vector. For example, we
2699 // reject "(v4i16)(intptr_t)&a".
2700 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2701 return false;
2702}
2703
2704/// Perform the given integer operation, which is known to need at most BitWidth
2705/// bits, and check for overflow in the original type (if that type was not an
2706/// unsigned type).
2707template<typename Operation>
2708static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
2709 const APSInt &LHS, const APSInt &RHS,
2710 unsigned BitWidth, Operation Op,
2711 APSInt &Result) {
2712 if (LHS.isUnsigned()) {
2713 Result = Op(LHS, RHS);
2714 return true;
2715 }
2716
2717 APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false);
2718 Result = Value.trunc(LHS.getBitWidth());
2719 if (Result.extend(BitWidth) != Value) {
2720 if (Info.checkingForUndefinedBehavior())
2721 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
2722 diag::warn_integer_constant_overflow)
2723 << toString(Result, 10) << E->getType();
2724 return HandleOverflow(Info, E, Value, E->getType());
2725 }
2726 return true;
2727}
2728
2729/// Perform the given binary integer operation.
2730static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
2731 BinaryOperatorKind Opcode, APSInt RHS,
2732 APSInt &Result) {
2733 switch (Opcode) {
2734 default:
2735 Info.FFDiag(E);
2736 return false;
2737 case BO_Mul:
2738 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
2739 std::multiplies<APSInt>(), Result);
2740 case BO_Add:
2741 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2742 std::plus<APSInt>(), Result);
2743 case BO_Sub:
2744 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
2745 std::minus<APSInt>(), Result);
2746 case BO_And: Result = LHS & RHS; return true;
2747 case BO_Xor: Result = LHS ^ RHS; return true;
2748 case BO_Or: Result = LHS | RHS; return true;
2749 case BO_Div:
2750 case BO_Rem:
2751 if (RHS == 0) {
2752 Info.FFDiag(E, diag::note_expr_divide_by_zero);
2753 return false;
2754 }
2755 Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2756 // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
2757 // this operation and gives the two's complement result.
2758 if (RHS.isNegative() && RHS.isAllOnesValue() &&
2759 LHS.isSigned() && LHS.isMinSignedValue())
2760 return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2761 E->getType());
2762 return true;
2763 case BO_Shl: {
2764 if (Info.getLangOpts().OpenCL)
2765 // OpenCL 6.3j: shift values are effectively % word size of LHS.
2766 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2767 static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2768 RHS.isUnsigned());
2769 else if (RHS.isSigned() && RHS.isNegative()) {
2770 // During constant-folding, a negative shift is an opposite shift. Such
2771 // a shift is not a constant expression.
2772 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2773 RHS = -RHS;
2774 goto shift_right;
2775 }
2776 shift_left:
2777 // C++11 [expr.shift]p1: Shift width must be less than the bit width of
2778 // the shifted type.
2779 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2780 if (SA != RHS) {
2781 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2782 << RHS << E->getType() << LHS.getBitWidth();
2783 } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {
2784 // C++11 [expr.shift]p2: A signed left shift must have a non-negative
2785 // operand, and must not overflow the corresponding unsigned type.
2786 // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to
2787 // E1 x 2^E2 module 2^N.
2788 if (LHS.isNegative())
2789 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2790 else if (LHS.countLeadingZeros() < SA)
2791 Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2792 }
2793 Result = LHS << SA;
2794 return true;
2795 }
2796 case BO_Shr: {
2797 if (Info.getLangOpts().OpenCL)
2798 // OpenCL 6.3j: shift values are effectively % word size of LHS.
2799 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2800 static_cast<uint64_t>(LHS.getBitWidth() - 1)),
2801 RHS.isUnsigned());
2802 else if (RHS.isSigned() && RHS.isNegative()) {
2803 // During constant-folding, a negative shift is an opposite shift. Such a
2804 // shift is not a constant expression.
2805 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2806 RHS = -RHS;
2807 goto shift_left;
2808 }
2809 shift_right:
2810 // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
2811 // shifted type.
2812 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2813 if (SA != RHS)
2814 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2815 << RHS << E->getType() << LHS.getBitWidth();
2816 Result = LHS >> SA;
2817 return true;
2818 }
2819
2820 case BO_LT: Result = LHS < RHS; return true;
2821 case BO_GT: Result = LHS > RHS; return true;
2822 case BO_LE: Result = LHS <= RHS; return true;
2823 case BO_GE: Result = LHS >= RHS; return true;
2824 case BO_EQ: Result = LHS == RHS; return true;
2825 case BO_NE: Result = LHS != RHS; return true;
2826 case BO_Cmp:
2827 llvm_unreachable("BO_Cmp should be handled elsewhere")__builtin_unreachable();
2828 }
2829}
2830
2831/// Perform the given binary floating-point operation, in-place, on LHS.
2832static bool handleFloatFloatBinOp(EvalInfo &Info, const BinaryOperator *E,
2833 APFloat &LHS, BinaryOperatorKind Opcode,
2834 const APFloat &RHS) {
2835 bool DynamicRM;
2836 llvm::RoundingMode RM = getActiveRoundingMode(Info, E, DynamicRM);
2837 APFloat::opStatus St;
2838 switch (Opcode) {
2839 default:
2840 Info.FFDiag(E);
2841 return false;
2842 case BO_Mul:
2843 St = LHS.multiply(RHS, RM);
2844 break;
2845 case BO_Add:
2846 St = LHS.add(RHS, RM);
2847 break;
2848 case BO_Sub:
2849 St = LHS.subtract(RHS, RM);
2850 break;
2851 case BO_Div:
2852 // [expr.mul]p4:
2853 // If the second operand of / or % is zero the behavior is undefined.
2854 if (RHS.isZero())
2855 Info.CCEDiag(E, diag::note_expr_divide_by_zero);
2856 St = LHS.divide(RHS, RM);
2857 break;
2858 }
2859
2860 // [expr.pre]p4:
2861 // If during the evaluation of an expression, the result is not
2862 // mathematically defined [...], the behavior is undefined.
2863 // FIXME: C++ rules require us to not conform to IEEE 754 here.
2864 if (LHS.isNaN()) {
2865 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2866 return Info.noteUndefinedBehavior();
2867 }
2868
2869 return checkFloatingPointResult(Info, E, St);
2870}
2871
2872static bool handleLogicalOpForVector(const APInt &LHSValue,
2873 BinaryOperatorKind Opcode,
2874 const APInt &RHSValue, APInt &Result) {
2875 bool LHS = (LHSValue != 0);
2876 bool RHS = (RHSValue != 0);
2877
2878 if (Opcode == BO_LAnd)
2879 Result = LHS && RHS;
2880 else
2881 Result = LHS || RHS;
2882 return true;
2883}
2884static bool handleLogicalOpForVector(const APFloat &LHSValue,
2885 BinaryOperatorKind Opcode,
2886 const APFloat &RHSValue, APInt &Result) {
2887 bool LHS = !LHSValue.isZero();
2888 bool RHS = !RHSValue.isZero();
2889
2890 if (Opcode == BO_LAnd)
2891 Result = LHS && RHS;
2892 else
2893 Result = LHS || RHS;
2894 return true;
2895}
2896
2897static bool handleLogicalOpForVector(const APValue &LHSValue,
2898 BinaryOperatorKind Opcode,
2899 const APValue &RHSValue, APInt &Result) {
2900 // The result is always an int type, however operands match the first.
2901 if (LHSValue.getKind() == APValue::Int)
2902 return handleLogicalOpForVector(LHSValue.getInt(), Opcode,
2903 RHSValue.getInt(), Result);
2904 assert(LHSValue.getKind() == APValue::Float && "Should be no other options")((void)0);
2905 return handleLogicalOpForVector(LHSValue.getFloat(), Opcode,
2906 RHSValue.getFloat(), Result);
2907}
2908
2909template <typename APTy>
2910static bool
2911handleCompareOpForVectorHelper(const APTy &LHSValue, BinaryOperatorKind Opcode,
2912 const APTy &RHSValue, APInt &Result) {
2913 switch (Opcode) {
2914 default:
2915 llvm_unreachable("unsupported binary operator")__builtin_unreachable();
2916 case BO_EQ:
2917 Result = (LHSValue == RHSValue);
2918 break;
2919 case BO_NE:
2920 Result = (LHSValue != RHSValue);
2921 break;
2922 case BO_LT:
2923 Result = (LHSValue < RHSValue);
2924 break;
2925 case BO_GT:
2926 Result = (LHSValue > RHSValue);
2927 break;
2928 case BO_LE:
2929 Result = (LHSValue <= RHSValue);
2930 break;
2931 case BO_GE:
2932 Result = (LHSValue >= RHSValue);
2933 break;
2934 }
2935
2936 return true;
2937}
2938
2939static bool handleCompareOpForVector(const APValue &LHSValue,
2940 BinaryOperatorKind Opcode,
2941 const APValue &RHSValue, APInt &Result) {
2942 // The result is always an int type, however operands match the first.
2943 if (LHSValue.getKind() == APValue::Int)
2944 return handleCompareOpForVectorHelper(LHSValue.getInt(), Opcode,
2945 RHSValue.getInt(), Result);
2946 assert(LHSValue.getKind() == APValue::Float && "Should be no other options")((void)0);
2947 return handleCompareOpForVectorHelper(LHSValue.getFloat(), Opcode,
2948 RHSValue.getFloat(), Result);
2949}
2950
2951// Perform binary operations for vector types, in place on the LHS.
2952static bool handleVectorVectorBinOp(EvalInfo &Info, const BinaryOperator *E,
2953 BinaryOperatorKind Opcode,
2954 APValue &LHSValue,
2955 const APValue &RHSValue) {
2956 assert(Opcode != BO_PtrMemD && Opcode != BO_PtrMemI &&((void)0)
2957 "Operation not supported on vector types")((void)0);
2958
2959 const auto *VT = E->getType()->castAs<VectorType>();
2960 unsigned NumElements = VT->getNumElements();
2961 QualType EltTy = VT->getElementType();
2962
2963 // In the cases (typically C as I've observed) where we aren't evaluating
2964 // constexpr but are checking for cases where the LHS isn't yet evaluatable,
2965 // just give up.
2966 if (!LHSValue.isVector()) {
2967 assert(LHSValue.isLValue() &&((void)0)
2968 "A vector result that isn't a vector OR uncalculated LValue")((void)0);
2969 Info.FFDiag(E);
2970 return false;
2971 }
2972
2973 assert(LHSValue.getVectorLength() == NumElements &&((void)0)
2974 RHSValue.getVectorLength() == NumElements && "Different vector sizes")((void)0);
2975
2976 SmallVector<APValue, 4> ResultElements;
2977
2978 for (unsigned EltNum = 0; EltNum < NumElements; ++EltNum) {
2979 APValue LHSElt = LHSValue.getVectorElt(EltNum);
2980 APValue RHSElt = RHSValue.getVectorElt(EltNum);
2981
2982 if (EltTy->isIntegerType()) {
2983 APSInt EltResult{Info.Ctx.getIntWidth(EltTy),
2984 EltTy->isUnsignedIntegerType()};
2985 bool Success = true;
2986
2987 if (BinaryOperator::isLogicalOp(Opcode))
2988 Success = handleLogicalOpForVector(LHSElt, Opcode, RHSElt, EltResult);
2989 else if (BinaryOperator::isComparisonOp(Opcode))
2990 Success = handleCompareOpForVector(LHSElt, Opcode, RHSElt, EltResult);
2991 else
2992 Success = handleIntIntBinOp(Info, E, LHSElt.getInt(), Opcode,
2993 RHSElt.getInt(), EltResult);
2994
2995 if (!Success) {
2996 Info.FFDiag(E);
2997 return false;
2998 }
2999 ResultElements.emplace_back(EltResult);
3000
3001 } else if (EltTy->isFloatingType()) {
3002 assert(LHSElt.getKind() == APValue::Float &&((void)0)
3003 RHSElt.getKind() == APValue::Float &&((void)0)
3004 "Mismatched LHS/RHS/Result Type")((void)0);
3005 APFloat LHSFloat = LHSElt.getFloat();
3006
3007 if (!handleFloatFloatBinOp(Info, E, LHSFloat, Opcode,
3008 RHSElt.getFloat())) {
3009 Info.FFDiag(E);
3010 return false;
3011 }
3012
3013 ResultElements.emplace_back(LHSFloat);
3014 }
3015 }
3016
3017 LHSValue = APValue(ResultElements.data(), ResultElements.size());
3018 return true;
3019}
3020
3021/// Cast an lvalue referring to a base subobject to a derived class, by
3022/// truncating the lvalue's path to the given length.
3023static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
3024 const RecordDecl *TruncatedType,
3025 unsigned TruncatedElements) {
3026 SubobjectDesignator &D = Result.Designator;
3027
3028 // Check we actually point to a derived class object.
3029 if (TruncatedElements == D.Entries.size())
3030 return true;
3031 assert(TruncatedElements >= D.MostDerivedPathLength &&((void)0)
3032 "not casting to a derived class")((void)0);
3033 if (!Result.checkSubobject(Info, E, CSK_Derived))
3034 return false;
3035
3036 // Truncate the path to the subobject, and remove any derived-to-base offsets.
3037 const RecordDecl *RD = TruncatedType;
3038 for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
3039 if (RD->isInvalidDecl()) return false;
3040 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
3041 const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]);
3042 if (isVirtualBaseClass(D.Entries[I]))
3043 Result.Offset -= Layout.getVBaseClassOffset(Base);
3044 else
3045 Result.Offset -= Layout.getBaseClassOffset(Base);
3046 RD = Base;
3047 }
3048 D.Entries.resize(TruncatedElements);
3049 return true;
3050}
3051
3052static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
3053 const CXXRecordDecl *Derived,
3054 const CXXRecordDecl *Base,
3055 const ASTRecordLayout *RL = nullptr) {
3056 if (!RL) {
3057 if (Derived->isInvalidDecl()) return false;
3058 RL = &Info.Ctx.getASTRecordLayout(Derived);
3059 }
3060
3061 Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
3062 Obj.addDecl(Info, E, Base, /*Virtual*/ false);
3063 return true;
3064}
3065
3066static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
3067 const CXXRecordDecl *DerivedDecl,
3068 const CXXBaseSpecifier *Base) {
3069 const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
3070
3071 if (!Base->isVirtual())
3072 return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
3073
3074 SubobjectDesignator &D = Obj.Designator;
3075 if (D.Invalid)
3076 return false;
3077
3078 // Extract most-derived object and corresponding type.
3079 DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
3080 if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
3081 return false;
3082
3083 // Find the virtual base class.
3084 if (DerivedDecl->isInvalidDecl()) return false;
3085 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
3086 Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
3087 Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
3088 return true;
3089}
3090
3091static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
3092 QualType Type, LValue &Result) {
3093 for (CastExpr::path_const_iterator PathI = E->path_begin(),
3094 PathE = E->path_end();
3095 PathI != PathE; ++PathI) {
3096 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
3097 *PathI))
3098 return false;
3099 Type = (*PathI)->getType();
3100 }
3101 return true;
3102}
3103
3104/// Cast an lvalue referring to a derived class to a known base subobject.
3105static bool CastToBaseClass(EvalInfo &Info, const Expr *E, LValue &Result,
3106 const CXXRecordDecl *DerivedRD,
3107 const CXXRecordDecl *BaseRD) {
3108 CXXBasePaths Paths(/*FindAmbiguities=*/false,
3109 /*RecordPaths=*/true, /*DetectVirtual=*/false);
3110 if (!DerivedRD->isDerivedFrom(BaseRD, Paths))
3111 llvm_unreachable("Class must be derived from the passed in base class!")__builtin_unreachable();
3112
3113 for (CXXBasePathElement &Elem : Paths.front())
3114 if (!HandleLValueBase(Info, E, Result, Elem.Class, Elem.Base))
3115 return false;
3116 return true;
3117}
3118
3119/// Update LVal to refer to the given field, which must be a member of the type
3120/// currently described by LVal.
3121static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
3122 const FieldDecl *FD,
3123 const ASTRecordLayout *RL = nullptr) {
3124 if (!RL) {
3125 if (FD->getParent()->isInvalidDecl()) return false;
3126 RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
3127 }
3128
3129 unsigned I = FD->getFieldIndex();
3130 LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
3131 LVal.addDecl(Info, E, FD);
3132 return true;
3133}
3134
3135/// Update LVal to refer to the given indirect field.
3136static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
3137 LValue &LVal,
3138 const IndirectFieldDecl *IFD) {
3139 for (const auto *C : IFD->chain())
3140 if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
3141 return false;
3142 return true;
3143}
3144
3145/// Get the size of the given type in char units.
3146static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
3147 QualType Type, CharUnits &Size) {
3148 // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
3149 // extension.
3150 if (Type->isVoidType() || Type->isFunctionType()) {
3151 Size = CharUnits::One();
3152 return true;
3153 }
3154
3155 if (Type->isDependentType()) {
3156 Info.FFDiag(Loc);
3157 return false;
3158 }
3159
3160 if (!Type->isConstantSizeType()) {
3161 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2.
3162 // FIXME: Better diagnostic.
3163 Info.FFDiag(Loc);
3164 return false;
3165 }
3166
3167 Size = Info.Ctx.getTypeSizeInChars(Type);
3168 return true;
3169}
3170
3171/// Update a pointer value to model pointer arithmetic.
3172/// \param Info - Information about the ongoing evaluation.
3173/// \param E - The expression being evaluated, for diagnostic purposes.
3174/// \param LVal - The pointer value to be updated.
3175/// \param EltTy - The pointee type represented by LVal.
3176/// \param Adjustment - The adjustment, in objects of type EltTy, to add.
3177static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
3178 LValue &LVal, QualType EltTy,
3179 APSInt Adjustment) {
3180 CharUnits SizeOfPointee;
3181 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
3182 return false;
3183
3184 LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
3185 return true;
3186}
3187
3188static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
3189 LValue &LVal, QualType EltTy,
3190 int64_t Adjustment) {
3191 return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
3192 APSInt::get(Adjustment));
3193}
3194
3195/// Update an lvalue to refer to a component of a complex number.
3196/// \param Info - Information about the ongoing evaluation.
3197/// \param LVal - The lvalue to be updated.
3198/// \param EltTy - The complex number's component type.
3199/// \param Imag - False for the real component, true for the imaginary.
3200static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
3201 LValue &LVal, QualType EltTy,
3202 bool Imag) {
3203 if (Imag) {
3204 CharUnits SizeOfComponent;
3205 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
3206 return false;
3207 LVal.Offset += SizeOfComponent;
3208 }
3209 LVal.addComplex(Info, E, EltTy, Imag);
3210 return true;
3211}
3212
3213/// Try to evaluate the initializer for a variable declaration.
3214///
3215/// \param Info Information about the ongoing evaluation.
3216/// \param E An expression to be used when printing diagnostics.
3217/// \param VD The variable whose initializer should be obtained.
3218/// \param Version The version of the variable within the frame.
3219/// \param Frame The frame in which the variable was created. Must be null
3220/// if this variable is not local to the evaluation.
3221/// \param Result Filled in with a pointer to the value of the variable.
3222static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
3223 const VarDecl *VD, CallStackFrame *Frame,
3224 unsigned Version, APValue *&Result) {
3225 APValue::LValueBase Base(VD, Frame ? Frame->Index : 0, Version);
3226
3227 // If this is a local variable, dig out its value.
3228 if (Frame) {
3229 Result = Frame->getTemporary(VD, Version);
3230 if (Result)
3231 return true;
3232
3233 if (!isa<ParmVarDecl>(VD)) {
3234 // Assume variables referenced within a lambda's call operator that were
3235 // not declared within the call operator are captures and during checking
3236 // of a potential constant expression, assume they are unknown constant
3237 // expressions.
3238 assert(isLambdaCallOperator(Frame->Callee) &&((void)0)
3239 (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) &&((void)0)
3240 "missing value for local variable")((void)0);
3241 if (Info.checkingPotentialConstantExpression())
3242 return false;
3243 // FIXME: This diagnostic is bogus; we do support captures. Is this code
3244 // still reachable at all?
3245 Info.FFDiag(E->getBeginLoc(),
3246 diag::note_unimplemented_constexpr_lambda_feature_ast)
3247 << "captures not currently allowed";
3248 return false;
3249 }
3250 }
3251
3252 // If we're currently evaluating the initializer of this declaration, use that
3253 // in-flight value.
3254 if (Info.EvaluatingDecl == Base) {
3255 Result = Info.EvaluatingDeclValue;
3256 return true;
3257 }
3258
3259 if (isa<ParmVarDecl>(VD)) {
3260 // Assume parameters of a potential constant expression are usable in
3261 // constant expressions.
3262 if (!Info.checkingPotentialConstantExpression() ||
3263 !Info.CurrentCall->Callee ||
3264 !Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
3265 if (Info.getLangOpts().CPlusPlus11) {
3266 Info.FFDiag(E, diag::note_constexpr_function_param_value_unknown)
3267 << VD;
3268 NoteLValueLocation(Info, Base);
3269 } else {
3270 Info.FFDiag(E);
3271 }
3272 }
3273 return false;
3274 }
3275
3276 // Dig out the initializer, and use the declaration which it's attached to.
3277 // FIXME: We should eventually check whether the variable has a reachable
3278 // initializing declaration.
3279 const Expr *Init = VD->getAnyInitializer(VD);
3280 if (!Init) {
3281 // Don't diagnose during potential constant expression checking; an
3282 // initializer might be added later.
3283 if (!Info.checkingPotentialConstantExpression()) {
3284 Info.FFDiag(E, diag::note_constexpr_var_init_unknown, 1)
3285 << VD;
3286 NoteLValueLocation(Info, Base);
3287 }
3288 return false;
3289 }
3290
3291 if (Init->isValueDependent()) {
3292 // The DeclRefExpr is not value-dependent, but the variable it refers to
3293 // has a value-dependent initializer. This should only happen in
3294 // constant-folding cases, where the variable is not actually of a suitable
3295 // type for use in a constant expression (otherwise the DeclRefExpr would
3296 // have been value-dependent too), so diagnose that.
3297 assert(!VD->mightBeUsableInConstantExpressions(Info.Ctx))((void)0);
3298 if (!Info.checkingPotentialConstantExpression()) {
3299 Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
3300 ? diag::note_constexpr_ltor_non_constexpr
3301 : diag::note_constexpr_ltor_non_integral, 1)
3302 << VD << VD->getType();
3303 NoteLValueLocation(Info, Base);
3304 }
3305 return false;
3306 }
3307
3308 // Check that we can fold the initializer. In C++, we will have already done
3309 // this in the cases where it matters for conformance.
3310 if (!VD->evaluateValue()) {
3311 Info.FFDiag(E, diag::note_constexpr_var_init_non_constant, 1) << VD;
3312 NoteLValueLocation(Info, Base);
3313 return false;
3314 }
3315
3316 // Check that the variable is actually usable in constant expressions. For a
3317 // const integral variable or a reference, we might have a non-constant
3318 // initializer that we can nonetheless evaluate the initializer for. Such
3319 // variables are not usable in constant expressions. In C++98, the
3320 // initializer also syntactically needs to be an ICE.
3321 //
3322 // FIXME: We don't diagnose cases that aren't potentially usable in constant
3323 // expressions here; doing so would regress diagnostics for things like
3324 // reading from a volatile constexpr variable.
3325 if ((Info.getLangOpts().CPlusPlus && !VD->hasConstantInitialization() &&
3326 VD->mightBeUsableInConstantExpressions(Info.Ctx)) ||
3327 ((Info.getLangOpts().CPlusPlus || Info.getLangOpts().OpenCL) &&
3328 !Info.getLangOpts().CPlusPlus11 && !VD->hasICEInitializer(Info.Ctx))) {
3329 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant, 1) << VD;
3330 NoteLValueLocation(Info, Base);
3331 }
3332
3333 // Never use the initializer of a weak variable, not even for constant
3334 // folding. We can't be sure that this is the definition that will be used.
3335 if (VD->isWeak()) {
3336 Info.FFDiag(E, diag::note_constexpr_var_init_weak) << VD;
3337 NoteLValueLocation(Info, Base);
3338 return false;
3339 }
3340
3341 Result = VD->getEvaluatedValue();
3342 return true;
3343}
3344
3345/// Get the base index of the given base class within an APValue representing
3346/// the given derived class.
3347static unsigned getBaseIndex(const CXXRecordDecl *Derived,
3348 const CXXRecordDecl *Base) {
3349 Base = Base->getCanonicalDecl();
3350 unsigned Index = 0;
3351 for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(),
3352 E = Derived->bases_end(); I != E; ++I, ++Index) {
3353 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
3354 return Index;
3355 }
3356
3357 llvm_unreachable("base class missing from derived class's bases list")__builtin_unreachable();
3358}
3359
3360/// Extract the value of a character from a string literal.
3361static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
3362 uint64_t Index) {
3363 assert(!isa<SourceLocExpr>(Lit) &&((void)0)
3364 "SourceLocExpr should have already been converted to a StringLiteral")((void)0);
3365
3366 // FIXME: Support MakeStringConstant
3367 if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
3368 std::string Str;
3369 Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
3370 assert(Index <= Str.size() && "Index too large")((void)0);
3371 return APSInt::getUnsigned(Str.c_str()[Index]);
3372 }
3373
3374 if (auto PE = dyn_cast<PredefinedExpr>(Lit))
3375 Lit = PE->getFunctionName();
3376 const StringLiteral *S = cast<StringLiteral>(Lit);
3377 const ConstantArrayType *CAT =
3378 Info.Ctx.getAsConstantArrayType(S->getType());
3379 assert(CAT && "string literal isn't an array")((void)0);
3380 QualType CharType = CAT->getElementType();
3381 assert(CharType->isIntegerType() && "unexpected character type")((void)0);
3382
3383 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
3384 CharType->isUnsignedIntegerType());
3385 if (Index < S->getLength())
3386 Value = S->getCodeUnit(Index);
3387 return Value;
3388}
3389
3390// Expand a string literal into an array of characters.
3391//
3392// FIXME: This is inefficient; we should probably introduce something similar
3393// to the LLVM ConstantDataArray to make this cheaper.
3394static void expandStringLiteral(EvalInfo &Info, const StringLiteral *S,
3395 APValue &Result,
3396 QualType AllocType = QualType()) {
3397 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
3398 AllocType.isNull() ? S->getType() : AllocType);
3399 assert(CAT && "string literal isn't an array")((void)0);
3400 QualType CharType = CAT->getElementType();
3401 assert(CharType->isIntegerType() && "unexpected character type")((void)0);
3402
3403 unsigned Elts = CAT->getSize().getZExtValue();
3404 Result = APValue(APValue::UninitArray(),
3405 std::min(S->getLength(), Elts), Elts);
3406 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
3407 CharType->isUnsignedIntegerType());
3408 if (Result.hasArrayFiller())
3409 Result.getArrayFiller() = APValue(Value);
3410 for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) {
3411 Value = S->getCodeUnit(I);
3412 Result.getArrayInitializedElt(I) = APValue(Value);
3413 }
3414}
3415
3416// Expand an array so that it has more than Index filled elements.
3417static void expandArray(APValue &Array, unsigned Index) {
3418 unsigned Size = Array.getArraySize();
3419 assert(Index < Size)((void)0);
3420
3421 // Always at least double the number of elements for which we store a value.
3422 unsigned OldElts = Array.getArrayInitializedElts();
3423 unsigned NewElts = std::max(Index+1, OldElts * 2);
3424 NewElts = std::min(Size, std::max(NewElts, 8u));
3425
3426 // Copy the data across.
3427 APValue NewValue(APValue::UninitArray(), NewElts, Size);
3428 for (unsigned I = 0; I != OldElts; ++I)
3429 NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I));
3430 for (unsigned I = OldElts; I != NewElts; ++I)
3431 NewValue.getArrayInitializedElt(I) = Array.getArrayFiller();
3432 if (NewValue.hasArrayFiller())
3433 NewValue.getArrayFiller() = Array.getArrayFiller();
3434 Array.swap(NewValue);
3435}
3436
3437/// Determine whether a type would actually be read by an lvalue-to-rvalue
3438/// conversion. If it's of class type, we may assume that the copy operation
3439/// is trivial. Note that this is never true for a union type with fields
3440/// (because the copy always "reads" the active member) and always true for
3441/// a non-class type.
3442static bool isReadByLvalueToRvalueConversion(const CXXRecordDecl *RD);
3443static bool isReadByLvalueToRvalueConversion(QualType T) {
3444 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3445 return !RD || isReadByLvalueToRvalueConversion(RD);
3446}
3447static bool isReadByLvalueToRvalueConversion(const CXXRecordDecl *RD) {
3448 // FIXME: A trivial copy of a union copies the object representation, even if
3449 // the union is empty.
3450 if (RD->isUnion())
38
Calling 'TagDecl::isUnion'
41
Returning from 'TagDecl::isUnion'
42
Taking true branch
3451 return !RD->field_empty();
43
Calling 'RecordDecl::field_empty'
52
Returning from 'RecordDecl::field_empty'
53
Returning the value 1, which participates in a condition later
3452 if (RD->isEmpty())
3453 return false;
3454
3455 for (auto *Field : RD->fields())
3456 if (!Field->isUnnamedBitfield() &&
3457 isReadByLvalueToRvalueConversion(Field->getType()))
3458 return true;
3459
3460 for (auto &BaseSpec : RD->bases())
3461 if (isReadByLvalueToRvalueConversion(BaseSpec.getType()))
3462 return true;
3463
3464 return false;
3465}
3466
3467/// Diagnose an attempt to read from any unreadable field within the specified
3468/// type, which might be a class type.
3469static bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK,
3470 QualType T) {
3471 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
3472 if (!RD)
3473 return false;
3474
3475 if (!RD->hasMutableFields())
3476 return false;
3477
3478 for (auto *Field : RD->fields()) {
3479 // If we're actually going to read this field in some way, then it can't
3480 // be mutable. If we're in a union, then assigning to a mutable field
3481 // (even an empty one) can change the active member, so that's not OK.
3482 // FIXME: Add core issue number for the union case.
3483 if (Field->isMutable() &&
3484 (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {
3485 Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) << AK << Field;
3486 Info.Note(Field->getLocation(), diag::note_declared_at);
3487 return true;
3488 }
3489
3490 if (diagnoseMutableFields(Info, E, AK, Field->getType()))
3491 return true;
3492 }
3493
3494 for (auto &BaseSpec : RD->bases())
3495 if (diagnoseMutableFields(Info, E, AK, BaseSpec.getType()))
3496 return true;
3497
3498 // All mutable fields were empty, and thus not actually read.
3499 return false;
3500}
3501
3502static bool lifetimeStartedInEvaluation(EvalInfo &Info,
3503 APValue::LValueBase Base,
3504 bool MutableSubobject = false) {
3505 // A temporary or transient heap allocation we created.
3506 if (Base.getCallIndex() || Base.is<DynamicAllocLValue>())
3507 return true;
3508
3509 switch (Info.IsEvaluatingDecl) {
3510 case EvalInfo::EvaluatingDeclKind::None:
3511 return false;
3512
3513 case EvalInfo::EvaluatingDeclKind::Ctor:
3514 // The variable whose initializer we're evaluating.
3515 if (Info.EvaluatingDecl == Base)
3516 return true;
3517
3518 // A temporary lifetime-extended by the variable whose initializer we're
3519 // evaluating.
3520 if (auto *BaseE = Base.dyn_cast<const Expr *>())
3521 if (auto *BaseMTE = dyn_cast<MaterializeTemporaryExpr>(BaseE))
3522 return Info.EvaluatingDecl == BaseMTE->getExtendingDecl();
3523 return false;
3524
3525 case EvalInfo::EvaluatingDeclKind::Dtor:
3526 // C++2a [expr.const]p6:
3527 // [during constant destruction] the lifetime of a and its non-mutable
3528 // subobjects (but not its mutable subobjects) [are] considered to start
3529 // within e.
3530 if (MutableSubobject || Base != Info.EvaluatingDecl)
3531 return false;
3532 // FIXME: We can meaningfully extend this to cover non-const objects, but
3533 // we will need special handling: we should be able to access only
3534 // subobjects of such objects that are themselves declared const.
3535 QualType T = getType(Base);
3536 return T.isConstQualified() || T->isReferenceType();
3537 }
3538
3539 llvm_unreachable("unknown evaluating decl kind")__builtin_unreachable();
3540}
3541
3542namespace {
3543/// A handle to a complete object (an object that is not a subobject of
3544/// another object).
3545struct CompleteObject {
3546 /// The identity of the object.
3547 APValue::LValueBase Base;
3548 /// The value of the complete object.
3549 APValue *Value;
3550 /// The type of the complete object.
3551 QualType Type;
3552
3553 CompleteObject() : Value(nullptr) {}
3554 CompleteObject(APValue::LValueBase Base, APValue *Value, QualType Type)
3555 : Base(Base), Value(Value), Type(Type) {}
3556
3557 bool mayAccessMutableMembers(EvalInfo &Info, AccessKinds AK) const {
3558 // If this isn't a "real" access (eg, if it's just accessing the type
3559 // info), allow it. We assume the type doesn't change dynamically for
3560 // subobjects of constexpr objects (even though we'd hit UB here if it
3561 // did). FIXME: Is this right?
3562 if (!isAnyAccess(AK))
3563 return true;
3564
3565 // In C++14 onwards, it is permitted to read a mutable member whose
3566 // lifetime began within the evaluation.
3567 // FIXME: Should we also allow this in C++11?
3568 if (!Info.getLangOpts().CPlusPlus14)
3569 return false;
3570 return lifetimeStartedInEvaluation(Info, Base, /*MutableSubobject*/true);
3571 }
3572
3573 explicit operator bool() const { return !Type.isNull(); }
3574};
3575} // end anonymous namespace
3576
3577static QualType getSubobjectType(QualType ObjType, QualType SubobjType,
3578 bool IsMutable = false) {
3579 // C++ [basic.type.qualifier]p1:
3580 // - A const object is an object of type const T or a non-mutable subobject
3581 // of a const object.
3582 if (ObjType.isConstQualified() && !IsMutable)
3583 SubobjType.addConst();
3584 // - A volatile object is an object of type const T or a subobject of a
3585 // volatile object.
3586 if (ObjType.isVolatileQualified())
3587 SubobjType.addVolatile();
3588 return SubobjType;
3589}
3590
3591/// Find the designated sub-object of an rvalue.
3592template<typename SubobjectHandler>
3593typename SubobjectHandler::result_type
3594findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
3595 const SubobjectDesignator &Sub, SubobjectHandler &handler) {
3596 if (Sub.Invalid)
3597 // A diagnostic will have already been produced.
3598 return handler.failed();
3599 if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {
3600 if (Info.getLangOpts().CPlusPlus11)
3601 Info.FFDiag(E, Sub.isOnePastTheEnd()
3602 ? diag::note_constexpr_access_past_end
3603 : diag::note_constexpr_access_unsized_array)
3604 << handler.AccessKind;
3605 else
3606 Info.FFDiag(E);
3607 return handler.failed();
3608 }
3609
3610 APValue *O = Obj.Value;
3611 QualType ObjType = Obj.Type;
3612 const FieldDecl *LastField = nullptr;
3613 const FieldDecl *VolatileField = nullptr;
3614
3615 // Walk the designator's path to find the subobject.
3616 for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
3617 // Reading an indeterminate value is undefined, but assigning over one is OK.
3618 if ((O->isAbsent() && !(handler.AccessKind == AK_Construct && I == N)) ||
3619 (O->isIndeterminate() &&
3620 !isValidIndeterminateAccess(handler.AccessKind))) {
3621 if (!Info.checkingPotentialConstantExpression())
3622 Info.FFDiag(E, diag::note_constexpr_access_uninit)
3623 << handler.AccessKind << O->isIndeterminate();
3624 return handler.failed();
3625 }
3626
3627 // C++ [class.ctor]p5, C++ [class.dtor]p5:
3628 // const and volatile semantics are not applied on an object under
3629 // {con,de}struction.
3630 if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) &&
3631 ObjType->isRecordType() &&
3632 Info.isEvaluatingCtorDtor(
3633 Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(),
3634 Sub.Entries.begin() + I)) !=
3635 ConstructionPhase::None) {
3636 ObjType = Info.Ctx.getCanonicalType(ObjType);
3637 ObjType.removeLocalConst();
3638 ObjType.removeLocalVolatile();
3639 }
3640
3641 // If this is our last pass, check that the final object type is OK.
3642 if (I == N || (I == N - 1 && ObjType->isAnyComplexType())) {
3643 // Accesses to volatile objects are prohibited.
3644 if (ObjType.isVolatileQualified() && isFormalAccess(handler.AccessKind)) {
3645 if (Info.getLangOpts().CPlusPlus) {
3646 int DiagKind;
3647 SourceLocation Loc;
3648 const NamedDecl *Decl = nullptr;
3649 if (VolatileField) {
3650 DiagKind = 2;
3651 Loc = VolatileField->getLocation();
3652 Decl = VolatileField;
3653 } else if (auto *VD = Obj.Base.dyn_cast<const ValueDecl*>()) {
3654 DiagKind = 1;
3655 Loc = VD->getLocation();
3656 Decl = VD;
3657 } else {
3658 DiagKind = 0;
3659 if (auto *E = Obj.Base.dyn_cast<const Expr *>())
3660 Loc = E->getExprLoc();
3661 }
3662 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3663 << handler.AccessKind << DiagKind << Decl;
3664 Info.Note(Loc, diag::note_constexpr_volatile_here) << DiagKind;
3665 } else {
3666 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
3667 }
3668 return handler.failed();
3669 }
3670
3671 // If we are reading an object of class type, there may still be more
3672 // things we need to check: if there are any mutable subobjects, we
3673 // cannot perform this read. (This only happens when performing a trivial
3674 // copy or assignment.)
3675 if (ObjType->isRecordType() &&
3676 !Obj.mayAccessMutableMembers(Info, handler.AccessKind) &&
3677 diagnoseMutableFields(Info, E, handler.AccessKind, ObjType))
3678 return handler.failed();
3679 }
3680
3681 if (I == N) {
3682 if (!handler.found(*O, ObjType))
3683 return false;
3684
3685 // If we modified a bit-field, truncate it to the right width.
3686 if (isModification(handler.AccessKind) &&
3687 LastField && LastField->isBitField() &&
3688 !truncateBitfieldValue(Info, E, *O, LastField))
3689 return false;
3690
3691 return true;
3692 }
3693
3694 LastField = nullptr;
3695 if (ObjType->isArrayType()) {
3696 // Next subobject is an array element.
3697 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
3698 assert(CAT && "vla in literal type?")((void)0);
3699 uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3700 if (CAT->getSize().ule(Index)) {
3701 // Note, it should not be possible to form a pointer with a valid
3702 // designator which points more than one past the end of the array.
3703 if (Info.getLangOpts().CPlusPlus11)
3704 Info.FFDiag(E, diag::note_constexpr_access_past_end)
3705 << handler.AccessKind;
3706 else
3707 Info.FFDiag(E);
3708 return handler.failed();
3709 }
3710
3711 ObjType = CAT->getElementType();
3712
3713 if (O->getArrayInitializedElts() > Index)
3714 O = &O->getArrayInitializedElt(Index);
3715 else if (!isRead(handler.AccessKind)) {
3716 expandArray(*O, Index);
3717 O = &O->getArrayInitializedElt(Index);
3718 } else
3719 O = &O->getArrayFiller();
3720 } else if (ObjType->isAnyComplexType()) {
3721 // Next subobject is a complex number.
3722 uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3723 if (Index > 1) {
3724 if (Info.getLangOpts().CPlusPlus11)
3725 Info.FFDiag(E, diag::note_constexpr_access_past_end)
3726 << handler.AccessKind;
3727 else
3728 Info.FFDiag(E);
3729 return handler.failed();
3730 }
3731
3732 ObjType = getSubobjectType(
3733 ObjType, ObjType->castAs<ComplexType>()->getElementType());
3734
3735 assert(I == N - 1 && "extracting subobject of scalar?")((void)0);
3736 if (O->isComplexInt()) {
3737 return handler.found(Index ? O->getComplexIntImag()
3738 : O->getComplexIntReal(), ObjType);
3739 } else {
3740 assert(O->isComplexFloat())((void)0);
3741 return handler.found(Index ? O->getComplexFloatImag()
3742 : O->getComplexFloatReal(), ObjType);
3743 }
3744 } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
3745 if (Field->isMutable() &&
3746 !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {
3747 Info.FFDiag(E, diag::note_constexpr_access_mutable, 1)
3748 << handler.AccessKind << Field;
3749 Info.Note(Field->getLocation(), diag::note_declared_at);
3750 return handler.failed();
3751 }
3752
3753 // Next subobject is a class, struct or union field.
3754 RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
3755 if (RD->isUnion()) {
3756 const FieldDecl *UnionField = O->getUnionField();
3757 if (!UnionField ||
3758 UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
3759 if (I == N - 1 && handler.AccessKind == AK_Construct) {
3760 // Placement new onto an inactive union member makes it active.
3761 O->setUnion(Field, APValue());
3762 } else {
3763 // FIXME: If O->getUnionValue() is absent, report that there's no
3764 // active union member rather than reporting the prior active union
3765 // member. We'll need to fix nullptr_t to not use APValue() as its
3766 // representation first.
3767 Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
3768 << handler.AccessKind << Field << !UnionField << UnionField;
3769 return handler.failed();
3770 }
3771 }
3772 O = &O->getUnionValue();
3773 } else
3774 O = &O->getStructField(Field->getFieldIndex());
3775
3776 ObjType = getSubobjectType(ObjType, Field->getType(), Field->isMutable());
3777 LastField = Field;
3778 if (Field->getType().isVolatileQualified())
3779 VolatileField = Field;
3780 } else {
3781 // Next subobject is a base class.
3782 const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
3783 const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
3784 O = &O->getStructBase(getBaseIndex(Derived, Base));
3785
3786 ObjType = getSubobjectType(ObjType, Info.Ctx.getRecordType(Base));
3787 }
3788 }
3789}
3790
3791namespace {
3792struct ExtractSubobjectHandler {
3793 EvalInfo &Info;
3794 const Expr *E;
3795 APValue &Result;
3796 const AccessKinds AccessKind;
3797
3798 typedef bool result_type;
3799 bool failed() { return false; }
3800 bool found(APValue &Subobj, QualType SubobjType) {
3801 Result = Subobj;
3802 if (AccessKind == AK_ReadObjectRepresentation)
3803 return true;
3804 return CheckFullyInitialized(Info, E->getExprLoc(), SubobjType, Result);
3805 }
3806 bool found(APSInt &Value, QualType SubobjType) {
3807 Result = APValue(Value);
3808 return true;
3809 }
3810 bool found(APFloat &Value, QualType SubobjType) {
3811 Result = APValue(Value);
3812 return true;
3813 }
3814};
3815} // end anonymous namespace
3816
3817/// Extract the designated sub-object of an rvalue.
3818static bool extractSubobject(EvalInfo &Info, const Expr *E,
3819 const CompleteObject &Obj,
3820 const SubobjectDesignator &Sub, APValue &Result,
3821 AccessKinds AK = AK_Read) {
3822 assert(AK == AK_Read || AK == AK_ReadObjectRepresentation)((void)0);
3823 ExtractSubobjectHandler Handler = {Info, E, Result, AK};
3824 return findSubobject(Info, E, Obj, Sub, Handler);
3825}
3826
3827namespace {
3828struct ModifySubobjectHandler {
3829 EvalInfo &Info;
3830 APValue &NewVal;
3831 const Expr *E;
3832
3833 typedef bool result_type;
3834 static const AccessKinds AccessKind = AK_Assign;
3835
3836 bool checkConst(QualType QT) {
3837 // Assigning to a const object has undefined behavior.
3838 if (QT.isConstQualified()) {
3839 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3840 return false;
3841 }
3842 return true;
3843 }
3844
3845 bool failed() { return false; }
3846 bool found(APValue &Subobj, QualType SubobjType) {
3847 if (!checkConst(SubobjType))
3848 return false;
3849 // We've been given ownership of NewVal, so just swap it in.
3850 Subobj.swap(NewVal);
3851 return true;
3852 }
3853 bool found(APSInt &Value, QualType SubobjType) {
3854 if (!checkConst(SubobjType))
3855 return false;
3856 if (!NewVal.isInt()) {
3857 // Maybe trying to write a cast pointer value into a complex?
3858 Info.FFDiag(E);
3859 return false;
3860 }
3861 Value = NewVal.getInt();
3862 return true;
3863 }
3864 bool found(APFloat &Value, QualType SubobjType) {
3865 if (!checkConst(SubobjType))
3866 return false;
3867 Value = NewVal.getFloat();
3868 return true;
3869 }
3870};
3871} // end anonymous namespace
3872
3873const AccessKinds ModifySubobjectHandler::AccessKind;
3874
3875/// Update the designated sub-object of an rvalue to the given value.
3876static bool modifySubobject(EvalInfo &Info, const Expr *E,
3877 const CompleteObject &Obj,
3878 const SubobjectDesignator &Sub,
3879 APValue &NewVal) {
3880 ModifySubobjectHandler Handler = { Info, NewVal, E };
3881 return findSubobject(Info, E, Obj, Sub, Handler);
3882}
3883
3884/// Find the position where two subobject designators diverge, or equivalently
3885/// the length of the common initial subsequence.
3886static unsigned FindDesignatorMismatch(QualType ObjType,
3887 const SubobjectDesignator &A,
3888 const SubobjectDesignator &B,
3889 bool &WasArrayIndex) {
3890 unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
3891 for (/**/; I != N; ++I) {
3892 if (!ObjType.isNull() &&
3893 (ObjType->isArrayType() || ObjType->isAnyComplexType())) {
3894 // Next subobject is an array element.
3895 if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) {
3896 WasArrayIndex = true;
3897 return I;
3898 }
3899 if (ObjType->isAnyComplexType())
3900 ObjType = ObjType->castAs<ComplexType>()->getElementType();
3901 else
3902 ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType();
3903 } else {
3904 if (A.Entries[I].getAsBaseOrMember() !=
3905 B.Entries[I].getAsBaseOrMember()) {
3906 WasArrayIndex = false;
3907 return I;
3908 }
3909 if (const FieldDecl *FD = getAsField(A.Entries[I]))
3910 // Next subobject is a field.
3911 ObjType = FD->getType();
3912 else
3913 // Next subobject is a base class.
3914 ObjType = QualType();
3915 }
3916 }
3917 WasArrayIndex = false;
3918 return I;
3919}
3920
3921/// Determine whether the given subobject designators refer to elements of the
3922/// same array object.
3923static bool AreElementsOfSameArray(QualType ObjType,
3924 const SubobjectDesignator &A,
3925 const SubobjectDesignator &B) {
3926 if (A.Entries.size() != B.Entries.size())
3927 return false;
3928
3929 bool IsArray = A.MostDerivedIsArrayElement;
3930 if (IsArray && A.MostDerivedPathLength != A.Entries.size())
3931 // A is a subobject of the array element.
3932 return false;
3933
3934 // If A (and B) designates an array element, the last entry will be the array
3935 // index. That doesn't have to match. Otherwise, we're in the 'implicit array
3936 // of length 1' case, and the entire path must match.
3937 bool WasArrayIndex;
3938 unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex);
3939 return CommonLength >= A.Entries.size() - IsArray;
3940}
3941
3942/// Find the complete object to which an LValue refers.
3943static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
3944 AccessKinds AK, const LValue &LVal,
3945 QualType LValType) {
3946 if (LVal.InvalidBase) {
3947 Info.FFDiag(E);
3948 return CompleteObject();
3949 }
3950
3951 if (!LVal.Base) {
3952 Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
3953 return CompleteObject();
3954 }
3955
3956 CallStackFrame *Frame = nullptr;
3957 unsigned Depth = 0;
3958 if (LVal.getLValueCallIndex()) {
3959 std::tie(Frame, Depth) =
3960 Info.getCallFrameAndDepth(LVal.getLValueCallIndex());
3961 if (!Frame) {
3962 Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
3963 << AK << LVal.Base.is<const ValueDecl*>();
3964 NoteLValueLocation(Info, LVal.Base);
3965 return CompleteObject();
3966 }
3967 }
3968
3969 bool IsAccess = isAnyAccess(AK);
3970
3971 // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type
3972 // is not a constant expression (even if the object is non-volatile). We also
3973 // apply this rule to C++98, in order to conform to the expected 'volatile'
3974 // semantics.
3975 if (isFormalAccess(AK) && LValType.isVolatileQualified()) {
3976 if (Info.getLangOpts().CPlusPlus)
3977 Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
3978 << AK << LValType;
3979 else
3980 Info.FFDiag(E);
3981 return CompleteObject();
3982 }
3983
3984 // Compute value storage location and type of base object.
3985 APValue *BaseVal = nullptr;
3986 QualType BaseType = getType(LVal.Base);
3987
3988 if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl &&
3989 lifetimeStartedInEvaluation(Info, LVal.Base)) {
3990 // This is the object whose initializer we're evaluating, so its lifetime
3991 // started in the current evaluation.
3992 BaseVal = Info.EvaluatingDeclValue;
3993 } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {
3994 // Allow reading from a GUID declaration.
3995 if (auto *GD = dyn_cast<MSGuidDecl>(D)) {
3996 if (isModification(AK)) {
3997 // All the remaining cases do not permit modification of the object.
3998 Info.FFDiag(E, diag::note_constexpr_modify_global);
3999 return CompleteObject();
4000 }
4001 APValue &V = GD->getAsAPValue();
4002 if (V.isAbsent()) {
4003 Info.FFDiag(E, diag::note_constexpr_unsupported_layout)
4004 << GD->getType();
4005 return CompleteObject();
4006 }
4007 return CompleteObject(LVal.Base, &V, GD->getType());
4008 }
4009
4010 // Allow reading from template parameter objects.
4011 if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {
4012 if (isModification(AK)) {
4013 Info.FFDiag(E, diag::note_constexpr_modify_global);
4014 return CompleteObject();
4015 }
4016 return CompleteObject(LVal.Base, const_cast<APValue *>(&TPO->getValue()),
4017 TPO->getType());
4018 }
4019
4020 // In C++98, const, non-volatile integers initialized with ICEs are ICEs.
4021 // In C++11, constexpr, non-volatile variables initialized with constant
4022 // expressions are constant expressions too. Inside constexpr functions,
4023 // parameters are constant expressions even if they're non-const.
4024 // In C++1y, objects local to a constant expression (those with a Frame) are
4025 // both readable and writable inside constant expressions.
4026 // In C, such things can also be folded, although they are not ICEs.
4027 const VarDecl *VD = dyn_cast<VarDecl>(D);
4028 if (VD) {
4029 if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
4030 VD = VDef;
4031 }
4032 if (!VD || VD->isInvalidDecl()) {
4033 Info.FFDiag(E);
4034 return CompleteObject();
4035 }
4036
4037 bool IsConstant = BaseType.isConstant(Info.Ctx);
4038
4039 // Unless we're looking at a local variable or argument in a constexpr call,
4040 // the variable we're reading must be const.
4041 if (!Frame) {
4042 if (IsAccess && isa<ParmVarDecl>(VD)) {
4043 // Access of a parameter that's not associated with a frame isn't going
4044 // to work out, but we can leave it to evaluateVarDeclInit to provide a
4045 // suitable diagnostic.
4046 } else if (Info.getLangOpts().CPlusPlus14 &&
4047 lifetimeStartedInEvaluation(Info, LVal.Base)) {
4048 // OK, we can read and modify an object if we're in the process of
4049 // evaluating its initializer, because its lifetime began in this
4050 // evaluation.
4051 } else if (isModification(AK)) {
4052 // All the remaining cases do not permit modification of the object.
4053 Info.FFDiag(E, diag::note_constexpr_modify_global);
4054 return CompleteObject();
4055 } else if (VD->isConstexpr()) {
4056 // OK, we can read this variable.
4057 } else if (BaseType->isIntegralOrEnumerationType()) {
4058 if (!IsConstant) {
4059 if (!IsAccess)
4060 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
4061 if (Info.getLangOpts().CPlusPlus) {
4062 Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
4063 Info.Note(VD->getLocation(), diag::note_declared_at);
4064 } else {
4065 Info.FFDiag(E);
4066 }
4067 return CompleteObject();
4068 }
4069 } else if (!IsAccess) {
4070 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
4071 } else if (IsConstant && Info.checkingPotentialConstantExpression() &&
4072 BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {
4073 // This variable might end up being constexpr. Don't diagnose it yet.
4074 } else if (IsConstant) {
4075 // Keep evaluating to see what we can do. In particular, we support
4076 // folding of const floating-point types, in order to make static const
4077 // data members of such types (supported as an extension) more useful.
4078 if (Info.getLangOpts().CPlusPlus) {
4079 Info.CCEDiag(E, Info.getLangOpts().CPlusPlus11
4080 ? diag::note_constexpr_ltor_non_constexpr
4081 : diag::note_constexpr_ltor_non_integral, 1)
4082 << VD << BaseType;
4083 Info.Note(VD->getLocation(), diag::note_declared_at);
4084 } else {
4085 Info.CCEDiag(E);
4086 }
4087 } else {
4088 // Never allow reading a non-const value.
4089 if (Info.getLangOpts().CPlusPlus) {
4090 Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
4091 ? diag::note_constexpr_ltor_non_constexpr
4092 : diag::note_constexpr_ltor_non_integral, 1)
4093 << VD << BaseType;
4094 Info.Note(VD->getLocation(), diag::note_declared_at);
4095 } else {
4096 Info.FFDiag(E);
4097 }
4098 return CompleteObject();
4099 }
4100 }
4101
4102 if (!evaluateVarDeclInit(Info, E, VD, Frame, LVal.getLValueVersion(), BaseVal))
4103 return CompleteObject();
4104 } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {
4105 Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA);
4106 if (!Alloc) {
4107 Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK;
4108 return CompleteObject();
4109 }
4110 return CompleteObject(LVal.Base, &(*Alloc)->Value,
4111 LVal.Base.getDynamicAllocType());
4112 } else {
4113 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
4114
4115 if (!Frame) {
4116 if (const MaterializeTemporaryExpr *MTE =
4117 dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {
4118 assert(MTE->getStorageDuration() == SD_Static &&((void)0)
4119 "should have a frame for a non-global materialized temporary")((void)0);
4120
4121 // C++20 [expr.const]p4: [DR2126]
4122 // An object or reference is usable in constant expressions if it is
4123 // - a temporary object of non-volatile const-qualified literal type
4124 // whose lifetime is extended to that of a variable that is usable
4125 // in constant expressions
4126 //
4127 // C++20 [expr.const]p5:
4128 // an lvalue-to-rvalue conversion [is not allowed unless it applies to]
4129 // - a non-volatile glvalue that refers to an object that is usable
4130 // in constant expressions, or
4131 // - a non-volatile glvalue of literal type that refers to a
4132 // non-volatile object whose lifetime began within the evaluation
4133 // of E;
4134 //
4135 // C++11 misses the 'began within the evaluation of e' check and
4136 // instead allows all temporaries, including things like:
4137 // int &&r = 1;
4138 // int x = ++r;
4139 // constexpr int k = r;
4140 // Therefore we use the C++14-onwards rules in C++11 too.
4141 //
4142 // Note that temporaries whose lifetimes began while evaluating a
4143 // variable's constructor are not usable while evaluating the
4144 // corresponding destructor, not even if they're of const-qualified
4145 // types.
4146 if (!MTE->isUsableInConstantExpressions(Info.Ctx) &&
4147 !lifetimeStartedInEvaluation(Info, LVal.Base)) {
4148 if (!IsAccess)
4149 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
4150 Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
4151 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
4152 return CompleteObject();
4153 }
4154
4155 BaseVal = MTE->getOrCreateValue(false);
4156 assert(BaseVal && "got reference to unevaluated temporary")((void)0);
4157 } else {
4158 if (!IsAccess)
4159 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType);
4160 APValue Val;
4161 LVal.moveInto(Val);
4162 Info.FFDiag(E, diag::note_constexpr_access_unreadable_object)
4163 << AK
4164 << Val.getAsString(Info.Ctx,
4165 Info.Ctx.getLValueReferenceType(LValType));
4166 NoteLValueLocation(Info, LVal.Base);
4167 return CompleteObject();
4168 }
4169 } else {
4170 BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion());
4171 assert(BaseVal && "missing value for temporary")((void)0);
4172 }
4173 }
4174
4175 // In C++14, we can't safely access any mutable state when we might be
4176 // evaluating after an unmodeled side effect. Parameters are modeled as state
4177 // in the caller, but aren't visible once the call returns, so they can be
4178 // modified in a speculatively-evaluated call.
4179 //
4180 // FIXME: Not all local state is mutable. Allow local constant subobjects
4181 // to be read here (but take care with 'mutable' fields).
4182 unsigned VisibleDepth = Depth;
4183 if (llvm::isa_and_nonnull<ParmVarDecl>(
4184 LVal.Base.dyn_cast<const ValueDecl *>()))
4185 ++VisibleDepth;
4186 if ((Frame && Info.getLangOpts().CPlusPlus14 &&
4187 Info.EvalStatus.HasSideEffects) ||
4188 (isModification(AK) && VisibleDepth < Info.SpeculativeEvaluationDepth))
4189 return CompleteObject();
4190
4191 return CompleteObject(LVal.getLValueBase(), BaseVal, BaseType);
4192}
4193
4194/// Perform an lvalue-to-rvalue conversion on the given glvalue. This
4195/// can also be used for 'lvalue-to-lvalue' conversions for looking up the
4196/// glvalue referred to by an entity of reference type.
4197///
4198/// \param Info - Information about the ongoing evaluation.
4199/// \param Conv - The expression for which we are performing the conversion.
4200/// Used for diagnostics.
4201/// \param Type - The type of the glvalue (before stripping cv-qualifiers in the
4202/// case of a non-class type).
4203/// \param LVal - The glvalue on which we are attempting to perform this action.
4204/// \param RVal - The produced value will be placed here.
4205/// \param WantObjectRepresentation - If true, we're looking for the object
4206/// representation rather than the value, and in particular,
4207/// there is no requirement that the result be fully initialized.
4208static bool
4209handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type,
4210 const LValue &LVal, APValue &RVal,
4211 bool WantObjectRepresentation = false) {
4212 if (LVal.Designator.Invalid)
69
Assuming field 'Invalid' is 0
70
Taking false branch
4213 return false;
4214
4215 // Check for special cases where there is no existing APValue to look at.
4216 const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
71
Calling 'LValueBase::dyn_cast'
81
Returning from 'LValueBase::dyn_cast'
4217
4218 AccessKinds AK =
4219 WantObjectRepresentation
81.1
'WantObjectRepresentation' is false
81.1
'WantObjectRepresentation' is false
81.1
'WantObjectRepresentation' is false
81.1
'WantObjectRepresentation' is false
81.1
'WantObjectRepresentation' is false
81.1
'WantObjectRepresentation' is false
? AK_ReadObjectRepresentation : AK_Read;
82
'?' condition is false
4220
4221 if (Base
82.1
'Base' is null
82.1
'Base' is null
82.1
'Base' is null
82.1
'Base' is null
82.1
'Base' is null
82.1
'Base' is null
&& !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {
4222 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
4223 // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
4224 // initializer until now for such expressions. Such an expression can't be
4225 // an ICE in C, so this only matters for fold.
4226 if (Type.isVolatileQualified()) {
4227 Info.FFDiag(Conv);
4228 return false;
4229 }
4230 APValue Lit;
4231 if (!Evaluate(Lit, Info, CLE->getInitializer()))
4232 return false;
4233 CompleteObject LitObj(LVal.Base, &Lit, Base->getType());
4234 return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal, AK);
4235 } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
4236 // Special-case character extraction so we don't have to construct an
4237 // APValue for the whole string.
4238 assert(LVal.Designator.Entries.size() <= 1 &&((void)0)
4239 "Can only read characters from string literals")((void)0);
4240 if (LVal.Designator.Entries.empty()) {
4241 // Fail for now for LValue to RValue conversion of an array.
4242 // (This shouldn't show up in C/C++, but it could be triggered by a
4243 // weird EvaluateAsRValue call from a tool.)
4244 Info.FFDiag(Conv);
4245 return false;
4246 }
4247 if (LVal.Designator.isOnePastTheEnd()) {
4248 if (Info.getLangOpts().CPlusPlus11)
4249 Info.FFDiag(Conv, diag::note_constexpr_access_past_end) << AK;
4250 else
4251 Info.FFDiag(Conv);
4252 return false;
4253 }
4254 uint64_t CharIndex = LVal.Designator.Entries[0].getAsArrayIndex();
4255 RVal = APValue(extractStringLiteralCharacter(Info, Base, CharIndex));
4256 return true;
4257 }
4258 }
4259
4260 CompleteObject Obj = findCompleteObject(Info, Conv, AK, LVal, Type);
4261 return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal, AK);
83
Returning value, which participates in a condition later
4262}
4263
4264/// Perform an assignment of Val to LVal. Takes ownership of Val.
4265static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
4266 QualType LValType, APValue &Val) {
4267 if (LVal.Designator.Invalid)
4268 return false;
4269
4270 if (!Info.getLangOpts().CPlusPlus14) {
4271 Info.FFDiag(E);
4272 return false;
4273 }
4274
4275 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
4276 return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
4277}
4278
4279namespace {
4280struct CompoundAssignSubobjectHandler {
4281 EvalInfo &Info;
4282 const CompoundAssignOperator *E;
4283 QualType PromotedLHSType;
4284 BinaryOperatorKind Opcode;
4285 const APValue &RHS;
4286
4287 static const AccessKinds AccessKind = AK_Assign;
4288
4289 typedef bool result_type;
4290
4291 bool checkConst(QualType QT) {
4292 // Assigning to a const object has undefined behavior.
4293 if (QT.isConstQualified()) {
4294 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
4295 return false;
4296 }
4297 return true;
4298 }
4299
4300 bool failed() { return false; }
4301 bool found(APValue &Subobj, QualType SubobjType) {
4302 switch (Subobj.getKind()) {
4303 case APValue::Int:
4304 return found(Subobj.getInt(), SubobjType);
4305 case APValue::Float:
4306 return found(Subobj.getFloat(), SubobjType);
4307 case APValue::ComplexInt:
4308 case APValue::ComplexFloat:
4309 // FIXME: Implement complex compound assignment.
4310 Info.FFDiag(E);
4311 return false;
4312 case APValue::LValue:
4313 return foundPointer(Subobj, SubobjType);
4314 case APValue::Vector:
4315 return foundVector(Subobj, SubobjType);
4316 default:
4317 // FIXME: can this happen?
4318 Info.FFDiag(E);
4319 return false;
4320 }
4321 }
4322
4323 bool foundVector(APValue &Value, QualType SubobjType) {
4324 if (!checkConst(SubobjType))
4325 return false;
4326
4327 if (!SubobjType->isVectorType()) {
4328 Info.FFDiag(E);
4329 return false;
4330 }
4331 return handleVectorVectorBinOp(Info, E, Opcode, Value, RHS);
4332 }
4333
4334 bool found(APSInt &Value, QualType SubobjType) {
4335 if (!checkConst(SubobjType))
4336 return false;
4337
4338 if (!SubobjType->isIntegerType()) {
4339 // We don't support compound assignment on integer-cast-to-pointer
4340 // values.
4341 Info.FFDiag(E);
4342 return false;
4343 }
4344
4345 if (RHS.isInt()) {
4346 APSInt LHS =
4347 HandleIntToIntCast(Info, E, PromotedLHSType, SubobjType, Value);
4348 if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
4349 return false;
4350 Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
4351 return true;
4352 } else if (RHS.isFloat()) {
4353 const FPOptions FPO = E->getFPFeaturesInEffect(
4354 Info.Ctx.getLangOpts());
4355 APFloat FValue(0.0);
4356 return HandleIntToFloatCast(Info, E, FPO, SubobjType, Value,
4357 PromotedLHSType, FValue) &&
4358 handleFloatFloatBinOp(Info, E, FValue, Opcode, RHS.getFloat()) &&
4359 HandleFloatToIntCast(Info, E, PromotedLHSType, FValue, SubobjType,
4360 Value);
4361 }
4362
4363 Info.FFDiag(E);
4364 return false;
4365 }
4366 bool found(APFloat &Value, QualType SubobjType) {
4367 return checkConst(SubobjType) &&
4368 HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
4369 Value) &&
4370 handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
4371 HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
4372 }
4373 bool foundPointer(APValue &Subobj, QualType SubobjType) {
4374 if (!checkConst(SubobjType))
4375 return false;
4376
4377 QualType PointeeType;
4378 if (const PointerType *PT = SubobjType->getAs<PointerType>())
4379 PointeeType = PT->getPointeeType();
4380
4381 if (PointeeType.isNull() || !RHS.isInt() ||
4382 (Opcode != BO_Add && Opcode != BO_Sub)) {
4383 Info.FFDiag(E);
4384 return false;
4385 }
4386
4387 APSInt Offset = RHS.getInt();
4388 if (Opcode == BO_Sub)
4389 negateAsSigned(Offset);
4390
4391 LValue LVal;
4392 LVal.setFrom(Info.Ctx, Subobj);
4393 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
4394 return false;
4395 LVal.moveInto(Subobj);
4396 return true;
4397 }
4398};
4399} // end anonymous namespace
4400
4401const AccessKinds CompoundAssignSubobjectHandler::AccessKind;
4402
4403/// Perform a compound assignment of LVal <op>= RVal.
4404static bool handleCompoundAssignment(EvalInfo &Info,
4405 const CompoundAssignOperator *E,
4406 const LValue &LVal, QualType LValType,
4407 QualType PromotedLValType,
4408 BinaryOperatorKind Opcode,
4409 const APValue &RVal) {
4410 if (LVal.Designator.Invalid)
4411 return false;
4412
4413 if (!Info.getLangOpts().CPlusPlus14) {
4414 Info.FFDiag(E);
4415 return false;
4416 }
4417
4418 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
4419 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
4420 RVal };
4421 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
4422}
4423
4424namespace {
4425struct IncDecSubobjectHandler {
4426 EvalInfo &Info;
4427 const UnaryOperator *E;
4428 AccessKinds AccessKind;
4429 APValue *Old;
4430
4431 typedef bool result_type;
4432
4433 bool checkConst(QualType QT) {
4434 // Assigning to a const object has undefined behavior.
4435 if (QT.isConstQualified()) {
4436 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
4437 return false;
4438 }
4439 return true;
4440 }
4441
4442 bool failed() { return false; }
4443 bool found(APValue &Subobj, QualType SubobjType) {
4444 // Stash the old value. Also clear Old, so we don't clobber it later
4445 // if we're post-incrementing a complex.
4446 if (Old) {
4447 *Old = Subobj;
4448 Old = nullptr;
4449 }
4450
4451 switch (Subobj.getKind()) {
4452 case APValue::Int:
4453 return found(Subobj.getInt(), SubobjType);
4454 case APValue::Float:
4455 return found(Subobj.getFloat(), SubobjType);
4456 case APValue::ComplexInt:
4457 return found(Subobj.getComplexIntReal(),
4458 SubobjType->castAs<ComplexType>()->getElementType()
4459 .withCVRQualifiers(SubobjType.getCVRQualifiers()));
4460 case APValue::ComplexFloat:
4461 return found(Subobj.getComplexFloatReal(),
4462 SubobjType->castAs<ComplexType>()->getElementType()
4463 .withCVRQualifiers(SubobjType.getCVRQualifiers()));
4464 case APValue::LValue:
4465 return foundPointer(Subobj, SubobjType);
4466 default:
4467 // FIXME: can this happen?
4468 Info.FFDiag(E);
4469 return false;
4470 }
4471 }
4472 bool found(APSInt &Value, QualType SubobjType) {
4473 if (!checkConst(SubobjType))
4474 return false;
4475
4476 if (!SubobjType->isIntegerType()) {
4477 // We don't support increment / decrement on integer-cast-to-pointer
4478 // values.
4479 Info.FFDiag(E);
4480 return false;
4481 }
4482
4483 if (Old) *Old = APValue(Value);
4484
4485 // bool arithmetic promotes to int, and the conversion back to bool
4486 // doesn't reduce mod 2^n, so special-case it.
4487 if (SubobjType->isBooleanType()) {
4488 if (AccessKind == AK_Increment)
4489 Value = 1;
4490 else
4491 Value = !Value;
4492 return true;
4493 }
4494
4495 bool WasNegative = Value.isNegative();
4496 if (AccessKind == AK_Increment) {
4497 ++Value;
4498
4499 if (!WasNegative && Value.isNegative() && E->canOverflow()) {
4500 APSInt ActualValue(Value, /*IsUnsigned*/true);
4501 return HandleOverflow(Info, E, ActualValue, SubobjType);
4502 }
4503 } else {
4504 --Value;
4505
4506 if (WasNegative && !Value.isNegative() && E->canOverflow()) {
4507 unsigned BitWidth = Value.getBitWidth();
4508 APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
4509 ActualValue.setBit(BitWidth);
4510 return HandleOverflow(Info, E, ActualValue, SubobjType);
4511 }
4512 }
4513 return true;
4514 }
4515 bool found(APFloat &Value, QualType SubobjType) {
4516 if (!checkConst(SubobjType))
4517 return false;
4518
4519 if (Old) *Old = APValue(Value);
4520
4521 APFloat One(Value.getSemantics(), 1);
4522 if (AccessKind == AK_Increment)
4523 Value.add(One, APFloat::rmNearestTiesToEven);
4524 else
4525 Value.subtract(One, APFloat::rmNearestTiesToEven);
4526 return true;
4527 }
4528 bool foundPointer(APValue &Subobj, QualType SubobjType) {
4529 if (!checkConst(SubobjType))
4530 return false;
4531
4532 QualType PointeeType;
4533 if (const PointerType *PT = SubobjType->getAs<PointerType>())
4534 PointeeType = PT->getPointeeType();
4535 else {
4536 Info.FFDiag(E);
4537 return false;
4538 }
4539
4540 LValue LVal;
4541 LVal.setFrom(Info.Ctx, Subobj);
4542 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
4543 AccessKind == AK_Increment ? 1 : -1))
4544 return false;
4545 LVal.moveInto(Subobj);
4546 return true;
4547 }
4548};
4549} // end anonymous namespace
4550
4551/// Perform an increment or decrement on LVal.
4552static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
4553 QualType LValType, bool IsIncrement, APValue *Old) {
4554 if (LVal.Designator.Invalid)
4555 return false;
4556
4557 if (!Info.getLangOpts().CPlusPlus14) {
4558 Info.FFDiag(E);
4559 return false;
4560 }
4561
4562 AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
4563 CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
4564 IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
4565 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
4566}
4567
4568/// Build an lvalue for the object argument of a member function call.
4569static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
4570 LValue &This) {
4571 if (Object->getType()->isPointerType() && Object->isPRValue())
4572 return EvaluatePointer(Object, This, Info);
4573
4574 if (Object->isGLValue())
4575 return EvaluateLValue(Object, This, Info);
4576
4577 if (Object->getType()->isLiteralType(Info.Ctx))
4578 return EvaluateTemporary(Object, This, Info);
4579
4580 Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();
4581 return false;
4582}
4583
4584/// HandleMemberPointerAccess - Evaluate a member access operation and build an
4585/// lvalue referring to the result.
4586///
4587/// \param Info - Information about the ongoing evaluation.
4588/// \param LV - An lvalue referring to the base of the member pointer.
4589/// \param RHS - The member pointer expression.
4590/// \param IncludeMember - Specifies whether the member itself is included in
4591/// the resulting LValue subobject designator. This is not possible when
4592/// creating a bound member function.
4593/// \return The field or method declaration to which the member pointer refers,
4594/// or 0 if evaluation fails.
4595static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
4596 QualType LVType,
4597 LValue &LV,
4598 const Expr *RHS,
4599 bool IncludeMember = true) {
4600 MemberPtr MemPtr;
4601 if (!EvaluateMemberPointer(RHS, MemPtr, Info))
4602 return nullptr;
4603
4604 // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to
4605 // member value, the behavior is undefined.
4606 if (!MemPtr.getDecl()) {
4607 // FIXME: Specific diagnostic.
4608 Info.FFDiag(RHS);
4609 return nullptr;
4610 }
4611
4612 if (MemPtr.isDerivedMember()) {
4613 // This is a member of some derived class. Truncate LV appropriately.
4614 // The end of the derived-to-base path for the base object must match the
4615 // derived-to-base path for the member pointer.
4616 if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
4617 LV.Designator.Entries.size()) {
4618 Info.FFDiag(RHS);
4619 return nullptr;
4620 }
4621 unsigned PathLengthToMember =
4622 LV.Designator.Entries.size() - MemPtr.Path.size();
4623 for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
4624 const CXXRecordDecl *LVDecl = getAsBaseClass(
4625 LV.Designator.Entries[PathLengthToMember + I]);
4626 const CXXRecordDecl *MPDecl = MemPtr.Path[I];
4627 if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
4628 Info.FFDiag(RHS);
4629 return nullptr;
4630 }
4631 }
4632
4633 // Truncate the lvalue to the appropriate derived class.
4634 if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(),
4635 PathLengthToMember))
4636 return nullptr;
4637 } else if (!MemPtr.Path.empty()) {
4638 // Extend the LValue path with the member pointer's path.
4639 LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
4640 MemPtr.Path.size() + IncludeMember);
4641
4642 // Walk down to the appropriate base class.
4643 if (const PointerType *PT = LVType->getAs<PointerType>())
4644 LVType = PT->getPointeeType();
4645 const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
4646 assert(RD && "member pointer access on non-class-type expression")((void)0);
4647 // The first class in the path is that of the lvalue.
4648 for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
4649 const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
4650 if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
4651 return nullptr;
4652 RD = Base;
4653 }
4654 // Finally cast to the class containing the member.
4655 if (!HandleLValueDirectBase(Info, RHS, LV, RD,
4656 MemPtr.getContainingRecord()))
4657 return nullptr;
4658 }
4659
4660 // Add the member. Note that we cannot build bound member functions here.
4661 if (IncludeMember) {
4662 if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
4663 if (!HandleLValueMember(Info, RHS, LV, FD))
4664 return nullptr;
4665 } else if (const IndirectFieldDecl *IFD =
4666 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
4667 if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
4668 return nullptr;
4669 } else {
4670 llvm_unreachable("can't construct reference to bound member function")__builtin_unreachable();
4671 }
4672 }
4673
4674 return MemPtr.getDecl();
4675}
4676
4677static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
4678 const BinaryOperator *BO,
4679 LValue &LV,
4680 bool IncludeMember = true) {
4681 assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)((void)0);
4682
4683 if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
4684 if (Info.noteFailure()) {
4685 MemberPtr MemPtr;
4686 EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
4687 }
4688 return nullptr;
4689 }
4690
4691 return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
4692 BO->getRHS(), IncludeMember);
4693}
4694
4695/// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
4696/// the provided lvalue, which currently refers to the base object.
4697static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
4698 LValue &Result) {
4699 SubobjectDesignator &D = Result.Designator;
4700 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
4701 return false;
4702
4703 QualType TargetQT = E->getType();
4704 if (const PointerType *PT = TargetQT->getAs<PointerType>())
4705 TargetQT = PT->getPointeeType();
4706
4707 // Check this cast lands within the final derived-to-base subobject path.
4708 if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
4709 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
4710 << D.MostDerivedType << TargetQT;
4711 return false;
4712 }
4713
4714 // Check the type of the final cast. We don't need to check the path,
4715 // since a cast can only be formed if the path is unique.
4716 unsigned NewEntriesSize = D.Entries.size() - E->path_size();
4717 const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl();
4718 const CXXRecordDecl *FinalType;
4719 if (NewEntriesSize == D.MostDerivedPathLength)
4720 FinalType = D.MostDerivedType->getAsCXXRecordDecl();
4721 else
4722 FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
4723 if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
4724 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
4725 << D.MostDerivedType << TargetQT;
4726 return false;
4727 }
4728
4729 // Truncate the lvalue to the appropriate derived class.
4730 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
4731}
4732
4733/// Get the value to use for a default-initialized object of type T.
4734/// Return false if it encounters something invalid.
4735static bool getDefaultInitValue(QualType T, APValue &Result) {
4736 bool Success = true;
4737 if (auto *RD = T->getAsCXXRecordDecl()) {
4738 if (RD->isInvalidDecl()) {
4739 Result = APValue();
4740 return false;
4741 }
4742 if (RD->isUnion()) {
4743 Result = APValue((const FieldDecl *)nullptr);
4744 return true;
4745 }
4746 Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
4747 std::distance(RD->field_begin(), RD->field_end()));
4748
4749 unsigned Index = 0;
4750 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
4751 End = RD->bases_end();
4752 I != End; ++I, ++Index)
4753 Success &= getDefaultInitValue(I->getType(), Result.getStructBase(Index));
4754
4755 for (const auto *I : RD->fields()) {
4756 if (I->isUnnamedBitfield())
4757 continue;
4758 Success &= getDefaultInitValue(I->getType(),
4759 Result.getStructField(I->getFieldIndex()));
4760 }
4761 return Success;
4762 }
4763
4764 if (auto *AT =
4765 dyn_cast_or_null<ConstantArrayType>(T->getAsArrayTypeUnsafe())) {
4766 Result = APValue(APValue::UninitArray(), 0, AT->getSize().getZExtValue());
4767 if (Result.hasArrayFiller())
4768 Success &=
4769 getDefaultInitValue(AT->getElementType(), Result.getArrayFiller());
4770
4771 return Success;
4772 }
4773
4774 Result = APValue::IndeterminateValue();
4775 return true;
4776}
4777
4778namespace {
4779enum EvalStmtResult {
4780 /// Evaluation failed.
4781 ESR_Failed,
4782 /// Hit a 'return' statement.
4783 ESR_Returned,
4784 /// Evaluation succeeded.
4785 ESR_Succeeded,
4786 /// Hit a 'continue' statement.
4787 ESR_Continue,
4788 /// Hit a 'break' statement.
4789 ESR_Break,
4790 /// Still scanning for 'case' or 'default' statement.
4791 ESR_CaseNotFound
4792};
4793}
4794
4795static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
4796 // We don't need to evaluate the initializer for a static local.
4797 if (!VD->hasLocalStorage())
4798 return true;
4799
4800 LValue Result;
4801 APValue &Val = Info.CurrentCall->createTemporary(VD, VD->getType(),
4802 ScopeKind::Block, Result);
4803
4804 const Expr *InitE = VD->getInit();
4805 if (!InitE) {
4806 if (VD->getType()->isDependentType())
4807 return Info.noteSideEffect();
4808 return getDefaultInitValue(VD->getType(), Val);
4809 }
4810 if (InitE->isValueDependent())
4811 return false;
4812
4813 if (!EvaluateInPlace(Val, Info, Result, InitE)) {
4814 // Wipe out any partially-computed value, to allow tracking that this
4815 // evaluation failed.
4816 Val = APValue();
4817 return false;
4818 }
4819
4820 return true;
4821}
4822
4823static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
4824 bool OK = true;
4825
4826 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
4827 OK &= EvaluateVarDecl(Info, VD);
4828
4829 if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
4830 for (auto *BD : DD->bindings())
4831 if (auto *VD = BD->getHoldingVar())
4832 OK &= EvaluateDecl(Info, VD);
4833
4834 return OK;
4835}
4836
4837static bool EvaluateDependentExpr(const Expr *E, EvalInfo &Info) {
4838 assert(E->isValueDependent())((void)0);
4839 if (Info.noteSideEffect())
4840 return true;
4841 assert(E->containsErrors() && "valid value-dependent expression should never "((void)0)
4842 "reach invalid code path.")((void)0);
4843 return false;
4844}
4845
4846/// Evaluate a condition (either a variable declaration or an expression).
4847static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
4848 const Expr *Cond, bool &Result) {
4849 if (Cond->isValueDependent())
4850 return false;
4851 FullExpressionRAII Scope(Info);
4852 if (CondDecl && !EvaluateDecl(Info, CondDecl))
4853 return false;
4854 if (!EvaluateAsBooleanCondition(Cond, Result, Info))
4855 return false;
4856 return Scope.destroy();
4857}
4858
4859namespace {
4860/// A location where the result (returned value) of evaluating a
4861/// statement should be stored.
4862struct StmtResult {
4863 /// The APValue that should be filled in with the returned value.
4864 APValue &Value;
4865 /// The location containing the result, if any (used to support RVO).
4866 const LValue *Slot;
4867};
4868
4869struct TempVersionRAII {
4870 CallStackFrame &Frame;
4871
4872 TempVersionRAII(CallStackFrame &Frame) : Frame(Frame) {
4873 Frame.pushTempVersion();
4874 }
4875
4876 ~TempVersionRAII() {
4877 Frame.popTempVersion();
4878 }
4879};
4880
4881}
4882
4883static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
4884 const Stmt *S,
4885 const SwitchCase *SC = nullptr);
4886
4887/// Evaluate the body of a loop, and translate the result as appropriate.
4888static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
4889 const Stmt *Body,
4890 const SwitchCase *Case = nullptr) {
4891 BlockScopeRAII Scope(Info);
4892
4893 EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case);
4894 if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy())
4895 ESR = ESR_Failed;
4896
4897 switch (ESR) {
4898 case ESR_Break:
4899 return ESR_Succeeded;
4900 case ESR_Succeeded:
4901 case ESR_Continue:
4902 return ESR_Continue;
4903 case ESR_Failed:
4904 case ESR_Returned:
4905 case ESR_CaseNotFound:
4906 return ESR;
4907 }
4908 llvm_unreachable("Invalid EvalStmtResult!")__builtin_unreachable();
4909}
4910
4911/// Evaluate a switch statement.
4912static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
4913 const SwitchStmt *SS) {
4914 BlockScopeRAII Scope(Info);
4915
4916 // Evaluate the switch condition.
4917 APSInt Value;
4918 {
4919 if (const Stmt *Init = SS->getInit()) {
4920 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
4921 if (ESR != ESR_Succeeded) {
4922 if (ESR != ESR_Failed && !Scope.destroy())
4923 ESR = ESR_Failed;
4924 return ESR;
4925 }
4926 }
4927
4928 FullExpressionRAII CondScope(Info);
4929 if (SS->getConditionVariable() &&
4930 !EvaluateDecl(Info, SS->getConditionVariable()))
4931 return ESR_Failed;
4932 if (!EvaluateInteger(SS->getCond(), Value, Info))
4933 return ESR_Failed;
4934 if (!CondScope.destroy())
4935 return ESR_Failed;
4936 }
4937
4938 // Find the switch case corresponding to the value of the condition.
4939 // FIXME: Cache this lookup.
4940 const SwitchCase *Found = nullptr;
4941 for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
4942 SC = SC->getNextSwitchCase()) {
4943 if (isa<DefaultStmt>(SC)) {
4944 Found = SC;
4945 continue;
4946 }
4947
4948 const CaseStmt *CS = cast<CaseStmt>(SC);
4949 APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
4950 APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
4951 : LHS;
4952 if (LHS <= Value && Value <= RHS) {
4953 Found = SC;
4954 break;
4955 }
4956 }
4957
4958 if (!Found)
4959 return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
4960
4961 // Search the switch body for the switch case and evaluate it from there.
4962 EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found);
4963 if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy())
4964 return ESR_Failed;
4965
4966 switch (ESR) {
4967 case ESR_Break:
4968 return ESR_Succeeded;
4969 case ESR_Succeeded:
4970 case ESR_Continue:
4971 case ESR_Failed:
4972 case ESR_Returned:
4973 return ESR;
4974 case ESR_CaseNotFound:
4975 // This can only happen if the switch case is nested within a statement
4976 // expression. We have no intention of supporting that.
4977 Info.FFDiag(Found->getBeginLoc(),
4978 diag::note_constexpr_stmt_expr_unsupported);
4979 return ESR_Failed;
4980 }
4981 llvm_unreachable("Invalid EvalStmtResult!")__builtin_unreachable();
4982}
4983
4984// Evaluate a statement.
4985static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
4986 const Stmt *S, const SwitchCase *Case) {
4987 if (!Info.nextStep(S))
4988 return ESR_Failed;
4989
4990 // If we're hunting down a 'case' or 'default' label, recurse through
4991 // substatements until we hit the label.
4992 if (Case) {
4993 switch (S->getStmtClass()) {
4994 case Stmt::CompoundStmtClass:
4995 // FIXME: Precompute which substatement of a compound statement we
4996 // would jump to, and go straight there rather than performing a
4997 // linear scan each time.
4998 case Stmt::LabelStmtClass:
4999 case Stmt::AttributedStmtClass:
5000 case Stmt::DoStmtClass:
5001 break;
5002
5003 case Stmt::CaseStmtClass:
5004 case Stmt::DefaultStmtClass:
5005 if (Case == S)
5006 Case = nullptr;
5007 break;
5008
5009 case Stmt::IfStmtClass: {
5010 // FIXME: Precompute which side of an 'if' we would jump to, and go
5011 // straight there rather than scanning both sides.
5012 const IfStmt *IS = cast<IfStmt>(S);
5013
5014 // Wrap the evaluation in a block scope, in case it's a DeclStmt
5015 // preceded by our switch label.
5016 BlockScopeRAII Scope(Info);
5017
5018 // Step into the init statement in case it brings an (uninitialized)
5019 // variable into scope.
5020 if (const Stmt *Init = IS->getInit()) {
5021 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
5022 if (ESR != ESR_CaseNotFound) {
5023 assert(ESR != ESR_Succeeded)((void)0);
5024 return ESR;
5025 }
5026 }
5027
5028 // Condition variable must be initialized if it exists.
5029 // FIXME: We can skip evaluating the body if there's a condition
5030 // variable, as there can't be any case labels within it.
5031 // (The same is true for 'for' statements.)
5032
5033 EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
5034 if (ESR == ESR_Failed)
5035 return ESR;
5036 if (ESR != ESR_CaseNotFound)
5037 return Scope.destroy() ? ESR : ESR_Failed;
5038 if (!IS->getElse())
5039 return ESR_CaseNotFound;
5040
5041 ESR = EvaluateStmt(Result, Info, IS->getElse(), Case);
5042 if (ESR == ESR_Failed)
5043 return ESR;
5044 if (ESR != ESR_CaseNotFound)
5045 return Scope.destroy() ? ESR : ESR_Failed;
5046 return ESR_CaseNotFound;
5047 }
5048
5049 case Stmt::WhileStmtClass: {
5050 EvalStmtResult ESR =
5051 EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
5052 if (ESR != ESR_Continue)
5053 return ESR;
5054 break;
5055 }
5056
5057 case Stmt::ForStmtClass: {
5058 const ForStmt *FS = cast<ForStmt>(S);
5059 BlockScopeRAII Scope(Info);
5060
5061 // Step into the init statement in case it brings an (uninitialized)
5062 // variable into scope.
5063 if (const Stmt *Init = FS->getInit()) {
5064 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
5065 if (ESR != ESR_CaseNotFound) {
5066 assert(ESR != ESR_Succeeded)((void)0);
5067 return ESR;
5068 }
5069 }
5070
5071 EvalStmtResult ESR =
5072 EvaluateLoopBody(Result, Info, FS->getBody(), Case);
5073 if (ESR != ESR_Continue)
5074 return ESR;
5075 if (const auto *Inc = FS->getInc()) {
5076 if (Inc->isValueDependent()) {
5077 if (!EvaluateDependentExpr(Inc, Info))
5078 return ESR_Failed;
5079 } else {
5080 FullExpressionRAII IncScope(Info);
5081 if (!EvaluateIgnoredValue(Info, Inc) || !IncScope.destroy())
5082 return ESR_Failed;
5083 }
5084 }
5085 break;
5086 }
5087
5088 case Stmt::DeclStmtClass: {
5089 // Start the lifetime of any uninitialized variables we encounter. They
5090 // might be used by the selected branch of the switch.
5091 const DeclStmt *DS = cast<DeclStmt>(S);
5092 for (const auto *D : DS->decls()) {
5093 if (const auto *VD = dyn_cast<VarDecl>(D)) {
5094 if (VD->hasLocalStorage() && !VD->getInit())
5095 if (!EvaluateVarDecl(Info, VD))
5096 return ESR_Failed;
5097 // FIXME: If the variable has initialization that can't be jumped
5098 // over, bail out of any immediately-surrounding compound-statement
5099 // too. There can't be any case labels here.
5100 }
5101 }
5102 return ESR_CaseNotFound;
5103 }
5104
5105 default:
5106 return ESR_CaseNotFound;
5107 }
5108 }
5109
5110 switch (S->getStmtClass()) {
5111 default:
5112 if (const Expr *E = dyn_cast<Expr>(S)) {
5113 if (E->isValueDependent()) {
5114 if (!EvaluateDependentExpr(E, Info))
5115 return ESR_Failed;
5116 } else {
5117 // Don't bother evaluating beyond an expression-statement which couldn't
5118 // be evaluated.
5119 // FIXME: Do we need the FullExpressionRAII object here?
5120 // VisitExprWithCleanups should create one when necessary.
5121 FullExpressionRAII Scope(Info);
5122 if (!EvaluateIgnoredValue(Info, E) || !Scope.destroy())
5123 return ESR_Failed;
5124 }
5125 return ESR_Succeeded;
5126 }
5127
5128 Info.FFDiag(S->getBeginLoc());
5129 return ESR_Failed;
5130
5131 case Stmt::NullStmtClass:
5132 return ESR_Succeeded;
5133
5134 case Stmt::DeclStmtClass: {
5135 const DeclStmt *DS = cast<DeclStmt>(S);
5136 for (const auto *D : DS->decls()) {
5137 // Each declaration initialization is its own full-expression.
5138 FullExpressionRAII Scope(Info);
5139 if (!EvaluateDecl(Info, D) && !Info.noteFailure())
5140 return ESR_Failed;
5141 if (!Scope.destroy())
5142 return ESR_Failed;
5143 }
5144 return ESR_Succeeded;
5145 }
5146
5147 case Stmt::ReturnStmtClass: {
5148 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
5149 FullExpressionRAII Scope(Info);
5150 if (RetExpr && RetExpr->isValueDependent()) {
5151 EvaluateDependentExpr(RetExpr, Info);
5152 // We know we returned, but we don't know what the value is.
5153 return ESR_Failed;
5154 }
5155 if (RetExpr &&
5156 !(Result.Slot
5157 ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
5158 : Evaluate(Result.Value, Info, RetExpr)))
5159 return ESR_Failed;
5160 return Scope.destroy() ? ESR_Returned : ESR_Failed;
5161 }
5162
5163 case Stmt::CompoundStmtClass: {
5164 BlockScopeRAII Scope(Info);
5165
5166 const CompoundStmt *CS = cast<CompoundStmt>(S);
5167 for (const auto *BI : CS->body()) {
5168 EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
5169 if (ESR == ESR_Succeeded)
5170 Case = nullptr;
5171 else if (ESR != ESR_CaseNotFound) {
5172 if (ESR != ESR_Failed && !Scope.destroy())
5173 return ESR_Failed;
5174 return ESR;
5175 }
5176 }
5177 if (Case)
5178 return ESR_CaseNotFound;
5179 return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
5180 }
5181
5182 case Stmt::IfStmtClass: {
5183 const IfStmt *IS = cast<IfStmt>(S);
5184
5185 // Evaluate the condition, as either a var decl or as an expression.
5186 BlockScopeRAII Scope(Info);
5187 if (const Stmt *Init = IS->getInit()) {
5188 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
5189 if (ESR != ESR_Succeeded) {
5190 if (ESR != ESR_Failed && !Scope.destroy())
5191 return ESR_Failed;
5192 return ESR;
5193 }
5194 }
5195 bool Cond;
5196 if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
5197 return ESR_Failed;
5198
5199 if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
5200 EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
5201 if (ESR != ESR_Succeeded) {
5202 if (ESR != ESR_Failed && !Scope.destroy())
5203 return ESR_Failed;
5204 return ESR;
5205 }
5206 }
5207 return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
5208 }
5209
5210 case Stmt::WhileStmtClass: {
5211 const WhileStmt *WS = cast<WhileStmt>(S);
5212 while (true) {
5213 BlockScopeRAII Scope(Info);
5214 bool Continue;
5215 if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
5216 Continue))
5217 return ESR_Failed;
5218 if (!Continue)
5219 break;
5220
5221 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
5222 if (ESR != ESR_Continue) {
5223 if (ESR != ESR_Failed && !Scope.destroy())
5224 return ESR_Failed;
5225 return ESR;
5226 }
5227 if (!Scope.destroy())
5228 return ESR_Failed;
5229 }
5230 return ESR_Succeeded;
5231 }
5232
5233 case Stmt::DoStmtClass: {
5234 const DoStmt *DS = cast<DoStmt>(S);
5235 bool Continue;
5236 do {
5237 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
5238 if (ESR != ESR_Continue)
5239 return ESR;
5240 Case = nullptr;
5241
5242 if (DS->getCond()->isValueDependent()) {
5243 EvaluateDependentExpr(DS->getCond(), Info);
5244 // Bailout as we don't know whether to keep going or terminate the loop.
5245 return ESR_Failed;
5246 }
5247 FullExpressionRAII CondScope(Info);
5248 if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info) ||
5249 !CondScope.destroy())
5250 return ESR_Failed;
5251 } while (Continue);
5252 return ESR_Succeeded;
5253 }
5254
5255 case Stmt::ForStmtClass: {
5256 const ForStmt *FS = cast<ForStmt>(S);
5257 BlockScopeRAII ForScope(Info);
5258 if (FS->getInit()) {
5259 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
5260 if (ESR != ESR_Succeeded) {
5261 if (ESR != ESR_Failed && !ForScope.destroy())
5262 return ESR_Failed;
5263 return ESR;
5264 }
5265 }
5266 while (true) {
5267 BlockScopeRAII IterScope(Info);
5268 bool Continue = true;
5269 if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
5270 FS->getCond(), Continue))
5271 return ESR_Failed;
5272 if (!Continue)
5273 break;
5274
5275 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
5276 if (ESR != ESR_Continue) {
5277 if (ESR != ESR_Failed && (!IterScope.destroy() || !ForScope.destroy()))
5278 return ESR_Failed;
5279 return ESR;
5280 }
5281
5282 if (const auto *Inc = FS->getInc()) {
5283 if (Inc->isValueDependent()) {
5284 if (!EvaluateDependentExpr(Inc, Info))
5285 return ESR_Failed;
5286 } else {
5287 FullExpressionRAII IncScope(Info);
5288 if (!EvaluateIgnoredValue(Info, Inc) || !IncScope.destroy())
5289 return ESR_Failed;
5290 }
5291 }
5292
5293 if (!IterScope.destroy())
5294 return ESR_Failed;
5295 }
5296 return ForScope.destroy() ? ESR_Succeeded : ESR_Failed;
5297 }
5298
5299 case Stmt::CXXForRangeStmtClass: {
5300 const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
5301 BlockScopeRAII Scope(Info);
5302
5303 // Evaluate the init-statement if present.
5304 if (FS->getInit()) {
5305 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
5306 if (ESR != ESR_Succeeded) {
5307 if (ESR != ESR_Failed && !Scope.destroy())
5308 return ESR_Failed;
5309 return ESR;
5310 }
5311 }
5312
5313 // Initialize the __range variable.
5314 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
5315 if (ESR != ESR_Succeeded) {
5316 if (ESR != ESR_Failed && !Scope.destroy())
5317 return ESR_Failed;
5318 return ESR;
5319 }
5320
5321 // Create the __begin and __end iterators.
5322 ESR = EvaluateStmt(Result, Info, FS->getBeginStmt());
5323 if (ESR != ESR_Succeeded) {
5324 if (ESR != ESR_Failed && !Scope.destroy())
5325 return ESR_Failed;
5326 return ESR;
5327 }
5328 ESR = EvaluateStmt(Result, Info, FS->getEndStmt());
5329 if (ESR != ESR_Succeeded) {
5330 if (ESR != ESR_Failed && !Scope.destroy())
5331 return ESR_Failed;
5332 return ESR;
5333 }
5334
5335 while (true) {
5336 // Condition: __begin != __end.
5337 {
5338 if (FS->getCond()->isValueDependent()) {
5339 EvaluateDependentExpr(FS->getCond(), Info);
5340 // We don't know whether to keep going or terminate the loop.
5341 return ESR_Failed;
5342 }
5343 bool Continue = true;
5344 FullExpressionRAII CondExpr(Info);
5345 if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
5346 return ESR_Failed;
5347 if (!Continue)
5348 break;
5349 }
5350
5351 // User's variable declaration, initialized by *__begin.
5352 BlockScopeRAII InnerScope(Info);
5353 ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
5354 if (ESR != ESR_Succeeded) {
5355 if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
5356 return ESR_Failed;
5357 return ESR;
5358 }
5359
5360 // Loop body.
5361 ESR = EvaluateLoopBody(Result, Info, FS->getBody());
5362 if (ESR != ESR_Continue) {
5363 if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy()))
5364 return ESR_Failed;
5365 return ESR;
5366 }
5367 if (FS->getInc()->isValueDependent()) {
5368 if (!EvaluateDependentExpr(FS->getInc(), Info))
5369 return ESR_Failed;
5370 } else {
5371 // Increment: ++__begin
5372 if (!EvaluateIgnoredValue(Info, FS->getInc()))
5373 return ESR_Failed;
5374 }
5375
5376 if (!InnerScope.destroy())
5377 return ESR_Failed;
5378 }
5379
5380 return Scope.destroy() ? ESR_Succeeded : ESR_Failed;
5381 }
5382
5383 case Stmt::SwitchStmtClass:
5384 return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
5385
5386 case Stmt::ContinueStmtClass:
5387 return ESR_Continue;
5388
5389 case Stmt::BreakStmtClass:
5390 return ESR_Break;
5391
5392 case Stmt::LabelStmtClass:
5393 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
5394
5395 case Stmt::AttributedStmtClass:
5396 // As a general principle, C++11 attributes can be ignored without
5397 // any semantic impact.
5398 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
5399 Case);
5400
5401 case Stmt::CaseStmtClass:
5402 case Stmt::DefaultStmtClass:
5403 return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
5404 case Stmt::CXXTryStmtClass:
5405 // Evaluate try blocks by evaluating all sub statements.
5406 return EvaluateStmt(Result, Info, cast<CXXTryStmt>(S)->getTryBlock(), Case);
5407 }
5408}
5409
5410/// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
5411/// default constructor. If so, we'll fold it whether or not it's marked as
5412/// constexpr. If it is marked as constexpr, we will never implicitly define it,
5413/// so we need special handling.
5414static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
5415 const CXXConstructorDecl *CD,
5416 bool IsValueInitialization) {
5417 if (!CD->isTrivial() || !CD->isDefaultConstructor())
5418 return false;
5419
5420 // Value-initialization does not call a trivial default constructor, so such a
5421 // call is a core constant expression whether or not the constructor is
5422 // constexpr.
5423 if (!CD->isConstexpr() && !IsValueInitialization) {
5424 if (Info.getLangOpts().CPlusPlus11) {
5425 // FIXME: If DiagDecl is an implicitly-declared special member function,
5426 // we should be much more explicit about why it's not constexpr.
5427 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
5428 << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
5429 Info.Note(CD->getLocation(), diag::note_declared_at);
5430 } else {
5431 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
5432 }
5433 }
5434 return true;
5435}
5436
5437/// CheckConstexprFunction - Check that a function can be called in a constant
5438/// expression.
5439static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
5440 const FunctionDecl *Declaration,
5441 const FunctionDecl *Definition,
5442 const Stmt *Body) {
5443 // Potential constant expressions can contain calls to declared, but not yet
5444 // defined, constexpr functions.
5445 if (Info.checkingPotentialConstantExpression() && !Definition &&
5446 Declaration->isConstexpr())
5447 return false;
5448
5449 // Bail out if the function declaration itself is invalid. We will
5450 // have produced a relevant diagnostic while parsing it, so just
5451 // note the problematic sub-expression.
5452 if (Declaration->isInvalidDecl()) {
5453 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
5454 return false;
5455 }
5456
5457 // DR1872: An instantiated virtual constexpr function can't be called in a
5458 // constant expression (prior to C++20). We can still constant-fold such a
5459 // call.
5460 if (!Info.Ctx.getLangOpts().CPlusPlus20 && isa<CXXMethodDecl>(Declaration) &&
5461 cast<CXXMethodDecl>(Declaration)->isVirtual())
5462 Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call);
5463
5464 if (Definition && Definition->isInvalidDecl()) {
5465 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
5466 return false;
5467 }
5468
5469 // Can we evaluate this function call?
5470 if (Definition && Definition->isConstexpr() && Body)
5471 return true;
5472
5473 if (Info.getLangOpts().CPlusPlus11) {
5474 const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
5475
5476 // If this function is not constexpr because it is an inherited
5477 // non-constexpr constructor, diagnose that directly.
5478 auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
5479 if (CD && CD->isInheritingConstructor()) {
5480 auto *Inherited = CD->getInheritedConstructor().getConstructor();
5481 if (!Inherited->isConstexpr())
5482 DiagDecl = CD = Inherited;
5483 }
5484
5485 // FIXME: If DiagDecl is an implicitly-declared special member function
5486 // or an inheriting constructor, we should be much more explicit about why
5487 // it's not constexpr.
5488 if (CD && CD->isInheritingConstructor())
5489 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
5490 << CD->getInheritedConstructor().getConstructor()->getParent();
5491 else
5492 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
5493 << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
5494 Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
5495 } else {
5496 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
5497 }
5498 return false;
5499}
5500
5501namespace {
5502struct CheckDynamicTypeHandler {
5503 AccessKinds AccessKind;
5504 typedef bool result_type;
5505 bool failed() { return false; }
5506 bool found(APValue &Subobj, QualType SubobjType) { return true; }
5507 bool found(APSInt &Value, QualType SubobjType) { return true; }
5508 bool found(APFloat &Value, QualType SubobjType) { return true; }
5509};
5510} // end anonymous namespace
5511
5512/// Check that we can access the notional vptr of an object / determine its
5513/// dynamic type.
5514static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This,
5515 AccessKinds AK, bool Polymorphic) {
5516 if (This.Designator.Invalid)
5517 return false;
5518
5519 CompleteObject Obj = findCompleteObject(Info, E, AK, This, QualType());
5520
5521 if (!Obj)
5522 return false;
5523
5524 if (!Obj.Value) {
5525 // The object is not usable in constant expressions, so we can't inspect
5526 // its value to see if it's in-lifetime or what the active union members
5527 // are. We can still check for a one-past-the-end lvalue.
5528 if (This.Designator.isOnePastTheEnd() ||
5529 This.Designator.isMostDerivedAnUnsizedArray()) {
5530 Info.FFDiag(E, This.Designator.isOnePastTheEnd()
5531 ? diag::note_constexpr_access_past_end
5532 : diag::note_constexpr_access_unsized_array)
5533 << AK;
5534 return false;
5535 } else if (Polymorphic) {
5536 // Conservatively refuse to perform a polymorphic operation if we would
5537 // not be able to read a notional 'vptr' value.
5538 APValue Val;
5539 This.moveInto(Val);
5540 QualType StarThisType =
5541 Info.Ctx.getLValueReferenceType(This.Designator.getType(Info.Ctx));
5542 Info.FFDiag(E, diag::note_constexpr_polymorphic_unknown_dynamic_type)
5543 << AK << Val.getAsString(Info.Ctx, StarThisType);
5544 return false;
5545 }
5546 return true;
5547 }
5548
5549 CheckDynamicTypeHandler Handler{AK};
5550 return Obj && findSubobject(Info, E, Obj, This.Designator, Handler);
5551}
5552
5553/// Check that the pointee of the 'this' pointer in a member function call is
5554/// either within its lifetime or in its period of construction or destruction.
5555static bool
5556checkNonVirtualMemberCallThisPointer(EvalInfo &Info, const Expr *E,
5557 const LValue &This,
5558 const CXXMethodDecl *NamedMember) {
5559 return checkDynamicType(
5560 Info, E, This,
5561 isa<CXXDestructorDecl>(NamedMember) ? AK_Destroy : AK_MemberCall, false);
5562}
5563
5564struct DynamicType {
5565 /// The dynamic class type of the object.
5566 const CXXRecordDecl *Type;
5567 /// The corresponding path length in the lvalue.
5568 unsigned PathLength;
5569};
5570
5571static const CXXRecordDecl *getBaseClassType(SubobjectDesignator &Designator,
5572 unsigned PathLength) {
5573 assert(PathLength >= Designator.MostDerivedPathLength && PathLength <=((void)0)
5574 Designator.Entries.size() && "invalid path length")((void)0);
5575 return (PathLength == Designator.MostDerivedPathLength)
5576 ? Designator.MostDerivedType->getAsCXXRecordDecl()
5577 : getAsBaseClass(Designator.Entries[PathLength - 1]);
5578}
5579
5580/// Determine the dynamic type of an object.
5581static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
5582 LValue &This, AccessKinds AK) {
5583 // If we don't have an lvalue denoting an object of class type, there is no
5584 // meaningful dynamic type. (We consider objects of non-class type to have no
5585 // dynamic type.)
5586 if (!checkDynamicType(Info, E, This, AK, true))
5587 return None;
5588
5589 // Refuse to compute a dynamic type in the presence of virtual bases. This
5590 // shouldn't happen other than in constant-folding situations, since literal
5591 // types can't have virtual bases.
5592 //
5593 // Note that consumers of DynamicType assume that the type has no virtual
5594 // bases, and will need modifications if this restriction is relaxed.
5595 const CXXRecordDecl *Class =
5596 This.Designator.MostDerivedType->getAsCXXRecordDecl();
5597 if (!Class || Class->getNumVBases()) {
5598 Info.FFDiag(E);
5599 return None;
5600 }
5601
5602 // FIXME: For very deep class hierarchies, it might be beneficial to use a
5603 // binary search here instead. But the overwhelmingly common case is that
5604 // we're not in the middle of a constructor, so it probably doesn't matter
5605 // in practice.
5606 ArrayRef<APValue::LValuePathEntry> Path = This.Designator.Entries;
5607 for (unsigned PathLength = This.Designator.MostDerivedPathLength;
5608 PathLength <= Path.size(); ++PathLength) {
5609 switch (Info.isEvaluatingCtorDtor(This.getLValueBase(),
5610 Path.slice(0, PathLength))) {
5611 case ConstructionPhase::Bases:
5612 case ConstructionPhase::DestroyingBases:
5613 // We're constructing or destroying a base class. This is not the dynamic
5614 // type.
5615 break;
5616
5617 case ConstructionPhase::None:
5618 case ConstructionPhase::AfterBases:
5619 case ConstructionPhase::AfterFields:
5620 case ConstructionPhase::Destroying:
5621 // We've finished constructing the base classes and not yet started
5622 // destroying them again, so this is the dynamic type.
5623 return DynamicType{getBaseClassType(This.Designator, PathLength),
5624 PathLength};
5625 }
5626 }
5627
5628 // CWG issue 1517: we're constructing a base class of the object described by
5629 // 'This', so that object has not yet begun its period of construction and
5630 // any polymorphic operation on it results in undefined behavior.
5631 Info.FFDiag(E);
5632 return None;
5633}
5634
5635/// Perform virtual dispatch.
5636static const CXXMethodDecl *HandleVirtualDispatch(
5637 EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found,
5638 llvm::SmallVectorImpl<QualType> &CovariantAdjustmentPath) {
5639 Optional<DynamicType> DynType = ComputeDynamicType(
5640 Info, E, This,
5641 isa<CXXDestructorDecl>(Found) ? AK_Destroy : AK_MemberCall);
5642 if (!DynType)
5643 return nullptr;
5644
5645 // Find the final overrider. It must be declared in one of the classes on the
5646 // path from the dynamic type to the static type.
5647 // FIXME: If we ever allow literal types to have virtual base classes, that
5648 // won't be true.
5649 const CXXMethodDecl *Callee = Found;
5650 unsigned PathLength = DynType->PathLength;
5651 for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) {
5652 const CXXRecordDecl *Class = getBaseClassType(This.Designator, PathLength);
5653 const CXXMethodDecl *Overrider =
5654 Found->getCorrespondingMethodDeclaredInClass(Class, false);
5655 if (Overrider) {
5656 Callee = Overrider;
5657 break;
5658 }
5659 }
5660
5661 // C++2a [class.abstract]p6:
5662 // the effect of making a virtual call to a pure virtual function [...] is
5663 // undefined
5664 if (Callee->isPure()) {
5665 Info.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << Callee;
5666 Info.Note(Callee->getLocation(), diag::note_declared_at);
5667 return nullptr;
5668 }
5669
5670 // If necessary, walk the rest of the path to determine the sequence of
5671 // covariant adjustment steps to apply.
5672 if (!Info.Ctx.hasSameUnqualifiedType(Callee->getReturnType(),
5673 Found->getReturnType())) {
5674 CovariantAdjustmentPath.push_back(Callee->getReturnType());
5675 for (unsigned CovariantPathLength = PathLength + 1;
5676 CovariantPathLength != This.Designator.Entries.size();
5677 ++CovariantPathLength) {
5678 const CXXRecordDecl *NextClass =
5679 getBaseClassType(This.Designator, CovariantPathLength);
5680 const CXXMethodDecl *Next =
5681 Found->getCorrespondingMethodDeclaredInClass(NextClass, false);
5682 if (Next && !Info.Ctx.hasSameUnqualifiedType(
5683 Next->getReturnType(), CovariantAdjustmentPath.back()))
5684 CovariantAdjustmentPath.push_back(Next->getReturnType());
5685 }
5686 if (!Info.Ctx.hasSameUnqualifiedType(Found->getReturnType(),
5687 CovariantAdjustmentPath.back()))
5688 CovariantAdjustmentPath.push_back(Found->getReturnType());
5689 }
5690
5691 // Perform 'this' adjustment.
5692 if (!CastToDerivedClass(Info, E, This, Callee->getParent(), PathLength))
5693 return nullptr;
5694
5695 return Callee;
5696}
5697
5698/// Perform the adjustment from a value returned by a virtual function to
5699/// a value of the statically expected type, which may be a pointer or
5700/// reference to a base class of the returned type.
5701static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E,
5702 APValue &Result,
5703 ArrayRef<QualType> Path) {
5704 assert(Result.isLValue() &&((void)0)
5705 "unexpected kind of APValue for covariant return")((void)0);
5706 if (Result.isNullPointer())
5707 return true;
5708
5709 LValue LVal;
5710 LVal.setFrom(Info.Ctx, Result);
5711
5712 const CXXRecordDecl *OldClass = Path[0]->getPointeeCXXRecordDecl();
5713 for (unsigned I = 1; I != Path.size(); ++I) {
5714 const CXXRecordDecl *NewClass = Path[I]->getPointeeCXXRecordDecl();
5715 assert(OldClass && NewClass && "unexpected kind of covariant return")((void)0);
5716 if (OldClass != NewClass &&
5717 !CastToBaseClass(Info, E, LVal, OldClass, NewClass))
5718 return false;
5719 OldClass = NewClass;
5720 }
5721
5722 LVal.moveInto(Result);
5723 return true;
5724}
5725
5726/// Determine whether \p Base, which is known to be a direct base class of
5727/// \p Derived, is a public base class.
5728static bool isBaseClassPublic(const CXXRecordDecl *Derived,
5729 const CXXRecordDecl *Base) {
5730 for (const CXXBaseSpecifier &BaseSpec : Derived->bases()) {
5731 auto *BaseClass = BaseSpec.getType()->getAsCXXRecordDecl();
5732 if (BaseClass && declaresSameEntity(BaseClass, Base))
5733 return BaseSpec.getAccessSpecifier() == AS_public;
5734 }
5735 llvm_unreachable("Base is not a direct base of Derived")__builtin_unreachable();
5736}
5737
5738/// Apply the given dynamic cast operation on the provided lvalue.
5739///
5740/// This implements the hard case of dynamic_cast, requiring a "runtime check"
5741/// to find a suitable target subobject.
5742static bool HandleDynamicCast(EvalInfo &Info, const ExplicitCastExpr *E,
5743 LValue &Ptr) {
5744 // We can't do anything with a non-symbolic pointer value.
5745 SubobjectDesignator &D = Ptr.Designator;
5746 if (D.Invalid)
5747 return false;
5748
5749 // C++ [expr.dynamic.cast]p6:
5750 // If v is a null pointer value, the result is a null pointer value.
5751 if (Ptr.isNullPointer() && !E->isGLValue())
5752 return true;
5753
5754 // For all the other cases, we need the pointer to point to an object within
5755 // its lifetime / period of construction / destruction, and we need to know
5756 // its dynamic type.
5757 Optional<DynamicType> DynType =
5758 ComputeDynamicType(Info, E, Ptr, AK_DynamicCast);
5759 if (!DynType)
5760 return false;
5761
5762 // C++ [expr.dynamic.cast]p7:
5763 // If T is "pointer to cv void", then the result is a pointer to the most
5764 // derived object
5765 if (E->getType()->isVoidPointerType())
5766 return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength);
5767
5768 const CXXRecordDecl *C = E->getTypeAsWritten()->getPointeeCXXRecordDecl();
5769 assert(C && "dynamic_cast target is not void pointer nor class")((void)0);
5770 CanQualType CQT = Info.Ctx.getCanonicalType(Info.Ctx.getRecordType(C));
5771
5772 auto RuntimeCheckFailed = [&] (CXXBasePaths *Paths) {
5773 // C++ [expr.dynamic.cast]p9:
5774 if (!E->isGLValue()) {
5775 // The value of a failed cast to pointer type is the null pointer value
5776 // of the required result type.
5777 Ptr.setNull(Info.Ctx, E->getType());
5778 return true;
5779 }
5780
5781 // A failed cast to reference type throws [...] std::bad_cast.
5782 unsigned DiagKind;
5783 if (!Paths && (declaresSameEntity(DynType->Type, C) ||
5784 DynType->Type->isDerivedFrom(C)))
5785 DiagKind = 0;
5786 else if (!Paths || Paths->begin() == Paths->end())
5787 DiagKind = 1;
5788 else if (Paths->isAmbiguous(CQT))
5789 DiagKind = 2;
5790 else {
5791 assert(Paths->front().Access != AS_public && "why did the cast fail?")((void)0);
5792 DiagKind = 3;
5793 }
5794 Info.FFDiag(E, diag::note_constexpr_dynamic_cast_to_reference_failed)
5795 << DiagKind << Ptr.Designator.getType(Info.Ctx)
5796 << Info.Ctx.getRecordType(DynType->Type)
5797 << E->getType().getUnqualifiedType();
5798 return false;
5799 };
5800
5801 // Runtime check, phase 1:
5802 // Walk from the base subobject towards the derived object looking for the
5803 // target type.
5804 for (int PathLength = Ptr.Designator.Entries.size();
5805 PathLength >= (int)DynType->PathLength; --PathLength) {
5806 const CXXRecordDecl *Class = getBaseClassType(Ptr.Designator, PathLength);
5807 if (declaresSameEntity(Class, C))
5808 return CastToDerivedClass(Info, E, Ptr, Class, PathLength);
5809 // We can only walk across public inheritance edges.
5810 if (PathLength > (int)DynType->PathLength &&
5811 !isBaseClassPublic(getBaseClassType(Ptr.Designator, PathLength - 1),
5812 Class))
5813 return RuntimeCheckFailed(nullptr);
5814 }
5815
5816 // Runtime check, phase 2:
5817 // Search the dynamic type for an unambiguous public base of type C.
5818 CXXBasePaths Paths(/*FindAmbiguities=*/true,
5819 /*RecordPaths=*/true, /*DetectVirtual=*/false);
5820 if (DynType->Type->isDerivedFrom(C, Paths) && !Paths.isAmbiguous(CQT) &&
5821 Paths.front().Access == AS_public) {
5822 // Downcast to the dynamic type...
5823 if (!CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength))
5824 return false;
5825 // ... then upcast to the chosen base class subobject.
5826 for (CXXBasePathElement &Elem : Paths.front())
5827 if (!HandleLValueBase(Info, E, Ptr, Elem.Class, Elem.Base))
5828 return false;
5829 return true;
5830 }
5831
5832 // Otherwise, the runtime check fails.
5833 return RuntimeCheckFailed(&Paths);
5834}
5835
5836namespace {
5837struct StartLifetimeOfUnionMemberHandler {
5838 EvalInfo &Info;
5839 const Expr *LHSExpr;
5840 const FieldDecl *Field;
5841 bool DuringInit;
5842 bool Failed = false;
5843 static const AccessKinds AccessKind = AK_Assign;
5844
5845 typedef bool result_type;
5846 bool failed() { return Failed; }
5847 bool found(APValue &Subobj, QualType SubobjType) {
5848 // We are supposed to perform no initialization but begin the lifetime of
5849 // the object. We interpret that as meaning to do what default
5850 // initialization of the object would do if all constructors involved were
5851 // trivial:
5852 // * All base, non-variant member, and array element subobjects' lifetimes
5853 // begin
5854 // * No variant members' lifetimes begin
5855 // * All scalar subobjects whose lifetimes begin have indeterminate values
5856 assert(SubobjType->isUnionType())((void)0);
5857 if (declaresSameEntity(Subobj.getUnionField(), Field)) {
5858 // This union member is already active. If it's also in-lifetime, there's
5859 // nothing to do.
5860 if (Subobj.getUnionValue().hasValue())
5861 return true;
5862 } else if (DuringInit) {
5863 // We're currently in the process of initializing a different union
5864 // member. If we carried on, that initialization would attempt to
5865 // store to an inactive union member, resulting in undefined behavior.
5866 Info.FFDiag(LHSExpr,
5867 diag::note_constexpr_union_member_change_during_init);
5868 return false;
5869 }
5870 APValue Result;
5871 Failed = !getDefaultInitValue(Field->getType(), Result);
5872 Subobj.setUnion(Field, Result);
5873 return true;
5874 }
5875 bool found(APSInt &Value, QualType SubobjType) {
5876 llvm_unreachable("wrong value kind for union object")__builtin_unreachable();
5877 }
5878 bool found(APFloat &Value, QualType SubobjType) {
5879 llvm_unreachable("wrong value kind for union object")__builtin_unreachable();
5880 }
5881};
5882} // end anonymous namespace
5883
5884const AccessKinds StartLifetimeOfUnionMemberHandler::AccessKind;
5885
5886/// Handle a builtin simple-assignment or a call to a trivial assignment
5887/// operator whose left-hand side might involve a union member access. If it
5888/// does, implicitly start the lifetime of any accessed union elements per
5889/// C++20 [class.union]5.
5890static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
5891 const LValue &LHS) {
5892 if (LHS.InvalidBase || LHS.Designator.Invalid)
92
Assuming field 'InvalidBase' is false
93
Assuming field 'Invalid' is 0
94
Taking false branch
5893 return false;
5894
5895 llvm::SmallVector<std::pair<unsigned, const FieldDecl*>, 4> UnionPathLengths;
5896 // C++ [class.union]p5:
5897 // define the set S(E) of subexpressions of E as follows:
5898 unsigned PathLength = LHS.Designator.Entries.size();
5899 for (const Expr *E = LHSExpr; E != nullptr;) {
95
Assuming pointer value is null
96
Loop condition is false. Execution continues on line 5960
5900 // -- If E is of the form A.B, S(E) contains the elements of S(A)...
5901 if (auto *ME = dyn_cast<MemberExpr>(E)) {
5902 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
5903 // Note that we can't implicitly start the lifetime of a reference,
5904 // so we don't need to proceed any further if we reach one.
5905 if (!FD || FD->getType()->isReferenceType())
5906 break;
5907
5908 // ... and also contains A.B if B names a union member ...
5909 if (FD->getParent()->isUnion()) {
5910 // ... of a non-class, non-array type, or of a class type with a
5911 // trivial default constructor that is not deleted, or an array of
5912 // such types.
5913 auto *RD =
5914 FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
5915 if (!RD || RD->hasTrivialDefaultConstructor())
5916 UnionPathLengths.push_back({PathLength - 1, FD});
5917 }
5918
5919 E = ME->getBase();
5920 --PathLength;
5921 assert(declaresSameEntity(FD,((void)0)
5922 LHS.Designator.Entries[PathLength]((void)0)
5923 .getAsBaseOrMember().getPointer()))((void)0);
5924
5925 // -- If E is of the form A[B] and is interpreted as a built-in array
5926 // subscripting operator, S(E) is [S(the array operand, if any)].
5927 } else if (auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
5928 // Step over an ArrayToPointerDecay implicit cast.
5929 auto *Base = ASE->getBase()->IgnoreImplicit();
5930 if (!Base->getType()->isArrayType())
5931 break;
5932
5933 E = Base;
5934 --PathLength;
5935
5936 } else if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
5937 // Step over a derived-to-base conversion.
5938 E = ICE->getSubExpr();
5939 if (ICE->getCastKind() == CK_NoOp)
5940 continue;
5941 if (ICE->getCastKind() != CK_DerivedToBase &&
5942 ICE->getCastKind() != CK_UncheckedDerivedToBase)
5943 break;
5944 // Walk path backwards as we walk up from the base to the derived class.
5945 for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) {
5946 --PathLength;
5947 (void)Elt;
5948 assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),((void)0)
5949 LHS.Designator.Entries[PathLength]((void)0)
5950 .getAsBaseOrMember().getPointer()))((void)0);
5951 }
5952
5953 // -- Otherwise, S(E) is empty.
5954 } else {
5955 break;
5956 }
5957 }
5958
5959 // Common case: no unions' lifetimes are started.
5960 if (UnionPathLengths.empty())
97
Calling 'SmallVectorBase::empty'
100
Returning from 'SmallVectorBase::empty'
101
Taking false branch
5961 return true;
5962
5963 // if modification of X [would access an inactive union member], an object
5964 // of the type of X is implicitly created
5965 CompleteObject Obj =
5966 findCompleteObject(Info, LHSExpr, AK_Assign, LHS, LHSExpr->getType());
102
Called C++ object pointer is null
5967 if (!Obj)
5968 return false;
5969 for (std::pair<unsigned, const FieldDecl *> LengthAndField :
5970 llvm::reverse(UnionPathLengths)) {
5971 // Form a designator for the union object.
5972 SubobjectDesignator D = LHS.Designator;
5973 D.truncate(Info.Ctx, LHS.Base, LengthAndField.first);
5974
5975 bool DuringInit = Info.isEvaluatingCtorDtor(LHS.Base, D.Entries) ==
5976 ConstructionPhase::AfterBases;
5977 StartLifetimeOfUnionMemberHandler StartLifetime{
5978 Info, LHSExpr, LengthAndField.second, DuringInit};
5979 if (!findSubobject(Info, LHSExpr, Obj, D, StartLifetime))
5980 return false;
5981 }
5982
5983 return true;
5984}
5985
5986static bool EvaluateCallArg(const ParmVarDecl *PVD, const Expr *Arg,
5987 CallRef Call, EvalInfo &Info,
5988 bool NonNull = false) {
5989 LValue LV;
5990 // Create the parameter slot and register its destruction. For a vararg
5991 // argument, create a temporary.
5992 // FIXME: For calling conventions that destroy parameters in the callee,
5993 // should we consider performing destruction when the function returns
5994 // instead?
5995 APValue &V = PVD ? Info.CurrentCall->createParam(Call, PVD, LV)
5996 : Info.CurrentCall->createTemporary(Arg, Arg->getType(),
5997 ScopeKind::Call, LV);
5998 if (!EvaluateInPlace(V, Info, LV, Arg))
5999 return false;
6000
6001 // Passing a null pointer to an __attribute__((nonnull)) parameter results in
6002 // undefined behavior, so is non-constant.
6003 if (NonNull && V.isLValue() && V.isNullPointer()) {
6004 Info.CCEDiag(Arg, diag::note_non_null_attribute_failed);
6005 return false;
6006 }
6007
6008 return true;
6009}
6010
6011/// Evaluate the arguments to a function call.
6012static bool EvaluateArgs(ArrayRef<const Expr *> Args, CallRef Call,
6013 EvalInfo &Info, const FunctionDecl *Callee,
6014 bool RightToLeft = false) {
6015 bool Success = true;
6016 llvm::SmallBitVector ForbiddenNullArgs;
6017 if (Callee->hasAttr<NonNullAttr>()) {
6018 ForbiddenNullArgs.resize(Args.size());
6019 for (const auto *Attr : Callee->specific_attrs<NonNullAttr>()) {
6020 if (!Attr->args_size()) {
6021 ForbiddenNullArgs.set();
6022 break;
6023 } else
6024 for (auto Idx : Attr->args()) {
6025 unsigned ASTIdx = Idx.getASTIndex();
6026 if (ASTIdx >= Args.size())
6027 continue;
6028 ForbiddenNullArgs[ASTIdx] = 1;
6029 }
6030 }
6031 }
6032 for (unsigned I = 0; I < Args.size(); I++) {
6033 unsigned Idx = RightToLeft ? Args.size() - I - 1 : I;
6034 const ParmVarDecl *PVD =
6035 Idx < Callee->getNumParams() ? Callee->getParamDecl(Idx) : nullptr;
6036 bool NonNull = !ForbiddenNullArgs.empty() && ForbiddenNullArgs[Idx];
6037 if (!EvaluateCallArg(PVD, Args[Idx], Call, Info, NonNull)) {
6038 // If we're checking for a potential constant expression, evaluate all
6039 // initializers even if some of them fail.
6040 if (!Info.noteFailure())
6041 return false;
6042 Success = false;
6043 }
6044 }
6045 return Success;
6046}
6047
6048/// Perform a trivial copy from Param, which is the parameter of a copy or move
6049/// constructor or assignment operator.
6050static bool handleTrivialCopy(EvalInfo &Info, const ParmVarDecl *Param,
6051 const Expr *E, APValue &Result,
6052 bool CopyObjectRepresentation) {
6053 // Find the reference argument.
6054 CallStackFrame *Frame = Info.CurrentCall;
6055 APValue *RefValue = Info.getParamSlot(Frame->Arguments, Param);
57
Calling 'EvalInfo::getParamSlot'
65
Returning from 'EvalInfo::getParamSlot'
6056 if (!RefValue) {
66
Assuming 'RefValue' is non-null
67
Taking false branch
6057 Info.FFDiag(E);
6058 return false;
6059 }
6060
6061 // Copy out the contents of the RHS object.
6062 LValue RefLValue;
6063 RefLValue.setFrom(Info.Ctx, *RefValue);
6064 return handleLValueToRValueConversion(
68
Calling 'handleLValueToRValueConversion'
84
Returning from 'handleLValueToRValueConversion'
85
Returning value, which participates in a condition later
6065 Info, E, Param->getType().getNonReferenceType(), RefLValue, Result,
6066 CopyObjectRepresentation);
6067}
6068
6069/// Evaluate a function call.
6070static bool HandleFunctionCall(SourceLocation CallLoc,
6071 const FunctionDecl *Callee, const LValue *This,
6072 ArrayRef<const Expr *> Args, CallRef Call,
6073 const Stmt *Body, EvalInfo &Info,
6074 APValue &Result, const LValue *ResultSlot) {
6075 if (!Info.CheckCallLimit(CallLoc))
17
Calling 'EvalInfo::CheckCallLimit'
28
Returning from 'EvalInfo::CheckCallLimit'
29
Taking false branch
6076 return false;
6077
6078 CallStackFrame Frame(Info, CallLoc, Callee, This, Call);
6079
6080 // For a trivial copy or move assignment, perform an APValue copy. This is
6081 // essential for unions, where the operations performed by the assignment
6082 // operator cannot be represented as statements.
6083 //
6084 // Skip this for non-union classes with no fields; in that case, the defaulted
6085 // copy/move does not actually read the object.
6086 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
30
'Callee' is a 'CXXMethodDecl'
6087 if (MD
30.1
'MD' is non-null
30.1
'MD' is non-null
30.1
'MD' is non-null
30.1
'MD' is non-null
30.1
'MD' is non-null
30.1
'MD' is non-null
&& MD->isDefaulted() &&
31
Assuming the condition is true
55
Taking true branch
6088 (MD->getParent()->isUnion() ||
32
Calling 'TagDecl::isUnion'
35
Returning from 'TagDecl::isUnion'
6089 (MD->isTrivial() &&
36
Assuming the condition is true
6090 isReadByLvalueToRvalueConversion(MD->getParent())))) {
37
Calling 'isReadByLvalueToRvalueConversion'
54
Returning from 'isReadByLvalueToRvalueConversion'
6091 assert(This &&((void)0)
6092 (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()))((void)0);
6093 APValue RHSValue;
6094 if (!handleTrivialCopy(Info, MD->getParamDecl(0), Args[0], RHSValue,
56
Calling 'handleTrivialCopy'
86
Returning from 'handleTrivialCopy'
87
Assuming the condition is false
88
Taking false branch
6095 MD->getParent()->isUnion()))
6096 return false;
6097 if (Info.getLangOpts().CPlusPlus20 && MD->isTrivial() &&
89
Assuming field 'CPlusPlus20' is not equal to 0
6098 !HandleUnionActiveMemberChange(Info, Args[0], *This))
90
Passing value via 2nd parameter 'LHSExpr'
91
Calling 'HandleUnionActiveMemberChange'
6099 return false;
6100 if (!handleAssignment(Info, Args[0], *This, MD->getThisType(),
6101 RHSValue))
6102 return false;
6103 This->moveInto(Result);
6104 return true;
6105 } else if (MD && isLambdaCallOperator(MD)) {
6106 // We're in a lambda; determine the lambda capture field maps unless we're
6107 // just constexpr checking a lambda's call operator. constexpr checking is
6108 // done before the captures have been added to the closure object (unless
6109 // we're inferring constexpr-ness), so we don't have access to them in this
6110 // case. But since we don't need the captures to constexpr check, we can
6111 // just ignore them.
6112 if (!Info.checkingPotentialConstantExpression())
6113 MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
6114 Frame.LambdaThisCaptureField);
6115 }
6116
6117 StmtResult Ret = {Result, ResultSlot};
6118 EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body);
6119 if (ESR == ESR_Succeeded) {
6120 if (Callee->getReturnType()->isVoidType())
6121 return true;
6122 Info.FFDiag(Callee->getEndLoc(), diag::note_constexpr_no_return);
6123 }
6124 return ESR == ESR_Returned;
6125}
6126
6127/// Evaluate a constructor call.
6128static bool HandleConstructorCall(const Expr *E, const LValue &This,
6129 CallRef Call,
6130 const CXXConstructorDecl *Definition,
6131 EvalInfo &Info, APValue &Result) {
6132 SourceLocation CallLoc = E->getExprLoc();
6133 if (!Info.CheckCallLimit(CallLoc))
6134 return false;
6135
6136 const CXXRecordDecl *RD = Definition->getParent();
6137 if (RD->getNumVBases()) {
6138 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
6139 return false;
6140 }
6141
6142 EvalInfo::EvaluatingConstructorRAII EvalObj(
6143 Info,
6144 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
6145 RD->getNumBases());
6146 CallStackFrame Frame(Info, CallLoc, Definition, &This, Call);
6147
6148 // FIXME: Creating an APValue just to hold a nonexistent return value is
6149 // wasteful.
6150 APValue RetVal;
6151 StmtResult Ret = {RetVal, nullptr};
6152
6153 // If it's a delegating constructor, delegate.
6154 if (Definition->isDelegatingConstructor()) {
6155 CXXConstructorDecl::init_const_iterator I = Definition->init_begin();
6156 if ((*I)->getInit()->isValueDependent()) {
6157 if (!EvaluateDependentExpr((*I)->getInit(), Info))
6158 return false;
6159 } else {
6160 FullExpressionRAII InitScope(Info);
6161 if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()) ||
6162 !InitScope.destroy())
6163 return false;
6164 }
6165 return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed;
6166 }
6167
6168 // For a trivial copy or move constructor, perform an APValue copy. This is
6169 // essential for unions (or classes with anonymous union members), where the
6170 // operations performed by the constructor cannot be represented by
6171 // ctor-initializers.
6172 //
6173 // Skip this for empty non-union classes; we should not perform an
6174 // lvalue-to-rvalue conversion on them because their copy constructor does not
6175 // actually read them.
6176 if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() &&
6177 (Definition->getParent()->isUnion() ||
6178 (Definition->isTrivial() &&
6179 isReadByLvalueToRvalueConversion(Definition->getParent())))) {
6180 return handleTrivialCopy(Info, Definition->getParamDecl(0), E, Result,
6181 Definition->getParent()->isUnion());
6182 }
6183
6184 // Reserve space for the struct members.
6185 if (!Result.hasValue()) {
6186 if (!RD->isUnion())
6187 Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
6188 std::distance(RD->field_begin(), RD->field_end()));
6189 else
6190 // A union starts with no active member.
6191 Result = APValue((const FieldDecl*)nullptr);
6192 }
6193
6194 if (RD->isInvalidDecl()) return false;
6195 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6196
6197 // A scope for temporaries lifetime-extended by reference members.
6198 BlockScopeRAII LifetimeExtendedScope(Info);
6199
6200 bool Success = true;
6201 unsigned BasesSeen = 0;
6202#ifndef NDEBUG1
6203 CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin();
6204#endif
6205 CXXRecordDecl::field_iterator FieldIt = RD->field_begin();
6206 auto SkipToField = [&](FieldDecl *FD, bool Indirect) {
6207 // We might be initializing the same field again if this is an indirect
6208 // field initialization.
6209 if (FieldIt == RD->field_end() ||
6210 FieldIt->getFieldIndex() > FD->getFieldIndex()) {
6211 assert(Indirect && "fields out of order?")((void)0);
6212 return;
6213 }
6214
6215 // Default-initialize any fields with no explicit initializer.
6216 for (; !declaresSameEntity(*FieldIt, FD); ++FieldIt) {
6217 assert(FieldIt != RD->field_end() && "missing field?")((void)0);
6218 if (!FieldIt->isUnnamedBitfield())
6219 Success &= getDefaultInitValue(
6220 FieldIt->getType(),
6221 Result.getStructField(FieldIt->getFieldIndex()));
6222 }
6223 ++FieldIt;
6224 };
6225 for (const auto *I : Definition->inits()) {
6226 LValue Subobject = This;
6227 LValue SubobjectParent = This;
6228 APValue *Value = &Result;
6229
6230 // Determine the subobject to initialize.
6231 FieldDecl *FD = nullptr;
6232 if (I->isBaseInitializer()) {
6233 QualType BaseType(I->getBaseClass(), 0);
6234#ifndef NDEBUG1
6235 // Non-virtual base classes are initialized in the order in the class
6236 // definition. We have already checked for virtual base classes.
6237 assert(!BaseIt->isVirtual() && "virtual base for literal type")((void)0);
6238 assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&((void)0)
6239 "base class initializers not in expected order")((void)0);
6240 ++BaseIt;
6241#endif
6242 if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
6243 BaseType->getAsCXXRecordDecl(), &Layout))
6244 return false;
6245 Value = &Result.getStructBase(BasesSeen++);
6246 } else if ((FD = I->getMember())) {
6247 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
6248 return false;
6249 if (RD->isUnion()) {
6250 Result = APValue(FD);
6251 Value = &Result.getUnionValue();
6252 } else {
6253 SkipToField(FD, false);
6254 Value = &Result.getStructField(FD->getFieldIndex());
6255 }
6256 } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) {
6257 // Walk the indirect field decl's chain to find the object to initialize,
6258 // and make sure we've initialized every step along it.
6259 auto IndirectFieldChain = IFD->chain();
6260 for (auto *C : IndirectFieldChain) {
6261 FD = cast<FieldDecl>(C);
6262 CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent());
6263 // Switch the union field if it differs. This happens if we had
6264 // preceding zero-initialization, and we're now initializing a union
6265 // subobject other than the first.
6266 // FIXME: In this case, the values of the other subobjects are
6267 // specified, since zero-initialization sets all padding bits to zero.
6268 if (!Value->hasValue() ||
6269 (Value->isUnion() && Value->getUnionField() != FD)) {
6270 if (CD->isUnion())
6271 *Value = APValue(FD);
6272 else
6273 // FIXME: This immediately starts the lifetime of all members of
6274 // an anonymous struct. It would be preferable to strictly start
6275 // member lifetime in initialization order.
6276 Success &= getDefaultInitValue(Info.Ctx.getRecordType(CD), *Value);
6277 }
6278 // Store Subobject as its parent before updating it for the last element
6279 // in the chain.
6280 if (C == IndirectFieldChain.back())
6281 SubobjectParent = Subobject;
6282 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
6283 return false;
6284 if (CD->isUnion())
6285 Value = &Value->getUnionValue();
6286 else {
6287 if (C == IndirectFieldChain.front() && !RD->isUnion())
6288 SkipToField(FD, true);
6289 Value = &Value->getStructField(FD->getFieldIndex());
6290 }
6291 }
6292 } else {
6293 llvm_unreachable("unknown base initializer kind")__builtin_unreachable();
6294 }
6295
6296 // Need to override This for implicit field initializers as in this case
6297 // This refers to innermost anonymous struct/union containing initializer,
6298 // not to currently constructed class.
6299 const Expr *Init = I->getInit();
6300 if (Init->isValueDependent()) {
6301 if (!EvaluateDependentExpr(Init, Info))
6302 return false;
6303 } else {
6304 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent,
6305 isa<CXXDefaultInitExpr>(Init));
6306 FullExpressionRAII InitScope(Info);
6307 if (!EvaluateInPlace(*Value, Info, Subobject, Init) ||
6308 (FD && FD->isBitField() &&
6309 !truncateBitfieldValue(Info, Init, *Value, FD))) {
6310 // If we're checking for a potential constant expression, evaluate all
6311 // initializers even if some of them fail.
6312 if (!Info.noteFailure())
6313 return false;
6314 Success = false;
6315 }
6316 }
6317
6318 // This is the point at which the dynamic type of the object becomes this
6319 // class type.
6320 if (I->isBaseInitializer() && BasesSeen == RD->getNumBases())
6321 EvalObj.finishedConstructingBases();
6322 }
6323
6324 // Default-initialize any remaining fields.
6325 if (!RD->isUnion()) {
6326 for (; FieldIt != RD->field_end(); ++FieldIt) {
6327 if (!FieldIt->isUnnamedBitfield())
6328 Success &= getDefaultInitValue(
6329 FieldIt->getType(),
6330 Result.getStructField(FieldIt->getFieldIndex()));
6331 }
6332 }
6333
6334 EvalObj.finishedConstructingFields();
6335
6336 return Success &&
6337 EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed &&
6338 LifetimeExtendedScope.destroy();
6339}
6340
6341static bool HandleConstructorCall(const Expr *E, const LValue &This,
6342 ArrayRef<const Expr*> Args,
6343 const CXXConstructorDecl *Definition,
6344 EvalInfo &Info, APValue &Result) {
6345 CallScopeRAII CallScope(Info);
6346 CallRef Call = Info.CurrentCall->createCall(Definition);
6347 if (!EvaluateArgs(Args, Call, Info, Definition))
6348 return false;
6349
6350 return HandleConstructorCall(E, This, Call, Definition, Info, Result) &&
6351 CallScope.destroy();
6352}
6353
6354static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc,
6355 const LValue &This, APValue &Value,
6356 QualType T) {
6357 // Objects can only be destroyed while they're within their lifetimes.
6358 // FIXME: We have no representation for whether an object of type nullptr_t
6359 // is in its lifetime; it usually doesn't matter. Perhaps we should model it
6360 // as indeterminate instead?
6361 if (Value.isAbsent() && !T->isNullPtrType()) {
6362 APValue Printable;
6363 This.moveInto(Printable);
6364 Info.FFDiag(CallLoc, diag::note_constexpr_destroy_out_of_lifetime)
6365 << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T));
6366 return false;
6367 }
6368
6369 // Invent an expression for location purposes.
6370 // FIXME: We shouldn't need to do this.
6371 OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_PRValue);
6372
6373 // For arrays, destroy elements right-to-left.
6374 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(T)) {
6375 uint64_t Size = CAT->getSize().getZExtValue();
6376 QualType ElemT = CAT->getElementType();
6377
6378 LValue ElemLV = This;
6379 ElemLV.addArray(Info, &LocE, CAT);
6380 if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, Size))
6381 return false;
6382
6383 // Ensure that we have actual array elements available to destroy; the
6384 // destructors might mutate the value, so we can't run them on the array
6385 // filler.
6386 if (Size && Size > Value.getArrayInitializedElts())
6387 expandArray(Value, Value.getArraySize() - 1);
6388
6389 for (; Size != 0; --Size) {
6390 APValue &Elem = Value.getArrayInitializedElt(Size - 1);
6391 if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, -1) ||
6392 !HandleDestructionImpl(Info, CallLoc, ElemLV, Elem, ElemT))
6393 return false;
6394 }
6395
6396 // End the lifetime of this array now.
6397 Value = APValue();
6398 return true;
6399 }
6400
6401 const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
6402 if (!RD) {
6403 if (T.isDestructedType()) {
6404 Info.FFDiag(CallLoc, diag::note_constexpr_unsupported_destruction) << T;
6405 return false;
6406 }
6407
6408 Value = APValue();
6409 return true;
6410 }
6411
6412 if (RD->getNumVBases()) {
6413 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
6414 return false;
6415 }
6416
6417 const CXXDestructorDecl *DD = RD->getDestructor();
6418 if (!DD && !RD->hasTrivialDestructor()) {
6419 Info.FFDiag(CallLoc);
6420 return false;
6421 }
6422
6423 if (!DD || DD->isTrivial() ||
6424 (RD->isAnonymousStructOrUnion() && RD->isUnion())) {
6425 // A trivial destructor just ends the lifetime of the object. Check for
6426 // this case before checking for a body, because we might not bother
6427 // building a body for a trivial destructor. Note that it doesn't matter
6428 // whether the destructor is constexpr in this case; all trivial
6429 // destructors are constexpr.
6430 //
6431 // If an anonymous union would be destroyed, some enclosing destructor must
6432 // have been explicitly defined, and the anonymous union destruction should
6433 // have no effect.
6434 Value = APValue();
6435 return true;
6436 }
6437
6438 if (!Info.CheckCallLimit(CallLoc))
6439 return false;
6440
6441 const FunctionDecl *Definition = nullptr;
6442 const Stmt *Body = DD->getBody(Definition);
6443
6444 if (!CheckConstexprFunction(Info, CallLoc, DD, Definition, Body))
6445 return false;
6446
6447 CallStackFrame Frame(Info, CallLoc, Definition, &This, CallRef());
6448
6449 // We're now in the period of destruction of this object.
6450 unsigned BasesLeft = RD->getNumBases();
6451 EvalInfo::EvaluatingDestructorRAII EvalObj(
6452 Info,
6453 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries});
6454 if (!EvalObj.DidInsert) {
6455 // C++2a [class.dtor]p19:
6456 // the behavior is undefined if the destructor is invoked for an object
6457 // whose lifetime has ended
6458 // (Note that formally the lifetime ends when the period of destruction
6459 // begins, even though certain uses of the object remain valid until the
6460 // period of destruction ends.)
6461 Info.FFDiag(CallLoc, diag::note_constexpr_double_destroy);
6462 return false;
6463 }
6464
6465 // FIXME: Creating an APValue just to hold a nonexistent return value is
6466 // wasteful.
6467 APValue RetVal;
6468 StmtResult Ret = {RetVal, nullptr};
6469 if (EvaluateStmt(Ret, Info, Definition->getBody()) == ESR_Failed)
6470 return false;
6471
6472 // A union destructor does not implicitly destroy its members.
6473 if (RD->isUnion())
6474 return true;
6475
6476 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6477
6478 // We don't have a good way to iterate fields in reverse, so collect all the
6479 // fields first and then walk them backwards.
6480 SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end());
6481 for (const FieldDecl *FD : llvm::reverse(Fields)) {
6482 if (FD->isUnnamedBitfield())
6483 continue;
6484
6485 LValue Subobject = This;
6486 if (!HandleLValueMember(Info, &LocE, Subobject, FD, &Layout))
6487 return false;
6488
6489 APValue *SubobjectValue = &Value.getStructField(FD->getFieldIndex());
6490 if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue,
6491 FD->getType()))
6492 return false;
6493 }
6494
6495 if (BasesLeft != 0)
6496 EvalObj.startedDestroyingBases();
6497
6498 // Destroy base classes in reverse order.
6499 for (const CXXBaseSpecifier &Base : llvm::reverse(RD->bases())) {
6500 --BasesLeft;
6501
6502 QualType BaseType = Base.getType();
6503 LValue Subobject = This;
6504 if (!HandleLValueDirectBase(Info, &LocE, Subobject, RD,
6505 BaseType->getAsCXXRecordDecl(), &Layout))
6506 return false;
6507
6508 APValue *SubobjectValue = &Value.getStructBase(BasesLeft);
6509 if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue,
6510 BaseType))
6511 return false;
6512 }
6513 assert(BasesLeft == 0 && "NumBases was wrong?")((void)0);
6514
6515 // The period of destruction ends now. The object is gone.
6516 Value = APValue();
6517 return true;
6518}
6519
6520namespace {
6521struct DestroyObjectHandler {
6522 EvalInfo &Info;
6523 const Expr *E;
6524 const LValue &This;
6525 const AccessKinds AccessKind;
6526
6527 typedef bool result_type;
6528 bool failed() { return false; }
6529 bool found(APValue &Subobj, QualType SubobjType) {
6530 return HandleDestructionImpl(Info, E->getExprLoc(), This, Subobj,
6531 SubobjType);
6532 }
6533 bool found(APSInt &Value, QualType SubobjType) {
6534 Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);
6535 return false;
6536 }
6537 bool found(APFloat &Value, QualType SubobjType) {
6538 Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);
6539 return false;
6540 }
6541};
6542}
6543
6544/// Perform a destructor or pseudo-destructor call on the given object, which
6545/// might in general not be a complete object.
6546static bool HandleDestruction(EvalInfo &Info, const Expr *E,
6547 const LValue &This, QualType ThisType) {
6548 CompleteObject Obj = findCompleteObject(Info, E, AK_Destroy, This, ThisType);
6549 DestroyObjectHandler Handler = {Info, E, This, AK_Destroy};
6550 return Obj && findSubobject(Info, E, Obj, This.Designator, Handler);
6551}
6552
6553/// Destroy and end the lifetime of the given complete object.
6554static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc,
6555 APValue::LValueBase LVBase, APValue &Value,
6556 QualType T) {
6557 // If we've had an unmodeled side-effect, we can't rely on mutable state
6558 // (such as the object we're about to destroy) being correct.
6559 if (Info.EvalStatus.HasSideEffects)
6560 return false;
6561
6562 LValue LV;
6563 LV.set({LVBase});
6564 return HandleDestructionImpl(Info, Loc, LV, Value, T);
6565}
6566
6567/// Perform a call to 'perator new' or to `__builtin_operator_new'.
6568static bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E,
6569 LValue &Result) {
6570 if (Info.checkingPotentialConstantExpression() ||
6571 Info.SpeculativeEvaluationDepth)
6572 return false;
6573
6574 // This is permitted only within a call to std::allocator<T>::allocate.
6575 auto Caller = Info.getStdAllocatorCaller("allocate");
6576 if (!Caller) {
6577 Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus20
6578 ? diag::note_constexpr_new_untyped
6579 : diag::note_constexpr_new);
6580 return false;
6581 }
6582
6583 QualType ElemType = Caller.ElemType;
6584 if (ElemType->isIncompleteType() || ElemType->isFunctionType()) {
6585 Info.FFDiag(E->getExprLoc(),
6586 diag::note_constexpr_new_not_complete_object_type)
6587 << (ElemType->isIncompleteType() ? 0 : 1) << ElemType;
6588 return false;
6589 }
6590
6591 APSInt ByteSize;
6592 if (!EvaluateInteger(E->getArg(0), ByteSize, Info))
6593 return false;
6594 bool IsNothrow = false;
6595 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) {
6596 EvaluateIgnoredValue(Info, E->getArg(I));
6597 IsNothrow |= E->getType()->isNothrowT();
6598 }
6599
6600 CharUnits ElemSize;
6601 if (!HandleSizeof(Info, E->getExprLoc(), ElemType, ElemSize))
6602 return false;
6603 APInt Size, Remainder;
6604 APInt ElemSizeAP(ByteSize.getBitWidth(), ElemSize.getQuantity());
6605 APInt::udivrem(ByteSize, ElemSizeAP, Size, Remainder);
6606 if (Remainder != 0) {
6607 // This likely indicates a bug in the implementation of 'std::allocator'.
6608 Info.FFDiag(E->getExprLoc(), diag::note_constexpr_operator_new_bad_size)
6609 << ByteSize << APSInt(ElemSizeAP, true) << ElemType;
6610 return false;
6611 }
6612
6613 if (ByteSize.getActiveBits() > ConstantArrayType::getMaxSizeBits(Info.Ctx)) {
6614 if (IsNothrow) {
6615 Result.setNull(Info.Ctx, E->getType());
6616 return true;
6617 }
6618
6619 Info.FFDiag(E, diag::note_constexpr_new_too_large) << APSInt(Size, true);
6620 return false;
6621 }
6622
6623 QualType AllocType = Info.Ctx.getConstantArrayType(ElemType, Size, nullptr,
6624 ArrayType::Normal, 0);
6625 APValue *Val = Info.createHeapAlloc(E, AllocType, Result);
6626 *Val = APValue(APValue::UninitArray(), 0, Size.getZExtValue());
6627 Result.addArray(Info, E, cast<ConstantArrayType>(AllocType));
6628 return true;
6629}
6630
6631static bool hasVirtualDestructor(QualType T) {
6632 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
6633 if (CXXDestructorDecl *DD = RD->getDestructor())
6634 return DD->isVirtual();
6635 return false;
6636}
6637
6638static const FunctionDecl *getVirtualOperatorDelete(QualType T) {
6639 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
6640 if (CXXDestructorDecl *DD = RD->getDestructor())
6641 return DD->isVirtual() ? DD->getOperatorDelete() : nullptr;
6642 return nullptr;
6643}
6644
6645/// Check that the given object is a suitable pointer to a heap allocation that
6646/// still exists and is of the right kind for the purpose of a deletion.
6647///
6648/// On success, returns the heap allocation to deallocate. On failure, produces
6649/// a diagnostic and returns None.
6650static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
6651 const LValue &Pointer,
6652 DynAlloc::Kind DeallocKind) {
6653 auto PointerAsString = [&] {
6654 return Pointer.toString(Info.Ctx, Info.Ctx.VoidPtrTy);
6655 };
6656
6657 DynamicAllocLValue DA = Pointer.Base.dyn_cast<DynamicAllocLValue>();
6658 if (!DA) {
6659 Info.FFDiag(E, diag::note_constexpr_delete_not_heap_alloc)
6660 << PointerAsString();
6661 if (Pointer.Base)
6662 NoteLValueLocation(Info, Pointer.Base);
6663 return None;
6664 }
6665
6666 Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
6667 if (!Alloc) {
6668 Info.FFDiag(E, diag::note_constexpr_double_delete);
6669 return None;
6670 }
6671
6672 QualType AllocType = Pointer.Base.getDynamicAllocType();
6673 if (DeallocKind != (*Alloc)->getKind()) {
6674 Info.FFDiag(E, diag::note_constexpr_new_delete_mismatch)
6675 << DeallocKind << (*Alloc)->getKind() << AllocType;
6676 NoteLValueLocation(Info, Pointer.Base);
6677 return None;
6678 }
6679
6680 bool Subobject = false;
6681 if (DeallocKind == DynAlloc::New) {
6682 Subobject = Pointer.Designator.MostDerivedPathLength != 0 ||
6683 Pointer.Designator.isOnePastTheEnd();
6684 } else {
6685 Subobject = Pointer.Designator.Entries.size() != 1 ||
6686 Pointer.Designator.Entries[0].getAsArrayIndex() != 0;
6687 }
6688 if (Subobject) {
6689 Info.FFDiag(E, diag::note_constexpr_delete_subobject)
6690 << PointerAsString() << Pointer.Designator.isOnePastTheEnd();
6691 return None;
6692 }
6693
6694 return Alloc;
6695}
6696
6697// Perform a call to 'operator delete' or '__builtin_operator_delete'.
6698bool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) {
6699 if (Info.checkingPotentialConstantExpression() ||
6700 Info.SpeculativeEvaluationDepth)
6701 return false;
6702
6703 // This is permitted only within a call to std::allocator<T>::deallocate.
6704 if (!Info.getStdAllocatorCaller("deallocate")) {
6705 Info.FFDiag(E->getExprLoc());
6706 return true;
6707 }
6708
6709 LValue Pointer;
6710 if (!EvaluatePointer(E->getArg(0), Pointer, Info))
6711 return false;
6712 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I)
6713 EvaluateIgnoredValue(Info, E->getArg(I));
6714
6715 if (Pointer.Designator.Invalid)
6716 return false;
6717
6718 // Deleting a null pointer would have no effect, but it's not permitted by
6719 // std::allocator<T>::deallocate's contract.
6720 if (Pointer.isNullPointer()) {
6721 Info.CCEDiag(E->getExprLoc(), diag::note_constexpr_deallocate_null);
6722 return true;
6723 }
6724
6725 if (!CheckDeleteKind(Info, E, Pointer, DynAlloc::StdAllocator))
6726 return false;
6727
6728 Info.HeapAllocs.erase(Pointer.Base.get<DynamicAllocLValue>());
6729 return true;
6730}
6731
6732//===----------------------------------------------------------------------===//
6733// Generic Evaluation
6734//===----------------------------------------------------------------------===//
6735namespace {
6736
6737class BitCastBuffer {
6738 // FIXME: We're going to need bit-level granularity when we support
6739 // bit-fields.
6740 // FIXME: Its possible under the C++ standard for 'char' to not be 8 bits, but
6741 // we don't support a host or target where that is the case. Still, we should
6742 // use a more generic type in case we ever do.
6743 SmallVector<Optional<unsigned char>, 32> Bytes;
6744
6745 static_assert(std::numeric_limits<unsigned char>::digits >= 8,
6746 "Need at least 8 bit unsigned char");
6747
6748 bool TargetIsLittleEndian;
6749
6750public:
6751 BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian)
6752 : Bytes(Width.getQuantity()),
6753 TargetIsLittleEndian(TargetIsLittleEndian) {}
6754
6755 LLVM_NODISCARD[[clang::warn_unused_result]]
6756 bool readObject(CharUnits Offset, CharUnits Width,
6757 SmallVectorImpl<unsigned char> &Output) const {
6758 for (CharUnits I = Offset, E = Offset + Width; I != E; ++I) {
6759 // If a byte of an integer is uninitialized, then the whole integer is
6760 // uninitalized.
6761 if (!Bytes[I.getQuantity()])
6762 return false;
6763 Output.push_back(*Bytes[I.getQuantity()]);
6764 }
6765 if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
6766 std::reverse(Output.begin(), Output.end());
6767 return true;
6768 }
6769
6770 void writeObject(CharUnits Offset, SmallVectorImpl<unsigned char> &Input) {
6771 if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian)
6772 std::reverse(Input.begin(), Input.end());
6773
6774 size_t Index = 0;
6775 for (unsigned char Byte : Input) {
6776 assert(!Bytes[Offset.getQuantity() + Index] && "overwriting a byte?")((void)0);
6777 Bytes[Offset.getQuantity() + Index] = Byte;
6778 ++Index;
6779 }
6780 }
6781
6782 size_t size() { return Bytes.size(); }
6783};
6784
6785/// Traverse an APValue to produce an BitCastBuffer, emulating how the current
6786/// target would represent the value at runtime.
6787class APValueToBufferConverter {
6788 EvalInfo &Info;
6789 BitCastBuffer Buffer;
6790 const CastExpr *BCE;
6791
6792 APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth,
6793 const CastExpr *BCE)
6794 : Info(Info),
6795 Buffer(ObjectWidth, Info.Ctx.getTargetInfo().isLittleEndian()),
6796 BCE(BCE) {}
6797
6798 bool visit(const APValue &Val, QualType Ty) {
6799 return visit(Val, Ty, CharUnits::fromQuantity(0));
6800 }
6801
6802 // Write out Val with type Ty into Buffer starting at Offset.
6803 bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
6804 assert((size_t)Offset.getQuantity() <= Buffer.size())((void)0);
6805
6806 // As a special case, nullptr_t has an indeterminate value.
6807 if (Ty->isNullPtrType())
6808 return true;
6809
6810 // Dig through Src to find the byte at SrcOffset.
6811 switch (Val.getKind()) {
6812 case APValue::Indeterminate:
6813 case APValue::None:
6814 return true;
6815
6816 case APValue::Int:
6817 return visitInt(Val.getInt(), Ty, Offset);
6818 case APValue::Float:
6819 return visitFloat(Val.getFloat(), Ty, Offset);
6820 case APValue::Array:
6821 return visitArray(Val, Ty, Offset);
6822 case APValue::Struct:
6823 return visitRecord(Val, Ty, Offset);
6824
6825 case APValue::ComplexInt:
6826 case APValue::ComplexFloat:
6827 case APValue::Vector:
6828 case APValue::FixedPoint:
6829 // FIXME: We should support these.
6830
6831 case APValue::Union:
6832 case APValue::MemberPointer:
6833 case APValue::AddrLabelDiff: {
6834 Info.FFDiag(BCE->getBeginLoc(),
6835 diag::note_constexpr_bit_cast_unsupported_type)
6836 << Ty;
6837 return false;
6838 }
6839
6840 case APValue::LValue:
6841 llvm_unreachable("LValue subobject in bit_cast?")__builtin_unreachable();
6842 }
6843 llvm_unreachable("Unhandled APValue::ValueKind")__builtin_unreachable();
6844 }
6845
6846 bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {
6847 const RecordDecl *RD = Ty->getAsRecordDecl();
6848 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
6849
6850 // Visit the base classes.
6851 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
6852 for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
6853 const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
6854 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
6855
6856 if (!visitRecord(Val.getStructBase(I), BS.getType(),
6857 Layout.getBaseClassOffset(BaseDecl) + Offset))
6858 return false;
6859 }
6860 }
6861
6862 // Visit the fields.
6863 unsigned FieldIdx = 0;
6864 for (FieldDecl *FD : RD->fields()) {
6865 if (FD->isBitField()) {
6866 Info.FFDiag(BCE->getBeginLoc(),
6867 diag::note_constexpr_bit_cast_unsupported_bitfield);
6868 return false;
6869 }
6870
6871 uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
6872
6873 assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0 &&((void)0)
6874 "only bit-fields can have sub-char alignment")((void)0);
6875 CharUnits FieldOffset =
6876 Info.Ctx.toCharUnitsFromBits(FieldOffsetBits) + Offset;
6877 QualType FieldTy = FD->getType();
6878 if (!visit(Val.getStructField(FieldIdx), FieldTy, FieldOffset))
6879 return false;
6880 ++FieldIdx;
6881 }
6882
6883 return true;
6884 }
6885
6886 bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) {
6887 const auto *CAT =
6888 dyn_cast_or_null<ConstantArrayType>(Ty->getAsArrayTypeUnsafe());
6889 if (!CAT)
6890 return false;
6891
6892 CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(CAT->getElementType());
6893 unsigned NumInitializedElts = Val.getArrayInitializedElts();
6894 unsigned ArraySize = Val.getArraySize();
6895 // First, initialize the initialized elements.
6896 for (unsigned I = 0; I != NumInitializedElts; ++I) {
6897 const APValue &SubObj = Val.getArrayInitializedElt(I);
6898 if (!visit(SubObj, CAT->getElementType(), Offset + I * ElemWidth))
6899 return false;
6900 }
6901
6902 // Next, initialize the rest of the array using the filler.
6903 if (Val.hasArrayFiller()) {
6904 const APValue &Filler = Val.getArrayFiller();
6905 for (unsigned I = NumInitializedElts; I != ArraySize; ++I) {
6906 if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth))
6907 return false;
6908 }
6909 }
6910
6911 return true;
6912 }
6913
6914 bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
6915 APSInt AdjustedVal = Val;
6916 unsigned Width = AdjustedVal.getBitWidth();
6917 if (Ty->isBooleanType()) {
6918 Width = Info.Ctx.getTypeSize(Ty);
6919 AdjustedVal = AdjustedVal.extend(Width);
6920 }
6921
6922 SmallVector<unsigned char, 8> Bytes(Width / 8);
6923 llvm::StoreIntToMemory(AdjustedVal, &*Bytes.begin(), Width / 8);
6924 Buffer.writeObject(Offset, Bytes);
6925 return true;
6926 }
6927
6928 bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
6929 APSInt AsInt(Val.bitcastToAPInt());
6930 return visitInt(AsInt, Ty, Offset);
6931 }
6932
6933public:
6934 static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src,
6935 const CastExpr *BCE) {
6936 CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType());
6937 APValueToBufferConverter Converter(Info, DstSize, BCE);
6938 if (!Converter.visit(Src, BCE->getSubExpr()->getType()))
6939 return None;
6940 return Converter.Buffer;
6941 }
6942};
6943
6944/// Write an BitCastBuffer into an APValue.
6945class BufferToAPValueConverter {
6946 EvalInfo &Info;
6947 const BitCastBuffer &Buffer;
6948 const CastExpr *BCE;
6949
6950 BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer,
6951 const CastExpr *BCE)
6952 : Info(Info), Buffer(Buffer), BCE(BCE) {}
6953
6954 // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast
6955 // with an invalid type, so anything left is a deficiency on our part (FIXME).
6956 // Ideally this will be unreachable.
6957 llvm::NoneType unsupportedType(QualType Ty) {
6958 Info.FFDiag(BCE->getBeginLoc(),
6959 diag::note_constexpr_bit_cast_unsupported_type)
6960 << Ty;
6961 return None;
6962 }
6963
6964 llvm::NoneType unrepresentableValue(QualType Ty, const APSInt &Val) {
6965 Info.FFDiag(BCE->getBeginLoc(),
6966 diag::note_constexpr_bit_cast_unrepresentable_value)
6967 << Ty << toString(Val, /*Radix=*/10);
6968 return None;
6969 }
6970
6971 Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
6972 const EnumType *EnumSugar = nullptr) {
6973 if (T->isNullPtrType()) {
6974 uint64_t NullValue = Info.Ctx.getTargetNullPointerValue(QualType(T, 0));
6975 return APValue((Expr *)nullptr,
6976 /*Offset=*/CharUnits::fromQuantity(NullValue),
6977 APValue::NoLValuePath{}, /*IsNullPtr=*/true);
6978 }
6979
6980 CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T);
6981
6982 // Work around floating point types that contain unused padding bytes. This
6983 // is really just `long double` on x86, which is the only fundamental type
6984 // with padding bytes.
6985 if (T->isRealFloatingType()) {
6986 const llvm::fltSemantics &Semantics =
6987 Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
6988 unsigned NumBits = llvm::APFloatBase::getSizeInBits(Semantics);
6989 assert(NumBits % 8 == 0)((void)0);
6990 CharUnits NumBytes = CharUnits::fromQuantity(NumBits / 8);
6991 if (NumBytes != SizeOf)
6992 SizeOf = NumBytes;
6993 }
6994
6995 SmallVector<uint8_t, 8> Bytes;
6996 if (!Buffer.readObject(Offset, SizeOf, Bytes)) {
6997 // If this is std::byte or unsigned char, then its okay to store an
6998 // indeterminate value.
6999 bool IsStdByte = EnumSugar && EnumSugar->isStdByteType();
7000 bool IsUChar =
7001 !EnumSugar && (T->isSpecificBuiltinType(BuiltinType::UChar) ||
7002 T->isSpecificBuiltinType(BuiltinType::Char_U));
7003 if (!IsStdByte && !IsUChar) {
7004 QualType DisplayType(EnumSugar ? (const Type *)EnumSugar : T, 0);
7005 Info.FFDiag(BCE->getExprLoc(),
7006 diag::note_constexpr_bit_cast_indet_dest)
7007 << DisplayType << Info.Ctx.getLangOpts().CharIsSigned;
7008 return None;
7009 }
7010
7011 return APValue::IndeterminateValue();
7012 }
7013
7014 APSInt Val(SizeOf.getQuantity() * Info.Ctx.getCharWidth(), true);
7015 llvm::LoadIntFromMemory(Val, &*Bytes.begin(), Bytes.size());
7016
7017 if (T->isIntegralOrEnumerationType()) {
7018 Val.setIsSigned(T->isSignedIntegerOrEnumerationType());
7019
7020 unsigned IntWidth = Info.Ctx.getIntWidth(QualType(T, 0));
7021 if (IntWidth != Val.getBitWidth()) {
7022 APSInt Truncated = Val.trunc(IntWidth);
7023 if (Truncated.extend(Val.getBitWidth()) != Val)
7024 return unrepresentableValue(QualType(T, 0), Val);
7025 Val = Truncated;
7026 }
7027
7028 return APValue(Val);
7029 }
7030
7031 if (T->isRealFloatingType()) {
7032 const llvm::fltSemantics &Semantics =
7033 Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
7034 return APValue(APFloat(Semantics, Val));
7035 }
7036
7037 return unsupportedType(QualType(T, 0));
7038 }
7039
7040 Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
7041 const RecordDecl *RD = RTy->getAsRecordDecl();
7042 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
7043
7044 unsigned NumBases = 0;
7045 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
7046 NumBases = CXXRD->getNumBases();
7047
7048 APValue ResultVal(APValue::UninitStruct(), NumBases,
7049 std::distance(RD->field_begin(), RD->field_end()));
7050
7051 // Visit the base classes.
7052 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
7053 for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
7054 const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
7055 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
7056 if (BaseDecl->isEmpty() ||
7057 Info.Ctx.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
7058 continue;
7059
7060 Optional<APValue> SubObj = visitType(
7061 BS.getType(), Layout.getBaseClassOffset(BaseDecl) + Offset);
7062 if (!SubObj)
7063 return None;
7064 ResultVal.getStructBase(I) = *SubObj;
7065 }
7066 }
7067
7068 // Visit the fields.
7069 unsigned FieldIdx = 0;
7070 for (FieldDecl *FD : RD->fields()) {
7071 // FIXME: We don't currently support bit-fields. A lot of the logic for
7072 // this is in CodeGen, so we need to factor it around.
7073 if (FD->isBitField()) {
7074 Info.FFDiag(BCE->getBeginLoc(),
7075 diag::note_constexpr_bit_cast_unsupported_bitfield);
7076 return None;
7077 }
7078
7079 uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx);
7080 assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0)((void)0);
7081
7082 CharUnits FieldOffset =
7083 CharUnits::fromQuantity(FieldOffsetBits / Info.Ctx.getCharWidth()) +
7084 Offset;
7085 QualType FieldTy = FD->getType();
7086 Optional<APValue> SubObj = visitType(FieldTy, FieldOffset);
7087 if (!SubObj)
7088 return None;
7089 ResultVal.getStructField(FieldIdx) = *SubObj;
7090 ++FieldIdx;
7091 }
7092
7093 return ResultVal;
7094 }
7095
7096 Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
7097 QualType RepresentationType = Ty->getDecl()->getIntegerType();
7098 assert(!RepresentationType.isNull() &&((void)0)
7099 "enum forward decl should be caught by Sema")((void)0);
7100 const auto *AsBuiltin =
7101 RepresentationType.getCanonicalType()->castAs<BuiltinType>();
7102 // Recurse into the underlying type. Treat std::byte transparently as
7103 // unsigned char.
7104 return visit(AsBuiltin, Offset, /*EnumTy=*/Ty);
7105 }
7106
7107 Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
7108 size_t Size = Ty->getSize().getLimitedValue();
7109 CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
7110
7111 APValue ArrayValue(APValue::UninitArray(), Size, Size);
7112 for (size_t I = 0; I != Size; ++I) {
7113 Optional<APValue> ElementValue =
7114 visitType(Ty->getElementType(), Offset + I * ElementWidth);
7115 if (!ElementValue)
7116 return None;
7117 ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue);
7118 }
7119
7120 return ArrayValue;
7121 }
7122
7123 Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
7124 return unsupportedType(QualType(Ty, 0));
7125 }
7126
7127 Optional<APValue> visitType(QualType Ty, CharUnits Offset) {
7128 QualType Can = Ty.getCanonicalType();
7129
7130 switch (Can->getTypeClass()) {
7131#define TYPE(Class, Base) \
7132 case Type::Class: \
7133 return visit(cast<Class##Type>(Can.getTypePtr()), Offset);
7134#define ABSTRACT_TYPE(Class, Base)
7135#define NON_CANONICAL_TYPE(Class, Base) \
7136 case Type::Class: \
7137 llvm_unreachable("non-canonical type should be impossible!")__builtin_unreachable();
7138#define DEPENDENT_TYPE(Class, Base) \
7139 case Type::Class: \
7140 llvm_unreachable( \__builtin_unreachable()
7141 "dependent types aren't supported in the constant evaluator!")__builtin_unreachable();
7142#define NON_CANONICAL_UNLESS_DEPENDENT(Class, Base)case Type::Class: __builtin_unreachable(); \
7143 case Type::Class: \
7144 llvm_unreachable("either dependent or not canonical!")__builtin_unreachable();
7145#include "clang/AST/TypeNodes.inc"
7146 }
7147 llvm_unreachable("Unhandled Type::TypeClass")__builtin_unreachable();
7148 }
7149
7150public:
7151 // Pull out a full value of type DstType.
7152 static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer,
7153 const CastExpr *BCE) {
7154 BufferToAPValueConverter Converter(Info, Buffer, BCE);
7155 return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0));
7156 }
7157};
7158
7159static bool checkBitCastConstexprEligibilityType(SourceLocation Loc,
7160 QualType Ty, EvalInfo *Info,
7161 const ASTContext &Ctx,
7162 bool CheckingDest) {
7163 Ty = Ty.getCanonicalType();
7164
7165 auto diag = [&](int Reason) {
7166 if (Info)
7167 Info->FFDiag(Loc, diag::note_constexpr_bit_cast_invalid_type)
7168 << CheckingDest << (Reason == 4) << Reason;
7169 return false;
7170 };
7171 auto note = [&](int Construct, QualType NoteTy, SourceLocation NoteLoc) {
7172 if (Info)
7173 Info->Note(NoteLoc, diag::note_constexpr_bit_cast_invalid_subtype)
7174 << NoteTy << Construct << Ty;
7175 return false;
7176 };
7177
7178 if (Ty->isUnionType())
7179 return diag(0);
7180 if (Ty->isPointerType())
7181 return diag(1);
7182 if (Ty->isMemberPointerType())
7183 return diag(2);
7184 if (Ty.isVolatileQualified())
7185 return diag(3);
7186
7187 if (RecordDecl *Record = Ty->getAsRecordDecl()) {
7188 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(Record)) {
7189 for (CXXBaseSpecifier &BS : CXXRD->bases())
7190 if (!checkBitCastConstexprEligibilityType(Loc, BS.getType(), Info, Ctx,
7191 CheckingDest))
7192 return note(1, BS.getType(), BS.getBeginLoc());
7193 }
7194 for (FieldDecl *FD : Record->fields()) {
7195 if (FD->getType()->isReferenceType())
7196 return diag(4);
7197 if (!checkBitCastConstexprEligibilityType(Loc, FD->getType(), Info, Ctx,
7198 CheckingDest))
7199 return note(0, FD->getType(), FD->getBeginLoc());
7200 }
7201 }
7202
7203 if (Ty->isArrayType() &&
7204 !checkBitCastConstexprEligibilityType(Loc, Ctx.getBaseElementType(Ty),
7205 Info, Ctx, CheckingDest))
7206 return false;
7207
7208 return true;
7209}
7210
7211static bool checkBitCastConstexprEligibility(EvalInfo *Info,
7212 const ASTContext &Ctx,
7213 const CastExpr *BCE) {
7214 bool DestOK = checkBitCastConstexprEligibilityType(
7215 BCE->getBeginLoc(), BCE->getType(), Info, Ctx, true);
7216 bool SourceOK = DestOK && checkBitCastConstexprEligibilityType(
7217 BCE->getBeginLoc(),
7218 BCE->getSubExpr()->getType(), Info, Ctx, false);
7219 return SourceOK;
7220}
7221
7222static bool handleLValueToRValueBitCast(EvalInfo &Info, APValue &DestValue,
7223 APValue &SourceValue,
7224 const CastExpr *BCE) {
7225 assert(CHAR_BIT == 8 && Info.Ctx.getTargetInfo().getCharWidth() == 8 &&((void)0)
7226 "no host or target supports non 8-bit chars")((void)0);
7227 assert(SourceValue.isLValue() &&((void)0)
7228 "LValueToRValueBitcast requires an lvalue operand!")((void)0);
7229
7230 if (!checkBitCastConstexprEligibility(&Info, Info.Ctx, BCE))
7231 return false;
7232
7233 LValue SourceLValue;
7234 APValue SourceRValue;
7235 SourceLValue.setFrom(Info.Ctx, SourceValue);
7236 if (!handleLValueToRValueConversion(
7237 Info, BCE, BCE->getSubExpr()->getType().withConst(), SourceLValue,
7238 SourceRValue, /*WantObjectRepresentation=*/true))
7239 return false;
7240
7241 // Read out SourceValue into a char buffer.
7242 Optional<BitCastBuffer> Buffer =
7243 APValueToBufferConverter::convert(Info, SourceRValue, BCE);
7244 if (!Buffer)
7245 return false;
7246
7247 // Write out the buffer into a new APValue.
7248 Optional<APValue> MaybeDestValue =
7249 BufferToAPValueConverter::convert(Info, *Buffer, BCE);
7250 if (!MaybeDestValue)
7251 return false;
7252
7253 DestValue = std::move(*MaybeDestValue);
7254 return true;
7255}
7256
7257template <class Derived>
7258class ExprEvaluatorBase
7259 : public ConstStmtVisitor<Derived, bool> {
7260private:
7261 Derived &getDerived() { return static_cast<Derived&>(*this); }
7262 bool DerivedSuccess(const APValue &V, const Expr *E) {
7263 return getDerived().Success(V, E);
7264 }
7265 bool DerivedZeroInitialization(const Expr *E) {
7266 return getDerived().ZeroInitialization(E);
7267 }
7268
7269 // Check whether a conditional operator with a non-constant condition is a
7270 // potential constant expression. If neither arm is a potential constant
7271 // expression, then the conditional operator is not either.
7272 template<typename ConditionalOperator>
7273 void CheckPotentialConstantConditional(const ConditionalOperator *E) {
7274 assert(Info.checkingPotentialConstantExpression())((void)0);
7275
7276 // Speculatively evaluate both arms.
7277 SmallVector<PartialDiagnosticAt, 8> Diag;
7278 {
7279 SpeculativeEvaluationRAII Speculate(Info, &Diag);
7280 StmtVisitorTy::Visit(E->getFalseExpr());
7281 if (Diag.empty())
7282 return;
7283 }
7284
7285 {
7286 SpeculativeEvaluationRAII Speculate(Info, &Diag);
7287 Diag.clear();
7288 StmtVisitorTy::Visit(E->getTrueExpr());
7289 if (Diag.empty())
7290 return;
7291 }
7292
7293 Error(E, diag::note_constexpr_conditional_never_const);
7294 }
7295
7296
7297 template<typename ConditionalOperator>
7298 bool HandleConditionalOperator(const ConditionalOperator *E) {
7299 bool BoolResult;
7300 if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
7301 if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
7302 CheckPotentialConstantConditional(E);
7303 return false;
7304 }
7305 if (Info.noteFailure()) {
7306 StmtVisitorTy::Visit(E->getTrueExpr());
7307 StmtVisitorTy::Visit(E->getFalseExpr());
7308 }
7309 return false;
7310 }
7311
7312 Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr();
7313 return StmtVisitorTy::Visit(EvalExpr);
7314 }
7315
7316protected:
7317 EvalInfo &Info;
7318 typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
7319 typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
7320
7321 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
7322 return Info.CCEDiag(E, D);
7323 }
7324
7325 bool ZeroInitialization(const Expr *E) { return Error(E); }
7326
7327public:
7328 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
7329
7330 EvalInfo &getEvalInfo() { return Info; }
7331
7332 /// Report an evaluation error. This should only be called when an error is
7333 /// first discovered. When propagating an error, just return false.
7334 bool Error(const Expr *E, diag::kind D) {
7335 Info.FFDiag(E, D);
7336 return false;
7337 }
7338 bool Error(const Expr *E) {
7339 return Error(E, diag::note_invalid_subexpr_in_const_expr);
7340 }
7341
7342 bool VisitStmt(const Stmt *) {
7343 llvm_unreachable("Expression evaluator should not be called on stmts")__builtin_unreachable();
7344 }
7345 bool VisitExpr(const Expr *E) {
7346 return Error(E);
7347 }
7348
7349 bool VisitConstantExpr(const ConstantExpr *E) {
7350 if (E->hasAPValueResult())
7351 return DerivedSuccess(E->getAPValueResult(), E);
7352
7353 return StmtVisitorTy::Visit(E->getSubExpr());
7354 }
7355
7356 bool VisitParenExpr(const ParenExpr *E)
7357 { return StmtVisitorTy::Visit(E->getSubExpr()); }
7358 bool VisitUnaryExtension(const UnaryOperator *E)
7359 { return StmtVisitorTy::Visit(E->getSubExpr()); }
7360 bool VisitUnaryPlus(const UnaryOperator *E)
7361 { return StmtVisitorTy::Visit(E->getSubExpr()); }
7362 bool VisitChooseExpr(const ChooseExpr *E)
7363 { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
7364 bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
7365 { return StmtVisitorTy::Visit(E->getResultExpr()); }
7366 bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
7367 { return StmtVisitorTy::Visit(E->getReplacement()); }
7368 bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
7369 TempVersionRAII RAII(*Info.CurrentCall);
7370 SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
7371 return StmtVisitorTy::Visit(E->getExpr());
7372 }
7373 bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
7374 TempVersionRAII RAII(*Info.CurrentCall);
7375 // The initializer may not have been parsed yet, or might be erroneous.
7376 if (!E->getExpr())
7377 return Error(E);
7378 SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
7379 return StmtVisitorTy::Visit(E->getExpr());
7380 }
7381
7382 bool VisitExprWithCleanups(const ExprWithCleanups *E) {
7383 FullExpressionRAII Scope(Info);
7384 return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
7385 }
7386
7387 // Temporaries are registered when created, so we don't care about
7388 // CXXBindTemporaryExpr.
7389 bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {
7390 return StmtVisitorTy::Visit(E->getSubExpr());
7391 }
7392
7393 bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
7394 CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
7395 return static_cast<Derived*>(this)->VisitCastExpr(E);
7396 }
7397 bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
7398 if (!Info.Ctx.getLangOpts().CPlusPlus20)
7399 CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
7400 return static_cast<Derived*>(this)->VisitCastExpr(E);
7401 }
7402 bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
7403 return static_cast<Derived*>(this)->VisitCastExpr(E);
7404 }
7405
7406 bool VisitBinaryOperator(const BinaryOperator *E) {
7407 switch (E->getOpcode()) {
7408 default:
7409 return Error(E);
7410
7411 case BO_Comma:
7412 VisitIgnoredValue(E->getLHS());
7413 return StmtVisitorTy::Visit(E->getRHS());
7414
7415 case BO_PtrMemD:
7416 case BO_PtrMemI: {
7417 LValue Obj;
7418 if (!HandleMemberPointerAccess(Info, E, Obj))
7419 return false;
7420 APValue Result;
7421 if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
7422 return false;
7423 return DerivedSuccess(Result, E);
7424 }
7425 }
7426 }
7427
7428 bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E) {
7429 return StmtVisitorTy::Visit(E->getSemanticForm());
7430 }
7431
7432 bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
7433 // Evaluate and cache the common expression. We treat it as a temporary,
7434 // even though it's not quite the same thing.
7435 LValue CommonLV;
7436 if (!Evaluate(Info.CurrentCall->createTemporary(
7437 E->getOpaqueValue(),
7438 getStorageType(Info.Ctx, E->getOpaqueValue()),
7439 ScopeKind::FullExpression, CommonLV),
7440 Info, E->getCommon()))
7441 return false;
7442
7443 return HandleConditionalOperator(E);
7444 }
7445
7446 bool VisitConditionalOperator(const ConditionalOperator *E) {
7447 bool IsBcpCall = false;
7448 // If the condition (ignoring parens) is a __builtin_constant_p call,
7449 // the result is a constant expression if it can be folded without
7450 // side-effects. This is an important GNU extension. See GCC PR38377
7451 // for discussion.
7452 if (const CallExpr *CallCE =
7453 dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
7454 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
7455 IsBcpCall = true;
7456
7457 // Always assume __builtin_constant_p(...) ? ... : ... is a potential
7458 // constant expression; we can't check whether it's potentially foldable.
7459 // FIXME: We should instead treat __builtin_constant_p as non-constant if
7460 // it would return 'false' in this mode.
7461 if (Info.checkingPotentialConstantExpression() && IsBcpCall)
7462 return false;
7463
7464 FoldConstant Fold(Info, IsBcpCall);
7465 if (!HandleConditionalOperator(E)) {
7466 Fold.keepDiagnostics();
7467 return false;
7468 }
7469
7470 return true;
7471 }
7472
7473 bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
7474 if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E))
7475 return DerivedSuccess(*Value, E);
7476
7477 const Expr *Source = E->getSourceExpr();
7478 if (!Source)
7479 return Error(E);
7480 if (Source == E) { // sanity checking.
7481 assert(0 && "OpaqueValueExpr recursively refers to itself")((void)0);
7482 return Error(E);
7483 }
7484 return StmtVisitorTy::Visit(Source);
7485 }
7486
7487 bool VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
7488 for (const Expr *SemE : E->semantics()) {
7489 if (auto *OVE = dyn_cast<OpaqueValueExpr>(SemE)) {
7490 // FIXME: We can't handle the case where an OpaqueValueExpr is also the
7491 // result expression: there could be two different LValues that would
7492 // refer to the same object in that case, and we can't model that.
7493 if (SemE == E->getResultExpr())
7494 return Error(E);
7495
7496 // Unique OVEs get evaluated if and when we encounter them when
7497 // emitting the rest of the semantic form, rather than eagerly.
7498 if (OVE->isUnique())
7499 continue;
7500
7501 LValue LV;
7502 if (!Evaluate(Info.CurrentCall->createTemporary(
7503 OVE, getStorageType(Info.Ctx, OVE),
7504 ScopeKind::FullExpression, LV),
7505 Info, OVE->getSourceExpr()))
7506 return false;
7507 } else if (SemE == E->getResultExpr()) {
7508 if (!StmtVisitorTy::Visit(SemE))
7509 return false;
7510 } else {
7511 if (!EvaluateIgnoredValue(Info, SemE))
7512 return false;
7513 }
7514 }
7515 return true;
7516 }
7517
7518 bool VisitCallExpr(const CallExpr *E) {
7519 APValue Result;
7520 if (!handleCallExpr(E, Result, nullptr))
7521 return false;
7522 return DerivedSuccess(Result, E);
7523 }
7524
7525 bool handleCallExpr(const CallExpr *E, APValue &Result,
7526 const LValue *ResultSlot) {
7527 CallScopeRAII CallScope(Info);
7528
7529 const Expr *Callee = E->getCallee()->IgnoreParens();
7530 QualType CalleeType = Callee->getType();
7531
7532 const FunctionDecl *FD = nullptr;
7533 LValue *This = nullptr, ThisVal;
7534 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
7535 bool HasQualifier = false;
7536
7537 CallRef Call;
7538
7539 // Extract function decl and 'this' pointer from the callee.
7540 if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
7541 const CXXMethodDecl *Member = nullptr;
7542 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
7543 // Explicit bound member calls, such as x.f() or p->g();
7544 if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
7545 return false;
7546 Member = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
7547 if (!Member)
7548 return Error(Callee);
7549 This = &ThisVal;
7550 HasQualifier = ME->hasQualifier();
7551 } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
7552 // Indirect bound member calls ('.*' or '->*').
7553 const ValueDecl *D =
7554 HandleMemberPointerAccess(Info, BE, ThisVal, false);
7555 if (!D)
7556 return false;
7557 Member = dyn_cast<CXXMethodDecl>(D);
7558 if (!Member)
7559 return Error(Callee);
7560 This = &ThisVal;
7561 } else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
7562 if (!Info.getLangOpts().CPlusPlus20)
7563 Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor);
7564 return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal) &&
7565 HandleDestruction(Info, PDE, ThisVal, PDE->getDestroyedType());
7566 } else
7567 return Error(Callee);
7568 FD = Member;
7569 } else if (CalleeType->isFunctionPointerType()) {
7570 LValue CalleeLV;
7571 if (!EvaluatePointer(Callee, CalleeLV, Info))
7572 return false;
7573
7574 if (!CalleeLV.getLValueOffset().isZero())
7575 return Error(Callee);
7576 FD = dyn_cast_or_null<FunctionDecl>(
7577 CalleeLV.getLValueBase().dyn_cast<const ValueDecl *>());
7578 if (!FD)
7579 return Error(Callee);
7580 // Don't call function pointers which have been cast to some other type.
7581 // Per DR (no number yet), the caller and callee can differ in noexcept.
7582 if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
7583 CalleeType->getPointeeType(), FD->getType())) {
7584 return Error(E);
7585 }
7586
7587 // For an (overloaded) assignment expression, evaluate the RHS before the
7588 // LHS.
7589 auto *OCE = dyn_cast<CXXOperatorCallExpr>(E);
7590 if (OCE && OCE->isAssignmentOp()) {
7591 assert(Args.size() == 2 && "wrong number of arguments in assignment")((void)0);
7592 Call = Info.CurrentCall->createCall(FD);
7593 if (!EvaluateArgs(isa<CXXMethodDecl>(FD) ? Args.slice(1) : Args, Call,
7594 Info, FD, /*RightToLeft=*/true))
7595 return false;
7596 }
7597
7598 // Overloaded operator calls to member functions are represented as normal
7599 // calls with '*this' as the first argument.
7600 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
7601 if (MD && !MD->isStatic()) {
7602 // FIXME: When selecting an implicit conversion for an overloaded
7603 // operator delete, we sometimes try to evaluate calls to conversion
7604 // operators without a 'this' parameter!
7605 if (Args.empty())
7606 return Error(E);
7607
7608 if (!EvaluateObjectArgument(Info, Args[0], ThisVal))
7609 return false;
7610 This = &ThisVal;
7611 Args = Args.slice(1);
7612 } else if (MD && MD->isLambdaStaticInvoker()) {
7613 // Map the static invoker for the lambda back to the call operator.
7614 // Conveniently, we don't have to slice out the 'this' argument (as is
7615 // being done for the non-static case), since a static member function
7616 // doesn't have an implicit argument passed in.
7617 const CXXRecordDecl *ClosureClass = MD->getParent();
7618 assert(((void)0)
7619 ClosureClass->captures_begin() == ClosureClass->captures_end() &&((void)0)
7620 "Number of captures must be zero for conversion to function-ptr")((void)0);
7621
7622 const CXXMethodDecl *LambdaCallOp =
7623 ClosureClass->getLambdaCallOperator();
7624
7625 // Set 'FD', the function that will be called below, to the call
7626 // operator. If the closure object represents a generic lambda, find
7627 // the corresponding specialization of the call operator.
7628
7629 if (ClosureClass->isGenericLambda()) {
7630 assert(MD->isFunctionTemplateSpecialization() &&((void)0)
7631 "A generic lambda's static-invoker function must be a "((void)0)
7632 "template specialization")((void)0);
7633 const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
7634 FunctionTemplateDecl *CallOpTemplate =
7635 LambdaCallOp->getDescribedFunctionTemplate();
7636 void *InsertPos = nullptr;
7637 FunctionDecl *CorrespondingCallOpSpecialization =
7638 CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos);
7639 assert(CorrespondingCallOpSpecialization &&((void)0)
7640 "We must always have a function call operator specialization "((void)0)
7641 "that corresponds to our static invoker specialization")((void)0);
7642 FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
7643 } else
7644 FD = LambdaCallOp;
7645 } else if (FD->isReplaceableGlobalAllocationFunction()) {
7646 if (FD->getDeclName().getCXXOverloadedOperator() == OO_New ||
7647 FD->getDeclName().getCXXOverloadedOperator() == OO_Array_New) {
7648 LValue Ptr;
7649 if (!HandleOperatorNewCall(Info, E, Ptr))
7650 return false;
7651 Ptr.moveInto(Result);
7652 return CallScope.destroy();
7653 } else {
7654 return HandleOperatorDeleteCall(Info, E) && CallScope.destroy();
7655 }
7656 }
7657 } else
7658 return Error(E);
7659
7660 // Evaluate the arguments now if we've not already done so.
7661 if (!Call) {
7662 Call = Info.CurrentCall->createCall(FD);
7663 if (!EvaluateArgs(Args, Call, Info, FD))
7664 return false;
7665 }
7666
7667 SmallVector<QualType, 4> CovariantAdjustmentPath;
7668 if (This) {
7669 auto *NamedMember = dyn_cast<CXXMethodDecl>(FD);
7670 if (NamedMember && NamedMember->isVirtual() && !HasQualifier) {
7671 // Perform virtual dispatch, if necessary.
7672 FD = HandleVirtualDispatch(Info, E, *This, NamedMember,
7673 CovariantAdjustmentPath);
7674 if (!FD)
7675 return false;
7676 } else {
7677 // Check that the 'this' pointer points to an object of the right type.
7678 // FIXME: If this is an assignment operator call, we may need to change
7679 // the active union member before we check this.
7680 if (!checkNonVirtualMemberCallThisPointer(Info, E, *This, NamedMember))
7681 return false;
7682 }
7683 }
7684
7685 // Destructor calls are different enough that they have their own codepath.
7686 if (auto *DD = dyn_cast<CXXDestructorDecl>(FD)) {
7687 assert(This && "no 'this' pointer for destructor call")((void)0);
7688 return HandleDestruction(Info, E, *This,
7689 Info.Ctx.getRecordType(DD->getParent())) &&
7690 CallScope.destroy();
7691 }
7692
7693 const FunctionDecl *Definition = nullptr;
7694 Stmt *Body = FD->getBody(Definition);
7695
7696 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
7697 !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Call,
7698 Body, Info, Result, ResultSlot))
7699 return false;
7700
7701 if (!CovariantAdjustmentPath.empty() &&
7702 !HandleCovariantReturnAdjustment(Info, E, Result,
7703 CovariantAdjustmentPath))
7704 return false;
7705
7706 return CallScope.destroy();
7707 }
7708
7709 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
7710 return StmtVisitorTy::Visit(E->getInitializer());
7711 }
7712 bool VisitInitListExpr(const InitListExpr *E) {
7713 if (E->getNumInits() == 0)
7714 return DerivedZeroInitialization(E);
7715 if (E->getNumInits() == 1)
7716 return StmtVisitorTy::Visit(E->getInit(0));
7717 return Error(E);
7718 }
7719 bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
7720 return DerivedZeroInitialization(E);
7721 }
7722 bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
7723 return DerivedZeroInitialization(E);
7724 }
7725 bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
7726 return DerivedZeroInitialization(E);
7727 }
7728
7729 /// A member expression where the object is a prvalue is itself a prvalue.
7730 bool VisitMemberExpr(const MemberExpr *E) {
7731 assert(!Info.Ctx.getLangOpts().CPlusPlus11 &&((void)0)
7732 "missing temporary materialization conversion")((void)0);
7733 assert(!E->isArrow() && "missing call to bound member function?")((void)0);
7734
7735 APValue Val;
7736 if (!Evaluate(Val, Info, E->getBase()))
7737 return false;
7738
7739 QualType BaseTy = E->getBase()->getType();
7740
7741 const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
7742 if (!FD) return Error(E);
7743 assert(!FD->getType()->isReferenceType() && "prvalue reference?")((void)0);
7744 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==((void)0)
7745 FD->getParent()->getCanonicalDecl() && "record / field mismatch")((void)0);
7746
7747 // Note: there is no lvalue base here. But this case should only ever
7748 // happen in C or in C++98, where we cannot be evaluating a constexpr
7749 // constructor, which is the only case the base matters.
7750 CompleteObject Obj(APValue::LValueBase(), &Val, BaseTy);
7751 SubobjectDesignator Designator(BaseTy);
7752 Designator.addDeclUnchecked(FD);
7753
7754 APValue Result;
7755 return extractSubobject(Info, E, Obj, Designator, Result) &&
7756 DerivedSuccess(Result, E);
7757 }
7758
7759 bool VisitExtVectorElementExpr(const ExtVectorElementExpr *E) {
7760 APValue Val;
7761 if (!Evaluate(Val, Info, E->getBase()))
7762 return false;
7763
7764 if (Val.isVector()) {
7765 SmallVector<uint32_t, 4> Indices;
7766 E->getEncodedElementAccess(Indices);
7767 if (Indices.size() == 1) {
7768 // Return scalar.
7769 return DerivedSuccess(Val.getVectorElt(Indices[0]), E);
7770 } else {
7771 // Construct new APValue vector.
7772 SmallVector<APValue, 4> Elts;
7773 for (unsigned I = 0; I < Indices.size(); ++I) {
7774 Elts.push_back(Val.getVectorElt(Indices[I]));
7775 }
7776 APValue VecResult(Elts.data(), Indices.size());
7777 return DerivedSuccess(VecResult, E);
7778 }
7779 }
7780
7781 return false;
7782 }
7783
7784 bool VisitCastExpr(const CastExpr *E) {
7785 switch (E->getCastKind()) {
7786 default:
7787 break;
7788
7789 case CK_AtomicToNonAtomic: {
7790 APValue AtomicVal;
7791 // This does not need to be done in place even for class/array types:
7792 // atomic-to-non-atomic conversion implies copying the object
7793 // representation.
7794 if (!Evaluate(AtomicVal, Info, E->getSubExpr()))
7795 return false;
7796 return DerivedSuccess(AtomicVal, E);
7797 }
7798
7799 case CK_NoOp:
7800 case CK_UserDefinedConversion:
7801 return StmtVisitorTy::Visit(E->getSubExpr());
7802
7803 case CK_LValueToRValue: {
7804 LValue LVal;
7805 if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
7806 return false;
7807 APValue RVal;
7808 // Note, we use the subexpression's type in order to retain cv-qualifiers.
7809 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
7810 LVal, RVal))
7811 return false;
7812 return DerivedSuccess(RVal, E);
7813 }
7814 case CK_LValueToRValueBitCast: {
7815 APValue DestValue, SourceValue;
7816 if (!Evaluate(SourceValue, Info, E->getSubExpr()))
7817 return false;
7818 if (!handleLValueToRValueBitCast(Info, DestValue, SourceValue, E))
7819 return false;
7820 return DerivedSuccess(DestValue, E);
7821 }
7822
7823 case CK_AddressSpaceConversion: {
7824 APValue Value;
7825 if (!Evaluate(Value, Info, E->getSubExpr()))
7826 return false;
7827 return DerivedSuccess(Value, E);
7828 }
7829 }
7830
7831 return Error(E);
7832 }
7833
7834 bool VisitUnaryPostInc(const UnaryOperator *UO) {
7835 return VisitUnaryPostIncDec(UO);
7836 }
7837 bool VisitUnaryPostDec(const UnaryOperator *UO) {
7838 return VisitUnaryPostIncDec(UO);
7839 }
7840 bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
7841 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
7842 return Error(UO);
7843
7844 LValue LVal;
7845 if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
7846 return false;
7847 APValue RVal;
7848 if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
7849 UO->isIncrementOp(), &RVal))
7850 return false;
7851 return DerivedSuccess(RVal, UO);
7852 }
7853
7854 bool VisitStmtExpr(const StmtExpr *E) {
7855 // We will have checked the full-expressions inside the statement expression
7856 // when they were completed, and don't need to check them again now.
7857 llvm::SaveAndRestore<bool> NotCheckingForUB(
7858 Info.CheckingForUndefinedBehavior, false);
7859
7860 const CompoundStmt *CS = E->getSubStmt();
7861 if (CS->body_empty())
7862 return true;
7863
7864 BlockScopeRAII Scope(Info);
7865 for (CompoundStmt::const_body_iterator BI = CS->body_begin(),
7866 BE = CS->body_end();
7867 /**/; ++BI) {
7868 if (BI + 1 == BE) {
7869 const Expr *FinalExpr = dyn_cast<Expr>(*BI);
7870 if (!FinalExpr) {
7871 Info.FFDiag((*BI)->getBeginLoc(),
7872 diag::note_constexpr_stmt_expr_unsupported);
7873 return false;
7874 }
7875 return this->Visit(FinalExpr) && Scope.destroy();
7876 }
7877
7878 APValue ReturnValue;
7879 StmtResult Result = { ReturnValue, nullptr };
7880 EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
7881 if (ESR != ESR_Succeeded) {
7882 // FIXME: If the statement-expression terminated due to 'return',
7883 // 'break', or 'continue', it would be nice to propagate that to
7884 // the outer statement evaluation rather than bailing out.
7885 if (ESR != ESR_Failed)
7886 Info.FFDiag((*BI)->getBeginLoc(),
7887 diag::note_constexpr_stmt_expr_unsupported);
7888 return false;
7889 }
7890 }
7891
7892 llvm_unreachable("Return from function from the loop above.")__builtin_unreachable();
7893 }
7894
7895 /// Visit a value which is evaluated, but whose value is ignored.
7896 void VisitIgnoredValue(const Expr *E) {
7897 EvaluateIgnoredValue(Info, E);
7898 }
7899
7900 /// Potentially visit a MemberExpr's base expression.
7901 void VisitIgnoredBaseExpression(const Expr *E) {
7902 // While MSVC doesn't evaluate the base expression, it does diagnose the
7903 // presence of side-effecting behavior.
7904 if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
7905 return;
7906 VisitIgnoredValue(E);
7907 }
7908};
7909
7910} // namespace
7911
7912//===----------------------------------------------------------------------===//
7913// Common base class for lvalue and temporary evaluation.
7914//===----------------------------------------------------------------------===//
7915namespace {
7916template<class Derived>
7917class LValueExprEvaluatorBase
7918 : public ExprEvaluatorBase<Derived> {
7919protected:
7920 LValue &Result;
7921 bool InvalidBaseOK;
7922 typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
7923 typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
7924
7925 bool Success(APValue::LValueBase B) {
7926 Result.set(B);
7927 return true;
7928 }
7929
7930 bool evaluatePointer(const Expr *E, LValue &Result) {
7931 return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
7932 }
7933
7934public:
7935 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
7936 : ExprEvaluatorBaseTy(Info), Result(Result),
7937 InvalidBaseOK(InvalidBaseOK) {}
7938
7939 bool Success(const APValue &V, const Expr *E) {
7940 Result.setFrom(this->Info.Ctx, V);
7941 return true;
7942 }
7943
7944 bool VisitMemberExpr(const MemberExpr *E) {
7945 // Handle non-static data members.
7946 QualType BaseTy;
7947 bool EvalOK;
7948 if (E->isArrow()) {
7949 EvalOK = evaluatePointer(E->getBase(), Result);
7950 BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType();
7951 } else if (E->getBase()->isPRValue()) {
7952 assert(E->getBase()->getType()->isRecordType())((void)0);
7953 EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info);
7954 BaseTy = E->getBase()->getType();
7955 } else {
7956 EvalOK = this->Visit(E->getBase());
7957 BaseTy = E->getBase()->getType();
7958 }
7959 if (!EvalOK) {
7960 if (!InvalidBaseOK)
7961 return false;
7962 Result.setInvalid(E);
7963 return true;
7964 }
7965
7966 const ValueDecl *MD = E->getMemberDecl();
7967 if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
7968 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==((void)0)
7969 FD->getParent()->getCanonicalDecl() && "record / field mismatch")((void)0);
7970 (void)BaseTy;
7971 if (!HandleLValueMember(this->Info, E, Result, FD))
7972 return false;
7973 } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
7974 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
7975 return false;
7976 } else
7977 return this->Error(E);
7978
7979 if (MD->getType()->isReferenceType()) {
7980 APValue RefValue;
7981 if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
7982 RefValue))
7983 return false;
7984 return Success(RefValue, E);
7985 }
7986 return true;
7987 }
7988
7989 bool VisitBinaryOperator(const BinaryOperator *E) {
7990 switch (E->getOpcode()) {
7991 default:
7992 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
7993
7994 case BO_PtrMemD:
7995 case BO_PtrMemI:
7996 return HandleMemberPointerAccess(this->Info, E, Result);
7997 }
7998 }
7999
8000 bool VisitCastExpr(const CastExpr *E) {
8001 switch (E->getCastKind()) {
8002 default:
8003 return ExprEvaluatorBaseTy::VisitCastExpr(E);
8004
8005 case CK_DerivedToBase:
8006 case CK_UncheckedDerivedToBase:
8007 if (!this->Visit(E->getSubExpr()))
8008 return false;
8009
8010 // Now figure out the necessary offset to add to the base LV to get from
8011 // the derived class to the base class.
8012 return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
8013 Result);
8014 }
8015 }
8016};
8017}
8018
8019//===----------------------------------------------------------------------===//
8020// LValue Evaluation
8021//
8022// This is used for evaluating lvalues (in C and C++), xvalues (in C++11),
8023// function designators (in C), decl references to void objects (in C), and
8024// temporaries (if building with -Wno-address-of-temporary).
8025//
8026// LValue evaluation produces values comprising a base expression of one of the
8027// following types:
8028// - Declarations
8029// * VarDecl
8030// * FunctionDecl
8031// - Literals
8032// * CompoundLiteralExpr in C (and in global scope in C++)
8033// * StringLiteral
8034// * PredefinedExpr
8035// * ObjCStringLiteralExpr
8036// * ObjCEncodeExpr
8037// * AddrLabelExpr
8038// * BlockExpr
8039// * CallExpr for a MakeStringConstant builtin
8040// - typeid(T) expressions, as TypeInfoLValues
8041// - Locals and temporaries
8042// * MaterializeTemporaryExpr
8043// * Any Expr, with a CallIndex indicating the function in which the temporary
8044// was evaluated, for cases where the MaterializeTemporaryExpr is missing
8045// from the AST (FIXME).
8046// * A MaterializeTemporaryExpr that has static storage duration, with no
8047// CallIndex, for a lifetime-extended temporary.
8048// * The ConstantExpr that is currently being evaluated during evaluation of an
8049// immediate invocation.
8050// plus an offset in bytes.
8051//===----------------------------------------------------------------------===//
8052namespace {
8053class LValueExprEvaluator
8054 : public LValueExprEvaluatorBase<LValueExprEvaluator> {
8055public:
8056 LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
8057 LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
8058
8059 bool VisitVarDecl(const Expr *E, const VarDecl *VD);
8060 bool VisitUnaryPreIncDec(const UnaryOperator *UO);
8061
8062 bool VisitDeclRefExpr(const DeclRefExpr *E);
8063 bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
8064 bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
8065 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
8066 bool VisitMemberExpr(const MemberExpr *E);
8067 bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
8068 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
8069 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
8070 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
8071 bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
8072 bool VisitUnaryDeref(const UnaryOperator *E);
8073 bool VisitUnaryReal(const UnaryOperator *E);
8074 bool VisitUnaryImag(const UnaryOperator *E);
8075 bool VisitUnaryPreInc(const UnaryOperator *UO) {
8076 return VisitUnaryPreIncDec(UO);
8077 }
8078 bool VisitUnaryPreDec(const UnaryOperator *UO) {
8079 return VisitUnaryPreIncDec(UO);
8080 }
8081 bool VisitBinAssign(const BinaryOperator *BO);
8082 bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
8083
8084 bool VisitCastExpr(const CastExpr *E) {
8085 switch (E->getCastKind()) {
8086 default:
8087 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
8088
8089 case CK_LValueBitCast:
8090 this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
8091 if (!Visit(E->getSubExpr()))
8092 return false;
8093 Result.Designator.setInvalid();
8094 return true;
8095
8096 case CK_BaseToDerived:
8097 if (!Visit(E->getSubExpr()))
8098 return false;
8099 return HandleBaseToDerivedCast(Info, E, Result);
8100
8101 case CK_Dynamic:
8102 if (!Visit(E->getSubExpr()))
8103 return false;
8104 return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result);
8105 }
8106 }
8107};
8108} // end anonymous namespace
8109
8110/// Evaluate an expression as an lvalue. This can be legitimately called on
8111/// expressions which are not glvalues, in three cases:
8112/// * function designators in C, and
8113/// * "extern void" objects
8114/// * @selector() expressions in Objective-C
8115static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
8116 bool InvalidBaseOK) {
8117 assert(!E->isValueDependent())((void)0);
8118 assert(E->isGLValue() || E->getType()->isFunctionType() ||((void)0)
8119 E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E))((void)0);
8120 return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
8121}
8122
8123bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
8124 const NamedDecl *D = E->getDecl();
8125 if (isa<FunctionDecl, MSGuidDecl, TemplateParamObjectDecl>(D))
8126 return Success(cast<ValueDecl>(D));
8127 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
8128 return VisitVarDecl(E, VD);
8129 if (const BindingDecl *BD = dyn_cast<BindingDecl>(D))
8130 return Visit(BD->getBinding());
8131 return Error(E);
8132}
8133
8134
8135bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
8136
8137 // If we are within a lambda's call operator, check whether the 'VD' referred
8138 // to within 'E' actually represents a lambda-capture that maps to a
8139 // data-member/field within the closure object, and if so, evaluate to the
8140 // field or what the field refers to.
8141 if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee) &&
8142 isa<DeclRefExpr>(E) &&
8143 cast<DeclRefExpr>(E)->refersToEnclosingVariableOrCapture()) {
8144 // We don't always have a complete capture-map when checking or inferring if
8145 // the function call operator meets the requirements of a constexpr function
8146 // - but we don't need to evaluate the captures to determine constexprness
8147 // (dcl.constexpr C++17).
8148 if (Info.checkingPotentialConstantExpression())
8149 return false;
8150
8151 if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
8152 // Start with 'Result' referring to the complete closure object...
8153 Result = *Info.CurrentCall->This;
8154 // ... then update it to refer to the field of the closure object
8155 // that represents the capture.
8156 if (!HandleLValueMember(Info, E, Result, FD))
8157 return false;
8158 // And if the field is of reference type, update 'Result' to refer to what
8159 // the field refers to.
8160 if (FD->getType()->isReferenceType()) {
8161 APValue RVal;
8162 if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result,
8163 RVal))
8164 return false;
8165 Result.setFrom(Info.Ctx, RVal);
8166 }
8167 return true;
8168 }
8169 }
8170
8171 CallStackFrame *Frame = nullptr;
8172 unsigned Version = 0;
8173 if (VD->hasLocalStorage()) {
8174 // Only if a local variable was declared in the function currently being
8175 // evaluated, do we expect to be able to find its value in the current
8176 // frame. (Otherwise it was likely declared in an enclosing context and
8177 // could either have a valid evaluatable value (for e.g. a constexpr
8178 // variable) or be ill-formed (and trigger an appropriate evaluation
8179 // diagnostic)).
8180 CallStackFrame *CurrFrame = Info.CurrentCall;
8181 if (CurrFrame->Callee && CurrFrame->Callee->Equals(VD->getDeclContext())) {
8182 // Function parameters are stored in some caller's frame. (Usually the
8183 // immediate caller, but for an inherited constructor they may be more
8184 // distant.)
8185 if (auto *PVD = dyn_cast<ParmVarDecl>(VD)) {
8186 if (CurrFrame->Arguments) {
8187 VD = CurrFrame->Arguments.getOrigParam(PVD);
8188 Frame =
8189 Info.getCallFrameAndDepth(CurrFrame->Arguments.CallIndex).first;
8190 Version = CurrFrame->Arguments.Version;
8191 }
8192 } else {
8193 Frame = CurrFrame;
8194 Version = CurrFrame->getCurrentTemporaryVersion(VD);
8195 }
8196 }
8197 }
8198
8199 if (!VD->getType()->isReferenceType()) {
8200 if (Frame) {
8201 Result.set({VD, Frame->Index, Version});
8202 return true;
8203 }
8204 return Success(VD);
8205 }
8206
8207 if (!Info.getLangOpts().CPlusPlus11) {
8208 Info.CCEDiag(E, diag::note_constexpr_ltor_non_integral, 1)
8209 << VD << VD->getType();
8210 Info.Note(VD->getLocation(), diag::note_declared_at);
8211 }
8212
8213 APValue *V;
8214 if (!evaluateVarDeclInit(Info, E, VD, Frame, Version, V))
8215 return false;
8216 if (!V->hasValue()) {
8217 // FIXME: Is it possible for V to be indeterminate here? If so, we should
8218 // adjust the diagnostic to say that.
8219 if (!Info.checkingPotentialConstantExpression())
8220 Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
8221 return false;
8222 }
8223 return Success(*V, E);
8224}
8225
8226bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
8227 const MaterializeTemporaryExpr *E) {
8228 // Walk through the expression to find the materialized temporary itself.
8229 SmallVector<const Expr *, 2> CommaLHSs;
8230 SmallVector<SubobjectAdjustment, 2> Adjustments;
8231 const Expr *Inner =
8232 E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
8233
8234 // If we passed any comma operators, evaluate their LHSs.
8235 for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
8236 if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
8237 return false;
8238
8239 // A materialized temporary with static storage duration can appear within the
8240 // result of a constant expression evaluation, so we need to preserve its
8241 // value for use outside this evaluation.
8242 APValue *Value;
8243 if (E->getStorageDuration() == SD_Static) {
8244 // FIXME: What about SD_Thread?
8245 Value = E->getOrCreateValue(true);
8246 *Value = APValue();
8247 Result.set(E);
8248 } else {
8249 Value = &Info.CurrentCall->createTemporary(
8250 E, E->getType(),
8251 E->getStorageDuration() == SD_FullExpression ? ScopeKind::FullExpression
8252 : ScopeKind::Block,
8253 Result);
8254 }
8255
8256 QualType Type = Inner->getType();
8257
8258 // Materialize the temporary itself.
8259 if (!EvaluateInPlace(*Value, Info, Result, Inner)) {
8260 *Value = APValue();
8261 return false;
8262 }
8263
8264 // Adjust our lvalue to refer to the desired subobject.
8265 for (unsigned I = Adjustments.size(); I != 0; /**/) {
8266 --I;
8267 switch (Adjustments[I].Kind) {
8268 case SubobjectAdjustment::DerivedToBaseAdjustment:
8269 if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
8270 Type, Result))
8271 return false;
8272 Type = Adjustments[I].DerivedToBase.BasePath->getType();
8273 break;
8274
8275 case SubobjectAdjustment::FieldAdjustment:
8276 if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
8277 return false;
8278 Type = Adjustments[I].Field->getType();
8279 break;
8280
8281 case SubobjectAdjustment::MemberPointerAdjustment:
8282 if (!HandleMemberPointerAccess(this->Info, Type, Result,
8283 Adjustments[I].Ptr.RHS))
8284 return false;
8285 Type = Adjustments[I].Ptr.MPT->getPointeeType();
8286 break;
8287 }
8288 }
8289
8290 return true;
8291}
8292
8293bool
8294LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
8295 assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&((void)0)
8296 "lvalue compound literal in c++?")((void)0);
8297 // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
8298 // only see this when folding in C, so there's no standard to follow here.
8299 return Success(E);
8300}
8301
8302bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
8303 TypeInfoLValue TypeInfo;
8304
8305 if (!E->isPotentiallyEvaluated()) {
8306 if (E->isTypeOperand())
8307 TypeInfo = TypeInfoLValue(E->getTypeOperand(Info.Ctx).getTypePtr());
8308 else
8309 TypeInfo = TypeInfoLValue(E->getExprOperand()->getType().getTypePtr());
8310 } else {
8311 if (!Info.Ctx.getLangOpts().CPlusPlus20) {
8312 Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
8313 << E->getExprOperand()->getType()
8314 << E->getExprOperand()->getSourceRange();
8315 }
8316
8317 if (!Visit(E->getExprOperand()))
8318 return false;
8319
8320 Optional<DynamicType> DynType =
8321 ComputeDynamicType(Info, E, Result, AK_TypeId);
8322 if (!DynType)
8323 return false;
8324
8325 TypeInfo =
8326 TypeInfoLValue(Info.Ctx.getRecordType(DynType->Type).getTypePtr());
8327 }
8328
8329 return Success(APValue::LValueBase::getTypeInfo(TypeInfo, E->getType()));
8330}
8331
8332bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
8333 return Success(E->getGuidDecl());
8334}
8335
8336bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
8337 // Handle static data members.
8338 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
8339 VisitIgnoredBaseExpression(E->getBase());
8340 return VisitVarDecl(E, VD);
8341 }
8342
8343 // Handle static member functions.
8344 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
8345 if (MD->isStatic()) {
8346 VisitIgnoredBaseExpression(E->getBase());
8347 return Success(MD);
8348 }
8349 }
8350
8351 // Handle non-static data members.
8352 return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
8353}
8354
8355bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
8356 // FIXME: Deal with vectors as array subscript bases.
8357 if (E->getBase()->getType()->isVectorType())
8358 return Error(E);
8359
8360 APSInt Index;
8361 bool Success = true;
8362
8363 // C++17's rules require us to evaluate the LHS first, regardless of which
8364 // side is the base.
8365 for (const Expr *SubExpr : {E->getLHS(), E->getRHS()}) {
8366 if (SubExpr == E->getBase() ? !evaluatePointer(SubExpr, Result)
8367 : !EvaluateInteger(SubExpr, Index, Info)) {
8368 if (!Info.noteFailure())
8369 return false;
8370 Success = false;
8371 }
8372 }
8373
8374 return Success &&
8375 HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
8376}
8377
8378bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
8379 return evaluatePointer(E->getSubExpr(), Result);
8380}
8381
8382bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
8383 if (!Visit(E->getSubExpr()))
8384 return false;
8385 // __real is a no-op on scalar lvalues.
8386 if (E->getSubExpr()->getType()->isAnyComplexType())
8387 HandleLValueComplexElement(Info, E, Result, E->getType(), false);
8388 return true;
8389}
8390
8391bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
8392 assert(E->getSubExpr()->getType()->isAnyComplexType() &&((void)0)
8393 "lvalue __imag__ on scalar?")((void)0);
8394 if (!Visit(E->getSubExpr()))
8395 return false;
8396 HandleLValueComplexElement(Info, E, Result, E->getType(), true);
8397 return true;
8398}
8399
8400bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
8401 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
8402 return Error(UO);
8403
8404 if (!this->Visit(UO->getSubExpr()))
8405 return false;
8406
8407 return handleIncDec(
8408 this->Info, UO, Result, UO->getSubExpr()->getType(),
8409 UO->isIncrementOp(), nullptr);
8410}
8411
8412bool LValueExprEvaluator::VisitCompoundAssignOperator(
8413 const CompoundAssignOperator *CAO) {
8414 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
8415 return Error(CAO);
8416
8417 bool Success = true;
8418
8419 // C++17 onwards require that we evaluate the RHS first.
8420 APValue RHS;
8421 if (!Evaluate(RHS, this->Info, CAO->getRHS())) {
8422 if (!Info.noteFailure())
8423 return false;
8424 Success = false;
8425 }
8426
8427 // The overall lvalue result is the result of evaluating the LHS.
8428 if (!this->Visit(CAO->getLHS()) || !Success)
8429 return false;
8430
8431 return handleCompoundAssignment(
8432 this->Info, CAO,
8433 Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
8434 CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
8435}
8436
8437bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
8438 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
8439 return Error(E);
8440
8441 bool Success = true;
8442
8443 // C++17 onwards require that we evaluate the RHS first.
8444 APValue NewVal;
8445 if (!Evaluate(NewVal, this->Info, E->getRHS())) {
8446 if (!Info.noteFailure())
8447 return false;
8448 Success = false;
8449 }
8450
8451 if (!this->Visit(E->getLHS()) || !Success)
8452 return false;
8453
8454 if (Info.getLangOpts().CPlusPlus20 &&
8455 !HandleUnionActiveMemberChange(Info, E->getLHS(), Result))
8456 return false;
8457
8458 return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
8459 NewVal);
8460}
8461
8462//===----------------------------------------------------------------------===//
8463// Pointer Evaluation
8464//===----------------------------------------------------------------------===//
8465
8466/// Attempts to compute the number of bytes available at the pointer
8467/// returned by a function with the alloc_size attribute. Returns true if we
8468/// were successful. Places an unsigned number into `Result`.
8469///
8470/// This expects the given CallExpr to be a call to a function with an
8471/// alloc_size attribute.
8472static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
8473 const CallExpr *Call,
8474 llvm::APInt &Result) {
8475 const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
8476
8477 assert(AllocSize && AllocSize->getElemSizeParam().isValid())((void)0);
8478 unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();
8479 unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType());
8480 if (Call->getNumArgs() <= SizeArgNo)
8481 return false;
8482
8483 auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
8484 Expr::EvalResult ExprResult;
8485 if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
8486 return false;
8487 Into = ExprResult.Val.getInt();
8488 if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
8489 return false;
8490 Into = Into.zextOrSelf(BitsInSizeT);
8491 return true;
8492 };
8493
8494 APSInt SizeOfElem;
8495 if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem))
8496 return false;
8497
8498 if (!AllocSize->getNumElemsParam().isValid()) {
8499 Result = std::move(SizeOfElem);
8500 return true;
8501 }
8502
8503 APSInt NumberOfElems;
8504 unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex();
8505 if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems))
8506 return false;
8507
8508 bool Overflow;
8509 llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
8510 if (Overflow)
8511 return false;
8512
8513 Result = std::move(BytesAvailable);
8514 return true;
8515}
8516
8517/// Convenience function. LVal's base must be a call to an alloc_size
8518/// function.
8519static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
8520 const LValue &LVal,
8521 llvm::APInt &Result) {
8522 assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&((void)0)
8523 "Can't get the size of a non alloc_size function")((void)0);
8524 const auto *Base = LVal.getLValueBase().get<const Expr *>();
8525 const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
8526 return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
8527}
8528
8529/// Attempts to evaluate the given LValueBase as the result of a call to
8530/// a function with the alloc_size attribute. If it was possible to do so, this
8531/// function will return true, make Result's Base point to said function call,
8532/// and mark Result's Base as invalid.
8533static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base,
8534 LValue &Result) {
8535 if (Base.isNull())
8536 return false;
8537
8538 // Because we do no form of static analysis, we only support const variables.
8539 //
8540 // Additionally, we can't support parameters, nor can we support static
8541 // variables (in the latter case, use-before-assign isn't UB; in the former,
8542 // we have no clue what they'll be assigned to).
8543 const auto *VD =
8544 dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
8545 if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
8546 return false;
8547
8548 const Expr *Init = VD->getAnyInitializer();
8549 if (!Init)
8550 return false;
8551
8552 const Expr *E = Init->IgnoreParens();
8553 if (!tryUnwrapAllocSizeCall(E))
8554 return false;
8555
8556 // Store E instead of E unwrapped so that the type of the LValue's base is
8557 // what the user wanted.
8558 Result.setInvalid(E);
8559
8560 QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType();
8561 Result.addUnsizedArray(Info, E, Pointee);
8562 return true;
8563}
8564
8565namespace {
8566class PointerExprEvaluator
8567 : public ExprEvaluatorBase<PointerExprEvaluator> {
8568 LValue &Result;
8569 bool InvalidBaseOK;
8570
8571 bool Success(const Expr *E) {
8572 Result.set(E);
8573 return true;
8574 }
8575
8576 bool evaluateLValue(const Expr *E, LValue &Result) {
8577 return EvaluateLValue(E, Result, Info, InvalidBaseOK);
8578 }
8579
8580 bool evaluatePointer(const Expr *E, LValue &Result) {
8581 return EvaluatePointer(E, Result, Info, InvalidBaseOK);
8582 }
8583
8584 bool visitNonBuiltinCallExpr(const CallExpr *E);
8585public:
8586
8587 PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
8588 : ExprEvaluatorBaseTy(info), Result(Result),
8589 InvalidBaseOK(InvalidBaseOK) {}
8590
8591 bool Success(const APValue &V, const Expr *E) {
8592 Result.setFrom(Info.Ctx, V);
8593 return true;
8594 }
8595 bool ZeroInitialization(const Expr *E) {
8596 Result.setNull(Info.Ctx, E->getType());
8597 return true;
8598 }
8599
8600 bool VisitBinaryOperator(const BinaryOperator *E);
8601 bool VisitCastExpr(const CastExpr* E);
8602 bool VisitUnaryAddrOf(const UnaryOperator *E);
8603 bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
8604 { return Success(E); }
8605 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
8606 if (E->isExpressibleAsConstantInitializer())
8607 return Success(E);
8608 if (Info.noteFailure())
8609 EvaluateIgnoredValue(Info, E->getSubExpr());
8610 return Error(E);
8611 }
8612 bool VisitAddrLabelExpr(const AddrLabelExpr *E)
8613 { return Success(E); }
8614 bool VisitCallExpr(const CallExpr *E);
8615 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
8616 bool VisitBlockExpr(const BlockExpr *E) {
8617 if (!E->getBlockDecl()->hasCaptures())
8618 return Success(E);
8619 return Error(E);
8620 }
8621 bool VisitCXXThisExpr(const CXXThisExpr *E) {
8622 // Can't look at 'this' when checking a potential constant expression.
8623 if (Info.checkingPotentialConstantExpression())
8624 return false;
8625 if (!Info.CurrentCall->This) {
8626 if (Info.getLangOpts().CPlusPlus11)
8627 Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit();
8628 else
8629 Info.FFDiag(E);
8630 return false;
8631 }
8632 Result = *Info.CurrentCall->This;
8633 // If we are inside a lambda's call operator, the 'this' expression refers
8634 // to the enclosing '*this' object (either by value or reference) which is
8635 // either copied into the closure object's field that represents the '*this'
8636 // or refers to '*this'.
8637 if (isLambdaCallOperator(Info.CurrentCall->Callee)) {
8638 // Ensure we actually have captured 'this'. (an error will have
8639 // been previously reported if not).
8640 if (!Info.CurrentCall->LambdaThisCaptureField)
8641 return false;
8642
8643 // Update 'Result' to refer to the data member/field of the closure object
8644 // that represents the '*this' capture.
8645 if (!HandleLValueMember(Info, E, Result,
8646 Info.CurrentCall->LambdaThisCaptureField))
8647 return false;
8648 // If we captured '*this' by reference, replace the field with its referent.
8649 if (Info.CurrentCall->LambdaThisCaptureField->getType()
8650 ->isPointerType()) {
8651 APValue RVal;
8652 if (!handleLValueToRValueConversion(Info, E, E->getType(), Result,
8653 RVal))
8654 return false;
8655
8656 Result.setFrom(Info.Ctx, RVal);
8657 }
8658 }
8659 return true;
8660 }
8661
8662 bool VisitCXXNewExpr(const CXXNewExpr *E);
8663
8664 bool VisitSourceLocExpr(const SourceLocExpr *E) {
8665 assert(E->isStringType() && "SourceLocExpr isn't a pointer type?")((void)0);
8666 APValue LValResult = E->EvaluateInContext(
8667 Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
8668 Result.setFrom(Info.Ctx, LValResult);
8669 return true;
8670 }
8671
8672 bool VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E) {
8673 std::string ResultStr = E->ComputeName(Info.Ctx);
8674
8675 Info.Ctx.SYCLUniqueStableNameEvaluatedValues[E] = ResultStr;
8676
8677 QualType CharTy = Info.Ctx.CharTy.withConst();
8678 APInt Size(Info.Ctx.getTypeSize(Info.Ctx.getSizeType()),
8679 ResultStr.size() + 1);
8680 QualType ArrayTy = Info.Ctx.getConstantArrayType(CharTy, Size, nullptr,
8681 ArrayType::Normal, 0);
8682
8683 StringLiteral *SL =
8684 StringLiteral::Create(Info.Ctx, ResultStr, StringLiteral::Ascii,
8685 /*Pascal*/ false, ArrayTy, E->getLocation());
8686
8687 evaluateLValue(SL, Result);
8688 Result.addArray(Info, E, cast<ConstantArrayType>(ArrayTy));
8689 return true;
8690 }
8691
8692 // FIXME: Missing: @protocol, @selector
8693};
8694} // end anonymous namespace
8695
8696static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
8697 bool InvalidBaseOK) {
8698 assert(!E->isValueDependent())((void)0);
8699 assert(E->isPRValue() && E->getType()->hasPointerRepresentation())((void)0);
8700 return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
8701}
8702
8703bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
8704 if (E->getOpcode() != BO_Add &&
8705 E->getOpcode() != BO_Sub)
8706 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
8707
8708 const Expr *PExp = E->getLHS();
8709 const Expr *IExp = E->getRHS();
8710 if (IExp->getType()->isPointerType())
8711 std::swap(PExp, IExp);
8712
8713 bool EvalPtrOK = evaluatePointer(PExp, Result);
8714 if (!EvalPtrOK && !Info.noteFailure())
8715 return false;
8716
8717 llvm::APSInt Offset;
8718 if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
8719 return false;
8720
8721 if (E->getOpcode() == BO_Sub)
8722 negateAsSigned(Offset);
8723
8724 QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType();
8725 return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
8726}
8727
8728bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
8729 return evaluateLValue(E->getSubExpr(), Result);
8730}
8731
8732bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
8733 const Expr *SubExpr = E->getSubExpr();
8734
8735 switch (E->getCastKind()) {
8736 default:
8737 break;
8738 case CK_BitCast:
8739 case CK_CPointerToObjCPointerCast:
8740 case CK_BlockPointerToObjCPointerCast:
8741 case CK_AnyPointerToBlockPointerCast:
8742 case CK_AddressSpaceConversion:
8743 if (!Visit(SubExpr))
8744 return false;
8745 // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are
8746 // permitted in constant expressions in C++11. Bitcasts from cv void* are
8747 // also static_casts, but we disallow them as a resolution to DR1312.
8748 if (!E->getType()->isVoidPointerType()) {
8749 if (!Result.InvalidBase && !Result.Designator.Invalid &&
8750 !Result.IsNullPtr &&
8751 Info.Ctx.hasSameUnqualifiedType(Result.Designator.getType(Info.Ctx),
8752 E->getType()->getPointeeType()) &&
8753 Info.getStdAllocatorCaller("allocate")) {
8754 // Inside a call to std::allocator::allocate and friends, we permit
8755 // casting from void* back to cv1 T* for a pointer that points to a
8756 // cv2 T.
8757 } else {
8758 Result.Designator.setInvalid();
8759 if (SubExpr->getType()->isVoidPointerType())
8760 CCEDiag(E, diag::note_constexpr_invalid_cast)
8761 << 3 << SubExpr->getType();
8762 else
8763 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
8764 }
8765 }
8766 if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
8767 ZeroInitialization(E);
8768 return true;
8769
8770 case CK_DerivedToBase:
8771 case CK_UncheckedDerivedToBase:
8772 if (!evaluatePointer(E->getSubExpr(), Result))
8773 return false;
8774 if (!Result.Base && Result.Offset.isZero())
8775 return true;
8776
8777 // Now figure out the necessary offset to add to the base LV to get from
8778 // the derived class to the base class.
8779 return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
8780 castAs<PointerType>()->getPointeeType(),
8781 Result);
8782
8783 case CK_BaseToDerived:
8784 if (!Visit(E->getSubExpr()))
8785 return false;
8786 if (!Result.Base && Result.Offset.isZero())
8787 return true;
8788 return HandleBaseToDerivedCast(Info, E, Result);
8789
8790 case CK_Dynamic:
8791 if (!Visit(E->getSubExpr()))
8792 return false;
8793 return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result);
8794
8795 case CK_NullToPointer:
8796 VisitIgnoredValue(E->getSubExpr());
8797 return ZeroInitialization(E);
8798
8799 case CK_IntegralToPointer: {
8800 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
8801
8802 APValue Value;
8803 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
8804 break;
8805
8806 if (Value.isInt()) {
8807 unsigned Size = Info.Ctx.getTypeSize(E->getType());
8808 uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
8809 Result.Base = (Expr*)nullptr;
8810 Result.InvalidBase = false;
8811 Result.Offset = CharUnits::fromQuantity(N);
8812 Result.Designator.setInvalid();
8813 Result.IsNullPtr = false;
8814 return true;
8815 } else {
8816 // Cast is of an lvalue, no need to change value.
8817 Result.setFrom(Info.Ctx, Value);
8818 return true;
8819 }
8820 }
8821
8822 case CK_ArrayToPointerDecay: {
8823 if (SubExpr->isGLValue()) {
8824 if (!evaluateLValue(SubExpr, Result))
8825 return false;
8826 } else {
8827 APValue &Value = Info.CurrentCall->createTemporary(
8828 SubExpr, SubExpr->getType(), ScopeKind::FullExpression, Result);
8829 if (!EvaluateInPlace(Value, Info, Result, SubExpr))
8830 return false;
8831 }
8832 // The result is a pointer to the first element of the array.
8833 auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType());
8834 if (auto *CAT = dyn_cast<ConstantArrayType>(AT))
8835 Result.addArray(Info, E, CAT);
8836 else
8837 Result.addUnsizedArray(Info, E, AT->getElementType());
8838 return true;
8839 }
8840
8841 case CK_FunctionToPointerDecay:
8842 return evaluateLValue(SubExpr, Result);
8843
8844 case CK_LValueToRValue: {
8845 LValue LVal;
8846 if (!evaluateLValue(E->getSubExpr(), LVal))
8847 return false;
8848
8849 APValue RVal;
8850 // Note, we use the subexpression's type in order to retain cv-qualifiers.
8851 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
8852 LVal, RVal))
8853 return InvalidBaseOK &&
8854 evaluateLValueAsAllocSize(Info, LVal.Base, Result);
8855 return Success(RVal, E);
8856 }
8857 }
8858
8859 return ExprEvaluatorBaseTy::VisitCastExpr(E);
8860}
8861
8862static CharUnits GetAlignOfType(EvalInfo &Info, QualType T,
8863 UnaryExprOrTypeTrait ExprKind) {
8864 // C++ [expr.alignof]p3:
8865 // When alignof is applied to a reference type, the result is the
8866 // alignment of the referenced type.
8867 if (const ReferenceType *Ref = T->getAs<ReferenceType>())
8868 T = Ref->getPointeeType();
8869
8870 if (T.getQualifiers().hasUnaligned())
8871 return CharUnits::One();
8872
8873 const bool AlignOfReturnsPreferred =
8874 Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
8875
8876 // __alignof is defined to return the preferred alignment.
8877 // Before 8, clang returned the preferred alignment for alignof and _Alignof
8878 // as well.
8879 if (ExprKind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)
8880 return Info.Ctx.toCharUnitsFromBits(
8881 Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
8882 // alignof and _Alignof are defined to return the ABI alignment.
8883 else if (ExprKind == UETT_AlignOf)
8884 return Info.Ctx.getTypeAlignInChars(T.getTypePtr());
8885 else
8886 llvm_unreachable("GetAlignOfType on a non-alignment ExprKind")__builtin_unreachable();
8887}
8888
8889static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
8890 UnaryExprOrTypeTrait ExprKind) {
8891 E = E->IgnoreParens();
8892
8893 // The kinds of expressions that we have special-case logic here for
8894 // should be kept up to date with the special checks for those
8895 // expressions in Sema.
8896
8897 // alignof decl is always accepted, even if it doesn't make sense: we default
8898 // to 1 in those cases.
8899 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
8900 return Info.Ctx.getDeclAlign(DRE->getDecl(),
8901 /*RefAsPointee*/true);
8902
8903 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
8904 return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
8905 /*RefAsPointee*/true);
8906
8907 return GetAlignOfType(Info, E->getType(), ExprKind);
8908}
8909
8910static CharUnits getBaseAlignment(EvalInfo &Info, const LValue &Value) {
8911 if (const auto *VD = Value.Base.dyn_cast<const ValueDecl *>())
8912 return Info.Ctx.getDeclAlign(VD);
8913 if (const auto *E = Value.Base.dyn_cast<const Expr *>())
8914 return GetAlignOfExpr(Info, E, UETT_AlignOf);
8915 return GetAlignOfType(Info, Value.Base.getTypeInfoType(), UETT_AlignOf);
8916}
8917
8918/// Evaluate the value of the alignment argument to __builtin_align_{up,down},
8919/// __builtin_is_aligned and __builtin_assume_aligned.
8920static bool getAlignmentArgument(const Expr *E, QualType ForType,
8921 EvalInfo &Info, APSInt &Alignment) {
8922 if (!EvaluateInteger(E, Alignment, Info))
8923 return false;
8924 if (Alignment < 0 || !Alignment.isPowerOf2()) {
8925 Info.FFDiag(E, diag::note_constexpr_invalid_alignment) << Alignment;
8926 return false;
8927 }
8928 unsigned SrcWidth = Info.Ctx.getIntWidth(ForType);
8929 APSInt MaxValue(APInt::getOneBitSet(SrcWidth, SrcWidth - 1));
8930 if (APSInt::compareValues(Alignment, MaxValue) > 0) {
8931 Info.FFDiag(E, diag::note_constexpr_alignment_too_big)
8932 << MaxValue << ForType << Alignment;
8933 return false;
8934 }
8935 // Ensure both alignment and source value have the same bit width so that we
8936 // don't assert when computing the resulting value.
8937 APSInt ExtAlignment =
8938 APSInt(Alignment.zextOrTrunc(SrcWidth), /*isUnsigned=*/true);
8939 assert(APSInt::compareValues(Alignment, ExtAlignment) == 0 &&((void)0)
8940 "Alignment should not be changed by ext/trunc")((void)0);
8941 Alignment = ExtAlignment;
8942 assert(Alignment.getBitWidth() == SrcWidth)((void)0);
8943 return true;
8944}
8945
8946// To be clear: this happily visits unsupported builtins. Better name welcomed.
8947bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
8948 if (ExprEvaluatorBaseTy::VisitCallExpr(E))
8949 return true;
8950
8951 if (!(InvalidBaseOK && getAllocSizeAttr(E)))
8952 return false;
8953
8954 Result.setInvalid(E);
8955 QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType();
8956 Result.addUnsizedArray(Info, E, PointeeTy);
8957 return true;
8958}
8959
8960bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
8961 if (IsStringLiteralCall(E))
8962 return Success(E);
8963
8964 if (unsigned BuiltinOp = E->getBuiltinCallee())
8965 return VisitBuiltinCallExpr(E, BuiltinOp);
8966
8967 return visitNonBuiltinCallExpr(E);
8968}
8969
8970// Determine if T is a character type for which we guarantee that
8971// sizeof(T) == 1.
8972static bool isOneByteCharacterType(QualType T) {
8973 return T->isCharType() || T->isChar8Type();
8974}
8975
8976bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
8977 unsigned BuiltinOp) {
8978 switch (BuiltinOp) {
8979 case Builtin::BI__builtin_addressof:
8980 return evaluateLValue(E->getArg(0), Result);
8981 case Builtin::BI__builtin_assume_aligned: {
8982 // We need to be very careful here because: if the pointer does not have the
8983 // asserted alignment, then the behavior is undefined, and undefined
8984 // behavior is non-constant.
8985 if (!evaluatePointer(E->getArg(0), Result))
8986 return false;
8987
8988 LValue OffsetResult(Result);
8989 APSInt Alignment;
8990 if (!getAlignmentArgument(E->getArg(1), E->getArg(0)->getType(), Info,
8991 Alignment))
8992 return false;
8993 CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
8994
8995 if (E->getNumArgs() > 2) {
8996 APSInt Offset;
8997 if (!EvaluateInteger(E->getArg(2), Offset, Info))
8998 return false;
8999
9000 int64_t AdditionalOffset = -Offset.getZExtValue();
9001 OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
9002 }
9003
9004 // If there is a base object, then it must have the correct alignment.
9005 if (OffsetResult.Base) {
9006 CharUnits BaseAlignment = getBaseAlignment(Info, OffsetResult);
9007
9008 if (BaseAlignment < Align) {
9009 Result.Designator.setInvalid();
9010 // FIXME: Add support to Diagnostic for long / long long.
9011 CCEDiag(E->getArg(0),
9012 diag::note_constexpr_baa_insufficient_alignment) << 0
9013 << (unsigned)BaseAlignment.getQuantity()
9014 << (unsigned)Align.getQuantity();
9015 return false;
9016 }
9017 }
9018
9019 // The offset must also have the correct alignment.
9020 if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
9021 Result.Designator.setInvalid();
9022
9023 (OffsetResult.Base
9024 ? CCEDiag(E->getArg(0),
9025 diag::note_constexpr_baa_insufficient_alignment) << 1
9026 : CCEDiag(E->getArg(0),
9027 diag::note_constexpr_baa_value_insufficient_alignment))
9028 << (int)OffsetResult.Offset.getQuantity()
9029 << (unsigned)Align.getQuantity();
9030 return false;
9031 }
9032
9033 return true;
9034 }
9035 case Builtin::BI__builtin_align_up:
9036 case Builtin::BI__builtin_align_down: {
9037 if (!evaluatePointer(E->getArg(0), Result))
9038 return false;
9039 APSInt Alignment;
9040 if (!getAlignmentArgument(E->getArg(1), E->getArg(0)->getType(), Info,
9041 Alignment))
9042 return false;
9043 CharUnits BaseAlignment = getBaseAlignment(Info, Result);
9044 CharUnits PtrAlign = BaseAlignment.alignmentAtOffset(Result.Offset);
9045 // For align_up/align_down, we can return the same value if the alignment
9046 // is known to be greater or equal to the requested value.
9047 if (PtrAlign.getQuantity() >= Alignment)
9048 return true;
9049
9050 // The alignment could be greater than the minimum at run-time, so we cannot
9051 // infer much about the resulting pointer value. One case is possible:
9052 // For `_Alignas(32) char buf[N]; __builtin_align_down(&buf[idx], 32)` we
9053 // can infer the correct index if the requested alignment is smaller than
9054 // the base alignment so we can perform the computation on the offset.
9055 if (BaseAlignment.getQuantity() >= Alignment) {
9056 assert(Alignment.getBitWidth() <= 64 &&((void)0)
9057 "Cannot handle > 64-bit address-space")((void)0);
9058 uint64_t Alignment64 = Alignment.getZExtValue();
9059 CharUnits NewOffset = CharUnits::fromQuantity(
9060 BuiltinOp == Builtin::BI__builtin_align_down
9061 ? llvm::alignDown(Result.Offset.getQuantity(), Alignment64)
9062 : llvm::alignTo(Result.Offset.getQuantity(), Alignment64));
9063 Result.adjustOffset(NewOffset - Result.Offset);
9064 // TODO: diagnose out-of-bounds values/only allow for arrays?
9065 return true;
9066 }
9067 // Otherwise, we cannot constant-evaluate the result.
9068 Info.FFDiag(E->getArg(0), diag::note_constexpr_alignment_adjust)
9069 << Alignment;
9070 return false;
9071 }
9072 case Builtin::BI__builtin_operator_new:
9073 return HandleOperatorNewCall(Info, E, Result);
9074 case Builtin::BI__builtin_launder:
9075 return evaluatePointer(E->getArg(0), Result);
9076 case Builtin::BIstrchr:
9077 case Builtin::BIwcschr:
9078 case Builtin::BImemchr:
9079 case Builtin::BIwmemchr:
9080 if (Info.getLangOpts().CPlusPlus11)
9081 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
9082 << /*isConstexpr*/0 << /*isConstructor*/0
9083 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
9084 else
9085 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
9086 LLVM_FALLTHROUGH[[gnu::fallthrough]];
9087 case Builtin::BI__builtin_strchr:
9088 case Builtin::BI__builtin_wcschr:
9089 case Builtin::BI__builtin_memchr:
9090 case Builtin::BI__builtin_char_memchr:
9091 case Builtin::BI__builtin_wmemchr: {
9092 if (!Visit(E->getArg(0)))
9093 return false;
9094 APSInt Desired;
9095 if (!EvaluateInteger(E->getArg(1), Desired, Info))
9096 return false;
9097 uint64_t MaxLength = uint64_t(-1);
9098 if (BuiltinOp != Builtin::BIstrchr &&
9099 BuiltinOp != Builtin::BIwcschr &&
9100 BuiltinOp != Builtin::BI__builtin_strchr &&
9101 BuiltinOp != Builtin::BI__builtin_wcschr) {
9102 APSInt N;
9103 if (!EvaluateInteger(E->getArg(2), N, Info))
9104 return false;
9105 MaxLength = N.getExtValue();
9106 }
9107 // We cannot find the value if there are no candidates to match against.
9108 if (MaxLength == 0u)
9109 return ZeroInitialization(E);
9110 if (!Result.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
9111 Result.Designator.Invalid)
9112 return false;
9113 QualType CharTy = Result.Designator.getType(Info.Ctx);
9114 bool IsRawByte = BuiltinOp == Builtin::BImemchr ||
9115 BuiltinOp == Builtin::BI__builtin_memchr;
9116 assert(IsRawByte ||((void)0)
9117 Info.Ctx.hasSameUnqualifiedType(((void)0)
9118 CharTy, E->getArg(0)->getType()->getPointeeType()))((void)0);
9119 // Pointers to const void may point to objects of incomplete type.
9120 if (IsRawByte && CharTy->isIncompleteType()) {
9121 Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy;
9122 return false;
9123 }
9124 // Give up on byte-oriented matching against multibyte elements.
9125 // FIXME: We can compare the bytes in the correct order.
9126 if (IsRawByte && !isOneByteCharacterType(CharTy)) {
9127 Info.FFDiag(E, diag::note_constexpr_memchr_unsupported)
9128 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'")
9129 << CharTy;
9130 return false;
9131 }
9132 // Figure out what value we're actually looking for (after converting to
9133 // the corresponding unsigned type if necessary).
9134 uint64_t DesiredVal;
9135 bool StopAtNull = false;
9136 switch (BuiltinOp) {
9137 case Builtin::BIstrchr:
9138 case Builtin::BI__builtin_strchr:
9139 // strchr compares directly to the passed integer, and therefore
9140 // always fails if given an int that is not a char.
9141 if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy,
9142 E->getArg(1)->getType(),
9143 Desired),
9144 Desired))
9145 return ZeroInitialization(E);
9146 StopAtNull = true;
9147 LLVM_FALLTHROUGH[[gnu::fallthrough]];
9148 case Builtin::BImemchr:
9149 case Builtin::BI__builtin_memchr:
9150 case Builtin::BI__builtin_char_memchr:
9151 // memchr compares by converting both sides to unsigned char. That's also
9152 // correct for strchr if we get this far (to cope with plain char being
9153 // unsigned in the strchr case).
9154 DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
9155 break;
9156
9157 case Builtin::BIwcschr:
9158 case Builtin::BI__builtin_wcschr:
9159 StopAtNull = true;
9160 LLVM_FALLTHROUGH[[gnu::fallthrough]];
9161 case Builtin::BIwmemchr:
9162 case Builtin::BI__builtin_wmemchr:
9163 // wcschr and wmemchr are given a wchar_t to look for. Just use it.
9164 DesiredVal = Desired.getZExtValue();
9165 break;
9166 }
9167
9168 for (; MaxLength; --MaxLength) {
9169 APValue Char;
9170 if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) ||
9171 !Char.isInt())
9172 return false;
9173 if (Char.getInt().getZExtValue() == DesiredVal)
9174 return true;
9175 if (StopAtNull && !Char.getInt())
9176 break;
9177 if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1))
9178 return false;
9179 }
9180 // Not found: return nullptr.
9181 return ZeroInitialization(E);
9182 }
9183
9184 case Builtin::BImemcpy:
9185 case Builtin::BImemmove:
9186 case Builtin::BIwmemcpy:
9187 case Builtin::BIwmemmove:
9188 if (Info.getLangOpts().CPlusPlus11)
9189 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
9190 << /*isConstexpr*/0 << /*isConstructor*/0
9191 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
9192 else
9193 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
9194 LLVM_FALLTHROUGH[[gnu::fallthrough]];
9195 case Builtin::BI__builtin_memcpy:
9196 case Builtin::BI__builtin_memmove:
9197 case Builtin::BI__builtin_wmemcpy:
9198 case Builtin::BI__builtin_wmemmove: {
9199 bool WChar = BuiltinOp == Builtin::BIwmemcpy ||
9200 BuiltinOp == Builtin::BIwmemmove ||
9201 BuiltinOp == Builtin::BI__builtin_wmemcpy ||
9202 BuiltinOp == Builtin::BI__builtin_wmemmove;
9203 bool Move = BuiltinOp == Builtin::BImemmove ||
9204 BuiltinOp == Builtin::BIwmemmove ||
9205 BuiltinOp == Builtin::BI__builtin_memmove ||
9206 BuiltinOp == Builtin::BI__builtin_wmemmove;
9207
9208 // The result of mem* is the first argument.
9209 if (!Visit(E->getArg(0)))
9210 return false;
9211 LValue Dest = Result;
9212
9213 LValue Src;
9214 if (!EvaluatePointer(E->getArg(1), Src, Info))
9215 return false;
9216
9217 APSInt N;
9218 if (!EvaluateInteger(E->getArg(2), N, Info))
9219 return false;
9220 assert(!N.isSigned() && "memcpy and friends take an unsigned size")((void)0);
9221
9222 // If the size is zero, we treat this as always being a valid no-op.
9223 // (Even if one of the src and dest pointers is null.)
9224 if (!N)
9225 return true;
9226
9227 // Otherwise, if either of the operands is null, we can't proceed. Don't
9228 // try to determine the type of the copied objects, because there aren't
9229 // any.
9230 if (!Src.Base || !Dest.Base) {
9231 APValue Val;
9232 (!Src.Base ? Src : Dest).moveInto(Val);
9233 Info.FFDiag(E, diag::note_constexpr_memcpy_null)
9234 << Move << WChar << !!Src.Base
9235 << Val.getAsString(Info.Ctx, E->getArg(0)->getType());
9236 return false;
9237 }
9238 if (Src.Designator.Invalid || Dest.Designator.Invalid)
9239 return false;
9240
9241 // We require that Src and Dest are both pointers to arrays of
9242 // trivially-copyable type. (For the wide version, the designator will be
9243 // invalid if the designated object is not a wchar_t.)
9244 QualType T = Dest.Designator.getType(Info.Ctx);
9245 QualType SrcT = Src.Designator.getType(Info.Ctx);
9246 if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) {
9247 // FIXME: Consider using our bit_cast implementation to support this.
9248 Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T;
9249 return false;
9250 }
9251 if (T->isIncompleteType()) {
9252 Info.FFDiag(E, diag::note_constexpr_memcpy_incomplete_type) << Move << T;
9253 return false;
9254 }
9255 if (!T.isTriviallyCopyableType(Info.Ctx)) {
9256 Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T;
9257 return false;
9258 }
9259
9260 // Figure out how many T's we're copying.
9261 uint64_t TSize = Info.Ctx.getTypeSizeInChars(T).getQuantity();
9262 if (!WChar) {
9263 uint64_t Remainder;
9264 llvm::APInt OrigN = N;
9265 llvm::APInt::udivrem(OrigN, TSize, N, Remainder);
9266 if (Remainder) {
9267 Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
9268 << Move << WChar << 0 << T << toString(OrigN, 10, /*Signed*/false)
9269 << (unsigned)TSize;
9270 return false;
9271 }
9272 }
9273
9274 // Check that the copying will remain within the arrays, just so that we
9275 // can give a more meaningful diagnostic. This implicitly also checks that
9276 // N fits into 64 bits.
9277 uint64_t RemainingSrcSize = Src.Designator.validIndexAdjustments().second;
9278 uint64_t RemainingDestSize = Dest.Designator.validIndexAdjustments().second;
9279 if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) {
9280 Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
9281 << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T
9282 << toString(N, 10, /*Signed*/false);
9283 return false;
9284 }
9285 uint64_t NElems = N.getZExtValue();
9286 uint64_t NBytes = NElems * TSize;
9287
9288 // Check for overlap.
9289 int Direction = 1;
9290 if (HasSameBase(Src, Dest)) {
9291 uint64_t SrcOffset = Src.getLValueOffset().getQuantity();
9292 uint64_t DestOffset = Dest.getLValueOffset().getQuantity();
9293 if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) {
9294 // Dest is inside the source region.
9295 if (!Move) {
9296 Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
9297 return false;
9298 }
9299 // For memmove and friends, copy backwards.
9300 if (!HandleLValueArrayAdjustment(Info, E, Src, T, NElems - 1) ||
9301 !HandleLValueArrayAdjustment(Info, E, Dest, T, NElems - 1))
9302 return false;
9303 Direction = -1;
9304 } else if (!Move && SrcOffset >= DestOffset &&
9305 SrcOffset - DestOffset < NBytes) {
9306 // Src is inside the destination region for memcpy: invalid.
9307 Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;
9308 return false;
9309 }
9310 }
9311
9312 while (true) {
9313 APValue Val;
9314 // FIXME: Set WantObjectRepresentation to true if we're copying a
9315 // char-like type?
9316 if (!handleLValueToRValueConversion(Info, E, T, Src, Val) ||
9317 !handleAssignment(Info, E, Dest, T, Val))
9318 return false;
9319 // Do not iterate past the last element; if we're copying backwards, that
9320 // might take us off the start of the array.
9321 if (--NElems == 0)
9322 return true;
9323 if (!HandleLValueArrayAdjustment(Info, E, Src, T, Direction) ||
9324 !HandleLValueArrayAdjustment(Info, E, Dest, T, Direction))
9325 return false;
9326 }
9327 }
9328
9329 default:
9330 break;
9331 }
9332
9333 return visitNonBuiltinCallExpr(E);
9334}
9335
9336static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
9337 APValue &Result, const InitListExpr *ILE,
9338 QualType AllocType);
9339static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
9340 APValue &Result,
9341 const CXXConstructExpr *CCE,
9342 QualType AllocType);
9343
9344bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
9345 if (!Info.getLangOpts().CPlusPlus20)
9346 Info.CCEDiag(E, diag::note_constexpr_new);
9347
9348 // We cannot speculatively evaluate a delete expression.
9349 if (Info.SpeculativeEvaluationDepth)
9350 return false;
9351
9352 FunctionDecl *OperatorNew = E->getOperatorNew();
9353
9354 bool IsNothrow = false;
9355 bool IsPlacement = false;
9356 if (OperatorNew->isReservedGlobalPlacementOperator() &&
9357 Info.CurrentCall->isStdFunction() && !E->isArray()) {
9358 // FIXME Support array placement new.
9359 assert(E->getNumPlacementArgs() == 1)((void)0);
9360 if (!EvaluatePointer(E->getPlacementArg(0), Result, Info))
9361 return false;
9362 if (Result.Designator.Invalid)
9363 return false;
9364 IsPlacement = true;
9365 } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {
9366 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
9367 << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;
9368 return false;
9369 } else if (E->getNumPlacementArgs()) {
9370 // The only new-placement list we support is of the form (std::nothrow).
9371 //
9372 // FIXME: There is no restriction on this, but it's not clear that any
9373 // other form makes any sense. We get here for cases such as:
9374 //
9375 // new (std::align_val_t{N}) X(int)
9376 //
9377 // (which should presumably be valid only if N is a multiple of
9378 // alignof(int), and in any case can't be deallocated unless N is
9379 // alignof(X) and X has new-extended alignment).
9380 if (E->getNumPlacementArgs() != 1 ||
9381 !E->getPlacementArg(0)->getType()->isNothrowT())
9382 return Error(E, diag::note_constexpr_new_placement);
9383
9384 LValue Nothrow;
9385 if (!EvaluateLValue(E->getPlacementArg(0), Nothrow, Info))
9386 return false;
9387 IsNothrow = true;
9388 }
9389
9390 const Expr *Init = E->getInitializer();
9391 const InitListExpr *ResizedArrayILE = nullptr;
9392 const CXXConstructExpr *ResizedArrayCCE = nullptr;
9393 bool ValueInit = false;
9394
9395 QualType AllocType = E->getAllocatedType();
9396 if (Optional<const Expr*> ArraySize = E->getArraySize()) {
9397 const Expr *Stripped = *ArraySize;
9398 for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Stripped);
9399 Stripped = ICE->getSubExpr())
9400 if (ICE->getCastKind() != CK_NoOp &&
9401 ICE->getCastKind() != CK_IntegralCast)
9402 break;
9403
9404 llvm::APSInt ArrayBound;
9405 if (!EvaluateInteger(Stripped, ArrayBound, Info))
9406 return false;
9407
9408 // C++ [expr.new]p9:
9409 // The expression is erroneous if:
9410 // -- [...] its value before converting to size_t [or] applying the
9411 // second standard conversion sequence is less than zero
9412 if (ArrayBound.isSigned() && ArrayBound.isNegative()) {
9413 if (IsNothrow)
9414 return ZeroInitialization(E);
9415
9416 Info.FFDiag(*ArraySize, diag::note_constexpr_new_negative)
9417 << ArrayBound << (*ArraySize)->getSourceRange();
9418 return false;
9419 }
9420
9421 // -- its value is such that the size of the allocated object would
9422 // exceed the implementation-defined limit
9423 if (ConstantArrayType::getNumAddressingBits(Info.Ctx, AllocType,
9424 ArrayBound) >
9425 ConstantArrayType::getMaxSizeBits(Info.Ctx)) {
9426 if (IsNothrow)
9427 return ZeroInitialization(E);
9428
9429 Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large)
9430 << ArrayBound << (*ArraySize)->getSourceRange();
9431 return false;
9432 }
9433
9434 // -- the new-initializer is a braced-init-list and the number of
9435 // array elements for which initializers are provided [...]
9436 // exceeds the number of elements to initialize
9437 if (!Init) {
9438 // No initialization is performed.
9439 } else if (isa<CXXScalarValueInitExpr>(Init) ||
9440 isa<ImplicitValueInitExpr>(Init)) {
9441 ValueInit = true;
9442 } else if (auto *CCE = dyn_cast<CXXConstructExpr>(Init)) {
9443 ResizedArrayCCE = CCE;
9444 } else {
9445 auto *CAT = Info.Ctx.getAsConstantArrayType(Init->getType());
9446 assert(CAT && "unexpected type for array initializer")((void)0);
9447
9448 unsigned Bits =
9449 std::max(CAT->getSize().getBitWidth(), ArrayBound.getBitWidth());
9450 llvm::APInt InitBound = CAT->getSize().zextOrSelf(Bits);
9451 llvm::APInt AllocBound = ArrayBound.zextOrSelf(Bits);
9452 if (InitBound.ugt(AllocBound)) {
9453 if (IsNothrow)
9454 return ZeroInitialization(E);
9455
9456 Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_small)
9457 << toString(AllocBound, 10, /*Signed=*/false)
9458 << toString(InitBound, 10, /*Signed=*/false)
9459 << (*ArraySize)->getSourceRange();
9460 return false;
9461 }
9462
9463 // If the sizes differ, we must have an initializer list, and we need
9464 // special handling for this case when we initialize.
9465 if (InitBound != AllocBound)
9466 ResizedArrayILE = cast<InitListExpr>(Init);
9467 }
9468
9469 AllocType = Info.Ctx.getConstantArrayType(AllocType, ArrayBound, nullptr,
9470 ArrayType::Normal, 0);
9471 } else {
9472 assert(!AllocType->isArrayType() &&((void)0)
9473 "array allocation with non-array new")((void)0);
9474 }
9475
9476 APValue *Val;
9477 if (IsPlacement) {
9478 AccessKinds AK = AK_Construct;
9479 struct FindObjectHandler {
9480 EvalInfo &Info;
9481 const Expr *E;
9482 QualType AllocType;
9483 const AccessKinds AccessKind;
9484 APValue *Value;
9485
9486 typedef bool result_type;
9487 bool failed() { return false; }
9488 bool found(APValue &Subobj, QualType SubobjType) {
9489 // FIXME: Reject the cases where [basic.life]p8 would not permit the
9490 // old name of the object to be used to name the new object.
9491 if (!Info.Ctx.hasSameUnqualifiedType(SubobjType, AllocType)) {
9492 Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type) <<
9493 SubobjType << AllocType;
9494 return false;
9495 }
9496 Value = &Subobj;
9497 return true;
9498 }
9499 bool found(APSInt &Value, QualType SubobjType) {
9500 Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);
9501 return false;
9502 }
9503 bool found(APFloat &Value, QualType SubobjType) {
9504 Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);
9505 return false;
9506 }
9507 } Handler = {Info, E, AllocType, AK, nullptr};
9508
9509 CompleteObject Obj = findCompleteObject(Info, E, AK, Result, AllocType);
9510 if (!Obj || !findSubobject(Info, E, Obj, Result.Designator, Handler))
9511 return false;
9512
9513 Val = Handler.Value;
9514
9515 // [basic.life]p1:
9516 // The lifetime of an object o of type T ends when [...] the storage
9517 // which the object occupies is [...] reused by an object that is not
9518 // nested within o (6.6.2).
9519 *Val = APValue();
9520 } else {
9521 // Perform the allocation and obtain a pointer to the resulting object.
9522 Val = Info.createHeapAlloc(E, AllocType, Result);
9523 if (!Val)
9524 return false;
9525 }
9526
9527 if (ValueInit) {
9528 ImplicitValueInitExpr VIE(AllocType);
9529 if (!EvaluateInPlace(*Val, Info, Result, &VIE))
9530 return false;
9531 } else if (ResizedArrayILE) {
9532 if (!EvaluateArrayNewInitList(Info, Result, *Val, ResizedArrayILE,
9533 AllocType))
9534 return false;
9535 } else if (ResizedArrayCCE) {
9536 if (!EvaluateArrayNewConstructExpr(Info, Result, *Val, ResizedArrayCCE,
9537 AllocType))
9538 return false;
9539 } else if (Init) {
9540 if (!EvaluateInPlace(*Val, Info, Result, Init))
9541 return false;
9542 } else if (!getDefaultInitValue(AllocType, *Val)) {
9543 return false;
9544 }
9545
9546 // Array new returns a pointer to the first element, not a pointer to the
9547 // array.
9548 if (auto *AT = AllocType->getAsArrayTypeUnsafe())
9549 Result.addArray(Info, E, cast<ConstantArrayType>(AT));
9550
9551 return true;
9552}
9553//===----------------------------------------------------------------------===//
9554// Member Pointer Evaluation
9555//===----------------------------------------------------------------------===//
9556
9557namespace {
9558class MemberPointerExprEvaluator
9559 : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
9560 MemberPtr &Result;
9561
9562 bool Success(const ValueDecl *D) {
9563 Result = MemberPtr(D);
9564 return true;
9565 }
9566public:
9567
9568 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
9569 : ExprEvaluatorBaseTy(Info), Result(Result) {}
9570
9571 bool Success(const APValue &V, const Expr *E) {
9572 Result.setFrom(V);
9573 return true;
9574 }
9575 bool ZeroInitialization(const Expr *E) {
9576 return Success((const ValueDecl*)nullptr);
9577 }
9578
9579 bool VisitCastExpr(const CastExpr *E);
9580 bool VisitUnaryAddrOf(const UnaryOperator *E);
9581};
9582} // end anonymous namespace
9583
9584static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
9585 EvalInfo &Info) {
9586 assert(!E->isValueDependent())((void)0);
9587 assert(E->isPRValue() && E->getType()->isMemberPointerType())((void)0);
9588 return MemberPointerExprEvaluator(Info, Result).Visit(E);
9589}
9590
9591bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
9592 switch (E->getCastKind()) {
9593 default:
9594 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9595
9596 case CK_NullToMemberPointer:
9597 VisitIgnoredValue(E->getSubExpr());
9598 return ZeroInitialization(E);
9599
9600 case CK_BaseToDerivedMemberPointer: {
9601 if (!Visit(E->getSubExpr()))
9602 return false;
9603 if (E->path_empty())
9604 return true;
9605 // Base-to-derived member pointer casts store the path in derived-to-base
9606 // order, so iterate backwards. The CXXBaseSpecifier also provides us with
9607 // the wrong end of the derived->base arc, so stagger the path by one class.
9608 typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
9609 for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
9610 PathI != PathE; ++PathI) {
9611 assert(!(*PathI)->isVirtual() && "memptr cast through vbase")((void)0);
9612 const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
9613 if (!Result.castToDerived(Derived))
9614 return Error(E);
9615 }
9616 const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
9617 if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
9618 return Error(E);
9619 return true;
9620 }
9621
9622 case CK_DerivedToBaseMemberPointer:
9623 if (!Visit(E->getSubExpr()))
9624 return false;
9625 for (CastExpr::path_const_iterator PathI = E->path_begin(),
9626 PathE = E->path_end(); PathI != PathE; ++PathI) {
9627 assert(!(*PathI)->isVirtual() && "memptr cast through vbase")((void)0);
9628 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
9629 if (!Result.castToBase(Base))
9630 return Error(E);
9631 }
9632 return true;
9633 }
9634}
9635
9636bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
9637 // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
9638 // member can be formed.
9639 return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
9640}
9641
9642//===----------------------------------------------------------------------===//
9643// Record Evaluation
9644//===----------------------------------------------------------------------===//
9645
9646namespace {
9647 class RecordExprEvaluator
9648 : public ExprEvaluatorBase<RecordExprEvaluator> {
9649 const LValue &This;
9650 APValue &Result;
9651 public:
9652
9653 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
9654 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
9655
9656 bool Success(const APValue &V, const Expr *E) {
9657 Result = V;
9658 return true;
9659 }
9660 bool ZeroInitialization(const Expr *E) {
9661 return ZeroInitialization(E, E->getType());
9662 }
9663 bool ZeroInitialization(const Expr *E, QualType T);
9664
9665 bool VisitCallExpr(const CallExpr *E) {
9666 return handleCallExpr(E, Result, &This);
9667 }
9668 bool VisitCastExpr(const CastExpr *E);
9669 bool VisitInitListExpr(const InitListExpr *E);
9670 bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
9671 return VisitCXXConstructExpr(E, E->getType());
9672 }
9673 bool VisitLambdaExpr(const LambdaExpr *E);
9674 bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
9675 bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
9676 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
9677 bool VisitBinCmp(const BinaryOperator *E);
9678 };
9679}
9680
9681/// Perform zero-initialization on an object of non-union class type.
9682/// C++11 [dcl.init]p5:
9683/// To zero-initialize an object or reference of type T means:
9684/// [...]
9685/// -- if T is a (possibly cv-qualified) non-union class type,
9686/// each non-static data member and each base-class subobject is
9687/// zero-initialized
9688static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
9689 const RecordDecl *RD,
9690 const LValue &This, APValue &Result) {
9691 assert(!RD->isUnion() && "Expected non-union class type")((void)0);
9692 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
9693 Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
9694 std::distance(RD->field_begin(), RD->field_end()));
9695
9696 if (RD->isInvalidDecl()) return false;
9697 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
9698
9699 if (CD) {
9700 unsigned Index = 0;
9701 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
9702 End = CD->bases_end(); I != End; ++I, ++Index) {
9703 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
9704 LValue Subobject = This;
9705 if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
9706 return false;
9707 if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
9708 Result.getStructBase(Index)))
9709 return false;
9710 }
9711 }
9712
9713 for (const auto *I : RD->fields()) {
9714 // -- if T is a reference type, no initialization is performed.
9715 if (I->isUnnamedBitfield() || I->getType()->isReferenceType())
9716 continue;
9717
9718 LValue Subobject = This;
9719 if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
9720 return false;
9721
9722 ImplicitValueInitExpr VIE(I->getType());
9723 if (!EvaluateInPlace(
9724 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
9725 return false;
9726 }
9727
9728 return true;
9729}
9730
9731bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
9732 const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
9733 if (RD->isInvalidDecl()) return false;
9734 if (RD->isUnion()) {
9735 // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
9736 // object's first non-static named data member is zero-initialized
9737 RecordDecl::field_iterator I = RD->field_begin();
9738 while (I != RD->field_end() && (*I)->isUnnamedBitfield())
9739 ++I;
9740 if (I == RD->field_end()) {
9741 Result = APValue((const FieldDecl*)nullptr);
9742 return true;
9743 }
9744
9745 LValue Subobject = This;
9746 if (!HandleLValueMember(Info, E, Subobject, *I))
9747 return false;
9748 Result = APValue(*I);
9749 ImplicitValueInitExpr VIE(I->getType());
9750 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
9751 }
9752
9753 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
9754 Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
9755 return false;
9756 }
9757
9758 return HandleClassZeroInitialization(Info, E, RD, This, Result);
9759}
9760
9761bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
9762 switch (E->getCastKind()) {
9763 default:
9764 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9765
9766 case CK_ConstructorConversion:
9767 return Visit(E->getSubExpr());
9768
9769 case CK_DerivedToBase:
9770 case CK_UncheckedDerivedToBase: {
9771 APValue DerivedObject;
9772 if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
9773 return false;
9774 if (!DerivedObject.isStruct())
9775 return Error(E->getSubExpr());
9776
9777 // Derived-to-base rvalue conversion: just slice off the derived part.
9778 APValue *Value = &DerivedObject;
9779 const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
9780 for (CastExpr::path_const_iterator PathI = E->path_begin(),
9781 PathE = E->path_end(); PathI != PathE; ++PathI) {
9782 assert(!(*PathI)->isVirtual() && "record rvalue with virtual base")((void)0);
9783 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
9784 Value = &Value->getStructBase(getBaseIndex(RD, Base));
9785 RD = Base;
9786 }
9787 Result = *Value;
9788 return true;
9789 }
9790 }
9791}
9792
9793bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
9794 if (E->isTransparent())
9795 return Visit(E->getInit(0));
9796
9797 const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
9798 if (RD->isInvalidDecl()) return false;
9799 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
9800 auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
9801
9802 EvalInfo::EvaluatingConstructorRAII EvalObj(
9803 Info,
9804 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries},
9805 CXXRD && CXXRD->getNumBases());
9806
9807 if (RD->isUnion()) {
9808 const FieldDecl *Field = E->getInitializedFieldInUnion();
9809 Result = APValue(Field);
9810 if (!Field)
9811 return true;
9812
9813 // If the initializer list for a union does not contain any elements, the
9814 // first element of the union is value-initialized.
9815 // FIXME: The element should be initialized from an initializer list.
9816 // Is this difference ever observable for initializer lists which
9817 // we don't build?
9818 ImplicitValueInitExpr VIE(Field->getType());
9819 const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
9820
9821 LValue Subobject = This;
9822 if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
9823 return false;
9824
9825 // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
9826 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
9827 isa<CXXDefaultInitExpr>(InitExpr));
9828
9829 if (EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr)) {
9830 if (Field->isBitField())
9831 return truncateBitfieldValue(Info, InitExpr, Result.getUnionValue(),
9832 Field);
9833 return true;
9834 }
9835
9836 return false;
9837 }
9838
9839 if (!Result.hasValue())
9840 Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0,
9841 std::distance(RD->field_begin(), RD->field_end()));
9842 unsigned ElementNo = 0;
9843 bool Success = true;
9844
9845 // Initialize base classes.
9846 if (CXXRD && CXXRD->getNumBases()) {
9847 for (const auto &Base : CXXRD->bases()) {
9848 assert(ElementNo < E->getNumInits() && "missing init for base class")((void)0);
9849 const Expr *Init = E->getInit(ElementNo);
9850
9851 LValue Subobject = This;
9852 if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
9853 return false;
9854
9855 APValue &FieldVal = Result.getStructBase(ElementNo);
9856 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) {
9857 if (!Info.noteFailure())
9858 return false;
9859 Success = false;
9860 }
9861 ++ElementNo;
9862 }
9863
9864 EvalObj.finishedConstructingBases();
9865 }
9866
9867 // Initialize members.
9868 for (const auto *Field : RD->fields()) {
9869 // Anonymous bit-fields are not considered members of the class for
9870 // purposes of aggregate initialization.
9871 if (Field->isUnnamedBitfield())
9872 continue;
9873
9874 LValue Subobject = This;
9875
9876 bool HaveInit = ElementNo < E->getNumInits();
9877
9878 // FIXME: Diagnostics here should point to the end of the initializer
9879 // list, not the start.
9880 if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
9881 Subobject, Field, &Layout))
9882 return false;
9883
9884 // Perform an implicit value-initialization for members beyond the end of
9885 // the initializer list.
9886 ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
9887 const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
9888
9889 // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
9890 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
9891 isa<CXXDefaultInitExpr>(Init));
9892
9893 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
9894 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
9895 (Field->isBitField() && !truncateBitfieldValue(Info, Init,
9896 FieldVal, Field))) {
9897 if (!Info.noteFailure())
9898 return false;
9899 Success = false;
9900 }
9901 }
9902
9903 EvalObj.finishedConstructingFields();
9904
9905 return Success;
9906}
9907
9908bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
9909 QualType T) {
9910 // Note that E's type is not necessarily the type of our class here; we might
9911 // be initializing an array element instead.
9912 const CXXConstructorDecl *FD = E->getConstructor();
9913 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
9914
9915 bool ZeroInit = E->requiresZeroInitialization();
9916 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
9917 // If we've already performed zero-initialization, we're already done.
9918 if (Result.hasValue())
9919 return true;
9920
9921 if (ZeroInit)
9922 return ZeroInitialization(E, T);
9923
9924 return getDefaultInitValue(T, Result);
9925 }
9926
9927 const FunctionDecl *Definition = nullptr;
9928 auto Body = FD->getBody(Definition);
9929
9930 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
9931 return false;
9932
9933 // Avoid materializing a temporary for an elidable copy/move constructor.
9934 if (E->isElidable() && !ZeroInit) {
9935 // FIXME: This only handles the simplest case, where the source object
9936 // is passed directly as the first argument to the constructor.
9937 // This should also handle stepping though implicit casts and
9938 // and conversion sequences which involve two steps, with a
9939 // conversion operator followed by a converting constructor.
9940 const Expr *SrcObj = E->getArg(0);
9941 assert(SrcObj->isTemporaryObject(Info.Ctx, FD->getParent()))((void)0);
9942 assert(Info.Ctx.hasSameUnqualifiedType(E->getType(), SrcObj->getType()))((void)0);
9943 if (const MaterializeTemporaryExpr *ME =
9944 dyn_cast<MaterializeTemporaryExpr>(SrcObj))
9945 return Visit(ME->getSubExpr());
9946 }
9947
9948 if (ZeroInit && !ZeroInitialization(E, T))
9949 return false;
9950
9951 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
9952 return HandleConstructorCall(E, This, Args,
9953 cast<CXXConstructorDecl>(Definition), Info,
9954 Result);
9955}
9956
9957bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
9958 const CXXInheritedCtorInitExpr *E) {
9959 if (!Info.CurrentCall) {
9960 assert(Info.checkingPotentialConstantExpression())((void)0);
9961 return false;
9962 }
9963
9964 const CXXConstructorDecl *FD = E->getConstructor();
9965 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
9966 return false;
9967
9968 const FunctionDecl *Definition = nullptr;
9969 auto Body = FD->getBody(Definition);
9970
9971 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
9972 return false;
9973
9974 return HandleConstructorCall(E, This, Info.CurrentCall->Arguments,
9975 cast<CXXConstructorDecl>(Definition), Info,
9976 Result);
9977}
9978
9979bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
9980 const CXXStdInitializerListExpr *E) {
9981 const ConstantArrayType *ArrayType =
9982 Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
9983
9984 LValue Array;
9985 if (!EvaluateLValue(E->getSubExpr(), Array, Info))
9986 return false;
9987
9988 // Get a pointer to the first element of the array.
9989 Array.addArray(Info, E, ArrayType);
9990
9991 auto InvalidType = [&] {
9992 Info.FFDiag(E, diag::note_constexpr_unsupported_layout)
9993 << E->getType();
9994 return false;
9995 };
9996
9997 // FIXME: Perform the checks on the field types in SemaInit.
9998 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
9999 RecordDecl::field_iterator Field = Record->field_begin();
10000 if (Field == Record->field_end())
10001 return InvalidType();
10002
10003 // Start pointer.
10004 if (!Field->getType()->isPointerType() ||
10005 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
10006 ArrayType->getElementType()))
10007 return InvalidType();
10008
10009 // FIXME: What if the initializer_list type has base classes, etc?
10010 Result = APValue(APValue::UninitStruct(), 0, 2);
10011 Array.moveInto(Result.getStructField(0));
10012
10013 if (++Field == Record->field_end())
10014 return InvalidType();
10015
10016 if (Field->getType()->isPointerType() &&
10017 Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
10018 ArrayType->getElementType())) {
10019 // End pointer.
10020 if (!HandleLValueArrayAdjustment(Info, E, Array,
10021 ArrayType->getElementType(),
10022 ArrayType->getSize().getZExtValue()))
10023 return false;
10024 Array.moveInto(Result.getStructField(1));
10025 } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
10026 // Length.
10027 Result.getStructField(1) = APValue(APSInt(ArrayType->getSize()));
10028 else
10029 return InvalidType();
10030
10031 if (++Field != Record->field_end())
10032 return InvalidType();
10033
10034 return true;
10035}
10036
10037bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
10038 const CXXRecordDecl *ClosureClass = E->getLambdaClass();
10039 if (ClosureClass->isInvalidDecl())
10040 return false;
10041
10042 const size_t NumFields =
10043 std::distance(ClosureClass->field_begin(), ClosureClass->field_end());
10044
10045 assert(NumFields == (size_t)std::distance(E->capture_init_begin(),((void)0)
10046 E->capture_init_end()) &&((void)0)
10047 "The number of lambda capture initializers should equal the number of "((void)0)
10048 "fields within the closure type")((void)0);
10049
10050 Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
10051 // Iterate through all the lambda's closure object's fields and initialize
10052 // them.
10053 auto *CaptureInitIt = E->capture_init_begin();
10054 const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
10055 bool Success = true;
10056 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(ClosureClass);
10057 for (const auto *Field : ClosureClass->fields()) {
10058 assert(CaptureInitIt != E->capture_init_end())((void)0);
10059 // Get the initializer for this field
10060 Expr *const CurFieldInit = *CaptureInitIt++;
10061
10062 // If there is no initializer, either this is a VLA or an error has
10063 // occurred.
10064 if (!CurFieldInit)
10065 return Error(E);
10066
10067 LValue Subobject = This;
10068
10069 if (!HandleLValueMember(Info, E, Subobject, Field, &Layout))
10070 return false;
10071
10072 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
10073 if (!EvaluateInPlace(FieldVal, Info, Subobject, CurFieldInit)) {
10074 if (!Info.keepEvaluatingAfterFailure())
10075 return false;
10076 Success = false;
10077 }
10078 ++CaptureIt;
10079 }
10080 return Success;
10081}
10082
10083static bool EvaluateRecord(const Expr *E, const LValue &This,
10084 APValue &Result, EvalInfo &Info) {
10085 assert(!E->isValueDependent())((void)0);
10086 assert(E->isPRValue() && E->getType()->isRecordType() &&((void)0)
10087 "can't evaluate expression as a record rvalue")((void)0);
10088 return RecordExprEvaluator(Info, This, Result).Visit(E);
10089}
10090
10091//===----------------------------------------------------------------------===//
10092// Temporary Evaluation
10093//
10094// Temporaries are represented in the AST as rvalues, but generally behave like
10095// lvalues. The full-object of which the temporary is a subobject is implicitly
10096// materialized so that a reference can bind to it.
10097//===----------------------------------------------------------------------===//
10098namespace {
10099class TemporaryExprEvaluator
10100 : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
10101public:
10102 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
10103 LValueExprEvaluatorBaseTy(Info, Result, false) {}
10104
10105 /// Visit an expression which constructs the value of this temporary.
10106 bool VisitConstructExpr(const Expr *E) {
10107 APValue &Value = Info.CurrentCall->createTemporary(
10108 E, E->getType(), ScopeKind::FullExpression, Result);
10109 return EvaluateInPlace(Value, Info, Result, E);
10110 }
10111
10112 bool VisitCastExpr(const CastExpr *E) {
10113 switch (E->getCastKind()) {
10114 default:
10115 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
10116
10117 case CK_ConstructorConversion:
10118 return VisitConstructExpr(E->getSubExpr());
10119 }
10120 }
10121 bool VisitInitListExpr(const InitListExpr *E) {
10122 return VisitConstructExpr(E);
10123 }
10124 bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
10125 return VisitConstructExpr(E);
10126 }
10127 bool VisitCallExpr(const CallExpr *E) {
10128 return VisitConstructExpr(E);
10129 }
10130 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
10131 return VisitConstructExpr(E);
10132 }
10133 bool VisitLambdaExpr(const LambdaExpr *E) {
10134 return VisitConstructExpr(E);
10135 }
10136};
10137} // end anonymous namespace
10138
10139/// Evaluate an expression of record type as a temporary.
10140static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
10141 assert(!E->isValueDependent())((void)0);
10142 assert(E->isPRValue() && E->getType()->isRecordType())((void)0);
10143 return TemporaryExprEvaluator(Info, Result).Visit(E);
10144}
10145
10146//===----------------------------------------------------------------------===//
10147// Vector Evaluation
10148//===----------------------------------------------------------------------===//
10149
10150namespace {
10151 class VectorExprEvaluator
10152 : public ExprEvaluatorBase<VectorExprEvaluator> {
10153 APValue &Result;
10154 public:
10155
10156 VectorExprEvaluator(EvalInfo &info, APValue &Result)
10157 : ExprEvaluatorBaseTy(info), Result(Result) {}
10158
10159 bool Success(ArrayRef<APValue> V, const Expr *E) {
10160 assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements())((void)0);
10161 // FIXME: remove this APValue copy.
10162 Result = APValue(V.data(), V.size());
10163 return true;
10164 }
10165 bool Success(const APValue &V, const Expr *E) {
10166 assert(V.isVector())((void)0);
10167 Result = V;
10168 return true;
10169 }
10170 bool ZeroInitialization(const Expr *E);
10171
10172 bool VisitUnaryReal(const UnaryOperator *E)
10173 { return Visit(E->getSubExpr()); }
10174 bool VisitCastExpr(const CastExpr* E);
10175 bool VisitInitListExpr(const InitListExpr *E);
10176 bool VisitUnaryImag(const UnaryOperator *E);
10177 bool VisitBinaryOperator(const BinaryOperator *E);
10178 // FIXME: Missing: unary -, unary ~, conditional operator (for GNU
10179 // conditional select), shufflevector, ExtVectorElementExpr
10180 };
10181} // end anonymous namespace
10182
10183static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
10184 assert(E->isPRValue() && E->getType()->isVectorType() &&((void)0)
10185 "not a vector prvalue")((void)0);
10186 return VectorExprEvaluator(Info, Result).Visit(E);
10187}
10188
10189bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
10190 const VectorType *VTy = E->getType()->castAs<VectorType>();
10191 unsigned NElts = VTy->getNumElements();
10192
10193 const Expr *SE = E->getSubExpr();
10194 QualType SETy = SE->getType();
10195
10196 switch (E->getCastKind()) {
10197 case CK_VectorSplat: {
10198 APValue Val = APValue();
10199 if (SETy->isIntegerType()) {
10200 APSInt IntResult;
10201 if (!EvaluateInteger(SE, IntResult, Info))
10202 return false;
10203 Val = APValue(std::move(IntResult));
10204 } else if (SETy->isRealFloatingType()) {
10205 APFloat FloatResult(0.0);
10206 if (!EvaluateFloat(SE, FloatResult, Info))
10207 return false;
10208 Val = APValue(std::move(FloatResult));
10209 } else {
10210 return Error(E);
10211 }
10212
10213 // Splat and create vector APValue.
10214 SmallVector<APValue, 4> Elts(NElts, Val);
10215 return Success(Elts, E);
10216 }
10217 case CK_BitCast: {
10218 // Evaluate the operand into an APInt we can extract from.
10219 llvm::APInt SValInt;
10220 if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
10221 return false;
10222 // Extract the elements
10223 QualType EltTy = VTy->getElementType();
10224 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
10225 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
10226 SmallVector<APValue, 4> Elts;
10227 if (EltTy->isRealFloatingType()) {
10228 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
10229 unsigned FloatEltSize = EltSize;
10230 if (&Sem == &APFloat::x87DoubleExtended())
10231 FloatEltSize = 80;
10232 for (unsigned i = 0; i < NElts; i++) {
10233 llvm::APInt Elt;
10234 if (BigEndian)
10235 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
10236 else
10237 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
10238 Elts.push_back(APValue(APFloat(Sem, Elt)));
10239 }
10240 } else if (EltTy->isIntegerType()) {
10241 for (unsigned i = 0; i < NElts; i++) {
10242 llvm::APInt Elt;
10243 if (BigEndian)
10244 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
10245 else
10246 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
10247 Elts.push_back(APValue(APSInt(Elt, !EltTy->isSignedIntegerType())));
10248 }
10249 } else {
10250 return Error(E);
10251 }
10252 return Success(Elts, E);
10253 }
10254 default:
10255 return ExprEvaluatorBaseTy::VisitCastExpr(E);
10256 }
10257}
10258
10259bool
10260VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
10261 const VectorType *VT = E->getType()->castAs<VectorType>();
10262 unsigned NumInits = E->getNumInits();
10263 unsigned NumElements = VT->getNumElements();
10264
10265 QualType EltTy = VT->getElementType();
10266 SmallVector<APValue, 4> Elements;
10267
10268 // The number of initializers can be less than the number of
10269 // vector elements. For OpenCL, this can be due to nested vector
10270 // initialization. For GCC compatibility, missing trailing elements
10271 // should be initialized with zeroes.
10272 unsigned CountInits = 0, CountElts = 0;
10273 while (CountElts < NumElements) {
10274 // Handle nested vector initialization.
10275 if (CountInits < NumInits
10276 && E->getInit(CountInits)->getType()->isVectorType()) {
10277 APValue v;
10278 if (!EvaluateVector(E->getInit(CountInits), v, Info))
10279 return Error(E);
10280 unsigned vlen = v.getVectorLength();
10281 for (unsigned j = 0; j < vlen; j++)
10282 Elements.push_back(v.getVectorElt(j));
10283 CountElts += vlen;
10284 } else if (EltTy->isIntegerType()) {
10285 llvm::APSInt sInt(32);
10286 if (CountInits < NumInits) {
10287 if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
10288 return false;
10289 } else // trailing integer zero.
10290 sInt = Info.Ctx.MakeIntValue(0, EltTy);
10291 Elements.push_back(APValue(sInt));
10292 CountElts++;
10293 } else {
10294 llvm::APFloat f(0.0);
10295 if (CountInits < NumInits) {
10296 if (!EvaluateFloat(E->getInit(CountInits), f, Info))
10297 return false;
10298 } else // trailing float zero.
10299 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
10300 Elements.push_back(APValue(f));
10301 CountElts++;
10302 }
10303 CountInits++;
10304 }
10305 return Success(Elements, E);
10306}
10307
10308bool
10309VectorExprEvaluator::ZeroInitialization(const Expr *E) {
10310 const auto *VT = E->getType()->castAs<VectorType>();
10311 QualType EltTy = VT->getElementType();
10312 APValue ZeroElement;
10313 if (EltTy->isIntegerType())
10314 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
10315 else
10316 ZeroElement =
10317 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
10318
10319 SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement);
10320 return Success(Elements, E);
10321}
10322
10323bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
10324 VisitIgnoredValue(E->getSubExpr());
10325 return ZeroInitialization(E);
10326}
10327
10328bool VectorExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
10329 BinaryOperatorKind Op = E->getOpcode();
10330 assert(Op != BO_PtrMemD && Op != BO_PtrMemI && Op != BO_Cmp &&((void)0)
10331 "Operation not supported on vector types")((void)0);
10332
10333 if (Op == BO_Comma)
10334 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
10335
10336 Expr *LHS = E->getLHS();
10337 Expr *RHS = E->getRHS();
10338
10339 assert(LHS->getType()->isVectorType() && RHS->getType()->isVectorType() &&((void)0)
10340 "Must both be vector types")((void)0);
10341 // Checking JUST the types are the same would be fine, except shifts don't
10342 // need to have their types be the same (since you always shift by an int).
10343 assert(LHS->getType()->castAs<VectorType>()->getNumElements() ==((void)0)
10344 E->getType()->castAs<VectorType>()->getNumElements() &&((void)0)
10345 RHS->getType()->castAs<VectorType>()->getNumElements() ==((void)0)
10346 E->getType()->castAs<VectorType>()->getNumElements() &&((void)0)
10347 "All operands must be the same size.")((void)0);
10348
10349 APValue LHSValue;
10350 APValue RHSValue;
10351 bool LHSOK = Evaluate(LHSValue, Info, LHS);
10352 if (!LHSOK && !Info.noteFailure())
10353 return false;
10354 if (!Evaluate(RHSValue, Info, RHS) || !LHSOK)
10355 return false;
10356
10357 if (!handleVectorVectorBinOp(Info, E, Op, LHSValue, RHSValue))
10358 return false;
10359
10360 return Success(LHSValue, E);
10361}
10362
10363//===----------------------------------------------------------------------===//
10364// Array Evaluation
10365//===----------------------------------------------------------------------===//
10366
10367namespace {
10368 class ArrayExprEvaluator
10369 : public ExprEvaluatorBase<ArrayExprEvaluator> {
10370 const LValue &This;
10371 APValue &Result;
10372 public:
10373
10374 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
10375 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
10376
10377 bool Success(const APValue &V, const Expr *E) {
10378 assert(V.isArray() && "expected array")((void)0);
10379 Result = V;
10380 return true;
10381 }
10382
10383 bool ZeroInitialization(const Expr *E) {
10384 const ConstantArrayType *CAT =
10385 Info.Ctx.getAsConstantArrayType(E->getType());
10386 if (!CAT) {
10387 if (E->getType()->isIncompleteArrayType()) {
10388 // We can be asked to zero-initialize a flexible array member; this
10389 // is represented as an ImplicitValueInitExpr of incomplete array
10390 // type. In this case, the array has zero elements.
10391 Result = APValue(APValue::UninitArray(), 0, 0);
10392 return true;
10393 }
10394 // FIXME: We could handle VLAs here.
10395 return Error(E);
10396 }
10397
10398 Result = APValue(APValue::UninitArray(), 0,
10399 CAT->getSize().getZExtValue());
10400 if (!Result.hasArrayFiller())
10401 return true;
10402
10403 // Zero-initialize all elements.
10404 LValue Subobject = This;
10405 Subobject.addArray(Info, E, CAT);
10406 ImplicitValueInitExpr VIE(CAT->getElementType());
10407 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
10408 }
10409
10410 bool VisitCallExpr(const CallExpr *E) {
10411 return handleCallExpr(E, Result, &This);
10412 }
10413 bool VisitInitListExpr(const InitListExpr *E,
10414 QualType AllocType = QualType());
10415 bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
10416 bool VisitCXXConstructExpr(const CXXConstructExpr *E);
10417 bool VisitCXXConstructExpr(const CXXConstructExpr *E,
10418 const LValue &Subobject,
10419 APValue *Value, QualType Type);
10420 bool VisitStringLiteral(const StringLiteral *E,
10421 QualType AllocType = QualType()) {
10422 expandStringLiteral(Info, E, Result, AllocType);
10423 return true;
10424 }
10425 };
10426} // end anonymous namespace
10427
10428static bool EvaluateArray(const Expr *E, const LValue &This,
10429 APValue &Result, EvalInfo &Info) {
10430 assert(!E->isValueDependent())((void)0);
10431 assert(E->isPRValue() && E->getType()->isArrayType() &&((void)0)
10432 "not an array prvalue")((void)0);
10433 return ArrayExprEvaluator(Info, This, Result).Visit(E);
10434}
10435
10436static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
10437 APValue &Result, const InitListExpr *ILE,
10438 QualType AllocType) {
10439 assert(!ILE->isValueDependent())((void)0);
10440 assert(ILE->isPRValue() && ILE->getType()->isArrayType() &&((void)0)
10441 "not an array prvalue")((void)0);
10442 return ArrayExprEvaluator(Info, This, Result)
10443 .VisitInitListExpr(ILE, AllocType);
10444}
10445
10446static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
10447 APValue &Result,
10448 const CXXConstructExpr *CCE,
10449 QualType AllocType) {
10450 assert(!CCE->isValueDependent())((void)0);
10451 assert(CCE->isPRValue() && CCE->getType()->isArrayType() &&((void)0)
10452 "not an array prvalue")((void)0);
10453 return ArrayExprEvaluator(Info, This, Result)
10454 .VisitCXXConstructExpr(CCE, This, &Result, AllocType);
10455}
10456
10457// Return true iff the given array filler may depend on the element index.
10458static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
10459 // For now, just allow non-class value-initialization and initialization
10460 // lists comprised of them.
10461 if (isa<ImplicitValueInitExpr>(FillerExpr))
10462 return false;
10463 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
10464 for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
10465 if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
10466 return true;
10467 }
10468 return false;
10469 }
10470 return true;
10471}
10472
10473bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E,
10474 QualType AllocType) {
10475 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
10476 AllocType.isNull() ? E->getType() : AllocType);
10477 if (!CAT)
10478 return Error(E);
10479
10480 // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...]
10481 // an appropriately-typed string literal enclosed in braces.
10482 if (E->isStringLiteralInit()) {
10483 auto *SL = dyn_cast<StringLiteral>(E->getInit(0)->IgnoreParens());
10484 // FIXME: Support ObjCEncodeExpr here once we support it in
10485 // ArrayExprEvaluator generally.
10486 if (!SL)
10487 return Error(E);
10488 return VisitStringLiteral(SL, AllocType);
10489 }
10490
10491 bool Success = true;
10492
10493 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&((void)0)
10494 "zero-initialized array shouldn't have any initialized elts")((void)0);
10495 APValue Filler;
10496 if (Result.isArray() && Result.hasArrayFiller())
10497 Filler = Result.getArrayFiller();
10498
10499 unsigned NumEltsToInit = E->getNumInits();
10500 unsigned NumElts = CAT->getSize().getZExtValue();
10501 const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
10502
10503 // If the initializer might depend on the array index, run it for each
10504 // array element.
10505 if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr))
10506 NumEltsToInit = NumElts;
10507
10508 LLVM_DEBUG(llvm::dbgs() << "The number of elements to initialize: "do { } while (false)
10509 << NumEltsToInit << ".\n")do { } while (false);
10510
10511 Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts);
10512
10513 // If the array was previously zero-initialized, preserve the
10514 // zero-initialized values.
10515 if (Filler.hasValue()) {
10516 for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
10517 Result.getArrayInitializedElt(I) = Filler;
10518 if (Result.hasArrayFiller())
10519 Result.getArrayFiller() = Filler;
10520 }
10521
10522 LValue Subobject = This;
10523 Subobject.addArray(Info, E, CAT);
10524 for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
10525 const Expr *Init =
10526 Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
10527 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
10528 Info, Subobject, Init) ||
10529 !HandleLValueArrayAdjustment(Info, Init, Subobject,
10530 CAT->getElementType(), 1)) {
10531 if (!Info.noteFailure())
10532 return false;
10533 Success = false;
10534 }
10535 }
10536
10537 if (!Result.hasArrayFiller())
10538 return Success;
10539
10540 // If we get here, we have a trivial filler, which we can just evaluate
10541 // once and splat over the rest of the array elements.
10542 assert(FillerExpr && "no array filler for incomplete init list")((void)0);
10543 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
10544 FillerExpr) && Success;
10545}
10546
10547bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
10548 LValue CommonLV;
10549 if (E->getCommonExpr() &&
10550 !Evaluate(Info.CurrentCall->createTemporary(
10551 E->getCommonExpr(),
10552 getStorageType(Info.Ctx, E->getCommonExpr()),
10553 ScopeKind::FullExpression, CommonLV),
10554 Info, E->getCommonExpr()->getSourceExpr()))
10555 return false;
10556
10557 auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe());
10558
10559 uint64_t Elements = CAT->getSize().getZExtValue();
10560 Result = APValue(APValue::UninitArray(), Elements, Elements);
10561
10562 LValue Subobject = This;
10563 Subobject.addArray(Info, E, CAT);
10564
10565 bool Success = true;
10566 for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
10567 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
10568 Info, Subobject, E->getSubExpr()) ||
10569 !HandleLValueArrayAdjustment(Info, E, Subobject,
10570 CAT->getElementType(), 1)) {
10571 if (!Info.noteFailure())
10572 return false;
10573 Success = false;
10574 }
10575 }
10576
10577 return Success;
10578}
10579
10580bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
10581 return VisitCXXConstructExpr(E, This, &Result, E->getType());
10582}
10583
10584bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
10585 const LValue &Subobject,
10586 APValue *Value,
10587 QualType Type) {
10588 bool HadZeroInit = Value->hasValue();
10589
10590 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
10591 unsigned N = CAT->getSize().getZExtValue();
10592
10593 // Preserve the array filler if we had prior zero-initialization.
10594 APValue Filler =
10595 HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
10596 : APValue();
10597
10598 *Value = APValue(APValue::UninitArray(), N, N);
10599
10600 if (HadZeroInit)
10601 for (unsigned I = 0; I != N; ++I)
10602 Value->getArrayInitializedElt(I) = Filler;
10603
10604 // Initialize the elements.
10605 LValue ArrayElt = Subobject;
10606 ArrayElt.addArray(Info, E, CAT);
10607 for (unsigned I = 0; I != N; ++I)
10608 if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
10609 CAT->getElementType()) ||
10610 !HandleLValueArrayAdjustment(Info, E, ArrayElt,
10611 CAT->getElementType(), 1))
10612 return false;
10613
10614 return true;
10615 }
10616
10617 if (!Type->isRecordType())
10618 return Error(E);
10619
10620 return RecordExprEvaluator(Info, Subobject, *Value)
10621 .VisitCXXConstructExpr(E, Type);
10622}
10623
10624//===----------------------------------------------------------------------===//
10625// Integer Evaluation
10626//
10627// As a GNU extension, we support casting pointers to sufficiently-wide integer
10628// types and back in constant folding. Integer values are thus represented
10629// either as an integer-valued APValue, or as an lvalue-valued APValue.
10630//===----------------------------------------------------------------------===//
10631
10632namespace {
10633class IntExprEvaluator
10634 : public ExprEvaluatorBase<IntExprEvaluator> {
10635 APValue &Result;
10636public:
10637 IntExprEvaluator(EvalInfo &info, APValue &result)
10638 : ExprEvaluatorBaseTy(info), Result(result) {}
10639
10640 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
10641 assert(E->getType()->isIntegralOrEnumerationType() &&((void)0)
10642 "Invalid evaluation result.")((void)0);
10643 assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&((void)0)
10644 "Invalid evaluation result.")((void)0);
10645 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&((void)0)
10646 "Invalid evaluation result.")((void)0);
10647 Result = APValue(SI);
10648 return true;
10649 }
10650 bool Success(const llvm::APSInt &SI, const Expr *E) {
10651 return Success(SI, E, Result);
10652 }
10653
10654 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
10655 assert(E->getType()->isIntegralOrEnumerationType() &&((void)0)
10656 "Invalid evaluation result.")((void)0);
10657 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&((void)0)
10658 "Invalid evaluation result.")((void)0);
10659 Result = APValue(APSInt(I));
10660 Result.getInt().setIsUnsigned(
10661 E->getType()->isUnsignedIntegerOrEnumerationType());
10662 return true;
10663 }
10664 bool Success(const llvm::APInt &I, const Expr *E) {
10665 return Success(I, E, Result);
10666 }
10667
10668 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
10669 assert(E->getType()->isIntegralOrEnumerationType() &&((void)0)
10670 "Invalid evaluation result.")((void)0);
10671 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
10672 return true;
10673 }
10674 bool Success(uint64_t Value, const Expr *E) {
10675 return Success(Value, E, Result);
10676 }
10677
10678 bool Success(CharUnits Size, const Expr *E) {
10679 return Success(Size.getQuantity(), E);
10680 }
10681
10682 bool Success(const APValue &V, const Expr *E) {
10683 if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) {
10684 Result = V;
10685 return true;
10686 }
10687 return Success(V.getInt(), E);
10688 }
10689
10690 bool ZeroInitialization(const Expr *E) { return Success(0, E); }
10691
10692 //===--------------------------------------------------------------------===//
10693 // Visitor Methods
10694 //===--------------------------------------------------------------------===//
10695
10696 bool VisitIntegerLiteral(const IntegerLiteral *E) {
10697 return Success(E->getValue(), E);
10698 }
10699 bool VisitCharacterLiteral(const CharacterLiteral *E) {
10700 return Success(E->getValue(), E);
10701 }
10702
10703 bool CheckReferencedDecl(const Expr *E, const Decl *D);
10704 bool VisitDeclRefExpr(const DeclRefExpr *E) {
10705 if (CheckReferencedDecl(E, E->getDecl()))
10706 return true;
10707
10708 return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
10709 }
10710 bool VisitMemberExpr(const MemberExpr *E) {
10711 if (CheckReferencedDecl(E, E->getMemberDecl())) {
10712 VisitIgnoredBaseExpression(E->getBase());
10713 return true;
10714 }
10715
10716 return ExprEvaluatorBaseTy::VisitMemberExpr(E);
10717 }
10718
10719 bool VisitCallExpr(const CallExpr *E);
10720 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
10721 bool VisitBinaryOperator(const BinaryOperator *E);
10722 bool VisitOffsetOfExpr(const OffsetOfExpr *E);
10723 bool VisitUnaryOperator(const UnaryOperator *E);
10724
10725 bool VisitCastExpr(const CastExpr* E);
10726 bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
10727
10728 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
10729 return Success(E->getValue(), E);
10730 }
10731
10732 bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
10733 return Success(E->getValue(), E);
10734 }
10735
10736 bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
10737 if (Info.ArrayInitIndex == uint64_t(-1)) {
10738 // We were asked to evaluate this subexpression independent of the
10739 // enclosing ArrayInitLoopExpr. We can't do that.
10740 Info.FFDiag(E);
10741 return false;
10742 }
10743 return Success(Info.ArrayInitIndex, E);
10744 }
10745
10746 // Note, GNU defines __null as an integer, not a pointer.
10747 bool VisitGNUNullExpr(const GNUNullExpr *E) {
10748 return ZeroInitialization(E);
10749 }
10750
10751 bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
10752 return Success(E->getValue(), E);
10753 }
10754
10755 bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
10756 return Success(E->getValue(), E);
10757 }
10758
10759 bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
10760 return Success(E->getValue(), E);
10761 }
10762
10763 bool VisitUnaryReal(const UnaryOperator *E);
10764 bool VisitUnaryImag(const UnaryOperator *E);
10765
10766 bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
10767 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
10768 bool VisitSourceLocExpr(const SourceLocExpr *E);
10769 bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
10770 bool VisitRequiresExpr(const RequiresExpr *E);
10771 // FIXME: Missing: array subscript of vector, member of vector
10772};
10773
10774class FixedPointExprEvaluator
10775 : public ExprEvaluatorBase<FixedPointExprEvaluator> {
10776 APValue &Result;
10777
10778 public:
10779 FixedPointExprEvaluator(EvalInfo &info, APValue &result)
10780 : ExprEvaluatorBaseTy(info), Result(result) {}
10781
10782 bool Success(const llvm::APInt &I, const Expr *E) {
10783 return Success(
10784 APFixedPoint(I, Info.Ctx.getFixedPointSemantics(E->getType())), E);
10785 }
10786
10787 bool Success(uint64_t Value, const Expr *E) {
10788 return Success(
10789 APFixedPoint(Value, Info.Ctx.getFixedPointSemantics(E->getType())), E);
10790 }
10791
10792 bool Success(const APValue &V, const Expr *E) {
10793 return Success(V.getFixedPoint(), E);
10794 }
10795
10796 bool Success(const APFixedPoint &V, const Expr *E) {
10797 assert(E->getType()->isFixedPointType() && "Invalid evaluation result.")((void)0);
10798 assert(V.getWidth() == Info.Ctx.getIntWidth(E->getType()) &&((void)0)
10799 "Invalid evaluation result.")((void)0);
10800 Result = APValue(V);
10801 return true;
10802 }
10803
10804 //===--------------------------------------------------------------------===//
10805 // Visitor Methods
10806 //===--------------------------------------------------------------------===//
10807
10808 bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
10809 return Success(E->getValue(), E);
10810 }
10811
10812 bool VisitCastExpr(const CastExpr *E);
10813 bool VisitUnaryOperator(const UnaryOperator *E);
10814 bool VisitBinaryOperator(const BinaryOperator *E);
10815};
10816} // end anonymous namespace
10817
10818/// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and
10819/// produce either the integer value or a pointer.
10820///
10821/// GCC has a heinous extension which folds casts between pointer types and
10822/// pointer-sized integral types. We support this by allowing the evaluation of
10823/// an integer rvalue to produce a pointer (represented as an lvalue) instead.
10824/// Some simple arithmetic on such values is supported (they are treated much
10825/// like char*).
10826static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
10827 EvalInfo &Info) {
10828 assert(!E->isValueDependent())((void)0);
10829 assert(E->isPRValue() && E->getType()->isIntegralOrEnumerationType())((void)0);
10830 return IntExprEvaluator(Info, Result).Visit(E);
10831}
10832
10833static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
10834 assert(!E->isValueDependent())((void)0);
10835 APValue Val;
10836 if (!EvaluateIntegerOrLValue(E, Val, Info))
10837 return false;
10838 if (!Val.isInt()) {
10839 // FIXME: It would be better to produce the diagnostic for casting
10840 // a pointer to an integer.
10841 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
10842 return false;
10843 }
10844 Result = Val.getInt();
10845 return true;
10846}
10847
10848bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) {
10849 APValue Evaluated = E->EvaluateInContext(
10850 Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
10851 return Success(Evaluated, E);
10852}
10853
10854static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
10855 EvalInfo &Info) {
10856 assert(!E->isValueDependent())((void)0);
10857 if (E->getType()->isFixedPointType()) {
10858 APValue Val;
10859 if (!FixedPointExprEvaluator(Info, Val).Visit(E))
10860 return false;
10861 if (!Val.isFixedPoint())
10862 return false;
10863
10864 Result = Val.getFixedPoint();
10865 return true;
10866 }
10867 return false;
10868}
10869
10870static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
10871 EvalInfo &Info) {
10872 assert(!E->isValueDependent())((void)0);
10873 if (E->getType()->isIntegerType()) {
10874 auto FXSema = Info.Ctx.getFixedPointSemantics(E->getType());
10875 APSInt Val;
10876 if (!EvaluateInteger(E, Val, Info))
10877 return false;
10878 Result = APFixedPoint(Val, FXSema);
10879 return true;
10880 } else if (E->getType()->isFixedPointType()) {
10881 return EvaluateFixedPoint(E, Result, Info);
10882 }
10883 return false;
10884}
10885
10886/// Check whether the given declaration can be directly converted to an integral
10887/// rvalue. If not, no diagnostic is produced; there are other things we can
10888/// try.
10889bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
10890 // Enums are integer constant exprs.
10891 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
10892 // Check for signedness/width mismatches between E type and ECD value.
10893 bool SameSign = (ECD->getInitVal().isSigned()
10894 == E->getType()->isSignedIntegerOrEnumerationType());
10895 bool SameWidth = (ECD->getInitVal().getBitWidth()
10896 == Info.Ctx.getIntWidth(E->getType()));
10897 if (SameSign && SameWidth)
10898 return Success(ECD->getInitVal(), E);
10899 else {
10900 // Get rid of mismatch (otherwise Success assertions will fail)
10901 // by computing a new value matching the type of E.
10902 llvm::APSInt Val = ECD->getInitVal();
10903 if (!SameSign)
10904 Val.setIsSigned(!ECD->getInitVal().isSigned());
10905 if (!SameWidth)
10906 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
10907 return Success(Val, E);
10908 }
10909 }
10910 return false;
10911}
10912
10913/// Values returned by __builtin_classify_type, chosen to match the values
10914/// produced by GCC's builtin.
10915enum class GCCTypeClass {
10916 None = -1,
10917 Void = 0,
10918 Integer = 1,
10919 // GCC reserves 2 for character types, but instead classifies them as
10920 // integers.
10921 Enum = 3,
10922 Bool = 4,
10923 Pointer = 5,
10924 // GCC reserves 6 for references, but appears to never use it (because
10925 // expressions never have reference type, presumably).
10926 PointerToDataMember = 7,
10927 RealFloat = 8,
10928 Complex = 9,
10929 // GCC reserves 10 for functions, but does not use it since GCC version 6 due
10930 // to decay to pointer. (Prior to version 6 it was only used in C++ mode).
10931 // GCC claims to reserve 11 for pointers to member functions, but *actually*
10932 // uses 12 for that purpose, same as for a class or struct. Maybe it
10933 // internally implements a pointer to member as a struct? Who knows.
10934 PointerToMemberFunction = 12, // Not a bug, see above.
10935 ClassOrStruct = 12,
10936 Union = 13,
10937 // GCC reserves 14 for arrays, but does not use it since GCC version 6 due to
10938 // decay to pointer. (Prior to version 6 it was only used in C++ mode).
10939 // GCC reserves 15 for strings, but actually uses 5 (pointer) for string
10940 // literals.
10941};
10942
10943/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
10944/// as GCC.
10945static GCCTypeClass
10946EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts) {
10947 assert(!T->isDependentType() && "unexpected dependent type")((void)0);
10948
10949 QualType CanTy = T.getCanonicalType();
10950 const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
10951
10952 switch (CanTy->getTypeClass()) {
10953#define TYPE(ID, BASE)
10954#define DEPENDENT_TYPE(ID, BASE) case Type::ID:
10955#define NON_CANONICAL_TYPE(ID, BASE) case Type::ID:
10956#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID:
10957#include "clang/AST/TypeNodes.inc"
10958 case Type::Auto:
10959 case Type::DeducedTemplateSpecialization:
10960 llvm_unreachable("unexpected non-canonical or dependent type")__builtin_unreachable();
10961
10962 case Type::Builtin:
10963 switch (BT->getKind()) {
10964#define BUILTIN_TYPE(ID, SINGLETON_ID)
10965#define SIGNED_TYPE(ID, SINGLETON_ID) \
10966 case BuiltinType::ID: return GCCTypeClass::Integer;
10967#define FLOATING_TYPE(ID, SINGLETON_ID) \
10968 case BuiltinType::ID: return GCCTypeClass::RealFloat;
10969#define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \
10970 case BuiltinType::ID: break;
10971#include "clang/AST/BuiltinTypes.def"
10972 case BuiltinType::Void:
10973 return GCCTypeClass::Void;
10974
10975 case BuiltinType::Bool:
10976 return GCCTypeClass::Bool;
10977
10978 case BuiltinType::Char_U:
10979 case BuiltinType::UChar:
10980 case BuiltinType::WChar_U:
10981 case BuiltinType::Char8:
10982 case BuiltinType::Char16:
10983 case BuiltinType::Char32:
10984 case BuiltinType::UShort:
10985 case BuiltinType::UInt:
10986 case BuiltinType::ULong:
10987 case BuiltinType::ULongLong:
10988 case BuiltinType::UInt128:
10989 return GCCTypeClass::Integer;
10990
10991 case BuiltinType::UShortAccum:
10992 case BuiltinType::UAccum:
10993 case BuiltinType::ULongAccum:
10994 case BuiltinType::UShortFract:
10995 case BuiltinType::UFract:
10996 case BuiltinType::ULongFract:
10997 case BuiltinType::SatUShortAccum:
10998 case BuiltinType::SatUAccum:
10999 case BuiltinType::SatULongAccum:
11000 case BuiltinType::SatUShortFract:
11001 case BuiltinType::SatUFract:
11002 case BuiltinType::SatULongFract:
11003 return GCCTypeClass::None;
11004
11005 case BuiltinType::NullPtr:
11006
11007 case BuiltinType::ObjCId:
11008 case BuiltinType::ObjCClass:
11009 case BuiltinType::ObjCSel:
11010#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
11011 case BuiltinType::Id:
11012#include "clang/Basic/OpenCLImageTypes.def"
11013#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
11014 case BuiltinType::Id:
11015#include "clang/Basic/OpenCLExtensionTypes.def"
11016 case BuiltinType::OCLSampler:
11017 case BuiltinType::OCLEvent:
11018 case BuiltinType::OCLClkEvent:
11019 case BuiltinType::OCLQueue:
11020 case BuiltinType::OCLReserveID:
11021#define SVE_TYPE(Name, Id, SingletonId) \
11022 case BuiltinType::Id:
11023#include "clang/Basic/AArch64SVEACLETypes.def"
11024#define PPC_VECTOR_TYPE(Name, Id, Size) \
11025 case BuiltinType::Id:
11026#include "clang/Basic/PPCTypes.def"
11027#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
11028#include "clang/Basic/RISCVVTypes.def"
11029 return GCCTypeClass::None;
11030
11031 case BuiltinType::Dependent:
11032 llvm_unreachable("unexpected dependent type")__builtin_unreachable();
11033 };
11034 llvm_unreachable("unexpected placeholder type")__builtin_unreachable();
11035
11036 case Type::Enum:
11037 return LangOpts.CPlusPlus ? GCCTypeClass::Enum : GCCTypeClass::Integer;
11038
11039 case Type::Pointer:
11040 case Type::ConstantArray:
11041 case Type::VariableArray:
11042 case Type::IncompleteArray:
11043 case Type::FunctionNoProto:
11044 case Type::FunctionProto:
11045 return GCCTypeClass::Pointer;
11046
11047 case Type::MemberPointer:
11048 return CanTy->isMemberDataPointerType()
11049 ? GCCTypeClass::PointerToDataMember
11050 : GCCTypeClass::PointerToMemberFunction;
11051
11052 case Type::Complex:
11053 return GCCTypeClass::Complex;
11054
11055 case Type::Record:
11056 return CanTy->isUnionType() ? GCCTypeClass::Union
11057 : GCCTypeClass::ClassOrStruct;
11058
11059 case Type::Atomic:
11060 // GCC classifies _Atomic T the same as T.
11061 return EvaluateBuiltinClassifyType(
11062 CanTy->castAs<AtomicType>()->getValueType(), LangOpts);
11063
11064 case Type::BlockPointer:
11065 case Type::Vector:
11066 case Type::ExtVector:
11067 case Type::ConstantMatrix:
11068 case Type::ObjCObject:
11069 case Type::ObjCInterface:
11070 case Type::ObjCObjectPointer:
11071 case Type::Pipe:
11072 case Type::ExtInt:
11073 // GCC classifies vectors as None. We follow its lead and classify all
11074 // other types that don't fit into the regular classification the same way.
11075 return GCCTypeClass::None;
11076
11077 case Type::LValueReference:
11078 case Type::RValueReference:
11079 llvm_unreachable("invalid type for expression")__builtin_unreachable();
11080 }
11081
11082 llvm_unreachable("unexpected type class")__builtin_unreachable();
11083}
11084
11085/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
11086/// as GCC.
11087static GCCTypeClass
11088EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts) {
11089 // If no argument was supplied, default to None. This isn't
11090 // ideal, however it is what gcc does.
11091 if (E->getNumArgs() == 0)
11092 return GCCTypeClass::None;
11093
11094 // FIXME: Bizarrely, GCC treats a call with more than one argument as not
11095 // being an ICE, but still folds it to a constant using the type of the first
11096 // argument.
11097 return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts);
11098}
11099
11100/// EvaluateBuiltinConstantPForLValue - Determine the result of
11101/// __builtin_constant_p when applied to the given pointer.
11102///
11103/// A pointer is only "constant" if it is null (or a pointer cast to integer)
11104/// or it points to the first character of a string literal.
11105static bool EvaluateBuiltinConstantPForLValue(const APValue &LV) {
11106 APValue::LValueBase Base = LV.getLValueBase();
11107 if (Base.isNull()) {
11108 // A null base is acceptable.
11109 return true;
11110 } else if (const Expr *E = Base.dyn_cast<const Expr *>()) {
11111 if (!isa<StringLiteral>(E))
11112 return false;
11113 return LV.getLValueOffset().isZero();
11114 } else if (Base.is<TypeInfoLValue>()) {
11115 // Surprisingly, GCC considers __builtin_constant_p(&typeid(int)) to
11116 // evaluate to true.
11117 return true;
11118 } else {
11119 // Any other base is not constant enough for GCC.
11120 return false;
11121 }
11122}
11123
11124/// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
11125/// GCC as we can manage.
11126static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) {
11127 // This evaluation is not permitted to have side-effects, so evaluate it in
11128 // a speculative evaluation context.
11129 SpeculativeEvaluationRAII SpeculativeEval(Info);
11130
11131 // Constant-folding is always enabled for the operand of __builtin_constant_p
11132 // (even when the enclosing evaluation context otherwise requires a strict
11133 // language-specific constant expression).
11134 FoldConstant Fold(Info, true);
11135
11136 QualType ArgType = Arg->getType();
11137
11138 // __builtin_constant_p always has one operand. The rules which gcc follows
11139 // are not precisely documented, but are as follows:
11140 //
11141 // - If the operand is of integral, floating, complex or enumeration type,
11142 // and can be folded to a known value of that type, it returns 1.
11143 // - If the operand can be folded to a pointer to the first character
11144 // of a string literal (or such a pointer cast to an integral type)
11145 // or to a null pointer or an integer cast to a pointer, it returns 1.
11146 //
11147 // Otherwise, it returns 0.
11148 //
11149 // FIXME: GCC also intends to return 1 for literals of aggregate types, but
11150 // its support for this did not work prior to GCC 9 and is not yet well
11151 // understood.
11152 if (ArgType->isIntegralOrEnumerationType() || ArgType->isFloatingType() ||
11153 ArgType->isAnyComplexType() || ArgType->isPointerType() ||
11154 ArgType->isNullPtrType()) {
11155 APValue V;
11156 if (!::EvaluateAsRValue(Info, Arg, V) || Info.EvalStatus.HasSideEffects) {
11157 Fold.keepDiagnostics();
11158 return false;
11159 }
11160
11161 // For a pointer (possibly cast to integer), there are special rules.
11162 if (V.getKind() == APValue::LValue)
11163 return EvaluateBuiltinConstantPForLValue(V);
11164
11165 // Otherwise, any constant value is good enough.
11166 return V.hasValue();
11167 }
11168
11169 // Anything else isn't considered to be sufficiently constant.
11170 return false;
11171}
11172
11173/// Retrieves the "underlying object type" of the given expression,
11174/// as used by __builtin_object_size.
11175static QualType getObjectType(APValue::LValueBase B) {
11176 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
11177 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
11178 return VD->getType();
11179 } else if (const Expr *E = B.dyn_cast<const Expr*>()) {
11180 if (isa<CompoundLiteralExpr>(E))
11181 return E->getType();
11182 } else if (B.is<TypeInfoLValue>()) {
11183 return B.getTypeInfoType();
11184 } else if (B.is<DynamicAllocLValue>()) {
11185 return B.getDynamicAllocType();
11186 }
11187
11188 return QualType();
11189}
11190
11191/// A more selective version of E->IgnoreParenCasts for
11192/// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only
11193/// to change the type of E.
11194/// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
11195///
11196/// Always returns an RValue with a pointer representation.
11197static const Expr *ignorePointerCastsAndParens(const Expr *E) {
11198 assert(E->isPRValue() && E->getType()->hasPointerRepresentation())((void)0);
11199
11200 auto *NoParens = E->IgnoreParens();
11201 auto *Cast = dyn_cast<CastExpr>(NoParens);
11202 if (Cast == nullptr)
11203 return NoParens;
11204
11205 // We only conservatively allow a few kinds of casts, because this code is
11206 // inherently a simple solution that seeks to support the common case.
11207 auto CastKind = Cast->getCastKind();
11208 if (CastKind != CK_NoOp && CastKind != CK_BitCast &&
11209 CastKind != CK_AddressSpaceConversion)
11210 return NoParens;
11211
11212 auto *SubExpr = Cast->getSubExpr();
11213 if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isPRValue())
11214 return NoParens;
11215 return ignorePointerCastsAndParens(SubExpr);
11216}
11217
11218/// Checks to see if the given LValue's Designator is at the end of the LValue's
11219/// record layout. e.g.
11220/// struct { struct { int a, b; } fst, snd; } obj;
11221/// obj.fst // no
11222/// obj.snd // yes
11223/// obj.fst.a // no
11224/// obj.fst.b // no
11225/// obj.snd.a // no
11226/// obj.snd.b // yes
11227///
11228/// Please note: this function is specialized for how __builtin_object_size
11229/// views "objects".
11230///
11231/// If this encounters an invalid RecordDecl or otherwise cannot determine the
11232/// correct result, it will always return true.
11233static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
11234 assert(!LVal.Designator.Invalid)((void)0);
11235
11236 auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
11237 const RecordDecl *Parent = FD->getParent();
11238 Invalid = Parent->isInvalidDecl();
11239 if (Invalid || Parent->isUnion())
11240 return true;
11241 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent);
11242 return FD->getFieldIndex() + 1 == Layout.getFieldCount();
11243 };
11244
11245 auto &Base = LVal.getLValueBase();
11246 if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
11247 if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
11248 bool Invalid;
11249 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
11250 return Invalid;
11251 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
11252 for (auto *FD : IFD->chain()) {
11253 bool Invalid;
11254 if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
11255 return Invalid;
11256 }
11257 }
11258 }
11259
11260 unsigned I = 0;
11261 QualType BaseType = getType(Base);
11262 if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
11263 // If we don't know the array bound, conservatively assume we're looking at
11264 // the final array element.
11265 ++I;
11266 if (BaseType->isIncompleteArrayType())
11267 BaseType = Ctx.getAsArrayType(BaseType)->getElementType();
11268 else
11269 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
11270 }
11271
11272 for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
11273 const auto &Entry = LVal.Designator.Entries[I];
11274 if (BaseType->isArrayType()) {
11275 // Because __builtin_object_size treats arrays as objects, we can ignore
11276 // the index iff this is the last array in the Designator.
11277 if (I + 1 == E)
11278 return true;
11279 const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
11280 uint64_t Index = Entry.getAsArrayIndex();
11281 if (Index + 1 != CAT->getSize())
11282 return false;
11283 BaseType = CAT->getElementType();
11284 } else if (BaseType->isAnyComplexType()) {
11285 const auto *CT = BaseType->castAs<ComplexType>();
11286 uint64_t Index = Entry.getAsArrayIndex();
11287 if (Index != 1)
11288 return false;
11289 BaseType = CT->getElementType();
11290 } else if (auto *FD = getAsField(Entry)) {
11291 bool Invalid;
11292 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
11293 return Invalid;
11294 BaseType = FD->getType();
11295 } else {
11296 assert(getAsBaseClass(Entry) && "Expecting cast to a base class")((void)0);
11297 return false;
11298 }
11299 }
11300 return true;
11301}
11302
11303/// Tests to see if the LValue has a user-specified designator (that isn't
11304/// necessarily valid). Note that this always returns 'true' if the LValue has
11305/// an unsized array as its first designator entry, because there's currently no
11306/// way to tell if the user typed *foo or foo[0].
11307static bool refersToCompleteObject(const LValue &LVal) {
11308 if (LVal.Designator.Invalid)
11309 return false;
11310
11311 if (!LVal.Designator.Entries.empty())
11312 return LVal.Designator.isMostDerivedAnUnsizedArray();
11313
11314 if (!LVal.InvalidBase)
11315 return true;
11316
11317 // If `E` is a MemberExpr, then the first part of the designator is hiding in
11318 // the LValueBase.
11319 const auto *E = LVal.Base.dyn_cast<const Expr *>();
11320 return !E || !isa<MemberExpr>(E);
11321}
11322
11323/// Attempts to detect a user writing into a piece of memory that's impossible
11324/// to figure out the size of by just using types.
11325static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
11326 const SubobjectDesignator &Designator = LVal.Designator;
11327 // Notes:
11328 // - Users can only write off of the end when we have an invalid base. Invalid
11329 // bases imply we don't know where the memory came from.
11330 // - We used to be a bit more aggressive here; we'd only be conservative if
11331 // the array at the end was flexible, or if it had 0 or 1 elements. This
11332 // broke some common standard library extensions (PR30346), but was
11333 // otherwise seemingly fine. It may be useful to reintroduce this behavior
11334 // with some sort of list. OTOH, it seems that GCC is always
11335 // conservative with the last element in structs (if it's an array), so our
11336 // current behavior is more compatible than an explicit list approach would
11337 // be.
11338 return LVal.InvalidBase &&
11339 Designator.Entries.size() == Designator.MostDerivedPathLength &&
11340 Designator.MostDerivedIsArrayElement &&
11341 isDesignatorAtObjectEnd(Ctx, LVal);
11342}
11343
11344/// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
11345/// Fails if the conversion would cause loss of precision.
11346static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
11347 CharUnits &Result) {
11348 auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max();
11349 if (Int.ugt(CharUnitsMax))
11350 return false;
11351 Result = CharUnits::fromQuantity(Int.getZExtValue());
11352 return true;
11353}
11354
11355/// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will
11356/// determine how many bytes exist from the beginning of the object to either
11357/// the end of the current subobject, or the end of the object itself, depending
11358/// on what the LValue looks like + the value of Type.
11359///
11360/// If this returns false, the value of Result is undefined.
11361static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
11362 unsigned Type, const LValue &LVal,
11363 CharUnits &EndOffset) {
11364 bool DetermineForCompleteObject = refersToCompleteObject(LVal);
11365
11366 auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) {
11367 if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType())
11368 return false;
11369 return HandleSizeof(Info, ExprLoc, Ty, Result);
11370 };
11371
11372 // We want to evaluate the size of the entire object. This is a valid fallback
11373 // for when Type=1 and the designator is invalid, because we're asked for an
11374 // upper-bound.
11375 if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
11376 // Type=3 wants a lower bound, so we can't fall back to this.
11377 if (Type == 3 && !DetermineForCompleteObject)
11378 return false;
11379
11380 llvm::APInt APEndOffset;
11381 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
11382 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
11383 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
11384
11385 if (LVal.InvalidBase)
11386 return false;
11387
11388 QualType BaseTy = getObjectType(LVal.getLValueBase());
11389 return CheckedHandleSizeof(BaseTy, EndOffset);
11390 }
11391
11392 // We want to evaluate the size of a subobject.
11393 const SubobjectDesignator &Designator = LVal.Designator;
11394
11395 // The following is a moderately common idiom in C:
11396 //
11397 // struct Foo { int a; char c[1]; };
11398 // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar));
11399 // strcpy(&F->c[0], Bar);
11400 //
11401 // In order to not break too much legacy code, we need to support it.
11402 if (isUserWritingOffTheEnd(Info.Ctx, LVal)) {
11403 // If we can resolve this to an alloc_size call, we can hand that back,
11404 // because we know for certain how many bytes there are to write to.
11405 llvm::APInt APEndOffset;
11406 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
11407 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset))
11408 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset);
11409
11410 // If we cannot determine the size of the initial allocation, then we can't
11411 // given an accurate upper-bound. However, we are still able to give
11412 // conservative lower-bounds for Type=3.
11413 if (Type == 1)
11414 return false;
11415 }
11416
11417 CharUnits BytesPerElem;
11418 if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
11419 return false;
11420
11421 // According to the GCC documentation, we want the size of the subobject
11422 // denoted by the pointer. But that's not quite right -- what we actually
11423 // want is the size of the immediately-enclosing array, if there is one.
11424 int64_t ElemsRemaining;
11425 if (Designator.MostDerivedIsArrayElement &&
11426 Designator.Entries.size() == Designator.MostDerivedPathLength) {
11427 uint64_t ArraySize = Designator.getMostDerivedArraySize();
11428 uint64_t ArrayIndex = Designator.Entries.back().getAsArrayIndex();
11429 ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
11430 } else {
11431 ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
11432 }
11433
11434 EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
11435 return true;
11436}
11437
11438/// Tries to evaluate the __builtin_object_size for @p E. If successful,
11439/// returns true and stores the result in @p Size.
11440///
11441/// If @p WasError is non-null, this will report whether the failure to evaluate
11442/// is to be treated as an Error in IntExprEvaluator.
11443static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
11444 EvalInfo &Info, uint64_t &Size) {
11445 // Determine the denoted object.
11446 LValue LVal;
11447 {
11448 // The operand of __builtin_object_size is never evaluated for side-effects.
11449 // If there are any, but we can determine the pointed-to object anyway, then
11450 // ignore the side-effects.
11451 SpeculativeEvaluationRAII SpeculativeEval(Info);
11452 IgnoreSideEffectsRAII Fold(Info);
11453
11454 if (E->isGLValue()) {
11455 // It's possible for us to be given GLValues if we're called via
11456 // Expr::tryEvaluateObjectSize.
11457 APValue RVal;
11458 if (!EvaluateAsRValue(Info, E, RVal))
11459 return false;
11460 LVal.setFrom(Info.Ctx, RVal);
11461 } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info,
11462 /*InvalidBaseOK=*/true))
11463 return false;
11464 }
11465
11466 // If we point to before the start of the object, there are no accessible
11467 // bytes.
11468 if (LVal.getLValueOffset().isNegative()) {
11469 Size = 0;
11470 return true;
11471 }
11472
11473 CharUnits EndOffset;
11474 if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset))
11475 return false;
11476
11477 // If we've fallen outside of the end offset, just pretend there's nothing to
11478 // write to/read from.
11479 if (EndOffset <= LVal.getLValueOffset())
11480 Size = 0;
11481 else
11482 Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
11483 return true;
11484}
11485
11486bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
11487 if (unsigned BuiltinOp = E->getBuiltinCallee())
11488 return VisitBuiltinCallExpr(E, BuiltinOp);
11489
11490 return ExprEvaluatorBaseTy::VisitCallExpr(E);
11491}
11492
11493static bool getBuiltinAlignArguments(const CallExpr *E, EvalInfo &Info,
11494 APValue &Val, APSInt &Alignment) {
11495 QualType SrcTy = E->getArg(0)->getType();
11496 if (!getAlignmentArgument(E->getArg(1), SrcTy, Info, Alignment))
11497 return false;
11498 // Even though we are evaluating integer expressions we could get a pointer
11499 // argument for the __builtin_is_aligned() case.
11500 if (SrcTy->isPointerType()) {
11501 LValue Ptr;
11502 if (!EvaluatePointer(E->getArg(0), Ptr, Info))
11503 return false;
11504 Ptr.moveInto(Val);
11505 } else if (!SrcTy->isIntegralOrEnumerationType()) {
11506 Info.FFDiag(E->getArg(0));
11507 return false;
11508 } else {
11509 APSInt SrcInt;
11510 if (!EvaluateInteger(E->getArg(0), SrcInt, Info))
11511 return false;
11512 assert(SrcInt.getBitWidth() >= Alignment.getBitWidth() &&((void)0)
11513 "Bit widths must be the same")((void)0);
11514 Val = APValue(SrcInt);
11515 }
11516 assert(Val.hasValue())((void)0);
11517 return true;
11518}
11519
11520bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
11521 unsigned BuiltinOp) {
11522 switch (BuiltinOp) {
11523 default:
11524 return ExprEvaluatorBaseTy::VisitCallExpr(E);
11525
11526 case Builtin::BI__builtin_dynamic_object_size:
11527 case Builtin::BI__builtin_object_size: {
11528 // The type was checked when we built the expression.
11529 unsigned Type =
11530 E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
11531 assert(Type <= 3 && "unexpected type")((void)0);
11532
11533 uint64_t Size;
11534 if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size))
11535 return Success(Size, E);
11536
11537 if (E->getArg(0)->HasSideEffects(Info.Ctx))
11538 return Success((Type & 2) ? 0 : -1, E);
11539
11540 // Expression had no side effects, but we couldn't statically determine the
11541 // size of the referenced object.
11542 switch (Info.EvalMode) {
11543 case EvalInfo::EM_ConstantExpression:
11544 case EvalInfo::EM_ConstantFold:
11545 case EvalInfo::EM_IgnoreSideEffects:
11546 // Leave it to IR generation.
11547 return Error(E);
11548 case EvalInfo::EM_ConstantExpressionUnevaluated:
11549 // Reduce it to a constant now.
11550 return Success((Type & 2) ? 0 : -1, E);
11551 }
11552
11553 llvm_unreachable("unexpected EvalMode")__builtin_unreachable();
11554 }
11555
11556 case Builtin::BI__builtin_os_log_format_buffer_size: {
11557 analyze_os_log::OSLogBufferLayout Layout;
11558 analyze_os_log::computeOSLogBufferLayout(Info.Ctx, E, Layout);
11559 return Success(Layout.size().getQuantity(), E);
11560 }
11561
11562 case Builtin::BI__builtin_is_aligned: {
11563 APValue Src;
11564 APSInt Alignment;
11565 if (!getBuiltinAlignArguments(E, Info, Src, Alignment))
11566 return false;
11567 if (Src.isLValue()) {
11568 // If we evaluated a pointer, check the minimum known alignment.
11569 LValue Ptr;
11570 Ptr.setFrom(Info.Ctx, Src);
11571 CharUnits BaseAlignment = getBaseAlignment(Info, Ptr);
11572 CharUnits PtrAlign = BaseAlignment.alignmentAtOffset(Ptr.Offset);
11573 // We can return true if the known alignment at the computed offset is
11574 // greater than the requested alignment.
11575 assert(PtrAlign.isPowerOfTwo())((void)0);
11576 assert(Alignment.isPowerOf2())((void)0);
11577 if (PtrAlign.getQuantity() >= Alignment)
11578 return Success(1, E);
11579 // If the alignment is not known to be sufficient, some cases could still
11580 // be aligned at run time. However, if the requested alignment is less or
11581 // equal to the base alignment and the offset is not aligned, we know that
11582 // the run-time value can never be aligned.
11583 if (BaseAlignment.getQuantity() >= Alignment &&
11584 PtrAlign.getQuantity() < Alignment)
11585 return Success(0, E);
11586 // Otherwise we can't infer whether the value is sufficiently aligned.
11587 // TODO: __builtin_is_aligned(__builtin_align_{down,up{(expr, N), N)
11588 // in cases where we can't fully evaluate the pointer.
11589 Info.FFDiag(E->getArg(0), diag::note_constexpr_alignment_compute)
11590 << Alignment;
11591 return false;
11592 }
11593 assert(Src.isInt())((void)0);
11594 return Success((Src.getInt() & (Alignment - 1)) == 0 ? 1 : 0, E);
11595 }
11596 case Builtin::BI__builtin_align_up: {
11597 APValue Src;
11598 APSInt Alignment;
11599 if (!getBuiltinAlignArguments(E, Info, Src, Alignment))
11600 return false;
11601 if (!Src.isInt())
11602 return Error(E);
11603 APSInt AlignedVal =
11604 APSInt((Src.getInt() + (Alignment - 1)) & ~(Alignment - 1),
11605 Src.getInt().isUnsigned());
11606 assert(AlignedVal.getBitWidth() == Src.getInt().getBitWidth())((void)0);
11607 return Success(AlignedVal, E);
11608 }
11609 case Builtin::BI__builtin_align_down: {
11610 APValue Src;
11611 APSInt Alignment;
11612 if (!getBuiltinAlignArguments(E, Info, Src, Alignment))
11613 return false;
11614 if (!Src.isInt())
11615 return Error(E);
11616 APSInt AlignedVal =
11617 APSInt(Src.getInt() & ~(Alignment - 1), Src.getInt().isUnsigned());
11618 assert(AlignedVal.getBitWidth() == Src.getInt().getBitWidth())((void)0);
11619 return Success(AlignedVal, E);
11620 }
11621
11622 case Builtin::BI__builtin_bitreverse8:
11623 case Builtin::BI__builtin_bitreverse16:
11624 case Builtin::BI__builtin_bitreverse32:
11625 case Builtin::BI__builtin_bitreverse64: {
11626 APSInt Val;
11627 if (!EvaluateInteger(E->getArg(0), Val, Info))
11628 return false;
11629
11630 return Success(Val.reverseBits(), E);
11631 }
11632
11633 case Builtin::BI__builtin_bswap16:
11634 case Builtin::BI__builtin_bswap32:
11635 case Builtin::BI__builtin_bswap64: {
11636 APSInt Val;
11637 if (!EvaluateInteger(E->getArg(0), Val, Info))
11638 return false;
11639
11640 return Success(Val.byteSwap(), E);
11641 }
11642
11643 case Builtin::BI__builtin_classify_type:
11644 return Success((int)EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E);
11645
11646 case Builtin::BI__builtin_clrsb:
11647 case Builtin::BI__builtin_clrsbl:
11648 case Builtin::BI__builtin_clrsbll: {
11649 APSInt Val;
11650 if (!EvaluateInteger(E->getArg(0), Val, Info))
11651 return false;
11652
11653 return Success(Val.getBitWidth() - Val.getMinSignedBits(), E);
11654 }
11655
11656 case Builtin::BI__builtin_clz:
11657 case Builtin::BI__builtin_clzl:
11658 case Builtin::BI__builtin_clzll:
11659 case Builtin::BI__builtin_clzs: {
11660 APSInt Val;
11661 if (!EvaluateInteger(E->getArg(0), Val, Info))
11662 return false;
11663 if (!Val)
11664 return Error(E);
11665
11666 return Success(Val.countLeadingZeros(), E);
11667 }
11668
11669 case Builtin::BI__builtin_constant_p: {
11670 const Expr *Arg = E->getArg(0);
11671 if (EvaluateBuiltinConstantP(Info, Arg))
11672 return Success(true, E);
11673 if (Info.InConstantContext || Arg->HasSideEffects(Info.Ctx)) {
11674 // Outside a constant context, eagerly evaluate to false in the presence
11675 // of side-effects in order to avoid -Wunsequenced false-positives in
11676 // a branch on __builtin_constant_p(expr).
11677 return Success(false, E);
11678 }
11679 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
11680 return false;
11681 }
11682
11683 case Builtin::BI__builtin_is_constant_evaluated: {
11684 const auto *Callee = Info.CurrentCall->getCallee();
11685 if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
11686 (Info.CallStackDepth == 1 ||
11687 (Info.CallStackDepth == 2 && Callee->isInStdNamespace() &&
11688 Callee->getIdentifier() &&
11689 Callee->getIdentifier()->isStr("is_constant_evaluated")))) {
11690 // FIXME: Find a better way to avoid duplicated diagnostics.
11691 if (Info.EvalStatus.Diag)
11692 Info.report((Info.CallStackDepth == 1) ? E->getExprLoc()
11693 : Info.CurrentCall->CallLoc,
11694 diag::warn_is_constant_evaluated_always_true_constexpr)
11695 << (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated"
11696 : "std::is_constant_evaluated");
11697 }
11698
11699 return Success(Info.InConstantContext, E);
11700 }
11701
11702 case Builtin::BI__builtin_ctz:
11703 case Builtin::BI__builtin_ctzl:
11704 case Builtin::BI__builtin_ctzll:
11705 case Builtin::BI__builtin_ctzs: {
11706 APSInt Val;
11707 if (!EvaluateInteger(E->getArg(0), Val, Info))
11708 return false;
11709 if (!Val)
11710 return Error(E);
11711
11712 return Success(Val.countTrailingZeros(), E);
11713 }
11714
11715 case Builtin::BI__builtin_eh_return_data_regno: {
11716 int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
11717 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
11718 return Success(Operand, E);
11719 }
11720
11721 case Builtin::BI__builtin_expect:
11722 case Builtin::BI__builtin_expect_with_probability:
11723 return Visit(E->getArg(0));
11724
11725 case Builtin::BI__builtin_ffs:
11726 case Builtin::BI__builtin_ffsl:
11727 case Builtin::BI__builtin_ffsll: {
11728 APSInt Val;
11729 if (!EvaluateInteger(E->getArg(0), Val, Info))
11730 return false;
11731
11732 unsigned N = Val.countTrailingZeros();
11733 return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
11734 }
11735
11736 case Builtin::BI__builtin_fpclassify: {
11737 APFloat Val(0.0);
11738 if (!EvaluateFloat(E->getArg(5), Val, Info))
11739 return false;
11740 unsigned Arg;
11741 switch (Val.getCategory()) {
11742 case APFloat::fcNaN: Arg = 0; break;
11743 case APFloat::fcInfinity: Arg = 1; break;
11744 case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
11745 case APFloat::fcZero: Arg = 4; break;
11746 }
11747 return Visit(E->getArg(Arg));
11748 }
11749
11750 case Builtin::BI__builtin_isinf_sign: {
11751 APFloat Val(0.0);
11752 return EvaluateFloat(E->getArg(0), Val, Info) &&
11753 Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);
11754 }
11755
11756 case Builtin::BI__builtin_isinf: {
11757 APFloat Val(0.0);
11758 return EvaluateFloat(E->getArg(0), Val, Info) &&
11759 Success(Val.isInfinity() ? 1 : 0, E);
11760 }
11761
11762 case Builtin::BI__builtin_isfinite: {
11763 APFloat Val(0.0);
11764 return EvaluateFloat(E->getArg(0), Val, Info) &&
11765 Success(Val.isFinite() ? 1 : 0, E);
11766 }
11767
11768 case Builtin::BI__builtin_isnan: {
11769 APFloat Val(0.0);
11770 return EvaluateFloat(E->getArg(0), Val, Info) &&
11771 Success(Val.isNaN() ? 1 : 0, E);
11772 }
11773
11774 case Builtin::BI__builtin_isnormal: {
11775 APFloat Val(0.0);
11776 return EvaluateFloat(E->getArg(0), Val, Info) &&
11777 Success(Val.isNormal() ? 1 : 0, E);
11778 }
11779
11780 case Builtin::BI__builtin_parity:
11781 case Builtin::BI__builtin_parityl:
11782 case Builtin::BI__builtin_parityll: {
11783 APSInt Val;
11784 if (!EvaluateInteger(E->getArg(0), Val, Info))
11785 return false;
11786
11787 return Success(Val.countPopulation() % 2, E);
11788 }
11789
11790 case Builtin::BI__builtin_popcount:
11791 case Builtin::BI__builtin_popcountl:
11792 case Builtin::BI__builtin_popcountll: {
11793 APSInt Val;
11794 if (!EvaluateInteger(E->getArg(0), Val, Info))
11795 return false;
11796
11797 return Success(Val.countPopulation(), E);
11798 }
11799
11800 case Builtin::BI__builtin_rotateleft8:
11801 case Builtin::BI__builtin_rotateleft16:
11802 case Builtin::BI__builtin_rotateleft32:
11803 case Builtin::BI__builtin_rotateleft64:
11804 case Builtin::BI_rotl8: // Microsoft variants of rotate right
11805 case Builtin::BI_rotl16:
11806 case Builtin::BI_rotl:
11807 case Builtin::BI_lrotl:
11808 case Builtin::BI_rotl64: {
11809 APSInt Val, Amt;
11810 if (!EvaluateInteger(E->getArg(0), Val, Info) ||
11811 !EvaluateInteger(E->getArg(1), Amt, Info))
11812 return false;
11813
11814 return Success(Val.rotl(Amt.urem(Val.getBitWidth())), E);
11815 }
11816
11817 case Builtin::BI__builtin_rotateright8:
11818 case Builtin::BI__builtin_rotateright16:
11819 case Builtin::BI__builtin_rotateright32:
11820 case Builtin::BI__builtin_rotateright64:
11821 case Builtin::BI_rotr8: // Microsoft variants of rotate right
11822 case Builtin::BI_rotr16:
11823 case Builtin::BI_rotr:
11824 case Builtin::BI_lrotr:
11825 case Builtin::BI_rotr64: {
11826 APSInt Val, Amt;
11827 if (!EvaluateInteger(E->getArg(0), Val, Info) ||
11828 !EvaluateInteger(E->getArg(1), Amt, Info))
11829 return false;
11830
11831 return Success(Val.rotr(Amt.urem(Val.getBitWidth())), E);
11832 }
11833
11834 case Builtin::BIstrlen:
11835 case Builtin::BIwcslen:
11836 // A call to strlen is not a constant expression.
11837 if (Info.getLangOpts().CPlusPlus11)
11838 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
11839 << /*isConstexpr*/0 << /*isConstructor*/0
11840 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
11841 else
11842 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
11843 LLVM_FALLTHROUGH[[gnu::fallthrough]];
11844 case Builtin::BI__builtin_strlen:
11845 case Builtin::BI__builtin_wcslen: {
11846 // As an extension, we support __builtin_strlen() as a constant expression,
11847 // and support folding strlen() to a constant.
11848 LValue String;
11849 if (!EvaluatePointer(E->getArg(0), String, Info))
11850 return false;
11851
11852 QualType CharTy = E->getArg(0)->getType()->getPointeeType();
11853
11854 // Fast path: if it's a string literal, search the string value.
11855 if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
11856 String.getLValueBase().dyn_cast<const Expr *>())) {
11857 // The string literal may have embedded null characters. Find the first
11858 // one and truncate there.
11859 StringRef Str = S->getBytes();
11860 int64_t Off = String.Offset.getQuantity();
11861 if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
11862 S->getCharByteWidth() == 1 &&
11863 // FIXME: Add fast-path for wchar_t too.
11864 Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) {
11865 Str = Str.substr(Off);
11866
11867 StringRef::size_type Pos = Str.find(0);
11868 if (Pos != StringRef::npos)
11869 Str = Str.substr(0, Pos);
11870
11871 return Success(Str.size(), E);
11872 }
11873
11874 // Fall through to slow path to issue appropriate diagnostic.
11875 }
11876
11877 // Slow path: scan the bytes of the string looking for the terminating 0.
11878 for (uint64_t Strlen = 0; /**/; ++Strlen) {
11879 APValue Char;
11880 if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) ||
11881 !Char.isInt())
11882 return false;
11883 if (!Char.getInt())
11884 return Success(Strlen, E);
11885 if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1))
11886 return false;
11887 }
11888 }
11889
11890 case Builtin::BIstrcmp:
11891 case Builtin::BIwcscmp:
11892 case Builtin::BIstrncmp:
11893 case Builtin::BIwcsncmp:
11894 case Builtin::BImemcmp:
11895 case Builtin::BIbcmp:
11896 case Builtin::BIwmemcmp:
11897 // A call to strlen is not a constant expression.
11898 if (Info.getLangOpts().CPlusPlus11)
11899 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
11900 << /*isConstexpr*/0 << /*isConstructor*/0
11901 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
11902 else
11903 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
11904 LLVM_FALLTHROUGH[[gnu::fallthrough]];
11905 case Builtin::BI__builtin_strcmp:
11906 case Builtin::BI__builtin_wcscmp:
11907 case Builtin::BI__builtin_strncmp:
11908 case Builtin::BI__builtin_wcsncmp:
11909 case Builtin::BI__builtin_memcmp:
11910 case Builtin::BI__builtin_bcmp:
11911 case Builtin::BI__builtin_wmemcmp: {
11912 LValue String1, String2;
11913 if (!EvaluatePointer(E->getArg(0), String1, Info) ||
11914 !EvaluatePointer(E->getArg(1), String2, Info))
11915 return false;
11916
11917 uint64_t MaxLength = uint64_t(-1);
11918 if (BuiltinOp != Builtin::BIstrcmp &&
11919 BuiltinOp != Builtin::BIwcscmp &&
11920 BuiltinOp != Builtin::BI__builtin_strcmp &&
11921 BuiltinOp != Builtin::BI__builtin_wcscmp) {
11922 APSInt N;
11923 if (!EvaluateInteger(E->getArg(2), N, Info))
11924 return false;
11925 MaxLength = N.getExtValue();
11926 }
11927
11928 // Empty substrings compare equal by definition.
11929 if (MaxLength == 0u)
11930 return Success(0, E);
11931
11932 if (!String1.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
11933 !String2.checkNullPointerForFoldAccess(Info, E, AK_Read) ||
11934 String1.Designator.Invalid || String2.Designator.Invalid)
11935 return false;
11936
11937 QualType CharTy1 = String1.Designator.getType(Info.Ctx);
11938 QualType CharTy2 = String2.Designator.getType(Info.Ctx);
11939
11940 bool IsRawByte = BuiltinOp == Builtin::BImemcmp ||
11941 BuiltinOp == Builtin::BIbcmp ||
11942 BuiltinOp == Builtin::BI__builtin_memcmp ||
11943 BuiltinOp == Builtin::BI__builtin_bcmp;
11944
11945 assert(IsRawByte ||((void)0)
11946 (Info.Ctx.hasSameUnqualifiedType(((void)0)
11947 CharTy1, E->getArg(0)->getType()->getPointeeType()) &&((void)0)
11948 Info.Ctx.hasSameUnqualifiedType(CharTy1, CharTy2)))((void)0);
11949
11950 // For memcmp, allow comparing any arrays of '[[un]signed] char' or
11951 // 'char8_t', but no other types.
11952 if (IsRawByte &&
11953 !(isOneByteCharacterType(CharTy1) && isOneByteCharacterType(CharTy2))) {
11954 // FIXME: Consider using our bit_cast implementation to support this.
11955 Info.FFDiag(E, diag::note_constexpr_memcmp_unsupported)
11956 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'")
11957 << CharTy1 << CharTy2;
11958 return false;
11959 }
11960
11961 const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) {
11962 return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) &&
11963 handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) &&
11964 Char1.isInt() && Char2.isInt();
11965 };
11966 const auto &AdvanceElems = [&] {
11967 return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) &&
11968 HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1);
11969 };
11970
11971 bool StopAtNull =
11972 (BuiltinOp != Builtin::BImemcmp && BuiltinOp != Builtin::BIbcmp &&
11973 BuiltinOp != Builtin::BIwmemcmp &&
11974 BuiltinOp != Builtin::BI__builtin_memcmp &&
11975 BuiltinOp != Builtin::BI__builtin_bcmp &&
11976 BuiltinOp != Builtin::BI__builtin_wmemcmp);
11977 bool IsWide = BuiltinOp == Builtin::BIwcscmp ||
11978 BuiltinOp == Builtin::BIwcsncmp ||
11979 BuiltinOp == Builtin::BIwmemcmp ||
11980 BuiltinOp == Builtin::BI__builtin_wcscmp ||
11981 BuiltinOp == Builtin::BI__builtin_wcsncmp ||
11982 BuiltinOp == Builtin::BI__builtin_wmemcmp;
11983
11984 for (; MaxLength; --MaxLength) {
11985 APValue Char1, Char2;
11986 if (!ReadCurElems(Char1, Char2))
11987 return false;
11988 if (Char1.getInt().ne(Char2.getInt())) {
11989 if (IsWide) // wmemcmp compares with wchar_t signedness.
11990 return Success(Char1.getInt() < Char2.getInt() ? -1 : 1, E);
11991 // memcmp always compares unsigned chars.
11992 return Success(Char1.getInt().ult(Char2.getInt()) ? -1 : 1, E);
11993 }
11994 if (StopAtNull && !Char1.getInt())
11995 return Success(0, E);
11996 assert(!(StopAtNull && !Char2.getInt()))((void)0);
11997 if (!AdvanceElems())
11998 return false;
11999 }
12000 // We hit the strncmp / memcmp limit.
12001 return Success(0, E);
12002 }
12003
12004 case Builtin::BI__atomic_always_lock_free:
12005 case Builtin::BI__atomic_is_lock_free:
12006 case Builtin::BI__c11_atomic_is_lock_free: {
12007 APSInt SizeVal;
12008 if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
12009 return false;
12010
12011 // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power
12012 // of two less than or equal to the maximum inline atomic width, we know it
12013 // is lock-free. If the size isn't a power of two, or greater than the
12014 // maximum alignment where we promote atomics, we know it is not lock-free
12015 // (at least not in the sense of atomic_is_lock_free). Otherwise,
12016 // the answer can only be determined at runtime; for example, 16-byte
12017 // atomics have lock-free implementations on some, but not all,
12018 // x86-64 processors.
12019
12020 // Check power-of-two.
12021 CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
12022 if (Size.isPowerOfTwo()) {
12023 // Check against inlining width.
12024 unsigned InlineWidthBits =
12025 Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
12026 if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
12027 if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||
12028 Size == CharUnits::One() ||
12029 E->getArg(1)->isNullPointerConstant(Info.Ctx,
12030 Expr::NPC_NeverValueDependent))
12031 // OK, we will inline appropriately-aligned operations of this size,
12032 // and _Atomic(T) is appropriately-aligned.
12033 return Success(1, E);
12034
12035 QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
12036 castAs<PointerType>()->getPointeeType();
12037 if (!PointeeType->isIncompleteType() &&
12038 Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
12039 // OK, we will inline operations on this object.
12040 return Success(1, E);
12041 }
12042 }
12043 }
12044
12045 return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
12046 Success(0, E) : Error(E);
12047 }
12048 case Builtin::BI__builtin_add_overflow:
12049 case Builtin::BI__builtin_sub_overflow:
12050 case Builtin::BI__builtin_mul_overflow:
12051 case Builtin::BI__builtin_sadd_overflow:
12052 case Builtin::BI__builtin_uadd_overflow:
12053 case Builtin::BI__builtin_uaddl_overflow:
12054 case Builtin::BI__builtin_uaddll_overflow:
12055 case Builtin::BI__builtin_usub_overflow:
12056 case Builtin::BI__builtin_usubl_overflow:
12057 case Builtin::BI__builtin_usubll_overflow:
12058 case Builtin::BI__builtin_umul_overflow:
12059 case Builtin::BI__builtin_umull_overflow:
12060 case Builtin::BI__builtin_umulll_overflow:
12061 case Builtin::BI__builtin_saddl_overflow:
12062 case Builtin::BI__builtin_saddll_overflow:
12063 case Builtin::BI__builtin_ssub_overflow:
12064 case Builtin::BI__builtin_ssubl_overflow:
12065 case Builtin::BI__builtin_ssubll_overflow:
12066 case Builtin::BI__builtin_smul_overflow:
12067 case Builtin::BI__builtin_smull_overflow:
12068 case Builtin::BI__builtin_smulll_overflow: {
12069 LValue ResultLValue;
12070 APSInt LHS, RHS;
12071
12072 QualType ResultType = E->getArg(2)->getType()->getPointeeType();
12073 if (!EvaluateInteger(E->getArg(0), LHS, Info) ||
12074 !EvaluateInteger(E->getArg(1), RHS, Info) ||
12075 !EvaluatePointer(E->getArg(2), ResultLValue, Info))
12076 return false;
12077
12078 APSInt Result;
12079 bool DidOverflow = false;
12080
12081 // If the types don't have to match, enlarge all 3 to the largest of them.
12082 if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
12083 BuiltinOp == Builtin::BI__builtin_sub_overflow ||
12084 BuiltinOp == Builtin::BI__builtin_mul_overflow) {
12085 bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
12086 ResultType->isSignedIntegerOrEnumerationType();
12087 bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
12088 ResultType->isSignedIntegerOrEnumerationType();
12089 uint64_t LHSSize = LHS.getBitWidth();
12090 uint64_t RHSSize = RHS.getBitWidth();
12091 uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType);
12092 uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize);
12093
12094 // Add an additional bit if the signedness isn't uniformly agreed to. We
12095 // could do this ONLY if there is a signed and an unsigned that both have
12096 // MaxBits, but the code to check that is pretty nasty. The issue will be
12097 // caught in the shrink-to-result later anyway.
12098 if (IsSigned && !AllSigned)
12099 ++MaxBits;
12100
12101 LHS = APSInt(LHS.extOrTrunc(MaxBits), !IsSigned);
12102 RHS = APSInt(RHS.extOrTrunc(MaxBits), !IsSigned);
12103 Result = APSInt(MaxBits, !IsSigned);
12104 }
12105
12106 // Find largest int.
12107 switch (BuiltinOp) {
12108 default:
12109 llvm_unreachable("Invalid value for BuiltinOp")__builtin_unreachable();
12110 case Builtin::BI__builtin_add_overflow:
12111 case Builtin::BI__builtin_sadd_overflow:
12112 case Builtin::BI__builtin_saddl_overflow:
12113 case Builtin::BI__builtin_saddll_overflow:
12114 case Builtin::BI__builtin_uadd_overflow:
12115 case Builtin::BI__builtin_uaddl_overflow:
12116 case Builtin::BI__builtin_uaddll_overflow:
12117 Result = LHS.isSigned() ? LHS.sadd_ov(RHS, DidOverflow)
12118 : LHS.uadd_ov(RHS, DidOverflow);
12119 break;
12120 case Builtin::BI__builtin_sub_overflow:
12121 case Builtin::BI__builtin_ssub_overflow:
12122 case Builtin::BI__builtin_ssubl_overflow:
12123 case Builtin::BI__builtin_ssubll_overflow:
12124 case Builtin::BI__builtin_usub_overflow:
12125 case Builtin::BI__builtin_usubl_overflow:
12126 case Builtin::BI__builtin_usubll_overflow:
12127 Result = LHS.isSigned() ? LHS.ssub_ov(RHS, DidOverflow)
12128 : LHS.usub_ov(RHS, DidOverflow);
12129 break;
12130 case Builtin::BI__builtin_mul_overflow:
12131 case Builtin::BI__builtin_smul_overflow:
12132 case Builtin::BI__builtin_smull_overflow:
12133 case Builtin::BI__builtin_smulll_overflow:
12134 case Builtin::BI__builtin_umul_overflow:
12135 case Builtin::BI__builtin_umull_overflow:
12136 case Builtin::BI__builtin_umulll_overflow:
12137 Result = LHS.isSigned() ? LHS.smul_ov(RHS, DidOverflow)
12138 : LHS.umul_ov(RHS, DidOverflow);
12139 break;
12140 }
12141
12142 // In the case where multiple sizes are allowed, truncate and see if
12143 // the values are the same.
12144 if (BuiltinOp == Builtin::BI__builtin_add_overflow ||
12145 BuiltinOp == Builtin::BI__builtin_sub_overflow ||
12146 BuiltinOp == Builtin::BI__builtin_mul_overflow) {
12147 // APSInt doesn't have a TruncOrSelf, so we use extOrTrunc instead,
12148 // since it will give us the behavior of a TruncOrSelf in the case where
12149 // its parameter <= its size. We previously set Result to be at least the
12150 // type-size of the result, so getTypeSize(ResultType) <= Result.BitWidth
12151 // will work exactly like TruncOrSelf.
12152 APSInt Temp = Result.extOrTrunc(Info.Ctx.getTypeSize(ResultType));
12153 Temp.setIsSigned(ResultType->isSignedIntegerOrEnumerationType());
12154
12155 if (!APSInt::isSameValue(Temp, Result))
12156 DidOverflow = true;
12157 Result = Temp;
12158 }
12159
12160 APValue APV{Result};
12161 if (!handleAssignment(Info, E, ResultLValue, ResultType, APV))
12162 return false;
12163 return Success(DidOverflow, E);
12164 }
12165 }
12166}
12167
12168/// Determine whether this is a pointer past the end of the complete
12169/// object referred to by the lvalue.
12170static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx,
12171 const LValue &LV) {
12172 // A null pointer can be viewed as being "past the end" but we don't
12173 // choose to look at it that way here.
12174 if (!LV.getLValueBase())
12175 return false;
12176
12177 // If the designator is valid and refers to a subobject, we're not pointing
12178 // past the end.
12179 if (!LV.getLValueDesignator().Invalid &&
12180 !LV.getLValueDesignator().isOnePastTheEnd())
12181 return false;
12182
12183 // A pointer to an incomplete type might be past-the-end if the type's size is
12184 // zero. We cannot tell because the type is incomplete.
12185 QualType Ty = getType(LV.getLValueBase());
12186 if (Ty->isIncompleteType())
12187 return true;
12188
12189 // We're a past-the-end pointer if we point to the byte after the object,
12190 // no matter what our type or path is.
12191 auto Size = Ctx.getTypeSizeInChars(Ty);
12192 return LV.getLValueOffset() == Size;
12193}
12194
12195namespace {
12196
12197/// Data recursive integer evaluator of certain binary operators.
12198///
12199/// We use a data recursive algorithm for binary operators so that we are able
12200/// to handle extreme cases of chained binary operators without causing stack
12201/// overflow.
12202class DataRecursiveIntBinOpEvaluator {
12203 struct EvalResult {
12204 APValue Val;
12205 bool Failed;
12206
12207 EvalResult() : Failed(false) { }
12208
12209 void swap(EvalResult &RHS) {
12210 Val.swap(RHS.Val);
12211 Failed = RHS.Failed;
12212 RHS.Failed = false;
12213 }
12214 };
12215
12216 struct Job {
12217 const Expr *E;
12218 EvalResult LHSResult; // meaningful only for binary operator expression.
12219 enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind;
12220
12221 Job() = default;
12222 Job(Job &&) = default;
12223
12224 void startSpeculativeEval(EvalInfo &Info) {
12225 SpecEvalRAII = SpeculativeEvaluationRAII(Info);
12226 }
12227
12228 private:
12229 SpeculativeEvaluationRAII SpecEvalRAII;
12230 };
12231
12232 SmallVector<Job, 16> Queue;
12233
12234 IntExprEvaluator &IntEval;
12235 EvalInfo &Info;
12236 APValue &FinalResult;
12237
12238public:
12239 DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
12240 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
12241
12242 /// True if \param E is a binary operator that we are going to handle
12243 /// data recursively.
12244 /// We handle binary operators that are comma, logical, or that have operands
12245 /// with integral or enumeration type.
12246 static bool shouldEnqueue(const BinaryOperator *E) {
12247 return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
12248 (E->isPRValue() && E->getType()->isIntegralOrEnumerationType() &&
12249 E->getLHS()->getType()->isIntegralOrEnumerationType() &&
12250 E->getRHS()->getType()->isIntegralOrEnumerationType());
12251 }
12252
12253 bool Traverse(const BinaryOperator *E) {
12254 enqueue(E);
12255 EvalResult PrevResult;
12256 while (!Queue.empty())
12257 process(PrevResult);
12258
12259 if (PrevResult.Failed) return false;
12260
12261 FinalResult.swap(PrevResult.Val);
12262 return true;
12263 }
12264
12265private:
12266 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
12267 return IntEval.Success(Value, E, Result);
12268 }
12269 bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
12270 return IntEval.Success(Value, E, Result);
12271 }
12272 bool Error(const Expr *E) {
12273 return IntEval.Error(E);
12274 }
12275 bool Error(const Expr *E, diag::kind D) {
12276 return IntEval.Error(E, D);
12277 }
12278
12279 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
12280 return Info.CCEDiag(E, D);
12281 }
12282
12283 // Returns true if visiting the RHS is necessary, false otherwise.
12284 bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
12285 bool &SuppressRHSDiags);
12286
12287 bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
12288 const BinaryOperator *E, APValue &Result);
12289
12290 void EvaluateExpr(const Expr *E, EvalResult &Result) {
12291 Result.Failed = !Evaluate(Result.Val, Info, E);
12292 if (Result.Failed)
12293 Result.Val = APValue();
12294 }
12295
12296 void process(EvalResult &Result);
12297
12298 void enqueue(const Expr *E) {
12299 E = E->IgnoreParens();
12300 Queue.resize(Queue.size()+1);
12301 Queue.back().E = E;
12302 Queue.back().Kind = Job::AnyExprKind;
12303 }
12304};
12305
12306}
12307
12308bool DataRecursiveIntBinOpEvaluator::
12309 VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
12310 bool &SuppressRHSDiags) {
12311 if (E->getOpcode() == BO_Comma) {
12312 // Ignore LHS but note if we could not evaluate it.
12313 if (LHSResult.Failed)
12314 return Info.noteSideEffect();
12315 return true;
12316 }
12317
12318 if (E->isLogicalOp()) {
12319 bool LHSAsBool;
12320 if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) {
12321 // We were able to evaluate the LHS, see if we can get away with not
12322 // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
12323 if (LHSAsBool == (E->getOpcode() == BO_LOr)) {
12324 Success(LHSAsBool, E, LHSResult.Val);
12325 return false; // Ignore RHS
12326 }
12327 } else {
12328 LHSResult.Failed = true;
12329
12330 // Since we weren't able to evaluate the left hand side, it
12331 // might have had side effects.
12332 if (!Info.noteSideEffect())
12333 return false;
12334
12335 // We can't evaluate the LHS; however, sometimes the result
12336 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
12337 // Don't ignore RHS and suppress diagnostics from this arm.
12338 SuppressRHSDiags = true;
12339 }
12340
12341 return true;
12342 }
12343
12344 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&((void)0)
12345 E->getRHS()->getType()->isIntegralOrEnumerationType())((void)0);
12346
12347 if (LHSResult.Failed && !Info.noteFailure())
12348 return false; // Ignore RHS;
12349
12350 return true;
12351}
12352
12353static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
12354 bool IsSub) {
12355 // Compute the new offset in the appropriate width, wrapping at 64 bits.
12356 // FIXME: When compiling for a 32-bit target, we should use 32-bit
12357 // offsets.
12358 assert(!LVal.hasLValuePath() && "have designator for integer lvalue")((void)0);
12359 CharUnits &Offset = LVal.getLValueOffset();
12360 uint64_t Offset64 = Offset.getQuantity();
12361 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
12362 Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
12363 : Offset64 + Index64);
12364}
12365
12366bool DataRecursiveIntBinOpEvaluator::
12367 VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
12368 const BinaryOperator *E, APValue &Result) {
12369 if (E->getOpcode() == BO_Comma) {
12370 if (RHSResult.Failed)
12371 return false;
12372 Result = RHSResult.Val;
12373 return true;
12374 }
12375
12376 if (E->isLogicalOp()) {
12377 bool lhsResult, rhsResult;
12378 bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult);
12379 bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult);
12380
12381 if (LHSIsOK) {
12382 if (RHSIsOK) {
12383 if (E->getOpcode() == BO_LOr)
12384 return Success(lhsResult || rhsResult, E, Result);
12385 else
12386 return Success(lhsResult && rhsResult, E, Result);
12387 }
12388 } else {
12389 if (RHSIsOK) {
12390 // We can't evaluate the LHS; however, sometimes the result
12391 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1.
12392 if (rhsResult == (E->getOpcode() == BO_LOr))
12393 return Success(rhsResult, E, Result);
12394 }
12395 }
12396
12397 return false;
12398 }
12399
12400 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() &&((void)0)
12401 E->getRHS()->getType()->isIntegralOrEnumerationType())((void)0);
12402
12403 if (LHSResult.Failed || RHSResult.Failed)
12404 return false;
12405
12406 const APValue &LHSVal = LHSResult.Val;
12407 const APValue &RHSVal = RHSResult.Val;
12408
12409 // Handle cases like (unsigned long)&a + 4.
12410 if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {
12411 Result = LHSVal;
12412 addOrSubLValueAsInteger(Result, RHSVal.getInt(), E->getOpcode() == BO_Sub);
12413 return true;
12414 }
12415
12416 // Handle cases like 4 + (unsigned long)&a
12417 if (E->getOpcode() == BO_Add &&
12418 RHSVal.isLValue() && LHSVal.isInt()) {
12419 Result = RHSVal;
12420 addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false);
12421 return true;
12422 }
12423
12424 if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) {
12425 // Handle (intptr_t)&&A - (intptr_t)&&B.
12426 if (!LHSVal.getLValueOffset().isZero() ||
12427 !RHSVal.getLValueOffset().isZero())
12428 return false;
12429 const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
12430 const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
12431 if (!LHSExpr || !RHSExpr)
12432 return false;
12433 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
12434 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
12435 if (!LHSAddrExpr || !RHSAddrExpr)
12436 return false;
12437 // Make sure both labels come from the same function.
12438 if (LHSAddrExpr->getLabel()->getDeclContext() !=
12439 RHSAddrExpr->getLabel()->getDeclContext())
12440 return false;
12441 Result = APValue(LHSAddrExpr, RHSAddrExpr);
12442 return true;
12443 }
12444
12445 // All the remaining cases expect both operands to be an integer
12446 if (!LHSVal.isInt() || !RHSVal.isInt())
12447 return Error(E);
12448
12449 // Set up the width and signedness manually, in case it can't be deduced
12450 // from the operation we're performing.
12451 // FIXME: Don't do this in the cases where we can deduce it.
12452 APSInt Value(Info.Ctx.getIntWidth(E->getType()),
12453 E->getType()->isUnsignedIntegerOrEnumerationType());
12454 if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(),
12455 RHSVal.getInt(), Value))
12456 return false;
12457 return Success(Value, E, Result);
12458}
12459
12460void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
12461 Job &job = Queue.back();
12462
12463 switch (job.Kind) {
12464 case Job::AnyExprKind: {
12465 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
12466 if (shouldEnqueue(Bop)) {
12467 job.Kind = Job::BinOpKind;
12468 enqueue(Bop->getLHS());
12469 return;
12470 }
12471 }
12472
12473 EvaluateExpr(job.E, Result);
12474 Queue.pop_back();
12475 return;
12476 }
12477
12478 case Job::BinOpKind: {
12479 const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
12480 bool SuppressRHSDiags = false;
12481 if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
12482 Queue.pop_back();
12483 return;
12484 }
12485 if (SuppressRHSDiags)
12486 job.startSpeculativeEval(Info);
12487 job.LHSResult.swap(Result);
12488 job.Kind = Job::BinOpVisitedLHSKind;
12489 enqueue(Bop->getRHS());
12490 return;
12491 }
12492
12493 case Job::BinOpVisitedLHSKind: {
12494 const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
12495 EvalResult RHS;
12496 RHS.swap(Result);
12497 Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
12498 Queue.pop_back();
12499 return;
12500 }
12501 }
12502
12503 llvm_unreachable("Invalid Job::Kind!")__builtin_unreachable();
12504}
12505
12506namespace {
12507enum class CmpResult {
12508 Unequal,
12509 Less,
12510 Equal,
12511 Greater,
12512 Unordered,
12513};
12514}
12515
12516template <class SuccessCB, class AfterCB>
12517static bool
12518EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E,
12519 SuccessCB &&Success, AfterCB &&DoAfter) {
12520 assert(!E->isValueDependent())((void)0);
12521 assert(E->isComparisonOp() && "expected comparison operator")((void)0);
12522 assert((E->getOpcode() == BO_Cmp ||((void)0)
12523 E->getType()->isIntegralOrEnumerationType()) &&((void)0)
12524 "unsupported binary expression evaluation")((void)0);
12525 auto Error = [&](const Expr *E) {
12526 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
12527 return false;
12528 };
12529
12530 bool IsRelational = E->isRelationalOp() || E->getOpcode() == BO_Cmp;
12531 bool IsEquality = E->isEqualityOp();
12532
12533 QualType LHSTy = E->getLHS()->getType();
12534 QualType RHSTy = E->getRHS()->getType();
12535
12536 if (LHSTy->isIntegralOrEnumerationType() &&
12537 RHSTy->isIntegralOrEnumerationType()) {
12538 APSInt LHS, RHS;
12539 bool LHSOK = EvaluateInteger(E->getLHS(), LHS, Info);
12540 if (!LHSOK && !Info.noteFailure())
12541 return false;
12542 if (!EvaluateInteger(E->getRHS(), RHS, Info) || !LHSOK)
12543 return false;
12544 if (LHS < RHS)
12545 return Success(CmpResult::Less, E);
12546 if (LHS > RHS)
12547 return Success(CmpResult::Greater, E);
12548 return Success(CmpResult::Equal, E);
12549 }
12550
12551 if (LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) {
12552 APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHSTy));
12553 APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHSTy));
12554
12555 bool LHSOK = EvaluateFixedPointOrInteger(E->getLHS(), LHSFX, Info);
12556 if (!LHSOK && !Info.noteFailure())
12557 return false;
12558 if (!EvaluateFixedPointOrInteger(E->getRHS(), RHSFX, Info) || !LHSOK)
12559 return false;
12560 if (LHSFX < RHSFX)
12561 return Success(CmpResult::Less, E);
12562 if (LHSFX > RHSFX)
12563 return Success(CmpResult::Greater, E);
12564 return Success(CmpResult::Equal, E);
12565 }
12566
12567 if (LHSTy->isAnyComplexType() || RHSTy->isAnyComplexType()) {
12568 ComplexValue LHS, RHS;
12569 bool LHSOK;
12570 if (E->isAssignmentOp()) {
12571 LValue LV;
12572 EvaluateLValue(E->getLHS(), LV, Info);
12573 LHSOK = false;
12574 } else if (LHSTy->isRealFloatingType()) {
12575 LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info);
12576 if (LHSOK) {
12577 LHS.makeComplexFloat();
12578 LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics());
12579 }
12580 } else {
12581 LHSOK = EvaluateComplex(E->getLHS(), LHS, Info);
12582 }
12583 if (!LHSOK && !Info.noteFailure())
12584 return false;
12585
12586 if (E->getRHS()->getType()->isRealFloatingType()) {
12587 if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK)
12588 return false;
12589 RHS.makeComplexFloat();
12590 RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics());
12591 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
12592 return false;
12593
12594 if (LHS.isComplexFloat()) {
12595 APFloat::cmpResult CR_r =
12596 LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
12597 APFloat::cmpResult CR_i =
12598 LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
12599 bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
12600 return Success(IsEqual ? CmpResult::Equal : CmpResult::Unequal, E);
12601 } else {
12602 assert(IsEquality && "invalid complex comparison")((void)0);
12603 bool IsEqual = LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
12604 LHS.getComplexIntImag() == RHS.getComplexIntImag();
12605 return Success(IsEqual ? CmpResult::Equal : CmpResult::Unequal, E);
12606 }
12607 }
12608
12609 if (LHSTy->isRealFloatingType() &&
12610 RHSTy->isRealFloatingType()) {
12611 APFloat RHS(0.0), LHS(0.0);
12612
12613 bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
12614 if (!LHSOK && !Info.noteFailure())
12615 return false;
12616
12617 if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK)
12618 return false;
12619
12620 assert(E->isComparisonOp() && "Invalid binary operator!")((void)0);
12621 llvm::APFloatBase::cmpResult APFloatCmpResult = LHS.compare(RHS);
12622 if (!Info.InConstantContext &&
12623 APFloatCmpResult == APFloat::cmpUnordered &&
12624 E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).isFPConstrained()) {
12625 // Note: Compares may raise invalid in some cases involving NaN or sNaN.
12626 Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
12627 return false;
12628 }
12629 auto GetCmpRes = [&]() {
12630 switch (APFloatCmpResult) {
12631 case APFloat::cmpEqual:
12632 return CmpResult::Equal;
12633 case APFloat::cmpLessThan:
12634 return CmpResult::Less;
12635 case APFloat::cmpGreaterThan:
12636 return CmpResult::Greater;
12637 case APFloat::cmpUnordered:
12638 return CmpResult::Unordered;
12639 }
12640 llvm_unreachable("Unrecognised APFloat::cmpResult enum")__builtin_unreachable();
12641 };
12642 return Success(GetCmpRes(), E);
12643 }
12644
12645 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
12646 LValue LHSValue, RHSValue;
12647
12648 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
12649 if (!LHSOK && !Info.noteFailure())
12650 return false;
12651
12652 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
12653 return false;
12654
12655 // Reject differing bases from the normal codepath; we special-case
12656 // comparisons to null.
12657 if (!HasSameBase(LHSValue, RHSValue)) {
12658 // Inequalities and subtractions between unrelated pointers have
12659 // unspecified or undefined behavior.
12660 if (!IsEquality) {
12661 Info.FFDiag(E, diag::note_constexpr_pointer_comparison_unspecified);
12662 return false;
12663 }
12664 // A constant address may compare equal to the address of a symbol.
12665 // The one exception is that address of an object cannot compare equal
12666 // to a null pointer constant.
12667 if ((!LHSValue.Base && !LHSValue.Offset.isZero()) ||
12668 (!RHSValue.Base && !RHSValue.Offset.isZero()))
12669 return Error(E);
12670 // It's implementation-defined whether distinct literals will have
12671 // distinct addresses. In clang, the result of such a comparison is
12672 // unspecified, so it is not a constant expression. However, we do know
12673 // that the address of a literal will be non-null.
12674 if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) &&
12675 LHSValue.Base && RHSValue.Base)
12676 return Error(E);
12677 // We can't tell whether weak symbols will end up pointing to the same
12678 // object.
12679 if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue))
12680 return Error(E);
12681 // We can't compare the address of the start of one object with the
12682 // past-the-end address of another object, per C++ DR1652.
12683 if ((LHSValue.Base && LHSValue.Offset.isZero() &&
12684 isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
12685 (RHSValue.Base && RHSValue.Offset.isZero() &&
12686 isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
12687 return Error(E);
12688 // We can't tell whether an object is at the same address as another
12689 // zero sized object.
12690 if ((RHSValue.Base && isZeroSized(LHSValue)) ||
12691 (LHSValue.Base && isZeroSized(RHSValue)))
12692 return Error(E);
12693 return Success(CmpResult::Unequal, E);
12694 }
12695
12696 const CharUnits &LHSOffset = LHSValue.getLValueOffset();
12697 const CharUnits &RHSOffset = RHSValue.getLValueOffset();
12698
12699 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
12700 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
12701
12702 // C++11 [expr.rel]p3:
12703 // Pointers to void (after pointer conversions) can be compared, with a
12704 // result defined as follows: If both pointers represent the same
12705 // address or are both the null pointer value, the result is true if the
12706 // operator is <= or >= and false otherwise; otherwise the result is
12707 // unspecified.
12708 // We interpret this as applying to pointers to *cv* void.
12709 if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational)
12710 Info.CCEDiag(E, diag::note_constexpr_void_comparison);
12711
12712 // C++11 [expr.rel]p2:
12713 // - If two pointers point to non-static data members of the same object,
12714 // or to subobjects or array elements fo such members, recursively, the
12715 // pointer to the later declared member compares greater provided the
12716 // two members have the same access control and provided their class is
12717 // not a union.
12718 // [...]
12719 // - Otherwise pointer comparisons are unspecified.
12720 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {
12721 bool WasArrayIndex;
12722 unsigned Mismatch = FindDesignatorMismatch(
12723 getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex);
12724 // At the point where the designators diverge, the comparison has a
12725 // specified value if:
12726 // - we are comparing array indices
12727 // - we are comparing fields of a union, or fields with the same access
12728 // Otherwise, the result is unspecified and thus the comparison is not a
12729 // constant expression.
12730 if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
12731 Mismatch < RHSDesignator.Entries.size()) {
12732 const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
12733 const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
12734 if (!LF && !RF)
12735 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
12736 else if (!LF)
12737 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
12738 << getAsBaseClass(LHSDesignator.Entries[Mismatch])
12739 << RF->getParent() << RF;
12740 else if (!RF)
12741 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
12742 << getAsBaseClass(RHSDesignator.Entries[Mismatch])
12743 << LF->getParent() << LF;
12744 else if (!LF->getParent()->isUnion() &&
12745 LF->getAccess() != RF->getAccess())
12746 Info.CCEDiag(E,
12747 diag::note_constexpr_pointer_comparison_differing_access)
12748 << LF << LF->getAccess() << RF << RF->getAccess()
12749 << LF->getParent();
12750 }
12751 }
12752
12753 // The comparison here must be unsigned, and performed with the same
12754 // width as the pointer.
12755 unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
12756 uint64_t CompareLHS = LHSOffset.getQuantity();
12757 uint64_t CompareRHS = RHSOffset.getQuantity();
12758 assert(PtrSize <= 64 && "Unexpected pointer width")((void)0);
12759 uint64_t Mask = ~0ULL >> (64 - PtrSize);
12760 CompareLHS &= Mask;
12761 CompareRHS &= Mask;
12762
12763 // If there is a base and this is a relational operator, we can only
12764 // compare pointers within the object in question; otherwise, the result
12765 // depends on where the object is located in memory.
12766 if (!LHSValue.Base.isNull() && IsRelational) {
12767 QualType BaseTy = getType(LHSValue.Base);
12768 if (BaseTy->isIncompleteType())
12769 return Error(E);
12770 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
12771 uint64_t OffsetLimit = Size.getQuantity();
12772 if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit)
12773 return Error(E);
12774 }
12775
12776 if (CompareLHS < CompareRHS)
12777 return Success(CmpResult::Less, E);
12778 if (CompareLHS > CompareRHS)
12779 return Success(CmpResult::Greater, E);
12780 return Success(CmpResult::Equal, E);
12781 }
12782
12783 if (LHSTy->isMemberPointerType()) {
12784 assert(IsEquality && "unexpected member pointer operation")((void)0);
12785 assert(RHSTy->isMemberPointerType() && "invalid comparison")((void)0);
12786
12787 MemberPtr LHSValue, RHSValue;
12788
12789 bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info);
12790 if (!LHSOK && !Info.noteFailure())
12791 return false;
12792
12793 if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK)
12794 return false;
12795
12796 // C++11 [expr.eq]p2:
12797 // If both operands are null, they compare equal. Otherwise if only one is
12798 // null, they compare unequal.
12799 if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
12800 bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
12801 return Success(Equal ? CmpResult::Equal : CmpResult::Unequal, E);
12802 }
12803
12804 // Otherwise if either is a pointer to a virtual member function, the
12805 // result is unspecified.
12806 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
12807 if (MD->isVirtual())
12808 Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
12809 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
12810 if (MD->isVirtual())
12811 Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
12812
12813 // Otherwise they compare equal if and only if they would refer to the
12814 // same member of the same most derived object or the same subobject if
12815 // they were dereferenced with a hypothetical object of the associated
12816 // class type.
12817 bool Equal = LHSValue == RHSValue;
12818 return Success(Equal ? CmpResult::Equal : CmpResult::Unequal, E);
12819 }
12820
12821 if (LHSTy->isNullPtrType()) {
12822 assert(E->isComparisonOp() && "unexpected nullptr operation")((void)0);
12823 assert(RHSTy->isNullPtrType() && "missing pointer conversion")((void)0);
12824 // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t
12825 // are compared, the result is true of the operator is <=, >= or ==, and
12826 // false otherwise.
12827 return Success(CmpResult::Equal, E);
12828 }
12829
12830 return DoAfter();
12831}
12832
12833bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
12834 if (!CheckLiteralType(Info, E))
12835 return false;
12836
12837 auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
12838 ComparisonCategoryResult CCR;
12839 switch (CR) {
12840 case CmpResult::Unequal:
12841 llvm_unreachable("should never produce Unequal for three-way comparison")__builtin_unreachable();
12842 case CmpResult::Less:
12843 CCR = ComparisonCategoryResult::Less;
12844 break;
12845 case CmpResult::Equal:
12846 CCR = ComparisonCategoryResult::Equal;
12847 break;
12848 case CmpResult::Greater:
12849 CCR = ComparisonCategoryResult::Greater;
12850 break;
12851 case CmpResult::Unordered:
12852 CCR = ComparisonCategoryResult::Unordered;
12853 break;
12854 }
12855 // Evaluation succeeded. Lookup the information for the comparison category
12856 // type and fetch the VarDecl for the result.
12857 const ComparisonCategoryInfo &CmpInfo =
12858 Info.Ctx.CompCategories.getInfoForType(E->getType());
12859 const VarDecl *VD = CmpInfo.getValueInfo(CmpInfo.makeWeakResult(CCR))->VD;
12860 // Check and evaluate the result as a constant expression.
12861 LValue LV;
12862 LV.set(VD);
12863 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
12864 return false;
12865 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
12866 ConstantExprKind::Normal);
12867 };
12868 return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
12869 return ExprEvaluatorBaseTy::VisitBinCmp(E);
12870 });
12871}
12872
12873bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
12874 // We don't support assignment in C. C++ assignments don't get here because
12875 // assignment is an lvalue in C++.
12876 if (E->isAssignmentOp()) {
12877 Error(E);
12878 if (!Info.noteFailure())
12879 return false;
12880 }
12881
12882 if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
12883 return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
12884
12885 assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() ||((void)0)
12886 !E->getRHS()->getType()->isIntegralOrEnumerationType()) &&((void)0)
12887 "DataRecursiveIntBinOpEvaluator should have handled integral types")((void)0);
12888
12889 if (E->isComparisonOp()) {
12890 // Evaluate builtin binary comparisons by evaluating them as three-way
12891 // comparisons and then translating the result.
12892 auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
12893 assert((CR != CmpResult::Unequal || E->isEqualityOp()) &&((void)0)
12894 "should only produce Unequal for equality comparisons")((void)0);
12895 bool IsEqual = CR == CmpResult::Equal,
12896 IsLess = CR == CmpResult::Less,
12897 IsGreater = CR == CmpResult::Greater;
12898 auto Op = E->getOpcode();
12899 switch (Op) {
12900 default:
12901 llvm_unreachable("unsupported binary operator")__builtin_unreachable();
12902 case BO_EQ:
12903 case BO_NE:
12904 return Success(IsEqual == (Op == BO_EQ), E);
12905 case BO_LT:
12906 return Success(IsLess, E);
12907 case BO_GT:
12908 return Success(IsGreater, E);
12909 case BO_LE:
12910 return Success(IsEqual || IsLess, E);
12911 case BO_GE:
12912 return Success(IsEqual || IsGreater, E);
12913 }
12914 };
12915 return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() {
12916 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
12917 });
12918 }
12919
12920 QualType LHSTy = E->getLHS()->getType();
12921 QualType RHSTy = E->getRHS()->getType();
12922
12923 if (LHSTy->isPointerType() && RHSTy->isPointerType() &&
12924 E->getOpcode() == BO_Sub) {
12925 LValue LHSValue, RHSValue;
12926
12927 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
12928 if (!LHSOK && !Info.noteFailure())
12929 return false;
12930
12931 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
12932 return false;
12933
12934 // Reject differing bases from the normal codepath; we special-case
12935 // comparisons to null.
12936 if (!HasSameBase(LHSValue, RHSValue)) {
12937 // Handle &&A - &&B.
12938 if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
12939 return Error(E);
12940 const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
12941 const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
12942 if (!LHSExpr || !RHSExpr)
12943 return Error(E);
12944 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
12945 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
12946 if (!LHSAddrExpr || !RHSAddrExpr)
12947 return Error(E);
12948 // Make sure both labels come from the same function.
12949 if (LHSAddrExpr->getLabel()->getDeclContext() !=
12950 RHSAddrExpr->getLabel()->getDeclContext())
12951 return Error(E);
12952 return Success(APValue(LHSAddrExpr, RHSAddrExpr), E);
12953 }
12954 const CharUnits &LHSOffset = LHSValue.getLValueOffset();
12955 const CharUnits &RHSOffset = RHSValue.getLValueOffset();
12956
12957 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
12958 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
12959
12960 // C++11 [expr.add]p6:
12961 // Unless both pointers point to elements of the same array object, or
12962 // one past the last element of the array object, the behavior is
12963 // undefined.
12964 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
12965 !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator,
12966 RHSDesignator))
12967 Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
12968
12969 QualType Type = E->getLHS()->getType();
12970 QualType ElementType = Type->castAs<PointerType>()->getPointeeType();
12971
12972 CharUnits ElementSize;
12973 if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
12974 return false;
12975
12976 // As an extension, a type may have zero size (empty struct or union in
12977 // C, array of zero length). Pointer subtraction in such cases has
12978 // undefined behavior, so is not constant.
12979 if (ElementSize.isZero()) {
12980 Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size)
12981 << ElementType;
12982 return false;
12983 }
12984
12985 // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime,
12986 // and produce incorrect results when it overflows. Such behavior
12987 // appears to be non-conforming, but is common, so perhaps we should
12988 // assume the standard intended for such cases to be undefined behavior
12989 // and check for them.
12990
12991 // Compute (LHSOffset - RHSOffset) / Size carefully, checking for
12992 // overflow in the final conversion to ptrdiff_t.
12993 APSInt LHS(llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false);
12994 APSInt RHS(llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false);
12995 APSInt ElemSize(llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true),
12996 false);
12997 APSInt TrueResult = (LHS - RHS) / ElemSize;
12998 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
12999
13000 if (Result.extend(65) != TrueResult &&
13001 !HandleOverflow(Info, E, TrueResult, E->getType()))
13002 return false;
13003 return Success(Result, E);
13004 }
13005
13006 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
13007}
13008
13009/// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with
13010/// a result as the expression's type.
13011bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
13012 const UnaryExprOrTypeTraitExpr *E) {
13013 switch(E->getKind()) {
13014 case UETT_PreferredAlignOf:
13015 case UETT_AlignOf: {
13016 if (E->isArgumentType())
13017 return Success(GetAlignOfType(Info, E->getArgumentType(), E->getKind()),
13018 E);
13019 else
13020 return Success(GetAlignOfExpr(Info, E->getArgumentExpr(), E->getKind()),
13021 E);
13022 }
13023
13024 case UETT_VecStep: {
13025 QualType Ty = E->getTypeOfArgument();
13026
13027 if (Ty->isVectorType()) {
13028 unsigned n = Ty->castAs<VectorType>()->getNumElements();
13029
13030 // The vec_step built-in functions that take a 3-component
13031 // vector return 4. (OpenCL 1.1 spec 6.11.12)
13032 if (n == 3)
13033 n = 4;
13034
13035 return Success(n, E);
13036 } else
13037 return Success(1, E);
13038 }
13039
13040 case UETT_SizeOf: {
13041 QualType SrcTy = E->getTypeOfArgument();
13042 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
13043 // the result is the size of the referenced type."
13044 if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
13045 SrcTy = Ref->getPointeeType();
13046
13047 CharUnits Sizeof;
13048 if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof))
13049 return false;
13050 return Success(Sizeof, E);
13051 }
13052 case UETT_OpenMPRequiredSimdAlign:
13053 assert(E->isArgumentType())((void)0);
13054 return Success(
13055 Info.Ctx.toCharUnitsFromBits(
13056 Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
13057 .getQuantity(),
13058 E);
13059 }
13060
13061 llvm_unreachable("unknown expr/type trait")__builtin_unreachable();
13062}
13063
13064bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
13065 CharUnits Result;
13066 unsigned n = OOE->getNumComponents();
13067 if (n == 0)
13068 return Error(OOE);
13069 QualType CurrentType = OOE->getTypeSourceInfo()->getType();
13070 for (unsigned i = 0; i != n; ++i) {
13071 OffsetOfNode ON = OOE->getComponent(i);
13072 switch (ON.getKind()) {
13073 case OffsetOfNode::Array: {
13074 const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
13075 APSInt IdxResult;
13076 if (!EvaluateInteger(Idx, IdxResult, Info))
13077 return false;
13078 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
13079 if (!AT)
13080 return Error(OOE);
13081 CurrentType = AT->getElementType();
13082 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
13083 Result += IdxResult.getSExtValue() * ElementSize;
13084 break;
13085 }
13086
13087 case OffsetOfNode::Field: {
13088 FieldDecl *MemberDecl = ON.getField();
13089 const RecordType *RT = CurrentType->getAs<RecordType>();
13090 if (!RT)
13091 return Error(OOE);
13092 RecordDecl *RD = RT->getDecl();
13093 if (RD->isInvalidDecl()) return false;
13094 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
13095 unsigned i = MemberDecl->getFieldIndex();
13096 assert(i < RL.getFieldCount() && "offsetof field in wrong type")((void)0);
13097 Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
13098 CurrentType = MemberDecl->getType().getNonReferenceType();
13099 break;
13100 }
13101
13102 case OffsetOfNode::Identifier:
13103 llvm_unreachable("dependent __builtin_offsetof")__builtin_unreachable();
13104
13105 case OffsetOfNode::Base: {
13106 CXXBaseSpecifier *BaseSpec = ON.getBase();
13107 if (BaseSpec->isVirtual())
13108 return Error(OOE);
13109
13110 // Find the layout of the class whose base we are looking into.
13111 const RecordType *RT = CurrentType->getAs<RecordType>();
13112 if (!RT)
13113 return Error(OOE);
13114 RecordDecl *RD = RT->getDecl();
13115 if (RD->isInvalidDecl()) return false;
13116 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
13117
13118 // Find the base class itself.
13119 CurrentType = BaseSpec->getType();
13120 const RecordType *BaseRT = CurrentType->getAs<RecordType>();
13121 if (!BaseRT)
13122 return Error(OOE);
13123
13124 // Add the offset to the base.
13125 Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()));
13126 break;
13127 }
13128 }
13129 }
13130 return Success(Result, OOE);
13131}
13132
13133bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
13134 switch (E->getOpcode()) {
13135 default:
13136 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
13137 // See C99 6.6p3.
13138 return Error(E);
13139 case UO_Extension:
13140 // FIXME: Should extension allow i-c-e extension expressions in its scope?
13141 // If so, we could clear the diagnostic ID.
13142 return Visit(E->getSubExpr());
13143 case UO_Plus:
13144 // The result is just the value.
13145 return Visit(E->getSubExpr());
13146 case UO_Minus: {
13147 if (!Visit(E->getSubExpr()))
13148 return false;
13149 if (!Result.isInt()) return Error(E);
13150 const APSInt &Value = Result.getInt();
13151 if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
13152 !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
13153 E->getType()))
13154 return false;
13155 return Success(-Value, E);
13156 }
13157 case UO_Not: {
13158 if (!Visit(E->getSubExpr()))
13159 return false;
13160 if (!Result.isInt()) return Error(E);
13161 return Success(~Result.getInt(), E);
13162 }
13163 case UO_LNot: {
13164 bool bres;
13165 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
13166 return false;
13167 return Success(!bres, E);
13168 }
13169 }
13170}
13171
13172/// HandleCast - This is used to evaluate implicit or explicit casts where the
13173/// result type is integer.
13174bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
13175 const Expr *SubExpr = E->getSubExpr();
13176 QualType DestType = E->getType();
13177 QualType SrcType = SubExpr->getType();
13178
13179 switch (E->getCastKind()) {
13180 case CK_BaseToDerived:
13181 case CK_DerivedToBase:
13182 case CK_UncheckedDerivedToBase:
13183 case CK_Dynamic:
13184 case CK_ToUnion:
13185 case CK_ArrayToPointerDecay:
13186 case CK_FunctionToPointerDecay:
13187 case CK_NullToPointer:
13188 case CK_NullToMemberPointer:
13189 case CK_BaseToDerivedMemberPointer:
13190 case CK_DerivedToBaseMemberPointer:
13191 case CK_ReinterpretMemberPointer:
13192 case CK_ConstructorConversion:
13193 case CK_IntegralToPointer:
13194 case CK_ToVoid:
13195 case CK_VectorSplat:
13196 case CK_IntegralToFloating:
13197 case CK_FloatingCast:
13198 case CK_CPointerToObjCPointerCast:
13199 case CK_BlockPointerToObjCPointerCast:
13200 case CK_AnyPointerToBlockPointerCast:
13201 case CK_ObjCObjectLValueCast:
13202 case CK_FloatingRealToComplex:
13203 case CK_FloatingComplexToReal:
13204 case CK_FloatingComplexCast:
13205 case CK_FloatingComplexToIntegralComplex:
13206 case CK_IntegralRealToComplex:
13207 case CK_IntegralComplexCast:
13208 case CK_IntegralComplexToFloatingComplex:
13209 case CK_BuiltinFnToFnPtr:
13210 case CK_ZeroToOCLOpaqueType:
13211 case CK_NonAtomicToAtomic:
13212 case CK_AddressSpaceConversion:
13213 case CK_IntToOCLSampler:
13214 case CK_FloatingToFixedPoint:
13215 case CK_FixedPointToFloating:
13216 case CK_FixedPointCast:
13217 case CK_IntegralToFixedPoint:
13218 case CK_MatrixCast:
13219 llvm_unreachable("invalid cast kind for integral value")__builtin_unreachable();
13220
13221 case CK_BitCast:
13222 case CK_Dependent:
13223 case CK_LValueBitCast:
13224 case CK_ARCProduceObject:
13225 case CK_ARCConsumeObject:
13226 case CK_ARCReclaimReturnedObject:
13227 case CK_ARCExtendBlockObject:
13228 case CK_CopyAndAutoreleaseBlockObject:
13229 return Error(E);
13230
13231 case CK_UserDefinedConversion:
13232 case CK_LValueToRValue:
13233 case CK_AtomicToNonAtomic:
13234 case CK_NoOp:
13235 case CK_LValueToRValueBitCast:
13236 return ExprEvaluatorBaseTy::VisitCastExpr(E);
13237
13238 case CK_MemberPointerToBoolean:
13239 case CK_PointerToBoolean:
13240 case CK_IntegralToBoolean:
13241 case CK_FloatingToBoolean:
13242 case CK_BooleanToSignedIntegral:
13243 case CK_FloatingComplexToBoolean:
13244 case CK_IntegralComplexToBoolean: {
13245 bool BoolResult;
13246 if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info))
13247 return false;
13248 uint64_t IntResult = BoolResult;
13249 if (BoolResult && E->getCastKind() == CK_BooleanToSignedIntegral)
13250 IntResult = (uint64_t)-1;
13251 return Success(IntResult, E);
13252 }
13253
13254 case CK_FixedPointToIntegral: {
13255 APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SrcType));
13256 if (!EvaluateFixedPoint(SubExpr, Src, Info))
13257 return false;
13258 bool Overflowed;
13259 llvm::APSInt Result = Src.convertToInt(
13260 Info.Ctx.getIntWidth(DestType),
13261 DestType->isSignedIntegerOrEnumerationType(), &Overflowed);
13262 if (Overflowed && !HandleOverflow(Info, E, Result, DestType))
13263 return false;
13264 return Success(Result, E);
13265 }
13266
13267 case CK_FixedPointToBoolean: {
13268 // Unsigned padding does not affect this.
13269 APValue Val;
13270 if (!Evaluate(Val, Info, SubExpr))
13271 return false;
13272 return Success(Val.getFixedPoint().getBoolValue(), E);
13273 }
13274
13275 case CK_IntegralCast: {
13276 if (!Visit(SubExpr))
13277 return false;
13278
13279 if (!Result.isInt()) {
13280 // Allow casts of address-of-label differences if they are no-ops
13281 // or narrowing. (The narrowing case isn't actually guaranteed to
13282 // be constant-evaluatable except in some narrow cases which are hard
13283 // to detect here. We let it through on the assumption the user knows
13284 // what they are doing.)
13285 if (Result.isAddrLabelDiff())
13286 return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
13287 // Only allow casts of lvalues if they are lossless.
13288 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
13289 }
13290
13291 return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
13292 Result.getInt()), E);
13293 }
13294
13295 case CK_PointerToIntegral: {
13296 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
13297
13298 LValue LV;
13299 if (!EvaluatePointer(SubExpr, LV, Info))
13300 return false;
13301
13302 if (LV.getLValueBase()) {
13303 // Only allow based lvalue casts if they are lossless.
13304 // FIXME: Allow a larger integer size than the pointer size, and allow
13305 // narrowing back down to pointer width in subsequent integral casts.
13306 // FIXME: Check integer type's active bits, not its type size.
13307 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
13308 return Error(E);
13309
13310 LV.Designator.setInvalid();
13311 LV.moveInto(Result);
13312 return true;
13313 }
13314
13315 APSInt AsInt;
13316 APValue V;
13317 LV.moveInto(V);
13318 if (!V.toIntegralConstant(AsInt, SrcType, Info.Ctx))
13319 llvm_unreachable("Can't cast this!")__builtin_unreachable();
13320
13321 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E);
13322 }
13323
13324 case CK_IntegralComplexToReal: {
13325 ComplexValue C;
13326 if (!EvaluateComplex(SubExpr, C, Info))
13327 return false;
13328 return Success(C.getComplexIntReal(), E);
13329 }
13330
13331 case CK_FloatingToIntegral: {
13332 APFloat F(0.0);
13333 if (!EvaluateFloat(SubExpr, F, Info))
13334 return false;
13335
13336 APSInt Value;
13337 if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value))
13338 return false;
13339 return Success(Value, E);
13340 }
13341 }
13342
13343 llvm_unreachable("unknown cast resulting in integral value")__builtin_unreachable();
13344}
13345
13346bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
13347 if (E->getSubExpr()->getType()->isAnyComplexType()) {
13348 ComplexValue LV;
13349 if (!EvaluateComplex(E->getSubExpr(), LV, Info))
13350 return false;
13351 if (!LV.isComplexInt())
13352 return Error(E);
13353 return Success(LV.getComplexIntReal(), E);
13354 }
13355
13356 return Visit(E->getSubExpr());
13357}
13358
13359bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
13360 if (E->getSubExpr()->getType()->isComplexIntegerType()) {
13361 ComplexValue LV;
13362 if (!EvaluateComplex(E->getSubExpr(), LV, Info))
13363 return false;
13364 if (!LV.isComplexInt())
13365 return Error(E);
13366 return Success(LV.getComplexIntImag(), E);
13367 }
13368
13369 VisitIgnoredValue(E->getSubExpr());
13370 return Success(0, E);
13371}
13372
13373bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
13374 return Success(E->getPackLength(), E);
13375}
13376
13377bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
13378 return Success(E->getValue(), E);
13379}
13380
13381bool IntExprEvaluator::VisitConceptSpecializationExpr(
13382 const ConceptSpecializationExpr *E) {
13383 return Success(E->isSatisfied(), E);
13384}
13385
13386bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) {
13387 return Success(E->isSatisfied(), E);
13388}
13389
13390bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
13391 switch (E->getOpcode()) {
13392 default:
13393 // Invalid unary operators
13394 return Error(E);
13395 case UO_Plus:
13396 // The result is just the value.
13397 return Visit(E->getSubExpr());
13398 case UO_Minus: {
13399 if (!Visit(E->getSubExpr())) return false;
13400 if (!Result.isFixedPoint())
13401 return Error(E);
13402 bool Overflowed;
13403 APFixedPoint Negated = Result.getFixedPoint().negate(&Overflowed);
13404 if (Overflowed && !HandleOverflow(Info, E, Negated, E->getType()))
13405 return false;
13406 return Success(Negated, E);
13407 }
13408 case UO_LNot: {
13409 bool bres;
13410 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
13411 return false;
13412 return Success(!bres, E);
13413 }
13414 }
13415}
13416
13417bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) {
13418 const Expr *SubExpr = E->getSubExpr();
13419 QualType DestType = E->getType();
13420 assert(DestType->isFixedPointType() &&((void)0)
13421 "Expected destination type to be a fixed point type")((void)0);
13422 auto DestFXSema = Info.Ctx.getFixedPointSemantics(DestType);
13423
13424 switch (E->getCastKind()) {
13425 case CK_FixedPointCast: {
13426 APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SubExpr->getType()));
13427 if (!EvaluateFixedPoint(SubExpr, Src, Info))
13428 return false;
13429 bool Overflowed;
13430 APFixedPoint Result = Src.convert(DestFXSema, &Overflowed);
13431 if (Overflowed) {
13432 if (Info.checkingForUndefinedBehavior())
13433 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
13434 diag::warn_fixedpoint_constant_overflow)
13435 << Result.toString() << E->getType();
13436 if (!HandleOverflow(Info, E, Result, E->getType()))
13437 return false;
13438 }
13439 return Success(Result, E);
13440 }
13441 case CK_IntegralToFixedPoint: {
13442 APSInt Src;
13443 if (!EvaluateInteger(SubExpr, Src, Info))
13444 return false;
13445
13446 bool Overflowed;
13447 APFixedPoint IntResult = APFixedPoint::getFromIntValue(
13448 Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed);
13449
13450 if (Overflowed) {
13451 if (Info.checkingForUndefinedBehavior())
13452 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
13453 diag::warn_fixedpoint_constant_overflow)
13454 << IntResult.toString() << E->getType();
13455 if (!HandleOverflow(Info, E, IntResult, E->getType()))
13456 return false;
13457 }
13458
13459 return Success(IntResult, E);
13460 }
13461 case CK_FloatingToFixedPoint: {
13462 APFloat Src(0.0);
13463 if (!EvaluateFloat(SubExpr, Src, Info))
13464 return false;
13465
13466 bool Overflowed;
13467 APFixedPoint Result = APFixedPoint::getFromFloatValue(
13468 Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed);
13469
13470 if (Overflowed) {
13471 if (Info.checkingForUndefinedBehavior())
13472 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
13473 diag::warn_fixedpoint_constant_overflow)
13474 << Result.toString() << E->getType();
13475 if (!HandleOverflow(Info, E, Result, E->getType()))
13476 return false;
13477 }
13478
13479 return Success(Result, E);
13480 }
13481 case CK_NoOp:
13482 case CK_LValueToRValue:
13483 return ExprEvaluatorBaseTy::VisitCastExpr(E);
13484 default:
13485 return Error(E);
13486 }
13487}
13488
13489bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
13490 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
13491 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
13492
13493 const Expr *LHS = E->getLHS();
13494 const Expr *RHS = E->getRHS();
13495 FixedPointSemantics ResultFXSema =
13496 Info.Ctx.getFixedPointSemantics(E->getType());
13497
13498 APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHS->getType()));
13499 if (!EvaluateFixedPointOrInteger(LHS, LHSFX, Info))
13500 return false;
13501 APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHS->getType()));
13502 if (!EvaluateFixedPointOrInteger(RHS, RHSFX, Info))
13503 return false;
13504
13505 bool OpOverflow = false, ConversionOverflow = false;
13506 APFixedPoint Result(LHSFX.getSemantics());
13507 switch (E->getOpcode()) {
13508 case BO_Add: {
13509 Result = LHSFX.add(RHSFX, &OpOverflow)
13510 .convert(ResultFXSema, &ConversionOverflow);
13511 break;
13512 }
13513 case BO_Sub: {
13514 Result = LHSFX.sub(RHSFX, &OpOverflow)
13515 .convert(ResultFXSema, &ConversionOverflow);
13516 break;
13517 }
13518 case BO_Mul: {
13519 Result = LHSFX.mul(RHSFX, &OpOverflow)
13520 .convert(ResultFXSema, &ConversionOverflow);
13521 break;
13522 }
13523 case BO_Div: {
13524 if (RHSFX.getValue() == 0) {
13525 Info.FFDiag(E, diag::note_expr_divide_by_zero);
13526 return false;
13527 }
13528 Result = LHSFX.div(RHSFX, &OpOverflow)
13529 .convert(ResultFXSema, &ConversionOverflow);
13530 break;
13531 }
13532 case BO_Shl:
13533 case BO_Shr: {
13534 FixedPointSemantics LHSSema = LHSFX.getSemantics();
13535 llvm::APSInt RHSVal = RHSFX.getValue();
13536
13537 unsigned ShiftBW =
13538 LHSSema.getWidth() - (unsigned)LHSSema.hasUnsignedPadding();
13539 unsigned Amt = RHSVal.getLimitedValue(ShiftBW - 1);
13540 // Embedded-C 4.1.6.2.2:
13541 // The right operand must be nonnegative and less than the total number
13542 // of (nonpadding) bits of the fixed-point operand ...
13543 if (RHSVal.isNegative())
13544 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHSVal;
13545 else if (Amt != RHSVal)
13546 Info.CCEDiag(E, diag::note_constexpr_large_shift)
13547 << RHSVal << E->getType() << ShiftBW;
13548
13549 if (E->getOpcode() == BO_Shl)
13550 Result = LHSFX.shl(Amt, &OpOverflow);
13551 else
13552 Result = LHSFX.shr(Amt, &OpOverflow);
13553 break;
13554 }
13555 default:
13556 return false;
13557 }
13558 if (OpOverflow || ConversionOverflow) {
13559 if (Info.checkingForUndefinedBehavior())
13560 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
13561 diag::warn_fixedpoint_constant_overflow)
13562 << Result.toString() << E->getType();
13563 if (!HandleOverflow(Info, E, Result, E->getType()))
13564 return false;
13565 }
13566 return Success(Result, E);
13567}
13568
13569//===----------------------------------------------------------------------===//
13570// Float Evaluation
13571//===----------------------------------------------------------------------===//
13572
13573namespace {
13574class FloatExprEvaluator
13575 : public ExprEvaluatorBase<FloatExprEvaluator> {
13576 APFloat &Result;
13577public:
13578 FloatExprEvaluator(EvalInfo &info, APFloat &result)
13579 : ExprEvaluatorBaseTy(info), Result(result) {}
13580
13581 bool Success(const APValue &V, const Expr *e) {
13582 Result = V.getFloat();
13583 return true;
13584 }
13585
13586 bool ZeroInitialization(const Expr *E) {
13587 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
13588 return true;
13589 }
13590
13591 bool VisitCallExpr(const CallExpr *E);
13592
13593 bool VisitUnaryOperator(const UnaryOperator *E);
13594 bool VisitBinaryOperator(const BinaryOperator *E);
13595 bool VisitFloatingLiteral(const FloatingLiteral *E);
13596 bool VisitCastExpr(const CastExpr *E);
13597
13598 bool VisitUnaryReal(const UnaryOperator *E);
13599 bool VisitUnaryImag(const UnaryOperator *E);
13600
13601 // FIXME: Missing: array subscript of vector, member of vector
13602};
13603} // end anonymous namespace
13604
13605static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
13606 assert(!E->isValueDependent())((void)0);
13607 assert(E->isPRValue() && E->getType()->isRealFloatingType())((void)0);
13608 return FloatExprEvaluator(Info, Result).Visit(E);
13609}
13610
13611static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
13612 QualType ResultTy,
13613 const Expr *Arg,
13614 bool SNaN,
13615 llvm::APFloat &Result) {
13616 const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
13617 if (!S) return false;
13618
13619 const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
13620
13621 llvm::APInt fill;
13622
13623 // Treat empty strings as if they were zero.
13624 if (S->getString().empty())
13625 fill = llvm::APInt(32, 0);
13626 else if (S->getString().getAsInteger(0, fill))
13627 return false;
13628
13629 if (Context.getTargetInfo().isNan2008()) {
13630 if (SNaN)
13631 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
13632 else
13633 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
13634 } else {
13635 // Prior to IEEE 754-2008, architectures were allowed to choose whether
13636 // the first bit of their significand was set for qNaN or sNaN. MIPS chose
13637 // a different encoding to what became a standard in 2008, and for pre-
13638 // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as
13639 // sNaN. This is now known as "legacy NaN" encoding.
13640 if (SNaN)
13641 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
13642 else
13643 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
13644 }
13645
13646 return true;
13647}
13648
13649bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
13650 switch (E->getBuiltinCallee()) {
13651 default:
13652 return ExprEvaluatorBaseTy::VisitCallExpr(E);
13653
13654 case Builtin::BI__builtin_huge_val:
13655 case Builtin::BI__builtin_huge_valf:
13656 case Builtin::BI__builtin_huge_vall:
13657 case Builtin::BI__builtin_huge_valf128:
13658 case Builtin::BI__builtin_inf:
13659 case Builtin::BI__builtin_inff:
13660 case Builtin::BI__builtin_infl:
13661 case Builtin::BI__builtin_inff128: {
13662 const llvm::fltSemantics &Sem =
13663 Info.Ctx.getFloatTypeSemantics(E->getType());
13664 Result = llvm::APFloat::getInf(Sem);
13665 return true;
13666 }
13667
13668 case Builtin::BI__builtin_nans:
13669 case Builtin::BI__builtin_nansf:
13670 case Builtin::BI__builtin_nansl:
13671 case Builtin::BI__builtin_nansf128:
13672 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
13673 true, Result))
13674 return Error(E);
13675 return true;
13676
13677 case Builtin::BI__builtin_nan:
13678 case Builtin::BI__builtin_nanf:
13679 case Builtin::BI__builtin_nanl:
13680 case Builtin::BI__builtin_nanf128:
13681 // If this is __builtin_nan() turn this into a nan, otherwise we
13682 // can't constant fold it.
13683 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
13684 false, Result))
13685 return Error(E);
13686 return true;
13687
13688 case Builtin::BI__builtin_fabs:
13689 case Builtin::BI__builtin_fabsf:
13690 case Builtin::BI__builtin_fabsl:
13691 case Builtin::BI__builtin_fabsf128:
13692 // The C standard says "fabs raises no floating-point exceptions,
13693 // even if x is a signaling NaN. The returned value is independent of
13694 // the current rounding direction mode." Therefore constant folding can
13695 // proceed without regard to the floating point settings.
13696 // Reference, WG14 N2478 F.10.4.3
13697 if (!EvaluateFloat(E->getArg(0), Result, Info))
13698 return false;
13699
13700 if (Result.isNegative())
13701 Result.changeSign();
13702 return true;
13703
13704 case Builtin::BI__arithmetic_fence:
13705 return EvaluateFloat(E->getArg(0), Result, Info);
13706
13707 // FIXME: Builtin::BI__builtin_powi
13708 // FIXME: Builtin::BI__builtin_powif
13709 // FIXME: Builtin::BI__builtin_powil
13710
13711 case Builtin::BI__builtin_copysign:
13712 case Builtin::BI__builtin_copysignf:
13713 case Builtin::BI__builtin_copysignl:
13714 case Builtin::BI__builtin_copysignf128: {
13715 APFloat RHS(0.);
13716 if (!EvaluateFloat(E->getArg(0), Result, Info) ||
13717 !EvaluateFloat(E->getArg(1), RHS, Info))
13718 return false;
13719 Result.copySign(RHS);
13720 return true;
13721 }
13722 }
13723}
13724
13725bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
13726 if (E->getSubExpr()->getType()->isAnyComplexType()) {
13727 ComplexValue CV;
13728 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
13729 return false;
13730 Result = CV.FloatReal;
13731 return true;
13732 }
13733
13734 return Visit(E->getSubExpr());
13735}
13736
13737bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
13738 if (E->getSubExpr()->getType()->isAnyComplexType()) {
13739 ComplexValue CV;
13740 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
13741 return false;
13742 Result = CV.FloatImag;
13743 return true;
13744 }
13745
13746 VisitIgnoredValue(E->getSubExpr());
13747 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
13748 Result = llvm::APFloat::getZero(Sem);
13749 return true;
13750}
13751
13752bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
13753 switch (E->getOpcode()) {
13754 default: return Error(E);
13755 case UO_Plus:
13756 return EvaluateFloat(E->getSubExpr(), Result, Info);
13757 case UO_Minus:
13758 // In C standard, WG14 N2478 F.3 p4
13759 // "the unary - raises no floating point exceptions,
13760 // even if the operand is signalling."
13761 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
13762 return false;
13763 Result.changeSign();
13764 return true;
13765 }
13766}
13767
13768bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
13769 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
13770 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
13771
13772 APFloat RHS(0.0);
13773 bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
13774 if (!LHSOK && !Info.noteFailure())
13775 return false;
13776 return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK &&
13777 handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
13778}
13779
13780bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
13781 Result = E->getValue();
13782 return true;
13783}
13784
13785bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
13786 const Expr* SubExpr = E->getSubExpr();
13787
13788 switch (E->getCastKind()) {
13789 default:
13790 return ExprEvaluatorBaseTy::VisitCastExpr(E);
13791
13792 case CK_IntegralToFloating: {
13793 APSInt IntResult;
13794 const FPOptions FPO = E->getFPFeaturesInEffect(
13795 Info.Ctx.getLangOpts());
13796 return EvaluateInteger(SubExpr, IntResult, Info) &&
13797 HandleIntToFloatCast(Info, E, FPO, SubExpr->getType(),
13798 IntResult, E->getType(), Result);
13799 }
13800
13801 case CK_FixedPointToFloating: {
13802 APFixedPoint FixResult(Info.Ctx.getFixedPointSemantics(SubExpr->getType()));
13803 if (!EvaluateFixedPoint(SubExpr, FixResult, Info))
13804 return false;
13805 Result =
13806 FixResult.convertToFloat(Info.Ctx.getFloatTypeSemantics(E->getType()));
13807 return true;
13808 }
13809
13810 case CK_FloatingCast: {
13811 if (!Visit(SubExpr))
13812 return false;
13813 return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(),
13814 Result);
13815 }
13816
13817 case CK_FloatingComplexToReal: {
13818 ComplexValue V;
13819 if (!EvaluateComplex(SubExpr, V, Info))
13820 return false;
13821 Result = V.getComplexFloatReal();
13822 return true;
13823 }
13824 }
13825}
13826
13827//===----------------------------------------------------------------------===//
13828// Complex Evaluation (for float and integer)
13829//===----------------------------------------------------------------------===//
13830
13831namespace {
13832class ComplexExprEvaluator
13833 : public ExprEvaluatorBase<ComplexExprEvaluator> {
13834 ComplexValue &Result;
13835
13836public:
13837 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
13838 : ExprEvaluatorBaseTy(info), Result(Result) {}
13839
13840 bool Success(const APValue &V, const Expr *e) {
13841 Result.setFrom(V);
13842 return true;
13843 }
13844
13845 bool ZeroInitialization(const Expr *E);
13846
13847 //===--------------------------------------------------------------------===//
13848 // Visitor Methods
13849 //===--------------------------------------------------------------------===//
13850
13851 bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
13852 bool VisitCastExpr(const CastExpr *E);
13853 bool VisitBinaryOperator(const BinaryOperator *E);
13854 bool VisitUnaryOperator(const UnaryOperator *E);
13855 bool VisitInitListExpr(const InitListExpr *E);
13856 bool VisitCallExpr(const CallExpr *E);
13857};
13858} // end anonymous namespace
13859
13860static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
13861 EvalInfo &Info) {
13862 assert(!E->isValueDependent())((void)0);
13863 assert(E->isPRValue() && E->getType()->isAnyComplexType())((void)0);
13864 return ComplexExprEvaluator(Info, Result).Visit(E);
13865}
13866
13867bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
13868 QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
13869 if (ElemTy->isRealFloatingType()) {
13870 Result.makeComplexFloat();
13871 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
13872 Result.FloatReal = Zero;
13873 Result.FloatImag = Zero;
13874 } else {
13875 Result.makeComplexInt();
13876 APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
13877 Result.IntReal = Zero;
13878 Result.IntImag = Zero;
13879 }
13880 return true;
13881}
13882
13883bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
13884 const Expr* SubExpr = E->getSubExpr();
13885
13886 if (SubExpr->getType()->isRealFloatingType()) {
13887 Result.makeComplexFloat();
13888 APFloat &Imag = Result.FloatImag;
13889 if (!EvaluateFloat(SubExpr, Imag, Info))
13890 return false;
13891
13892 Result.FloatReal = APFloat(Imag.getSemantics());
13893 return true;
13894 } else {
13895 assert(SubExpr->getType()->isIntegerType() &&((void)0)
13896 "Unexpected imaginary literal.")((void)0);
13897
13898 Result.makeComplexInt();
13899 APSInt &Imag = Result.IntImag;
13900 if (!EvaluateInteger(SubExpr, Imag, Info))
13901 return false;
13902
13903 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
13904 return true;
13905 }
13906}
13907
13908bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
13909
13910 switch (E->getCastKind()) {
13911 case CK_BitCast:
13912 case CK_BaseToDerived:
13913 case CK_DerivedToBase:
13914 case CK_UncheckedDerivedToBase:
13915 case CK_Dynamic:
13916 case CK_ToUnion:
13917 case CK_ArrayToPointerDecay:
13918 case CK_FunctionToPointerDecay:
13919 case CK_NullToPointer:
13920 case CK_NullToMemberPointer:
13921 case CK_BaseToDerivedMemberPointer:
13922 case CK_DerivedToBaseMemberPointer:
13923 case CK_MemberPointerToBoolean:
13924 case CK_ReinterpretMemberPointer:
13925 case CK_ConstructorConversion:
13926 case CK_IntegralToPointer:
13927 case CK_PointerToIntegral:
13928 case CK_PointerToBoolean:
13929 case CK_ToVoid:
13930 case CK_VectorSplat:
13931 case CK_IntegralCast:
13932 case CK_BooleanToSignedIntegral:
13933 case CK_IntegralToBoolean:
13934 case CK_IntegralToFloating:
13935 case CK_FloatingToIntegral:
13936 case CK_FloatingToBoolean:
13937 case CK_FloatingCast:
13938 case CK_CPointerToObjCPointerCast:
13939 case CK_BlockPointerToObjCPointerCast:
13940 case CK_AnyPointerToBlockPointerCast:
13941 case CK_ObjCObjectLValueCast:
13942 case CK_FloatingComplexToReal:
13943 case CK_FloatingComplexToBoolean:
13944 case CK_IntegralComplexToReal:
13945 case CK_IntegralComplexToBoolean:
13946 case CK_ARCProduceObject:
13947 case CK_ARCConsumeObject:
13948 case CK_ARCReclaimReturnedObject:
13949 case CK_ARCExtendBlockObject:
13950 case CK_CopyAndAutoreleaseBlockObject:
13951 case CK_BuiltinFnToFnPtr:
13952 case CK_ZeroToOCLOpaqueType:
13953 case CK_NonAtomicToAtomic:
13954 case CK_AddressSpaceConversion:
13955 case CK_IntToOCLSampler:
13956 case CK_FloatingToFixedPoint:
13957 case CK_FixedPointToFloating:
13958 case CK_FixedPointCast:
13959 case CK_FixedPointToBoolean:
13960 case CK_FixedPointToIntegral:
13961 case CK_IntegralToFixedPoint:
13962 case CK_MatrixCast:
13963 llvm_unreachable("invalid cast kind for complex value")__builtin_unreachable();
13964
13965 case CK_LValueToRValue:
13966 case CK_AtomicToNonAtomic:
13967 case CK_NoOp:
13968 case CK_LValueToRValueBitCast:
13969 return ExprEvaluatorBaseTy::VisitCastExpr(E);
13970
13971 case CK_Dependent:
13972 case CK_LValueBitCast:
13973 case CK_UserDefinedConversion:
13974 return Error(E);
13975
13976 case CK_FloatingRealToComplex: {
13977 APFloat &Real = Result.FloatReal;
13978 if (!EvaluateFloat(E->getSubExpr(), Real, Info))
13979 return false;
13980
13981 Result.makeComplexFloat();
13982 Result.FloatImag = APFloat(Real.getSemantics());
13983 return true;
13984 }
13985
13986 case CK_FloatingComplexCast: {
13987 if (!Visit(E->getSubExpr()))
13988 return false;
13989
13990 QualType To = E->getType()->castAs<ComplexType>()->getElementType();
13991 QualType From
13992 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
13993
13994 return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
13995 HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
13996 }
13997
13998 case CK_FloatingComplexToIntegralComplex: {
13999 if (!Visit(E->getSubExpr()))
14000 return false;
14001
14002 QualType To = E->getType()->castAs<ComplexType>()->getElementType();
14003 QualType From
14004 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
14005 Result.makeComplexInt();
14006 return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
14007 To, Result.IntReal) &&
14008 HandleFloatToIntCast(Info, E, From, Result.FloatImag,
14009 To, Result.IntImag);
14010 }
14011
14012 case CK_IntegralRealToComplex: {
14013 APSInt &Real = Result.IntReal;
14014 if (!EvaluateInteger(E->getSubExpr(), Real, Info))
14015 return false;
14016
14017 Result.makeComplexInt();
14018 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
14019 return true;
14020 }
14021
14022 case CK_IntegralComplexCast: {
14023 if (!Visit(E->getSubExpr()))
14024 return false;
14025
14026 QualType To = E->getType()->castAs<ComplexType>()->getElementType();
14027 QualType From
14028 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
14029
14030 Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
14031 Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
14032 return true;
14033 }
14034
14035 case CK_IntegralComplexToFloatingComplex: {
14036 if (!Visit(E->getSubExpr()))
14037 return false;
14038
14039 const FPOptions FPO = E->getFPFeaturesInEffect(
14040 Info.Ctx.getLangOpts());
14041 QualType To = E->getType()->castAs<ComplexType>()->getElementType();
14042 QualType From
14043 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
14044 Result.makeComplexFloat();
14045 return HandleIntToFloatCast(Info, E, FPO, From, Result.IntReal,
14046 To, Result.FloatReal) &&
14047 HandleIntToFloatCast(Info, E, FPO, From, Result.IntImag,
14048 To, Result.FloatImag);
14049 }
14050 }
14051
14052 llvm_unreachable("unknown cast resulting in complex value")__builtin_unreachable();
14053}
14054
14055bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
14056 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
14057 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
14058
14059 // Track whether the LHS or RHS is real at the type system level. When this is
14060 // the case we can simplify our evaluation strategy.
14061 bool LHSReal = false, RHSReal = false;
14062
14063 bool LHSOK;
14064 if (E->getLHS()->getType()->isRealFloatingType()) {
14065 LHSReal = true;
14066 APFloat &Real = Result.FloatReal;
14067 LHSOK = EvaluateFloat(E->getLHS(), Real, Info);
14068 if (LHSOK) {
14069 Result.makeComplexFloat();
14070 Result.FloatImag = APFloat(Real.getSemantics());
14071 }
14072 } else {
14073 LHSOK = Visit(E->getLHS());
14074 }
14075 if (!LHSOK && !Info.noteFailure())
14076 return false;
14077
14078 ComplexValue RHS;
14079 if (E->getRHS()->getType()->isRealFloatingType()) {
14080 RHSReal = true;
14081 APFloat &Real = RHS.FloatReal;
14082 if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK)
14083 return false;
14084 RHS.makeComplexFloat();
14085 RHS.FloatImag = APFloat(Real.getSemantics());
14086 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
14087 return false;
14088
14089 assert(!(LHSReal && RHSReal) &&((void)0)
14090 "Cannot have both operands of a complex operation be real.")((void)0);
14091 switch (E->getOpcode()) {
14092 default: return Error(E);
14093 case BO_Add:
14094 if (Result.isComplexFloat()) {
14095 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
14096 APFloat::rmNearestTiesToEven);
14097 if (LHSReal)
14098 Result.getComplexFloatImag() = RHS.getComplexFloatImag();
14099 else if (!RHSReal)
14100 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
14101 APFloat::rmNearestTiesToEven);
14102 } else {
14103 Result.getComplexIntReal() += RHS.getComplexIntReal();
14104 Result.getComplexIntImag() += RHS.getComplexIntImag();
14105 }
14106 break;
14107 case BO_Sub:
14108 if (Result.isComplexFloat()) {
14109 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
14110 APFloat::rmNearestTiesToEven);
14111 if (LHSReal) {
14112 Result.getComplexFloatImag() = RHS.getComplexFloatImag();
14113 Result.getComplexFloatImag().changeSign();
14114 } else if (!RHSReal) {
14115 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
14116 APFloat::rmNearestTiesToEven);
14117 }
14118 } else {
14119 Result.getComplexIntReal() -= RHS.getComplexIntReal();
14120 Result.getComplexIntImag() -= RHS.getComplexIntImag();
14121 }
14122 break;
14123 case BO_Mul:
14124 if (Result.isComplexFloat()) {
14125 // This is an implementation of complex multiplication according to the
14126 // constraints laid out in C11 Annex G. The implementation uses the
14127 // following naming scheme:
14128 // (a + ib) * (c + id)
14129 ComplexValue LHS = Result;
14130 APFloat &A = LHS.getComplexFloatReal();
14131 APFloat &B = LHS.getComplexFloatImag();
14132 APFloat &C = RHS.getComplexFloatReal();
14133 APFloat &D = RHS.getComplexFloatImag();
14134 APFloat &ResR = Result.getComplexFloatReal();
14135 APFloat &ResI = Result.getComplexFloatImag();
14136 if (LHSReal) {
14137 assert(!RHSReal && "Cannot have two real operands for a complex op!")((void)0);
14138 ResR = A * C;
14139 ResI = A * D;
14140 } else if (RHSReal) {
14141 ResR = C * A;
14142 ResI = C * B;
14143 } else {
14144 // In the fully general case, we need to handle NaNs and infinities
14145 // robustly.
14146 APFloat AC = A * C;
14147 APFloat BD = B * D;
14148 APFloat AD = A * D;
14149 APFloat BC = B * C;
14150 ResR = AC - BD;
14151 ResI = AD + BC;
14152 if (ResR.isNaN() && ResI.isNaN()) {
14153 bool Recalc = false;
14154 if (A.isInfinity() || B.isInfinity()) {
14155 A = APFloat::copySign(
14156 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
14157 B = APFloat::copySign(
14158 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
14159 if (C.isNaN())
14160 C = APFloat::copySign(APFloat(C.getSemantics()), C);
14161 if (D.isNaN())
14162 D = APFloat::copySign(APFloat(D.getSemantics()), D);
14163 Recalc = true;
14164 }
14165 if (C.isInfinity() || D.isInfinity()) {
14166 C = APFloat::copySign(
14167 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
14168 D = APFloat::copySign(
14169 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
14170 if (A.isNaN())
14171 A = APFloat::copySign(APFloat(A.getSemantics()), A);
14172 if (B.isNaN())
14173 B = APFloat::copySign(APFloat(B.getSemantics()), B);
14174 Recalc = true;
14175 }
14176 if (!Recalc && (AC.isInfinity() || BD.isInfinity() ||
14177 AD.isInfinity() || BC.isInfinity())) {
14178 if (A.isNaN())
14179 A = APFloat::copySign(APFloat(A.getSemantics()), A);
14180 if (B.isNaN())
14181 B = APFloat::copySign(APFloat(B.getSemantics()), B);
14182 if (C.isNaN())
14183 C = APFloat::copySign(APFloat(C.getSemantics()), C);
14184 if (D.isNaN())
14185 D = APFloat::copySign(APFloat(D.getSemantics()), D);
14186 Recalc = true;
14187 }
14188 if (Recalc) {
14189 ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
14190 ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
14191 }
14192 }
14193 }
14194 } else {
14195 ComplexValue LHS = Result;
14196 Result.getComplexIntReal() =
14197 (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
14198 LHS.getComplexIntImag() * RHS.getComplexIntImag());
14199 Result.getComplexIntImag() =
14200 (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
14201 LHS.getComplexIntImag() * RHS.getComplexIntReal());
14202 }
14203 break;
14204 case BO_Div:
14205 if (Result.isComplexFloat()) {
14206 // This is an implementation of complex division according to the
14207 // constraints laid out in C11 Annex G. The implementation uses the
14208 // following naming scheme:
14209 // (a + ib) / (c + id)
14210 ComplexValue LHS = Result;
14211 APFloat &A = LHS.getComplexFloatReal();
14212 APFloat &B = LHS.getComplexFloatImag();
14213 APFloat &C = RHS.getComplexFloatReal();
14214 APFloat &D = RHS.getComplexFloatImag();
14215 APFloat &ResR = Result.getComplexFloatReal();
14216 APFloat &ResI = Result.getComplexFloatImag();
14217 if (RHSReal) {
14218 ResR = A / C;
14219 ResI = B / C;
14220 } else {
14221 if (LHSReal) {
14222 // No real optimizations we can do here, stub out with zero.
14223 B = APFloat::getZero(A.getSemantics());
14224 }
14225 int DenomLogB = 0;
14226 APFloat MaxCD = maxnum(abs(C), abs(D));
14227 if (MaxCD.isFinite()) {
14228 DenomLogB = ilogb(MaxCD);
14229 C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
14230 D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
14231 }
14232 APFloat Denom = C * C + D * D;
14233 ResR = scalbn((A * C + B * D) / Denom, -DenomLogB,
14234 APFloat::rmNearestTiesToEven);
14235 ResI = scalbn((B * C - A * D) / Denom, -DenomLogB,
14236 APFloat::rmNearestTiesToEven);
14237 if (ResR.isNaN() && ResI.isNaN()) {
14238 if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) {
14239 ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
14240 ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
14241 } else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() &&
14242 D.isFinite()) {
14243 A = APFloat::copySign(
14244 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
14245 B = APFloat::copySign(
14246 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
14247 ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
14248 ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
14249 } else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) {
14250 C = APFloat::copySign(
14251 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
14252 D = APFloat::copySign(
14253 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
14254 ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
14255 ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
14256 }
14257 }
14258 }
14259 } else {
14260 if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0)
14261 return Error(E, diag::note_expr_divide_by_zero);
14262
14263 ComplexValue LHS = Result;
14264 APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
14265 RHS.getComplexIntImag() * RHS.getComplexIntImag();
14266 Result.getComplexIntReal() =
14267 (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
14268 LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
14269 Result.getComplexIntImag() =
14270 (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
14271 LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
14272 }
14273 break;
14274 }
14275
14276 return true;
14277}
14278
14279bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
14280 // Get the operand value into 'Result'.
14281 if (!Visit(E->getSubExpr()))
14282 return false;
14283
14284 switch (E->getOpcode()) {
14285 default:
14286 return Error(E);
14287 case UO_Extension:
14288 return true;
14289 case UO_Plus:
14290 // The result is always just the subexpr.
14291 return true;
14292 case UO_Minus:
14293 if (Result.isComplexFloat()) {
14294 Result.getComplexFloatReal().changeSign();
14295 Result.getComplexFloatImag().changeSign();
14296 }
14297 else {
14298 Result.getComplexIntReal() = -Result.getComplexIntReal();
14299 Result.getComplexIntImag() = -Result.getComplexIntImag();
14300 }
14301 return true;
14302 case UO_Not:
14303 if (Result.isComplexFloat())
14304 Result.getComplexFloatImag().changeSign();
14305 else
14306 Result.getComplexIntImag() = -Result.getComplexIntImag();
14307 return true;
14308 }
14309}
14310
14311bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
14312 if (E->getNumInits() == 2) {
14313 if (E->getType()->isComplexType()) {
14314 Result.makeComplexFloat();
14315 if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
14316 return false;
14317 if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
14318 return false;
14319 } else {
14320 Result.makeComplexInt();
14321 if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
14322 return false;
14323 if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
14324 return false;
14325 }
14326 return true;
14327 }
14328 return ExprEvaluatorBaseTy::VisitInitListExpr(E);
14329}
14330
14331bool ComplexExprEvaluator::VisitCallExpr(const CallExpr *E) {
14332 switch (E->getBuiltinCallee()) {
14333 case Builtin::BI__builtin_complex:
14334 Result.makeComplexFloat();
14335 if (!EvaluateFloat(E->getArg(0), Result.FloatReal, Info))
14336 return false;
14337 if (!EvaluateFloat(E->getArg(1), Result.FloatImag, Info))
14338 return false;
14339 return true;
14340
14341 default:
14342 break;
14343 }
14344
14345 return ExprEvaluatorBaseTy::VisitCallExpr(E);
14346}
14347
14348//===----------------------------------------------------------------------===//
14349// Atomic expression evaluation, essentially just handling the NonAtomicToAtomic
14350// implicit conversion.
14351//===----------------------------------------------------------------------===//
14352
14353namespace {
14354class AtomicExprEvaluator :
14355 public ExprEvaluatorBase<AtomicExprEvaluator> {
14356 const LValue *This;
14357 APValue &Result;
14358public:
14359 AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result)
14360 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
14361
14362 bool Success(const APValue &V, const Expr *E) {
14363 Result = V;
14364 return true;
14365 }
14366
14367 bool ZeroInitialization(const Expr *E) {
14368 ImplicitValueInitExpr VIE(
14369 E->getType()->castAs<AtomicType>()->getValueType());
14370 // For atomic-qualified class (and array) types in C++, initialize the
14371 // _Atomic-wrapped subobject directly, in-place.
14372 return This ? EvaluateInPlace(Result, Info, *This, &VIE)
14373 : Evaluate(Result, Info, &VIE);
14374 }
14375
14376 bool VisitCastExpr(const CastExpr *E) {
14377 switch (E->getCastKind()) {
14378 default:
14379 return ExprEvaluatorBaseTy::VisitCastExpr(E);
14380 case CK_NonAtomicToAtomic:
14381 return This ? EvaluateInPlace(Result, Info, *This, E->getSubExpr())
14382 : Evaluate(Result, Info, E->getSubExpr());
14383 }
14384 }
14385};
14386} // end anonymous namespace
14387
14388static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
14389 EvalInfo &Info) {
14390 assert(!E->isValueDependent())((void)0);
14391 assert(E->isPRValue() && E->getType()->isAtomicType())((void)0);
14392 return AtomicExprEvaluator(Info, This, Result).Visit(E);
14393}
14394
14395//===----------------------------------------------------------------------===//
14396// Void expression evaluation, primarily for a cast to void on the LHS of a
14397// comma operator
14398//===----------------------------------------------------------------------===//
14399
14400namespace {
14401class VoidExprEvaluator
14402 : public ExprEvaluatorBase<VoidExprEvaluator> {
14403public:
14404 VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
14405
14406 bool Success(const APValue &V, const Expr *e) { return true; }
14407
14408 bool ZeroInitialization(const Expr *E) { return true; }
14409
14410 bool VisitCastExpr(const CastExpr *E) {
14411 switch (E->getCastKind()) {
14412 default:
14413 return ExprEvaluatorBaseTy::VisitCastExpr(E);
14414 case CK_ToVoid:
14415 VisitIgnoredValue(E->getSubExpr());
14416 return true;
14417 }
14418 }
14419
14420 bool VisitCallExpr(const CallExpr *E) {
14421 switch (E->getBuiltinCallee()) {
14422 case Builtin::BI__assume:
14423 case Builtin::BI__builtin_assume:
14424 // The argument is not evaluated!
14425 return true;
14426
14427 case Builtin::BI__builtin_operator_delete:
14428 return HandleOperatorDeleteCall(Info, E);
14429
14430 default:
14431 break;
14432 }
14433
14434 return ExprEvaluatorBaseTy::VisitCallExpr(E);
14435 }
14436
14437 bool VisitCXXDeleteExpr(const CXXDeleteExpr *E);
14438};
14439} // end anonymous namespace
14440
14441bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
14442 // We cannot speculatively evaluate a delete expression.
14443 if (Info.SpeculativeEvaluationDepth)
14444 return false;
14445
14446 FunctionDecl *OperatorDelete = E->getOperatorDelete();
14447 if (!OperatorDelete->isReplaceableGlobalAllocationFunction()) {
14448 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
14449 << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;
14450 return false;
14451 }
14452
14453 const Expr *Arg = E->getArgument();
14454
14455 LValue Pointer;
14456 if (!EvaluatePointer(Arg, Pointer, Info))
14457 return false;
14458 if (Pointer.Designator.Invalid)
14459 return false;
14460
14461 // Deleting a null pointer has no effect.
14462 if (Pointer.isNullPointer()) {
14463 // This is the only case where we need to produce an extension warning:
14464 // the only other way we can succeed is if we find a dynamic allocation,
14465 // and we will have warned when we allocated it in that case.
14466 if (!Info.getLangOpts().CPlusPlus20)
14467 Info.CCEDiag(E, diag::note_constexpr_new);
14468 return true;
14469 }
14470
14471 Optional<DynAlloc *> Alloc = CheckDeleteKind(
14472 Info, E, Pointer, E->isArrayForm() ? DynAlloc::ArrayNew : DynAlloc::New);
14473 if (!Alloc)
14474 return false;
14475 QualType AllocType = Pointer.Base.getDynamicAllocType();
14476
14477 // For the non-array case, the designator must be empty if the static type
14478 // does not have a virtual destructor.
14479 if (!E->isArrayForm() && Pointer.Designator.Entries.size() != 0 &&
14480 !hasVirtualDestructor(Arg->getType()->getPointeeType())) {
14481 Info.FFDiag(E, diag::note_constexpr_delete_base_nonvirt_dtor)
14482 << Arg->getType()->getPointeeType() << AllocType;
14483 return false;
14484 }
14485
14486 // For a class type with a virtual destructor, the selected operator delete
14487 // is the one looked up when building the destructor.
14488 if (!E->isArrayForm() && !E->isGlobalDelete()) {
14489 const FunctionDecl *VirtualDelete = getVirtualOperatorDelete(AllocType);
14490 if (VirtualDelete &&
14491 !VirtualDelete->isReplaceableGlobalAllocationFunction()) {
14492 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
14493 << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;
14494 return false;
14495 }
14496 }
14497
14498 if (!HandleDestruction(Info, E->getExprLoc(), Pointer.getLValueBase(),
14499 (*Alloc)->Value, AllocType))
14500 return false;
14501
14502 if (!Info.HeapAllocs.erase(Pointer.Base.dyn_cast<DynamicAllocLValue>())) {
14503 // The element was already erased. This means the destructor call also
14504 // deleted the object.
14505 // FIXME: This probably results in undefined behavior before we get this
14506 // far, and should be diagnosed elsewhere first.
14507 Info.FFDiag(E, diag::note_constexpr_double_delete);
14508 return false;
14509 }
14510
14511 return true;
14512}
14513
14514static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
14515 assert(!E->isValueDependent())((void)0);
14516 assert(E->isPRValue() && E->getType()->isVoidType())((void)0);
14517 return VoidExprEvaluator(Info).Visit(E);
14518}
14519
14520//===----------------------------------------------------------------------===//
14521// Top level Expr::EvaluateAsRValue method.
14522//===----------------------------------------------------------------------===//
14523
14524static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
14525 assert(!E->isValueDependent())((void)0);
14526 // In C, function designators are not lvalues, but we evaluate them as if they
14527 // are.
14528 QualType T = E->getType();
14529 if (E->isGLValue() || T->isFunctionType()) {
14530 LValue LV;
14531 if (!EvaluateLValue(E, LV, Info))
14532 return false;
14533 LV.moveInto(Result);
14534 } else if (T->isVectorType()) {
14535 if (!EvaluateVector(E, Result, Info))
14536 return false;
14537 } else if (T->isIntegralOrEnumerationType()) {
14538 if (!IntExprEvaluator(Info, Result).Visit(E))
14539 return false;
14540 } else if (T->hasPointerRepresentation()) {
14541 LValue LV;
14542 if (!EvaluatePointer(E, LV, Info))
14543 return false;
14544 LV.moveInto(Result);
14545 } else if (T->isRealFloatingType()) {
14546 llvm::APFloat F(0.0);
14547 if (!EvaluateFloat(E, F, Info))
14548 return false;
14549 Result = APValue(F);
14550 } else if (T->isAnyComplexType()) {
14551 ComplexValue C;
14552 if (!EvaluateComplex(E, C, Info))
14553 return false;
14554 C.moveInto(Result);
14555 } else if (T->isFixedPointType()) {
14556 if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false;
14557 } else if (T->isMemberPointerType()) {
14558 MemberPtr P;
14559 if (!EvaluateMemberPointer(E, P, Info))
14560 return false;
14561 P.moveInto(Result);
14562 return true;
14563 } else if (T->isArrayType()) {
14564 LValue LV;
14565 APValue &Value =
14566 Info.CurrentCall->createTemporary(E, T, ScopeKind::FullExpression, LV);
14567 if (!EvaluateArray(E, LV, Value, Info))
14568 return false;
14569 Result = Value;
14570 } else if (T->isRecordType()) {
14571 LValue LV;
14572 APValue &Value =
14573 Info.CurrentCall->createTemporary(E, T, ScopeKind::FullExpression, LV);
14574 if (!EvaluateRecord(E, LV, Value, Info))
14575 return false;
14576 Result = Value;
14577 } else if (T->isVoidType()) {
14578 if (!Info.getLangOpts().CPlusPlus11)
14579 Info.CCEDiag(E, diag::note_constexpr_nonliteral)
14580 << E->getType();
14581 if (!EvaluateVoid(E, Info))
14582 return false;
14583 } else if (T->isAtomicType()) {
14584 QualType Unqual = T.getAtomicUnqualifiedType();
14585 if (Unqual->isArrayType() || Unqual->isRecordType()) {
14586 LValue LV;
14587 APValue &Value = Info.CurrentCall->createTemporary(
14588 E, Unqual, ScopeKind::FullExpression, LV);
14589 if (!EvaluateAtomic(E, &LV, Value, Info))
14590 return false;
14591 } else {
14592 if (!EvaluateAtomic(E, nullptr, Result, Info))
14593 return false;
14594 }
14595 } else if (Info.getLangOpts().CPlusPlus11) {
14596 Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
14597 return false;
14598 } else {
14599 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
14600 return false;
14601 }
14602
14603 return true;
14604}
14605
14606/// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some
14607/// cases, the in-place evaluation is essential, since later initializers for
14608/// an object can indirectly refer to subobjects which were initialized earlier.
14609static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
14610 const Expr *E, bool AllowNonLiteralTypes) {
14611 assert(!E->isValueDependent())((void)0);
14612
14613 if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
14614 return false;
14615
14616 if (E->isPRValue()) {
14617 // Evaluate arrays and record types in-place, so that later initializers can
14618 // refer to earlier-initialized members of the object.
14619 QualType T = E->getType();
14620 if (T->isArrayType())
14621 return EvaluateArray(E, This, Result, Info);
14622 else if (T->isRecordType())
14623 return EvaluateRecord(E, This, Result, Info);
14624 else if (T->isAtomicType()) {
14625 QualType Unqual = T.getAtomicUnqualifiedType();
14626 if (Unqual->isArrayType() || Unqual->isRecordType())
14627 return EvaluateAtomic(E, &This, Result, Info);
14628 }
14629 }
14630
14631 // For any other type, in-place evaluation is unimportant.
14632 return Evaluate(Result, Info, E);
14633}
14634
14635/// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
14636/// lvalue-to-rvalue cast if it is an lvalue.
14637static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
14638 assert(!E->isValueDependent())((void)0);
14639 if (Info.EnableNewConstInterp) {
14640 if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result))
14641 return false;
14642 } else {
14643 if (E->getType().isNull())
14644 return false;
14645
14646 if (!CheckLiteralType(Info, E))
14647 return false;
14648
14649 if (!::Evaluate(Result, Info, E))
14650 return false;
14651
14652 if (E->isGLValue()) {
14653 LValue LV;
14654 LV.setFrom(Info.Ctx, Result);
14655 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
14656 return false;
14657 }
14658 }
14659
14660 // Check this core constant expression is a constant expression.
14661 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result,
14662 ConstantExprKind::Normal) &&
14663 CheckMemoryLeaks(Info);
14664}
14665
14666static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
14667 const ASTContext &Ctx, bool &IsConst) {
14668 // Fast-path evaluations of integer literals, since we sometimes see files
14669 // containing vast quantities of these.
14670 if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
14671 Result.Val = APValue(APSInt(L->getValue(),
14672 L->getType()->isUnsignedIntegerType()));
14673 IsConst = true;
14674 return true;
14675 }
14676
14677 // This case should be rare, but we need to check it before we check on
14678 // the type below.
14679 if (Exp->getType().isNull()) {
14680 IsConst = false;
14681 return true;
14682 }
14683
14684 // FIXME: Evaluating values of large array and record types can cause
14685 // performance problems. Only do so in C++11 for now.
14686 if (Exp->isPRValue() &&
14687 (Exp->getType()->isArrayType() || Exp->getType()->isRecordType()) &&
14688 !Ctx.getLangOpts().CPlusPlus11) {
14689 IsConst = false;
14690 return true;
14691 }
14692 return false;
14693}
14694
14695static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
14696 Expr::SideEffectsKind SEK) {
14697 return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
14698 (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
14699}
14700
14701static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
14702 const ASTContext &Ctx, EvalInfo &Info) {
14703 assert(!E->isValueDependent())((void)0);
14704 bool IsConst;
14705 if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
14706 return IsConst;
14707
14708 return EvaluateAsRValue(Info, E, Result.Val);
14709}
14710
14711static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
14712 const ASTContext &Ctx,
14713 Expr::SideEffectsKind AllowSideEffects,
14714 EvalInfo &Info) {
14715 assert(!E->isValueDependent())((void)0);
14716 if (!E->getType()->isIntegralOrEnumerationType())
14717 return false;
14718
14719 if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) ||
14720 !ExprResult.Val.isInt() ||
14721 hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
14722 return false;
14723
14724 return true;
14725}
14726
14727static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
14728 const ASTContext &Ctx,
14729 Expr::SideEffectsKind AllowSideEffects,
14730 EvalInfo &Info) {
14731 assert(!E->isValueDependent())((void)0);
14732 if (!E->getType()->isFixedPointType())
14733 return false;
14734
14735 if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info))
14736 return false;
14737
14738 if (!ExprResult.Val.isFixedPoint() ||
14739 hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
14740 return false;
14741
14742 return true;
14743}
14744
14745/// EvaluateAsRValue - Return true if this is a constant which we can fold using
14746/// any crazy technique (that has nothing to do with language standards) that
14747/// we want to. If this function returns true, it returns the folded constant
14748/// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
14749/// will be applied to the result.
14750bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,
14751 bool InConstantContext) const {
14752 assert(!isValueDependent() &&((void)0)
14753 "Expression evaluator can't be called on a dependent expression.")((void)0);
14754 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
14755 Info.InConstantContext = InConstantContext;
14756 return ::EvaluateAsRValue(this, Result, Ctx, Info);
14757}
14758
14759bool Expr::EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
14760 bool InConstantContext) const {
14761 assert(!isValueDependent() &&((void)0)
14762 "Expression evaluator can't be called on a dependent expression.")((void)0);
14763 EvalResult Scratch;
14764 return EvaluateAsRValue(Scratch, Ctx, InConstantContext) &&
14765 HandleConversionToBool(Scratch.Val, Result);
14766}
14767
14768bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
14769 SideEffectsKind AllowSideEffects,
14770 bool InConstantContext) const {
14771 assert(!isValueDependent() &&((void)0)
14772 "Expression evaluator can't be called on a dependent expression.")((void)0);
14773 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
14774 Info.InConstantContext = InConstantContext;
14775 return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
14776}
14777
14778bool Expr::EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
14779 SideEffectsKind AllowSideEffects,
14780 bool InConstantContext) const {
14781 assert(!isValueDependent() &&((void)0)
14782 "Expression evaluator can't be called on a dependent expression.")((void)0);
14783 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
14784 Info.InConstantContext = InConstantContext;
14785 return ::EvaluateAsFixedPoint(this, Result, Ctx, AllowSideEffects, Info);
14786}
14787
14788bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
14789 SideEffectsKind AllowSideEffects,
14790 bool InConstantContext) const {
14791 assert(!isValueDependent() &&((void)0)
14792 "Expression evaluator can't be called on a dependent expression.")((void)0);
14793
14794 if (!getType()->isRealFloatingType())
14795 return false;
14796
14797 EvalResult ExprResult;
14798 if (!EvaluateAsRValue(ExprResult, Ctx, InConstantContext) ||
14799 !ExprResult.Val.isFloat() ||
14800 hasUnacceptableSideEffect(ExprResult, AllowSideEffects))
14801 return false;
14802
14803 Result = ExprResult.Val.getFloat();
14804 return true;
14805}
14806
14807bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
14808 bool InConstantContext) const {
14809 assert(!isValueDependent() &&((void)0)
14810 "Expression evaluator can't be called on a dependent expression.")((void)0);
14811
14812 EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
14813 Info.InConstantContext = InConstantContext;
14814 LValue LV;
14815 CheckedTemporaries CheckedTemps;
14816 if (!EvaluateLValue(this, LV, Info) || !Info.discardCleanups() ||
14817 Result.HasSideEffects ||
14818 !CheckLValueConstantExpression(Info, getExprLoc(),
14819 Ctx.getLValueReferenceType(getType()), LV,
14820 ConstantExprKind::Normal, CheckedTemps))
14821 return false;
14822
14823 LV.moveInto(Result.Val);
14824 return true;
14825}
14826
14827static bool EvaluateDestruction(const ASTContext &Ctx, APValue::LValueBase Base,
14828 APValue DestroyedValue, QualType Type,
14829 SourceLocation Loc, Expr::EvalStatus &EStatus,
14830 bool IsConstantDestruction) {
14831 EvalInfo Info(Ctx, EStatus,
14832 IsConstantDestruction ? EvalInfo::EM_ConstantExpression
14833 : EvalInfo::EM_ConstantFold);
14834 Info.setEvaluatingDecl(Base, DestroyedValue,
14835 EvalInfo::EvaluatingDeclKind::Dtor);
14836 Info.InConstantContext = IsConstantDestruction;
14837
14838 LValue LVal;
14839 LVal.set(Base);
14840
14841 if (!HandleDestruction(Info, Loc, Base, DestroyedValue, Type) ||
14842 EStatus.HasSideEffects)
14843 return false;
14844
14845 if (!Info.discardCleanups())
14846 llvm_unreachable("Unhandled cleanup; missing full expression marker?")__builtin_unreachable();
14847
14848 return true;
14849}
14850
14851bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
14852 ConstantExprKind Kind) const {
14853 assert(!isValueDependent() &&((void)0)
14854 "Expression evaluator can't be called on a dependent expression.")((void)0);
14855
14856 EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
14857 EvalInfo Info(Ctx, Result, EM);
14858 Info.InConstantContext = true;
14859
14860 // The type of the object we're initializing is 'const T' for a class NTTP.
14861 QualType T = getType();
14862 if (Kind == ConstantExprKind::ClassTemplateArgument)
14863 T.addConst();
14864
14865 // If we're evaluating a prvalue, fake up a MaterializeTemporaryExpr to
14866 // represent the result of the evaluation. CheckConstantExpression ensures
14867 // this doesn't escape.
14868 MaterializeTemporaryExpr BaseMTE(T, const_cast<Expr*>(this), true);
14869 APValue::LValueBase Base(&BaseMTE);
14870
14871 Info.setEvaluatingDecl(Base, Result.Val);
14872 LValue LVal;
14873 LVal.set(Base);
14874
14875 if (!::EvaluateInPlace(Result.Val, Info, LVal, this) || Result.HasSideEffects)
14876 return false;
14877
14878 if (!Info.discardCleanups())
14879 llvm_unreachable("Unhandled cleanup; missing full expression marker?")__builtin_unreachable();
14880
14881 if (!CheckConstantExpression(Info, getExprLoc(), getStorageType(Ctx, this),
14882 Result.Val, Kind))
14883 return false;
14884 if (!CheckMemoryLeaks(Info))
14885 return false;
14886
14887 // If this is a class template argument, it's required to have constant
14888 // destruction too.
14889 if (Kind == ConstantExprKind::ClassTemplateArgument &&
14890 (!EvaluateDestruction(Ctx, Base, Result.Val, T, getBeginLoc(), Result,
14891 true) ||
14892 Result.HasSideEffects)) {
14893 // FIXME: Prefix a note to indicate that the problem is lack of constant
14894 // destruction.
14895 return false;
14896 }
14897
14898 return true;
14899}
14900
14901bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
14902 const VarDecl *VD,
14903 SmallVectorImpl<PartialDiagnosticAt> &Notes,
14904 bool IsConstantInitialization) const {
14905 assert(!isValueDependent() &&((void)0)
14906 "Expression evaluator can't be called on a dependent expression.")((void)0);
14907
14908 // FIXME: Evaluating initializers for large array and record types can cause
14909 // performance problems. Only do so in C++11 for now.
14910 if (isPRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
14911 !Ctx.getLangOpts().CPlusPlus11)
14912 return false;
14913
14914 Expr::EvalStatus EStatus;
14915 EStatus.Diag = &Notes;
14916
14917 EvalInfo Info(Ctx, EStatus,
14918 (IsConstantInitialization && Ctx.getLangOpts().CPlusPlus11)
14919 ? EvalInfo::EM_ConstantExpression
14920 : EvalInfo::EM_ConstantFold);
14921 Info.setEvaluatingDecl(VD, Value);
14922 Info.InConstantContext = IsConstantInitialization;
14923
14924 SourceLocation DeclLoc = VD->getLocation();
14925 QualType DeclTy = VD->getType();
14926
14927 if (Info.EnableNewConstInterp) {
14928 auto &InterpCtx = const_cast<ASTContext &>(Ctx).getInterpContext();
14929 if (!InterpCtx.evaluateAsInitializer(Info, VD, Value))
14930 return false;
14931 } else {
14932 LValue LVal;
14933 LVal.set(VD);
14934
14935 if (!EvaluateInPlace(Value, Info, LVal, this,
14936 /*AllowNonLiteralTypes=*/true) ||
14937 EStatus.HasSideEffects)
14938 return false;
14939
14940 // At this point, any lifetime-extended temporaries are completely
14941 // initialized.
14942 Info.performLifetimeExtension();
14943
14944 if (!Info.discardCleanups())
14945 llvm_unreachable("Unhandled cleanup; missing full expression marker?")__builtin_unreachable();
14946 }
14947 return CheckConstantExpression(Info, DeclLoc, DeclTy, Value,
14948 ConstantExprKind::Normal) &&
14949 CheckMemoryLeaks(Info);
14950}
14951
14952bool VarDecl::evaluateDestruction(
14953 SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
14954 Expr::EvalStatus EStatus;
14955 EStatus.Diag = &Notes;
14956
14957 // Only treat the destruction as constant destruction if we formally have
14958 // constant initialization (or are usable in a constant expression).
14959 bool IsConstantDestruction = hasConstantInitialization();
14960
14961 // Make a copy of the value for the destructor to mutate, if we know it.
14962 // Otherwise, treat the value as default-initialized; if the destructor works
14963 // anyway, then the destruction is constant (and must be essentially empty).
14964 APValue DestroyedValue;
14965 if (getEvaluatedValue() && !getEvaluatedValue()->isAbsent())
14966 DestroyedValue = *getEvaluatedValue();
14967 else if (!getDefaultInitValue(getType(), DestroyedValue))
14968 return false;
14969
14970 if (!EvaluateDestruction(getASTContext(), this, std::move(DestroyedValue),
14971 getType(), getLocation(), EStatus,
14972 IsConstantDestruction) ||
14973 EStatus.HasSideEffects)
14974 return false;
14975
14976 ensureEvaluatedStmt()->HasConstantDestruction = true;
14977 return true;
14978}
14979
14980/// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
14981/// constant folded, but discard the result.
14982bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
14983 assert(!isValueDependent() &&((void)0)
14984 "Expression evaluator can't be called on a dependent expression.")((void)0);
14985
14986 EvalResult Result;
14987 return EvaluateAsRValue(Result, Ctx, /* in constant context */ true) &&
14988 !hasUnacceptableSideEffect(Result, SEK);
14989}
14990
14991APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx,
14992 SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
14993 assert(!isValueDependent() &&((void)0)
14994 "Expression evaluator can't be called on a dependent expression.")((void)0);
14995
14996 EvalResult EVResult;
14997 EVResult.Diag = Diag;
14998 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
14999 Info.InConstantContext = true;
15000
15001 bool Result = ::EvaluateAsRValue(this, EVResult, Ctx, Info);
15002 (void)Result;
15003 assert(Result && "Could not evaluate expression")((void)0);
15004 assert(EVResult.Val.isInt() && "Expression did not evaluate to integer")((void)0);
15005
15006 return EVResult.Val.getInt();
15007}
15008
15009APSInt Expr::EvaluateKnownConstIntCheckOverflow(
15010 const ASTContext &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
15011 assert(!isValueDependent() &&((void)0)
15012 "Expression evaluator can't be called on a dependent expression.")((void)0);
15013
15014 EvalResult EVResult;
15015 EVResult.Diag = Diag;
15016 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
15017 Info.InConstantContext = true;
15018 Info.CheckingForUndefinedBehavior = true;
15019
15020 bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val);
15021 (void)Result;
15022 assert(Result && "Could not evaluate expression")((void)0);
15023 assert(EVResult.Val.isInt() && "Expression did not evaluate to integer")((void)0);
15024
15025 return EVResult.Val.getInt();
15026}
15027
15028void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
15029 assert(!isValueDependent() &&((void)0)
15030 "Expression evaluator can't be called on a dependent expression.")((void)0);
15031
15032 bool IsConst;
15033 EvalResult EVResult;
15034 if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) {
15035 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects);
15036 Info.CheckingForUndefinedBehavior = true;
15037 (void)::EvaluateAsRValue(Info, this, EVResult.Val);
15038 }
15039}
15040
15041bool Expr::EvalResult::isGlobalLValue() const {
15042 assert(Val.isLValue())((void)0);
15043 return IsGlobalLValue(Val.getLValueBase());
15044}
15045
15046/// isIntegerConstantExpr - this recursive routine will test if an expression is
15047/// an integer constant expression.
15048
15049/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
15050/// comma, etc
15051
15052// CheckICE - This function does the fundamental ICE checking: the returned
15053// ICEDiag contains an ICEKind indicating whether the expression is an ICE,
15054// and a (possibly null) SourceLocation indicating the location of the problem.
15055//
15056// Note that to reduce code duplication, this helper does no evaluation
15057// itself; the caller checks whether the expression is evaluatable, and
15058// in the rare cases where CheckICE actually cares about the evaluated
15059// value, it calls into Evaluate.
15060
15061namespace {
15062
15063enum ICEKind {
15064 /// This expression is an ICE.
15065 IK_ICE,
15066 /// This expression is not an ICE, but if it isn't evaluated, it's
15067 /// a legal subexpression for an ICE. This return value is used to handle
15068 /// the comma operator in C99 mode, and non-constant subexpressions.
15069 IK_ICEIfUnevaluated,
15070 /// This expression is not an ICE, and is not a legal subexpression for one.
15071 IK_NotICE
15072};
15073
15074struct ICEDiag {
15075 ICEKind Kind;
15076 SourceLocation Loc;
15077
15078 ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {}
15079};
15080
15081}
15082
15083static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); }
15084
15085static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; }
15086
15087static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
15088 Expr::EvalResult EVResult;
15089 Expr::EvalStatus Status;
15090 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
15091
15092 Info.InConstantContext = true;
15093 if (!::EvaluateAsRValue(E, EVResult, Ctx, Info) || EVResult.HasSideEffects ||
15094 !EVResult.Val.isInt())
15095 return ICEDiag(IK_NotICE, E->getBeginLoc());
15096
15097 return NoDiag();
15098}
15099
15100static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
15101 assert(!E->isValueDependent() && "Should not see value dependent exprs!")((void)0);
15102 if (!E->getType()->isIntegralOrEnumerationType())
15103 return ICEDiag(IK_NotICE, E->getBeginLoc());
15104
15105 switch (E->getStmtClass()) {
15106#define ABSTRACT_STMT(Node)
15107#define STMT(Node, Base) case Expr::Node##Class:
15108#define EXPR(Node, Base)
15109#include "clang/AST/StmtNodes.inc"
15110 case Expr::PredefinedExprClass:
15111 case Expr::FloatingLiteralClass:
15112 case Expr::ImaginaryLiteralClass:
15113 case Expr::StringLiteralClass:
15114 case Expr::ArraySubscriptExprClass:
15115 case Expr::MatrixSubscriptExprClass:
15116 case Expr::OMPArraySectionExprClass:
15117 case Expr::OMPArrayShapingExprClass:
15118 case Expr::OMPIteratorExprClass:
15119 case Expr::MemberExprClass:
15120 case Expr::CompoundAssignOperatorClass:
15121 case Expr::CompoundLiteralExprClass:
15122 case Expr::ExtVectorElementExprClass:
15123 case Expr::DesignatedInitExprClass:
15124 case Expr::ArrayInitLoopExprClass:
15125 case Expr::ArrayInitIndexExprClass:
15126 case Expr::NoInitExprClass:
15127 case Expr::DesignatedInitUpdateExprClass:
15128 case Expr::ImplicitValueInitExprClass:
15129 case Expr::ParenListExprClass:
15130 case Expr::VAArgExprClass:
15131 case Expr::AddrLabelExprClass:
15132 case Expr::StmtExprClass:
15133 case Expr::CXXMemberCallExprClass:
15134 case Expr::CUDAKernelCallExprClass:
15135 case Expr::CXXAddrspaceCastExprClass:
15136 case Expr::CXXDynamicCastExprClass:
15137 case Expr::CXXTypeidExprClass:
15138 case Expr::CXXUuidofExprClass:
15139 case Expr::MSPropertyRefExprClass:
15140 case Expr::MSPropertySubscriptExprClass:
15141 case Expr::CXXNullPtrLiteralExprClass:
15142 case Expr::UserDefinedLiteralClass:
15143 case Expr::CXXThisExprClass:
15144 case Expr::CXXThrowExprClass:
15145 case Expr::CXXNewExprClass:
15146 case Expr::CXXDeleteExprClass:
15147 case Expr::CXXPseudoDestructorExprClass:
15148 case Expr::UnresolvedLookupExprClass:
15149 case Expr::TypoExprClass:
15150 case Expr::RecoveryExprClass:
15151 case Expr::DependentScopeDeclRefExprClass:
15152 case Expr::CXXConstructExprClass:
15153 case Expr::CXXInheritedCtorInitExprClass:
15154 case Expr::CXXStdInitializerListExprClass:
15155 case Expr::CXXBindTemporaryExprClass:
15156 case Expr::ExprWithCleanupsClass:
15157 case Expr::CXXTemporaryObjectExprClass:
15158 case Expr::CXXUnresolvedConstructExprClass:
15159 case Expr::CXXDependentScopeMemberExprClass:
15160 case Expr::UnresolvedMemberExprClass:
15161 case Expr::ObjCStringLiteralClass:
15162 case Expr::ObjCBoxedExprClass:
15163 case Expr::ObjCArrayLiteralClass:
15164 case Expr::ObjCDictionaryLiteralClass:
15165 case Expr::ObjCEncodeExprClass:
15166 case Expr::ObjCMessageExprClass:
15167 case Expr::ObjCSelectorExprClass:
15168 case Expr::ObjCProtocolExprClass:
15169 case Expr::ObjCIvarRefExprClass:
15170 case Expr::ObjCPropertyRefExprClass:
15171 case Expr::ObjCSubscriptRefExprClass:
15172 case Expr::ObjCIsaExprClass:
15173 case Expr::ObjCAvailabilityCheckExprClass:
15174 case Expr::ShuffleVectorExprClass:
15175 case Expr::ConvertVectorExprClass:
15176 case Expr::BlockExprClass:
15177 case Expr::NoStmtClass:
15178 case Expr::OpaqueValueExprClass:
15179 case Expr::PackExpansionExprClass:
15180 case Expr::SubstNonTypeTemplateParmPackExprClass:
15181 case Expr::FunctionParmPackExprClass:
15182 case Expr::AsTypeExprClass:
15183 case Expr::ObjCIndirectCopyRestoreExprClass:
15184 case Expr::MaterializeTemporaryExprClass:
15185 case Expr::PseudoObjectExprClass:
15186 case Expr::AtomicExprClass:
15187 case Expr::LambdaExprClass:
15188 case Expr::CXXFoldExprClass:
15189 case Expr::CoawaitExprClass:
15190 case Expr::DependentCoawaitExprClass:
15191 case Expr::CoyieldExprClass:
15192 case Expr::SYCLUniqueStableNameExprClass:
15193 return ICEDiag(IK_NotICE, E->getBeginLoc());
15194
15195 case Expr::InitListExprClass: {
15196 // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the
15197 // form "T x = { a };" is equivalent to "T x = a;".
15198 // Unless we're initializing a reference, T is a scalar as it is known to be
15199 // of integral or enumeration type.
15200 if (E->isPRValue())
15201 if (cast<InitListExpr>(E)->getNumInits() == 1)
15202 return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
15203 return ICEDiag(IK_NotICE, E->getBeginLoc());
15204 }
15205
15206 case Expr::SizeOfPackExprClass:
15207 case Expr::GNUNullExprClass:
15208 case Expr::SourceLocExprClass:
15209 return NoDiag();
15210
15211 case Expr::SubstNonTypeTemplateParmExprClass:
15212 return
15213 CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
15214
15215 case Expr::ConstantExprClass:
15216 return CheckICE(cast<ConstantExpr>(E)->getSubExpr(), Ctx);
15217
15218 case Expr::ParenExprClass:
15219 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
15220 case Expr::GenericSelectionExprClass:
15221 return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
15222 case Expr::IntegerLiteralClass:
15223 case Expr::FixedPointLiteralClass:
15224 case Expr::CharacterLiteralClass:
15225 case Expr::ObjCBoolLiteralExprClass:
15226 case Expr::CXXBoolLiteralExprClass:
15227 case Expr::CXXScalarValueInitExprClass:
15228 case Expr::TypeTraitExprClass:
15229 case Expr::ConceptSpecializationExprClass:
15230 case Expr::RequiresExprClass:
15231 case Expr::ArrayTypeTraitExprClass:
15232 case Expr::ExpressionTraitExprClass:
15233 case Expr::CXXNoexceptExprClass:
15234 return NoDiag();
15235 case Expr::CallExprClass:
15236 case Expr::CXXOperatorCallExprClass: {
15237 // C99 6.6/3 allows function calls within unevaluated subexpressions of
15238 // constant expressions, but they can never be ICEs because an ICE cannot
15239 // contain an operand of (pointer to) function type.
15240 const CallExpr *CE = cast<CallExpr>(E);
15241 if (CE->getBuiltinCallee())
15242 return CheckEvalInICE(E, Ctx);
15243 return ICEDiag(IK_NotICE, E->getBeginLoc());
15244 }
15245 case Expr::CXXRewrittenBinaryOperatorClass:
15246 return CheckICE(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm(),
15247 Ctx);
15248 case Expr::DeclRefExprClass: {
15249 const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl();
15250 if (isa<EnumConstantDecl>(D))
15251 return NoDiag();
15252
15253 // C++ and OpenCL (FIXME: spec reference?) allow reading const-qualified
15254 // integer variables in constant expressions:
15255 //
15256 // C++ 7.1.5.1p2
15257 // A variable of non-volatile const-qualified integral or enumeration
15258 // type initialized by an ICE can be used in ICEs.
15259 //
15260 // We sometimes use CheckICE to check the C++98 rules in C++11 mode. In
15261 // that mode, use of reference variables should not be allowed.
15262 const VarDecl *VD = dyn_cast<VarDecl>(D);
15263 if (VD && VD->isUsableInConstantExpressions(Ctx) &&
15264 !VD->getType()->isReferenceType())
15265 return NoDiag();
15266
15267 return ICEDiag(IK_NotICE, E->getBeginLoc());
15268 }
15269 case Expr::UnaryOperatorClass: {
15270 const UnaryOperator *Exp = cast<UnaryOperator>(E);
15271 switch (Exp->getOpcode()) {
15272 case UO_PostInc:
15273 case UO_PostDec:
15274 case UO_PreInc:
15275 case UO_PreDec:
15276 case UO_AddrOf:
15277 case UO_Deref:
15278 case UO_Coawait:
15279 // C99 6.6/3 allows increment and decrement within unevaluated
15280 // subexpressions of constant expressions, but they can never be ICEs
15281 // because an ICE cannot contain an lvalue operand.
15282 return ICEDiag(IK_NotICE, E->getBeginLoc());
15283 case UO_Extension:
15284 case UO_LNot:
15285 case UO_Plus:
15286 case UO_Minus:
15287 case UO_Not:
15288 case UO_Real:
15289 case UO_Imag:
15290 return CheckICE(Exp->getSubExpr(), Ctx);
15291 }
15292 llvm_unreachable("invalid unary operator class")__builtin_unreachable();
15293 }
15294 case Expr::OffsetOfExprClass: {
15295 // Note that per C99, offsetof must be an ICE. And AFAIK, using
15296 // EvaluateAsRValue matches the proposed gcc behavior for cases like
15297 // "offsetof(struct s{int x[4];}, x[1.0])". This doesn't affect
15298 // compliance: we should warn earlier for offsetof expressions with
15299 // array subscripts that aren't ICEs, and if the array subscripts
15300 // are ICEs, the value of the offsetof must be an integer constant.
15301 return CheckEvalInICE(E, Ctx);
15302 }
15303 case Expr::UnaryExprOrTypeTraitExprClass: {
15304 const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
15305 if ((Exp->getKind() == UETT_SizeOf) &&
15306 Exp->getTypeOfArgument()->isVariableArrayType())
15307 return ICEDiag(IK_NotICE, E->getBeginLoc());
15308 return NoDiag();
15309 }
15310 case Expr::BinaryOperatorClass: {
15311 const BinaryOperator *Exp = cast<BinaryOperator>(E);
15312 switch (Exp->getOpcode()) {
15313 case BO_PtrMemD:
15314 case BO_PtrMemI:
15315 case BO_Assign:
15316 case BO_MulAssign:
15317 case BO_DivAssign:
15318 case BO_RemAssign:
15319 case BO_AddAssign:
15320 case BO_SubAssign:
15321 case BO_ShlAssign:
15322 case BO_ShrAssign:
15323 case BO_AndAssign:
15324 case BO_XorAssign:
15325 case BO_OrAssign:
15326 // C99 6.6/3 allows assignments within unevaluated subexpressions of
15327 // constant expressions, but they can never be ICEs because an ICE cannot
15328 // contain an lvalue operand.
15329 return ICEDiag(IK_NotICE, E->getBeginLoc());
15330
15331 case BO_Mul:
15332 case BO_Div:
15333 case BO_Rem:
15334 case BO_Add:
15335 case BO_Sub:
15336 case BO_Shl:
15337 case BO_Shr:
15338 case BO_LT:
15339 case BO_GT:
15340 case BO_LE:
15341 case BO_GE:
15342 case BO_EQ:
15343 case BO_NE:
15344 case BO_And:
15345 case BO_Xor:
15346 case BO_Or:
15347 case BO_Comma:
15348 case BO_Cmp: {
15349 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
15350 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
15351 if (Exp->getOpcode() == BO_Div ||
15352 Exp->getOpcode() == BO_Rem) {
15353 // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure
15354 // we don't evaluate one.
15355 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
15356 llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx);
15357 if (REval == 0)
15358 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
15359 if (REval.isSigned() && REval.isAllOnesValue()) {
15360 llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx);
15361 if (LEval.isMinSignedValue())
15362 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
15363 }
15364 }
15365 }
15366 if (Exp->getOpcode() == BO_Comma) {
15367 if (Ctx.getLangOpts().C99) {
15368 // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
15369 // if it isn't evaluated.
15370 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
15371 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc());
15372 } else {
15373 // In both C89 and C++, commas in ICEs are illegal.
15374 return ICEDiag(IK_NotICE, E->getBeginLoc());
15375 }
15376 }
15377 return Worst(LHSResult, RHSResult);
15378 }
15379 case BO_LAnd:
15380 case BO_LOr: {
15381 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
15382 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
15383 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) {
15384 // Rare case where the RHS has a comma "side-effect"; we need
15385 // to actually check the condition to see whether the side
15386 // with the comma is evaluated.
15387 if ((Exp->getOpcode() == BO_LAnd) !=
15388 (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0))
15389 return RHSResult;
15390 return NoDiag();
15391 }
15392
15393 return Worst(LHSResult, RHSResult);
15394 }
15395 }
15396 llvm_unreachable("invalid binary operator kind")__builtin_unreachable();
15397 }
15398 case Expr::ImplicitCastExprClass:
15399 case Expr::CStyleCastExprClass:
15400 case Expr::CXXFunctionalCastExprClass:
15401 case Expr::CXXStaticCastExprClass:
15402 case Expr::CXXReinterpretCastExprClass:
15403 case Expr::CXXConstCastExprClass:
15404 case Expr::ObjCBridgedCastExprClass: {
15405 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
15406 if (isa<ExplicitCastExpr>(E)) {
15407 if (const FloatingLiteral *FL
15408 = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
15409 unsigned DestWidth = Ctx.getIntWidth(E->getType());
15410 bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType();
15411 APSInt IgnoredVal(DestWidth, !DestSigned);
15412 bool Ignored;
15413 // If the value does not fit in the destination type, the behavior is
15414 // undefined, so we are not required to treat it as a constant
15415 // expression.
15416 if (FL->getValue().convertToInteger(IgnoredVal,
15417 llvm::APFloat::rmTowardZero,
15418 &Ignored) & APFloat::opInvalidOp)
15419 return ICEDiag(IK_NotICE, E->getBeginLoc());
15420 return NoDiag();
15421 }
15422 }
15423 switch (cast<CastExpr>(E)->getCastKind()) {
15424 case CK_LValueToRValue:
15425 case CK_AtomicToNonAtomic:
15426 case CK_NonAtomicToAtomic:
15427 case CK_NoOp:
15428 case CK_IntegralToBoolean:
15429 case CK_IntegralCast:
15430 return CheckICE(SubExpr, Ctx);
15431 default:
15432 return ICEDiag(IK_NotICE, E->getBeginLoc());
15433 }
15434 }
15435 case Expr::BinaryConditionalOperatorClass: {
15436 const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E);
15437 ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx);
15438 if (CommonResult.Kind == IK_NotICE) return CommonResult;
15439 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
15440 if (FalseResult.Kind == IK_NotICE) return FalseResult;
15441 if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult;
15442 if (FalseResult.Kind == IK_ICEIfUnevaluated &&
15443 Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag();
15444 return FalseResult;
15445 }
15446 case Expr::ConditionalOperatorClass: {
15447 const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
15448 // If the condition (ignoring parens) is a __builtin_constant_p call,
15449 // then only the true side is actually considered in an integer constant
15450 // expression, and it is fully evaluated. This is an important GNU
15451 // extension. See GCC PR38377 for discussion.
15452 if (const CallExpr *CallCE
15453 = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
15454 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
15455 return CheckEvalInICE(E, Ctx);
15456 ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
15457 if (CondResult.Kind == IK_NotICE)
15458 return CondResult;
15459
15460 ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
15461 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
15462
15463 if (TrueResult.Kind == IK_NotICE)
15464 return TrueResult;
15465 if (FalseResult.Kind == IK_NotICE)
15466 return FalseResult;
15467 if (CondResult.Kind == IK_ICEIfUnevaluated)
15468 return CondResult;
15469 if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE)
15470 return NoDiag();
15471 // Rare case where the diagnostics depend on which side is evaluated
15472 // Note that if we get here, CondResult is 0, and at least one of
15473 // TrueResult and FalseResult is non-zero.
15474 if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0)
15475 return FalseResult;
15476 return TrueResult;
15477 }
15478 case Expr::CXXDefaultArgExprClass:
15479 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
15480 case Expr::CXXDefaultInitExprClass:
15481 return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
15482 case Expr::ChooseExprClass: {
15483 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
15484 }
15485 case Expr::BuiltinBitCastExprClass: {
15486 if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E)))
15487 return ICEDiag(IK_NotICE, E->getBeginLoc());
15488 return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx);
15489 }
15490 }
15491
15492 llvm_unreachable("Invalid StmtClass!")__builtin_unreachable();
15493}
15494
15495/// Evaluate an expression as a C++11 integral constant expression.
15496static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
15497 const Expr *E,
15498 llvm::APSInt *Value,
15499 SourceLocation *Loc) {
15500 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
15501 if (Loc) *Loc = E->getExprLoc();
15502 return false;
15503 }
15504
15505 APValue Result;
15506 if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
15507 return false;
15508
15509 if (!Result.isInt()) {
15510 if (Loc) *Loc = E->getExprLoc();
15511 return false;
15512 }
15513
15514 if (Value) *Value = Result.getInt();
15515 return true;
15516}
15517
15518bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
15519 SourceLocation *Loc) const {
15520 assert(!isValueDependent() &&((void)0)
15521 "Expression evaluator can't be called on a dependent expression.")((void)0);
15522
15523 if (Ctx.getLangOpts().CPlusPlus11)
15524 return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc);
15525
15526 ICEDiag D = CheckICE(this, Ctx);
15527 if (D.Kind != IK_ICE) {
15528 if (Loc) *Loc = D.Loc;
15529 return false;
15530 }
15531 return true;
15532}
15533
15534Optional<llvm::APSInt> Expr::getIntegerConstantExpr(const ASTContext &Ctx,
15535 SourceLocation *Loc,
15536 bool isEvaluated) const {
15537 assert(!isValueDependent() &&((void)0)
15538 "Expression evaluator can't be called on a dependent expression.")((void)0);
15539
15540 APSInt Value;
15541
15542 if (Ctx.getLangOpts().CPlusPlus11) {
15543 if (EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc))
15544 return Value;
15545 return None;
15546 }
15547
15548 if (!isIntegerConstantExpr(Ctx, Loc))
15549 return None;
15550
15551 // The only possible side-effects here are due to UB discovered in the
15552 // evaluation (for instance, INT_MAX + 1). In such a case, we are still
15553 // required to treat the expression as an ICE, so we produce the folded
15554 // value.
15555 EvalResult ExprResult;
15556 Expr::EvalStatus Status;
15557 EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects);
15558 Info.InConstantContext = true;
15559
15560 if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info))
15561 llvm_unreachable("ICE cannot be evaluated!")__builtin_unreachable();
15562
15563 return ExprResult.Val.getInt();
15564}
15565
15566bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const {
15567 assert(!isValueDependent() &&((void)0)
15568 "Expression evaluator can't be called on a dependent expression.")((void)0);
15569
15570 return CheckICE(this, Ctx).Kind == IK_ICE;
15571}
15572
15573bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
15574 SourceLocation *Loc) const {
15575 assert(!isValueDependent() &&((void)0)
15576 "Expression evaluator can't be called on a dependent expression.")((void)0);
15577
15578 // We support this checking in C++98 mode in order to diagnose compatibility
15579 // issues.
15580 assert(Ctx.getLangOpts().CPlusPlus)((void)0);
15581
15582 // Build evaluation settings.
15583 Expr::EvalStatus Status;
15584 SmallVector<PartialDiagnosticAt, 8> Diags;
15585 Status.Diag = &Diags;
15586 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
15587
15588 APValue Scratch;
15589 bool IsConstExpr =
15590 ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch) &&
15591 // FIXME: We don't produce a diagnostic for this, but the callers that
15592 // call us on arbitrary full-expressions should generally not care.
15593 Info.discardCleanups() && !Status.HasSideEffects;
15594
15595 if (!Diags.empty()) {
15596 IsConstExpr = false;
15597 if (Loc) *Loc = Diags[0].first;
15598 } else if (!IsConstExpr) {
15599 // FIXME: This shouldn't happen.
15600 if (Loc) *Loc = getExprLoc();
15601 }
15602
15603 return IsConstExpr;
15604}
15605
15606bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
15607 const FunctionDecl *Callee,
15608 ArrayRef<const Expr*> Args,
15609 const Expr *This) const {
15610 assert(!isValueDependent() &&((void)0)
15611 "Expression evaluator can't be called on a dependent expression.")((void)0);
15612
15613 Expr::EvalStatus Status;
15614 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
15615 Info.InConstantContext = true;
15616
15617 LValue ThisVal;
15618 const LValue *ThisPtr = nullptr;
15619 if (This) {
15620#ifndef NDEBUG1
15621 auto *MD = dyn_cast<CXXMethodDecl>(Callee);
15622 assert(MD && "Don't provide `this` for non-methods.")((void)0);
15623 assert(!MD->isStatic() && "Don't provide `this` for static methods.")((void)0);
15624#endif
15625 if (!This->isValueDependent() &&
15626 EvaluateObjectArgument(Info, This, ThisVal) &&
15627 !Info.EvalStatus.HasSideEffects)
15628 ThisPtr = &ThisVal;
15629
15630 // Ignore any side-effects from a failed evaluation. This is safe because
15631 // they can't interfere with any other argument evaluation.
15632 Info.EvalStatus.HasSideEffects = false;
15633 }
15634
15635 CallRef Call = Info.CurrentCall->createCall(Callee);
15636 for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
15637 I != E; ++I) {
15638 unsigned Idx = I - Args.begin();
15639 if (Idx >= Callee->getNumParams())
15640 break;
15641 const ParmVarDecl *PVD = Callee->getParamDecl(Idx);
15642 if ((*I)->isValueDependent() ||
15643 !EvaluateCallArg(PVD, *I, Call, Info) ||
15644 Info.EvalStatus.HasSideEffects) {
15645 // If evaluation fails, throw away the argument entirely.
15646 if (APValue *Slot = Info.getParamSlot(Call, PVD))
15647 *Slot = APValue();
15648 }
15649
15650 // Ignore any side-effects from a failed evaluation. This is safe because
15651 // they can't interfere with any other argument evaluation.
15652 Info.EvalStatus.HasSideEffects = false;
15653 }
15654
15655 // Parameter cleanups happen in the caller and are not part of this
15656 // evaluation.
15657 Info.discardCleanups();
15658 Info.EvalStatus.HasSideEffects = false;
15659
15660 // Build fake call to Callee.
15661 CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr, Call);
15662 // FIXME: Missing ExprWithCleanups in enable_if conditions?
15663 FullExpressionRAII Scope(Info);
15664 return Evaluate(Value, Info, this) && Scope.destroy() &&
15665 !Info.EvalStatus.HasSideEffects;
15666}
15667
15668bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
15669 SmallVectorImpl<
15670 PartialDiagnosticAt> &Diags) {
15671 // FIXME: It would be useful to check constexpr function templates, but at the
15672 // moment the constant expression evaluator cannot cope with the non-rigorous
15673 // ASTs which we build for dependent expressions.
15674 if (FD->isDependentContext())
1
Assuming the condition is false
2
Taking false branch
15675 return true;
15676
15677 Expr::EvalStatus Status;
15678 Status.Diag = &Diags;
15679
15680 EvalInfo Info(FD->getASTContext(), Status, EvalInfo::EM_ConstantExpression);
3
Calling constructor for 'EvalInfo'
6
Returning from constructor for 'EvalInfo'
15681 Info.InConstantContext = true;
15682 Info.CheckingPotentialConstantExpression = true;
15683
15684 // The constexpr VM attempts to compile all methods to bytecode here.
15685 if (Info.EnableNewConstInterp) {
7
Assuming field 'EnableNewConstInterp' is false
8
Taking false branch
15686 Info.Ctx.getInterpContext().isPotentialConstantExpr(Info, FD);
15687 return Diags.empty();
15688 }
15689
15690 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
9
Assuming 'FD' is a 'CXXMethodDecl'
15691 const CXXRecordDecl *RD = MD
9.1
'MD' is non-null
9.1
'MD' is non-null
9.1
'MD' is non-null
9.1
'MD' is non-null
9.1
'MD' is non-null
9.1
'MD' is non-null
? MD->getParent()->getCanonicalDecl() : nullptr;
10
'?' condition is true
15692
15693 // Fabricate an arbitrary expression on the stack and pretend that it
15694 // is a temporary being used as the 'this' pointer.
15695 LValue This;
15696 ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
11
Assuming 'RD' is non-null
12
'?' condition is true
15697 This.set({&VIE, Info.CurrentCall->Index});
15698
15699 ArrayRef<const Expr*> Args;
15700
15701 APValue Scratch;
15702 if (const CXXConstructorDecl *CD
13.1
'CD' is null
13.1
'CD' is null
13.1
'CD' is null
13.1
'CD' is null
13.1
'CD' is null
13.1
'CD' is null
= dyn_cast<CXXConstructorDecl>(FD)) {
13
Assuming 'FD' is not a 'CXXConstructorDecl'
14
Taking false branch
15703 // Evaluate the call as a constant initializer, to allow the construction
15704 // of objects of non-literal types.
15705 Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
15706 HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch);
15707 } else {
15708 SourceLocation Loc = FD->getLocation();
15709 HandleFunctionCall(Loc, FD, (MD
14.1
'MD' is non-null
14.1
'MD' is non-null
14.1
'MD' is non-null
14.1
'MD' is non-null
14.1
'MD' is non-null
14.1
'MD' is non-null
&& MD->isInstance()) ? &This : nullptr,
15
'?' condition is true
16
Calling 'HandleFunctionCall'
15710 Args, CallRef(), FD->getBody(), Info, Scratch, nullptr);
15711 }
15712
15713 return Diags.empty();
15714}
15715
15716bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
15717 const FunctionDecl *FD,
15718 SmallVectorImpl<
15719 PartialDiagnosticAt> &Diags) {
15720 assert(!E->isValueDependent() &&((void)0)
15721 "Expression evaluator can't be called on a dependent expression.")((void)0);
15722
15723 Expr::EvalStatus Status;
15724 Status.Diag = &Diags;
15725
15726 EvalInfo Info(FD->getASTContext(), Status,
15727 EvalInfo::EM_ConstantExpressionUnevaluated);
15728 Info.InConstantContext = true;
15729 Info.CheckingPotentialConstantExpression = true;
15730
15731 // Fabricate a call stack frame to give the arguments a plausible cover story.
15732 CallStackFrame Frame(Info, SourceLocation(), FD, /*This*/ nullptr, CallRef());
15733
15734 APValue ResultScratch;
15735 Evaluate(ResultScratch, Info, E);
15736 return Diags.empty();
15737}
15738
15739bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
15740 unsigned Type) const {
15741 if (!getType()->isPointerType())
15742 return false;
15743
15744 Expr::EvalStatus Status;
15745 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
15746 return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
15747}

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/Decl.h

1//===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Decl subclasses.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_DECL_H
14#define LLVM_CLANG_AST_DECL_H
15
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContextAllocate.h"
18#include "clang/AST/DeclAccessPair.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/ExternalASTSource.h"
22#include "clang/AST/NestedNameSpecifier.h"
23#include "clang/AST/Redeclarable.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/AddressSpaces.h"
26#include "clang/Basic/Diagnostic.h"
27#include "clang/Basic/IdentifierTable.h"
28#include "clang/Basic/LLVM.h"
29#include "clang/Basic/Linkage.h"
30#include "clang/Basic/OperatorKinds.h"
31#include "clang/Basic/PartialDiagnostic.h"
32#include "clang/Basic/PragmaKinds.h"
33#include "clang/Basic/SourceLocation.h"
34#include "clang/Basic/Specifiers.h"
35#include "clang/Basic/Visibility.h"
36#include "llvm/ADT/APSInt.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/TrailingObjects.h"
46#include <cassert>
47#include <cstddef>
48#include <cstdint>
49#include <string>
50#include <utility>
51
52namespace clang {
53
54class ASTContext;
55struct ASTTemplateArgumentListInfo;
56class Attr;
57class CompoundStmt;
58class DependentFunctionTemplateSpecializationInfo;
59class EnumDecl;
60class Expr;
61class FunctionTemplateDecl;
62class FunctionTemplateSpecializationInfo;
63class FunctionTypeLoc;
64class LabelStmt;
65class MemberSpecializationInfo;
66class Module;
67class NamespaceDecl;
68class ParmVarDecl;
69class RecordDecl;
70class Stmt;
71class StringLiteral;
72class TagDecl;
73class TemplateArgumentList;
74class TemplateArgumentListInfo;
75class TemplateParameterList;
76class TypeAliasTemplateDecl;
77class TypeLoc;
78class UnresolvedSetImpl;
79class VarTemplateDecl;
80
81/// The top declaration context.
82class TranslationUnitDecl : public Decl,
83 public DeclContext,
84 public Redeclarable<TranslationUnitDecl> {
85 using redeclarable_base = Redeclarable<TranslationUnitDecl>;
86
87 TranslationUnitDecl *getNextRedeclarationImpl() override {
88 return getNextRedeclaration();
89 }
90
91 TranslationUnitDecl *getPreviousDeclImpl() override {
92 return getPreviousDecl();
93 }
94
95 TranslationUnitDecl *getMostRecentDeclImpl() override {
96 return getMostRecentDecl();
97 }
98
99 ASTContext &Ctx;
100
101 /// The (most recently entered) anonymous namespace for this
102 /// translation unit, if one has been created.
103 NamespaceDecl *AnonymousNamespace = nullptr;
104
105 explicit TranslationUnitDecl(ASTContext &ctx);
106
107 virtual void anchor();
108
109public:
110 using redecl_range = redeclarable_base::redecl_range;
111 using redecl_iterator = redeclarable_base::redecl_iterator;
112
113 using redeclarable_base::getMostRecentDecl;
114 using redeclarable_base::getPreviousDecl;
115 using redeclarable_base::isFirstDecl;
116 using redeclarable_base::redecls;
117 using redeclarable_base::redecls_begin;
118 using redeclarable_base::redecls_end;
119
120 ASTContext &getASTContext() const { return Ctx; }
121
122 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
123 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
124
125 static TranslationUnitDecl *Create(ASTContext &C);
126
127 // Implement isa/cast/dyncast/etc.
128 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
129 static bool classofKind(Kind K) { return K == TranslationUnit; }
130 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
131 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
132 }
133 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
134 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
135 }
136};
137
138/// Represents a `#pragma comment` line. Always a child of
139/// TranslationUnitDecl.
140class PragmaCommentDecl final
141 : public Decl,
142 private llvm::TrailingObjects<PragmaCommentDecl, char> {
143 friend class ASTDeclReader;
144 friend class ASTDeclWriter;
145 friend TrailingObjects;
146
147 PragmaMSCommentKind CommentKind;
148
149 PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
150 PragmaMSCommentKind CommentKind)
151 : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
152
153 virtual void anchor();
154
155public:
156 static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
157 SourceLocation CommentLoc,
158 PragmaMSCommentKind CommentKind,
159 StringRef Arg);
160 static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
161 unsigned ArgSize);
162
163 PragmaMSCommentKind getCommentKind() const { return CommentKind; }
164
165 StringRef getArg() const { return getTrailingObjects<char>(); }
166
167 // Implement isa/cast/dyncast/etc.
168 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
169 static bool classofKind(Kind K) { return K == PragmaComment; }
170};
171
172/// Represents a `#pragma detect_mismatch` line. Always a child of
173/// TranslationUnitDecl.
174class PragmaDetectMismatchDecl final
175 : public Decl,
176 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
177 friend class ASTDeclReader;
178 friend class ASTDeclWriter;
179 friend TrailingObjects;
180
181 size_t ValueStart;
182
183 PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
184 size_t ValueStart)
185 : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
186
187 virtual void anchor();
188
189public:
190 static PragmaDetectMismatchDecl *Create(const ASTContext &C,
191 TranslationUnitDecl *DC,
192 SourceLocation Loc, StringRef Name,
193 StringRef Value);
194 static PragmaDetectMismatchDecl *
195 CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
196
197 StringRef getName() const { return getTrailingObjects<char>(); }
198 StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
199
200 // Implement isa/cast/dyncast/etc.
201 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
202 static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
203};
204
205/// Declaration context for names declared as extern "C" in C++. This
206/// is neither the semantic nor lexical context for such declarations, but is
207/// used to check for conflicts with other extern "C" declarations. Example:
208///
209/// \code
210/// namespace N { extern "C" void f(); } // #1
211/// void N::f() {} // #2
212/// namespace M { extern "C" void f(); } // #3
213/// \endcode
214///
215/// The semantic context of #1 is namespace N and its lexical context is the
216/// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
217/// context is the TU. However, both declarations are also visible in the
218/// extern "C" context.
219///
220/// The declaration at #3 finds it is a redeclaration of \c N::f through
221/// lookup in the extern "C" context.
222class ExternCContextDecl : public Decl, public DeclContext {
223 explicit ExternCContextDecl(TranslationUnitDecl *TU)
224 : Decl(ExternCContext, TU, SourceLocation()),
225 DeclContext(ExternCContext) {}
226
227 virtual void anchor();
228
229public:
230 static ExternCContextDecl *Create(const ASTContext &C,
231 TranslationUnitDecl *TU);
232
233 // Implement isa/cast/dyncast/etc.
234 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
235 static bool classofKind(Kind K) { return K == ExternCContext; }
236 static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
237 return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
238 }
239 static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
240 return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
241 }
242};
243
244/// This represents a decl that may have a name. Many decls have names such
245/// as ObjCMethodDecl, but not \@class, etc.
246///
247/// Note that not every NamedDecl is actually named (e.g., a struct might
248/// be anonymous), and not every name is an identifier.
249class NamedDecl : public Decl {
250 /// The name of this declaration, which is typically a normal
251 /// identifier but may also be a special kind of name (C++
252 /// constructor, Objective-C selector, etc.)
253 DeclarationName Name;
254
255 virtual void anchor();
256
257private:
258 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY__attribute__((__pure__));
259
260protected:
261 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
262 : Decl(DK, DC, L), Name(N) {}
263
264public:
265 /// Get the identifier that names this declaration, if there is one.
266 ///
267 /// This will return NULL if this declaration has no name (e.g., for
268 /// an unnamed class) or if the name is a special name (C++ constructor,
269 /// Objective-C selector, etc.).
270 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
271
272 /// Get the name of identifier for this declaration as a StringRef.
273 ///
274 /// This requires that the declaration have a name and that it be a simple
275 /// identifier.
276 StringRef getName() const {
277 assert(Name.isIdentifier() && "Name is not a simple identifier")((void)0);
278 return getIdentifier() ? getIdentifier()->getName() : "";
279 }
280
281 /// Get a human-readable name for the declaration, even if it is one of the
282 /// special kinds of names (C++ constructor, Objective-C selector, etc).
283 ///
284 /// Creating this name requires expensive string manipulation, so it should
285 /// be called only when performance doesn't matter. For simple declarations,
286 /// getNameAsCString() should suffice.
287 //
288 // FIXME: This function should be renamed to indicate that it is not just an
289 // alternate form of getName(), and clients should move as appropriate.
290 //
291 // FIXME: Deprecated, move clients to getName().
292 std::string getNameAsString() const { return Name.getAsString(); }
293
294 /// Pretty-print the unqualified name of this declaration. Can be overloaded
295 /// by derived classes to provide a more user-friendly name when appropriate.
296 virtual void printName(raw_ostream &os) const;
297
298 /// Get the actual, stored name of the declaration, which may be a special
299 /// name.
300 ///
301 /// Note that generally in diagnostics, the non-null \p NamedDecl* itself
302 /// should be sent into the diagnostic instead of using the result of
303 /// \p getDeclName().
304 ///
305 /// A \p DeclarationName in a diagnostic will just be streamed to the output,
306 /// which will directly result in a call to \p DeclarationName::print.
307 ///
308 /// A \p NamedDecl* in a diagnostic will also ultimately result in a call to
309 /// \p DeclarationName::print, but with two customisation points along the
310 /// way (\p getNameForDiagnostic and \p printName). These are used to print
311 /// the template arguments if any, and to provide a user-friendly name for
312 /// some entities (such as unnamed variables and anonymous records).
313 DeclarationName getDeclName() const { return Name; }
314
315 /// Set the name of this declaration.
316 void setDeclName(DeclarationName N) { Name = N; }
317
318 /// Returns a human-readable qualified name for this declaration, like
319 /// A::B::i, for i being member of namespace A::B.
320 ///
321 /// If the declaration is not a member of context which can be named (record,
322 /// namespace), it will return the same result as printName().
323 ///
324 /// Creating this name is expensive, so it should be called only when
325 /// performance doesn't matter.
326 void printQualifiedName(raw_ostream &OS) const;
327 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
328
329 /// Print only the nested name specifier part of a fully-qualified name,
330 /// including the '::' at the end. E.g.
331 /// when `printQualifiedName(D)` prints "A::B::i",
332 /// this function prints "A::B::".
333 void printNestedNameSpecifier(raw_ostream &OS) const;
334 void printNestedNameSpecifier(raw_ostream &OS,
335 const PrintingPolicy &Policy) const;
336
337 // FIXME: Remove string version.
338 std::string getQualifiedNameAsString() const;
339
340 /// Appends a human-readable name for this declaration into the given stream.
341 ///
342 /// This is the method invoked by Sema when displaying a NamedDecl
343 /// in a diagnostic. It does not necessarily produce the same
344 /// result as printName(); for example, class template
345 /// specializations are printed with their template arguments.
346 virtual void getNameForDiagnostic(raw_ostream &OS,
347 const PrintingPolicy &Policy,
348 bool Qualified) const;
349
350 /// Determine whether this declaration, if known to be well-formed within
351 /// its context, will replace the declaration OldD if introduced into scope.
352 ///
353 /// A declaration will replace another declaration if, for example, it is
354 /// a redeclaration of the same variable or function, but not if it is a
355 /// declaration of a different kind (function vs. class) or an overloaded
356 /// function.
357 ///
358 /// \param IsKnownNewer \c true if this declaration is known to be newer
359 /// than \p OldD (for instance, if this declaration is newly-created).
360 bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
361
362 /// Determine whether this declaration has linkage.
363 bool hasLinkage() const;
364
365 using Decl::isModulePrivate;
366 using Decl::setModulePrivate;
367
368 /// Determine whether this declaration is a C++ class member.
369 bool isCXXClassMember() const {
370 const DeclContext *DC = getDeclContext();
371
372 // C++0x [class.mem]p1:
373 // The enumerators of an unscoped enumeration defined in
374 // the class are members of the class.
375 if (isa<EnumDecl>(DC))
376 DC = DC->getRedeclContext();
377
378 return DC->isRecord();
379 }
380
381 /// Determine whether the given declaration is an instance member of
382 /// a C++ class.
383 bool isCXXInstanceMember() const;
384
385 /// Determine if the declaration obeys the reserved identifier rules of the
386 /// given language.
387 ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
388
389 /// Determine what kind of linkage this entity has.
390 ///
391 /// This is not the linkage as defined by the standard or the codegen notion
392 /// of linkage. It is just an implementation detail that is used to compute
393 /// those.
394 Linkage getLinkageInternal() const;
395
396 /// Get the linkage from a semantic point of view. Entities in
397 /// anonymous namespaces are external (in c++98).
398 Linkage getFormalLinkage() const {
399 return clang::getFormalLinkage(getLinkageInternal());
400 }
401
402 /// True if this decl has external linkage.
403 bool hasExternalFormalLinkage() const {
404 return isExternalFormalLinkage(getLinkageInternal());
405 }
406
407 bool isExternallyVisible() const {
408 return clang::isExternallyVisible(getLinkageInternal());
409 }
410
411 /// Determine whether this declaration can be redeclared in a
412 /// different translation unit.
413 bool isExternallyDeclarable() const {
414 return isExternallyVisible() && !getOwningModuleForLinkage();
415 }
416
417 /// Determines the visibility of this entity.
418 Visibility getVisibility() const {
419 return getLinkageAndVisibility().getVisibility();
420 }
421
422 /// Determines the linkage and visibility of this entity.
423 LinkageInfo getLinkageAndVisibility() const;
424
425 /// Kinds of explicit visibility.
426 enum ExplicitVisibilityKind {
427 /// Do an LV computation for, ultimately, a type.
428 /// Visibility may be restricted by type visibility settings and
429 /// the visibility of template arguments.
430 VisibilityForType,
431
432 /// Do an LV computation for, ultimately, a non-type declaration.
433 /// Visibility may be restricted by value visibility settings and
434 /// the visibility of template arguments.
435 VisibilityForValue
436 };
437
438 /// If visibility was explicitly specified for this
439 /// declaration, return that visibility.
440 Optional<Visibility>
441 getExplicitVisibility(ExplicitVisibilityKind kind) const;
442
443 /// True if the computed linkage is valid. Used for consistency
444 /// checking. Should always return true.
445 bool isLinkageValid() const;
446
447 /// True if something has required us to compute the linkage
448 /// of this declaration.
449 ///
450 /// Language features which can retroactively change linkage (like a
451 /// typedef name for linkage purposes) may need to consider this,
452 /// but hopefully only in transitory ways during parsing.
453 bool hasLinkageBeenComputed() const {
454 return hasCachedLinkage();
455 }
456
457 /// Looks through UsingDecls and ObjCCompatibleAliasDecls for
458 /// the underlying named decl.
459 NamedDecl *getUnderlyingDecl() {
460 // Fast-path the common case.
461 if (this->getKind() != UsingShadow &&
462 this->getKind() != ConstructorUsingShadow &&
463 this->getKind() != ObjCCompatibleAlias &&
464 this->getKind() != NamespaceAlias)
465 return this;
466
467 return getUnderlyingDeclImpl();
468 }
469 const NamedDecl *getUnderlyingDecl() const {
470 return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
471 }
472
473 NamedDecl *getMostRecentDecl() {
474 return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
475 }
476 const NamedDecl *getMostRecentDecl() const {
477 return const_cast<NamedDecl*>(this)->getMostRecentDecl();
478 }
479
480 ObjCStringFormatFamily getObjCFStringFormattingFamily() const;
481
482 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
483 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
484};
485
486inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
487 ND.printName(OS);
488 return OS;
489}
490
491/// Represents the declaration of a label. Labels also have a
492/// corresponding LabelStmt, which indicates the position that the label was
493/// defined at. For normal labels, the location of the decl is the same as the
494/// location of the statement. For GNU local labels (__label__), the decl
495/// location is where the __label__ is.
496class LabelDecl : public NamedDecl {
497 LabelStmt *TheStmt;
498 StringRef MSAsmName;
499 bool MSAsmNameResolved = false;
500
501 /// For normal labels, this is the same as the main declaration
502 /// label, i.e., the location of the identifier; for GNU local labels,
503 /// this is the location of the __label__ keyword.
504 SourceLocation LocStart;
505
506 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
507 LabelStmt *S, SourceLocation StartL)
508 : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
509
510 void anchor() override;
511
512public:
513 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
514 SourceLocation IdentL, IdentifierInfo *II);
515 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
516 SourceLocation IdentL, IdentifierInfo *II,
517 SourceLocation GnuLabelL);
518 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
519
520 LabelStmt *getStmt() const { return TheStmt; }
521 void setStmt(LabelStmt *T) { TheStmt = T; }
522
523 bool isGnuLocal() const { return LocStart != getLocation(); }
524 void setLocStart(SourceLocation L) { LocStart = L; }
525
526 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
527 return SourceRange(LocStart, getLocation());
528 }
529
530 bool isMSAsmLabel() const { return !MSAsmName.empty(); }
531 bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
532 void setMSAsmLabel(StringRef Name);
533 StringRef getMSAsmLabel() const { return MSAsmName; }
534 void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
535
536 // Implement isa/cast/dyncast/etc.
537 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
538 static bool classofKind(Kind K) { return K == Label; }
539};
540
541/// Represent a C++ namespace.
542class NamespaceDecl : public NamedDecl, public DeclContext,
543 public Redeclarable<NamespaceDecl>
544{
545 /// The starting location of the source range, pointing
546 /// to either the namespace or the inline keyword.
547 SourceLocation LocStart;
548
549 /// The ending location of the source range.
550 SourceLocation RBraceLoc;
551
552 /// A pointer to either the anonymous namespace that lives just inside
553 /// this namespace or to the first namespace in the chain (the latter case
554 /// only when this is not the first in the chain), along with a
555 /// boolean value indicating whether this is an inline namespace.
556 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
557
558 NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
559 SourceLocation StartLoc, SourceLocation IdLoc,
560 IdentifierInfo *Id, NamespaceDecl *PrevDecl);
561
562 using redeclarable_base = Redeclarable<NamespaceDecl>;
563
564 NamespaceDecl *getNextRedeclarationImpl() override;
565 NamespaceDecl *getPreviousDeclImpl() override;
566 NamespaceDecl *getMostRecentDeclImpl() override;
567
568public:
569 friend class ASTDeclReader;
570 friend class ASTDeclWriter;
571
572 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
573 bool Inline, SourceLocation StartLoc,
574 SourceLocation IdLoc, IdentifierInfo *Id,
575 NamespaceDecl *PrevDecl);
576
577 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
578
579 using redecl_range = redeclarable_base::redecl_range;
580 using redecl_iterator = redeclarable_base::redecl_iterator;
581
582 using redeclarable_base::redecls_begin;
583 using redeclarable_base::redecls_end;
584 using redeclarable_base::redecls;
585 using redeclarable_base::getPreviousDecl;
586 using redeclarable_base::getMostRecentDecl;
587 using redeclarable_base::isFirstDecl;
588
589 /// Returns true if this is an anonymous namespace declaration.
590 ///
591 /// For example:
592 /// \code
593 /// namespace {
594 /// ...
595 /// };
596 /// \endcode
597 /// q.v. C++ [namespace.unnamed]
598 bool isAnonymousNamespace() const {
599 return !getIdentifier();
600 }
601
602 /// Returns true if this is an inline namespace declaration.
603 bool isInline() const {
604 return AnonOrFirstNamespaceAndInline.getInt();
605 }
606
607 /// Set whether this is an inline namespace declaration.
608 void setInline(bool Inline) {
609 AnonOrFirstNamespaceAndInline.setInt(Inline);
610 }
611
612 /// Returns true if the inline qualifier for \c Name is redundant.
613 bool isRedundantInlineQualifierFor(DeclarationName Name) const {
614 if (!isInline())
615 return false;
616 auto X = lookup(Name);
617 auto Y = getParent()->lookup(Name);
618 return std::distance(X.begin(), X.end()) ==
619 std::distance(Y.begin(), Y.end());
620 }
621
622 /// Get the original (first) namespace declaration.
623 NamespaceDecl *getOriginalNamespace();
624
625 /// Get the original (first) namespace declaration.
626 const NamespaceDecl *getOriginalNamespace() const;
627
628 /// Return true if this declaration is an original (first) declaration
629 /// of the namespace. This is false for non-original (subsequent) namespace
630 /// declarations and anonymous namespaces.
631 bool isOriginalNamespace() const;
632
633 /// Retrieve the anonymous namespace nested inside this namespace,
634 /// if any.
635 NamespaceDecl *getAnonymousNamespace() const {
636 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
637 }
638
639 void setAnonymousNamespace(NamespaceDecl *D) {
640 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
641 }
642
643 /// Retrieves the canonical declaration of this namespace.
644 NamespaceDecl *getCanonicalDecl() override {
645 return getOriginalNamespace();
646 }
647 const NamespaceDecl *getCanonicalDecl() const {
648 return getOriginalNamespace();
649 }
650
651 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
652 return SourceRange(LocStart, RBraceLoc);
653 }
654
655 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
656 SourceLocation getRBraceLoc() const { return RBraceLoc; }
657 void setLocStart(SourceLocation L) { LocStart = L; }
658 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
659
660 // Implement isa/cast/dyncast/etc.
661 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
662 static bool classofKind(Kind K) { return K == Namespace; }
663 static DeclContext *castToDeclContext(const NamespaceDecl *D) {
664 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
665 }
666 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
667 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
668 }
669};
670
671/// Represent the declaration of a variable (in which case it is
672/// an lvalue) a function (in which case it is a function designator) or
673/// an enum constant.
674class ValueDecl : public NamedDecl {
675 QualType DeclType;
676
677 void anchor() override;
678
679protected:
680 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
681 DeclarationName N, QualType T)
682 : NamedDecl(DK, DC, L, N), DeclType(T) {}
683
684public:
685 QualType getType() const { return DeclType; }
686 void setType(QualType newType) { DeclType = newType; }
687
688 /// Determine whether this symbol is weakly-imported,
689 /// or declared with the weak or weak-ref attr.
690 bool isWeak() const;
691
692 // Implement isa/cast/dyncast/etc.
693 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
694 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
695};
696
697/// A struct with extended info about a syntactic
698/// name qualifier, to be used for the case of out-of-line declarations.
699struct QualifierInfo {
700 NestedNameSpecifierLoc QualifierLoc;
701
702 /// The number of "outer" template parameter lists.
703 /// The count includes all of the template parameter lists that were matched
704 /// against the template-ids occurring into the NNS and possibly (in the
705 /// case of an explicit specialization) a final "template <>".
706 unsigned NumTemplParamLists = 0;
707
708 /// A new-allocated array of size NumTemplParamLists,
709 /// containing pointers to the "outer" template parameter lists.
710 /// It includes all of the template parameter lists that were matched
711 /// against the template-ids occurring into the NNS and possibly (in the
712 /// case of an explicit specialization) a final "template <>".
713 TemplateParameterList** TemplParamLists = nullptr;
714
715 QualifierInfo() = default;
716 QualifierInfo(const QualifierInfo &) = delete;
717 QualifierInfo& operator=(const QualifierInfo &) = delete;
718
719 /// Sets info about "outer" template parameter lists.
720 void setTemplateParameterListsInfo(ASTContext &Context,
721 ArrayRef<TemplateParameterList *> TPLists);
722};
723
724/// Represents a ValueDecl that came out of a declarator.
725/// Contains type source information through TypeSourceInfo.
726class DeclaratorDecl : public ValueDecl {
727 // A struct representing a TInfo, a trailing requires-clause and a syntactic
728 // qualifier, to be used for the (uncommon) case of out-of-line declarations
729 // and constrained function decls.
730 struct ExtInfo : public QualifierInfo {
731 TypeSourceInfo *TInfo;
732 Expr *TrailingRequiresClause = nullptr;
733 };
734
735 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
736
737 /// The start of the source range for this declaration,
738 /// ignoring outer template declarations.
739 SourceLocation InnerLocStart;
740
741 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
742 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
743 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
744
745protected:
746 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
747 DeclarationName N, QualType T, TypeSourceInfo *TInfo,
748 SourceLocation StartL)
749 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
750
751public:
752 friend class ASTDeclReader;
753 friend class ASTDeclWriter;
754
755 TypeSourceInfo *getTypeSourceInfo() const {
756 return hasExtInfo()
757 ? getExtInfo()->TInfo
758 : DeclInfo.get<TypeSourceInfo*>();
759 }
760
761 void setTypeSourceInfo(TypeSourceInfo *TI) {
762 if (hasExtInfo())
763 getExtInfo()->TInfo = TI;
764 else
765 DeclInfo = TI;
766 }
767
768 /// Return start of source range ignoring outer template declarations.
769 SourceLocation getInnerLocStart() const { return InnerLocStart; }
770 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
771
772 /// Return start of source range taking into account any outer template
773 /// declarations.
774 SourceLocation getOuterLocStart() const;
775
776 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
777
778 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
779 return getOuterLocStart();
780 }
781
782 /// Retrieve the nested-name-specifier that qualifies the name of this
783 /// declaration, if it was present in the source.
784 NestedNameSpecifier *getQualifier() const {
785 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
786 : nullptr;
787 }
788
789 /// Retrieve the nested-name-specifier (with source-location
790 /// information) that qualifies the name of this declaration, if it was
791 /// present in the source.
792 NestedNameSpecifierLoc getQualifierLoc() const {
793 return hasExtInfo() ? getExtInfo()->QualifierLoc
794 : NestedNameSpecifierLoc();
795 }
796
797 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
798
799 /// \brief Get the constraint-expression introduced by the trailing
800 /// requires-clause in the function/member declaration, or null if no
801 /// requires-clause was provided.
802 Expr *getTrailingRequiresClause() {
803 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
804 : nullptr;
805 }
806
807 const Expr *getTrailingRequiresClause() const {
808 return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
809 : nullptr;
810 }
811
812 void setTrailingRequiresClause(Expr *TrailingRequiresClause);
813
814 unsigned getNumTemplateParameterLists() const {
815 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
816 }
817
818 TemplateParameterList *getTemplateParameterList(unsigned index) const {
819 assert(index < getNumTemplateParameterLists())((void)0);
820 return getExtInfo()->TemplParamLists[index];
821 }
822
823 void setTemplateParameterListsInfo(ASTContext &Context,
824 ArrayRef<TemplateParameterList *> TPLists);
825
826 SourceLocation getTypeSpecStartLoc() const;
827 SourceLocation getTypeSpecEndLoc() const;
828
829 // Implement isa/cast/dyncast/etc.
830 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
831 static bool classofKind(Kind K) {
832 return K >= firstDeclarator && K <= lastDeclarator;
833 }
834};
835
836/// Structure used to store a statement, the constant value to
837/// which it was evaluated (if any), and whether or not the statement
838/// is an integral constant expression (if known).
839struct EvaluatedStmt {
840 /// Whether this statement was already evaluated.
841 bool WasEvaluated : 1;
842
843 /// Whether this statement is being evaluated.
844 bool IsEvaluating : 1;
845
846 /// Whether this variable is known to have constant initialization. This is
847 /// currently only computed in C++, for static / thread storage duration
848 /// variables that might have constant initialization and for variables that
849 /// are usable in constant expressions.
850 bool HasConstantInitialization : 1;
851
852 /// Whether this variable is known to have constant destruction. That is,
853 /// whether running the destructor on the initial value is a side-effect
854 /// (and doesn't inspect any state that might have changed during program
855 /// execution). This is currently only computed if the destructor is
856 /// non-trivial.
857 bool HasConstantDestruction : 1;
858
859 /// In C++98, whether the initializer is an ICE. This affects whether the
860 /// variable is usable in constant expressions.
861 bool HasICEInit : 1;
862 bool CheckedForICEInit : 1;
863
864 Stmt *Value;
865 APValue Evaluated;
866
867 EvaluatedStmt()
868 : WasEvaluated(false), IsEvaluating(false),
869 HasConstantInitialization(false), HasConstantDestruction(false),
870 HasICEInit(false), CheckedForICEInit(false) {}
871};
872
873/// Represents a variable declaration or definition.
874class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
875public:
876 /// Initialization styles.
877 enum InitializationStyle {
878 /// C-style initialization with assignment
879 CInit,
880
881 /// Call-style initialization (C++98)
882 CallInit,
883
884 /// Direct list-initialization (C++11)
885 ListInit
886 };
887
888 /// Kinds of thread-local storage.
889 enum TLSKind {
890 /// Not a TLS variable.
891 TLS_None,
892
893 /// TLS with a known-constant initializer.
894 TLS_Static,
895
896 /// TLS with a dynamic initializer.
897 TLS_Dynamic
898 };
899
900 /// Return the string used to specify the storage class \p SC.
901 ///
902 /// It is illegal to call this function with SC == None.
903 static const char *getStorageClassSpecifierString(StorageClass SC);
904
905protected:
906 // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
907 // have allocated the auxiliary struct of information there.
908 //
909 // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
910 // this as *many* VarDecls are ParmVarDecls that don't have default
911 // arguments. We could save some space by moving this pointer union to be
912 // allocated in trailing space when necessary.
913 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
914
915 /// The initializer for this variable or, for a ParmVarDecl, the
916 /// C++ default argument.
917 mutable InitType Init;
918
919private:
920 friend class ASTDeclReader;
921 friend class ASTNodeImporter;
922 friend class StmtIteratorBase;
923
924 class VarDeclBitfields {
925 friend class ASTDeclReader;
926 friend class VarDecl;
927
928 unsigned SClass : 3;
929 unsigned TSCSpec : 2;
930 unsigned InitStyle : 2;
931
932 /// Whether this variable is an ARC pseudo-__strong variable; see
933 /// isARCPseudoStrong() for details.
934 unsigned ARCPseudoStrong : 1;
935 };
936 enum { NumVarDeclBits = 8 };
937
938protected:
939 enum { NumParameterIndexBits = 8 };
940
941 enum DefaultArgKind {
942 DAK_None,
943 DAK_Unparsed,
944 DAK_Uninstantiated,
945 DAK_Normal
946 };
947
948 enum { NumScopeDepthOrObjCQualsBits = 7 };
949
950 class ParmVarDeclBitfields {
951 friend class ASTDeclReader;
952 friend class ParmVarDecl;
953
954 unsigned : NumVarDeclBits;
955
956 /// Whether this parameter inherits a default argument from a
957 /// prior declaration.
958 unsigned HasInheritedDefaultArg : 1;
959
960 /// Describes the kind of default argument for this parameter. By default
961 /// this is none. If this is normal, then the default argument is stored in
962 /// the \c VarDecl initializer expression unless we were unable to parse
963 /// (even an invalid) expression for the default argument.
964 unsigned DefaultArgKind : 2;
965
966 /// Whether this parameter undergoes K&R argument promotion.
967 unsigned IsKNRPromoted : 1;
968
969 /// Whether this parameter is an ObjC method parameter or not.
970 unsigned IsObjCMethodParam : 1;
971
972 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
973 /// Otherwise, the number of function parameter scopes enclosing
974 /// the function parameter scope in which this parameter was
975 /// declared.
976 unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;
977
978 /// The number of parameters preceding this parameter in the
979 /// function parameter scope in which it was declared.
980 unsigned ParameterIndex : NumParameterIndexBits;
981 };
982
983 class NonParmVarDeclBitfields {
984 friend class ASTDeclReader;
985 friend class ImplicitParamDecl;
986 friend class VarDecl;
987
988 unsigned : NumVarDeclBits;
989
990 // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
991 /// Whether this variable is a definition which was demoted due to
992 /// module merge.
993 unsigned IsThisDeclarationADemotedDefinition : 1;
994
995 /// Whether this variable is the exception variable in a C++ catch
996 /// or an Objective-C @catch statement.
997 unsigned ExceptionVar : 1;
998
999 /// Whether this local variable could be allocated in the return
1000 /// slot of its function, enabling the named return value optimization
1001 /// (NRVO).
1002 unsigned NRVOVariable : 1;
1003
1004 /// Whether this variable is the for-range-declaration in a C++0x
1005 /// for-range statement.
1006 unsigned CXXForRangeDecl : 1;
1007
1008 /// Whether this variable is the for-in loop declaration in Objective-C.
1009 unsigned ObjCForDecl : 1;
1010
1011 /// Whether this variable is (C++1z) inline.
1012 unsigned IsInline : 1;
1013
1014 /// Whether this variable has (C++1z) inline explicitly specified.
1015 unsigned IsInlineSpecified : 1;
1016
1017 /// Whether this variable is (C++0x) constexpr.
1018 unsigned IsConstexpr : 1;
1019
1020 /// Whether this variable is the implicit variable for a lambda
1021 /// init-capture.
1022 unsigned IsInitCapture : 1;
1023
1024 /// Whether this local extern variable's previous declaration was
1025 /// declared in the same block scope. This controls whether we should merge
1026 /// the type of this declaration with its previous declaration.
1027 unsigned PreviousDeclInSameBlockScope : 1;
1028
1029 /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
1030 /// something else.
1031 unsigned ImplicitParamKind : 3;
1032
1033 unsigned EscapingByref : 1;
1034 };
1035
1036 union {
1037 unsigned AllBits;
1038 VarDeclBitfields VarDeclBits;
1039 ParmVarDeclBitfields ParmVarDeclBits;
1040 NonParmVarDeclBitfields NonParmVarDeclBits;
1041 };
1042
1043 VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1044 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1045 TypeSourceInfo *TInfo, StorageClass SC);
1046
1047 using redeclarable_base = Redeclarable<VarDecl>;
1048
1049 VarDecl *getNextRedeclarationImpl() override {
1050 return getNextRedeclaration();
1051 }
1052
1053 VarDecl *getPreviousDeclImpl() override {
1054 return getPreviousDecl();
1055 }
1056
1057 VarDecl *getMostRecentDeclImpl() override {
1058 return getMostRecentDecl();
1059 }
1060
1061public:
1062 using redecl_range = redeclarable_base::redecl_range;
1063 using redecl_iterator = redeclarable_base::redecl_iterator;
1064
1065 using redeclarable_base::redecls_begin;
1066 using redeclarable_base::redecls_end;
1067 using redeclarable_base::redecls;
1068 using redeclarable_base::getPreviousDecl;
1069 using redeclarable_base::getMostRecentDecl;
1070 using redeclarable_base::isFirstDecl;
1071
1072 static VarDecl *Create(ASTContext &C, DeclContext *DC,
1073 SourceLocation StartLoc, SourceLocation IdLoc,
1074 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1075 StorageClass S);
1076
1077 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1078
1079 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
1080
1081 /// Returns the storage class as written in the source. For the
1082 /// computed linkage of symbol, see getLinkage.
1083 StorageClass getStorageClass() const {
1084 return (StorageClass) VarDeclBits.SClass;
1085 }
1086 void setStorageClass(StorageClass SC);
1087
1088 void setTSCSpec(ThreadStorageClassSpecifier TSC) {
1089 VarDeclBits.TSCSpec = TSC;
1090 assert(VarDeclBits.TSCSpec == TSC && "truncation")((void)0);
1091 }
1092 ThreadStorageClassSpecifier getTSCSpec() const {
1093 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
1094 }
1095 TLSKind getTLSKind() const;
1096
1097 /// Returns true if a variable with function scope is a non-static local
1098 /// variable.
1099 bool hasLocalStorage() const {
1100 if (getStorageClass() == SC_None) {
1101 // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
1102 // used to describe variables allocated in global memory and which are
1103 // accessed inside a kernel(s) as read-only variables. As such, variables
1104 // in constant address space cannot have local storage.
1105 if (getType().getAddressSpace() == LangAS::opencl_constant)
1106 return false;
1107 // Second check is for C++11 [dcl.stc]p4.
1108 return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
1109 }
1110
1111 // Global Named Register (GNU extension)
1112 if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
1113 return false;
1114
1115 // Return true for: Auto, Register.
1116 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
1117
1118 return getStorageClass() >= SC_Auto;
1119 }
1120
1121 /// Returns true if a variable with function scope is a static local
1122 /// variable.
1123 bool isStaticLocal() const {
1124 return (getStorageClass() == SC_Static ||
1125 // C++11 [dcl.stc]p4
1126 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
1127 && !isFileVarDecl();
1128 }
1129
1130 /// Returns true if a variable has extern or __private_extern__
1131 /// storage.
1132 bool hasExternalStorage() const {
1133 return getStorageClass() == SC_Extern ||
1134 getStorageClass() == SC_PrivateExtern;
1135 }
1136
1137 /// Returns true for all variables that do not have local storage.
1138 ///
1139 /// This includes all global variables as well as static variables declared
1140 /// within a function.
1141 bool hasGlobalStorage() const { return !hasLocalStorage(); }
1142
1143 /// Get the storage duration of this variable, per C++ [basic.stc].
1144 StorageDuration getStorageDuration() const {
1145 return hasLocalStorage() ? SD_Automatic :
1146 getTSCSpec() ? SD_Thread : SD_Static;
1147 }
1148
1149 /// Compute the language linkage.
1150 LanguageLinkage getLanguageLinkage() const;
1151
1152 /// Determines whether this variable is a variable with external, C linkage.
1153 bool isExternC() const;
1154
1155 /// Determines whether this variable's context is, or is nested within,
1156 /// a C++ extern "C" linkage spec.
1157 bool isInExternCContext() const;
1158
1159 /// Determines whether this variable's context is, or is nested within,
1160 /// a C++ extern "C++" linkage spec.
1161 bool isInExternCXXContext() const;
1162
1163 /// Returns true for local variable declarations other than parameters.
1164 /// Note that this includes static variables inside of functions. It also
1165 /// includes variables inside blocks.
1166 ///
1167 /// void foo() { int x; static int y; extern int z; }
1168 bool isLocalVarDecl() const {
1169 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1170 return false;
1171 if (const DeclContext *DC = getLexicalDeclContext())
1172 return DC->getRedeclContext()->isFunctionOrMethod();
1173 return false;
1174 }
1175
1176 /// Similar to isLocalVarDecl but also includes parameters.
1177 bool isLocalVarDeclOrParm() const {
1178 return isLocalVarDecl() || getKind() == Decl::ParmVar;
1179 }
1180
1181 /// Similar to isLocalVarDecl, but excludes variables declared in blocks.
1182 bool isFunctionOrMethodVarDecl() const {
1183 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1184 return false;
1185 const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
1186 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1187 }
1188
1189 /// Determines whether this is a static data member.
1190 ///
1191 /// This will only be true in C++, and applies to, e.g., the
1192 /// variable 'x' in:
1193 /// \code
1194 /// struct S {
1195 /// static int x;
1196 /// };
1197 /// \endcode
1198 bool isStaticDataMember() const {
1199 // If it wasn't static, it would be a FieldDecl.
1200 return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1201 }
1202
1203 VarDecl *getCanonicalDecl() override;
1204 const VarDecl *getCanonicalDecl() const {
1205 return const_cast<VarDecl*>(this)->getCanonicalDecl();
1206 }
1207
1208 enum DefinitionKind {
1209 /// This declaration is only a declaration.
1210 DeclarationOnly,
1211
1212 /// This declaration is a tentative definition.
1213 TentativeDefinition,
1214
1215 /// This declaration is definitely a definition.
1216 Definition
1217 };
1218
1219 /// Check whether this declaration is a definition. If this could be
1220 /// a tentative definition (in C), don't check whether there's an overriding
1221 /// definition.
1222 DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
1223 DefinitionKind isThisDeclarationADefinition() const {
1224 return isThisDeclarationADefinition(getASTContext());
1225 }
1226
1227 /// Check whether this variable is defined in this translation unit.
1228 DefinitionKind hasDefinition(ASTContext &) const;
1229 DefinitionKind hasDefinition() const {
1230 return hasDefinition(getASTContext());
1231 }
1232
1233 /// Get the tentative definition that acts as the real definition in a TU.
1234 /// Returns null if there is a proper definition available.
1235 VarDecl *getActingDefinition();
1236 const VarDecl *getActingDefinition() const {
1237 return const_cast<VarDecl*>(this)->getActingDefinition();
1238 }
1239
1240 /// Get the real (not just tentative) definition for this declaration.
1241 VarDecl *getDefinition(ASTContext &);
1242 const VarDecl *getDefinition(ASTContext &C) const {
1243 return const_cast<VarDecl*>(this)->getDefinition(C);
1244 }
1245 VarDecl *getDefinition() {
1246 return getDefinition(getASTContext());
1247 }
1248 const VarDecl *getDefinition() const {
1249 return const_cast<VarDecl*>(this)->getDefinition();
1250 }
1251
1252 /// Determine whether this is or was instantiated from an out-of-line
1253 /// definition of a static data member.
1254 bool isOutOfLine() const override;
1255
1256 /// Returns true for file scoped variable declaration.
1257 bool isFileVarDecl() const {
1258 Kind K = getKind();
1259 if (K == ParmVar || K == ImplicitParam)
1260 return false;
1261
1262 if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1263 return true;
1264
1265 if (isStaticDataMember())
1266 return true;
1267
1268 return false;
1269 }
1270
1271 /// Get the initializer for this variable, no matter which
1272 /// declaration it is attached to.
1273 const Expr *getAnyInitializer() const {
1274 const VarDecl *D;
1275 return getAnyInitializer(D);
1276 }
1277
1278 /// Get the initializer for this variable, no matter which
1279 /// declaration it is attached to. Also get that declaration.
1280 const Expr *getAnyInitializer(const VarDecl *&D) const;
1281
1282 bool hasInit() const;
1283 const Expr *getInit() const {
1284 return const_cast<VarDecl *>(this)->getInit();
1285 }
1286 Expr *getInit();
1287
1288 /// Retrieve the address of the initializer expression.
1289 Stmt **getInitAddress();
1290
1291 void setInit(Expr *I);
1292
1293 /// Get the initializing declaration of this variable, if any. This is
1294 /// usually the definition, except that for a static data member it can be
1295 /// the in-class declaration.
1296 VarDecl *getInitializingDeclaration();
1297 const VarDecl *getInitializingDeclaration() const {
1298 return const_cast<VarDecl *>(this)->getInitializingDeclaration();
1299 }
1300
1301 /// Determine whether this variable's value might be usable in a
1302 /// constant expression, according to the relevant language standard.
1303 /// This only checks properties of the declaration, and does not check
1304 /// whether the initializer is in fact a constant expression.
1305 ///
1306 /// This corresponds to C++20 [expr.const]p3's notion of a
1307 /// "potentially-constant" variable.
1308 bool mightBeUsableInConstantExpressions(const ASTContext &C) const;
1309
1310 /// Determine whether this variable's value can be used in a
1311 /// constant expression, according to the relevant language standard,
1312 /// including checking whether it was initialized by a constant expression.
1313 bool isUsableInConstantExpressions(const ASTContext &C) const;
1314
1315 EvaluatedStmt *ensureEvaluatedStmt() const;
1316 EvaluatedStmt *getEvaluatedStmt() const;
1317
1318 /// Attempt to evaluate the value of the initializer attached to this
1319 /// declaration, and produce notes explaining why it cannot be evaluated.
1320 /// Returns a pointer to the value if evaluation succeeded, 0 otherwise.
1321 APValue *evaluateValue() const;
1322
1323private:
1324 APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
1325 bool IsConstantInitialization) const;
1326
1327public:
1328 /// Return the already-evaluated value of this variable's
1329 /// initializer, or NULL if the value is not yet known. Returns pointer
1330 /// to untyped APValue if the value could not be evaluated.
1331 APValue *getEvaluatedValue() const;
1332
1333 /// Evaluate the destruction of this variable to determine if it constitutes
1334 /// constant destruction.
1335 ///
1336 /// \pre hasConstantInitialization()
1337 /// \return \c true if this variable has constant destruction, \c false if
1338 /// not.
1339 bool evaluateDestruction(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1340
1341 /// Determine whether this variable has constant initialization.
1342 ///
1343 /// This is only set in two cases: when the language semantics require
1344 /// constant initialization (globals in C and some globals in C++), and when
1345 /// the variable is usable in constant expressions (constexpr, const int, and
1346 /// reference variables in C++).
1347 bool hasConstantInitialization() const;
1348
1349 /// Determine whether the initializer of this variable is an integer constant
1350 /// expression. For use in C++98, where this affects whether the variable is
1351 /// usable in constant expressions.
1352 bool hasICEInitializer(const ASTContext &Context) const;
1353
1354 /// Evaluate the initializer of this variable to determine whether it's a
1355 /// constant initializer. Should only be called once, after completing the
1356 /// definition of the variable.
1357 bool checkForConstantInitialization(
1358 SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1359
1360 void setInitStyle(InitializationStyle Style) {
1361 VarDeclBits.InitStyle = Style;
1362 }
1363
1364 /// The style of initialization for this declaration.
1365 ///
1366 /// C-style initialization is "int x = 1;". Call-style initialization is
1367 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1368 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1369 /// expression for class types. List-style initialization is C++11 syntax,
1370 /// e.g. "int x{1};". Clients can distinguish between different forms of
1371 /// initialization by checking this value. In particular, "int x = {1};" is
1372 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1373 /// Init expression in all three cases is an InitListExpr.
1374 InitializationStyle getInitStyle() const {
1375 return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1376 }
1377
1378 /// Whether the initializer is a direct-initializer (list or call).
1379 bool isDirectInit() const {
1380 return getInitStyle() != CInit;
1381 }
1382
1383 /// If this definition should pretend to be a declaration.
1384 bool isThisDeclarationADemotedDefinition() const {
1385 return isa<ParmVarDecl>(this) ? false :
1386 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1387 }
1388
1389 /// This is a definition which should be demoted to a declaration.
1390 ///
1391 /// In some cases (mostly module merging) we can end up with two visible
1392 /// definitions one of which needs to be demoted to a declaration to keep
1393 /// the AST invariants.
1394 void demoteThisDefinitionToDeclaration() {
1395 assert(isThisDeclarationADefinition() && "Not a definition!")((void)0);
1396 assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!")((void)0);
1397 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1398 }
1399
1400 /// Determine whether this variable is the exception variable in a
1401 /// C++ catch statememt or an Objective-C \@catch statement.
1402 bool isExceptionVariable() const {
1403 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1404 }
1405 void setExceptionVariable(bool EV) {
1406 assert(!isa<ParmVarDecl>(this))((void)0);
1407 NonParmVarDeclBits.ExceptionVar = EV;
1408 }
1409
1410 /// Determine whether this local variable can be used with the named
1411 /// return value optimization (NRVO).
1412 ///
1413 /// The named return value optimization (NRVO) works by marking certain
1414 /// non-volatile local variables of class type as NRVO objects. These
1415 /// locals can be allocated within the return slot of their containing
1416 /// function, in which case there is no need to copy the object to the
1417 /// return slot when returning from the function. Within the function body,
1418 /// each return that returns the NRVO object will have this variable as its
1419 /// NRVO candidate.
1420 bool isNRVOVariable() const {
1421 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1422 }
1423 void setNRVOVariable(bool NRVO) {
1424 assert(!isa<ParmVarDecl>(this))((void)0);
1425 NonParmVarDeclBits.NRVOVariable = NRVO;
1426 }
1427
1428 /// Determine whether this variable is the for-range-declaration in
1429 /// a C++0x for-range statement.
1430 bool isCXXForRangeDecl() const {
1431 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1432 }
1433 void setCXXForRangeDecl(bool FRD) {
1434 assert(!isa<ParmVarDecl>(this))((void)0);
1435 NonParmVarDeclBits.CXXForRangeDecl = FRD;
1436 }
1437
1438 /// Determine whether this variable is a for-loop declaration for a
1439 /// for-in statement in Objective-C.
1440 bool isObjCForDecl() const {
1441 return NonParmVarDeclBits.ObjCForDecl;
1442 }
1443
1444 void setObjCForDecl(bool FRD) {
1445 NonParmVarDeclBits.ObjCForDecl = FRD;
1446 }
1447
1448 /// Determine whether this variable is an ARC pseudo-__strong variable. A
1449 /// pseudo-__strong variable has a __strong-qualified type but does not
1450 /// actually retain the object written into it. Generally such variables are
1451 /// also 'const' for safety. There are 3 cases where this will be set, 1) if
1452 /// the variable is annotated with the objc_externally_retained attribute, 2)
1453 /// if its 'self' in a non-init method, or 3) if its the variable in an for-in
1454 /// loop.
1455 bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }
1456 void setARCPseudoStrong(bool PS) { VarDeclBits.ARCPseudoStrong = PS; }
1457
1458 /// Whether this variable is (C++1z) inline.
1459 bool isInline() const {
1460 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1461 }
1462 bool isInlineSpecified() const {
1463 return isa<ParmVarDecl>(this) ? false
1464 : NonParmVarDeclBits.IsInlineSpecified;
1465 }
1466 void setInlineSpecified() {
1467 assert(!isa<ParmVarDecl>(this))((void)0);
1468 NonParmVarDeclBits.IsInline = true;
1469 NonParmVarDeclBits.IsInlineSpecified = true;
1470 }
1471 void setImplicitlyInline() {
1472 assert(!isa<ParmVarDecl>(this))((void)0);
1473 NonParmVarDeclBits.IsInline = true;
1474 }
1475
1476 /// Whether this variable is (C++11) constexpr.
1477 bool isConstexpr() const {
1478 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1479 }
1480 void setConstexpr(bool IC) {
1481 assert(!isa<ParmVarDecl>(this))((void)0);
1482 NonParmVarDeclBits.IsConstexpr = IC;
1483 }
1484
1485 /// Whether this variable is the implicit variable for a lambda init-capture.
1486 bool isInitCapture() const {
1487 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1488 }
1489 void setInitCapture(bool IC) {
1490 assert(!isa<ParmVarDecl>(this))((void)0);
1491 NonParmVarDeclBits.IsInitCapture = IC;
1492 }
1493
1494 /// Determine whether this variable is actually a function parameter pack or
1495 /// init-capture pack.
1496 bool isParameterPack() const;
1497
1498 /// Whether this local extern variable declaration's previous declaration
1499 /// was declared in the same block scope. Only correct in C++.
1500 bool isPreviousDeclInSameBlockScope() const {
1501 return isa<ParmVarDecl>(this)
1502 ? false
1503 : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1504 }
1505 void setPreviousDeclInSameBlockScope(bool Same) {
1506 assert(!isa<ParmVarDecl>(this))((void)0);
1507 NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1508 }
1509
1510 /// Indicates the capture is a __block variable that is captured by a block
1511 /// that can potentially escape (a block for which BlockDecl::doesNotEscape
1512 /// returns false).
1513 bool isEscapingByref() const;
1514
1515 /// Indicates the capture is a __block variable that is never captured by an
1516 /// escaping block.
1517 bool isNonEscapingByref() const;
1518
1519 void setEscapingByref() {
1520 NonParmVarDeclBits.EscapingByref = true;
1521 }
1522
1523 /// Determines if this variable's alignment is dependent.
1524 bool hasDependentAlignment() const;
1525
1526 /// Retrieve the variable declaration from which this variable could
1527 /// be instantiated, if it is an instantiation (rather than a non-template).
1528 VarDecl *getTemplateInstantiationPattern() const;
1529
1530 /// If this variable is an instantiated static data member of a
1531 /// class template specialization, returns the templated static data member
1532 /// from which it was instantiated.
1533 VarDecl *getInstantiatedFromStaticDataMember() const;
1534
1535 /// If this variable is an instantiation of a variable template or a
1536 /// static data member of a class template, determine what kind of
1537 /// template specialization or instantiation this is.
1538 TemplateSpecializationKind getTemplateSpecializationKind() const;
1539
1540 /// Get the template specialization kind of this variable for the purposes of
1541 /// template instantiation. This differs from getTemplateSpecializationKind()
1542 /// for an instantiation of a class-scope explicit specialization.
1543 TemplateSpecializationKind
1544 getTemplateSpecializationKindForInstantiation() const;
1545
1546 /// If this variable is an instantiation of a variable template or a
1547 /// static data member of a class template, determine its point of
1548 /// instantiation.
1549 SourceLocation getPointOfInstantiation() const;
1550
1551 /// If this variable is an instantiation of a static data member of a
1552 /// class template specialization, retrieves the member specialization
1553 /// information.
1554 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1555
1556 /// For a static data member that was instantiated from a static
1557 /// data member of a class template, set the template specialiation kind.
1558 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1559 SourceLocation PointOfInstantiation = SourceLocation());
1560
1561 /// Specify that this variable is an instantiation of the
1562 /// static data member VD.
1563 void setInstantiationOfStaticDataMember(VarDecl *VD,
1564 TemplateSpecializationKind TSK);
1565
1566 /// Retrieves the variable template that is described by this
1567 /// variable declaration.
1568 ///
1569 /// Every variable template is represented as a VarTemplateDecl and a
1570 /// VarDecl. The former contains template properties (such as
1571 /// the template parameter lists) while the latter contains the
1572 /// actual description of the template's
1573 /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1574 /// VarDecl that from a VarTemplateDecl, while
1575 /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1576 /// a VarDecl.
1577 VarTemplateDecl *getDescribedVarTemplate() const;
1578
1579 void setDescribedVarTemplate(VarTemplateDecl *Template);
1580
1581 // Is this variable known to have a definition somewhere in the complete
1582 // program? This may be true even if the declaration has internal linkage and
1583 // has no definition within this source file.
1584 bool isKnownToBeDefined() const;
1585
1586 /// Is destruction of this variable entirely suppressed? If so, the variable
1587 /// need not have a usable destructor at all.
1588 bool isNoDestroy(const ASTContext &) const;
1589
1590 /// Would the destruction of this variable have any effect, and if so, what
1591 /// kind?
1592 QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const;
1593
1594 // Implement isa/cast/dyncast/etc.
1595 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1596 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1597};
1598
1599class ImplicitParamDecl : public VarDecl {
1600 void anchor() override;
1601
1602public:
1603 /// Defines the kind of the implicit parameter: is this an implicit parameter
1604 /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1605 /// context or something else.
1606 enum ImplicitParamKind : unsigned {
1607 /// Parameter for Objective-C 'self' argument
1608 ObjCSelf,
1609
1610 /// Parameter for Objective-C '_cmd' argument
1611 ObjCCmd,
1612
1613 /// Parameter for C++ 'this' argument
1614 CXXThis,
1615
1616 /// Parameter for C++ virtual table pointers
1617 CXXVTT,
1618
1619 /// Parameter for captured context
1620 CapturedContext,
1621
1622 /// Other implicit parameter
1623 Other,
1624 };
1625
1626 /// Create implicit parameter.
1627 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
1628 SourceLocation IdLoc, IdentifierInfo *Id,
1629 QualType T, ImplicitParamKind ParamKind);
1630 static ImplicitParamDecl *Create(ASTContext &C, QualType T,
1631 ImplicitParamKind ParamKind);
1632
1633 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1634
1635 ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
1636 IdentifierInfo *Id, QualType Type,
1637 ImplicitParamKind ParamKind)
1638 : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1639 /*TInfo=*/nullptr, SC_None) {
1640 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1641 setImplicit();
1642 }
1643
1644 ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
1645 : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1646 SourceLocation(), /*Id=*/nullptr, Type,
1647 /*TInfo=*/nullptr, SC_None) {
1648 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1649 setImplicit();
1650 }
1651
1652 /// Returns the implicit parameter kind.
1653 ImplicitParamKind getParameterKind() const {
1654 return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1655 }
1656
1657 // Implement isa/cast/dyncast/etc.
1658 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1659 static bool classofKind(Kind K) { return K == ImplicitParam; }
1660};
1661
1662/// Represents a parameter to a function.
1663class ParmVarDecl : public VarDecl {
1664public:
1665 enum { MaxFunctionScopeDepth = 255 };
1666 enum { MaxFunctionScopeIndex = 255 };
1667
1668protected:
1669 ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1670 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1671 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1672 : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1673 assert(ParmVarDeclBits.HasInheritedDefaultArg == false)((void)0);
1674 assert(ParmVarDeclBits.DefaultArgKind == DAK_None)((void)0);
1675 assert(ParmVarDeclBits.IsKNRPromoted == false)((void)0);
1676 assert(ParmVarDeclBits.IsObjCMethodParam == false)((void)0);
1677 setDefaultArg(DefArg);
1678 }
1679
1680public:
1681 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1682 SourceLocation StartLoc,
1683 SourceLocation IdLoc, IdentifierInfo *Id,
1684 QualType T, TypeSourceInfo *TInfo,
1685 StorageClass S, Expr *DefArg);
1686
1687 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1688
1689 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
1690
1691 void setObjCMethodScopeInfo(unsigned parameterIndex) {
1692 ParmVarDeclBits.IsObjCMethodParam = true;
1693 setParameterIndex(parameterIndex);
1694 }
1695
1696 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1697 assert(!ParmVarDeclBits.IsObjCMethodParam)((void)0);
1698
1699 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1700 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth((void)0)
1701 && "truncation!")((void)0);
1702
1703 setParameterIndex(parameterIndex);
1704 }
1705
1706 bool isObjCMethodParameter() const {
1707 return ParmVarDeclBits.IsObjCMethodParam;
1708 }
1709
1710 /// Determines whether this parameter is destroyed in the callee function.
1711 bool isDestroyedInCallee() const;
1712
1713 unsigned getFunctionScopeDepth() const {
1714 if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1715 return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1716 }
1717
1718 static constexpr unsigned getMaxFunctionScopeDepth() {
1719 return (1u << NumScopeDepthOrObjCQualsBits) - 1;
1720 }
1721
1722 /// Returns the index of this parameter in its prototype or method scope.
1723 unsigned getFunctionScopeIndex() const {
1724 return getParameterIndex();
1725 }
1726
1727 ObjCDeclQualifier getObjCDeclQualifier() const {
1728 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1729 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1730 }
1731 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
1732 assert(ParmVarDeclBits.IsObjCMethodParam)((void)0);
1733 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1734 }
1735
1736 /// True if the value passed to this parameter must undergo
1737 /// K&R-style default argument promotion:
1738 ///
1739 /// C99 6.5.2.2.
1740 /// If the expression that denotes the called function has a type
1741 /// that does not include a prototype, the integer promotions are
1742 /// performed on each argument, and arguments that have type float
1743 /// are promoted to double.
1744 bool isKNRPromoted() const {
1745 return ParmVarDeclBits.IsKNRPromoted;
1746 }
1747 void setKNRPromoted(bool promoted) {
1748 ParmVarDeclBits.IsKNRPromoted = promoted;
1749 }
1750
1751 Expr *getDefaultArg();
1752 const Expr *getDefaultArg() const {
1753 return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1754 }
1755
1756 void setDefaultArg(Expr *defarg);
1757
1758 /// Retrieve the source range that covers the entire default
1759 /// argument.
1760 SourceRange getDefaultArgRange() const;
1761 void setUninstantiatedDefaultArg(Expr *arg);
1762 Expr *getUninstantiatedDefaultArg();
1763 const Expr *getUninstantiatedDefaultArg() const {
1764 return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1765 }
1766
1767 /// Determines whether this parameter has a default argument,
1768 /// either parsed or not.
1769 bool hasDefaultArg() const;
1770
1771 /// Determines whether this parameter has a default argument that has not
1772 /// yet been parsed. This will occur during the processing of a C++ class
1773 /// whose member functions have default arguments, e.g.,
1774 /// @code
1775 /// class X {
1776 /// public:
1777 /// void f(int x = 17); // x has an unparsed default argument now
1778 /// }; // x has a regular default argument now
1779 /// @endcode
1780 bool hasUnparsedDefaultArg() const {
1781 return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1782 }
1783
1784 bool hasUninstantiatedDefaultArg() const {
1785 return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1786 }
1787
1788 /// Specify that this parameter has an unparsed default argument.
1789 /// The argument will be replaced with a real default argument via
1790 /// setDefaultArg when the class definition enclosing the function
1791 /// declaration that owns this default argument is completed.
1792 void setUnparsedDefaultArg() {
1793 ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1794 }
1795
1796 bool hasInheritedDefaultArg() const {
1797 return ParmVarDeclBits.HasInheritedDefaultArg;
1798 }
1799
1800 void setHasInheritedDefaultArg(bool I = true) {
1801 ParmVarDeclBits.HasInheritedDefaultArg = I;
1802 }
1803
1804 QualType getOriginalType() const;
1805
1806 /// Sets the function declaration that owns this
1807 /// ParmVarDecl. Since ParmVarDecls are often created before the
1808 /// FunctionDecls that own them, this routine is required to update
1809 /// the DeclContext appropriately.
1810 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1811
1812 // Implement isa/cast/dyncast/etc.
1813 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1814 static bool classofKind(Kind K) { return K == ParmVar; }
1815
1816private:
1817 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1818
1819 void setParameterIndex(unsigned parameterIndex) {
1820 if (parameterIndex >= ParameterIndexSentinel) {
1821 setParameterIndexLarge(parameterIndex);
1822 return;
1823 }
1824
1825 ParmVarDeclBits.ParameterIndex = parameterIndex;
1826 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!")((void)0);
1827 }
1828 unsigned getParameterIndex() const {
1829 unsigned d = ParmVarDeclBits.ParameterIndex;
1830 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1831 }
1832
1833 void setParameterIndexLarge(unsigned parameterIndex);
1834 unsigned getParameterIndexLarge() const;
1835};
1836
1837enum class MultiVersionKind {
1838 None,
1839 Target,
1840 CPUSpecific,
1841 CPUDispatch
1842};
1843
1844/// Represents a function declaration or definition.
1845///
1846/// Since a given function can be declared several times in a program,
1847/// there may be several FunctionDecls that correspond to that
1848/// function. Only one of those FunctionDecls will be found when
1849/// traversing the list of declarations in the context of the
1850/// FunctionDecl (e.g., the translation unit); this FunctionDecl
1851/// contains all of the information known about the function. Other,
1852/// previous declarations of the function are available via the
1853/// getPreviousDecl() chain.
1854class FunctionDecl : public DeclaratorDecl,
1855 public DeclContext,
1856 public Redeclarable<FunctionDecl> {
1857 // This class stores some data in DeclContext::FunctionDeclBits
1858 // to save some space. Use the provided accessors to access it.
1859public:
1860 /// The kind of templated function a FunctionDecl can be.
1861 enum TemplatedKind {
1862 // Not templated.
1863 TK_NonTemplate,
1864 // The pattern in a function template declaration.
1865 TK_FunctionTemplate,
1866 // A non-template function that is an instantiation or explicit
1867 // specialization of a member of a templated class.
1868 TK_MemberSpecialization,
1869 // An instantiation or explicit specialization of a function template.
1870 // Note: this might have been instantiated from a templated class if it
1871 // is a class-scope explicit specialization.
1872 TK_FunctionTemplateSpecialization,
1873 // A function template specialization that hasn't yet been resolved to a
1874 // particular specialized function template.
1875 TK_DependentFunctionTemplateSpecialization
1876 };
1877
1878 /// Stashed information about a defaulted function definition whose body has
1879 /// not yet been lazily generated.
1880 class DefaultedFunctionInfo final
1881 : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1882 friend TrailingObjects;
1883 unsigned NumLookups;
1884
1885 public:
1886 static DefaultedFunctionInfo *Create(ASTContext &Context,
1887 ArrayRef<DeclAccessPair> Lookups);
1888 /// Get the unqualified lookup results that should be used in this
1889 /// defaulted function definition.
1890 ArrayRef<DeclAccessPair> getUnqualifiedLookups() const {
1891 return {getTrailingObjects<DeclAccessPair>(), NumLookups};
1892 }
1893 };
1894
1895private:
1896 /// A new[]'d array of pointers to VarDecls for the formal
1897 /// parameters of this function. This is null if a prototype or if there are
1898 /// no formals.
1899 ParmVarDecl **ParamInfo = nullptr;
1900
1901 /// The active member of this union is determined by
1902 /// FunctionDeclBits.HasDefaultedFunctionInfo.
1903 union {
1904 /// The body of the function.
1905 LazyDeclStmtPtr Body;
1906 /// Information about a future defaulted function definition.
1907 DefaultedFunctionInfo *DefaultedInfo;
1908 };
1909
1910 unsigned ODRHash;
1911
1912 /// End part of this FunctionDecl's source range.
1913 ///
1914 /// We could compute the full range in getSourceRange(). However, when we're
1915 /// dealing with a function definition deserialized from a PCH/AST file,
1916 /// we can only compute the full range once the function body has been
1917 /// de-serialized, so it's far better to have the (sometimes-redundant)
1918 /// EndRangeLoc.
1919 SourceLocation EndRangeLoc;
1920
1921 /// The template or declaration that this declaration
1922 /// describes or was instantiated from, respectively.
1923 ///
1924 /// For non-templates, this value will be NULL. For function
1925 /// declarations that describe a function template, this will be a
1926 /// pointer to a FunctionTemplateDecl. For member functions
1927 /// of class template specializations, this will be a MemberSpecializationInfo
1928 /// pointer containing information about the specialization.
1929 /// For function template specializations, this will be a
1930 /// FunctionTemplateSpecializationInfo, which contains information about
1931 /// the template being specialized and the template arguments involved in
1932 /// that specialization.
1933 llvm::PointerUnion<FunctionTemplateDecl *,
1934 MemberSpecializationInfo *,
1935 FunctionTemplateSpecializationInfo *,
1936 DependentFunctionTemplateSpecializationInfo *>
1937 TemplateOrSpecialization;
1938
1939 /// Provides source/type location info for the declaration name embedded in
1940 /// the DeclaratorDecl base class.
1941 DeclarationNameLoc DNLoc;
1942
1943 /// Specify that this function declaration is actually a function
1944 /// template specialization.
1945 ///
1946 /// \param C the ASTContext.
1947 ///
1948 /// \param Template the function template that this function template
1949 /// specialization specializes.
1950 ///
1951 /// \param TemplateArgs the template arguments that produced this
1952 /// function template specialization from the template.
1953 ///
1954 /// \param InsertPos If non-NULL, the position in the function template
1955 /// specialization set where the function template specialization data will
1956 /// be inserted.
1957 ///
1958 /// \param TSK the kind of template specialization this is.
1959 ///
1960 /// \param TemplateArgsAsWritten location info of template arguments.
1961 ///
1962 /// \param PointOfInstantiation point at which the function template
1963 /// specialization was first instantiated.
1964 void setFunctionTemplateSpecialization(ASTContext &C,
1965 FunctionTemplateDecl *Template,
1966 const TemplateArgumentList *TemplateArgs,
1967 void *InsertPos,
1968 TemplateSpecializationKind TSK,
1969 const TemplateArgumentListInfo *TemplateArgsAsWritten,
1970 SourceLocation PointOfInstantiation);
1971
1972 /// Specify that this record is an instantiation of the
1973 /// member function FD.
1974 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1975 TemplateSpecializationKind TSK);
1976
1977 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1978
1979 // This is unfortunately needed because ASTDeclWriter::VisitFunctionDecl
1980 // need to access this bit but we want to avoid making ASTDeclWriter
1981 // a friend of FunctionDeclBitfields just for this.
1982 bool isDeletedBit() const { return FunctionDeclBits.IsDeleted; }
1983
1984 /// Whether an ODRHash has been stored.
1985 bool hasODRHash() const { return FunctionDeclBits.HasODRHash; }
1986
1987 /// State that an ODRHash has been stored.
1988 void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }
1989
1990protected:
1991 FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1992 const DeclarationNameInfo &NameInfo, QualType T,
1993 TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
1994 ConstexprSpecKind ConstexprKind,
1995 Expr *TrailingRequiresClause = nullptr);
1996
1997 using redeclarable_base = Redeclarable<FunctionDecl>;
1998
1999 FunctionDecl *getNextRedeclarationImpl() override {
2000 return getNextRedeclaration();
2001 }
2002
2003 FunctionDecl *getPreviousDeclImpl() override {
2004 return getPreviousDecl();
2005 }
2006
2007 FunctionDecl *getMostRecentDeclImpl() override {
2008 return getMostRecentDecl();
2009 }
2010
2011public:
2012 friend class ASTDeclReader;
2013 friend class ASTDeclWriter;
2014
2015 using redecl_range = redeclarable_base::redecl_range;
2016 using redecl_iterator = redeclarable_base::redecl_iterator;
2017
2018 using redeclarable_base::redecls_begin;
2019 using redeclarable_base::redecls_end;
2020 using redeclarable_base::redecls;
2021 using redeclarable_base::getPreviousDecl;
2022 using redeclarable_base::getMostRecentDecl;
2023 using redeclarable_base::isFirstDecl;
2024
2025 static FunctionDecl *
2026 Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2027 SourceLocation NLoc, DeclarationName N, QualType T,
2028 TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified = false,
2029 bool hasWrittenPrototype = true,
2030 ConstexprSpecKind ConstexprKind = ConstexprSpecKind::Unspecified,
2031 Expr *TrailingRequiresClause = nullptr) {
2032 DeclarationNameInfo NameInfo(N, NLoc);
2033 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
2034 isInlineSpecified, hasWrittenPrototype,
2035 ConstexprKind, TrailingRequiresClause);
2036 }
2037
2038 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
2039 SourceLocation StartLoc,
2040 const DeclarationNameInfo &NameInfo, QualType T,
2041 TypeSourceInfo *TInfo, StorageClass SC,
2042 bool isInlineSpecified, bool hasWrittenPrototype,
2043 ConstexprSpecKind ConstexprKind,
2044 Expr *TrailingRequiresClause);
2045
2046 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2047
2048 DeclarationNameInfo getNameInfo() const {
2049 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
2050 }
2051
2052 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2053 bool Qualified) const override;
2054
2055 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
2056
2057 /// Returns the location of the ellipsis of a variadic function.
2058 SourceLocation getEllipsisLoc() const {
2059 const auto *FPT = getType()->getAs<FunctionProtoType>();
2060 if (FPT && FPT->isVariadic())
2061 return FPT->getEllipsisLoc();
2062 return SourceLocation();
2063 }
2064
2065 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
2066
2067 // Function definitions.
2068 //
2069 // A function declaration may be:
2070 // - a non defining declaration,
2071 // - a definition. A function may be defined because:
2072 // - it has a body, or will have it in the case of late parsing.
2073 // - it has an uninstantiated body. The body does not exist because the
2074 // function is not used yet, but the declaration is considered a
2075 // definition and does not allow other definition of this function.
2076 // - it does not have a user specified body, but it does not allow
2077 // redefinition, because it is deleted/defaulted or is defined through
2078 // some other mechanism (alias, ifunc).
2079
2080 /// Returns true if the function has a body.
2081 ///
2082 /// The function body might be in any of the (re-)declarations of this
2083 /// function. The variant that accepts a FunctionDecl pointer will set that
2084 /// function declaration to the actual declaration containing the body (if
2085 /// there is one).
2086 bool hasBody(const FunctionDecl *&Definition) const;
2087
2088 bool hasBody() const override {
2089 const FunctionDecl* Definition;
2090 return hasBody(Definition);
2091 }
2092
2093 /// Returns whether the function has a trivial body that does not require any
2094 /// specific codegen.
2095 bool hasTrivialBody() const;
2096
2097 /// Returns true if the function has a definition that does not need to be
2098 /// instantiated.
2099 ///
2100 /// The variant that accepts a FunctionDecl pointer will set that function
2101 /// declaration to the declaration that is a definition (if there is one).
2102 ///
2103 /// \param CheckForPendingFriendDefinition If \c true, also check for friend
2104 /// declarations that were instantiataed from function definitions.
2105 /// Such a declaration behaves as if it is a definition for the
2106 /// purpose of redefinition checking, but isn't actually a "real"
2107 /// definition until its body is instantiated.
2108 bool isDefined(const FunctionDecl *&Definition,
2109 bool CheckForPendingFriendDefinition = false) const;
2110
2111 bool isDefined() const {
2112 const FunctionDecl* Definition;
2113 return isDefined(Definition);
2114 }
2115
2116 /// Get the definition for this declaration.
2117 FunctionDecl *getDefinition() {
2118 const FunctionDecl *Definition;
2119 if (isDefined(Definition))
2120 return const_cast<FunctionDecl *>(Definition);
2121 return nullptr;
2122 }
2123 const FunctionDecl *getDefinition() const {
2124 return const_cast<FunctionDecl *>(this)->getDefinition();
2125 }
2126
2127 /// Retrieve the body (definition) of the function. The function body might be
2128 /// in any of the (re-)declarations of this function. The variant that accepts
2129 /// a FunctionDecl pointer will set that function declaration to the actual
2130 /// declaration containing the body (if there is one).
2131 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
2132 /// unnecessary AST de-serialization of the body.
2133 Stmt *getBody(const FunctionDecl *&Definition) const;
2134
2135 Stmt *getBody() const override {
2136 const FunctionDecl* Definition;
2137 return getBody(Definition);
2138 }
2139
2140 /// Returns whether this specific declaration of the function is also a
2141 /// definition that does not contain uninstantiated body.
2142 ///
2143 /// This does not determine whether the function has been defined (e.g., in a
2144 /// previous definition); for that information, use isDefined.
2145 ///
2146 /// Note: the function declaration does not become a definition until the
2147 /// parser reaches the definition, if called before, this function will return
2148 /// `false`.
2149 bool isThisDeclarationADefinition() const {
2150 return isDeletedAsWritten() || isDefaulted() ||
2151 doesThisDeclarationHaveABody() || hasSkippedBody() ||
2152 willHaveBody() || hasDefiningAttr();
2153 }
2154
2155 /// Determine whether this specific declaration of the function is a friend
2156 /// declaration that was instantiated from a function definition. Such
2157 /// declarations behave like definitions in some contexts.
2158 bool isThisDeclarationInstantiatedFromAFriendDefinition() const;
2159
2160 /// Returns whether this specific declaration of the function has a body.
2161 bool doesThisDeclarationHaveABody() const {
2162 return (!FunctionDeclBits.HasDefaultedFunctionInfo && Body) ||
2163 isLateTemplateParsed();
2164 }
2165
2166 void setBody(Stmt *B);
2167 void setLazyBody(uint64_t Offset) {
2168 FunctionDeclBits.HasDefaultedFunctionInfo = false;
2169 Body = LazyDeclStmtPtr(Offset);
2170 }
2171
2172 void setDefaultedFunctionInfo(DefaultedFunctionInfo *Info);
2173 DefaultedFunctionInfo *getDefaultedFunctionInfo() const;
2174
2175 /// Whether this function is variadic.
2176 bool isVariadic() const;
2177
2178 /// Whether this function is marked as virtual explicitly.
2179 bool isVirtualAsWritten() const {
2180 return FunctionDeclBits.IsVirtualAsWritten;
2181 }
2182
2183 /// State that this function is marked as virtual explicitly.
2184 void setVirtualAsWritten(bool V) { FunctionDeclBits.IsVirtualAsWritten = V; }
2185
2186 /// Whether this virtual function is pure, i.e. makes the containing class
2187 /// abstract.
2188 bool isPure() const { return FunctionDeclBits.IsPure; }
2189 void setPure(bool P = true);
2190
2191 /// Whether this templated function will be late parsed.
2192 bool isLateTemplateParsed() const {
2193 return FunctionDeclBits.IsLateTemplateParsed;
2194 }
2195
2196 /// State that this templated function will be late parsed.
2197 void setLateTemplateParsed(bool ILT = true) {
2198 FunctionDeclBits.IsLateTemplateParsed = ILT;
2199 }
2200
2201 /// Whether this function is "trivial" in some specialized C++ senses.
2202 /// Can only be true for default constructors, copy constructors,
2203 /// copy assignment operators, and destructors. Not meaningful until
2204 /// the class has been fully built by Sema.
2205 bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
2206 void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }
2207
2208 bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
2209 void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }
2210
2211 /// Whether this function is defaulted. Valid for e.g.
2212 /// special member functions, defaulted comparisions (not methods!).
2213 bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
2214 void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }
2215
2216 /// Whether this function is explicitly defaulted.
2217 bool isExplicitlyDefaulted() const {
2218 return FunctionDeclBits.IsExplicitlyDefaulted;
2219 }
2220
2221 /// State that this function is explicitly defaulted.
2222 void setExplicitlyDefaulted(bool ED = true) {
2223 FunctionDeclBits.IsExplicitlyDefaulted = ED;
2224 }
2225
2226 /// True if this method is user-declared and was not
2227 /// deleted or defaulted on its first declaration.
2228 bool isUserProvided() const {
2229 auto *DeclAsWritten = this;
2230 if (FunctionDecl *Pattern = getTemplateInstantiationPattern())
2231 DeclAsWritten = Pattern;
2232 return !(DeclAsWritten->isDeleted() ||
2233 DeclAsWritten->getCanonicalDecl()->isDefaulted());
2234 }
2235
2236 /// Whether falling off this function implicitly returns null/zero.
2237 /// If a more specific implicit return value is required, front-ends
2238 /// should synthesize the appropriate return statements.
2239 bool hasImplicitReturnZero() const {
2240 return FunctionDeclBits.HasImplicitReturnZero;
2241 }
2242
2243 /// State that falling off this function implicitly returns null/zero.
2244 /// If a more specific implicit return value is required, front-ends
2245 /// should synthesize the appropriate return statements.
2246 void setHasImplicitReturnZero(bool IRZ) {
2247 FunctionDeclBits.HasImplicitReturnZero = IRZ;
2248 }
2249
2250 /// Whether this function has a prototype, either because one
2251 /// was explicitly written or because it was "inherited" by merging
2252 /// a declaration without a prototype with a declaration that has a
2253 /// prototype.
2254 bool hasPrototype() const {
2255 return hasWrittenPrototype() || hasInheritedPrototype();
2256 }
2257
2258 /// Whether this function has a written prototype.
2259 bool hasWrittenPrototype() const {
2260 return FunctionDeclBits.HasWrittenPrototype;
2261 }
2262
2263 /// State that this function has a written prototype.
2264 void setHasWrittenPrototype(bool P = true) {
2265 FunctionDeclBits.HasWrittenPrototype = P;
2266 }
2267
2268 /// Whether this function inherited its prototype from a
2269 /// previous declaration.
2270 bool hasInheritedPrototype() const {
2271 return FunctionDeclBits.HasInheritedPrototype;
2272 }
2273
2274 /// State that this function inherited its prototype from a
2275 /// previous declaration.
2276 void setHasInheritedPrototype(bool P = true) {
2277 FunctionDeclBits.HasInheritedPrototype = P;
2278 }
2279
2280 /// Whether this is a (C++11) constexpr function or constexpr constructor.
2281 bool isConstexpr() const {
2282 return getConstexprKind() != ConstexprSpecKind::Unspecified;
2283 }
2284 void setConstexprKind(ConstexprSpecKind CSK) {
2285 FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(CSK);
2286 }
2287 ConstexprSpecKind getConstexprKind() const {
2288 return static_cast<ConstexprSpecKind>(FunctionDeclBits.ConstexprKind);
2289 }
2290 bool isConstexprSpecified() const {
2291 return getConstexprKind() == ConstexprSpecKind::Constexpr;
2292 }
2293 bool isConsteval() const {
2294 return getConstexprKind() == ConstexprSpecKind::Consteval;
2295 }
2296
2297 /// Whether the instantiation of this function is pending.
2298 /// This bit is set when the decision to instantiate this function is made
2299 /// and unset if and when the function body is created. That leaves out
2300 /// cases where instantiation did not happen because the template definition
2301 /// was not seen in this TU. This bit remains set in those cases, under the
2302 /// assumption that the instantiation will happen in some other TU.
2303 bool instantiationIsPending() const {
2304 return FunctionDeclBits.InstantiationIsPending;
2305 }
2306
2307 /// State that the instantiation of this function is pending.
2308 /// (see instantiationIsPending)
2309 void setInstantiationIsPending(bool IC) {
2310 FunctionDeclBits.InstantiationIsPending = IC;
2311 }
2312
2313 /// Indicates the function uses __try.
2314 bool usesSEHTry() const { return FunctionDeclBits.UsesSEHTry; }
2315 void setUsesSEHTry(bool UST) { FunctionDeclBits.UsesSEHTry = UST; }
2316
2317 /// Whether this function has been deleted.
2318 ///
2319 /// A function that is "deleted" (via the C++0x "= delete" syntax)
2320 /// acts like a normal function, except that it cannot actually be
2321 /// called or have its address taken. Deleted functions are
2322 /// typically used in C++ overload resolution to attract arguments
2323 /// whose type or lvalue/rvalue-ness would permit the use of a
2324 /// different overload that would behave incorrectly. For example,
2325 /// one might use deleted functions to ban implicit conversion from
2326 /// a floating-point number to an Integer type:
2327 ///
2328 /// @code
2329 /// struct Integer {
2330 /// Integer(long); // construct from a long
2331 /// Integer(double) = delete; // no construction from float or double
2332 /// Integer(long double) = delete; // no construction from long double
2333 /// };
2334 /// @endcode
2335 // If a function is deleted, its first declaration must be.
2336 bool isDeleted() const {
2337 return getCanonicalDecl()->FunctionDeclBits.IsDeleted;
2338 }
2339
2340 bool isDeletedAsWritten() const {
2341 return FunctionDeclBits.IsDeleted && !isDefaulted();
2342 }
2343
2344 void setDeletedAsWritten(bool D = true) { FunctionDeclBits.IsDeleted = D; }
2345
2346 /// Determines whether this function is "main", which is the
2347 /// entry point into an executable program.
2348 bool isMain() const;
2349
2350 /// Determines whether this function is a MSVCRT user defined entry
2351 /// point.
2352 bool isMSVCRTEntryPoint() const;
2353
2354 /// Determines whether this operator new or delete is one
2355 /// of the reserved global placement operators:
2356 /// void *operator new(size_t, void *);
2357 /// void *operator new[](size_t, void *);
2358 /// void operator delete(void *, void *);
2359 /// void operator delete[](void *, void *);
2360 /// These functions have special behavior under [new.delete.placement]:
2361 /// These functions are reserved, a C++ program may not define
2362 /// functions that displace the versions in the Standard C++ library.
2363 /// The provisions of [basic.stc.dynamic] do not apply to these
2364 /// reserved placement forms of operator new and operator delete.
2365 ///
2366 /// This function must be an allocation or deallocation function.
2367 bool isReservedGlobalPlacementOperator() const;
2368
2369 /// Determines whether this function is one of the replaceable
2370 /// global allocation functions:
2371 /// void *operator new(size_t);
2372 /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2373 /// void *operator new[](size_t);
2374 /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2375 /// void operator delete(void *) noexcept;
2376 /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2377 /// void operator delete(void *, const std::nothrow_t &) noexcept;
2378 /// void operator delete[](void *) noexcept;
2379 /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2380 /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2381 /// These functions have special behavior under C++1y [expr.new]:
2382 /// An implementation is allowed to omit a call to a replaceable global
2383 /// allocation function. [...]
2384 ///
2385 /// If this function is an aligned allocation/deallocation function, return
2386 /// the parameter number of the requested alignment through AlignmentParam.
2387 ///
2388 /// If this function is an allocation/deallocation function that takes
2389 /// the `std::nothrow_t` tag, return true through IsNothrow,
2390 bool isReplaceableGlobalAllocationFunction(
2391 Optional<unsigned> *AlignmentParam = nullptr,
2392 bool *IsNothrow = nullptr) const;
2393
2394 /// Determine if this function provides an inline implementation of a builtin.
2395 bool isInlineBuiltinDeclaration() const;
2396
2397 /// Determine whether this is a destroying operator delete.
2398 bool isDestroyingOperatorDelete() const;
2399
2400 /// Compute the language linkage.
2401 LanguageLinkage getLanguageLinkage() const;
2402
2403 /// Determines whether this function is a function with
2404 /// external, C linkage.
2405 bool isExternC() const;
2406
2407 /// Determines whether this function's context is, or is nested within,
2408 /// a C++ extern "C" linkage spec.
2409 bool isInExternCContext() const;
2410
2411 /// Determines whether this function's context is, or is nested within,
2412 /// a C++ extern "C++" linkage spec.
2413 bool isInExternCXXContext() const;
2414
2415 /// Determines whether this is a global function.
2416 bool isGlobal() const;
2417
2418 /// Determines whether this function is known to be 'noreturn', through
2419 /// an attribute on its declaration or its type.
2420 bool isNoReturn() const;
2421
2422 /// True if the function was a definition but its body was skipped.
2423 bool hasSkippedBody() const { return FunctionDeclBits.HasSkippedBody; }
2424 void setHasSkippedBody(bool Skipped = true) {
2425 FunctionDeclBits.HasSkippedBody = Skipped;
2426 }
2427
2428 /// True if this function will eventually have a body, once it's fully parsed.
2429 bool willHaveBody() const { return FunctionDeclBits.WillHaveBody; }
2430 void setWillHaveBody(bool V = true) { FunctionDeclBits.WillHaveBody = V; }
2431
2432 /// True if this function is considered a multiversioned function.
2433 bool isMultiVersion() const {
2434 return getCanonicalDecl()->FunctionDeclBits.IsMultiVersion;
2435 }
2436
2437 /// Sets the multiversion state for this declaration and all of its
2438 /// redeclarations.
2439 void setIsMultiVersion(bool V = true) {
2440 getCanonicalDecl()->FunctionDeclBits.IsMultiVersion = V;
2441 }
2442
2443 /// Gets the kind of multiversioning attribute this declaration has. Note that
2444 /// this can return a value even if the function is not multiversion, such as
2445 /// the case of 'target'.
2446 MultiVersionKind getMultiVersionKind() const;
2447
2448
2449 /// True if this function is a multiversioned dispatch function as a part of
2450 /// the cpu_specific/cpu_dispatch functionality.
2451 bool isCPUDispatchMultiVersion() const;
2452 /// True if this function is a multiversioned processor specific function as a
2453 /// part of the cpu_specific/cpu_dispatch functionality.
2454 bool isCPUSpecificMultiVersion() const;
2455
2456 /// True if this function is a multiversioned dispatch function as a part of
2457 /// the target functionality.
2458 bool isTargetMultiVersion() const;
2459
2460 /// \brief Get the associated-constraints of this function declaration.
2461 /// Currently, this will either be a vector of size 1 containing the
2462 /// trailing-requires-clause or an empty vector.
2463 ///
2464 /// Use this instead of getTrailingRequiresClause for concepts APIs that
2465 /// accept an ArrayRef of constraint expressions.
2466 void getAssociatedConstraints(SmallVectorImpl<const Expr *> &AC) const {
2467 if (auto *TRC = getTrailingRequiresClause())
2468 AC.push_back(TRC);
2469 }
2470
2471 void setPreviousDeclaration(FunctionDecl * PrevDecl);
2472
2473 FunctionDecl *getCanonicalDecl() override;
2474 const FunctionDecl *getCanonicalDecl() const {
2475 return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2476 }
2477
2478 unsigned getBuiltinID(bool ConsiderWrapperFunctions = false) const;
2479
2480 // ArrayRef interface to parameters.
2481 ArrayRef<ParmVarDecl *> parameters() const {
2482 return {ParamInfo, getNumParams()};
2483 }
2484 MutableArrayRef<ParmVarDecl *> parameters() {
2485 return {ParamInfo, getNumParams()};
2486 }
2487
2488 // Iterator access to formal parameters.
2489 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
2490 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
2491
2492 bool param_empty() const { return parameters().empty(); }
2493 param_iterator param_begin() { return parameters().begin(); }
2494 param_iterator param_end() { return parameters().end(); }
2495 param_const_iterator param_begin() const { return parameters().begin(); }
2496 param_const_iterator param_end() const { return parameters().end(); }
2497 size_t param_size() const { return parameters().size(); }
2498
2499 /// Return the number of parameters this function must have based on its
2500 /// FunctionType. This is the length of the ParamInfo array after it has been
2501 /// created.
2502 unsigned getNumParams() const;
2503
2504 const ParmVarDecl *getParamDecl(unsigned i) const {
2505 assert(i < getNumParams() && "Illegal param #")((void)0);
2506 return ParamInfo[i];
2507 }
2508 ParmVarDecl *getParamDecl(unsigned i) {
2509 assert(i < getNumParams() && "Illegal param #")((void)0);
2510 return ParamInfo[i];
2511 }
2512 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2513 setParams(getASTContext(), NewParamInfo);
2514 }
2515
2516 /// Returns the minimum number of arguments needed to call this function. This
2517 /// may be fewer than the number of function parameters, if some of the
2518 /// parameters have default arguments (in C++).
2519 unsigned getMinRequiredArguments() const;
2520
2521 /// Determine whether this function has a single parameter, or multiple
2522 /// parameters where all but the first have default arguments.
2523 ///
2524 /// This notion is used in the definition of copy/move constructors and
2525 /// initializer list constructors. Note that, unlike getMinRequiredArguments,
2526 /// parameter packs are not treated specially here.
2527 bool hasOneParamOrDefaultArgs() const;
2528
2529 /// Find the source location information for how the type of this function
2530 /// was written. May be absent (for example if the function was declared via
2531 /// a typedef) and may contain a different type from that of the function
2532 /// (for example if the function type was adjusted by an attribute).
2533 FunctionTypeLoc getFunctionTypeLoc() const;
2534
2535 QualType getReturnType() const {
2536 return getType()->castAs<FunctionType>()->getReturnType();
2537 }
2538
2539 /// Attempt to compute an informative source range covering the
2540 /// function return type. This may omit qualifiers and other information with
2541 /// limited representation in the AST.
2542 SourceRange getReturnTypeSourceRange() const;
2543
2544 /// Attempt to compute an informative source range covering the
2545 /// function parameters, including the ellipsis of a variadic function.
2546 /// The source range excludes the parentheses, and is invalid if there are
2547 /// no parameters and no ellipsis.
2548 SourceRange getParametersSourceRange() const;
2549
2550 /// Get the declared return type, which may differ from the actual return
2551 /// type if the return type is deduced.
2552 QualType getDeclaredReturnType() const {
2553 auto *TSI = getTypeSourceInfo();
2554 QualType T = TSI ? TSI->getType() : getType();
2555 return T->castAs<FunctionType>()->getReturnType();
2556 }
2557
2558 /// Gets the ExceptionSpecificationType as declared.
2559 ExceptionSpecificationType getExceptionSpecType() const {
2560 auto *TSI = getTypeSourceInfo();
2561 QualType T = TSI ? TSI->getType() : getType();
2562 const auto *FPT = T->getAs<FunctionProtoType>();
2563 return FPT ? FPT->getExceptionSpecType() : EST_None;
2564 }
2565
2566 /// Attempt to compute an informative source range covering the
2567 /// function exception specification, if any.
2568 SourceRange getExceptionSpecSourceRange() const;
2569
2570 /// Determine the type of an expression that calls this function.
2571 QualType getCallResultType() const {
2572 return getType()->castAs<FunctionType>()->getCallResultType(
2573 getASTContext());
2574 }
2575
2576 /// Returns the storage class as written in the source. For the
2577 /// computed linkage of symbol, see getLinkage.
2578 StorageClass getStorageClass() const {
2579 return static_cast<StorageClass>(FunctionDeclBits.SClass);
2580 }
2581
2582 /// Sets the storage class as written in the source.
2583 void setStorageClass(StorageClass SClass) {
2584 FunctionDeclBits.SClass = SClass;
2585 }
2586
2587 /// Determine whether the "inline" keyword was specified for this
2588 /// function.
2589 bool isInlineSpecified() const { return FunctionDeclBits.IsInlineSpecified; }
2590
2591 /// Set whether the "inline" keyword was specified for this function.
2592 void setInlineSpecified(bool I) {
2593 FunctionDeclBits.IsInlineSpecified = I;
2594 FunctionDeclBits.IsInline = I;
2595 }
2596
2597 /// Flag that this function is implicitly inline.
2598 void setImplicitlyInline(bool I = true) { FunctionDeclBits.IsInline = I; }
2599
2600 /// Determine whether this function should be inlined, because it is
2601 /// either marked "inline" or "constexpr" or is a member function of a class
2602 /// that was defined in the class body.
2603 bool isInlined() const { return FunctionDeclBits.IsInline; }
2604
2605 bool isInlineDefinitionExternallyVisible() const;
2606
2607 bool isMSExternInline() const;
2608
2609 bool doesDeclarationForceExternallyVisibleDefinition() const;
2610
2611 bool isStatic() const { return getStorageClass() == SC_Static; }
2612
2613 /// Whether this function declaration represents an C++ overloaded
2614 /// operator, e.g., "operator+".
2615 bool isOverloadedOperator() const {
2616 return getOverloadedOperator() != OO_None;
2617 }
2618
2619 OverloadedOperatorKind getOverloadedOperator() const;
2620
2621 const IdentifierInfo *getLiteralIdentifier() const;
2622
2623 /// If this function is an instantiation of a member function
2624 /// of a class template specialization, retrieves the function from
2625 /// which it was instantiated.
2626 ///
2627 /// This routine will return non-NULL for (non-templated) member
2628 /// functions of class templates and for instantiations of function
2629 /// templates. For example, given:
2630 ///
2631 /// \code
2632 /// template<typename T>
2633 /// struct X {
2634 /// void f(T);
2635 /// };
2636 /// \endcode
2637 ///
2638 /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2639 /// whose parent is the class template specialization X<int>. For
2640 /// this declaration, getInstantiatedFromFunction() will return
2641 /// the FunctionDecl X<T>::A. When a complete definition of
2642 /// X<int>::A is required, it will be instantiated from the
2643 /// declaration returned by getInstantiatedFromMemberFunction().
2644 FunctionDecl *getInstantiatedFromMemberFunction() const;
2645
2646 /// What kind of templated function this is.
2647 TemplatedKind getTemplatedKind() const;
2648
2649 /// If this function is an instantiation of a member function of a
2650 /// class template specialization, retrieves the member specialization
2651 /// information.
2652 MemberSpecializationInfo *getMemberSpecializationInfo() const;
2653
2654 /// Specify that this record is an instantiation of the
2655 /// member function FD.
2656 void setInstantiationOfMemberFunction(FunctionDecl *FD,
2657 TemplateSpecializationKind TSK) {
2658 setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2659 }
2660
2661 /// Retrieves the function template that is described by this
2662 /// function declaration.
2663 ///
2664 /// Every function template is represented as a FunctionTemplateDecl
2665 /// and a FunctionDecl (or something derived from FunctionDecl). The
2666 /// former contains template properties (such as the template
2667 /// parameter lists) while the latter contains the actual
2668 /// description of the template's
2669 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2670 /// FunctionDecl that describes the function template,
2671 /// getDescribedFunctionTemplate() retrieves the
2672 /// FunctionTemplateDecl from a FunctionDecl.
2673 FunctionTemplateDecl *getDescribedFunctionTemplate() const;
2674
2675 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);
2676
2677 /// Determine whether this function is a function template
2678 /// specialization.
2679 bool isFunctionTemplateSpecialization() const {
2680 return getPrimaryTemplate() != nullptr;
2681 }
2682
2683 /// If this function is actually a function template specialization,
2684 /// retrieve information about this function template specialization.
2685 /// Otherwise, returns NULL.
2686 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;
2687
2688 /// Determines whether this function is a function template
2689 /// specialization or a member of a class template specialization that can
2690 /// be implicitly instantiated.
2691 bool isImplicitlyInstantiable() const;
2692
2693 /// Determines if the given function was instantiated from a
2694 /// function template.
2695 bool isTemplateInstantiation() const;
2696
2697 /// Retrieve the function declaration from which this function could
2698 /// be instantiated, if it is an instantiation (rather than a non-template
2699 /// or a specialization, for example).
2700 ///
2701 /// If \p ForDefinition is \c false, explicit specializations will be treated
2702 /// as if they were implicit instantiations. This will then find the pattern
2703 /// corresponding to non-definition portions of the declaration, such as
2704 /// default arguments and the exception specification.
2705 FunctionDecl *
2706 getTemplateInstantiationPattern(bool ForDefinition = true) const;
2707
2708 /// Retrieve the primary template that this function template
2709 /// specialization either specializes or was instantiated from.
2710 ///
2711 /// If this function declaration is not a function template specialization,
2712 /// returns NULL.
2713 FunctionTemplateDecl *getPrimaryTemplate() const;
2714
2715 /// Retrieve the template arguments used to produce this function
2716 /// template specialization from the primary template.
2717 ///
2718 /// If this function declaration is not a function template specialization,
2719 /// returns NULL.
2720 const TemplateArgumentList *getTemplateSpecializationArgs() const;
2721
2722 /// Retrieve the template argument list as written in the sources,
2723 /// if any.
2724 ///
2725 /// If this function declaration is not a function template specialization
2726 /// or if it had no explicit template argument list, returns NULL.
2727 /// Note that it an explicit template argument list may be written empty,
2728 /// e.g., template<> void foo<>(char* s);
2729 const ASTTemplateArgumentListInfo*
2730 getTemplateSpecializationArgsAsWritten() const;
2731
2732 /// Specify that this function declaration is actually a function
2733 /// template specialization.
2734 ///
2735 /// \param Template the function template that this function template
2736 /// specialization specializes.
2737 ///
2738 /// \param TemplateArgs the template arguments that produced this
2739 /// function template specialization from the template.
2740 ///
2741 /// \param InsertPos If non-NULL, the position in the function template
2742 /// specialization set where the function template specialization data will
2743 /// be inserted.
2744 ///
2745 /// \param TSK the kind of template specialization this is.
2746 ///
2747 /// \param TemplateArgsAsWritten location info of template arguments.
2748 ///
2749 /// \param PointOfInstantiation point at which the function template
2750 /// specialization was first instantiated.
2751 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2752 const TemplateArgumentList *TemplateArgs,
2753 void *InsertPos,
2754 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
2755 const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2756 SourceLocation PointOfInstantiation = SourceLocation()) {
2757 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2758 InsertPos, TSK, TemplateArgsAsWritten,
2759 PointOfInstantiation);
2760 }
2761
2762 /// Specifies that this function declaration is actually a
2763 /// dependent function template specialization.
2764 void setDependentTemplateSpecialization(ASTContext &Context,
2765 const UnresolvedSetImpl &Templates,
2766 const TemplateArgumentListInfo &TemplateArgs);
2767
2768 DependentFunctionTemplateSpecializationInfo *
2769 getDependentSpecializationInfo() const;
2770
2771 /// Determine what kind of template instantiation this function
2772 /// represents.
2773 TemplateSpecializationKind getTemplateSpecializationKind() const;
2774
2775 /// Determine the kind of template specialization this function represents
2776 /// for the purpose of template instantiation.
2777 TemplateSpecializationKind
2778 getTemplateSpecializationKindForInstantiation() const;
2779
2780 /// Determine what kind of template instantiation this function
2781 /// represents.
2782 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2783 SourceLocation PointOfInstantiation = SourceLocation());
2784
2785 /// Retrieve the (first) point of instantiation of a function template
2786 /// specialization or a member of a class template specialization.
2787 ///
2788 /// \returns the first point of instantiation, if this function was
2789 /// instantiated from a template; otherwise, returns an invalid source
2790 /// location.
2791 SourceLocation getPointOfInstantiation() const;
2792
2793 /// Determine whether this is or was instantiated from an out-of-line
2794 /// definition of a member function.
2795 bool isOutOfLine() const override;
2796
2797 /// Identify a memory copying or setting function.
2798 /// If the given function is a memory copy or setting function, returns
2799 /// the corresponding Builtin ID. If the function is not a memory function,
2800 /// returns 0.
2801 unsigned getMemoryFunctionKind() const;
2802
2803 /// Returns ODRHash of the function. This value is calculated and
2804 /// stored on first call, then the stored value returned on the other calls.
2805 unsigned getODRHash();
2806
2807 /// Returns cached ODRHash of the function. This must have been previously
2808 /// computed and stored.
2809 unsigned getODRHash() const;
2810
2811 // Implement isa/cast/dyncast/etc.
2812 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2813 static bool classofKind(Kind K) {
2814 return K >= firstFunction && K <= lastFunction;
2815 }
2816 static DeclContext *castToDeclContext(const FunctionDecl *D) {
2817 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2818 }
2819 static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
2820 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2821 }
2822};
2823
2824/// Represents a member of a struct/union/class.
2825class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2826 unsigned BitField : 1;
2827 unsigned Mutable : 1;
2828 mutable unsigned CachedFieldIndex : 30;
2829
2830 /// The kinds of value we can store in InitializerOrBitWidth.
2831 ///
2832 /// Note that this is compatible with InClassInitStyle except for
2833 /// ISK_CapturedVLAType.
2834 enum InitStorageKind {
2835 /// If the pointer is null, there's nothing special. Otherwise,
2836 /// this is a bitfield and the pointer is the Expr* storing the
2837 /// bit-width.
2838 ISK_NoInit = (unsigned) ICIS_NoInit,
2839
2840 /// The pointer is an (optional due to delayed parsing) Expr*
2841 /// holding the copy-initializer.
2842 ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2843
2844 /// The pointer is an (optional due to delayed parsing) Expr*
2845 /// holding the list-initializer.
2846 ISK_InClassListInit = (unsigned) ICIS_ListInit,
2847
2848 /// The pointer is a VariableArrayType* that's been captured;
2849 /// the enclosing context is a lambda or captured statement.
2850 ISK_CapturedVLAType,
2851 };
2852
2853 /// If this is a bitfield with a default member initializer, this
2854 /// structure is used to represent the two expressions.
2855 struct InitAndBitWidth {
2856 Expr *Init;
2857 Expr *BitWidth;
2858 };
2859
2860 /// Storage for either the bit-width, the in-class initializer, or
2861 /// both (via InitAndBitWidth), or the captured variable length array bound.
2862 ///
2863 /// If the storage kind is ISK_InClassCopyInit or
2864 /// ISK_InClassListInit, but the initializer is null, then this
2865 /// field has an in-class initializer that has not yet been parsed
2866 /// and attached.
2867 // FIXME: Tail-allocate this to reduce the size of FieldDecl in the
2868 // overwhelmingly common case that we have none of these things.
2869 llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2870
2871protected:
2872 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
2873 SourceLocation IdLoc, IdentifierInfo *Id,
2874 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2875 InClassInitStyle InitStyle)
2876 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2877 BitField(false), Mutable(Mutable), CachedFieldIndex(0),
2878 InitStorage(nullptr, (InitStorageKind) InitStyle) {
2879 if (BW)
2880 setBitWidth(BW);
2881 }
2882
2883public:
2884 friend class ASTDeclReader;
2885 friend class ASTDeclWriter;
2886
2887 static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2888 SourceLocation StartLoc, SourceLocation IdLoc,
2889 IdentifierInfo *Id, QualType T,
2890 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2891 InClassInitStyle InitStyle);
2892
2893 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2894
2895 /// Returns the index of this field within its record,
2896 /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2897 unsigned getFieldIndex() const;
2898
2899 /// Determines whether this field is mutable (C++ only).
2900 bool isMutable() const { return Mutable; }
2901
2902 /// Determines whether this field is a bitfield.
2903 bool isBitField() const { return BitField; }
2904
2905 /// Determines whether this is an unnamed bitfield.
2906 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2907
2908 /// Determines whether this field is a
2909 /// representative for an anonymous struct or union. Such fields are
2910 /// unnamed and are implicitly generated by the implementation to
2911 /// store the data for the anonymous union or struct.
2912 bool isAnonymousStructOrUnion() const;
2913
2914 Expr *getBitWidth() const {
2915 if (!BitField)
2916 return nullptr;
2917 void *Ptr = InitStorage.getPointer();
2918 if (getInClassInitStyle())
2919 return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
2920 return static_cast<Expr*>(Ptr);
2921 }
2922
2923 unsigned getBitWidthValue(const ASTContext &Ctx) const;
2924
2925 /// Set the bit-field width for this member.
2926 // Note: used by some clients (i.e., do not remove it).
2927 void setBitWidth(Expr *Width) {
2928 assert(!hasCapturedVLAType() && !BitField &&((void)0)
2929 "bit width or captured type already set")((void)0);
2930 assert(Width && "no bit width specified")((void)0);
2931 InitStorage.setPointer(
2932 InitStorage.getInt()
2933 ? new (getASTContext())
2934 InitAndBitWidth{getInClassInitializer(), Width}
2935 : static_cast<void*>(Width));
2936 BitField = true;
2937 }
2938
2939 /// Remove the bit-field width from this member.
2940 // Note: used by some clients (i.e., do not remove it).
2941 void removeBitWidth() {
2942 assert(isBitField() && "no bitfield width to remove")((void)0);
2943 InitStorage.setPointer(getInClassInitializer());
2944 BitField = false;
2945 }
2946
2947 /// Is this a zero-length bit-field? Such bit-fields aren't really bit-fields
2948 /// at all and instead act as a separator between contiguous runs of other
2949 /// bit-fields.
2950 bool isZeroLengthBitField(const ASTContext &Ctx) const;
2951
2952 /// Determine if this field is a subobject of zero size, that is, either a
2953 /// zero-length bit-field or a field of empty class type with the
2954 /// [[no_unique_address]] attribute.
2955 bool isZeroSize(const ASTContext &Ctx) const;
2956
2957 /// Get the kind of (C++11) default member initializer that this field has.
2958 InClassInitStyle getInClassInitStyle() const {
2959 InitStorageKind storageKind = InitStorage.getInt();
2960 return (storageKind == ISK_CapturedVLAType
2961 ? ICIS_NoInit : (InClassInitStyle) storageKind);
2962 }
2963
2964 /// Determine whether this member has a C++11 default member initializer.
2965 bool hasInClassInitializer() const {
2966 return getInClassInitStyle() != ICIS_NoInit;
2967 }
2968
2969 /// Get the C++11 default member initializer for this member, or null if one
2970 /// has not been set. If a valid declaration has a default member initializer,
2971 /// but this returns null, then we have not parsed and attached it yet.
2972 Expr *getInClassInitializer() const {
2973 if (!hasInClassInitializer())
2974 return nullptr;
2975 void *Ptr = InitStorage.getPointer();
2976 if (BitField)
2977 return static_cast<InitAndBitWidth*>(Ptr)->Init;
2978 return static_cast<Expr*>(Ptr);
2979 }
2980
2981 /// Set the C++11 in-class initializer for this member.
2982 void setInClassInitializer(Expr *Init) {
2983 assert(hasInClassInitializer() && !getInClassInitializer())((void)0);
2984 if (BitField)
2985 static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
2986 else
2987 InitStorage.setPointer(Init);
2988 }
2989
2990 /// Remove the C++11 in-class initializer from this member.
2991 void removeInClassInitializer() {
2992 assert(hasInClassInitializer() && "no initializer to remove")((void)0);
2993 InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
2994 }
2995
2996 /// Determine whether this member captures the variable length array
2997 /// type.
2998 bool hasCapturedVLAType() const {
2999 return InitStorage.getInt() == ISK_CapturedVLAType;
3000 }
3001
3002 /// Get the captured variable length array type.
3003 const VariableArrayType *getCapturedVLAType() const {
3004 return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
3005 InitStorage.getPointer())
3006 : nullptr;
3007 }
3008
3009 /// Set the captured variable length array type for this field.
3010 void setCapturedVLAType(const VariableArrayType *VLAType);
3011
3012 /// Returns the parent of this field declaration, which
3013 /// is the struct in which this field is defined.
3014 ///
3015 /// Returns null if this is not a normal class/struct field declaration, e.g.
3016 /// ObjCAtDefsFieldDecl, ObjCIvarDecl.
3017 const RecordDecl *getParent() const {
3018 return dyn_cast<RecordDecl>(getDeclContext());
3019 }
3020
3021 RecordDecl *getParent() {
3022 return dyn_cast<RecordDecl>(getDeclContext());
3023 }
3024
3025 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3026
3027 /// Retrieves the canonical declaration of this field.
3028 FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
3029 const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3030
3031 // Implement isa/cast/dyncast/etc.
3032 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3033 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
3034};
3035
3036/// An instance of this object exists for each enum constant
3037/// that is defined. For example, in "enum X {a,b}", each of a/b are
3038/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
3039/// TagType for the X EnumDecl.
3040class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
3041 Stmt *Init; // an integer constant expression
3042 llvm::APSInt Val; // The value.
3043
3044protected:
3045 EnumConstantDecl(DeclContext *DC, SourceLocation L,
3046 IdentifierInfo *Id, QualType T, Expr *E,
3047 const llvm::APSInt &V)
3048 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
3049
3050public:
3051 friend class StmtIteratorBase;
3052
3053 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
3054 SourceLocation L, IdentifierInfo *Id,
3055 QualType T, Expr *E,
3056 const llvm::APSInt &V);
3057 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3058
3059 const Expr *getInitExpr() const { return (const Expr*) Init; }
3060 Expr *getInitExpr() { return (Expr*) Init; }
3061 const llvm::APSInt &getInitVal() const { return Val; }
3062
3063 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
3064 void setInitVal(const llvm::APSInt &V) { Val = V; }
3065
3066 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3067
3068 /// Retrieves the canonical declaration of this enumerator.
3069 EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
3070 const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
3071
3072 // Implement isa/cast/dyncast/etc.
3073 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3074 static bool classofKind(Kind K) { return K == EnumConstant; }
3075};
3076
3077/// Represents a field injected from an anonymous union/struct into the parent
3078/// scope. These are always implicit.
3079class IndirectFieldDecl : public ValueDecl,
3080 public Mergeable<IndirectFieldDecl> {
3081 NamedDecl **Chaining;
3082 unsigned ChainingSize;
3083
3084 IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
3085 DeclarationName N, QualType T,
3086 MutableArrayRef<NamedDecl *> CH);
3087
3088 void anchor() override;
3089
3090public:
3091 friend class ASTDeclReader;
3092
3093 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
3094 SourceLocation L, IdentifierInfo *Id,
3095 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);
3096
3097 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3098
3099 using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;
3100
3101 ArrayRef<NamedDecl *> chain() const {
3102 return llvm::makeArrayRef(Chaining, ChainingSize);
3103 }
3104 chain_iterator chain_begin() const { return chain().begin(); }
3105 chain_iterator chain_end() const { return chain().end(); }
3106
3107 unsigned getChainingSize() const { return ChainingSize; }
3108
3109 FieldDecl *getAnonField() const {
3110 assert(chain().size() >= 2)((void)0);
3111 return cast<FieldDecl>(chain().back());
3112 }
3113
3114 VarDecl *getVarDecl() const {
3115 assert(chain().size() >= 2)((void)0);
3116 return dyn_cast<VarDecl>(chain().front());
3117 }
3118
3119 IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
3120 const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3121
3122 // Implement isa/cast/dyncast/etc.
3123 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3124 static bool classofKind(Kind K) { return K == IndirectField; }
3125};
3126
3127/// Represents a declaration of a type.
3128class TypeDecl : public NamedDecl {
3129 friend class ASTContext;
3130
3131 /// This indicates the Type object that represents
3132 /// this TypeDecl. It is a cache maintained by
3133 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
3134 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
3135 mutable const Type *TypeForDecl = nullptr;
3136
3137 /// The start of the source range for this declaration.
3138 SourceLocation LocStart;
3139
3140 void anchor() override;
3141
3142protected:
3143 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
3144 SourceLocation StartL = SourceLocation())
3145 : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}
3146
3147public:
3148 // Low-level accessor. If you just want the type defined by this node,
3149 // check out ASTContext::getTypeDeclType or one of
3150 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
3151 // already know the specific kind of node this is.
3152 const Type *getTypeForDecl() const { return TypeForDecl; }
3153 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
3154
3155 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LocStart; }
3156 void setLocStart(SourceLocation L) { LocStart = L; }
3157 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
3158 if (LocStart.isValid())
3159 return SourceRange(LocStart, getLocation());
3160 else
3161 return SourceRange(getLocation());
3162 }
3163
3164 // Implement isa/cast/dyncast/etc.
3165 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3166 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
3167};
3168
3169/// Base class for declarations which introduce a typedef-name.
3170class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
3171 struct alignas(8) ModedTInfo {
3172 TypeSourceInfo *first;
3173 QualType second;
3174 };
3175
3176 /// If int part is 0, we have not computed IsTransparentTag.
3177 /// Otherwise, IsTransparentTag is (getInt() >> 1).
3178 mutable llvm::PointerIntPair<
3179 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3180 MaybeModedTInfo;
3181
3182 void anchor() override;
3183
3184protected:
3185 TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
3186 SourceLocation StartLoc, SourceLocation IdLoc,
3187 IdentifierInfo *Id, TypeSourceInfo *TInfo)
3188 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
3189 MaybeModedTInfo(TInfo, 0) {}
3190
3191 using redeclarable_base = Redeclarable<TypedefNameDecl>;
3192
3193 TypedefNameDecl *getNextRedeclarationImpl() override {
3194 return getNextRedeclaration();
3195 }
3196
3197 TypedefNameDecl *getPreviousDeclImpl() override {
3198 return getPreviousDecl();
3199 }
3200
3201 TypedefNameDecl *getMostRecentDeclImpl() override {
3202 return getMostRecentDecl();
3203 }
3204
3205public:
3206 using redecl_range = redeclarable_base::redecl_range;
3207 using redecl_iterator = redeclarable_base::redecl_iterator;
3208
3209 using redeclarable_base::redecls_begin;
3210 using redeclarable_base::redecls_end;
3211 using redeclarable_base::redecls;
3212 using redeclarable_base::getPreviousDecl;
3213 using redeclarable_base::getMostRecentDecl;
3214 using redeclarable_base::isFirstDecl;
3215
3216 bool isModed() const {
3217 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3218 }
3219
3220 TypeSourceInfo *getTypeSourceInfo() const {
3221 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3222 : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
3223 }
3224
3225 QualType getUnderlyingType() const {
3226 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3227 : MaybeModedTInfo.getPointer()
3228 .get<TypeSourceInfo *>()
3229 ->getType();
3230 }
3231
3232 void setTypeSourceInfo(TypeSourceInfo *newType) {
3233 MaybeModedTInfo.setPointer(newType);
3234 }
3235
3236 void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
3237 MaybeModedTInfo.setPointer(new (getASTContext(), 8)
3238 ModedTInfo({unmodedTSI, modedTy}));
3239 }
3240
3241 /// Retrieves the canonical declaration of this typedef-name.
3242 TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
3243 const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
3244
3245 /// Retrieves the tag declaration for which this is the typedef name for
3246 /// linkage purposes, if any.
3247 ///
3248 /// \param AnyRedecl Look for the tag declaration in any redeclaration of
3249 /// this typedef declaration.
3250 TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
3251
3252 /// Determines if this typedef shares a name and spelling location with its
3253 /// underlying tag type, as is the case with the NS_ENUM macro.
3254 bool isTransparentTag() const {
3255 if (MaybeModedTInfo.getInt())
3256 return MaybeModedTInfo.getInt() & 0x2;
3257 return isTransparentTagSlow();
3258 }
3259
3260 // Implement isa/cast/dyncast/etc.
3261 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3262 static bool classofKind(Kind K) {
3263 return K >= firstTypedefName && K <= lastTypedefName;
3264 }
3265
3266private:
3267 bool isTransparentTagSlow() const;
3268};
3269
3270/// Represents the declaration of a typedef-name via the 'typedef'
3271/// type specifier.
3272class TypedefDecl : public TypedefNameDecl {
3273 TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3274 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
3275 : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
3276
3277public:
3278 static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
3279 SourceLocation StartLoc, SourceLocation IdLoc,
3280 IdentifierInfo *Id, TypeSourceInfo *TInfo);
3281 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3282
3283 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3284
3285 // Implement isa/cast/dyncast/etc.
3286 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3287 static bool classofKind(Kind K) { return K == Typedef; }
3288};
3289
3290/// Represents the declaration of a typedef-name via a C++11
3291/// alias-declaration.
3292class TypeAliasDecl : public TypedefNameDecl {
3293 /// The template for which this is the pattern, if any.
3294 TypeAliasTemplateDecl *Template;
3295
3296 TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3297 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
3298 : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
3299 Template(nullptr) {}
3300
3301public:
3302 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
3303 SourceLocation StartLoc, SourceLocation IdLoc,
3304 IdentifierInfo *Id, TypeSourceInfo *TInfo);
3305 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3306
3307 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3308
3309 TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
3310 void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
3311
3312 // Implement isa/cast/dyncast/etc.
3313 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3314 static bool classofKind(Kind K) { return K == TypeAlias; }
3315};
3316
3317/// Represents the declaration of a struct/union/class/enum.
3318class TagDecl : public TypeDecl,
3319 public DeclContext,
3320 public Redeclarable<TagDecl> {
3321 // This class stores some data in DeclContext::TagDeclBits
3322 // to save some space. Use the provided accessors to access it.
3323public:
3324 // This is really ugly.
3325 using TagKind = TagTypeKind;
3326
3327private:
3328 SourceRange BraceRange;
3329
3330 // A struct representing syntactic qualifier info,
3331 // to be used for the (uncommon) case of out-of-line declarations.
3332 using ExtInfo = QualifierInfo;
3333
3334 /// If the (out-of-line) tag declaration name
3335 /// is qualified, it points to the qualifier info (nns and range);
3336 /// otherwise, if the tag declaration is anonymous and it is part of
3337 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
3338 /// otherwise, if the tag declaration is anonymous and it is used as a
3339 /// declaration specifier for variables, it points to the first VarDecl (used
3340 /// for mangling);
3341 /// otherwise, it is a null (TypedefNameDecl) pointer.
3342 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3343
3344 bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
3345 ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3346 const ExtInfo *getExtInfo() const {
3347 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3348 }
3349
3350protected:
3351 TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3352 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3353 SourceLocation StartL);
3354
3355 using redeclarable_base = Redeclarable<TagDecl>;
3356
3357 TagDecl *getNextRedeclarationImpl() override {
3358 return getNextRedeclaration();
3359 }
3360
3361 TagDecl *getPreviousDeclImpl() override {
3362 return getPreviousDecl();
3363 }
3364
3365 TagDecl *getMostRecentDeclImpl() override {
3366 return getMostRecentDecl();
3367 }
3368
3369 /// Completes the definition of this tag declaration.
3370 ///
3371 /// This is a helper function for derived classes.
3372 void completeDefinition();
3373
3374 /// True if this decl is currently being defined.
3375 void setBeingDefined(bool V = true) { TagDeclBits.IsBeingDefined = V; }
3376
3377 /// Indicates whether it is possible for declarations of this kind
3378 /// to have an out-of-date definition.
3379 ///
3380 /// This option is only enabled when modules are enabled.
3381 void setMayHaveOutOfDateDef(bool V = true) {
3382 TagDeclBits.MayHaveOutOfDateDef = V;
3383 }
3384
3385public:
3386 friend class ASTDeclReader;
3387 friend class ASTDeclWriter;
3388
3389 using redecl_range = redeclarable_base::redecl_range;
3390 using redecl_iterator = redeclarable_base::redecl_iterator;
3391
3392 using redeclarable_base::redecls_begin;
3393 using redeclarable_base::redecls_end;
3394 using redeclarable_base::redecls;
3395 using redeclarable_base::getPreviousDecl;
3396 using redeclarable_base::getMostRecentDecl;
3397 using redeclarable_base::isFirstDecl;
3398
3399 SourceRange getBraceRange() const { return BraceRange; }
3400 void setBraceRange(SourceRange R) { BraceRange = R; }
3401
3402 /// Return SourceLocation representing start of source
3403 /// range ignoring outer template declarations.
3404 SourceLocation getInnerLocStart() const { return getBeginLoc(); }
3405
3406 /// Return SourceLocation representing start of source
3407 /// range taking into account any outer template declarations.
3408 SourceLocation getOuterLocStart() const;
3409 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
3410
3411 TagDecl *getCanonicalDecl() override;
3412 const TagDecl *getCanonicalDecl() const {
3413 return const_cast<TagDecl*>(this)->getCanonicalDecl();
3414 }
3415
3416 /// Return true if this declaration is a completion definition of the type.
3417 /// Provided for consistency.
3418 bool isThisDeclarationADefinition() const {
3419 return isCompleteDefinition();
3420 }
3421
3422 /// Return true if this decl has its body fully specified.
3423 bool isCompleteDefinition() const { return TagDeclBits.IsCompleteDefinition; }
3424
3425 /// True if this decl has its body fully specified.
3426 void setCompleteDefinition(bool V = true) {
3427 TagDeclBits.IsCompleteDefinition = V;
3428 }
3429
3430 /// Return true if this complete decl is
3431 /// required to be complete for some existing use.
3432 bool isCompleteDefinitionRequired() const {
3433 return TagDeclBits.IsCompleteDefinitionRequired;
3434 }
3435
3436 /// True if this complete decl is
3437 /// required to be complete for some existing use.
3438 void setCompleteDefinitionRequired(bool V = true) {
3439 TagDeclBits.IsCompleteDefinitionRequired = V;
3440 }
3441
3442 /// Return true if this decl is currently being defined.
3443 bool isBeingDefined() const { return TagDeclBits.IsBeingDefined; }
3444
3445 /// True if this tag declaration is "embedded" (i.e., defined or declared
3446 /// for the very first time) in the syntax of a declarator.
3447 bool isEmbeddedInDeclarator() const {
3448 return TagDeclBits.IsEmbeddedInDeclarator;
3449 }
3450
3451 /// True if this tag declaration is "embedded" (i.e., defined or declared
3452 /// for the very first time) in the syntax of a declarator.
3453 void setEmbeddedInDeclarator(bool isInDeclarator) {
3454 TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3455 }
3456
3457 /// True if this tag is free standing, e.g. "struct foo;".
3458 bool isFreeStanding() const { return TagDeclBits.IsFreeStanding; }
3459
3460 /// True if this tag is free standing, e.g. "struct foo;".
3461 void setFreeStanding(bool isFreeStanding = true) {
3462 TagDeclBits.IsFreeStanding = isFreeStanding;
3463 }
3464
3465 /// Indicates whether it is possible for declarations of this kind
3466 /// to have an out-of-date definition.
3467 ///
3468 /// This option is only enabled when modules are enabled.
3469 bool mayHaveOutOfDateDef() const { return TagDeclBits.MayHaveOutOfDateDef; }
3470
3471 /// Whether this declaration declares a type that is
3472 /// dependent, i.e., a type that somehow depends on template
3473 /// parameters.
3474 bool isDependentType() const { return isDependentContext(); }
3475
3476 /// Starts the definition of this tag declaration.
3477 ///
3478 /// This method should be invoked at the beginning of the definition
3479 /// of this tag declaration. It will set the tag type into a state
3480 /// where it is in the process of being defined.
3481 void startDefinition();
3482
3483 /// Returns the TagDecl that actually defines this
3484 /// struct/union/class/enum. When determining whether or not a
3485 /// struct/union/class/enum has a definition, one should use this
3486 /// method as opposed to 'isDefinition'. 'isDefinition' indicates
3487 /// whether or not a specific TagDecl is defining declaration, not
3488 /// whether or not the struct/union/class/enum type is defined.
3489 /// This method returns NULL if there is no TagDecl that defines
3490 /// the struct/union/class/enum.
3491 TagDecl *getDefinition() const;
3492
3493 StringRef getKindName() const {
3494 return TypeWithKeyword::getTagTypeKindName(getTagKind());
3495 }
3496
3497 TagKind getTagKind() const {
3498 return static_cast<TagKind>(TagDeclBits.TagDeclKind);
3499 }
3500
3501 void setTagKind(TagKind TK) { TagDeclBits.TagDeclKind = TK; }
3502
3503 bool isStruct() const { return getTagKind() == TTK_Struct; }
3504 bool isInterface() const { return getTagKind() == TTK_Interface; }
3505 bool isClass() const { return getTagKind() == TTK_Class; }
3506 bool isUnion() const { return getTagKind() == TTK_Union; }
33
Assuming the condition is false
34
Returning zero, which participates in a condition later
39
Assuming the condition is true
40
Returning the value 1, which participates in a condition later
3507 bool isEnum() const { return getTagKind() == TTK_Enum; }
3508
3509 /// Is this tag type named, either directly or via being defined in
3510 /// a typedef of this type?
3511 ///
3512 /// C++11 [basic.link]p8:
3513 /// A type is said to have linkage if and only if:
3514 /// - it is a class or enumeration type that is named (or has a
3515 /// name for linkage purposes) and the name has linkage; ...
3516 /// C++11 [dcl.typedef]p9:
3517 /// If the typedef declaration defines an unnamed class (or enum),
3518 /// the first typedef-name declared by the declaration to be that
3519 /// class type (or enum type) is used to denote the class type (or
3520 /// enum type) for linkage purposes only.
3521 ///
3522 /// C does not have an analogous rule, but the same concept is
3523 /// nonetheless useful in some places.
3524 bool hasNameForLinkage() const {
3525 return (getDeclName() || getTypedefNameForAnonDecl());
3526 }
3527
3528 TypedefNameDecl *getTypedefNameForAnonDecl() const {
3529 return hasExtInfo() ? nullptr
3530 : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3531 }
3532
3533 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
3534
3535 /// Retrieve the nested-name-specifier that qualifies the name of this
3536 /// declaration, if it was present in the source.
3537 NestedNameSpecifier *getQualifier() const {
3538 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3539 : nullptr;
3540 }
3541
3542 /// Retrieve the nested-name-specifier (with source-location
3543 /// information) that qualifies the name of this declaration, if it was
3544 /// present in the source.
3545 NestedNameSpecifierLoc getQualifierLoc() const {
3546 return hasExtInfo() ? getExtInfo()->QualifierLoc
3547 : NestedNameSpecifierLoc();
3548 }
3549
3550 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3551
3552 unsigned getNumTemplateParameterLists() const {
3553 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3554 }
3555
3556 TemplateParameterList *getTemplateParameterList(unsigned i) const {
3557 assert(i < getNumTemplateParameterLists())((void)0);
3558 return getExtInfo()->TemplParamLists[i];
3559 }
3560
3561 void setTemplateParameterListsInfo(ASTContext &Context,
3562 ArrayRef<TemplateParameterList *> TPLists);
3563
3564 // Implement isa/cast/dyncast/etc.
3565 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3566 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3567
3568 static DeclContext *castToDeclContext(const TagDecl *D) {
3569 return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3570 }
3571
3572 static TagDecl *castFromDeclContext(const DeclContext *DC) {
3573 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3574 }
3575};
3576
3577/// Represents an enum. In C++11, enums can be forward-declared
3578/// with a fixed underlying type, and in C we allow them to be forward-declared
3579/// with no underlying type as an extension.
3580class EnumDecl : public TagDecl {
3581 // This class stores some data in DeclContext::EnumDeclBits
3582 // to save some space. Use the provided accessors to access it.
3583
3584 /// This represent the integer type that the enum corresponds
3585 /// to for code generation purposes. Note that the enumerator constants may
3586 /// have a different type than this does.
3587 ///
3588 /// If the underlying integer type was explicitly stated in the source
3589 /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3590 /// was automatically deduced somehow, and this is a Type*.
3591 ///
3592 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3593 /// some cases it won't.
3594 ///
3595 /// The underlying type of an enumeration never has any qualifiers, so
3596 /// we can get away with just storing a raw Type*, and thus save an
3597 /// extra pointer when TypeSourceInfo is needed.
3598 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3599
3600 /// The integer type that values of this type should
3601 /// promote to. In C, enumerators are generally of an integer type
3602 /// directly, but gcc-style large enumerators (and all enumerators
3603 /// in C++) are of the enum type instead.
3604 QualType PromotionType;
3605
3606 /// If this enumeration is an instantiation of a member enumeration
3607 /// of a class template specialization, this is the member specialization
3608 /// information.
3609 MemberSpecializationInfo *SpecializationInfo = nullptr;
3610
3611 /// Store the ODRHash after first calculation.
3612 /// The corresponding flag HasODRHash is in EnumDeclBits
3613 /// and can be accessed with the provided accessors.
3614 unsigned ODRHash;
3615
3616 EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3617 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3618 bool Scoped, bool ScopedUsingClassTag, bool Fixed);
3619
3620 void anchor() override;
3621
3622 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3623 TemplateSpecializationKind TSK);
3624
3625 /// Sets the width in bits required to store all the
3626 /// non-negative enumerators of this enum.
3627 void setNumPositiveBits(unsigned Num) {
3628 EnumDeclBits.NumPositiveBits = Num;
3629 assert(EnumDeclBits.NumPositiveBits == Num && "can't store this bitcount")((void)0);
3630 }
3631
3632 /// Returns the width in bits required to store all the
3633 /// negative enumerators of this enum. (see getNumNegativeBits)
3634 void setNumNegativeBits(unsigned Num) { EnumDeclBits.NumNegativeBits = Num; }
3635
3636public:
3637 /// True if this tag declaration is a scoped enumeration. Only
3638 /// possible in C++11 mode.
3639 void setScoped(bool Scoped = true) { EnumDeclBits.IsScoped = Scoped; }
3640
3641 /// If this tag declaration is a scoped enum,
3642 /// then this is true if the scoped enum was declared using the class
3643 /// tag, false if it was declared with the struct tag. No meaning is
3644 /// associated if this tag declaration is not a scoped enum.
3645 void setScopedUsingClassTag(bool ScopedUCT = true) {
3646 EnumDeclBits.IsScopedUsingClassTag = ScopedUCT;
3647 }
3648
3649 /// True if this is an Objective-C, C++11, or
3650 /// Microsoft-style enumeration with a fixed underlying type.
3651 void setFixed(bool Fixed = true) { EnumDeclBits.IsFixed = Fixed; }
3652
3653private:
3654 /// True if a valid hash is stored in ODRHash.
3655 bool hasODRHash() const { return EnumDeclBits.HasODRHash; }
3656 void setHasODRHash(bool Hash = true) { EnumDeclBits.HasODRHash = Hash; }
3657
3658public:
3659 friend class ASTDeclReader;
3660
3661 EnumDecl *getCanonicalDecl() override {
3662 return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3663 }
3664 const EnumDecl *getCanonicalDecl() const {
3665 return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3666 }
3667
3668 EnumDecl *getPreviousDecl() {
3669 return cast_or_null<EnumDecl>(
3670 static_cast<TagDecl *>(this)->getPreviousDecl());
3671 }
3672 const EnumDecl *getPreviousDecl() const {
3673 return const_cast<EnumDecl*>(this)->getPreviousDecl();
3674 }
3675
3676 EnumDecl *getMostRecentDecl() {
3677 return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3678 }
3679 const EnumDecl *getMostRecentDecl() const {
3680 return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3681 }
3682
3683 EnumDecl *getDefinition() const {
3684 return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3685 }
3686
3687 static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3688 SourceLocation StartLoc, SourceLocation IdLoc,
3689 IdentifierInfo *Id, EnumDecl *PrevDecl,
3690 bool IsScoped, bool IsScopedUsingClassTag,
3691 bool IsFixed);
3692 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3693
3694 /// When created, the EnumDecl corresponds to a
3695 /// forward-declared enum. This method is used to mark the
3696 /// declaration as being defined; its enumerators have already been
3697 /// added (via DeclContext::addDecl). NewType is the new underlying
3698 /// type of the enumeration type.
3699 void completeDefinition(QualType NewType,
3700 QualType PromotionType,
3701 unsigned NumPositiveBits,
3702 unsigned NumNegativeBits);
3703
3704 // Iterates through the enumerators of this enumeration.
3705 using enumerator_iterator = specific_decl_iterator<EnumConstantDecl>;
3706 using enumerator_range =
3707 llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;
3708
3709 enumerator_range enumerators() const {
3710 return enumerator_range(enumerator_begin(), enumerator_end());
3711 }
3712
3713 enumerator_iterator enumerator_begin() const {
3714 const EnumDecl *E = getDefinition();
3715 if (!E)
3716 E = this;
3717 return enumerator_iterator(E->decls_begin());
3718 }
3719
3720 enumerator_iterator enumerator_end() const {
3721 const EnumDecl *E = getDefinition();
3722 if (!E)
3723 E = this;
3724 return enumerator_iterator(E->decls_end());
3725 }
3726
3727 /// Return the integer type that enumerators should promote to.
3728 QualType getPromotionType() const { return PromotionType; }
3729
3730 /// Set the promotion type.
3731 void setPromotionType(QualType T) { PromotionType = T; }
3732
3733 /// Return the integer type this enum decl corresponds to.
3734 /// This returns a null QualType for an enum forward definition with no fixed
3735 /// underlying type.
3736 QualType getIntegerType() const {
3737 if (!IntegerType)
3738 return QualType();
3739 if (const Type *T = IntegerType.dyn_cast<const Type*>())
3740 return QualType(T, 0);
3741 return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3742 }
3743
3744 /// Set the underlying integer type.
3745 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3746
3747 /// Set the underlying integer type source info.
3748 void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3749
3750 /// Return the type source info for the underlying integer type,
3751 /// if no type source info exists, return 0.
3752 TypeSourceInfo *getIntegerTypeSourceInfo() const {
3753 return IntegerType.dyn_cast<TypeSourceInfo*>();
3754 }
3755
3756 /// Retrieve the source range that covers the underlying type if
3757 /// specified.
3758 SourceRange getIntegerTypeRange() const LLVM_READONLY__attribute__((__pure__));
3759
3760 /// Returns the width in bits required to store all the
3761 /// non-negative enumerators of this enum.
3762 unsigned getNumPositiveBits() const { return EnumDeclBits.NumPositiveBits; }
3763
3764 /// Returns the width in bits required to store all the
3765 /// negative enumerators of this enum. These widths include
3766 /// the rightmost leading 1; that is:
3767 ///
3768 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3769 /// ------------------------ ------- -----------------
3770 /// -1 1111111 1
3771 /// -10 1110110 5
3772 /// -101 1001011 8
3773 unsigned getNumNegativeBits() const { return EnumDeclBits.NumNegativeBits; }
3774
3775 /// Returns true if this is a C++11 scoped enumeration.
3776 bool isScoped() const { return EnumDeclBits.IsScoped; }
3777
3778 /// Returns true if this is a C++11 scoped enumeration.
3779 bool isScopedUsingClassTag() const {
3780 return EnumDeclBits.IsScopedUsingClassTag;
3781 }
3782
3783 /// Returns true if this is an Objective-C, C++11, or
3784 /// Microsoft-style enumeration with a fixed underlying type.
3785 bool isFixed() const { return EnumDeclBits.IsFixed; }
3786
3787 unsigned getODRHash();
3788
3789 /// Returns true if this can be considered a complete type.
3790 bool isComplete() const {
3791 // IntegerType is set for fixed type enums and non-fixed but implicitly
3792 // int-sized Microsoft enums.
3793 return isCompleteDefinition() || IntegerType;
3794 }
3795
3796 /// Returns true if this enum is either annotated with
3797 /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3798 bool isClosed() const;
3799
3800 /// Returns true if this enum is annotated with flag_enum and isn't annotated
3801 /// with enum_extensibility(open).
3802 bool isClosedFlag() const;
3803
3804 /// Returns true if this enum is annotated with neither flag_enum nor
3805 /// enum_extensibility(open).
3806 bool isClosedNonFlag() const;
3807
3808 /// Retrieve the enum definition from which this enumeration could
3809 /// be instantiated, if it is an instantiation (rather than a non-template).
3810 EnumDecl *getTemplateInstantiationPattern() const;
3811
3812 /// Returns the enumeration (declared within the template)
3813 /// from which this enumeration type was instantiated, or NULL if
3814 /// this enumeration was not instantiated from any template.
3815 EnumDecl *getInstantiatedFromMemberEnum() const;
3816
3817 /// If this enumeration is a member of a specialization of a
3818 /// templated class, determine what kind of template specialization
3819 /// or instantiation this is.
3820 TemplateSpecializationKind getTemplateSpecializationKind() const;
3821
3822 /// For an enumeration member that was instantiated from a member
3823 /// enumeration of a templated class, set the template specialiation kind.
3824 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3825 SourceLocation PointOfInstantiation = SourceLocation());
3826
3827 /// If this enumeration is an instantiation of a member enumeration of
3828 /// a class template specialization, retrieves the member specialization
3829 /// information.
3830 MemberSpecializationInfo *getMemberSpecializationInfo() const {
3831 return SpecializationInfo;
3832 }
3833
3834 /// Specify that this enumeration is an instantiation of the
3835 /// member enumeration ED.
3836 void setInstantiationOfMemberEnum(EnumDecl *ED,
3837 TemplateSpecializationKind TSK) {
3838 setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3839 }
3840
3841 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3842 static bool classofKind(Kind K) { return K == Enum; }
3843};
3844
3845/// Represents a struct/union/class. For example:
3846/// struct X; // Forward declaration, no "body".
3847/// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3848/// This decl will be marked invalid if *any* members are invalid.
3849class RecordDecl : public TagDecl {
3850 // This class stores some data in DeclContext::RecordDeclBits
3851 // to save some space. Use the provided accessors to access it.
3852public:
3853 friend class DeclContext;
3854 /// Enum that represents the different ways arguments are passed to and
3855 /// returned from function calls. This takes into account the target-specific
3856 /// and version-specific rules along with the rules determined by the
3857 /// language.
3858 enum ArgPassingKind : unsigned {
3859 /// The argument of this type can be passed directly in registers.
3860 APK_CanPassInRegs,
3861
3862 /// The argument of this type cannot be passed directly in registers.
3863 /// Records containing this type as a subobject are not forced to be passed
3864 /// indirectly. This value is used only in C++. This value is required by
3865 /// C++ because, in uncommon situations, it is possible for a class to have
3866 /// only trivial copy/move constructors even when one of its subobjects has
3867 /// a non-trivial copy/move constructor (if e.g. the corresponding copy/move
3868 /// constructor in the derived class is deleted).
3869 APK_CannotPassInRegs,
3870
3871 /// The argument of this type cannot be passed directly in registers.
3872 /// Records containing this type as a subobject are forced to be passed
3873 /// indirectly.
3874 APK_CanNeverPassInRegs
3875 };
3876
3877protected:
3878 RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3879 SourceLocation StartLoc, SourceLocation IdLoc,
3880 IdentifierInfo *Id, RecordDecl *PrevDecl);
3881
3882public:
3883 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3884 SourceLocation StartLoc, SourceLocation IdLoc,
3885 IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3886 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3887
3888 RecordDecl *getPreviousDecl() {
3889 return cast_or_null<RecordDecl>(
3890 static_cast<TagDecl *>(this)->getPreviousDecl());
3891 }
3892 const RecordDecl *getPreviousDecl() const {
3893 return const_cast<RecordDecl*>(this)->getPreviousDecl();
3894 }
3895
3896 RecordDecl *getMostRecentDecl() {
3897 return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3898 }
3899 const RecordDecl *getMostRecentDecl() const {
3900 return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3901 }
3902
3903 bool hasFlexibleArrayMember() const {
3904 return RecordDeclBits.HasFlexibleArrayMember;
3905 }
3906
3907 void setHasFlexibleArrayMember(bool V) {
3908 RecordDeclBits.HasFlexibleArrayMember = V;
3909 }
3910
3911 /// Whether this is an anonymous struct or union. To be an anonymous
3912 /// struct or union, it must have been declared without a name and
3913 /// there must be no objects of this type declared, e.g.,
3914 /// @code
3915 /// union { int i; float f; };
3916 /// @endcode
3917 /// is an anonymous union but neither of the following are:
3918 /// @code
3919 /// union X { int i; float f; };
3920 /// union { int i; float f; } obj;
3921 /// @endcode
3922 bool isAnonymousStructOrUnion() const {
3923 return RecordDeclBits.AnonymousStructOrUnion;
3924 }
3925
3926 void setAnonymousStructOrUnion(bool Anon) {
3927 RecordDeclBits.AnonymousStructOrUnion = Anon;
3928 }
3929
3930 bool hasObjectMember() const { return RecordDeclBits.HasObjectMember; }
3931 void setHasObjectMember(bool val) { RecordDeclBits.HasObjectMember = val; }
3932
3933 bool hasVolatileMember() const { return RecordDeclBits.HasVolatileMember; }
3934
3935 void setHasVolatileMember(bool val) {
3936 RecordDeclBits.HasVolatileMember = val;
3937 }
3938
3939 bool hasLoadedFieldsFromExternalStorage() const {
3940 return RecordDeclBits.LoadedFieldsFromExternalStorage;
3941 }
3942
3943 void setHasLoadedFieldsFromExternalStorage(bool val) const {
3944 RecordDeclBits.LoadedFieldsFromExternalStorage = val;
3945 }
3946
3947 /// Functions to query basic properties of non-trivial C structs.
3948 bool isNonTrivialToPrimitiveDefaultInitialize() const {
3949 return RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize;
3950 }
3951
3952 void setNonTrivialToPrimitiveDefaultInitialize(bool V) {
3953 RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize = V;
3954 }
3955
3956 bool isNonTrivialToPrimitiveCopy() const {
3957 return RecordDeclBits.NonTrivialToPrimitiveCopy;
3958 }
3959
3960 void setNonTrivialToPrimitiveCopy(bool V) {
3961 RecordDeclBits.NonTrivialToPrimitiveCopy = V;
3962 }
3963
3964 bool isNonTrivialToPrimitiveDestroy() const {
3965 return RecordDeclBits.NonTrivialToPrimitiveDestroy;
3966 }
3967
3968 void setNonTrivialToPrimitiveDestroy(bool V) {
3969 RecordDeclBits.NonTrivialToPrimitiveDestroy = V;
3970 }
3971
3972 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
3973 return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
3974 }
3975
3976 void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V) {
3977 RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion = V;
3978 }
3979
3980 bool hasNonTrivialToPrimitiveDestructCUnion() const {
3981 return RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion;
3982 }
3983
3984 void setHasNonTrivialToPrimitiveDestructCUnion(bool V) {
3985 RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion = V;
3986 }
3987
3988 bool hasNonTrivialToPrimitiveCopyCUnion() const {
3989 return RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion;
3990 }
3991
3992 void setHasNonTrivialToPrimitiveCopyCUnion(bool V) {
3993 RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion = V;
3994 }
3995
3996 /// Determine whether this class can be passed in registers. In C++ mode,
3997 /// it must have at least one trivial, non-deleted copy or move constructor.
3998 /// FIXME: This should be set as part of completeDefinition.
3999 bool canPassInRegisters() const {
4000 return getArgPassingRestrictions() == APK_CanPassInRegs;
4001 }
4002
4003 ArgPassingKind getArgPassingRestrictions() const {
4004 return static_cast<ArgPassingKind>(RecordDeclBits.ArgPassingRestrictions);
4005 }
4006
4007 void setArgPassingRestrictions(ArgPassingKind Kind) {
4008 RecordDeclBits.ArgPassingRestrictions = Kind;
4009 }
4010
4011 bool isParamDestroyedInCallee() const {
4012 return RecordDeclBits.ParamDestroyedInCallee;
4013 }
4014
4015 void setParamDestroyedInCallee(bool V) {
4016 RecordDeclBits.ParamDestroyedInCallee = V;
4017 }
4018
4019 /// Determines whether this declaration represents the
4020 /// injected class name.
4021 ///
4022 /// The injected class name in C++ is the name of the class that
4023 /// appears inside the class itself. For example:
4024 ///
4025 /// \code
4026 /// struct C {
4027 /// // C is implicitly declared here as a synonym for the class name.
4028 /// };
4029 ///
4030 /// C::C c; // same as "C c;"
4031 /// \endcode
4032 bool isInjectedClassName() const;
4033
4034 /// Determine whether this record is a class describing a lambda
4035 /// function object.
4036 bool isLambda() const;
4037
4038 /// Determine whether this record is a record for captured variables in
4039 /// CapturedStmt construct.
4040 bool isCapturedRecord() const;
4041
4042 /// Mark the record as a record for captured variables in CapturedStmt
4043 /// construct.
4044 void setCapturedRecord();
4045
4046 /// Returns the RecordDecl that actually defines
4047 /// this struct/union/class. When determining whether or not a
4048 /// struct/union/class is completely defined, one should use this
4049 /// method as opposed to 'isCompleteDefinition'.
4050 /// 'isCompleteDefinition' indicates whether or not a specific
4051 /// RecordDecl is a completed definition, not whether or not the
4052 /// record type is defined. This method returns NULL if there is
4053 /// no RecordDecl that defines the struct/union/tag.
4054 RecordDecl *getDefinition() const {
4055 return cast_or_null<RecordDecl>(TagDecl::getDefinition());
4056 }
4057
4058 /// Returns whether this record is a union, or contains (at any nesting level)
4059 /// a union member. This is used by CMSE to warn about possible information
4060 /// leaks.
4061 bool isOrContainsUnion() const;
4062
4063 // Iterator access to field members. The field iterator only visits
4064 // the non-static data members of this class, ignoring any static
4065 // data members, functions, constructors, destructors, etc.
4066 using field_iterator = specific_decl_iterator<FieldDecl>;
4067 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4068
4069 field_range fields() const { return field_range(field_begin(), field_end()); }
4070 field_iterator field_begin() const;
4071
4072 field_iterator field_end() const {
4073 return field_iterator(decl_iterator());
4074 }
4075
4076 // Whether there are any fields (non-static data members) in this record.
4077 bool field_empty() const {
4078 return field_begin() == field_end();
44
Calling 'operator=='
50
Returning from 'operator=='
51
Returning zero, which participates in a condition later
4079 }
4080
4081 /// Note that the definition of this type is now complete.
4082 virtual void completeDefinition();
4083
4084 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4085 static bool classofKind(Kind K) {
4086 return K >= firstRecord && K <= lastRecord;
4087 }
4088
4089 /// Get whether or not this is an ms_struct which can
4090 /// be turned on with an attribute, pragma, or -mms-bitfields
4091 /// commandline option.
4092 bool isMsStruct(const ASTContext &C) const;
4093
4094 /// Whether we are allowed to insert extra padding between fields.
4095 /// These padding are added to help AddressSanitizer detect
4096 /// intra-object-overflow bugs.
4097 bool mayInsertExtraPadding(bool EmitRemark = false) const;
4098
4099 /// Finds the first data member which has a name.
4100 /// nullptr is returned if no named data member exists.
4101 const FieldDecl *findFirstNamedDataMember() const;
4102
4103private:
4104 /// Deserialize just the fields.
4105 void LoadFieldsFromExternalStorage() const;
4106};
4107
4108class FileScopeAsmDecl : public Decl {
4109 StringLiteral *AsmString;
4110 SourceLocation RParenLoc;
4111
4112 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
4113 SourceLocation StartL, SourceLocation EndL)
4114 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4115
4116 virtual void anchor();
4117
4118public:
4119 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
4120 StringLiteral *Str, SourceLocation AsmLoc,
4121 SourceLocation RParenLoc);
4122
4123 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4124
4125 SourceLocation getAsmLoc() const { return getLocation(); }
4126 SourceLocation getRParenLoc() const { return RParenLoc; }
4127 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
4128 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
4129 return SourceRange(getAsmLoc(), getRParenLoc());
4130 }
4131
4132 const StringLiteral *getAsmString() const { return AsmString; }
4133 StringLiteral *getAsmString() { return AsmString; }
4134 void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
4135
4136 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4137 static bool classofKind(Kind K) { return K == FileScopeAsm; }
4138};
4139
4140/// Represents a block literal declaration, which is like an
4141/// unnamed FunctionDecl. For example:
4142/// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
4143class BlockDecl : public Decl, public DeclContext {
4144 // This class stores some data in DeclContext::BlockDeclBits
4145 // to save some space. Use the provided accessors to access it.
4146public:
4147 /// A class which contains all the information about a particular
4148 /// captured value.
4149 class Capture {
4150 enum {
4151 flag_isByRef = 0x1,
4152 flag_isNested = 0x2
4153 };
4154
4155 /// The variable being captured.
4156 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4157
4158 /// The copy expression, expressed in terms of a DeclRef (or
4159 /// BlockDeclRef) to the captured variable. Only required if the
4160 /// variable has a C++ class type.
4161 Expr *CopyExpr;
4162
4163 public:
4164 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
4165 : VariableAndFlags(variable,
4166 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4167 CopyExpr(copy) {}
4168
4169 /// The variable being captured.
4170 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
4171
4172 /// Whether this is a "by ref" capture, i.e. a capture of a __block
4173 /// variable.
4174 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
4175
4176 bool isEscapingByref() const {
4177 return getVariable()->isEscapingByref();
4178 }
4179
4180 bool isNonEscapingByref() const {
4181 return getVariable()->isNonEscapingByref();
4182 }
4183
4184 /// Whether this is a nested capture, i.e. the variable captured
4185 /// is not from outside the immediately enclosing function/block.
4186 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
4187
4188 bool hasCopyExpr() const { return CopyExpr != nullptr; }
4189 Expr *getCopyExpr() const { return CopyExpr; }
4190 void setCopyExpr(Expr *e) { CopyExpr = e; }
4191 };
4192
4193private:
4194 /// A new[]'d array of pointers to ParmVarDecls for the formal
4195 /// parameters of this function. This is null if a prototype or if there are
4196 /// no formals.
4197 ParmVarDecl **ParamInfo = nullptr;
4198 unsigned NumParams = 0;
4199
4200 Stmt *Body = nullptr;
4201 TypeSourceInfo *SignatureAsWritten = nullptr;
4202
4203 const Capture *Captures = nullptr;
4204 unsigned NumCaptures = 0;
4205
4206 unsigned ManglingNumber = 0;
4207 Decl *ManglingContextDecl = nullptr;
4208
4209protected:
4210 BlockDecl(DeclContext *DC, SourceLocation CaretLoc);
4211
4212public:
4213 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
4214 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4215
4216 SourceLocation getCaretLocation() const { return getLocation(); }
4217
4218 bool isVariadic() const { return BlockDeclBits.IsVariadic; }
4219 void setIsVariadic(bool value) { BlockDeclBits.IsVariadic = value; }
4220
4221 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
4222 Stmt *getBody() const override { return (Stmt*) Body; }
4223 void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
4224
4225 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
4226 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
4227
4228 // ArrayRef access to formal parameters.
4229 ArrayRef<ParmVarDecl *> parameters() const {
4230 return {ParamInfo, getNumParams()};
4231 }
4232 MutableArrayRef<ParmVarDecl *> parameters() {
4233 return {ParamInfo, getNumParams()};
4234 }
4235
4236 // Iterator access to formal parameters.
4237 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
4238 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
4239
4240 bool param_empty() const { return parameters().empty(); }
4241 param_iterator param_begin() { return parameters().begin(); }
4242 param_iterator param_end() { return parameters().end(); }
4243 param_const_iterator param_begin() const { return parameters().begin(); }
4244 param_const_iterator param_end() const { return parameters().end(); }
4245 size_t param_size() const { return parameters().size(); }
4246
4247 unsigned getNumParams() const { return NumParams; }
4248
4249 const ParmVarDecl *getParamDecl(unsigned i) const {
4250 assert(i < getNumParams() && "Illegal param #")((void)0);
4251 return ParamInfo[i];
4252 }
4253 ParmVarDecl *getParamDecl(unsigned i) {
4254 assert(i < getNumParams() && "Illegal param #")((void)0);
4255 return ParamInfo[i];
4256 }
4257
4258 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
4259
4260 /// True if this block (or its nested blocks) captures
4261 /// anything of local storage from its enclosing scopes.
4262 bool hasCaptures() const { return NumCaptures || capturesCXXThis(); }
4263
4264 /// Returns the number of captured variables.
4265 /// Does not include an entry for 'this'.
4266 unsigned getNumCaptures() const { return NumCaptures; }
4267
4268 using capture_const_iterator = ArrayRef<Capture>::const_iterator;
4269
4270 ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
4271
4272 capture_const_iterator capture_begin() const { return captures().begin(); }
4273 capture_const_iterator capture_end() const { return captures().end(); }
4274
4275 bool capturesCXXThis() const { return BlockDeclBits.CapturesCXXThis; }
4276 void setCapturesCXXThis(bool B = true) { BlockDeclBits.CapturesCXXThis = B; }
4277
4278 bool blockMissingReturnType() const {
4279 return BlockDeclBits.BlockMissingReturnType;
4280 }
4281
4282 void setBlockMissingReturnType(bool val = true) {
4283 BlockDeclBits.BlockMissingReturnType = val;
4284 }
4285
4286 bool isConversionFromLambda() const {
4287 return BlockDeclBits.IsConversionFromLambda;
4288 }
4289
4290 void setIsConversionFromLambda(bool val = true) {
4291 BlockDeclBits.IsConversionFromLambda = val;
4292 }
4293
4294 bool doesNotEscape() const { return BlockDeclBits.DoesNotEscape; }
4295 void setDoesNotEscape(bool B = true) { BlockDeclBits.DoesNotEscape = B; }
4296
4297 bool canAvoidCopyToHeap() const {
4298 return BlockDeclBits.CanAvoidCopyToHeap;
4299 }
4300 void setCanAvoidCopyToHeap(bool B = true) {
4301 BlockDeclBits.CanAvoidCopyToHeap = B;
4302 }
4303
4304 bool capturesVariable(const VarDecl *var) const;
4305
4306 void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
4307 bool CapturesCXXThis);
4308
4309 unsigned getBlockManglingNumber() const { return ManglingNumber; }
4310
4311 Decl *getBlockManglingContextDecl() const { return ManglingContextDecl; }
4312
4313 void setBlockMangling(unsigned Number, Decl *Ctx) {
4314 ManglingNumber = Number;
4315 ManglingContextDecl = Ctx;
4316 }
4317
4318 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
4319
4320 // Implement isa/cast/dyncast/etc.
4321 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4322 static bool classofKind(Kind K) { return K == Block; }
4323 static DeclContext *castToDeclContext(const BlockDecl *D) {
4324 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
4325 }
4326 static BlockDecl *castFromDeclContext(const DeclContext *DC) {
4327 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
4328 }
4329};
4330
4331/// Represents the body of a CapturedStmt, and serves as its DeclContext.
4332class CapturedDecl final
4333 : public Decl,
4334 public DeclContext,
4335 private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4336protected:
4337 size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
4338 return NumParams;
4339 }
4340
4341private:
4342 /// The number of parameters to the outlined function.
4343 unsigned NumParams;
4344
4345 /// The position of context parameter in list of parameters.
4346 unsigned ContextParam;
4347
4348 /// The body of the outlined function.
4349 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4350
4351 explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
4352
4353 ImplicitParamDecl *const *getParams() const {
4354 return getTrailingObjects<ImplicitParamDecl *>();
4355 }
4356
4357 ImplicitParamDecl **getParams() {
4358 return getTrailingObjects<ImplicitParamDecl *>();
4359 }
4360
4361public:
4362 friend class ASTDeclReader;
4363 friend class ASTDeclWriter;
4364 friend TrailingObjects;
4365
4366 static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
4367 unsigned NumParams);
4368 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4369 unsigned NumParams);
4370
4371 Stmt *getBody() const override;
4372 void setBody(Stmt *B);
4373
4374 bool isNothrow() const;
4375 void setNothrow(bool Nothrow = true);
4376
4377 unsigned getNumParams() const { return NumParams; }
4378
4379 ImplicitParamDecl *getParam(unsigned i) const {
4380 assert(i < NumParams)((void)0);
4381 return getParams()[i];
4382 }
4383 void setParam(unsigned i, ImplicitParamDecl *P) {
4384 assert(i < NumParams)((void)0);
4385 getParams()[i] = P;
4386 }
4387
4388 // ArrayRef interface to parameters.
4389 ArrayRef<ImplicitParamDecl *> parameters() const {
4390 return {getParams(), getNumParams()};
4391 }
4392 MutableArrayRef<ImplicitParamDecl *> parameters() {
4393 return {getParams(), getNumParams()};
4394 }
4395
4396 /// Retrieve the parameter containing captured variables.
4397 ImplicitParamDecl *getContextParam() const {
4398 assert(ContextParam < NumParams)((void)0);
4399 return getParam(ContextParam);
4400 }
4401 void setContextParam(unsigned i, ImplicitParamDecl *P) {
4402 assert(i < NumParams)((void)0);
4403 ContextParam = i;
4404 setParam(i, P);
4405 }
4406 unsigned getContextParamPosition() const { return ContextParam; }
4407
4408 using param_iterator = ImplicitParamDecl *const *;
4409 using param_range = llvm::iterator_range<param_iterator>;
4410
4411 /// Retrieve an iterator pointing to the first parameter decl.
4412 param_iterator param_begin() const { return getParams(); }
4413 /// Retrieve an iterator one past the last parameter decl.
4414 param_iterator param_end() const { return getParams() + NumParams; }
4415
4416 // Implement isa/cast/dyncast/etc.
4417 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4418 static bool classofKind(Kind K) { return K == Captured; }
4419 static DeclContext *castToDeclContext(const CapturedDecl *D) {
4420 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
4421 }
4422 static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
4423 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
4424 }
4425};
4426
4427/// Describes a module import declaration, which makes the contents
4428/// of the named module visible in the current translation unit.
4429///
4430/// An import declaration imports the named module (or submodule). For example:
4431/// \code
4432/// @import std.vector;
4433/// \endcode
4434///
4435/// Import declarations can also be implicitly generated from
4436/// \#include/\#import directives.
4437class ImportDecl final : public Decl,
4438 llvm::TrailingObjects<ImportDecl, SourceLocation> {
4439 friend class ASTContext;
4440 friend class ASTDeclReader;
4441 friend class ASTReader;
4442 friend TrailingObjects;
4443
4444 /// The imported module.
4445 Module *ImportedModule = nullptr;
4446
4447 /// The next import in the list of imports local to the translation
4448 /// unit being parsed (not loaded from an AST file).
4449 ///
4450 /// Includes a bit that indicates whether we have source-location information
4451 /// for each identifier in the module name.
4452 ///
4453 /// When the bit is false, we only have a single source location for the
4454 /// end of the import declaration.
4455 llvm::PointerIntPair<ImportDecl *, 1, bool> NextLocalImportAndComplete;
4456
4457 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4458 ArrayRef<SourceLocation> IdentifierLocs);
4459
4460 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4461 SourceLocation EndLoc);
4462
4463 ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}
4464
4465 bool isImportComplete() const { return NextLocalImportAndComplete.getInt(); }
4466
4467 void setImportComplete(bool C) { NextLocalImportAndComplete.setInt(C); }
4468
4469 /// The next import in the list of imports local to the translation
4470 /// unit being parsed (not loaded from an AST file).
4471 ImportDecl *getNextLocalImport() const {
4472 return NextLocalImportAndComplete.getPointer();
4473 }
4474
4475 void setNextLocalImport(ImportDecl *Import) {
4476 NextLocalImportAndComplete.setPointer(Import);
4477 }
4478
4479public:
4480 /// Create a new module import declaration.
4481 static ImportDecl *Create(ASTContext &C, DeclContext *DC,
4482 SourceLocation StartLoc, Module *Imported,
4483 ArrayRef<SourceLocation> IdentifierLocs);
4484
4485 /// Create a new module import declaration for an implicitly-generated
4486 /// import.
4487 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
4488 SourceLocation StartLoc, Module *Imported,
4489 SourceLocation EndLoc);
4490
4491 /// Create a new, deserialized module import declaration.
4492 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4493 unsigned NumLocations);
4494
4495 /// Retrieve the module that was imported by the import declaration.
4496 Module *getImportedModule() const { return ImportedModule; }
4497
4498 /// Retrieves the locations of each of the identifiers that make up
4499 /// the complete module name in the import declaration.
4500 ///
4501 /// This will return an empty array if the locations of the individual
4502 /// identifiers aren't available.
4503 ArrayRef<SourceLocation> getIdentifierLocs() const;
4504
4505 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__));
4506
4507 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4508 static bool classofKind(Kind K) { return K == Import; }
4509};
4510
4511/// Represents a C++ Modules TS module export declaration.
4512///
4513/// For example:
4514/// \code
4515/// export void foo();
4516/// \endcode
4517class ExportDecl final : public Decl, public DeclContext {
4518 virtual void anchor();
4519
4520private:
4521 friend class ASTDeclReader;
4522
4523 /// The source location for the right brace (if valid).
4524 SourceLocation RBraceLoc;
4525
4526 ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
4527 : Decl(Export, DC, ExportLoc), DeclContext(Export),
4528 RBraceLoc(SourceLocation()) {}
4529
4530public:
4531 static ExportDecl *Create(ASTContext &C, DeclContext *DC,
4532 SourceLocation ExportLoc);
4533 static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4534
4535 SourceLocation getExportLoc() const { return getLocation(); }
4536 SourceLocation getRBraceLoc() const { return RBraceLoc; }
4537 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
4538
4539 bool hasBraces() const { return RBraceLoc.isValid(); }
4540
4541 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
4542 if (hasBraces())
4543 return RBraceLoc;
4544 // No braces: get the end location of the (only) declaration in context
4545 // (if present).
4546 return decls_empty() ? getLocation() : decls_begin()->getEndLoc();
4547 }
4548
4549 SourceRange getSourceRange() const override LLVM_READONLY__attribute__((__pure__)) {
4550 return SourceRange(getLocation(), getEndLoc());
4551 }
4552
4553 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4554 static bool classofKind(Kind K) { return K == Export; }
4555 static DeclContext *castToDeclContext(const ExportDecl *D) {
4556 return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
4557 }
4558 static ExportDecl *castFromDeclContext(const DeclContext *DC) {
4559 return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
4560 }
4561};
4562
4563/// Represents an empty-declaration.
4564class EmptyDecl : public Decl {
4565 EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
4566
4567 virtual void anchor();
4568
4569public:
4570 static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
4571 SourceLocation L);
4572 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4573
4574 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4575 static bool classofKind(Kind K) { return K == Empty; }
4576};
4577
4578/// Insertion operator for diagnostics. This allows sending NamedDecl's
4579/// into a diagnostic with <<.
4580inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
4581 const NamedDecl *ND) {
4582 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4583 DiagnosticsEngine::ak_nameddecl);
4584 return PD;
4585}
4586
4587template<typename decl_type>
4588void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
4589 // Note: This routine is implemented here because we need both NamedDecl
4590 // and Redeclarable to be defined.
4591 assert(RedeclLink.isFirst() &&((void)0)
4592 "setPreviousDecl on a decl already in a redeclaration chain")((void)0);
4593
4594 if (PrevDecl) {
4595 // Point to previous. Make sure that this is actually the most recent
4596 // redeclaration, or we can build invalid chains. If the most recent
4597 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
4598 First = PrevDecl->getFirstDecl();
4599 assert(First->RedeclLink.isFirst() && "Expected first")((void)0);
4600 decl_type *MostRecent = First->getNextRedeclaration();
4601 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
4602
4603 // If the declaration was previously visible, a redeclaration of it remains
4604 // visible even if it wouldn't be visible by itself.
4605 static_cast<decl_type*>(this)->IdentifierNamespace |=
4606 MostRecent->getIdentifierNamespace() &
4607 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
4608 } else {
4609 // Make this first.
4610 First = static_cast<decl_type*>(this);
4611 }
4612
4613 // First one will point to this one as latest.
4614 First->RedeclLink.setLatest(static_cast<decl_type*>(this));
4615
4616 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||((void)0)
4617 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid())((void)0);
4618}
4619
4620// Inline function definitions.
4621
4622/// Check if the given decl is complete.
4623///
4624/// We use this function to break a cycle between the inline definitions in
4625/// Type.h and Decl.h.
4626inline bool IsEnumDeclComplete(EnumDecl *ED) {
4627 return ED->isComplete();
4628}
4629
4630/// Check if the given decl is scoped.
4631///
4632/// We use this function to break a cycle between the inline definitions in
4633/// Type.h and Decl.h.
4634inline bool IsEnumDeclScoped(EnumDecl *ED) {
4635 return ED->isScoped();
4636}
4637
4638/// OpenMP variants are mangled early based on their OpenMP context selector.
4639/// The new name looks likes this:
4640/// <name> + OpenMPVariantManglingSeparatorStr + <mangled OpenMP context>
4641static constexpr StringRef getOpenMPVariantManglingSeparatorStr() {
4642 return "$ompvariant";
4643}
4644
4645} // namespace clang
4646
4647#endif // LLVM_CLANG_AST_DECL_H

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/DeclBase.h

1//===- DeclBase.h - Base Classes for representing declarations --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Decl and DeclContext interfaces.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_DECLBASE_H
14#define LLVM_CLANG_AST_DECLBASE_H
15
16#include "clang/AST/ASTDumperUtils.h"
17#include "clang/AST/AttrIterator.h"
18#include "clang/AST/DeclarationName.h"
19#include "clang/Basic/IdentifierTable.h"
20#include "clang/Basic/LLVM.h"
21#include "clang/Basic/SourceLocation.h"
22#include "clang/Basic/Specifiers.h"
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/PointerIntPair.h"
25#include "llvm/ADT/PointerUnion.h"
26#include "llvm/ADT/iterator.h"
27#include "llvm/ADT/iterator_range.h"
28#include "llvm/Support/Casting.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/PrettyStackTrace.h"
31#include "llvm/Support/VersionTuple.h"
32#include <algorithm>
33#include <cassert>
34#include <cstddef>
35#include <iterator>
36#include <string>
37#include <type_traits>
38#include <utility>
39
40namespace clang {
41
42class ASTContext;
43class ASTMutationListener;
44class Attr;
45class BlockDecl;
46class DeclContext;
47class ExternalSourceSymbolAttr;
48class FunctionDecl;
49class FunctionType;
50class IdentifierInfo;
51enum Linkage : unsigned char;
52class LinkageSpecDecl;
53class Module;
54class NamedDecl;
55class ObjCCategoryDecl;
56class ObjCCategoryImplDecl;
57class ObjCContainerDecl;
58class ObjCImplDecl;
59class ObjCImplementationDecl;
60class ObjCInterfaceDecl;
61class ObjCMethodDecl;
62class ObjCProtocolDecl;
63struct PrintingPolicy;
64class RecordDecl;
65class SourceManager;
66class Stmt;
67class StoredDeclsMap;
68class TemplateDecl;
69class TemplateParameterList;
70class TranslationUnitDecl;
71class UsingDirectiveDecl;
72
73/// Captures the result of checking the availability of a
74/// declaration.
75enum AvailabilityResult {
76 AR_Available = 0,
77 AR_NotYetIntroduced,
78 AR_Deprecated,
79 AR_Unavailable
80};
81
82/// Decl - This represents one declaration (or definition), e.g. a variable,
83/// typedef, function, struct, etc.
84///
85/// Note: There are objects tacked on before the *beginning* of Decl
86/// (and its subclasses) in its Decl::operator new(). Proper alignment
87/// of all subclasses (not requiring more than the alignment of Decl) is
88/// asserted in DeclBase.cpp.
89class alignas(8) Decl {
90public:
91 /// Lists the kind of concrete classes of Decl.
92 enum Kind {
93#define DECL(DERIVED, BASE) DERIVED,
94#define ABSTRACT_DECL(DECL)
95#define DECL_RANGE(BASE, START, END) \
96 first##BASE = START, last##BASE = END,
97#define LAST_DECL_RANGE(BASE, START, END) \
98 first##BASE = START, last##BASE = END
99#include "clang/AST/DeclNodes.inc"
100 };
101
102 /// A placeholder type used to construct an empty shell of a
103 /// decl-derived type that will be filled in later (e.g., by some
104 /// deserialization method).
105 struct EmptyShell {};
106
107 /// IdentifierNamespace - The different namespaces in which
108 /// declarations may appear. According to C99 6.2.3, there are
109 /// four namespaces, labels, tags, members and ordinary
110 /// identifiers. C++ describes lookup completely differently:
111 /// certain lookups merely "ignore" certain kinds of declarations,
112 /// usually based on whether the declaration is of a type, etc.
113 ///
114 /// These are meant as bitmasks, so that searches in
115 /// C++ can look into the "tag" namespace during ordinary lookup.
116 ///
117 /// Decl currently provides 15 bits of IDNS bits.
118 enum IdentifierNamespace {
119 /// Labels, declared with 'x:' and referenced with 'goto x'.
120 IDNS_Label = 0x0001,
121
122 /// Tags, declared with 'struct foo;' and referenced with
123 /// 'struct foo'. All tags are also types. This is what
124 /// elaborated-type-specifiers look for in C.
125 /// This also contains names that conflict with tags in the
126 /// same scope but that are otherwise ordinary names (non-type
127 /// template parameters and indirect field declarations).
128 IDNS_Tag = 0x0002,
129
130 /// Types, declared with 'struct foo', typedefs, etc.
131 /// This is what elaborated-type-specifiers look for in C++,
132 /// but note that it's ill-formed to find a non-tag.
133 IDNS_Type = 0x0004,
134
135 /// Members, declared with object declarations within tag
136 /// definitions. In C, these can only be found by "qualified"
137 /// lookup in member expressions. In C++, they're found by
138 /// normal lookup.
139 IDNS_Member = 0x0008,
140
141 /// Namespaces, declared with 'namespace foo {}'.
142 /// Lookup for nested-name-specifiers find these.
143 IDNS_Namespace = 0x0010,
144
145 /// Ordinary names. In C, everything that's not a label, tag,
146 /// member, or function-local extern ends up here.
147 IDNS_Ordinary = 0x0020,
148
149 /// Objective C \@protocol.
150 IDNS_ObjCProtocol = 0x0040,
151
152 /// This declaration is a friend function. A friend function
153 /// declaration is always in this namespace but may also be in
154 /// IDNS_Ordinary if it was previously declared.
155 IDNS_OrdinaryFriend = 0x0080,
156
157 /// This declaration is a friend class. A friend class
158 /// declaration is always in this namespace but may also be in
159 /// IDNS_Tag|IDNS_Type if it was previously declared.
160 IDNS_TagFriend = 0x0100,
161
162 /// This declaration is a using declaration. A using declaration
163 /// *introduces* a number of other declarations into the current
164 /// scope, and those declarations use the IDNS of their targets,
165 /// but the actual using declarations go in this namespace.
166 IDNS_Using = 0x0200,
167
168 /// This declaration is a C++ operator declared in a non-class
169 /// context. All such operators are also in IDNS_Ordinary.
170 /// C++ lexical operator lookup looks for these.
171 IDNS_NonMemberOperator = 0x0400,
172
173 /// This declaration is a function-local extern declaration of a
174 /// variable or function. This may also be IDNS_Ordinary if it
175 /// has been declared outside any function. These act mostly like
176 /// invisible friend declarations, but are also visible to unqualified
177 /// lookup within the scope of the declaring function.
178 IDNS_LocalExtern = 0x0800,
179
180 /// This declaration is an OpenMP user defined reduction construction.
181 IDNS_OMPReduction = 0x1000,
182
183 /// This declaration is an OpenMP user defined mapper.
184 IDNS_OMPMapper = 0x2000,
185 };
186
187 /// ObjCDeclQualifier - 'Qualifiers' written next to the return and
188 /// parameter types in method declarations. Other than remembering
189 /// them and mangling them into the method's signature string, these
190 /// are ignored by the compiler; they are consumed by certain
191 /// remote-messaging frameworks.
192 ///
193 /// in, inout, and out are mutually exclusive and apply only to
194 /// method parameters. bycopy and byref are mutually exclusive and
195 /// apply only to method parameters (?). oneway applies only to
196 /// results. All of these expect their corresponding parameter to
197 /// have a particular type. None of this is currently enforced by
198 /// clang.
199 ///
200 /// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
201 enum ObjCDeclQualifier {
202 OBJC_TQ_None = 0x0,
203 OBJC_TQ_In = 0x1,
204 OBJC_TQ_Inout = 0x2,
205 OBJC_TQ_Out = 0x4,
206 OBJC_TQ_Bycopy = 0x8,
207 OBJC_TQ_Byref = 0x10,
208 OBJC_TQ_Oneway = 0x20,
209
210 /// The nullability qualifier is set when the nullability of the
211 /// result or parameter was expressed via a context-sensitive
212 /// keyword.
213 OBJC_TQ_CSNullability = 0x40
214 };
215
216 /// The kind of ownership a declaration has, for visibility purposes.
217 /// This enumeration is designed such that higher values represent higher
218 /// levels of name hiding.
219 enum class ModuleOwnershipKind : unsigned {
220 /// This declaration is not owned by a module.
221 Unowned,
222
223 /// This declaration has an owning module, but is globally visible
224 /// (typically because its owning module is visible and we know that
225 /// modules cannot later become hidden in this compilation).
226 /// After serialization and deserialization, this will be converted
227 /// to VisibleWhenImported.
228 Visible,
229
230 /// This declaration has an owning module, and is visible when that
231 /// module is imported.
232 VisibleWhenImported,
233
234 /// This declaration has an owning module, but is only visible to
235 /// lookups that occur within that module.
236 ModulePrivate
237 };
238
239protected:
240 /// The next declaration within the same lexical
241 /// DeclContext. These pointers form the linked list that is
242 /// traversed via DeclContext's decls_begin()/decls_end().
243 ///
244 /// The extra two bits are used for the ModuleOwnershipKind.
245 llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;
246
247private:
248 friend class DeclContext;
249
250 struct MultipleDC {
251 DeclContext *SemanticDC;
252 DeclContext *LexicalDC;
253 };
254
255 /// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
256 /// For declarations that don't contain C++ scope specifiers, it contains
257 /// the DeclContext where the Decl was declared.
258 /// For declarations with C++ scope specifiers, it contains a MultipleDC*
259 /// with the context where it semantically belongs (SemanticDC) and the
260 /// context where it was lexically declared (LexicalDC).
261 /// e.g.:
262 ///
263 /// namespace A {
264 /// void f(); // SemanticDC == LexicalDC == 'namespace A'
265 /// }
266 /// void A::f(); // SemanticDC == namespace 'A'
267 /// // LexicalDC == global namespace
268 llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;
269
270 bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
271 bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }
272
273 MultipleDC *getMultipleDC() const {
274 return DeclCtx.get<MultipleDC*>();
275 }
276
277 DeclContext *getSemanticDC() const {
278 return DeclCtx.get<DeclContext*>();
279 }
280
281 /// Loc - The location of this decl.
282 SourceLocation Loc;
283
284 /// DeclKind - This indicates which class this is.
285 unsigned DeclKind : 7;
286
287 /// InvalidDecl - This indicates a semantic error occurred.
288 unsigned InvalidDecl : 1;
289
290 /// HasAttrs - This indicates whether the decl has attributes or not.
291 unsigned HasAttrs : 1;
292
293 /// Implicit - Whether this declaration was implicitly generated by
294 /// the implementation rather than explicitly written by the user.
295 unsigned Implicit : 1;
296
297 /// Whether this declaration was "used", meaning that a definition is
298 /// required.
299 unsigned Used : 1;
300
301 /// Whether this declaration was "referenced".
302 /// The difference with 'Used' is whether the reference appears in a
303 /// evaluated context or not, e.g. functions used in uninstantiated templates
304 /// are regarded as "referenced" but not "used".
305 unsigned Referenced : 1;
306
307 /// Whether this declaration is a top-level declaration (function,
308 /// global variable, etc.) that is lexically inside an objc container
309 /// definition.
310 unsigned TopLevelDeclInObjCContainer : 1;
311
312 /// Whether statistic collection is enabled.
313 static bool StatisticsEnabled;
314
315protected:
316 friend class ASTDeclReader;
317 friend class ASTDeclWriter;
318 friend class ASTNodeImporter;
319 friend class ASTReader;
320 friend class CXXClassMemberWrapper;
321 friend class LinkageComputer;
322 template<typename decl_type> friend class Redeclarable;
323
324 /// Access - Used by C++ decls for the access specifier.
325 // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
326 unsigned Access : 2;
327
328 /// Whether this declaration was loaded from an AST file.
329 unsigned FromASTFile : 1;
330
331 /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
332 unsigned IdentifierNamespace : 14;
333
334 /// If 0, we have not computed the linkage of this declaration.
335 /// Otherwise, it is the linkage + 1.
336 mutable unsigned CacheValidAndLinkage : 3;
337
338 /// Allocate memory for a deserialized declaration.
339 ///
340 /// This routine must be used to allocate memory for any declaration that is
341 /// deserialized from a module file.
342 ///
343 /// \param Size The size of the allocated object.
344 /// \param Ctx The context in which we will allocate memory.
345 /// \param ID The global ID of the deserialized declaration.
346 /// \param Extra The amount of extra space to allocate after the object.
347 void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
348 std::size_t Extra = 0);
349
350 /// Allocate memory for a non-deserialized declaration.
351 void *operator new(std::size_t Size, const ASTContext &Ctx,
352 DeclContext *Parent, std::size_t Extra = 0);
353
354private:
355 bool AccessDeclContextSanity() const;
356
357 /// Get the module ownership kind to use for a local lexical child of \p DC,
358 /// which may be either a local or (rarely) an imported declaration.
359 static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
360 if (DC) {
361 auto *D = cast<Decl>(DC);
362 auto MOK = D->getModuleOwnershipKind();
363 if (MOK != ModuleOwnershipKind::Unowned &&
364 (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))
365 return MOK;
366 // If D is not local and we have no local module storage, then we don't
367 // need to track module ownership at all.
368 }
369 return ModuleOwnershipKind::Unowned;
370 }
371
372public:
373 Decl() = delete;
374 Decl(const Decl&) = delete;
375 Decl(Decl &&) = delete;
376 Decl &operator=(const Decl&) = delete;
377 Decl &operator=(Decl&&) = delete;
378
379protected:
380 Decl(Kind DK, DeclContext *DC, SourceLocation L)
381 : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
382 DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
383 Implicit(false), Used(false), Referenced(false),
384 TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
385 IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
386 CacheValidAndLinkage(0) {
387 if (StatisticsEnabled) add(DK);
388 }
389
390 Decl(Kind DK, EmptyShell Empty)
391 : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
392 Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
393 Access(AS_none), FromASTFile(0),
394 IdentifierNamespace(getIdentifierNamespaceForKind(DK)),
395 CacheValidAndLinkage(0) {
396 if (StatisticsEnabled) add(DK);
397 }
398
399 virtual ~Decl();
400
401 /// Update a potentially out-of-date declaration.
402 void updateOutOfDate(IdentifierInfo &II) const;
403
404 Linkage getCachedLinkage() const {
405 return Linkage(CacheValidAndLinkage - 1);
406 }
407
408 void setCachedLinkage(Linkage L) const {
409 CacheValidAndLinkage = L + 1;
410 }
411
412 bool hasCachedLinkage() const {
413 return CacheValidAndLinkage;
414 }
415
416public:
417 /// Source range that this declaration covers.
418 virtual SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
419 return SourceRange(getLocation(), getLocation());
420 }
421
422 SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
423 return getSourceRange().getBegin();
424 }
425
426 SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
427 return getSourceRange().getEnd();
428 }
429
430 SourceLocation getLocation() const { return Loc; }
431 void setLocation(SourceLocation L) { Loc = L; }
432
433 Kind getKind() const { return static_cast<Kind>(DeclKind); }
434 const char *getDeclKindName() const;
435
436 Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
437 const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}
438
439 DeclContext *getDeclContext() {
440 if (isInSemaDC())
441 return getSemanticDC();
442 return getMultipleDC()->SemanticDC;
443 }
444 const DeclContext *getDeclContext() const {
445 return const_cast<Decl*>(this)->getDeclContext();
446 }
447
448 /// Find the innermost non-closure ancestor of this declaration,
449 /// walking up through blocks, lambdas, etc. If that ancestor is
450 /// not a code context (!isFunctionOrMethod()), returns null.
451 ///
452 /// A declaration may be its own non-closure context.
453 Decl *getNonClosureContext();
454 const Decl *getNonClosureContext() const {
455 return const_cast<Decl*>(this)->getNonClosureContext();
456 }
457
458 TranslationUnitDecl *getTranslationUnitDecl();
459 const TranslationUnitDecl *getTranslationUnitDecl() const {
460 return const_cast<Decl*>(this)->getTranslationUnitDecl();
461 }
462
463 bool isInAnonymousNamespace() const;
464
465 bool isInStdNamespace() const;
466
467 ASTContext &getASTContext() const LLVM_READONLY__attribute__((__pure__));
468
469 /// Helper to get the language options from the ASTContext.
470 /// Defined out of line to avoid depending on ASTContext.h.
471 const LangOptions &getLangOpts() const LLVM_READONLY__attribute__((__pure__));
472
473 void setAccess(AccessSpecifier AS) {
474 Access = AS;
475 assert(AccessDeclContextSanity())((void)0);
476 }
477
478 AccessSpecifier getAccess() const {
479 assert(AccessDeclContextSanity())((void)0);
480 return AccessSpecifier(Access);
481 }
482
483 /// Retrieve the access specifier for this declaration, even though
484 /// it may not yet have been properly set.
485 AccessSpecifier getAccessUnsafe() const {
486 return AccessSpecifier(Access);
487 }
488
489 bool hasAttrs() const { return HasAttrs; }
490
491 void setAttrs(const AttrVec& Attrs) {
492 return setAttrsImpl(Attrs, getASTContext());
493 }
494
495 AttrVec &getAttrs() {
496 return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
497 }
498
499 const AttrVec &getAttrs() const;
500 void dropAttrs();
501 void addAttr(Attr *A);
502
503 using attr_iterator = AttrVec::const_iterator;
504 using attr_range = llvm::iterator_range<attr_iterator>;
505
506 attr_range attrs() const {
507 return attr_range(attr_begin(), attr_end());
508 }
509
510 attr_iterator attr_begin() const {
511 return hasAttrs() ? getAttrs().begin() : nullptr;
512 }
513 attr_iterator attr_end() const {
514 return hasAttrs() ? getAttrs().end() : nullptr;
515 }
516
517 template <typename T>
518 void dropAttr() {
519 if (!HasAttrs) return;
520
521 AttrVec &Vec = getAttrs();
522 llvm::erase_if(Vec, [](Attr *A) { return isa<T>(A); });
523
524 if (Vec.empty())
525 HasAttrs = false;
526 }
527
528 template <typename T>
529 llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
530 return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
531 }
532
533 template <typename T>
534 specific_attr_iterator<T> specific_attr_begin() const {
535 return specific_attr_iterator<T>(attr_begin());
536 }
537
538 template <typename T>
539 specific_attr_iterator<T> specific_attr_end() const {
540 return specific_attr_iterator<T>(attr_end());
541 }
542
543 template<typename T> T *getAttr() const {
544 return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
545 }
546
547 template<typename T> bool hasAttr() const {
548 return hasAttrs() && hasSpecificAttr<T>(getAttrs());
549 }
550
551 /// getMaxAlignment - return the maximum alignment specified by attributes
552 /// on this decl, 0 if there are none.
553 unsigned getMaxAlignment() const;
554
555 /// setInvalidDecl - Indicates the Decl had a semantic error. This
556 /// allows for graceful error recovery.
557 void setInvalidDecl(bool Invalid = true);
558 bool isInvalidDecl() const { return (bool) InvalidDecl; }
559
560 /// isImplicit - Indicates whether the declaration was implicitly
561 /// generated by the implementation. If false, this declaration
562 /// was written explicitly in the source code.
563 bool isImplicit() const { return Implicit; }
564 void setImplicit(bool I = true) { Implicit = I; }
565
566 /// Whether *any* (re-)declaration of the entity was used, meaning that
567 /// a definition is required.
568 ///
569 /// \param CheckUsedAttr When true, also consider the "used" attribute
570 /// (in addition to the "used" bit set by \c setUsed()) when determining
571 /// whether the function is used.
572 bool isUsed(bool CheckUsedAttr = true) const;
573
574 /// Set whether the declaration is used, in the sense of odr-use.
575 ///
576 /// This should only be used immediately after creating a declaration.
577 /// It intentionally doesn't notify any listeners.
578 void setIsUsed() { getCanonicalDecl()->Used = true; }
579
580 /// Mark the declaration used, in the sense of odr-use.
581 ///
582 /// This notifies any mutation listeners in addition to setting a bit
583 /// indicating the declaration is used.
584 void markUsed(ASTContext &C);
585
586 /// Whether any declaration of this entity was referenced.
587 bool isReferenced() const;
588
589 /// Whether this declaration was referenced. This should not be relied
590 /// upon for anything other than debugging.
591 bool isThisDeclarationReferenced() const { return Referenced; }
592
593 void setReferenced(bool R = true) { Referenced = R; }
594
595 /// Whether this declaration is a top-level declaration (function,
596 /// global variable, etc.) that is lexically inside an objc container
597 /// definition.
598 bool isTopLevelDeclInObjCContainer() const {
599 return TopLevelDeclInObjCContainer;
600 }
601
602 void setTopLevelDeclInObjCContainer(bool V = true) {
603 TopLevelDeclInObjCContainer = V;
604 }
605
606 /// Looks on this and related declarations for an applicable
607 /// external source symbol attribute.
608 ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;
609
610 /// Whether this declaration was marked as being private to the
611 /// module in which it was defined.
612 bool isModulePrivate() const {
613 return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate;
614 }
615
616 /// Return true if this declaration has an attribute which acts as
617 /// definition of the entity, such as 'alias' or 'ifunc'.
618 bool hasDefiningAttr() const;
619
620 /// Return this declaration's defining attribute if it has one.
621 const Attr *getDefiningAttr() const;
622
623protected:
624 /// Specify that this declaration was marked as being private
625 /// to the module in which it was defined.
626 void setModulePrivate() {
627 // The module-private specifier has no effect on unowned declarations.
628 // FIXME: We should track this in some way for source fidelity.
629 if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned)
630 return;
631 setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate);
632 }
633
634public:
635 /// Set the FromASTFile flag. This indicates that this declaration
636 /// was deserialized and not parsed from source code and enables
637 /// features such as module ownership information.
638 void setFromASTFile() {
639 FromASTFile = true;
640 }
641
642 /// Set the owning module ID. This may only be called for
643 /// deserialized Decls.
644 void setOwningModuleID(unsigned ID) {
645 assert(isFromASTFile() && "Only works on a deserialized declaration")((void)0);
646 *((unsigned*)this - 2) = ID;
647 }
648
649public:
650 /// Determine the availability of the given declaration.
651 ///
652 /// This routine will determine the most restrictive availability of
653 /// the given declaration (e.g., preferring 'unavailable' to
654 /// 'deprecated').
655 ///
656 /// \param Message If non-NULL and the result is not \c
657 /// AR_Available, will be set to a (possibly empty) message
658 /// describing why the declaration has not been introduced, is
659 /// deprecated, or is unavailable.
660 ///
661 /// \param EnclosingVersion The version to compare with. If empty, assume the
662 /// deployment target version.
663 ///
664 /// \param RealizedPlatform If non-NULL and the availability result is found
665 /// in an available attribute it will set to the platform which is written in
666 /// the available attribute.
667 AvailabilityResult
668 getAvailability(std::string *Message = nullptr,
669 VersionTuple EnclosingVersion = VersionTuple(),
670 StringRef *RealizedPlatform = nullptr) const;
671
672 /// Retrieve the version of the target platform in which this
673 /// declaration was introduced.
674 ///
675 /// \returns An empty version tuple if this declaration has no 'introduced'
676 /// availability attributes, or the version tuple that's specified in the
677 /// attribute otherwise.
678 VersionTuple getVersionIntroduced() const;
679
680 /// Determine whether this declaration is marked 'deprecated'.
681 ///
682 /// \param Message If non-NULL and the declaration is deprecated,
683 /// this will be set to the message describing why the declaration
684 /// was deprecated (which may be empty).
685 bool isDeprecated(std::string *Message = nullptr) const {
686 return getAvailability(Message) == AR_Deprecated;
687 }
688
689 /// Determine whether this declaration is marked 'unavailable'.
690 ///
691 /// \param Message If non-NULL and the declaration is unavailable,
692 /// this will be set to the message describing why the declaration
693 /// was made unavailable (which may be empty).
694 bool isUnavailable(std::string *Message = nullptr) const {
695 return getAvailability(Message) == AR_Unavailable;
696 }
697
698 /// Determine whether this is a weak-imported symbol.
699 ///
700 /// Weak-imported symbols are typically marked with the
701 /// 'weak_import' attribute, but may also be marked with an
702 /// 'availability' attribute where we're targing a platform prior to
703 /// the introduction of this feature.
704 bool isWeakImported() const;
705
706 /// Determines whether this symbol can be weak-imported,
707 /// e.g., whether it would be well-formed to add the weak_import
708 /// attribute.
709 ///
710 /// \param IsDefinition Set to \c true to indicate that this
711 /// declaration cannot be weak-imported because it has a definition.
712 bool canBeWeakImported(bool &IsDefinition) const;
713
714 /// Determine whether this declaration came from an AST file (such as
715 /// a precompiled header or module) rather than having been parsed.
716 bool isFromASTFile() const { return FromASTFile; }
717
718 /// Retrieve the global declaration ID associated with this
719 /// declaration, which specifies where this Decl was loaded from.
720 unsigned getGlobalID() const {
721 if (isFromASTFile())
722 return *((const unsigned*)this - 1);
723 return 0;
724 }
725
726 /// Retrieve the global ID of the module that owns this particular
727 /// declaration.
728 unsigned getOwningModuleID() const {
729 if (isFromASTFile())
730 return *((const unsigned*)this - 2);
731 return 0;
732 }
733
734private:
735 Module *getOwningModuleSlow() const;
736
737protected:
738 bool hasLocalOwningModuleStorage() const;
739
740public:
741 /// Get the imported owning module, if this decl is from an imported
742 /// (non-local) module.
743 Module *getImportedOwningModule() const {
744 if (!isFromASTFile() || !hasOwningModule())
745 return nullptr;
746
747 return getOwningModuleSlow();
748 }
749
750 /// Get the local owning module, if known. Returns nullptr if owner is
751 /// not yet known or declaration is not from a module.
752 Module *getLocalOwningModule() const {
753 if (isFromASTFile() || !hasOwningModule())
754 return nullptr;
755
756 assert(hasLocalOwningModuleStorage() &&((void)0)
757 "owned local decl but no local module storage")((void)0);
758 return reinterpret_cast<Module *const *>(this)[-1];
759 }
760 void setLocalOwningModule(Module *M) {
761 assert(!isFromASTFile() && hasOwningModule() &&((void)0)
762 hasLocalOwningModuleStorage() &&((void)0)
763 "should not have a cached owning module")((void)0);
764 reinterpret_cast<Module **>(this)[-1] = M;
765 }
766
767 /// Is this declaration owned by some module?
768 bool hasOwningModule() const {
769 return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned;
770 }
771
772 /// Get the module that owns this declaration (for visibility purposes).
773 Module *getOwningModule() const {
774 return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule();
775 }
776
777 /// Get the module that owns this declaration for linkage purposes.
778 /// There only ever is such a module under the C++ Modules TS.
779 ///
780 /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
781 /// all declarations in a global module fragment are unowned.
782 Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
783
784 /// Determine whether this declaration is definitely visible to name lookup,
785 /// independent of whether the owning module is visible.
786 /// Note: The declaration may be visible even if this returns \c false if the
787 /// owning module is visible within the query context. This is a low-level
788 /// helper function; most code should be calling Sema::isVisible() instead.
789 bool isUnconditionallyVisible() const {
790 return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
791 }
792
793 /// Set that this declaration is globally visible, even if it came from a
794 /// module that is not visible.
795 void setVisibleDespiteOwningModule() {
796 if (!isUnconditionallyVisible())
797 setModuleOwnershipKind(ModuleOwnershipKind::Visible);
798 }
799
800 /// Get the kind of module ownership for this declaration.
801 ModuleOwnershipKind getModuleOwnershipKind() const {
802 return NextInContextAndBits.getInt();
803 }
804
805 /// Set whether this declaration is hidden from name lookup.
806 void setModuleOwnershipKind(ModuleOwnershipKind MOK) {
807 assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned &&((void)0)
808 MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() &&((void)0)
809 !hasLocalOwningModuleStorage()) &&((void)0)
810 "no storage available for owning module for this declaration")((void)0);
811 NextInContextAndBits.setInt(MOK);
812 }
813
814 unsigned getIdentifierNamespace() const {
815 return IdentifierNamespace;
816 }
817
818 bool isInIdentifierNamespace(unsigned NS) const {
819 return getIdentifierNamespace() & NS;
820 }
821
822 static unsigned getIdentifierNamespaceForKind(Kind DK);
823
824 bool hasTagIdentifierNamespace() const {
825 return isTagIdentifierNamespace(getIdentifierNamespace());
826 }
827
828 static bool isTagIdentifierNamespace(unsigned NS) {
829 // TagDecls have Tag and Type set and may also have TagFriend.
830 return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
831 }
832
833 /// getLexicalDeclContext - The declaration context where this Decl was
834 /// lexically declared (LexicalDC). May be different from
835 /// getDeclContext() (SemanticDC).
836 /// e.g.:
837 ///
838 /// namespace A {
839 /// void f(); // SemanticDC == LexicalDC == 'namespace A'
840 /// }
841 /// void A::f(); // SemanticDC == namespace 'A'
842 /// // LexicalDC == global namespace
843 DeclContext *getLexicalDeclContext() {
844 if (isInSemaDC())
845 return getSemanticDC();
846 return getMultipleDC()->LexicalDC;
847 }
848 const DeclContext *getLexicalDeclContext() const {
849 return const_cast<Decl*>(this)->getLexicalDeclContext();
850 }
851
852 /// Determine whether this declaration is declared out of line (outside its
853 /// semantic context).
854 virtual bool isOutOfLine() const;
855
856 /// setDeclContext - Set both the semantic and lexical DeclContext
857 /// to DC.
858 void setDeclContext(DeclContext *DC);
859
860 void setLexicalDeclContext(DeclContext *DC);
861
862 /// Determine whether this declaration is a templated entity (whether it is
863 // within the scope of a template parameter).
864 bool isTemplated() const;
865
866 /// Determine the number of levels of template parameter surrounding this
867 /// declaration.
868 unsigned getTemplateDepth() const;
869
870 /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
871 /// scoped decl is defined outside the current function or method. This is
872 /// roughly global variables and functions, but also handles enums (which
873 /// could be defined inside or outside a function etc).
874 bool isDefinedOutsideFunctionOrMethod() const {
875 return getParentFunctionOrMethod() == nullptr;
876 }
877
878 /// Determine whether a substitution into this declaration would occur as
879 /// part of a substitution into a dependent local scope. Such a substitution
880 /// transitively substitutes into all constructs nested within this
881 /// declaration.
882 ///
883 /// This recognizes non-defining declarations as well as members of local
884 /// classes and lambdas:
885 /// \code
886 /// template<typename T> void foo() { void bar(); }
887 /// template<typename T> void foo2() { class ABC { void bar(); }; }
888 /// template<typename T> inline int x = [](){ return 0; }();
889 /// \endcode
890 bool isInLocalScopeForInstantiation() const;
891
892 /// If this decl is defined inside a function/method/block it returns
893 /// the corresponding DeclContext, otherwise it returns null.
894 const DeclContext *getParentFunctionOrMethod() const;
895 DeclContext *getParentFunctionOrMethod() {
896 return const_cast<DeclContext*>(
897 const_cast<const Decl*>(this)->getParentFunctionOrMethod());
898 }
899
900 /// Retrieves the "canonical" declaration of the given declaration.
901 virtual Decl *getCanonicalDecl() { return this; }
902 const Decl *getCanonicalDecl() const {
903 return const_cast<Decl*>(this)->getCanonicalDecl();
904 }
905
906 /// Whether this particular Decl is a canonical one.
907 bool isCanonicalDecl() const { return getCanonicalDecl() == this; }
908
909protected:
910 /// Returns the next redeclaration or itself if this is the only decl.
911 ///
912 /// Decl subclasses that can be redeclared should override this method so that
913 /// Decl::redecl_iterator can iterate over them.
914 virtual Decl *getNextRedeclarationImpl() { return this; }
915
916 /// Implementation of getPreviousDecl(), to be overridden by any
917 /// subclass that has a redeclaration chain.
918 virtual Decl *getPreviousDeclImpl() { return nullptr; }
919
920 /// Implementation of getMostRecentDecl(), to be overridden by any
921 /// subclass that has a redeclaration chain.
922 virtual Decl *getMostRecentDeclImpl() { return this; }
923
924public:
925 /// Iterates through all the redeclarations of the same decl.
926 class redecl_iterator {
927 /// Current - The current declaration.
928 Decl *Current = nullptr;
929 Decl *Starter;
930
931 public:
932 using value_type = Decl *;
933 using reference = const value_type &;
934 using pointer = const value_type *;
935 using iterator_category = std::forward_iterator_tag;
936 using difference_type = std::ptrdiff_t;
937
938 redecl_iterator() = default;
939 explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}
940
941 reference operator*() const { return Current; }
942 value_type operator->() const { return Current; }
943
944 redecl_iterator& operator++() {
945 assert(Current && "Advancing while iterator has reached end")((void)0);
946 // Get either previous decl or latest decl.
947 Decl *Next = Current->getNextRedeclarationImpl();
948 assert(Next && "Should return next redeclaration or itself, never null!")((void)0);
949 Current = (Next != Starter) ? Next : nullptr;
950 return *this;
951 }
952
953 redecl_iterator operator++(int) {
954 redecl_iterator tmp(*this);
955 ++(*this);
956 return tmp;
957 }
958
959 friend bool operator==(redecl_iterator x, redecl_iterator y) {
960 return x.Current == y.Current;
961 }
962
963 friend bool operator!=(redecl_iterator x, redecl_iterator y) {
964 return x.Current != y.Current;
965 }
966 };
967
968 using redecl_range = llvm::iterator_range<redecl_iterator>;
969
970 /// Returns an iterator range for all the redeclarations of the same
971 /// decl. It will iterate at least once (when this decl is the only one).
972 redecl_range redecls() const {
973 return redecl_range(redecls_begin(), redecls_end());
974 }
975
976 redecl_iterator redecls_begin() const {
977 return redecl_iterator(const_cast<Decl *>(this));
978 }
979
980 redecl_iterator redecls_end() const { return redecl_iterator(); }
981
982 /// Retrieve the previous declaration that declares the same entity
983 /// as this declaration, or NULL if there is no previous declaration.
984 Decl *getPreviousDecl() { return getPreviousDeclImpl(); }
985
986 /// Retrieve the previous declaration that declares the same entity
987 /// as this declaration, or NULL if there is no previous declaration.
988 const Decl *getPreviousDecl() const {
989 return const_cast<Decl *>(this)->getPreviousDeclImpl();
990 }
991
992 /// True if this is the first declaration in its redeclaration chain.
993 bool isFirstDecl() const {
994 return getPreviousDecl() == nullptr;
995 }
996
997 /// Retrieve the most recent declaration that declares the same entity
998 /// as this declaration (which may be this declaration).
999 Decl *getMostRecentDecl() { return getMostRecentDeclImpl(); }
1000
1001 /// Retrieve the most recent declaration that declares the same entity
1002 /// as this declaration (which may be this declaration).
1003 const Decl *getMostRecentDecl() const {
1004 return const_cast<Decl *>(this)->getMostRecentDeclImpl();
1005 }
1006
1007 /// getBody - If this Decl represents a declaration for a body of code,
1008 /// such as a function or method definition, this method returns the
1009 /// top-level Stmt* of that body. Otherwise this method returns null.
1010 virtual Stmt* getBody() const { return nullptr; }
1011
1012 /// Returns true if this \c Decl represents a declaration for a body of
1013 /// code, such as a function or method definition.
1014 /// Note that \c hasBody can also return true if any redeclaration of this
1015 /// \c Decl represents a declaration for a body of code.
1016 virtual bool hasBody() const { return getBody() != nullptr; }
1017
1018 /// getBodyRBrace - Gets the right brace of the body, if a body exists.
1019 /// This works whether the body is a CompoundStmt or a CXXTryStmt.
1020 SourceLocation getBodyRBrace() const;
1021
1022 // global temp stats (until we have a per-module visitor)
1023 static void add(Kind k);
1024 static void EnableStatistics();
1025 static void PrintStats();
1026
1027 /// isTemplateParameter - Determines whether this declaration is a
1028 /// template parameter.
1029 bool isTemplateParameter() const;
1030
1031 /// isTemplateParameter - Determines whether this declaration is a
1032 /// template parameter pack.
1033 bool isTemplateParameterPack() const;
1034
1035 /// Whether this declaration is a parameter pack.
1036 bool isParameterPack() const;
1037
1038 /// returns true if this declaration is a template
1039 bool isTemplateDecl() const;
1040
1041 /// Whether this declaration is a function or function template.
1042 bool isFunctionOrFunctionTemplate() const {
1043 return (DeclKind >= Decl::firstFunction &&
1044 DeclKind <= Decl::lastFunction) ||
1045 DeclKind == FunctionTemplate;
1046 }
1047
1048 /// If this is a declaration that describes some template, this
1049 /// method returns that template declaration.
1050 ///
1051 /// Note that this returns nullptr for partial specializations, because they
1052 /// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle
1053 /// those cases.
1054 TemplateDecl *getDescribedTemplate() const;
1055
1056 /// If this is a declaration that describes some template or partial
1057 /// specialization, this returns the corresponding template parameter list.
1058 const TemplateParameterList *getDescribedTemplateParams() const;
1059
1060 /// Returns the function itself, or the templated function if this is a
1061 /// function template.
1062 FunctionDecl *getAsFunction() LLVM_READONLY__attribute__((__pure__));
1063
1064 const FunctionDecl *getAsFunction() const {
1065 return const_cast<Decl *>(this)->getAsFunction();
1066 }
1067
1068 /// Changes the namespace of this declaration to reflect that it's
1069 /// a function-local extern declaration.
1070 ///
1071 /// These declarations appear in the lexical context of the extern
1072 /// declaration, but in the semantic context of the enclosing namespace
1073 /// scope.
1074 void setLocalExternDecl() {
1075 Decl *Prev = getPreviousDecl();
1076 IdentifierNamespace &= ~IDNS_Ordinary;
1077
1078 // It's OK for the declaration to still have the "invisible friend" flag or
1079 // the "conflicts with tag declarations in this scope" flag for the outer
1080 // scope.
1081 assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&((void)0)
1082 "namespace is not ordinary")((void)0);
1083
1084 IdentifierNamespace |= IDNS_LocalExtern;
1085 if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
1086 IdentifierNamespace |= IDNS_Ordinary;
1087 }
1088
1089 /// Determine whether this is a block-scope declaration with linkage.
1090 /// This will either be a local variable declaration declared 'extern', or a
1091 /// local function declaration.
1092 bool isLocalExternDecl() {
1093 return IdentifierNamespace & IDNS_LocalExtern;
1094 }
1095
1096 /// Changes the namespace of this declaration to reflect that it's
1097 /// the object of a friend declaration.
1098 ///
1099 /// These declarations appear in the lexical context of the friending
1100 /// class, but in the semantic context of the actual entity. This property
1101 /// applies only to a specific decl object; other redeclarations of the
1102 /// same entity may not (and probably don't) share this property.
1103 void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
1104 unsigned OldNS = IdentifierNamespace;
1105 assert((OldNS & (IDNS_Tag | IDNS_Ordinary |((void)0)
1106 IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
1107 IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
1108 "namespace includes neither ordinary nor tag")((void)0);
1109 assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |((void)0)
1110 IDNS_TagFriend | IDNS_OrdinaryFriend |((void)0)
1111 IDNS_LocalExtern | IDNS_NonMemberOperator)) &&((void)0)
1112 "namespace includes other than ordinary or tag")((void)0);
1113
1114 Decl *Prev = getPreviousDecl();
1115 IdentifierNamespace &= ~(IDNS_Ordinary | IDNS_Tag | IDNS_Type);
1116
1117 if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
1118 IdentifierNamespace |= IDNS_TagFriend;
1119 if (PerformFriendInjection ||
1120 (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
1121 IdentifierNamespace |= IDNS_Tag | IDNS_Type;
1122 }
1123
1124 if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend |
1125 IDNS_LocalExtern | IDNS_NonMemberOperator)) {
1126 IdentifierNamespace |= IDNS_OrdinaryFriend;
1127 if (PerformFriendInjection ||
1128 (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
1129 IdentifierNamespace |= IDNS_Ordinary;
1130 }
1131 }
1132
1133 enum FriendObjectKind {
1134 FOK_None, ///< Not a friend object.
1135 FOK_Declared, ///< A friend of a previously-declared entity.
1136 FOK_Undeclared ///< A friend of a previously-undeclared entity.
1137 };
1138
1139 /// Determines whether this declaration is the object of a
1140 /// friend declaration and, if so, what kind.
1141 ///
1142 /// There is currently no direct way to find the associated FriendDecl.
1143 FriendObjectKind getFriendObjectKind() const {
1144 unsigned mask =
1145 (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend));
1146 if (!mask) return FOK_None;
1147 return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? FOK_Declared
1148 : FOK_Undeclared);
1149 }
1150
1151 /// Specifies that this declaration is a C++ overloaded non-member.
1152 void setNonMemberOperator() {
1153 assert(getKind() == Function || getKind() == FunctionTemplate)((void)0);
1154 assert((IdentifierNamespace & IDNS_Ordinary) &&((void)0)
1155 "visible non-member operators should be in ordinary namespace")((void)0);
1156 IdentifierNamespace |= IDNS_NonMemberOperator;
1157 }
1158
1159 static bool classofKind(Kind K) { return true; }
1160 static DeclContext *castToDeclContext(const Decl *);
1161 static Decl *castFromDeclContext(const DeclContext *);
1162
1163 void print(raw_ostream &Out, unsigned Indentation = 0,
1164 bool PrintInstantiation = false) const;
1165 void print(raw_ostream &Out, const PrintingPolicy &Policy,
1166 unsigned Indentation = 0, bool PrintInstantiation = false) const;
1167 static void printGroup(Decl** Begin, unsigned NumDecls,
1168 raw_ostream &Out, const PrintingPolicy &Policy,
1169 unsigned Indentation = 0);
1170
1171 // Debuggers don't usually respect default arguments.
1172 void dump() const;
1173
1174 // Same as dump(), but forces color printing.
1175 void dumpColor() const;
1176
1177 void dump(raw_ostream &Out, bool Deserialize = false,
1178 ASTDumpOutputFormat OutputFormat = ADOF_Default) const;
1179
1180 /// \return Unique reproducible object identifier
1181 int64_t getID() const;
1182
1183 /// Looks through the Decl's underlying type to extract a FunctionType
1184 /// when possible. Will return null if the type underlying the Decl does not
1185 /// have a FunctionType.
1186 const FunctionType *getFunctionType(bool BlocksToo = true) const;
1187
1188private:
1189 void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
1190 void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
1191 ASTContext &Ctx);
1192
1193protected:
1194 ASTMutationListener *getASTMutationListener() const;
1195};
1196
1197/// Determine whether two declarations declare the same entity.
1198inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
1199 if (!D1 || !D2)
1200 return false;
1201
1202 if (D1 == D2)
1203 return true;
1204
1205 return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1206}
1207
1208/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1209/// doing something to a specific decl.
1210class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
1211 const Decl *TheDecl;
1212 SourceLocation Loc;
1213 SourceManager &SM;
1214 const char *Message;
1215
1216public:
1217 PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L,
1218 SourceManager &sm, const char *Msg)
1219 : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}
1220
1221 void print(raw_ostream &OS) const override;
1222};
1223} // namespace clang
1224
1225// Required to determine the layout of the PointerUnion<NamedDecl*> before
1226// seeing the NamedDecl definition being first used in DeclListNode::operator*.
1227namespace llvm {
1228 template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
1229 static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
1230 static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
1231 return static_cast<::clang::NamedDecl *>(P);
1232 }
1233 static constexpr int NumLowBitsAvailable = 3;
1234 };
1235}
1236
1237namespace clang {
1238/// A list storing NamedDecls in the lookup tables.
1239class DeclListNode {
1240 friend class ASTContext; // allocate, deallocate nodes.
1241 friend class StoredDeclsList;
1242public:
1243 using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>;
1244 class iterator {
1245 friend class DeclContextLookupResult;
1246 friend class StoredDeclsList;
1247
1248 Decls Ptr;
1249 iterator(Decls Node) : Ptr(Node) { }
1250 public:
1251 using difference_type = ptrdiff_t;
1252 using value_type = NamedDecl*;
1253 using pointer = void;
1254 using reference = value_type;
1255 using iterator_category = std::forward_iterator_tag;
1256
1257 iterator() = default;
1258
1259 reference operator*() const {
1260 assert(Ptr && "dereferencing end() iterator")((void)0);
1261 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1262 return CurNode->D;
1263 return Ptr.get<NamedDecl*>();
1264 }
1265 void operator->() const { } // Unsupported.
1266 bool operator==(const iterator &X) const { return Ptr == X.Ptr; }
1267 bool operator!=(const iterator &X) const { return Ptr != X.Ptr; }
1268 inline iterator &operator++() { // ++It
1269 assert(!Ptr.isNull() && "Advancing empty iterator")((void)0);
1270
1271 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1272 Ptr = CurNode->Rest;
1273 else
1274 Ptr = nullptr;
1275 return *this;
1276 }
1277 iterator operator++(int) { // It++
1278 iterator temp = *this;
1279 ++(*this);
1280 return temp;
1281 }
1282 // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I)
1283 iterator end() { return iterator(); }
1284 };
1285private:
1286 NamedDecl *D = nullptr;
1287 Decls Rest = nullptr;
1288 DeclListNode(NamedDecl *ND) : D(ND) {}
1289};
1290
1291/// The results of name lookup within a DeclContext.
1292class DeclContextLookupResult {
1293 using Decls = DeclListNode::Decls;
1294
1295 /// When in collection form, this is what the Data pointer points to.
1296 Decls Result;
1297
1298public:
1299 DeclContextLookupResult() = default;
1300 DeclContextLookupResult(Decls Result) : Result(Result) {}
1301
1302 using iterator = DeclListNode::iterator;
1303 using const_iterator = iterator;
1304 using reference = iterator::reference;
1305
1306 iterator begin() { return iterator(Result); }
1307 iterator end() { return iterator(); }
1308 const_iterator begin() const {
1309 return const_cast<DeclContextLookupResult*>(this)->begin();
1310 }
1311 const_iterator end() const { return iterator(); }
1312
1313 bool empty() const { return Result.isNull(); }
1314 bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); }
1315 reference front() const { return *begin(); }
1316
1317 // Find the first declaration of the given type in the list. Note that this
1318 // is not in general the earliest-declared declaration, and should only be
1319 // used when it's not possible for there to be more than one match or where
1320 // it doesn't matter which one is found.
1321 template<class T> T *find_first() const {
1322 for (auto *D : *this)
1323 if (T *Decl = dyn_cast<T>(D))
1324 return Decl;
1325
1326 return nullptr;
1327 }
1328};
1329
1330/// DeclContext - This is used only as base class of specific decl types that
1331/// can act as declaration contexts. These decls are (only the top classes
1332/// that directly derive from DeclContext are mentioned, not their subclasses):
1333///
1334/// TranslationUnitDecl
1335/// ExternCContext
1336/// NamespaceDecl
1337/// TagDecl
1338/// OMPDeclareReductionDecl
1339/// OMPDeclareMapperDecl
1340/// FunctionDecl
1341/// ObjCMethodDecl
1342/// ObjCContainerDecl
1343/// LinkageSpecDecl
1344/// ExportDecl
1345/// BlockDecl
1346/// CapturedDecl
1347class DeclContext {
1348 /// For makeDeclVisibleInContextImpl
1349 friend class ASTDeclReader;
1350 /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
1351 /// hasNeedToReconcileExternalVisibleStorage
1352 friend class ExternalASTSource;
1353 /// For CreateStoredDeclsMap
1354 friend class DependentDiagnostic;
1355 /// For hasNeedToReconcileExternalVisibleStorage,
1356 /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
1357 friend class ASTWriter;
1358
1359 // We use uint64_t in the bit-fields below since some bit-fields
1360 // cross the unsigned boundary and this breaks the packing.
1361
1362 /// Stores the bits used by DeclContext.
1363 /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
1364 /// methods in DeclContext should be updated appropriately.
1365 class DeclContextBitfields {
1366 friend class DeclContext;
1367 /// DeclKind - This indicates which class this is.
1368 uint64_t DeclKind : 7;
1369
1370 /// Whether this declaration context also has some external
1371 /// storage that contains additional declarations that are lexically
1372 /// part of this context.
1373 mutable uint64_t ExternalLexicalStorage : 1;
1374
1375 /// Whether this declaration context also has some external
1376 /// storage that contains additional declarations that are visible
1377 /// in this context.
1378 mutable uint64_t ExternalVisibleStorage : 1;
1379
1380 /// Whether this declaration context has had externally visible
1381 /// storage added since the last lookup. In this case, \c LookupPtr's
1382 /// invariant may not hold and needs to be fixed before we perform
1383 /// another lookup.
1384 mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;
1385
1386 /// If \c true, this context may have local lexical declarations
1387 /// that are missing from the lookup table.
1388 mutable uint64_t HasLazyLocalLexicalLookups : 1;
1389
1390 /// If \c true, the external source may have lexical declarations
1391 /// that are missing from the lookup table.
1392 mutable uint64_t HasLazyExternalLexicalLookups : 1;
1393
1394 /// If \c true, lookups should only return identifier from
1395 /// DeclContext scope (for example TranslationUnit). Used in
1396 /// LookupQualifiedName()
1397 mutable uint64_t UseQualifiedLookup : 1;
1398 };
1399
1400 /// Number of bits in DeclContextBitfields.
1401 enum { NumDeclContextBits = 13 };
1402
1403 /// Stores the bits used by TagDecl.
1404 /// If modified NumTagDeclBits and the accessor
1405 /// methods in TagDecl should be updated appropriately.
1406 class TagDeclBitfields {
1407 friend class TagDecl;
1408 /// For the bits in DeclContextBitfields
1409 uint64_t : NumDeclContextBits;
1410
1411 /// The TagKind enum.
1412 uint64_t TagDeclKind : 3;
1413
1414 /// True if this is a definition ("struct foo {};"), false if it is a
1415 /// declaration ("struct foo;"). It is not considered a definition
1416 /// until the definition has been fully processed.
1417 uint64_t IsCompleteDefinition : 1;
1418
1419 /// True if this is currently being defined.
1420 uint64_t IsBeingDefined : 1;
1421
1422 /// True if this tag declaration is "embedded" (i.e., defined or declared
1423 /// for the very first time) in the syntax of a declarator.
1424 uint64_t IsEmbeddedInDeclarator : 1;
1425
1426 /// True if this tag is free standing, e.g. "struct foo;".
1427 uint64_t IsFreeStanding : 1;
1428
1429 /// Indicates whether it is possible for declarations of this kind
1430 /// to have an out-of-date definition.
1431 ///
1432 /// This option is only enabled when modules are enabled.
1433 uint64_t MayHaveOutOfDateDef : 1;
1434
1435 /// Has the full definition of this type been required by a use somewhere in
1436 /// the TU.
1437 uint64_t IsCompleteDefinitionRequired : 1;
1438 };
1439
1440 /// Number of non-inherited bits in TagDeclBitfields.
1441 enum { NumTagDeclBits = 9 };
1442
1443 /// Stores the bits used by EnumDecl.
1444 /// If modified NumEnumDeclBit and the accessor
1445 /// methods in EnumDecl should be updated appropriately.
1446 class EnumDeclBitfields {
1447 friend class EnumDecl;
1448 /// For the bits in DeclContextBitfields.
1449 uint64_t : NumDeclContextBits;
1450 /// For the bits in TagDeclBitfields.
1451 uint64_t : NumTagDeclBits;
1452
1453 /// Width in bits required to store all the non-negative
1454 /// enumerators of this enum.
1455 uint64_t NumPositiveBits : 8;
1456
1457 /// Width in bits required to store all the negative
1458 /// enumerators of this enum.
1459 uint64_t NumNegativeBits : 8;
1460
1461 /// True if this tag declaration is a scoped enumeration. Only
1462 /// possible in C++11 mode.
1463 uint64_t IsScoped : 1;
1464
1465 /// If this tag declaration is a scoped enum,
1466 /// then this is true if the scoped enum was declared using the class
1467 /// tag, false if it was declared with the struct tag. No meaning is
1468 /// associated if this tag declaration is not a scoped enum.
1469 uint64_t IsScopedUsingClassTag : 1;
1470
1471 /// True if this is an enumeration with fixed underlying type. Only
1472 /// possible in C++11, Microsoft extensions, or Objective C mode.
1473 uint64_t IsFixed : 1;
1474
1475 /// True if a valid hash is stored in ODRHash.
1476 uint64_t HasODRHash : 1;
1477 };
1478
1479 /// Number of non-inherited bits in EnumDeclBitfields.
1480 enum { NumEnumDeclBits = 20 };
1481
1482 /// Stores the bits used by RecordDecl.
1483 /// If modified NumRecordDeclBits and the accessor
1484 /// methods in RecordDecl should be updated appropriately.
1485 class RecordDeclBitfields {
1486 friend class RecordDecl;
1487 /// For the bits in DeclContextBitfields.
1488 uint64_t : NumDeclContextBits;
1489 /// For the bits in TagDeclBitfields.
1490 uint64_t : NumTagDeclBits;
1491
1492 /// This is true if this struct ends with a flexible
1493 /// array member (e.g. int X[]) or if this union contains a struct that does.
1494 /// If so, this cannot be contained in arrays or other structs as a member.
1495 uint64_t HasFlexibleArrayMember : 1;
1496
1497 /// Whether this is the type of an anonymous struct or union.
1498 uint64_t AnonymousStructOrUnion : 1;
1499
1500 /// This is true if this struct has at least one member
1501 /// containing an Objective-C object pointer type.
1502 uint64_t HasObjectMember : 1;
1503
1504 /// This is true if struct has at least one member of
1505 /// 'volatile' type.
1506 uint64_t HasVolatileMember : 1;
1507
1508 /// Whether the field declarations of this record have been loaded
1509 /// from external storage. To avoid unnecessary deserialization of
1510 /// methods/nested types we allow deserialization of just the fields
1511 /// when needed.
1512 mutable uint64_t LoadedFieldsFromExternalStorage : 1;
1513
1514 /// Basic properties of non-trivial C structs.
1515 uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
1516 uint64_t NonTrivialToPrimitiveCopy : 1;
1517 uint64_t NonTrivialToPrimitiveDestroy : 1;
1518
1519 /// The following bits indicate whether this is or contains a C union that
1520 /// is non-trivial to default-initialize, destruct, or copy. These bits
1521 /// imply the associated basic non-triviality predicates declared above.
1522 uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
1523 uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
1524 uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;
1525
1526 /// Indicates whether this struct is destroyed in the callee.
1527 uint64_t ParamDestroyedInCallee : 1;
1528
1529 /// Represents the way this type is passed to a function.
1530 uint64_t ArgPassingRestrictions : 2;
1531 };
1532
1533 /// Number of non-inherited bits in RecordDeclBitfields.
1534 enum { NumRecordDeclBits = 14 };
1535
1536 /// Stores the bits used by OMPDeclareReductionDecl.
1537 /// If modified NumOMPDeclareReductionDeclBits and the accessor
1538 /// methods in OMPDeclareReductionDecl should be updated appropriately.
1539 class OMPDeclareReductionDeclBitfields {
1540 friend class OMPDeclareReductionDecl;
1541 /// For the bits in DeclContextBitfields
1542 uint64_t : NumDeclContextBits;
1543
1544 /// Kind of initializer,
1545 /// function call or omp_priv<init_expr> initializtion.
1546 uint64_t InitializerKind : 2;
1547 };
1548
1549 /// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
1550 enum { NumOMPDeclareReductionDeclBits = 2 };
1551
1552 /// Stores the bits used by FunctionDecl.
1553 /// If modified NumFunctionDeclBits and the accessor
1554 /// methods in FunctionDecl and CXXDeductionGuideDecl
1555 /// (for IsCopyDeductionCandidate) should be updated appropriately.
1556 class FunctionDeclBitfields {
1557 friend class FunctionDecl;
1558 /// For IsCopyDeductionCandidate
1559 friend class CXXDeductionGuideDecl;
1560 /// For the bits in DeclContextBitfields.
1561 uint64_t : NumDeclContextBits;
1562
1563 uint64_t SClass : 3;
1564 uint64_t IsInline : 1;
1565 uint64_t IsInlineSpecified : 1;
1566
1567 uint64_t IsVirtualAsWritten : 1;
1568 uint64_t IsPure : 1;
1569 uint64_t HasInheritedPrototype : 1;
1570 uint64_t HasWrittenPrototype : 1;
1571 uint64_t IsDeleted : 1;
1572 /// Used by CXXMethodDecl
1573 uint64_t IsTrivial : 1;
1574
1575 /// This flag indicates whether this function is trivial for the purpose of
1576 /// calls. This is meaningful only when this function is a copy/move
1577 /// constructor or a destructor.
1578 uint64_t IsTrivialForCall : 1;
1579
1580 uint64_t IsDefaulted : 1;
1581 uint64_t IsExplicitlyDefaulted : 1;
1582 uint64_t HasDefaultedFunctionInfo : 1;
1583 uint64_t HasImplicitReturnZero : 1;
1584 uint64_t IsLateTemplateParsed : 1;
1585
1586 /// Kind of contexpr specifier as defined by ConstexprSpecKind.
1587 uint64_t ConstexprKind : 2;
1588 uint64_t InstantiationIsPending : 1;
1589
1590 /// Indicates if the function uses __try.
1591 uint64_t UsesSEHTry : 1;
1592
1593 /// Indicates if the function was a definition
1594 /// but its body was skipped.
1595 uint64_t HasSkippedBody : 1;
1596
1597 /// Indicates if the function declaration will
1598 /// have a body, once we're done parsing it.
1599 uint64_t WillHaveBody : 1;
1600
1601 /// Indicates that this function is a multiversioned
1602 /// function using attribute 'target'.
1603 uint64_t IsMultiVersion : 1;
1604
1605 /// [C++17] Only used by CXXDeductionGuideDecl. Indicates that
1606 /// the Deduction Guide is the implicitly generated 'copy
1607 /// deduction candidate' (is used during overload resolution).
1608 uint64_t IsCopyDeductionCandidate : 1;
1609
1610 /// Store the ODRHash after first calculation.
1611 uint64_t HasODRHash : 1;
1612
1613 /// Indicates if the function uses Floating Point Constrained Intrinsics
1614 uint64_t UsesFPIntrin : 1;
1615 };
1616
1617 /// Number of non-inherited bits in FunctionDeclBitfields.
1618 enum { NumFunctionDeclBits = 27 };
1619
1620 /// Stores the bits used by CXXConstructorDecl. If modified
1621 /// NumCXXConstructorDeclBits and the accessor
1622 /// methods in CXXConstructorDecl should be updated appropriately.
1623 class CXXConstructorDeclBitfields {
1624 friend class CXXConstructorDecl;
1625 /// For the bits in DeclContextBitfields.
1626 uint64_t : NumDeclContextBits;
1627 /// For the bits in FunctionDeclBitfields.
1628 uint64_t : NumFunctionDeclBits;
1629
1630 /// 24 bits to fit in the remaining available space.
1631 /// Note that this makes CXXConstructorDeclBitfields take
1632 /// exactly 64 bits and thus the width of NumCtorInitializers
1633 /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
1634 /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
1635 uint64_t NumCtorInitializers : 21;
1636 uint64_t IsInheritingConstructor : 1;
1637
1638 /// Whether this constructor has a trail-allocated explicit specifier.
1639 uint64_t HasTrailingExplicitSpecifier : 1;
1640 /// If this constructor does't have a trail-allocated explicit specifier.
1641 /// Whether this constructor is explicit specified.
1642 uint64_t IsSimpleExplicit : 1;
1643 };
1644
1645 /// Number of non-inherited bits in CXXConstructorDeclBitfields.
1646 enum {
1647 NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
1648 };
1649
1650 /// Stores the bits used by ObjCMethodDecl.
1651 /// If modified NumObjCMethodDeclBits and the accessor
1652 /// methods in ObjCMethodDecl should be updated appropriately.
1653 class ObjCMethodDeclBitfields {
1654 friend class ObjCMethodDecl;
1655
1656 /// For the bits in DeclContextBitfields.
1657 uint64_t : NumDeclContextBits;
1658
1659 /// The conventional meaning of this method; an ObjCMethodFamily.
1660 /// This is not serialized; instead, it is computed on demand and
1661 /// cached.
1662 mutable uint64_t Family : ObjCMethodFamilyBitWidth;
1663
1664 /// instance (true) or class (false) method.
1665 uint64_t IsInstance : 1;
1666 uint64_t IsVariadic : 1;
1667
1668 /// True if this method is the getter or setter for an explicit property.
1669 uint64_t IsPropertyAccessor : 1;
1670
1671 /// True if this method is a synthesized property accessor stub.
1672 uint64_t IsSynthesizedAccessorStub : 1;
1673
1674 /// Method has a definition.
1675 uint64_t IsDefined : 1;
1676
1677 /// Method redeclaration in the same interface.
1678 uint64_t IsRedeclaration : 1;
1679
1680 /// Is redeclared in the same interface.
1681 mutable uint64_t HasRedeclaration : 1;
1682
1683 /// \@required/\@optional
1684 uint64_t DeclImplementation : 2;
1685
1686 /// in, inout, etc.
1687 uint64_t objcDeclQualifier : 7;
1688
1689 /// Indicates whether this method has a related result type.
1690 uint64_t RelatedResultType : 1;
1691
1692 /// Whether the locations of the selector identifiers are in a
1693 /// "standard" position, a enum SelectorLocationsKind.
1694 uint64_t SelLocsKind : 2;
1695
1696 /// Whether this method overrides any other in the class hierarchy.
1697 ///
1698 /// A method is said to override any method in the class's
1699 /// base classes, its protocols, or its categories' protocols, that has
1700 /// the same selector and is of the same kind (class or instance).
1701 /// A method in an implementation is not considered as overriding the same
1702 /// method in the interface or its categories.
1703 uint64_t IsOverriding : 1;
1704
1705 /// Indicates if the method was a definition but its body was skipped.
1706 uint64_t HasSkippedBody : 1;
1707 };
1708
1709 /// Number of non-inherited bits in ObjCMethodDeclBitfields.
1710 enum { NumObjCMethodDeclBits = 24 };
1711
1712 /// Stores the bits used by ObjCContainerDecl.
1713 /// If modified NumObjCContainerDeclBits and the accessor
1714 /// methods in ObjCContainerDecl should be updated appropriately.
1715 class ObjCContainerDeclBitfields {
1716 friend class ObjCContainerDecl;
1717 /// For the bits in DeclContextBitfields
1718 uint32_t : NumDeclContextBits;
1719
1720 // Not a bitfield but this saves space.
1721 // Note that ObjCContainerDeclBitfields is full.
1722 SourceLocation AtStart;
1723 };
1724
1725 /// Number of non-inherited bits in ObjCContainerDeclBitfields.
1726 /// Note that here we rely on the fact that SourceLocation is 32 bits
1727 /// wide. We check this with the static_assert in the ctor of DeclContext.
1728 enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
1729
1730 /// Stores the bits used by LinkageSpecDecl.
1731 /// If modified NumLinkageSpecDeclBits and the accessor
1732 /// methods in LinkageSpecDecl should be updated appropriately.
1733 class LinkageSpecDeclBitfields {
1734 friend class LinkageSpecDecl;
1735 /// For the bits in DeclContextBitfields.
1736 uint64_t : NumDeclContextBits;
1737
1738 /// The language for this linkage specification with values
1739 /// in the enum LinkageSpecDecl::LanguageIDs.
1740 uint64_t Language : 3;
1741
1742 /// True if this linkage spec has braces.
1743 /// This is needed so that hasBraces() returns the correct result while the
1744 /// linkage spec body is being parsed. Once RBraceLoc has been set this is
1745 /// not used, so it doesn't need to be serialized.
1746 uint64_t HasBraces : 1;
1747 };
1748
1749 /// Number of non-inherited bits in LinkageSpecDeclBitfields.
1750 enum { NumLinkageSpecDeclBits = 4 };
1751
1752 /// Stores the bits used by BlockDecl.
1753 /// If modified NumBlockDeclBits and the accessor
1754 /// methods in BlockDecl should be updated appropriately.
1755 class BlockDeclBitfields {
1756 friend class BlockDecl;
1757 /// For the bits in DeclContextBitfields.
1758 uint64_t : NumDeclContextBits;
1759
1760 uint64_t IsVariadic : 1;
1761 uint64_t CapturesCXXThis : 1;
1762 uint64_t BlockMissingReturnType : 1;
1763 uint64_t IsConversionFromLambda : 1;
1764
1765 /// A bit that indicates this block is passed directly to a function as a
1766 /// non-escaping parameter.
1767 uint64_t DoesNotEscape : 1;
1768
1769 /// A bit that indicates whether it's possible to avoid coying this block to
1770 /// the heap when it initializes or is assigned to a local variable with
1771 /// automatic storage.
1772 uint64_t CanAvoidCopyToHeap : 1;
1773 };
1774
1775 /// Number of non-inherited bits in BlockDeclBitfields.
1776 enum { NumBlockDeclBits = 5 };
1777
1778 /// Pointer to the data structure used to lookup declarations
1779 /// within this context (or a DependentStoredDeclsMap if this is a
1780 /// dependent context). We maintain the invariant that, if the map
1781 /// contains an entry for a DeclarationName (and we haven't lazily
1782 /// omitted anything), then it contains all relevant entries for that
1783 /// name (modulo the hasExternalDecls() flag).
1784 mutable StoredDeclsMap *LookupPtr = nullptr;
1785
1786protected:
1787 /// This anonymous union stores the bits belonging to DeclContext and classes
1788 /// deriving from it. The goal is to use otherwise wasted
1789 /// space in DeclContext to store data belonging to derived classes.
1790 /// The space saved is especially significient when pointers are aligned
1791 /// to 8 bytes. In this case due to alignment requirements we have a
1792 /// little less than 8 bytes free in DeclContext which we can use.
1793 /// We check that none of the classes in this union is larger than
1794 /// 8 bytes with static_asserts in the ctor of DeclContext.
1795 union {
1796 DeclContextBitfields DeclContextBits;
1797 TagDeclBitfields TagDeclBits;
1798 EnumDeclBitfields EnumDeclBits;
1799 RecordDeclBitfields RecordDeclBits;
1800 OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
1801 FunctionDeclBitfields FunctionDeclBits;
1802 CXXConstructorDeclBitfields CXXConstructorDeclBits;
1803 ObjCMethodDeclBitfields ObjCMethodDeclBits;
1804 ObjCContainerDeclBitfields ObjCContainerDeclBits;
1805 LinkageSpecDeclBitfields LinkageSpecDeclBits;
1806 BlockDeclBitfields BlockDeclBits;
1807
1808 static_assert(sizeof(DeclContextBitfields) <= 8,
1809 "DeclContextBitfields is larger than 8 bytes!");
1810 static_assert(sizeof(TagDeclBitfields) <= 8,
1811 "TagDeclBitfields is larger than 8 bytes!");
1812 static_assert(sizeof(EnumDeclBitfields) <= 8,
1813 "EnumDeclBitfields is larger than 8 bytes!");
1814 static_assert(sizeof(RecordDeclBitfields) <= 8,
1815 "RecordDeclBitfields is larger than 8 bytes!");
1816 static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
1817 "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
1818 static_assert(sizeof(FunctionDeclBitfields) <= 8,
1819 "FunctionDeclBitfields is larger than 8 bytes!");
1820 static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
1821 "CXXConstructorDeclBitfields is larger than 8 bytes!");
1822 static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
1823 "ObjCMethodDeclBitfields is larger than 8 bytes!");
1824 static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
1825 "ObjCContainerDeclBitfields is larger than 8 bytes!");
1826 static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
1827 "LinkageSpecDeclBitfields is larger than 8 bytes!");
1828 static_assert(sizeof(BlockDeclBitfields) <= 8,
1829 "BlockDeclBitfields is larger than 8 bytes!");
1830 };
1831
1832 /// FirstDecl - The first declaration stored within this declaration
1833 /// context.
1834 mutable Decl *FirstDecl = nullptr;
1835
1836 /// LastDecl - The last declaration stored within this declaration
1837 /// context. FIXME: We could probably cache this value somewhere
1838 /// outside of the DeclContext, to reduce the size of DeclContext by
1839 /// another pointer.
1840 mutable Decl *LastDecl = nullptr;
1841
1842 /// Build up a chain of declarations.
1843 ///
1844 /// \returns the first/last pair of declarations.
1845 static std::pair<Decl *, Decl *>
1846 BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);
1847
1848 DeclContext(Decl::Kind K);
1849
1850public:
1851 ~DeclContext();
1852
1853 Decl::Kind getDeclKind() const {
1854 return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
1855 }
1856
1857 const char *getDeclKindName() const;
1858
1859 /// getParent - Returns the containing DeclContext.
1860 DeclContext *getParent() {
1861 return cast<Decl>(this)->getDeclContext();
1862 }
1863 const DeclContext *getParent() const {
1864 return const_cast<DeclContext*>(this)->getParent();
1865 }
1866
1867 /// getLexicalParent - Returns the containing lexical DeclContext. May be
1868 /// different from getParent, e.g.:
1869 ///
1870 /// namespace A {
1871 /// struct S;
1872 /// }
1873 /// struct A::S {}; // getParent() == namespace 'A'
1874 /// // getLexicalParent() == translation unit
1875 ///
1876 DeclContext *getLexicalParent() {
1877 return cast<Decl>(this)->getLexicalDeclContext();
1878 }
1879 const DeclContext *getLexicalParent() const {
1880 return const_cast<DeclContext*>(this)->getLexicalParent();
1881 }
1882
1883 DeclContext *getLookupParent();
1884
1885 const DeclContext *getLookupParent() const {
1886 return const_cast<DeclContext*>(this)->getLookupParent();
1887 }
1888
1889 ASTContext &getParentASTContext() const {
1890 return cast<Decl>(this)->getASTContext();
1891 }
1892
1893 bool isClosure() const { return getDeclKind() == Decl::Block; }
1894
1895 /// Return this DeclContext if it is a BlockDecl. Otherwise, return the
1896 /// innermost enclosing BlockDecl or null if there are no enclosing blocks.
1897 const BlockDecl *getInnermostBlockDecl() const;
1898
1899 bool isObjCContainer() const {
1900 switch (getDeclKind()) {
1901 case Decl::ObjCCategory:
1902 case Decl::ObjCCategoryImpl:
1903 case Decl::ObjCImplementation:
1904 case Decl::ObjCInterface:
1905 case Decl::ObjCProtocol:
1906 return true;
1907 default:
1908 return false;
1909 }
1910 }
1911
1912 bool isFunctionOrMethod() const {
1913 switch (getDeclKind()) {
1914 case Decl::Block:
1915 case Decl::Captured:
1916 case Decl::ObjCMethod:
1917 return true;
1918 default:
1919 return getDeclKind() >= Decl::firstFunction &&
1920 getDeclKind() <= Decl::lastFunction;
1921 }
1922 }
1923
1924 /// Test whether the context supports looking up names.
1925 bool isLookupContext() const {
1926 return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
1927 getDeclKind() != Decl::Export;
1928 }
1929
1930 bool isFileContext() const {
1931 return getDeclKind() == Decl::TranslationUnit ||
1932 getDeclKind() == Decl::Namespace;
1933 }
1934
1935 bool isTranslationUnit() const {
1936 return getDeclKind() == Decl::TranslationUnit;
1937 }
1938
1939 bool isRecord() const {
1940 return getDeclKind() >= Decl::firstRecord &&
1941 getDeclKind() <= Decl::lastRecord;
1942 }
1943
1944 bool isNamespace() const { return getDeclKind() == Decl::Namespace; }
1945
1946 bool isStdNamespace() const;
1947
1948 bool isInlineNamespace() const;
1949
1950 /// Determines whether this context is dependent on a
1951 /// template parameter.
1952 bool isDependentContext() const;
1953
1954 /// isTransparentContext - Determines whether this context is a
1955 /// "transparent" context, meaning that the members declared in this
1956 /// context are semantically declared in the nearest enclosing
1957 /// non-transparent (opaque) context but are lexically declared in
1958 /// this context. For example, consider the enumerators of an
1959 /// enumeration type:
1960 /// @code
1961 /// enum E {
1962 /// Val1
1963 /// };
1964 /// @endcode
1965 /// Here, E is a transparent context, so its enumerator (Val1) will
1966 /// appear (semantically) that it is in the same context of E.
1967 /// Examples of transparent contexts include: enumerations (except for
1968 /// C++0x scoped enums), and C++ linkage specifications.
1969 bool isTransparentContext() const;
1970
1971 /// Determines whether this context or some of its ancestors is a
1972 /// linkage specification context that specifies C linkage.
1973 bool isExternCContext() const;
1974
1975 /// Retrieve the nearest enclosing C linkage specification context.
1976 const LinkageSpecDecl *getExternCContext() const;
1977
1978 /// Determines whether this context or some of its ancestors is a
1979 /// linkage specification context that specifies C++ linkage.
1980 bool isExternCXXContext() const;
1981
1982 /// Determine whether this declaration context is equivalent
1983 /// to the declaration context DC.
1984 bool Equals(const DeclContext *DC) const {
1985 return DC && this->getPrimaryContext() == DC->getPrimaryContext();
1986 }
1987
1988 /// Determine whether this declaration context encloses the
1989 /// declaration context DC.
1990 bool Encloses(const DeclContext *DC) const;
1991
1992 /// Find the nearest non-closure ancestor of this context,
1993 /// i.e. the innermost semantic parent of this context which is not
1994 /// a closure. A context may be its own non-closure ancestor.
1995 Decl *getNonClosureAncestor();
1996 const Decl *getNonClosureAncestor() const {
1997 return const_cast<DeclContext*>(this)->getNonClosureAncestor();
1998 }
1999
2000 /// getPrimaryContext - There may be many different
2001 /// declarations of the same entity (including forward declarations
2002 /// of classes, multiple definitions of namespaces, etc.), each with
2003 /// a different set of declarations. This routine returns the
2004 /// "primary" DeclContext structure, which will contain the
2005 /// information needed to perform name lookup into this context.
2006 DeclContext *getPrimaryContext();
2007 const DeclContext *getPrimaryContext() const {
2008 return const_cast<DeclContext*>(this)->getPrimaryContext();
2009 }
2010
2011 /// getRedeclContext - Retrieve the context in which an entity conflicts with
2012 /// other entities of the same name, or where it is a redeclaration if the
2013 /// two entities are compatible. This skips through transparent contexts.
2014 DeclContext *getRedeclContext();
2015 const DeclContext *getRedeclContext() const {
2016 return const_cast<DeclContext *>(this)->getRedeclContext();
2017 }
2018
2019 /// Retrieve the nearest enclosing namespace context.
2020 DeclContext *getEnclosingNamespaceContext();
2021 const DeclContext *getEnclosingNamespaceContext() const {
2022 return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
2023 }
2024
2025 /// Retrieve the outermost lexically enclosing record context.
2026 RecordDecl *getOuterLexicalRecordContext();
2027 const RecordDecl *getOuterLexicalRecordContext() const {
2028 return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
2029 }
2030
2031 /// Test if this context is part of the enclosing namespace set of
2032 /// the context NS, as defined in C++0x [namespace.def]p9. If either context
2033 /// isn't a namespace, this is equivalent to Equals().
2034 ///
2035 /// The enclosing namespace set of a namespace is the namespace and, if it is
2036 /// inline, its enclosing namespace, recursively.
2037 bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;
2038
2039 /// Collects all of the declaration contexts that are semantically
2040 /// connected to this declaration context.
2041 ///
2042 /// For declaration contexts that have multiple semantically connected but
2043 /// syntactically distinct contexts, such as C++ namespaces, this routine
2044 /// retrieves the complete set of such declaration contexts in source order.
2045 /// For example, given:
2046 ///
2047 /// \code
2048 /// namespace N {
2049 /// int x;
2050 /// }
2051 /// namespace N {
2052 /// int y;
2053 /// }
2054 /// \endcode
2055 ///
2056 /// The \c Contexts parameter will contain both definitions of N.
2057 ///
2058 /// \param Contexts Will be cleared and set to the set of declaration
2059 /// contexts that are semanticaly connected to this declaration context,
2060 /// in source order, including this context (which may be the only result,
2061 /// for non-namespace contexts).
2062 void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts);
2063
2064 /// decl_iterator - Iterates through the declarations stored
2065 /// within this context.
2066 class decl_iterator {
2067 /// Current - The current declaration.
2068 Decl *Current = nullptr;
2069
2070 public:
2071 using value_type = Decl *;
2072 using reference = const value_type &;
2073 using pointer = const value_type *;
2074 using iterator_category = std::forward_iterator_tag;
2075 using difference_type = std::ptrdiff_t;
2076
2077 decl_iterator() = default;
2078 explicit decl_iterator(Decl *C) : Current(C) {}
2079
2080 reference operator*() const { return Current; }
2081
2082 // This doesn't meet the iterator requirements, but it's convenient
2083 value_type operator->() const { return Current; }
2084
2085 decl_iterator& operator++() {
2086 Current = Current->getNextDeclInContext();
2087 return *this;
2088 }
2089
2090 decl_iterator operator++(int) {
2091 decl_iterator tmp(*this);
2092 ++(*this);
2093 return tmp;
2094 }
2095
2096 friend bool operator==(decl_iterator x, decl_iterator y) {
2097 return x.Current == y.Current;
46
Assuming 'x.Current' is not equal to 'y.Current'
47
Returning zero, which participates in a condition later
2098 }
2099
2100 friend bool operator!=(decl_iterator x, decl_iterator y) {
2101 return x.Current != y.Current;
2102 }
2103 };
2104
2105 using decl_range = llvm::iterator_range<decl_iterator>;
2106
2107 /// decls_begin/decls_end - Iterate over the declarations stored in
2108 /// this context.
2109 decl_range decls() const { return decl_range(decls_begin(), decls_end()); }
2110 decl_iterator decls_begin() const;
2111 decl_iterator decls_end() const { return decl_iterator(); }
2112 bool decls_empty() const;
2113
2114 /// noload_decls_begin/end - Iterate over the declarations stored in this
2115 /// context that are currently loaded; don't attempt to retrieve anything
2116 /// from an external source.
2117 decl_range noload_decls() const {
2118 return decl_range(noload_decls_begin(), noload_decls_end());
2119 }
2120 decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); }
2121 decl_iterator noload_decls_end() const { return decl_iterator(); }
2122
2123 /// specific_decl_iterator - Iterates over a subrange of
2124 /// declarations stored in a DeclContext, providing only those that
2125 /// are of type SpecificDecl (or a class derived from it). This
2126 /// iterator is used, for example, to provide iteration over just
2127 /// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
2128 template<typename SpecificDecl>
2129 class specific_decl_iterator {
2130 /// Current - The current, underlying declaration iterator, which
2131 /// will either be NULL or will point to a declaration of
2132 /// type SpecificDecl.
2133 DeclContext::decl_iterator Current;
2134
2135 /// SkipToNextDecl - Advances the current position up to the next
2136 /// declaration of type SpecificDecl that also meets the criteria
2137 /// required by Acceptable.
2138 void SkipToNextDecl() {
2139 while (*Current && !isa<SpecificDecl>(*Current))
2140 ++Current;
2141 }
2142
2143 public:
2144 using value_type = SpecificDecl *;
2145 // TODO: Add reference and pointer types (with some appropriate proxy type)
2146 // if we ever have a need for them.
2147 using reference = void;
2148 using pointer = void;
2149 using difference_type =
2150 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2151 using iterator_category = std::forward_iterator_tag;
2152
2153 specific_decl_iterator() = default;
2154
2155 /// specific_decl_iterator - Construct a new iterator over a
2156 /// subset of the declarations the range [C,
2157 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2158 /// member function of SpecificDecl that should return true for
2159 /// all of the SpecificDecl instances that will be in the subset
2160 /// of iterators. For example, if you want Objective-C instance
2161 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2162 /// &ObjCMethodDecl::isInstanceMethod.
2163 explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
2164 SkipToNextDecl();
2165 }
2166
2167 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2168
2169 // This doesn't meet the iterator requirements, but it's convenient
2170 value_type operator->() const { return **this; }
2171
2172 specific_decl_iterator& operator++() {
2173 ++Current;
2174 SkipToNextDecl();
2175 return *this;
2176 }
2177
2178 specific_decl_iterator operator++(int) {
2179 specific_decl_iterator tmp(*this);
2180 ++(*this);
2181 return tmp;
2182 }
2183
2184 friend bool operator==(const specific_decl_iterator& x,
2185 const specific_decl_iterator& y) {
2186 return x.Current == y.Current;
45
Calling 'operator=='
48
Returning from 'operator=='
49
Returning zero, which participates in a condition later
2187 }
2188
2189 friend bool operator!=(const specific_decl_iterator& x,
2190 const specific_decl_iterator& y) {
2191 return x.Current != y.Current;
2192 }
2193 };
2194
2195 /// Iterates over a filtered subrange of declarations stored
2196 /// in a DeclContext.
2197 ///
2198 /// This iterator visits only those declarations that are of type
2199 /// SpecificDecl (or a class derived from it) and that meet some
2200 /// additional run-time criteria. This iterator is used, for
2201 /// example, to provide access to the instance methods within an
2202 /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
2203 /// Acceptable = ObjCMethodDecl::isInstanceMethod).
2204 template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
2205 class filtered_decl_iterator {
2206 /// Current - The current, underlying declaration iterator, which
2207 /// will either be NULL or will point to a declaration of
2208 /// type SpecificDecl.
2209 DeclContext::decl_iterator Current;
2210
2211 /// SkipToNextDecl - Advances the current position up to the next
2212 /// declaration of type SpecificDecl that also meets the criteria
2213 /// required by Acceptable.
2214 void SkipToNextDecl() {
2215 while (*Current &&
2216 (!isa<SpecificDecl>(*Current) ||
2217 (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
2218 ++Current;
2219 }
2220
2221 public:
2222 using value_type = SpecificDecl *;
2223 // TODO: Add reference and pointer types (with some appropriate proxy type)
2224 // if we ever have a need for them.
2225 using reference = void;
2226 using pointer = void;
2227 using difference_type =
2228 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2229 using iterator_category = std::forward_iterator_tag;
2230
2231 filtered_decl_iterator() = default;
2232
2233 /// filtered_decl_iterator - Construct a new iterator over a
2234 /// subset of the declarations the range [C,
2235 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2236 /// member function of SpecificDecl that should return true for
2237 /// all of the SpecificDecl instances that will be in the subset
2238 /// of iterators. For example, if you want Objective-C instance
2239 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2240 /// &ObjCMethodDecl::isInstanceMethod.
2241 explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) {
2242 SkipToNextDecl();
2243 }
2244
2245 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2246 value_type operator->() const { return cast<SpecificDecl>(*Current); }
2247
2248 filtered_decl_iterator& operator++() {
2249 ++Current;
2250 SkipToNextDecl();
2251 return *this;
2252 }
2253
2254 filtered_decl_iterator operator++(int) {
2255 filtered_decl_iterator tmp(*this);
2256 ++(*this);
2257 return tmp;
2258 }
2259
2260 friend bool operator==(const filtered_decl_iterator& x,
2261 const filtered_decl_iterator& y) {
2262 return x.Current == y.Current;
2263 }
2264
2265 friend bool operator!=(const filtered_decl_iterator& x,
2266 const filtered_decl_iterator& y) {
2267 return x.Current != y.Current;
2268 }
2269 };
2270
2271 /// Add the declaration D into this context.
2272 ///
2273 /// This routine should be invoked when the declaration D has first
2274 /// been declared, to place D into the context where it was
2275 /// (lexically) defined. Every declaration must be added to one
2276 /// (and only one!) context, where it can be visited via
2277 /// [decls_begin(), decls_end()). Once a declaration has been added
2278 /// to its lexical context, the corresponding DeclContext owns the
2279 /// declaration.
2280 ///
2281 /// If D is also a NamedDecl, it will be made visible within its
2282 /// semantic context via makeDeclVisibleInContext.
2283 void addDecl(Decl *D);
2284
2285 /// Add the declaration D into this context, but suppress
2286 /// searches for external declarations with the same name.
2287 ///
2288 /// Although analogous in function to addDecl, this removes an
2289 /// important check. This is only useful if the Decl is being
2290 /// added in response to an external search; in all other cases,
2291 /// addDecl() is the right function to use.
2292 /// See the ASTImporter for use cases.
2293 void addDeclInternal(Decl *D);
2294
2295 /// Add the declaration D to this context without modifying
2296 /// any lookup tables.
2297 ///
2298 /// This is useful for some operations in dependent contexts where
2299 /// the semantic context might not be dependent; this basically
2300 /// only happens with friends.
2301 void addHiddenDecl(Decl *D);
2302
2303 /// Removes a declaration from this context.
2304 void removeDecl(Decl *D);
2305
2306 /// Checks whether a declaration is in this context.
2307 bool containsDecl(Decl *D) const;
2308
2309 /// Checks whether a declaration is in this context.
2310 /// This also loads the Decls from the external source before the check.
2311 bool containsDeclAndLoad(Decl *D) const;
2312
2313 using lookup_result = DeclContextLookupResult;
2314 using lookup_iterator = lookup_result::iterator;
2315
2316 /// lookup - Find the declarations (if any) with the given Name in
2317 /// this context. Returns a range of iterators that contains all of
2318 /// the declarations with this name, with object, function, member,
2319 /// and enumerator names preceding any tag name. Note that this
2320 /// routine will not look into parent contexts.
2321 lookup_result lookup(DeclarationName Name) const;
2322
2323 /// Find the declarations with the given name that are visible
2324 /// within this context; don't attempt to retrieve anything from an
2325 /// external source.
2326 lookup_result noload_lookup(DeclarationName Name);
2327
2328 /// A simplistic name lookup mechanism that performs name lookup
2329 /// into this declaration context without consulting the external source.
2330 ///
2331 /// This function should almost never be used, because it subverts the
2332 /// usual relationship between a DeclContext and the external source.
2333 /// See the ASTImporter for the (few, but important) use cases.
2334 ///
2335 /// FIXME: This is very inefficient; replace uses of it with uses of
2336 /// noload_lookup.
2337 void localUncachedLookup(DeclarationName Name,
2338 SmallVectorImpl<NamedDecl *> &Results);
2339
2340 /// Makes a declaration visible within this context.
2341 ///
2342 /// This routine makes the declaration D visible to name lookup
2343 /// within this context and, if this is a transparent context,
2344 /// within its parent contexts up to the first enclosing
2345 /// non-transparent context. Making a declaration visible within a
2346 /// context does not transfer ownership of a declaration, and a
2347 /// declaration can be visible in many contexts that aren't its
2348 /// lexical context.
2349 ///
2350 /// If D is a redeclaration of an existing declaration that is
2351 /// visible from this context, as determined by
2352 /// NamedDecl::declarationReplaces, the previous declaration will be
2353 /// replaced with D.
2354 void makeDeclVisibleInContext(NamedDecl *D);
2355
2356 /// all_lookups_iterator - An iterator that provides a view over the results
2357 /// of looking up every possible name.
2358 class all_lookups_iterator;
2359
2360 using lookups_range = llvm::iterator_range<all_lookups_iterator>;
2361
2362 lookups_range lookups() const;
2363 // Like lookups(), but avoids loading external declarations.
2364 // If PreserveInternalState, avoids building lookup data structures too.
2365 lookups_range noload_lookups(bool PreserveInternalState) const;
2366
2367 /// Iterators over all possible lookups within this context.
2368 all_lookups_iterator lookups_begin() const;
2369 all_lookups_iterator lookups_end() const;
2370
2371 /// Iterators over all possible lookups within this context that are
2372 /// currently loaded; don't attempt to retrieve anything from an external
2373 /// source.
2374 all_lookups_iterator noload_lookups_begin() const;
2375 all_lookups_iterator noload_lookups_end() const;
2376
2377 struct udir_iterator;
2378
2379 using udir_iterator_base =
2380 llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
2381 typename lookup_iterator::iterator_category,
2382 UsingDirectiveDecl *>;
2383
2384 struct udir_iterator : udir_iterator_base {
2385 udir_iterator(lookup_iterator I) : udir_iterator_base(I) {}
2386
2387 UsingDirectiveDecl *operator*() const;
2388 };
2389
2390 using udir_range = llvm::iterator_range<udir_iterator>;
2391
2392 udir_range using_directives() const;
2393
2394 // These are all defined in DependentDiagnostic.h.
2395 class ddiag_iterator;
2396
2397 using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;
2398
2399 inline ddiag_range ddiags() const;
2400
2401 // Low-level accessors
2402
2403 /// Mark that there are external lexical declarations that we need
2404 /// to include in our lookup table (and that are not available as external
2405 /// visible lookups). These extra lookup results will be found by walking
2406 /// the lexical declarations of this context. This should be used only if
2407 /// setHasExternalLexicalStorage() has been called on any decl context for
2408 /// which this is the primary context.
2409 void setMustBuildLookupTable() {
2410 assert(this == getPrimaryContext() &&((void)0)
2411 "should only be called on primary context")((void)0);
2412 DeclContextBits.HasLazyExternalLexicalLookups = true;
2413 }
2414
2415 /// Retrieve the internal representation of the lookup structure.
2416 /// This may omit some names if we are lazily building the structure.
2417 StoredDeclsMap *getLookupPtr() const { return LookupPtr; }
2418
2419 /// Ensure the lookup structure is fully-built and return it.
2420 StoredDeclsMap *buildLookup();
2421
2422 /// Whether this DeclContext has external storage containing
2423 /// additional declarations that are lexically in this context.
2424 bool hasExternalLexicalStorage() const {
2425 return DeclContextBits.ExternalLexicalStorage;
2426 }
2427
2428 /// State whether this DeclContext has external storage for
2429 /// declarations lexically in this context.
2430 void setHasExternalLexicalStorage(bool ES = true) const {
2431 DeclContextBits.ExternalLexicalStorage = ES;
2432 }
2433
2434 /// Whether this DeclContext has external storage containing
2435 /// additional declarations that are visible in this context.
2436 bool hasExternalVisibleStorage() const {
2437 return DeclContextBits.ExternalVisibleStorage;
2438 }
2439
2440 /// State whether this DeclContext has external storage for
2441 /// declarations visible in this context.
2442 void setHasExternalVisibleStorage(bool ES = true) const {
2443 DeclContextBits.ExternalVisibleStorage = ES;
2444 if (ES && LookupPtr)
2445 DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
2446 }
2447
2448 /// Determine whether the given declaration is stored in the list of
2449 /// declarations lexically within this context.
2450 bool isDeclInLexicalTraversal(const Decl *D) const {
2451 return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
2452 D == LastDecl);
2453 }
2454
2455 bool setUseQualifiedLookup(bool use = true) const {
2456 bool old_value = DeclContextBits.UseQualifiedLookup;
2457 DeclContextBits.UseQualifiedLookup = use;
2458 return old_value;
2459 }
2460
2461 bool shouldUseQualifiedLookup() const {
2462 return DeclContextBits.UseQualifiedLookup;
2463 }
2464
2465 static bool classof(const Decl *D);
2466 static bool classof(const DeclContext *D) { return true; }
2467
2468 void dumpDeclContext() const;
2469 void dumpLookups() const;
2470 void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
2471 bool Deserialize = false) const;
2472
2473private:
2474 /// Whether this declaration context has had externally visible
2475 /// storage added since the last lookup. In this case, \c LookupPtr's
2476 /// invariant may not hold and needs to be fixed before we perform
2477 /// another lookup.
2478 bool hasNeedToReconcileExternalVisibleStorage() const {
2479 return DeclContextBits.NeedToReconcileExternalVisibleStorage;
2480 }
2481
2482 /// State that this declaration context has had externally visible
2483 /// storage added since the last lookup. In this case, \c LookupPtr's
2484 /// invariant may not hold and needs to be fixed before we perform
2485 /// another lookup.
2486 void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
2487 DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
2488 }
2489
2490 /// If \c true, this context may have local lexical declarations
2491 /// that are missing from the lookup table.
2492 bool hasLazyLocalLexicalLookups() const {
2493 return DeclContextBits.HasLazyLocalLexicalLookups;
2494 }
2495
2496 /// If \c true, this context may have local lexical declarations
2497 /// that are missing from the lookup table.
2498 void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
2499 DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
2500 }
2501
2502 /// If \c true, the external source may have lexical declarations
2503 /// that are missing from the lookup table.
2504 bool hasLazyExternalLexicalLookups() const {
2505 return DeclContextBits.HasLazyExternalLexicalLookups;
2506 }
2507
2508 /// If \c true, the external source may have lexical declarations
2509 /// that are missing from the lookup table.
2510 void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
2511 DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
2512 }
2513
2514 void reconcileExternalVisibleStorage() const;
2515 bool LoadLexicalDeclsFromExternalStorage() const;
2516
2517 /// Makes a declaration visible within this context, but
2518 /// suppresses searches for external declarations with the same
2519 /// name.
2520 ///
2521 /// Analogous to makeDeclVisibleInContext, but for the exclusive
2522 /// use of addDeclInternal().
2523 void makeDeclVisibleInContextInternal(NamedDecl *D);
2524
2525 StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;
2526
2527 void loadLazyLocalLexicalLookups();
2528 void buildLookupImpl(DeclContext *DCtx, bool Internal);
2529 void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
2530 bool Rediscoverable);
2531 void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2532};
2533
2534inline bool Decl::isTemplateParameter() const {
2535 return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
2536 getKind() == TemplateTemplateParm;
2537}
2538
2539// Specialization selected when ToTy is not a known subclass of DeclContext.
2540template <class ToTy,
2541 bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2542struct cast_convert_decl_context {
2543 static const ToTy *doit(const DeclContext *Val) {
2544 return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
2545 }
2546
2547 static ToTy *doit(DeclContext *Val) {
2548 return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
2549 }
2550};
2551
2552// Specialization selected when ToTy is a known subclass of DeclContext.
2553template <class ToTy>
2554struct cast_convert_decl_context<ToTy, true> {
2555 static const ToTy *doit(const DeclContext *Val) {
2556 return static_cast<const ToTy*>(Val);
2557 }
2558
2559 static ToTy *doit(DeclContext *Val) {
2560 return static_cast<ToTy*>(Val);
2561 }
2562};
2563
2564} // namespace clang
2565
2566namespace llvm {
2567
2568/// isa<T>(DeclContext*)
2569template <typename To>
2570struct isa_impl<To, ::clang::DeclContext> {
2571 static bool doit(const ::clang::DeclContext &Val) {
2572 return To::classofKind(Val.getDeclKind());
2573 }
2574};
2575
2576/// cast<T>(DeclContext*)
2577template<class ToTy>
2578struct cast_convert_val<ToTy,
2579 const ::clang::DeclContext,const ::clang::DeclContext> {
2580 static const ToTy &doit(const ::clang::DeclContext &Val) {
2581 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
2582 }
2583};
2584
2585template<class ToTy>
2586struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
2587 static ToTy &doit(::clang::DeclContext &Val) {
2588 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val);
2589 }
2590};
2591
2592template<class ToTy>
2593struct cast_convert_val<ToTy,
2594 const ::clang::DeclContext*, const ::clang::DeclContext*> {
2595 static const ToTy *doit(const ::clang::DeclContext *Val) {
2596 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2597 }
2598};
2599
2600template<class ToTy>
2601struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
2602 static ToTy *doit(::clang::DeclContext *Val) {
2603 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2604 }
2605};
2606
2607/// Implement cast_convert_val for Decl -> DeclContext conversions.
2608template<class FromTy>
2609struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
2610 static ::clang::DeclContext &doit(const FromTy &Val) {
2611 return *FromTy::castToDeclContext(&Val);
2612 }
2613};
2614
2615template<class FromTy>
2616struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
2617 static ::clang::DeclContext *doit(const FromTy *Val) {
2618 return FromTy::castToDeclContext(Val);
2619 }
2620};
2621
2622template<class FromTy>
2623struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
2624 static const ::clang::DeclContext &doit(const FromTy &Val) {
2625 return *FromTy::castToDeclContext(&Val);
2626 }
2627};
2628
2629template<class FromTy>
2630struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
2631 static const ::clang::DeclContext *doit(const FromTy *Val) {
2632 return FromTy::castToDeclContext(Val);
2633 }
2634};
2635
2636} // namespace llvm
2637
2638#endif // LLVM_CLANG_AST_DECLBASE_H

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/clang/include/clang/AST/APValue.h

1//===--- APValue.h - Union class for APFloat/APSInt/Complex -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the APValue class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_APVALUE_H
14#define LLVM_CLANG_AST_APVALUE_H
15
16#include "clang/Basic/LLVM.h"
17#include "llvm/ADT/APFixedPoint.h"
18#include "llvm/ADT/APFloat.h"
19#include "llvm/ADT/APSInt.h"
20#include "llvm/ADT/FoldingSet.h"
21#include "llvm/ADT/PointerIntPair.h"
22#include "llvm/ADT/PointerUnion.h"
23#include "llvm/Support/AlignOf.h"
24
25namespace clang {
26namespace serialization {
27template <typename T> class BasicReaderBase;
28} // end namespace serialization
29
30 class AddrLabelExpr;
31 class ASTContext;
32 class CharUnits;
33 class CXXRecordDecl;
34 class Decl;
35 class DiagnosticBuilder;
36 class Expr;
37 class FieldDecl;
38 struct PrintingPolicy;
39 class Type;
40 class ValueDecl;
41 class QualType;
42
43/// Symbolic representation of typeid(T) for some type T.
44class TypeInfoLValue {
45 const Type *T;
46
47public:
48 TypeInfoLValue() : T() {}
49 explicit TypeInfoLValue(const Type *T);
50
51 const Type *getType() const { return T; }
52 explicit operator bool() const { return T; }
53
54 void *getOpaqueValue() { return const_cast<Type*>(T); }
55 static TypeInfoLValue getFromOpaqueValue(void *Value) {
56 TypeInfoLValue V;
57 V.T = reinterpret_cast<const Type*>(Value);
58 return V;
59 }
60
61 void print(llvm::raw_ostream &Out, const PrintingPolicy &Policy) const;
62};
63
64/// Symbolic representation of a dynamic allocation.
65class DynamicAllocLValue {
66 unsigned Index;
67
68public:
69 DynamicAllocLValue() : Index(0) {}
70 explicit DynamicAllocLValue(unsigned Index) : Index(Index + 1) {}
71 unsigned getIndex() { return Index - 1; }
72
73 explicit operator bool() const { return Index != 0; }
74
75 void *getOpaqueValue() {
76 return reinterpret_cast<void *>(static_cast<uintptr_t>(Index)
77 << NumLowBitsAvailable);
78 }
79 static DynamicAllocLValue getFromOpaqueValue(void *Value) {
80 DynamicAllocLValue V;
81 V.Index = reinterpret_cast<uintptr_t>(Value) >> NumLowBitsAvailable;
82 return V;
83 }
84
85 static unsigned getMaxIndex() {
86 return (std::numeric_limits<unsigned>::max() >> NumLowBitsAvailable) - 1;
87 }
88
89 static constexpr int NumLowBitsAvailable = 3;
90};
91}
92
93namespace llvm {
94template<> struct PointerLikeTypeTraits<clang::TypeInfoLValue> {
95 static void *getAsVoidPointer(clang::TypeInfoLValue V) {
96 return V.getOpaqueValue();
97 }
98 static clang::TypeInfoLValue getFromVoidPointer(void *P) {
99 return clang::TypeInfoLValue::getFromOpaqueValue(P);
100 }
101 // Validated by static_assert in APValue.cpp; hardcoded to avoid needing
102 // to include Type.h.
103 static constexpr int NumLowBitsAvailable = 3;
104};
105
106template<> struct PointerLikeTypeTraits<clang::DynamicAllocLValue> {
107 static void *getAsVoidPointer(clang::DynamicAllocLValue V) {
108 return V.getOpaqueValue();
109 }
110 static clang::DynamicAllocLValue getFromVoidPointer(void *P) {
111 return clang::DynamicAllocLValue::getFromOpaqueValue(P);
112 }
113 static constexpr int NumLowBitsAvailable =
114 clang::DynamicAllocLValue::NumLowBitsAvailable;
115};
116}
117
118namespace clang {
119/// APValue - This class implements a discriminated union of [uninitialized]
120/// [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset],
121/// [Vector: N * APValue], [Array: N * APValue]
122class APValue {
123 typedef llvm::APFixedPoint APFixedPoint;
124 typedef llvm::APSInt APSInt;
125 typedef llvm::APFloat APFloat;
126public:
127 enum ValueKind {
128 /// There is no such object (it's outside its lifetime).
129 None,
130 /// This object has an indeterminate value (C++ [basic.indet]).
131 Indeterminate,
132 Int,
133 Float,
134 FixedPoint,
135 ComplexInt,
136 ComplexFloat,
137 LValue,
138 Vector,
139 Array,
140 Struct,
141 Union,
142 MemberPointer,
143 AddrLabelDiff
144 };
145
146 class LValueBase {
147 typedef llvm::PointerUnion<const ValueDecl *, const Expr *, TypeInfoLValue,
148 DynamicAllocLValue>
149 PtrTy;
150
151 public:
152 LValueBase() : Local{} {}
153 LValueBase(const ValueDecl *P, unsigned I = 0, unsigned V = 0);
154 LValueBase(const Expr *P, unsigned I = 0, unsigned V = 0);
155 static LValueBase getDynamicAlloc(DynamicAllocLValue LV, QualType Type);
156 static LValueBase getTypeInfo(TypeInfoLValue LV, QualType TypeInfo);
157
158 void Profile(llvm::FoldingSetNodeID &ID) const;
159
160 template <class T>
161 bool is() const { return Ptr.is<T>(); }
162
163 template <class T>
164 T get() const { return Ptr.get<T>(); }
165
166 template <class T>
167 T dyn_cast() const { return Ptr.dyn_cast<T>(); }
72
Calling 'PointerUnion::dyn_cast'
79
Returning from 'PointerUnion::dyn_cast'
80
Returning null pointer, which participates in a condition later
168
169 void *getOpaqueValue() const;
170
171 bool isNull() const;
172
173 explicit operator bool() const;
174
175 unsigned getCallIndex() const;
176 unsigned getVersion() const;
177 QualType getTypeInfoType() const;
178 QualType getDynamicAllocType() const;
179
180 QualType getType() const;
181
182 friend bool operator==(const LValueBase &LHS, const LValueBase &RHS);
183 friend bool operator!=(const LValueBase &LHS, const LValueBase &RHS) {
184 return !(LHS == RHS);
185 }
186 friend llvm::hash_code hash_value(const LValueBase &Base);
187 friend struct llvm::DenseMapInfo<LValueBase>;
188
189 private:
190 PtrTy Ptr;
191 struct LocalState {
192 unsigned CallIndex, Version;
193 };
194 union {
195 LocalState Local;
196 /// The type std::type_info, if this is a TypeInfoLValue.
197 void *TypeInfoType;
198 /// The QualType, if this is a DynamicAllocLValue.
199 void *DynamicAllocType;
200 };
201 };
202
203 /// A FieldDecl or CXXRecordDecl, along with a flag indicating whether we
204 /// mean a virtual or non-virtual base class subobject.
205 typedef llvm::PointerIntPair<const Decl *, 1, bool> BaseOrMemberType;
206
207 /// A non-discriminated union of a base, field, or array index.
208 class LValuePathEntry {
209 static_assert(sizeof(uintptr_t) <= sizeof(uint64_t),
210 "pointer doesn't fit in 64 bits?");
211 uint64_t Value;
212
213 public:
214 LValuePathEntry() : Value() {}
215 LValuePathEntry(BaseOrMemberType BaseOrMember);
216 static LValuePathEntry ArrayIndex(uint64_t Index) {
217 LValuePathEntry Result;
218 Result.Value = Index;
219 return Result;
220 }
221
222 BaseOrMemberType getAsBaseOrMember() const {
223 return BaseOrMemberType::getFromOpaqueValue(
224 reinterpret_cast<void *>(Value));
225 }
226 uint64_t getAsArrayIndex() const { return Value; }
227
228 void Profile(llvm::FoldingSetNodeID &ID) const;
229
230 friend bool operator==(LValuePathEntry A, LValuePathEntry B) {
231 return A.Value == B.Value;
232 }
233 friend bool operator!=(LValuePathEntry A, LValuePathEntry B) {
234 return A.Value != B.Value;
235 }
236 friend llvm::hash_code hash_value(LValuePathEntry A) {
237 return llvm::hash_value(A.Value);
238 }
239 };
240 class LValuePathSerializationHelper {
241 const void *ElemTy;
242
243 public:
244 ArrayRef<LValuePathEntry> Path;
245
246 LValuePathSerializationHelper(ArrayRef<LValuePathEntry>, QualType);
247 QualType getType();
248 };
249 struct NoLValuePath {};
250 struct UninitArray {};
251 struct UninitStruct {};
252
253 template <typename Impl> friend class clang::serialization::BasicReaderBase;
254 friend class ASTImporter;
255 friend class ASTNodeImporter;
256
257private:
258 ValueKind Kind;
259
260 struct ComplexAPSInt {
261 APSInt Real, Imag;
262 ComplexAPSInt() : Real(1), Imag(1) {}
263 };
264 struct ComplexAPFloat {
265 APFloat Real, Imag;
266 ComplexAPFloat() : Real(0.0), Imag(0.0) {}
267 };
268 struct LV;
269 struct Vec {
270 APValue *Elts;
271 unsigned NumElts;
272 Vec() : Elts(nullptr), NumElts(0) {}
273 ~Vec() { delete[] Elts; }
274 };
275 struct Arr {
276 APValue *Elts;
277 unsigned NumElts, ArrSize;
278 Arr(unsigned NumElts, unsigned ArrSize);
279 ~Arr();
280 };
281 struct StructData {
282 APValue *Elts;
283 unsigned NumBases;
284 unsigned NumFields;
285 StructData(unsigned NumBases, unsigned NumFields);
286 ~StructData();
287 };
288 struct UnionData {
289 const FieldDecl *Field;
290 APValue *Value;
291 UnionData();
292 ~UnionData();
293 };
294 struct AddrLabelDiffData {
295 const AddrLabelExpr* LHSExpr;
296 const AddrLabelExpr* RHSExpr;
297 };
298 struct MemberPointerData;
299
300 // We ensure elsewhere that Data is big enough for LV and MemberPointerData.
301 typedef llvm::AlignedCharArrayUnion<void *, APSInt, APFloat, ComplexAPSInt,
302 ComplexAPFloat, Vec, Arr, StructData,
303 UnionData, AddrLabelDiffData> DataType;
304 static const size_t DataSize = sizeof(DataType);
305
306 DataType Data;
307
308public:
309 APValue() : Kind(None) {}
310 explicit APValue(APSInt I) : Kind(None) {
311 MakeInt(); setInt(std::move(I));
312 }
313 explicit APValue(APFloat F) : Kind(None) {
314 MakeFloat(); setFloat(std::move(F));
315 }
316 explicit APValue(APFixedPoint FX) : Kind(None) {
317 MakeFixedPoint(std::move(FX));
318 }
319 explicit APValue(const APValue *E, unsigned N) : Kind(None) {
320 MakeVector(); setVector(E, N);
321 }
322 APValue(APSInt R, APSInt I) : Kind(None) {
323 MakeComplexInt(); setComplexInt(std::move(R), std::move(I));
324 }
325 APValue(APFloat R, APFloat I) : Kind(None) {
326 MakeComplexFloat(); setComplexFloat(std::move(R), std::move(I));
327 }
328 APValue(const APValue &RHS);
329 APValue(APValue &&RHS);
330 APValue(LValueBase B, const CharUnits &O, NoLValuePath N,
331 bool IsNullPtr = false)
332 : Kind(None) {
333 MakeLValue(); setLValue(B, O, N, IsNullPtr);
334 }
335 APValue(LValueBase B, const CharUnits &O, ArrayRef<LValuePathEntry> Path,
336 bool OnePastTheEnd, bool IsNullPtr = false)
337 : Kind(None) {
338 MakeLValue(); setLValue(B, O, Path, OnePastTheEnd, IsNullPtr);
339 }
340 APValue(UninitArray, unsigned InitElts, unsigned Size) : Kind(None) {
341 MakeArray(InitElts, Size);
342 }
343 APValue(UninitStruct, unsigned B, unsigned M) : Kind(None) {
344 MakeStruct(B, M);
345 }
346 explicit APValue(const FieldDecl *D, const APValue &V = APValue())
347 : Kind(None) {
348 MakeUnion(); setUnion(D, V);
349 }
350 APValue(const ValueDecl *Member, bool IsDerivedMember,
351 ArrayRef<const CXXRecordDecl*> Path) : Kind(None) {
352 MakeMemberPointer(Member, IsDerivedMember, Path);
353 }
354 APValue(const AddrLabelExpr* LHSExpr, const AddrLabelExpr* RHSExpr)
355 : Kind(None) {
356 MakeAddrLabelDiff(); setAddrLabelDiff(LHSExpr, RHSExpr);
357 }
358 static APValue IndeterminateValue() {
359 APValue Result;
360 Result.Kind = Indeterminate;
361 return Result;
362 }
363
364 APValue &operator=(const APValue &RHS);
365 APValue &operator=(APValue &&RHS);
366
367 ~APValue() {
368 if (Kind != None && Kind != Indeterminate)
369 DestroyDataAndMakeUninit();
370 }
371
372 /// Returns whether the object performed allocations.
373 ///
374 /// If APValues are constructed via placement new, \c needsCleanup()
375 /// indicates whether the destructor must be called in order to correctly
376 /// free all allocated memory.
377 bool needsCleanup() const;
378
379 /// Swaps the contents of this and the given APValue.
380 void swap(APValue &RHS);
381
382 /// profile this value. There is no guarantee that values of different
383 /// types will not produce the same profiled value, so the type should
384 /// typically also be profiled if it's not implied by the context.
385 void Profile(llvm::FoldingSetNodeID &ID) const;
386
387 ValueKind getKind() const { return Kind; }
388
389 bool isAbsent() const { return Kind == None; }
390 bool isIndeterminate() const { return Kind == Indeterminate; }
391 bool hasValue() const { return Kind != None && Kind != Indeterminate; }
392
393 bool isInt() const { return Kind == Int; }
394 bool isFloat() const { return Kind == Float; }
395 bool isFixedPoint() const { return Kind == FixedPoint; }
396 bool isComplexInt() const { return Kind == ComplexInt; }
397 bool isComplexFloat() const { return Kind == ComplexFloat; }
398 bool isLValue() const { return Kind == LValue; }
399 bool isVector() const { return Kind == Vector; }
400 bool isArray() const { return Kind == Array; }
401 bool isStruct() const { return Kind == Struct; }
402 bool isUnion() const { return Kind == Union; }
403 bool isMemberPointer() const { return Kind == MemberPointer; }
404 bool isAddrLabelDiff() const { return Kind == AddrLabelDiff; }
405
406 void dump() const;
407 void dump(raw_ostream &OS, const ASTContext &Context) const;
408
409 void printPretty(raw_ostream &OS, const ASTContext &Ctx, QualType Ty) const;
410 void printPretty(raw_ostream &OS, const PrintingPolicy &Policy, QualType Ty,
411 const ASTContext *Ctx = nullptr) const;
412
413 std::string getAsString(const ASTContext &Ctx, QualType Ty) const;
414
415 APSInt &getInt() {
416 assert(isInt() && "Invalid accessor")((void)0);
417 return *(APSInt *)(char *)&Data;
418 }
419 const APSInt &getInt() const {
420 return const_cast<APValue*>(this)->getInt();
421 }
422
423 /// Try to convert this value to an integral constant. This works if it's an
424 /// integer, null pointer, or offset from a null pointer. Returns true on
425 /// success.
426 bool toIntegralConstant(APSInt &Result, QualType SrcTy,
427 const ASTContext &Ctx) const;
428
429 APFloat &getFloat() {
430 assert(isFloat() && "Invalid accessor")((void)0);
431 return *(APFloat *)(char *)&Data;
432 }
433 const APFloat &getFloat() const {
434 return const_cast<APValue*>(this)->getFloat();
435 }
436
437 APFixedPoint &getFixedPoint() {
438 assert(isFixedPoint() && "Invalid accessor")((void)0);
439 return *(APFixedPoint *)(char *)&Data;
440 }
441 const APFixedPoint &getFixedPoint() const {
442 return const_cast<APValue *>(this)->getFixedPoint();
443 }
444
445 APSInt &getComplexIntReal() {
446 assert(isComplexInt() && "Invalid accessor")((void)0);
447 return ((ComplexAPSInt *)(char *)&Data)->Real;
448 }
449 const APSInt &getComplexIntReal() const {
450 return const_cast<APValue*>(this)->getComplexIntReal();
451 }
452
453 APSInt &getComplexIntImag() {
454 assert(isComplexInt() && "Invalid accessor")((void)0);
455 return ((ComplexAPSInt *)(char *)&Data)->Imag;
456 }
457 const APSInt &getComplexIntImag() const {
458 return const_cast<APValue*>(this)->getComplexIntImag();
459 }
460
461 APFloat &getComplexFloatReal() {
462 assert(isComplexFloat() && "Invalid accessor")((void)0);
463 return ((ComplexAPFloat *)(char *)&Data)->Real;
464 }
465 const APFloat &getComplexFloatReal() const {
466 return const_cast<APValue*>(this)->getComplexFloatReal();
467 }
468
469 APFloat &getComplexFloatImag() {
470 assert(isComplexFloat() && "Invalid accessor")((void)0);
471 return ((ComplexAPFloat *)(char *)&Data)->Imag;
472 }
473 const APFloat &getComplexFloatImag() const {
474 return const_cast<APValue*>(this)->getComplexFloatImag();
475 }
476
477 const LValueBase getLValueBase() const;
478 CharUnits &getLValueOffset();
479 const CharUnits &getLValueOffset() const {
480 return const_cast<APValue*>(this)->getLValueOffset();
481 }
482 bool isLValueOnePastTheEnd() const;
483 bool hasLValuePath() const;
484 ArrayRef<LValuePathEntry> getLValuePath() const;
485 unsigned getLValueCallIndex() const;
486 unsigned getLValueVersion() const;
487 bool isNullPointer() const;
488
489 APValue &getVectorElt(unsigned I) {
490 assert(isVector() && "Invalid accessor")((void)0);
491 assert(I < getVectorLength() && "Index out of range")((void)0);
492 return ((Vec *)(char *)&Data)->Elts[I];
493 }
494 const APValue &getVectorElt(unsigned I) const {
495 return const_cast<APValue*>(this)->getVectorElt(I);
496 }
497 unsigned getVectorLength() const {
498 assert(isVector() && "Invalid accessor")((void)0);
499 return ((const Vec *)(const void *)&Data)->NumElts;
500 }
501
502 APValue &getArrayInitializedElt(unsigned I) {
503 assert(isArray() && "Invalid accessor")((void)0);
504 assert(I < getArrayInitializedElts() && "Index out of range")((void)0);
505 return ((Arr *)(char *)&Data)->Elts[I];
506 }
507 const APValue &getArrayInitializedElt(unsigned I) const {
508 return const_cast<APValue*>(this)->getArrayInitializedElt(I);
509 }
510 bool hasArrayFiller() const {
511 return getArrayInitializedElts() != getArraySize();
512 }
513 APValue &getArrayFiller() {
514 assert(isArray() && "Invalid accessor")((void)0);
515 assert(hasArrayFiller() && "No array filler")((void)0);
516 return ((Arr *)(char *)&Data)->Elts[getArrayInitializedElts()];
517 }
518 const APValue &getArrayFiller() const {
519 return const_cast<APValue*>(this)->getArrayFiller();
520 }
521 unsigned getArrayInitializedElts() const {
522 assert(isArray() && "Invalid accessor")((void)0);
523 return ((const Arr *)(const void *)&Data)->NumElts;
524 }
525 unsigned getArraySize() const {
526 assert(isArray() && "Invalid accessor")((void)0);
527 return ((const Arr *)(const void *)&Data)->ArrSize;
528 }
529
530 unsigned getStructNumBases() const {
531 assert(isStruct() && "Invalid accessor")((void)0);
532 return ((const StructData *)(const char *)&Data)->NumBases;
533 }
534 unsigned getStructNumFields() const {
535 assert(isStruct() && "Invalid accessor")((void)0);
536 return ((const StructData *)(const char *)&Data)->NumFields;
537 }
538 APValue &getStructBase(unsigned i) {
539 assert(isStruct() && "Invalid accessor")((void)0);
540 assert(i < getStructNumBases() && "base class index OOB")((void)0);
541 return ((StructData *)(char *)&Data)->Elts[i];
542 }
543 APValue &getStructField(unsigned i) {
544 assert(isStruct() && "Invalid accessor")((void)0);
545 assert(i < getStructNumFields() && "field index OOB")((void)0);
546 return ((StructData *)(char *)&Data)->Elts[getStructNumBases() + i];
547 }
548 const APValue &getStructBase(unsigned i) const {
549 return const_cast<APValue*>(this)->getStructBase(i);
550 }
551 const APValue &getStructField(unsigned i) const {
552 return const_cast<APValue*>(this)->getStructField(i);
553 }
554
555 const FieldDecl *getUnionField() const {
556 assert(isUnion() && "Invalid accessor")((void)0);
557 return ((const UnionData *)(const char *)&Data)->Field;
558 }
559 APValue &getUnionValue() {
560 assert(isUnion() && "Invalid accessor")((void)0);
561 return *((UnionData *)(char *)&Data)->Value;
562 }
563 const APValue &getUnionValue() const {
564 return const_cast<APValue*>(this)->getUnionValue();
565 }
566
567 const ValueDecl *getMemberPointerDecl() const;
568 bool isMemberPointerToDerivedMember() const;
569 ArrayRef<const CXXRecordDecl*> getMemberPointerPath() const;
570
571 const AddrLabelExpr* getAddrLabelDiffLHS() const {
572 assert(isAddrLabelDiff() && "Invalid accessor")((void)0);
573 return ((const AddrLabelDiffData *)(const char *)&Data)->LHSExpr;
574 }
575 const AddrLabelExpr* getAddrLabelDiffRHS() const {
576 assert(isAddrLabelDiff() && "Invalid accessor")((void)0);
577 return ((const AddrLabelDiffData *)(const char *)&Data)->RHSExpr;
578 }
579
580 void setInt(APSInt I) {
581 assert(isInt() && "Invalid accessor")((void)0);
582 *(APSInt *)(char *)&Data = std::move(I);
583 }
584 void setFloat(APFloat F) {
585 assert(isFloat() && "Invalid accessor")((void)0);
586 *(APFloat *)(char *)&Data = std::move(F);
587 }
588 void setFixedPoint(APFixedPoint FX) {
589 assert(isFixedPoint() && "Invalid accessor")((void)0);
590 *(APFixedPoint *)(char *)&Data = std::move(FX);
591 }
592 void setVector(const APValue *E, unsigned N) {
593 MutableArrayRef<APValue> InternalElts = setVectorUninit(N);
594 for (unsigned i = 0; i != N; ++i)
595 InternalElts[i] = E[i];
596 }
597 void setComplexInt(APSInt R, APSInt I) {
598 assert(R.getBitWidth() == I.getBitWidth() &&((void)0)
599 "Invalid complex int (type mismatch).")((void)0);
600 assert(isComplexInt() && "Invalid accessor")((void)0);
601 ((ComplexAPSInt *)(char *)&Data)->Real = std::move(R);
602 ((ComplexAPSInt *)(char *)&Data)->Imag = std::move(I);
603 }
604 void setComplexFloat(APFloat R, APFloat I) {
605 assert(&R.getSemantics() == &I.getSemantics() &&((void)0)
606 "Invalid complex float (type mismatch).")((void)0);
607 assert(isComplexFloat() && "Invalid accessor")((void)0);
608 ((ComplexAPFloat *)(char *)&Data)->Real = std::move(R);
609 ((ComplexAPFloat *)(char *)&Data)->Imag = std::move(I);
610 }
611 void setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
612 bool IsNullPtr);
613 void setLValue(LValueBase B, const CharUnits &O,
614 ArrayRef<LValuePathEntry> Path, bool OnePastTheEnd,
615 bool IsNullPtr);
616 void setUnion(const FieldDecl *Field, const APValue &Value);
617 void setAddrLabelDiff(const AddrLabelExpr* LHSExpr,
618 const AddrLabelExpr* RHSExpr) {
619 ((AddrLabelDiffData *)(char *)&Data)->LHSExpr = LHSExpr;
620 ((AddrLabelDiffData *)(char *)&Data)->RHSExpr = RHSExpr;
621 }
622
623private:
624 void DestroyDataAndMakeUninit();
625 void MakeInt() {
626 assert(isAbsent() && "Bad state change")((void)0);
627 new ((void *)&Data) APSInt(1);
628 Kind = Int;
629 }
630 void MakeFloat() {
631 assert(isAbsent() && "Bad state change")((void)0);
632 new ((void *)(char *)&Data) APFloat(0.0);
633 Kind = Float;
634 }
635 void MakeFixedPoint(APFixedPoint &&FX) {
636 assert(isAbsent() && "Bad state change")((void)0);
637 new ((void *)(char *)&Data) APFixedPoint(std::move(FX));
638 Kind = FixedPoint;
639 }
640 void MakeVector() {
641 assert(isAbsent() && "Bad state change")((void)0);
642 new ((void *)(char *)&Data) Vec();
643 Kind = Vector;
644 }
645 void MakeComplexInt() {
646 assert(isAbsent() && "Bad state change")((void)0);
647 new ((void *)(char *)&Data) ComplexAPSInt();
648 Kind = ComplexInt;
649 }
650 void MakeComplexFloat() {
651 assert(isAbsent() && "Bad state change")((void)0);
652 new ((void *)(char *)&Data) ComplexAPFloat();
653 Kind = ComplexFloat;
654 }
655 void MakeLValue();
656 void MakeArray(unsigned InitElts, unsigned Size);
657 void MakeStruct(unsigned B, unsigned M) {
658 assert(isAbsent() && "Bad state change")((void)0);
659 new ((void *)(char *)&Data) StructData(B, M);
660 Kind = Struct;
661 }
662 void MakeUnion() {
663 assert(isAbsent() && "Bad state change")((void)0);
664 new ((void *)(char *)&Data) UnionData();
665 Kind = Union;
666 }
667 void MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
668 ArrayRef<const CXXRecordDecl*> Path);
669 void MakeAddrLabelDiff() {
670 assert(isAbsent() && "Bad state change")((void)0);
671 new ((void *)(char *)&Data) AddrLabelDiffData();
672 Kind = AddrLabelDiff;
673 }
674
675private:
676 /// The following functions are used as part of initialization, during
677 /// deserialization and importing. Reserve the space so that it can be
678 /// filled in by those steps.
679 MutableArrayRef<APValue> setVectorUninit(unsigned N) {
680 assert(isVector() && "Invalid accessor")((void)0);
681 Vec *V = ((Vec *)(char *)&Data);
682 V->Elts = new APValue[N];
683 V->NumElts = N;
684 return {V->Elts, V->NumElts};
685 }
686 MutableArrayRef<LValuePathEntry>
687 setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size,
688 bool OnePastTheEnd, bool IsNullPtr);
689 MutableArrayRef<const CXXRecordDecl *>
690 setMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember,
691 unsigned Size);
692};
693
694} // end namespace clang.
695
696namespace llvm {
697template<> struct DenseMapInfo<clang::APValue::LValueBase> {
698 static clang::APValue::LValueBase getEmptyKey();
699 static clang::APValue::LValueBase getTombstoneKey();
700 static unsigned getHashValue(const clang::APValue::LValueBase &Base);
701 static bool isEqual(const clang::APValue::LValueBase &LHS,
702 const clang::APValue::LValueBase &RHS);
703};
704}
705
706#endif

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/ADT/PointerUnion.h

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23
24namespace llvm {
25
26template <typename T> struct PointerUnionTypeSelectorReturn {
27 using Return = T;
28};
29
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35/// using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41 using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46 using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51 PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52 using Return =
53 typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55
56namespace pointer_union_detail {
57 /// Determine the number of bits required to store integers with values < n.
58 /// This is ceil(log2(n)).
59 constexpr int bitsRequired(unsigned n) {
60 return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61 }
62
63 template <typename... Ts> constexpr int lowBitsAvailable() {
64 return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65 }
66
67 /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68 /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69 /// list.
70 template <typename T, typename ...Us> struct TypeIndex;
71 template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72 static constexpr int Index = 0;
73 };
74 template <typename T, typename U, typename... Us>
75 struct TypeIndex<T, U, Us...> {
76 static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77 };
78 template <typename T> struct TypeIndex<T> {
79 static constexpr int Index = 0;
80 };
81
82 /// Find the first type in a list of types.
83 template <typename T, typename...> struct GetFirstType {
84 using type = T;
85 };
86
87 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88 /// for the template arguments.
89 template <typename ...PTs> class PointerUnionUIntTraits {
90 public:
91 static inline void *getAsVoidPointer(void *P) { return P; }
92 static inline void *getFromVoidPointer(void *P) { return P; }
93 static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94 };
95
96 template <typename Derived, typename ValTy, int I, typename ...Types>
97 class PointerUnionMembers;
98
99 template <typename Derived, typename ValTy, int I>
100 class PointerUnionMembers<Derived, ValTy, I> {
101 protected:
102 ValTy Val;
103 PointerUnionMembers() = default;
104 PointerUnionMembers(ValTy Val) : Val(Val) {}
105
106 friend struct PointerLikeTypeTraits<Derived>;
107 };
108
109 template <typename Derived, typename ValTy, int I, typename Type,
110 typename ...Types>
111 class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
112 : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
113 using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
114 public:
115 using Base::Base;
116 PointerUnionMembers() = default;
117 PointerUnionMembers(Type V)
118 : Base(ValTy(const_cast<void *>(
119 PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
120 I)) {}
121
122 using Base::operator=;
123 Derived &operator=(Type V) {
124 this->Val = ValTy(
125 const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
126 I);
127 return static_cast<Derived &>(*this);
128 };
129 };
130}
131
132/// A discriminated union of two or more pointer types, with the discriminator
133/// in the low bit of the pointer.
134///
135/// This implementation is extremely efficient in space due to leveraging the
136/// low bits of the pointer, while exposing a natural and type-safe API.
137///
138/// Common use patterns would be something like this:
139/// PointerUnion<int*, float*> P;
140/// P = (int*)0;
141/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"
142/// X = P.get<int*>(); // ok.
143/// Y = P.get<float*>(); // runtime assertion failure.
144/// Z = P.get<double*>(); // compile time failure.
145/// P = (float*)0;
146/// Y = P.get<float*>(); // ok.
147/// X = P.get<int*>(); // runtime assertion failure.
148template <typename... PTs>
149class PointerUnion
150 : public pointer_union_detail::PointerUnionMembers<
151 PointerUnion<PTs...>,
152 PointerIntPair<
153 void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
154 pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
155 0, PTs...> {
156 // The first type is special because we want to directly cast a pointer to a
157 // default-initialized union to a pointer to the first type. But we don't
158 // want PointerUnion to be a 'template <typename First, typename ...Rest>'
159 // because it's much more convenient to have a name for the whole pack. So
160 // split off the first type here.
161 using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
162 using Base = typename PointerUnion::PointerUnionMembers;
163
164public:
165 PointerUnion() = default;
166
167 PointerUnion(std::nullptr_t) : PointerUnion() {}
168 using Base::Base;
169
170 /// Test if the pointer held in the union is null, regardless of
171 /// which type it is.
172 bool isNull() const { return !this->Val.getPointer(); }
173
174 explicit operator bool() const { return !isNull(); }
175
176 /// Test if the Union currently holds the type matching T.
177 template <typename T> bool is() const {
178 constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
179 static_assert(Index < sizeof...(PTs),
180 "PointerUnion::is<T> given type not in the union");
181 return this->Val.getInt() == Index;
74
Assuming the condition is false
75
Returning zero, which participates in a condition later
182 }
183
184 /// Returns the value of the specified pointer type.
185 ///
186 /// If the specified pointer type is incorrect, assert.
187 template <typename T> T get() const {
188 assert(is<T>() && "Invalid accessor called")((void)0);
189 return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
190 }
191
192 /// Returns the current pointer if it is of the specified pointer type,
193 /// otherwise returns null.
194 template <typename T> T dyn_cast() const {
195 if (is<T>())
73
Calling 'PointerUnion::is'
76
Returning from 'PointerUnion::is'
77
Taking false branch
196 return get<T>();
197 return T();
78
Returning null pointer, which participates in a condition later
198 }
199
200 /// If the union is set to the first pointer type get an address pointing to
201 /// it.
202 First const *getAddrOfPtr1() const {
203 return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
204 }
205
206 /// If the union is set to the first pointer type get an address pointing to
207 /// it.
208 First *getAddrOfPtr1() {
209 assert(is<First>() && "Val is not the first pointer")((void)0);
210 assert(((void)0)
211 PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((void)0)
212 this->Val.getPointer() &&((void)0)
213 "Can't get the address because PointerLikeTypeTraits changes the ptr")((void)0);
214 return const_cast<First *>(
215 reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
216 }
217
218 /// Assignment from nullptr which just clears the union.
219 const PointerUnion &operator=(std::nullptr_t) {
220 this->Val.initWithPointer(nullptr);
221 return *this;
222 }
223
224 /// Assignment from elements of the union.
225 using Base::operator=;
226
227 void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
228 static inline PointerUnion getFromOpaqueValue(void *VP) {
229 PointerUnion V;
230 V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
231 return V;
232 }
233};
234
235template <typename ...PTs>
236bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
237 return lhs.getOpaqueValue() == rhs.getOpaqueValue();
238}
239
240template <typename ...PTs>
241bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
242 return lhs.getOpaqueValue() != rhs.getOpaqueValue();
243}
244
245template <typename ...PTs>
246bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
247 return lhs.getOpaqueValue() < rhs.getOpaqueValue();
248}
249
250// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
251// # low bits available = min(PT1bits,PT2bits)-1.
252template <typename ...PTs>
253struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
254 static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
255 return P.getOpaqueValue();
256 }
257
258 static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
259 return PointerUnion<PTs...>::getFromOpaqueValue(P);
260 }
261
262 // The number of bits available are the min of the pointer types minus the
263 // bits needed for the discriminator.
264 static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
265 PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
266};
267
268// Teach DenseMap how to use PointerUnions as keys.
269template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
270 using Union = PointerUnion<PTs...>;
271 using FirstInfo =
272 DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
273
274 static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
275
276 static inline Union getTombstoneKey() {
277 return Union(FirstInfo::getTombstoneKey());
278 }
279
280 static unsigned getHashValue(const Union &UnionVal) {
281 intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
282 return DenseMapInfo<intptr_t>::getHashValue(key);
283 }
284
285 static bool isEqual(const Union &LHS, const Union &RHS) {
286 return LHS == RHS;
287 }
288};
289
290} // end namespace llvm
291
292#endif // LLVM_ADT_POINTERUNION_H

/usr/src/gnu/usr.bin/clang/libclangAST/../../../llvm/llvm/include/llvm/ADT/SmallVector.h

1//===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the SmallVector class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_ADT_SMALLVECTOR_H
14#define LLVM_ADT_SMALLVECTOR_H
15
16#include "llvm/ADT/iterator_range.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/ErrorHandling.h"
19#include "llvm/Support/MemAlloc.h"
20#include "llvm/Support/type_traits.h"
21#include <algorithm>
22#include <cassert>
23#include <cstddef>
24#include <cstdlib>
25#include <cstring>
26#include <functional>
27#include <initializer_list>
28#include <iterator>
29#include <limits>
30#include <memory>
31#include <new>
32#include <type_traits>
33#include <utility>
34
35namespace llvm {
36
37/// This is all the stuff common to all SmallVectors.
38///
39/// The template parameter specifies the type which should be used to hold the
40/// Size and Capacity of the SmallVector, so it can be adjusted.
41/// Using 32 bit size is desirable to shrink the size of the SmallVector.
42/// Using 64 bit size is desirable for cases like SmallVector<char>, where a
43/// 32 bit size would limit the vector to ~4GB. SmallVectors are used for
44/// buffering bitcode output - which can exceed 4GB.
45template <class Size_T> class SmallVectorBase {
46protected:
47 void *BeginX;
48 Size_T Size = 0, Capacity;
49
50 /// The maximum value of the Size_T used.
51 static constexpr size_t SizeTypeMax() {
52 return std::numeric_limits<Size_T>::max();
53 }
54
55 SmallVectorBase() = delete;
56 SmallVectorBase(void *FirstEl, size_t TotalCapacity)
57 : BeginX(FirstEl), Capacity(TotalCapacity) {}
58
59 /// This is a helper for \a grow() that's out of line to reduce code
60 /// duplication. This function will report a fatal error if it can't grow at
61 /// least to \p MinSize.
62 void *mallocForGrow(size_t MinSize, size_t TSize, size_t &NewCapacity);
63
64 /// This is an implementation of the grow() method which only works
65 /// on POD-like data types and is out of line to reduce code duplication.
66 /// This function will report a fatal error if it cannot increase capacity.
67 void grow_pod(void *FirstEl, size_t MinSize, size_t TSize);
68
69public:
70 size_t size() const { return Size; }
71 size_t capacity() const { return Capacity; }
72
73 LLVM_NODISCARD[[clang::warn_unused_result]] bool empty() const { return !Size; }
98
Assuming field 'Size' is not equal to 0, which participates in a condition later
99
Returning zero, which participates in a condition later
74
75 /// Set the array size to \p N, which the current array must have enough
76 /// capacity for.
77 ///
78 /// This does not construct or destroy any elements in the vector.
79 ///
80 /// Clients can use this in conjunction with capacity() to write past the end
81 /// of the buffer when they know that more elements are available, and only
82 /// update the size later. This avoids the cost of value initializing elements
83 /// which will only be overwritten.
84 void set_size(size_t N) {
85 assert(N <= capacity())((void)0);
86 Size = N;
87 }
88};
89
90template <class T>
91using SmallVectorSizeType =
92 typename std::conditional<sizeof(T) < 4 && sizeof(void *) >= 8, uint64_t,
93 uint32_t>::type;
94
95/// Figure out the offset of the first element.
96template <class T, typename = void> struct SmallVectorAlignmentAndSize {
97 alignas(SmallVectorBase<SmallVectorSizeType<T>>) char Base[sizeof(
98 SmallVectorBase<SmallVectorSizeType<T>>)];
99 alignas(T) char FirstEl[sizeof(T)];
100};
101
102/// This is the part of SmallVectorTemplateBase which does not depend on whether
103/// the type T is a POD. The extra dummy template argument is used by ArrayRef
104/// to avoid unnecessarily requiring T to be complete.
105template <typename T, typename = void>
106class SmallVectorTemplateCommon
107 : public SmallVectorBase<SmallVectorSizeType<T>> {
108 using Base = SmallVectorBase<SmallVectorSizeType<T>>;
109
110 /// Find the address of the first element. For this pointer math to be valid
111 /// with small-size of 0 for T with lots of alignment, it's important that
112 /// SmallVectorStorage is properly-aligned even for small-size of 0.
113 void *getFirstEl() const {
114 return const_cast<void *>(reinterpret_cast<const void *>(
115 reinterpret_cast<const char *>(this) +
116 offsetof(SmallVectorAlignmentAndSize<T>, FirstEl)__builtin_offsetof(SmallVectorAlignmentAndSize<T>, FirstEl
)
));
117 }
118 // Space after 'FirstEl' is clobbered, do not add any instance vars after it.
119
120protected:
121 SmallVectorTemplateCommon(size_t Size) : Base(getFirstEl(), Size) {}
122
123 void grow_pod(size_t MinSize, size_t TSize) {
124 Base::grow_pod(getFirstEl(), MinSize, TSize);
125 }
126
127 /// Return true if this is a smallvector which has not had dynamic
128 /// memory allocated for it.
129 bool isSmall() const { return this->BeginX == getFirstEl(); }
130
131 /// Put this vector in a state of being small.
132 void resetToSmall() {
133 this->BeginX = getFirstEl();
134 this->Size = this->Capacity = 0; // FIXME: Setting Capacity to 0 is suspect.
135 }
136
137 /// Return true if V is an internal reference to the given range.
138 bool isReferenceToRange(const void *V, const void *First, const void *Last) const {
139 // Use std::less to avoid UB.
140 std::less<> LessThan;
141 return !LessThan(V, First) && LessThan(V, Last);
142 }
143
144 /// Return true if V is an internal reference to this vector.
145 bool isReferenceToStorage(const void *V) const {
146 return isReferenceToRange(V, this->begin(), this->end());
147 }
148
149 /// Return true if First and Last form a valid (possibly empty) range in this
150 /// vector's storage.
151 bool isRangeInStorage(const void *First, const void *Last) const {
152 // Use std::less to avoid UB.
153 std::less<> LessThan;
154 return !LessThan(First, this->begin()) && !LessThan(Last, First) &&
155 !LessThan(this->end(), Last);
156 }
157
158 /// Return true unless Elt will be invalidated by resizing the vector to
159 /// NewSize.
160 bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
161 // Past the end.
162 if (LLVM_LIKELY(!isReferenceToStorage(Elt))__builtin_expect((bool)(!isReferenceToStorage(Elt)), true))
163 return true;
164
165 // Return false if Elt will be destroyed by shrinking.
166 if (NewSize <= this->size())
167 return Elt < this->begin() + NewSize;
168
169 // Return false if we need to grow.
170 return NewSize <= this->capacity();
171 }
172
173 /// Check whether Elt will be invalidated by resizing the vector to NewSize.
174 void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize) {
175 assert(isSafeToReferenceAfterResize(Elt, NewSize) &&((void)0)
176 "Attempting to reference an element of the vector in an operation "((void)0)
177 "that invalidates it")((void)0);
178 }
179
180 /// Check whether Elt will be invalidated by increasing the size of the
181 /// vector by N.
182 void assertSafeToAdd(const void *Elt, size_t N = 1) {
183 this->assertSafeToReferenceAfterResize(Elt, this->size() + N);
184 }
185
186 /// Check whether any part of the range will be invalidated by clearing.
187 void assertSafeToReferenceAfterClear(const T *From, const T *To) {
188 if (From == To)
189 return;
190 this->assertSafeToReferenceAfterResize(From, 0);
191 this->assertSafeToReferenceAfterResize(To - 1, 0);
192 }
193 template <
194 class ItTy,
195 std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
196 bool> = false>
197 void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
198
199 /// Check whether any part of the range will be invalidated by growing.
200 void assertSafeToAddRange(const T *From, const T *To) {
201 if (From == To)
202 return;
203 this->assertSafeToAdd(From, To - From);
204 this->assertSafeToAdd(To - 1, To - From);
205 }
206 template <
207 class ItTy,
208 std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
209 bool> = false>
210 void assertSafeToAddRange(ItTy, ItTy) {}
211
212 /// Reserve enough space to add one element, and return the updated element
213 /// pointer in case it was a reference to the storage.
214 template <class U>
215 static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
216 size_t N) {
217 size_t NewSize = This->size() + N;
218 if (LLVM_LIKELY(NewSize <= This->capacity())__builtin_expect((bool)(NewSize <= This->capacity()), true
)
)
219 return &Elt;
220
221 bool ReferencesStorage = false;
222 int64_t Index = -1;
223 if (!U::TakesParamByValue) {
224 if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))__builtin_expect((bool)(This->isReferenceToStorage(&Elt
)), false)
) {
225 ReferencesStorage = true;
226 Index = &Elt - This->begin();
227 }
228 }
229 This->grow(NewSize);
230 return ReferencesStorage ? This->begin() + Index : &Elt;
231 }
232
233public:
234 using size_type = size_t;
235 using difference_type = ptrdiff_t;
236 using value_type = T;
237 using iterator = T *;
238 using const_iterator = const T *;
239
240 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
241 using reverse_iterator = std::reverse_iterator<iterator>;
242
243 using reference = T &;
244 using const_reference = const T &;
245 using pointer = T *;
246 using const_pointer = const T *;
247
248 using Base::capacity;
249 using Base::empty;
250 using Base::size;
251
252 // forward iterator creation methods.
253 iterator begin() { return (iterator)this->BeginX; }
254 const_iterator begin() const { return (const_iterator)this->BeginX; }
255 iterator end() { return begin() + size(); }
256 const_iterator end() const { return begin() + size(); }
257
258 // reverse iterator creation methods.
259 reverse_iterator rbegin() { return reverse_iterator(end()); }
260 const_reverse_iterator rbegin() const{ return const_reverse_iterator(end()); }
261 reverse_iterator rend() { return reverse_iterator(begin()); }
262 const_reverse_iterator rend() const { return const_reverse_iterator(begin());}
263
264 size_type size_in_bytes() const { return size() * sizeof(T); }
265 size_type max_size() const {
266 return std::min(this->SizeTypeMax(), size_type(-1) / sizeof(T));
267 }
268
269 size_t capacity_in_bytes() const { return capacity() * sizeof(T); }
270
271 /// Return a pointer to the vector's buffer, even if empty().
272 pointer data() { return pointer(begin()); }
273 /// Return a pointer to the vector's buffer, even if empty().
274 const_pointer data() const { return const_pointer(begin()); }
275
276 reference operator[](size_type idx) {
277 assert(idx < size())((void)0);
278 return begin()[idx];
279 }
280 const_reference operator[](size_type idx) const {
281 assert(idx < size())((void)0);
282 return begin()[idx];
283 }
284
285 reference front() {
286 assert(!empty())((void)0);
287 return begin()[0];
288 }
289 const_reference front() const {
290 assert(!empty())((void)0);
291 return begin()[0];
292 }
293
294 reference back() {
295 assert(!empty())((void)0);
296 return end()[-1];
297 }
298 const_reference back() const {
299 assert(!empty())((void)0);
300 return end()[-1];
301 }
302};
303
304/// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
305/// method implementations that are designed to work with non-trivial T's.
306///
307/// We approximate is_trivially_copyable with trivial move/copy construction and
308/// trivial destruction. While the standard doesn't specify that you're allowed
309/// copy these types with memcpy, there is no way for the type to observe this.
310/// This catches the important case of std::pair<POD, POD>, which is not
311/// trivially assignable.
312template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
313 (is_trivially_move_constructible<T>::value) &&
314 std::is_trivially_destructible<T>::value>
315class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
316 friend class SmallVectorTemplateCommon<T>;
317
318protected:
319 static constexpr bool TakesParamByValue = false;
320 using ValueParamT = const T &;
321
322 SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
323
324 static void destroy_range(T *S, T *E) {
325 while (S != E) {
326 --E;
327 E->~T();
328 }
329 }
330
331 /// Move the range [I, E) into the uninitialized memory starting with "Dest",
332 /// constructing elements as needed.
333 template<typename It1, typename It2>
334 static void uninitialized_move(It1 I, It1 E, It2 Dest) {
335 std::uninitialized_copy(std::make_move_iterator(I),
336 std::make_move_iterator(E), Dest);
337 }
338
339 /// Copy the range [I, E) onto the uninitialized memory starting with "Dest",
340 /// constructing elements as needed.
341 template<typename It1, typename It2>
342 static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
343 std::uninitialized_copy(I, E, Dest);
344 }
345
346 /// Grow the allocated memory (without initializing new elements), doubling
347 /// the size of the allocated memory. Guarantees space for at least one more
348 /// element, or MinSize more elements if specified.
349 void grow(size_t MinSize = 0);
350
351 /// Create a new allocation big enough for \p MinSize and pass back its size
352 /// in \p NewCapacity. This is the first section of \a grow().
353 T *mallocForGrow(size_t MinSize, size_t &NewCapacity) {
354 return static_cast<T *>(
355 SmallVectorBase<SmallVectorSizeType<T>>::mallocForGrow(
356 MinSize, sizeof(T), NewCapacity));
357 }
358
359 /// Move existing elements over to the new allocation \p NewElts, the middle
360 /// section of \a grow().
361 void moveElementsForGrow(T *NewElts);
362
363 /// Transfer ownership of the allocation, finishing up \a grow().
364 void takeAllocationForGrow(T *NewElts, size_t NewCapacity);
365
366 /// Reserve enough space to add one element, and return the updated element
367 /// pointer in case it was a reference to the storage.
368 const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
369 return this->reserveForParamAndGetAddressImpl(this, Elt, N);
370 }
371
372 /// Reserve enough space to add one element, and return the updated element
373 /// pointer in case it was a reference to the storage.
374 T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
375 return const_cast<T *>(
376 this->reserveForParamAndGetAddressImpl(this, Elt, N));
377 }
378
379 static T &&forward_value_param(T &&V) { return std::move(V); }
380 static const T &forward_value_param(const T &V) { return V; }
381
382 void growAndAssign(size_t NumElts, const T &Elt) {
383 // Grow manually in case Elt is an internal reference.
384 size_t NewCapacity;
385 T *NewElts = mallocForGrow(NumElts, NewCapacity);
386 std::uninitialized_fill_n(NewElts, NumElts, Elt);
387 this->destroy_range(this->begin(), this->end());
388 takeAllocationForGrow(NewElts, NewCapacity);
389 this->set_size(NumElts);
390 }
391
392 template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
393 // Grow manually in case one of Args is an internal reference.
394 size_t NewCapacity;
395 T *NewElts = mallocForGrow(0, NewCapacity);
396 ::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
397 moveElementsForGrow(NewElts);
398 takeAllocationForGrow(NewElts, NewCapacity);
399 this->set_size(this->size() + 1);
400 return this->back();
401 }
402
403public:
404 void push_back(const T &Elt) {
405 const T *EltPtr = reserveForParamAndGetAddress(Elt);
406 ::new ((void *)this->end()) T(*EltPtr);
407 this->set_size(this->size() + 1);
408 }
409
410 void push_back(T &&Elt) {
411 T *EltPtr = reserveForParamAndGetAddress(Elt);
412 ::new ((void *)this->end()) T(::std::move(*EltPtr));
413 this->set_size(this->size() + 1);
414 }
415
416 void pop_back() {
417 this->set_size(this->size() - 1);
418 this->end()->~T();
419 }
420};
421
422// Define this out-of-line to dissuade the C++ compiler from inlining it.
423template <typename T, bool TriviallyCopyable>
424void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
425 size_t NewCapacity;
426 T *NewElts = mallocForGrow(MinSize, NewCapacity);
427 moveElementsForGrow(NewElts);
428 takeAllocationForGrow(NewElts, NewCapacity);
429}
430
431// Define this out-of-line to dissuade the C++ compiler from inlining it.
432template <typename T, bool TriviallyCopyable>
433void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
434 T *NewElts) {
435 // Move the elements over.
436 this->uninitialized_move(this->begin(), this->end(), NewElts);
437
438 // Destroy the original elements.
439 destroy_range(this->begin(), this->end());
440}
441
442// Define this out-of-line to dissuade the C++ compiler from inlining it.
443template <typename T, bool TriviallyCopyable>
444void SmallVectorTemplateBase<T, TriviallyCopyable>::takeAllocationForGrow(
445 T *NewElts, size_t NewCapacity) {
446 // If this wasn't grown from the inline copy, deallocate the old space.
447 if (!this->isSmall())
448 free(this->begin());
449
450 this->BeginX = NewElts;
451 this->Capacity = NewCapacity;
452}
453
454/// SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put
455/// method implementations that are designed to work with trivially copyable
456/// T's. This allows using memcpy in place of copy/move construction and
457/// skipping destruction.
458template <typename T>
459class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
460 friend class SmallVectorTemplateCommon<T>;
461
462protected:
463 /// True if it's cheap enough to take parameters by value. Doing so avoids
464 /// overhead related to mitigations for reference invalidation.
465 static constexpr bool TakesParamByValue = sizeof(T) <= 2 * sizeof(void *);
466
467 /// Either const T& or T, depending on whether it's cheap enough to take
468 /// parameters by value.
469 using ValueParamT =
470 typename std::conditional<TakesParamByValue, T, const T &>::type;
471
472 SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
473
474 // No need to do a destroy loop for POD's.
475 static void destroy_range(T *, T *) {}
476
477 /// Move the range [I, E) onto the uninitialized memory
478 /// starting with "Dest", constructing elements into it as needed.
479 template<typename It1, typename It2>
480 static void uninitialized_move(It1 I, It1 E, It2 Dest) {
481 // Just do a copy.
482 uninitialized_copy(I, E, Dest);
483 }
484
485 /// Copy the range [I, E) onto the uninitialized memory
486 /// starting with "Dest", constructing elements into it as needed.
487 template<typename It1, typename It2>
488 static void uninitialized_copy(It1 I, It1 E, It2 Dest) {
489 // Arbitrary iterator types; just use the basic implementation.
490 std::uninitialized_copy(I, E, Dest);
491 }
492
493 /// Copy the range [I, E) onto the uninitialized memory
494 /// starting with "Dest", constructing elements into it as needed.
495 template <typename T1, typename T2>
496 static void uninitialized_copy(
497 T1 *I, T1 *E, T2 *Dest,
498 std::enable_if_t<std::is_same<typename std::remove_const<T1>::type,
499 T2>::value> * = nullptr) {
500 // Use memcpy for PODs iterated by pointers (which includes SmallVector
501 // iterators): std::uninitialized_copy optimizes to memmove, but we can
502 // use memcpy here. Note that I and E are iterators and thus might be
503 // invalid for memcpy if they are equal.
504 if (I != E)
505 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
506 }
507
508 /// Double the size of the allocated memory, guaranteeing space for at
509 /// least one more element or MinSize if specified.
510 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
511
512 /// Reserve enough space to add one element, and return the updated element
513 /// pointer in case it was a reference to the storage.
514 const T *reserveForParamAndGetAddress(const T &Elt, size_t N = 1) {
515 return this->reserveForParamAndGetAddressImpl(this, Elt, N);
516 }
517
518 /// Reserve enough space to add one element, and return the updated element
519 /// pointer in case it was a reference to the storage.
520 T *reserveForParamAndGetAddress(T &Elt, size_t N = 1) {
521 return const_cast<T *>(
522 this->reserveForParamAndGetAddressImpl(this, Elt, N));
523 }
524
525 /// Copy \p V or return a reference, depending on \a ValueParamT.
526 static ValueParamT forward_value_param(ValueParamT V) { return V; }
527
528 void growAndAssign(size_t NumElts, T Elt) {
529 // Elt has been copied in case it's an internal reference, side-stepping
530 // reference invalidation problems without losing the realloc optimization.
531 this->set_size(0);
532 this->grow(NumElts);
533 std::uninitialized_fill_n(this->begin(), NumElts, Elt);
534 this->set_size(NumElts);
535 }
536
537 template <typename... ArgTypes> T &growAndEmplaceBack(ArgTypes &&... Args) {
538 // Use push_back with a copy in case Args has an internal reference,
539 // side-stepping reference invalidation problems without losing the realloc
540 // optimization.
541 push_back(T(std::forward<ArgTypes>(Args)...));
542 return this->back();
543 }
544
545public:
546 void push_back(ValueParamT Elt) {
547 const T *EltPtr = reserveForParamAndGetAddress(Elt);
548 memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
549 this->set_size(this->size() + 1);
550 }
551
552 void pop_back() { this->set_size(this->size() - 1); }
553};
554
555/// This class consists of common code factored out of the SmallVector class to
556/// reduce code duplication based on the SmallVector 'N' template parameter.
557template <typename T>
558class SmallVectorImpl : public SmallVectorTemplateBase<T> {
559 using SuperClass = SmallVectorTemplateBase<T>;
560
561public:
562 using iterator = typename SuperClass::iterator;
563 using const_iterator = typename SuperClass::const_iterator;
564 using reference = typename SuperClass::reference;
565 using size_type = typename SuperClass::size_type;
566
567protected:
568 using SmallVectorTemplateBase<T>::TakesParamByValue;
569 using ValueParamT = typename SuperClass::ValueParamT;
570
571 // Default ctor - Initialize to empty.
572 explicit SmallVectorImpl(unsigned N)
573 : SmallVectorTemplateBase<T>(N) {}
574
575public:
576 SmallVectorImpl(const SmallVectorImpl &) = delete;
577
578 ~SmallVectorImpl() {
579 // Subclass has already destructed this vector's elements.
580 // If this wasn't grown from the inline copy, deallocate the old space.
581 if (!this->isSmall())
582 free(this->begin());
583 }
584
585 void clear() {
586 this->destroy_range(this->begin(), this->end());
587 this->Size = 0;
588 }
589
590private:
591 template <bool ForOverwrite> void resizeImpl(size_type N) {
592 if (N < this->size()) {
593 this->pop_back_n(this->size() - N);
594 } else if (N > this->size()) {
595 this->reserve(N);
596 for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
597 if (ForOverwrite)
598 new (&*I) T;
599 else
600 new (&*I) T();
601 this->set_size(N);
602 }
603 }
604
605public:
606 void resize(size_type N) { resizeImpl<false>(N); }
607
608 /// Like resize, but \ref T is POD, the new values won't be initialized.
609 void resize_for_overwrite(size_type N) { resizeImpl<true>(N); }
610
611 void resize(size_type N, ValueParamT NV) {
612 if (N == this->size())
613 return;
614
615 if (N < this->size()) {
616 this->pop_back_n(this->size() - N);
617 return;
618 }
619
620 // N > this->size(). Defer to append.
621 this->append(N - this->size(), NV);
622 }
623
624 void reserve(size_type N) {
625 if (this->capacity() < N)
626 this->grow(N);
627 }
628
629 void pop_back_n(size_type NumItems) {
630 assert(this->size() >= NumItems)((void)0);
631 this->destroy_range(this->end() - NumItems, this->end());
632 this->set_size(this->size() - NumItems);
633 }
634
635 LLVM_NODISCARD[[clang::warn_unused_result]] T pop_back_val() {
636 T Result = ::std::move(this->back());
637 this->pop_back();
638 return Result;
639 }
640
641 void swap(SmallVectorImpl &RHS);
642
643 /// Add the specified range to the end of the SmallVector.
644 template <typename in_iter,
645 typename = std::enable_if_t<std::is_convertible<
646 typename std::iterator_traits<in_iter>::iterator_category,
647 std::input_iterator_tag>::value>>
648 void append(in_iter in_start, in_iter in_end) {
649 this->assertSafeToAddRange(in_start, in_end);
650 size_type NumInputs = std::distance(in_start, in_end);
651 this->reserve(this->size() + NumInputs);
652 this->uninitialized_copy(in_start, in_end, this->end());
653 this->set_size(this->size() + NumInputs);
654 }
655
656 /// Append \p NumInputs copies of \p Elt to the end.
657 void append(size_type NumInputs, ValueParamT Elt) {
658 const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumInputs);
659 std::uninitialized_fill_n(this->end(), NumInputs, *EltPtr);
660 this->set_size(this->size() + NumInputs);
661 }
662
663 void append(std::initializer_list<T> IL) {
664 append(IL.begin(), IL.end());
665 }
666
667 void append(const SmallVectorImpl &RHS) { append(RHS.begin(), RHS.end()); }
668
669 void assign(size_type NumElts, ValueParamT Elt) {
670 // Note that Elt could be an internal reference.
671 if (NumElts > this->capacity()) {
672 this->growAndAssign(NumElts, Elt);
673 return;
674 }
675
676 // Assign over existing elements.
677 std::fill_n(this->begin(), std::min(NumElts, this->size()), Elt);
678 if (NumElts > this->size())
679 std::uninitialized_fill_n(this->end(), NumElts - this->size(), Elt);
680 else if (NumElts < this->size())
681 this->destroy_range(this->begin() + NumElts, this->end());
682 this->set_size(NumElts);
683 }
684
685 // FIXME: Consider assigning over existing elements, rather than clearing &
686 // re-initializing them - for all assign(...) variants.
687
688 template <typename in_iter,
689 typename = std::enable_if_t<std::is_convertible<
690 typename std::iterator_traits<in_iter>::iterator_category,
691 std::input_iterator_tag>::value>>
692 void assign(in_iter in_start, in_iter in_end) {
693 this->assertSafeToReferenceAfterClear(in_start, in_end);
694 clear();
695 append(in_start, in_end);
696 }
697
698 void assign(std::initializer_list<T> IL) {
699 clear();
700 append(IL);
701 }
702
703 void assign(const SmallVectorImpl &RHS) { assign(RHS.begin(), RHS.end()); }
704
705 iterator erase(const_iterator CI) {
706 // Just cast away constness because this is a non-const member function.
707 iterator I = const_cast<iterator>(CI);
708
709 assert(this->isReferenceToStorage(CI) && "Iterator to erase is out of bounds.")((void)0);
710
711 iterator N = I;
712 // Shift all elts down one.
713 std::move(I+1, this->end(), I);
714 // Drop the last elt.
715 this->pop_back();
716 return(N);
717 }
718
719 iterator erase(const_iterator CS, const_iterator CE) {
720 // Just cast away constness because this is a non-const member function.
721 iterator S = const_cast<iterator>(CS);
722 iterator E = const_cast<iterator>(CE);
723
724 assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.")((void)0);
725
726 iterator N = S;
727 // Shift all elts down.
728 iterator I = std::move(E, this->end(), S);
729 // Drop the last elts.
730 this->destroy_range(I, this->end());
731 this->set_size(I - this->begin());
732 return(N);
733 }
734
735private:
736 template <class ArgType> iterator insert_one_impl(iterator I, ArgType &&Elt) {
737 // Callers ensure that ArgType is derived from T.
738 static_assert(
739 std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
740 T>::value,
741 "ArgType must be derived from T!");
742
743 if (I == this->end()) { // Important special case for empty vector.
744 this->push_back(::std::forward<ArgType>(Elt));
745 return this->end()-1;
746 }
747
748 assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);
749
750 // Grow if necessary.
751 size_t Index = I - this->begin();
752 std::remove_reference_t<ArgType> *EltPtr =
753 this->reserveForParamAndGetAddress(Elt);
754 I = this->begin() + Index;
755
756 ::new ((void*) this->end()) T(::std::move(this->back()));
757 // Push everything else over.
758 std::move_backward(I, this->end()-1, this->end());
759 this->set_size(this->size() + 1);
760
761 // If we just moved the element we're inserting, be sure to update
762 // the reference (never happens if TakesParamByValue).
763 static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
764 "ArgType must be 'T' when taking by value!");
765 if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
766 ++EltPtr;
767
768 *I = ::std::forward<ArgType>(*EltPtr);
769 return I;
770 }
771
772public:
773 iterator insert(iterator I, T &&Elt) {
774 return insert_one_impl(I, this->forward_value_param(std::move(Elt)));
775 }
776
777 iterator insert(iterator I, const T &Elt) {
778 return insert_one_impl(I, this->forward_value_param(Elt));
779 }
780
781 iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt) {
782 // Convert iterator to elt# to avoid invalidating iterator when we reserve()
783 size_t InsertElt = I - this->begin();
784
785 if (I == this->end()) { // Important special case for empty vector.
786 append(NumToInsert, Elt);
787 return this->begin()+InsertElt;
788 }
789
790 assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);
791
792 // Ensure there is enough space, and get the (maybe updated) address of
793 // Elt.
794 const T *EltPtr = this->reserveForParamAndGetAddress(Elt, NumToInsert);
795
796 // Uninvalidate the iterator.
797 I = this->begin()+InsertElt;
798
799 // If there are more elements between the insertion point and the end of the
800 // range than there are being inserted, we can use a simple approach to
801 // insertion. Since we already reserved space, we know that this won't
802 // reallocate the vector.
803 if (size_t(this->end()-I) >= NumToInsert) {
804 T *OldEnd = this->end();
805 append(std::move_iterator<iterator>(this->end() - NumToInsert),
806 std::move_iterator<iterator>(this->end()));
807
808 // Copy the existing elements that get replaced.
809 std::move_backward(I, OldEnd-NumToInsert, OldEnd);
810
811 // If we just moved the element we're inserting, be sure to update
812 // the reference (never happens if TakesParamByValue).
813 if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
814 EltPtr += NumToInsert;
815
816 std::fill_n(I, NumToInsert, *EltPtr);
817 return I;
818 }
819
820 // Otherwise, we're inserting more elements than exist already, and we're
821 // not inserting at the end.
822
823 // Move over the elements that we're about to overwrite.
824 T *OldEnd = this->end();
825 this->set_size(this->size() + NumToInsert);
826 size_t NumOverwritten = OldEnd-I;
827 this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
828
829 // If we just moved the element we're inserting, be sure to update
830 // the reference (never happens if TakesParamByValue).
831 if (!TakesParamByValue && I <= EltPtr && EltPtr < this->end())
832 EltPtr += NumToInsert;
833
834 // Replace the overwritten part.
835 std::fill_n(I, NumOverwritten, *EltPtr);
836
837 // Insert the non-overwritten middle part.
838 std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
839 return I;
840 }
841
842 template <typename ItTy,
843 typename = std::enable_if_t<std::is_convertible<
844 typename std::iterator_traits<ItTy>::iterator_category,
845 std::input_iterator_tag>::value>>
846 iterator insert(iterator I, ItTy From, ItTy To) {
847 // Convert iterator to elt# to avoid invalidating iterator when we reserve()
848 size_t InsertElt = I - this->begin();
849
850 if (I == this->end()) { // Important special case for empty vector.
851 append(From, To);
852 return this->begin()+InsertElt;
853 }
854
855 assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.")((void)0);
856
857 // Check that the reserve that follows doesn't invalidate the iterators.
858 this->assertSafeToAddRange(From, To);
859
860 size_t NumToInsert = std::distance(From, To);
861
862 // Ensure there is enough space.
863 reserve(this->size() + NumToInsert);
864
865 // Uninvalidate the iterator.
866 I = this->begin()+InsertElt;
867
868 // If there are more elements between the insertion point and the end of the
869 // range than there are being inserted, we can use a simple approach to
870 // insertion. Since we already reserved space, we know that this won't
871 // reallocate the vector.
872 if (size_t(this->end()-I) >= NumToInsert) {
873 T *OldEnd = this->end();
874 append(std::move_iterator<iterator>(this->end() - NumToInsert),
875 std::move_iterator<iterator>(this->end()));
876
877 // Copy the existing elements that get replaced.
878 std::move_backward(I, OldEnd-NumToInsert, OldEnd);
879
880 std::copy(From, To, I);
881 return I;
882 }
883
884 // Otherwise, we're inserting more elements than exist already, and we're
885 // not inserting at the end.
886
887 // Move over the elements that we're about to overwrite.
888 T *OldEnd = this->end();
889 this->set_size(this->size() + NumToInsert);
890 size_t NumOverwritten = OldEnd-I;
891 this->uninitialized_move(I, OldEnd, this->end()-NumOverwritten);
892
893 // Replace the overwritten part.
894 for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
895 *J = *From;
896 ++J; ++From;
897 }
898
899 // Insert the non-overwritten middle part.
900 this->uninitialized_copy(From, To, OldEnd);
901 return I;
902 }
903
904 void insert(iterator I, std::initializer_list<T> IL) {
905 insert(I, IL.begin(), IL.end());
906 }
907
908 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
909 if (LLVM_UNLIKELY(this->size() >= this->capacity())__builtin_expect((bool)(this->size() >= this->capacity
()), false)
)
910 return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
911
912 ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
913 this->set_size(this->size() + 1);
914 return this->back();
915 }
916
917 SmallVectorImpl &operator=(const SmallVectorImpl &RHS);
918
919 SmallVectorImpl &operator=(SmallVectorImpl &&RHS);
920
921 bool operator==(const SmallVectorImpl &RHS) const {
922 if (this->size() != RHS.size()) return false;
923 return std::equal(this->begin(), this->end(), RHS.begin());
924 }
925 bool operator!=(const SmallVectorImpl &RHS) const {
926 return !(*this == RHS);
927 }
928
929 bool operator<(const SmallVectorImpl &RHS) const {
930 return std::lexicographical_compare(this->begin(), this->end(),
931 RHS.begin(), RHS.end());
932 }
933};
934
935template <typename T>
936void SmallVectorImpl<T>::swap(SmallVectorImpl<T> &RHS) {
937 if (this == &RHS) return;
938
939 // We can only avoid copying elements if neither vector is small.
940 if (!this->isSmall() && !RHS.isSmall()) {
941 std::swap(this->BeginX, RHS.BeginX);
942 std::swap(this->Size, RHS.Size);
943 std::swap(this->Capacity, RHS.Capacity);
944 return;
945 }
946 this->reserve(RHS.size());
947 RHS.reserve(this->size());
948
949 // Swap the shared elements.
950 size_t NumShared = this->size();
951 if (NumShared > RHS.size()) NumShared = RHS.size();
952 for (size_type i = 0; i != NumShared; ++i)
953 std::swap((*this)[i], RHS[i]);
954
955 // Copy over the extra elts.
956 if (this->size() > RHS.size()) {
957 size_t EltDiff = this->size() - RHS.size();
958 this->uninitialized_copy(this->begin()+NumShared, this->end(), RHS.end());
959 RHS.set_size(RHS.size() + EltDiff);
960 this->destroy_range(this->begin()+NumShared, this->end());
961 this->set_size(NumShared);
962 } else if (RHS.size() > this->size()) {
963 size_t EltDiff = RHS.size() - this->size();
964 this->uninitialized_copy(RHS.begin()+NumShared, RHS.end(), this->end());
965 this->set_size(this->size() + EltDiff);
966 this->destroy_range(RHS.begin()+NumShared, RHS.end());
967 RHS.set_size(NumShared);
968 }
969}
970
971template <typename T>
972SmallVectorImpl<T> &SmallVectorImpl<T>::
973 operator=(const SmallVectorImpl<T> &RHS) {
974 // Avoid self-assignment.
975 if (this == &RHS) return *this;
976
977 // If we already have sufficient space, assign the common elements, then
978 // destroy any excess.
979 size_t RHSSize = RHS.size();
980 size_t CurSize = this->size();
981 if (CurSize >= RHSSize) {
982 // Assign common elements.
983 iterator NewEnd;
984 if (RHSSize)
985 NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
986 else
987 NewEnd = this->begin();
988
989 // Destroy excess elements.
990 this->destroy_range(NewEnd, this->end());
991
992 // Trim.
993 this->set_size(RHSSize);
994 return *this;
995 }
996
997 // If we have to grow to have enough elements, destroy the current elements.
998 // This allows us to avoid copying them during the grow.
999 // FIXME: don't do this if they're efficiently moveable.
1000 if (this->capacity() < RHSSize) {
1001 // Destroy current elements.
1002 this->clear();
1003 CurSize = 0;
1004 this->grow(RHSSize);
1005 } else if (CurSize) {
1006 // Otherwise, use assignment for the already-constructed elements.
1007 std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
1008 }
1009
1010 // Copy construct the new elements in place.
1011 this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
1012 this->begin()+CurSize);
1013
1014 // Set end.
1015 this->set_size(RHSSize);
1016 return *this;
1017}
1018
1019template <typename T>
1020SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
1021 // Avoid self-assignment.
1022 if (this == &RHS) return *this;
1023
1024 // If the RHS isn't small, clear this vector and then steal its buffer.
1025 if (!RHS.isSmall()) {
1026 this->destroy_range(this->begin(), this->end());
1027 if (!this->isSmall()) free(this->begin());
1028 this->BeginX = RHS.BeginX;
1029 this->Size = RHS.Size;
1030 this->Capacity = RHS.Capacity;
1031 RHS.resetToSmall();
1032 return *this;
1033 }
1034
1035 // If we already have sufficient space, assign the common elements, then
1036 // destroy any excess.
1037 size_t RHSSize = RHS.size();
1038 size_t CurSize = this->size();
1039 if (CurSize >= RHSSize) {
1040 // Assign common elements.
1041 iterator NewEnd = this->begin();
1042 if (RHSSize)
1043 NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
1044
1045 // Destroy excess elements and trim the bounds.
1046 this->destroy_range(NewEnd, this->end());
1047 this->set_size(RHSSize);
1048
1049 // Clear the RHS.
1050 RHS.clear();
1051
1052 return *this;
1053 }
1054
1055 // If we have to grow to have enough elements, destroy the current elements.
1056 // This allows us to avoid copying them during the grow.
1057 // FIXME: this may not actually make any sense if we can efficiently move
1058 // elements.
1059 if (this->capacity() < RHSSize) {
1060 // Destroy current elements.
1061 this->clear();
1062 CurSize = 0;
1063 this->grow(RHSSize);
1064 } else if (CurSize) {
1065 // Otherwise, use assignment for the already-constructed elements.
1066 std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
1067 }
1068
1069 // Move-construct the new elements in place.
1070 this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
1071 this->begin()+CurSize);
1072
1073 // Set end.
1074 this->set_size(RHSSize);
1075
1076 RHS.clear();
1077 return *this;
1078}
1079
1080/// Storage for the SmallVector elements. This is specialized for the N=0 case
1081/// to avoid allocating unnecessary storage.
1082template <typename T, unsigned N>
1083struct SmallVectorStorage {
1084 alignas(T) char InlineElts[N * sizeof(T)];
1085};
1086
1087/// We need the storage to be properly aligned even for small-size of 0 so that
1088/// the pointer math in \a SmallVectorTemplateCommon::getFirstEl() is
1089/// well-defined.
1090template <typename T> struct alignas(T) SmallVectorStorage<T, 0> {};
1091
1092/// Forward declaration of SmallVector so that
1093/// calculateSmallVectorDefaultInlinedElements can reference
1094/// `sizeof(SmallVector<T, 0>)`.
1095template <typename T, unsigned N> class LLVM_GSL_OWNER[[gsl::Owner]] SmallVector;
1096
1097/// Helper class for calculating the default number of inline elements for
1098/// `SmallVector<T>`.
1099///
1100/// This should be migrated to a constexpr function when our minimum
1101/// compiler support is enough for multi-statement constexpr functions.
1102template <typename T> struct CalculateSmallVectorDefaultInlinedElements {
1103 // Parameter controlling the default number of inlined elements
1104 // for `SmallVector<T>`.
1105 //
1106 // The default number of inlined elements ensures that
1107 // 1. There is at least one inlined element.
1108 // 2. `sizeof(SmallVector<T>) <= kPreferredSmallVectorSizeof` unless
1109 // it contradicts 1.
1110 static constexpr size_t kPreferredSmallVectorSizeof = 64;
1111
1112 // static_assert that sizeof(T) is not "too big".
1113 //
1114 // Because our policy guarantees at least one inlined element, it is possible
1115 // for an arbitrarily large inlined element to allocate an arbitrarily large
1116 // amount of inline storage. We generally consider it an antipattern for a
1117 // SmallVector to allocate an excessive amount of inline storage, so we want
1118 // to call attention to these cases and make sure that users are making an
1119 // intentional decision if they request a lot of inline storage.
1120 //
1121 // We want this assertion to trigger in pathological cases, but otherwise
1122 // not be too easy to hit. To accomplish that, the cutoff is actually somewhat
1123 // larger than kPreferredSmallVectorSizeof (otherwise,
1124 // `SmallVector<SmallVector<T>>` would be one easy way to trip it, and that
1125 // pattern seems useful in practice).
1126 //
1127 // One wrinkle is that this assertion is in theory non-portable, since
1128 // sizeof(T) is in general platform-dependent. However, we don't expect this
1129 // to be much of an issue, because most LLVM development happens on 64-bit
1130 // hosts, and therefore sizeof(T) is expected to *decrease* when compiled for
1131 // 32-bit hosts, dodging the issue. The reverse situation, where development
1132 // happens on a 32-bit host and then fails due to sizeof(T) *increasing* on a
1133 // 64-bit host, is expected to be very rare.
1134 static_assert(
1135 sizeof(T) <= 256,
1136 "You are trying to use a default number of inlined elements for "
1137 "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
1138 "explicit number of inlined elements with `SmallVector<T, N>` to make "
1139 "sure you really want that much inline storage.");
1140
1141 // Discount the size of the header itself when calculating the maximum inline
1142 // bytes.
1143 static constexpr size_t PreferredInlineBytes =
1144 kPreferredSmallVectorSizeof - sizeof(SmallVector<T, 0>);
1145 static constexpr size_t NumElementsThatFit = PreferredInlineBytes / sizeof(T);
1146 static constexpr size_t value =
1147 NumElementsThatFit == 0 ? 1 : NumElementsThatFit;
1148};
1149
1150/// This is a 'vector' (really, a variable-sized array), optimized
1151/// for the case when the array is small. It contains some number of elements
1152/// in-place, which allows it to avoid heap allocation when the actual number of
1153/// elements is below that threshold. This allows normal "small" cases to be
1154/// fast without losing generality for large inputs.
1155///
1156/// \note
1157/// In the absence of a well-motivated choice for the number of inlined
1158/// elements \p N, it is recommended to use \c SmallVector<T> (that is,
1159/// omitting the \p N). This will choose a default number of inlined elements
1160/// reasonable for allocation on the stack (for example, trying to keep \c
1161/// sizeof(SmallVector<T>) around 64 bytes).
1162///
1163/// \warning This does not attempt to be exception safe.
1164///
1165/// \see https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h
1166template <typename T,
1167 unsigned N = CalculateSmallVectorDefaultInlinedElements<T>::value>
1168class LLVM_GSL_OWNER[[gsl::Owner]] SmallVector : public SmallVectorImpl<T>,
1169 SmallVectorStorage<T, N> {
1170public:
1171 SmallVector() : SmallVectorImpl<T>(N) {}
1172
1173 ~SmallVector() {
1174 // Destroy the constructed elements in the vector.
1175 this->destroy_range(this->begin(), this->end());
1176 }
1177
1178 explicit SmallVector(size_t Size, const T &Value = T())
1179 : SmallVectorImpl<T>(N) {
1180 this->assign(Size, Value);
1181 }
1182
1183 template <typename ItTy,
1184 typename = std::enable_if_t<std::is_convertible<
1185 typename std::iterator_traits<ItTy>::iterator_category,
1186 std::input_iterator_tag>::value>>
1187 SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
1188 this->append(S, E);
1189 }
1190
1191 template <typename RangeTy>
1192 explicit SmallVector(const iterator_range<RangeTy> &R)
1193 : SmallVectorImpl<T>(N) {
1194 this->append(R.begin(), R.end());
1195 }
1196
1197 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
1198 this->assign(IL);
1199 }
1200
1201 SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
1202 if (!RHS.empty())
1203 SmallVectorImpl<T>::operator=(RHS);
1204 }
1205
1206 SmallVector &operator=(const SmallVector &RHS) {
1207 SmallVectorImpl<T>::operator=(RHS);
1208 return *this;
1209 }
1210
1211 SmallVector(SmallVector &&RHS) : SmallVectorImpl<T>(N) {
1212 if (!RHS.empty())
1213 SmallVectorImpl<T>::operator=(::std::move(RHS));
1214 }
1215
1216 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
1217 if (!RHS.empty())
1218 SmallVectorImpl<T>::operator=(::std::move(RHS));
1219 }
1220
1221 SmallVector &operator=(SmallVector &&RHS) {
1222 SmallVectorImpl<T>::operator=(::std::move(RHS));
1223 return *this;
1224 }
1225
1226 SmallVector &operator=(SmallVectorImpl<T> &&RHS) {
1227 SmallVectorImpl<T>::operator=(::std::move(RHS));
1228 return *this;
1229 }
1230
1231 SmallVector &operator=(std::initializer_list<T> IL) {
1232 this->assign(IL);
1233 return *this;
1234 }
1235};
1236
1237template <typename T, unsigned N>
1238inline size_t capacity_in_bytes(const SmallVector<T, N> &X) {
1239 return X.capacity_in_bytes();
1240}
1241
1242/// Given a range of type R, iterate the entire range and return a
1243/// SmallVector with elements of the vector. This is useful, for example,
1244/// when you want to iterate a range and then sort the results.
1245template <unsigned Size, typename R>
1246SmallVector<typename std::remove_const<typename std::remove_reference<
1247 decltype(*std::begin(std::declval<R &>()))>::type>::type,
1248 Size>
1249to_vector(R &&Range) {
1250 return {std::begin(Range), std::end(Range)};
1251}
1252
1253} // end namespace llvm
1254
1255namespace std {
1256
1257 /// Implement std::swap in terms of SmallVector swap.
1258 template<typename T>
1259 inline void
1260 swap(llvm::SmallVectorImpl<T> &LHS, llvm::SmallVectorImpl<T> &RHS) {
1261 LHS.swap(RHS);
1262 }
1263
1264 /// Implement std::swap in terms of SmallVector swap.
1265 template<typename T, unsigned N>
1266 inline void
1267 swap(llvm::SmallVector<T, N> &LHS, llvm::SmallVector<T, N> &RHS) {
1268 LHS.swap(RHS);
1269 }
1270
1271} // end namespace std
1272
1273#endif // LLVM_ADT_SMALLVECTOR_H