47 #include "llvm/Support/raw_ostream.h" 51 using namespace clang;
59 struct CallStackFrame;
71 return cast<ValueDecl>(D->getMostRecentDecl())->getType();
78 dyn_cast<MaterializeTemporaryExpr>(Base)) {
81 const Expr *Temp = MTE->GetTemporaryExpr();
86 if (!Adjustments.empty())
105 return dyn_cast<
FieldDecl>(getAsBaseOrMember(E).getPointer());
110 return dyn_cast<
CXXRecordDecl>(getAsBaseOrMember(E).getPointer());
115 return getAsBaseOrMember(E).getInt();
119 static const AllocSizeAttr *getAllocSizeAttr(
const CallExpr *CE) {
121 return Callee ? Callee->
getAttr<AllocSizeAttr>() :
nullptr;
128 static const CallExpr *tryUnwrapAllocSizeCall(
const Expr *E) {
135 if (
const auto *Cast = dyn_cast<CastExpr>(E))
138 if (
const auto *CE = dyn_cast<CallExpr>(E))
139 return getAllocSizeAttr(CE) ? CE :
nullptr;
146 const auto *E = Base.dyn_cast<
const Expr *>();
153 static const uint64_t AssumedSizeForUnsizedArray =
164 bool &FirstEntryIsUnsizedArray) {
167 assert(!isBaseAnAllocSizeCall(Base) &&
168 "Unsized arrays shouldn't appear here");
169 unsigned MostDerivedLength = 0;
170 Type = getType(Base);
172 for (
unsigned I = 0, N = Path.size(); I != N; ++I) {
176 MostDerivedLength = I + 1;
179 if (
auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
180 ArraySize = CAT->getSize().getZExtValue();
182 assert(I == 0 &&
"unexpected unsized array designator");
183 FirstEntryIsUnsizedArray =
true;
184 ArraySize = AssumedSizeForUnsizedArray;
190 MostDerivedLength = I + 1;
192 }
else if (
const FieldDecl *FD = getAsField(Path[I])) {
193 Type = FD->getType();
195 MostDerivedLength = I + 1;
203 return MostDerivedLength;
208 CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex,
209 CSK_This, CSK_Real, CSK_Imag
213 struct SubobjectDesignator {
217 unsigned Invalid : 1;
220 unsigned IsOnePastTheEnd : 1;
223 unsigned FirstEntryIsAnUnsizedArray : 1;
226 unsigned MostDerivedIsArrayElement : 1;
230 unsigned MostDerivedPathLength : 28;
239 uint64_t MostDerivedArraySize;
249 SubobjectDesignator() : Invalid(
true) {}
252 : Invalid(
false), IsOnePastTheEnd(
false),
253 FirstEntryIsAnUnsizedArray(
false), MostDerivedIsArrayElement(
false),
254 MostDerivedPathLength(0), MostDerivedArraySize(0),
255 MostDerivedType(T) {}
259 FirstEntryIsAnUnsizedArray(
false), MostDerivedIsArrayElement(
false),
260 MostDerivedPathLength(0), MostDerivedArraySize(0) {
261 assert(V.
isLValue() &&
"Non-LValue used to make an LValue designator?");
265 Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
267 bool IsArray =
false;
268 bool FirstIsUnsizedArray =
false;
269 MostDerivedPathLength = findMostDerivedSubobject(
271 MostDerivedType, IsArray, FirstIsUnsizedArray);
272 MostDerivedIsArrayElement = IsArray;
273 FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
285 bool isMostDerivedAnUnsizedArray()
const {
286 assert(!Invalid &&
"Calling this makes no sense on invalid designators");
287 return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
292 uint64_t getMostDerivedArraySize()
const {
293 assert(!isMostDerivedAnUnsizedArray() &&
"Unsized array has no size");
294 return MostDerivedArraySize;
298 bool isOnePastTheEnd()
const {
302 if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
303 Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize)
309 bool isValidSubobject()
const {
312 return !isOnePastTheEnd();
321 Entry.ArrayIndex = 0;
322 Entries.push_back(Entry);
326 MostDerivedIsArrayElement =
true;
327 MostDerivedArraySize = CAT->
getSize().getZExtValue();
328 MostDerivedPathLength = Entries.size();
332 void addUnsizedArrayUnchecked(
QualType ElemTy) {
334 Entry.ArrayIndex = 0;
335 Entries.push_back(Entry);
337 MostDerivedType = ElemTy;
338 MostDerivedIsArrayElement =
true;
342 MostDerivedArraySize = AssumedSizeForUnsizedArray;
343 MostDerivedPathLength = Entries.size();
347 void addDeclUnchecked(
const Decl *D,
bool Virtual =
false) {
350 Entry.BaseOrMember = Value.getOpaqueValue();
351 Entries.push_back(Entry);
354 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
355 MostDerivedType = FD->getType();
356 MostDerivedIsArrayElement =
false;
357 MostDerivedArraySize = 0;
358 MostDerivedPathLength = Entries.size();
362 void addComplexUnchecked(
QualType EltTy,
bool Imag) {
364 Entry.ArrayIndex = Imag;
365 Entries.push_back(Entry);
369 MostDerivedType = EltTy;
370 MostDerivedIsArrayElement =
true;
371 MostDerivedArraySize = 2;
372 MostDerivedPathLength = Entries.size();
374 void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
const Expr *E);
375 void diagnosePointerArithmetic(EvalInfo &Info,
const Expr *E,
378 void adjustIndex(EvalInfo &Info,
const Expr *E, APSInt N) {
379 if (Invalid || !N)
return;
380 uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
381 if (isMostDerivedAnUnsizedArray()) {
382 diagnoseUnsizedArrayPointerArithmetic(Info, E);
386 Entries.back().ArrayIndex += TruncatedN;
393 bool IsArray = MostDerivedPathLength == Entries.size() &&
394 MostDerivedIsArrayElement;
395 uint64_t ArrayIndex =
396 IsArray ? Entries.back().ArrayIndex : (uint64_t)IsOnePastTheEnd;
398 IsArray ? getMostDerivedArraySize() : (uint64_t)1;
400 if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
403 N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
404 (llvm::APInt&)N += ArrayIndex;
405 assert(N.ugt(ArraySize) &&
"bounds check failed for in-bounds index");
406 diagnosePointerArithmetic(Info, E, N);
411 ArrayIndex += TruncatedN;
412 assert(ArrayIndex <= ArraySize &&
413 "bounds check succeeded for out-of-bounds index");
416 Entries.back().ArrayIndex = ArrayIndex;
418 IsOnePastTheEnd = (ArrayIndex != 0);
423 struct CallStackFrame {
427 CallStackFrame *Caller;
441 typedef std::map<const void*, APValue>
MapTy;
442 typedef MapTy::const_iterator temp_iterator;
460 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
468 APValue *getTemporary(
const void *Key) {
469 MapTy::iterator I = Temporaries.find(Key);
470 return I == Temporaries.end() ? nullptr : &I->second;
472 APValue &createTemporary(
const void *Key,
bool IsLifetimeExtended);
476 class ThisOverrideRAII {
478 ThisOverrideRAII(CallStackFrame &Frame,
const LValue *NewThis,
bool Enable)
479 : Frame(Frame), OldThis(Frame.This) {
481 Frame.This = NewThis;
483 ~ThisOverrideRAII() {
484 Frame.This = OldThis;
487 CallStackFrame &Frame;
488 const LValue *OldThis;
493 class OptionalDiagnostic {
507 OptionalDiagnostic &
operator<<(
const APSInt &I) {
511 *Diag << StringRef(Buffer.data(), Buffer.size());
516 OptionalDiagnostic &
operator<<(
const APFloat &F) {
525 llvm::APFloat::semanticsPrecision(F.getSemantics());
526 precision = (precision * 59 + 195) / 196;
528 F.toString(Buffer, precision);
529 *Diag << StringRef(Buffer.data(), Buffer.size());
537 llvm::PointerIntPair<APValue*, 1, bool>
Value;
540 Cleanup(
APValue *Val,
bool IsLifetimeExtended)
541 :
Value(Val, IsLifetimeExtended) {}
543 bool isLifetimeExtended()
const {
return Value.getInt(); }
545 *Value.getPointer() =
APValue();
570 CallStackFrame *CurrentCall;
573 unsigned CallStackDepth;
576 unsigned NextCallIndex;
585 CallStackFrame BottomFrame;
601 typedef std::pair<APValue::LValueBase, unsigned> EvaluatingObject;
607 struct EvaluatingConstructorRAII {
609 EvaluatingObject Object;
611 EvaluatingConstructorRAII(EvalInfo &EI, EvaluatingObject Object)
612 : EI(EI), Object(Object) {
613 DidInsert = EI.EvaluatingConstructors.insert(Object).second;
615 ~EvaluatingConstructorRAII() {
616 if (DidInsert) EI.EvaluatingConstructors.erase(Object);
621 return EvaluatingConstructors.count(EvaluatingObject(Decl, CallIndex));
626 uint64_t ArrayInitIndex = -1;
630 bool HasActiveDiagnostic;
634 bool HasFoldFailureDiagnostic;
637 bool IsSpeculativelyEvaluating;
639 enum EvaluationMode {
642 EM_ConstantExpression,
648 EM_PotentialConstantExpression,
657 EM_EvaluateForOverflow,
661 EM_IgnoreSideEffects,
668 EM_ConstantExpressionUnevaluated,
677 EM_PotentialConstantExpressionUnevaluated,
694 bool checkingPotentialConstantExpression()
const {
695 return EvalMode == EM_PotentialConstantExpression ||
696 EvalMode == EM_PotentialConstantExpressionUnevaluated;
702 bool checkingForOverflow() {
return EvalMode == EM_EvaluateForOverflow; }
705 : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(
nullptr),
706 CallStackDepth(0), NextCallIndex(1),
707 StepsLeft(getLangOpts().ConstexprStepLimit),
709 EvaluatingDecl((
const ValueDecl *)
nullptr),
710 EvaluatingDeclValue(
nullptr), HasActiveDiagnostic(
false),
711 HasFoldFailureDiagnostic(
false), IsSpeculativelyEvaluating(
false),
715 EvaluatingDecl = Base;
716 EvaluatingDeclValue = &
Value;
717 EvaluatingConstructors.insert({Base, 0});
725 if (checkingPotentialConstantExpression() && CallStackDepth > 1)
727 if (NextCallIndex == 0) {
729 FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
732 if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
734 FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
735 << getLangOpts().ConstexprCallDepth;
739 CallStackFrame *getCallFrame(
unsigned CallIndex) {
740 assert(CallIndex &&
"no call index in getCallFrame");
743 CallStackFrame *Frame = CurrentCall;
744 while (Frame->Index > CallIndex)
745 Frame = Frame->Caller;
746 return (Frame->Index == CallIndex) ? Frame :
nullptr;
749 bool nextStep(
const Stmt *S) {
751 FFDiag(S->
getLocStart(), diag::note_constexpr_step_limit_exceeded);
762 EvalStatus.
Diag->push_back(std::make_pair(Loc, PD));
763 return EvalStatus.
Diag->back().second;
767 void addCallStack(
unsigned Limit);
771 unsigned ExtraNotes,
bool IsCCEDiag) {
773 if (EvalStatus.
Diag) {
780 if (!EvalStatus.
Diag->empty()) {
782 case EM_ConstantFold:
783 case EM_IgnoreSideEffects:
784 case EM_EvaluateForOverflow:
785 if (!HasFoldFailureDiagnostic)
789 case EM_ConstantExpression:
790 case EM_PotentialConstantExpression:
791 case EM_ConstantExpressionUnevaluated:
792 case EM_PotentialConstantExpressionUnevaluated:
794 HasActiveDiagnostic =
false;
795 return OptionalDiagnostic();
799 unsigned CallStackNotes = CallStackDepth - 1;
802 CallStackNotes =
std::min(CallStackNotes, Limit + 1);
803 if (checkingPotentialConstantExpression())
806 HasActiveDiagnostic =
true;
807 HasFoldFailureDiagnostic = !IsCCEDiag;
808 EvalStatus.
Diag->clear();
809 EvalStatus.
Diag->reserve(1 + ExtraNotes + CallStackNotes);
810 addDiag(Loc, DiagId);
811 if (!checkingPotentialConstantExpression())
813 return OptionalDiagnostic(&(*EvalStatus.
Diag)[0].second);
815 HasActiveDiagnostic =
false;
816 return OptionalDiagnostic();
822 diag::kind DiagId = diag::note_invalid_subexpr_in_const_expr,
823 unsigned ExtraNotes = 0) {
824 return Diag(Loc, DiagId, ExtraNotes,
false);
828 = diag::note_invalid_subexpr_in_const_expr,
829 unsigned ExtraNotes = 0) {
832 HasActiveDiagnostic =
false;
833 return OptionalDiagnostic();
842 = diag::note_invalid_subexpr_in_const_expr,
843 unsigned ExtraNotes = 0) {
846 if (!EvalStatus.
Diag || !EvalStatus.
Diag->empty()) {
847 HasActiveDiagnostic =
false;
848 return OptionalDiagnostic();
850 return Diag(Loc, DiagId, ExtraNotes,
true);
853 = diag::note_invalid_subexpr_in_const_expr,
854 unsigned ExtraNotes = 0) {
855 return CCEDiag(E->
getExprLoc(), DiagId, ExtraNotes);
859 if (!HasActiveDiagnostic)
860 return OptionalDiagnostic();
861 return OptionalDiagnostic(&addDiag(Loc, DiagId));
866 if (HasActiveDiagnostic) {
867 EvalStatus.
Diag->insert(EvalStatus.
Diag->end(),
868 Diags.begin(), Diags.end());
874 bool keepEvaluatingAfterSideEffect() {
876 case EM_PotentialConstantExpression:
877 case EM_PotentialConstantExpressionUnevaluated:
878 case EM_EvaluateForOverflow:
879 case EM_IgnoreSideEffects:
882 case EM_ConstantExpression:
883 case EM_ConstantExpressionUnevaluated:
884 case EM_ConstantFold:
888 llvm_unreachable(
"Missed EvalMode case");
893 bool noteSideEffect() {
895 return keepEvaluatingAfterSideEffect();
899 bool keepEvaluatingAfterUndefinedBehavior() {
901 case EM_EvaluateForOverflow:
902 case EM_IgnoreSideEffects:
903 case EM_ConstantFold:
907 case EM_PotentialConstantExpression:
908 case EM_PotentialConstantExpressionUnevaluated:
909 case EM_ConstantExpression:
910 case EM_ConstantExpressionUnevaluated:
913 llvm_unreachable(
"Missed EvalMode case");
919 bool noteUndefinedBehavior() {
921 return keepEvaluatingAfterUndefinedBehavior();
926 bool keepEvaluatingAfterFailure() {
931 case EM_PotentialConstantExpression:
932 case EM_PotentialConstantExpressionUnevaluated:
933 case EM_EvaluateForOverflow:
936 case EM_ConstantExpression:
937 case EM_ConstantExpressionUnevaluated:
938 case EM_ConstantFold:
939 case EM_IgnoreSideEffects:
943 llvm_unreachable(
"Missed EvalMode case");
956 LLVM_NODISCARD
bool noteFailure() {
964 bool KeepGoing = keepEvaluatingAfterFailure();
969 class ArrayInitLoopIndex {
974 ArrayInitLoopIndex(EvalInfo &Info)
975 : Info(Info), OuterIndex(Info.ArrayInitIndex) {
976 Info.ArrayInitIndex = 0;
978 ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
980 operator uint64_t&() {
return Info.ArrayInitIndex; }
985 struct FoldConstant {
988 bool HadNoPriorDiags;
989 EvalInfo::EvaluationMode OldMode;
991 explicit FoldConstant(EvalInfo &Info,
bool Enabled)
994 HadNoPriorDiags(Info.EvalStatus.Diag &&
995 Info.EvalStatus.Diag->empty() &&
996 !Info.EvalStatus.HasSideEffects),
997 OldMode(Info.EvalMode) {
999 (Info.EvalMode == EvalInfo::EM_ConstantExpression ||
1000 Info.EvalMode == EvalInfo::EM_ConstantExpressionUnevaluated))
1001 Info.EvalMode = EvalInfo::EM_ConstantFold;
1003 void keepDiagnostics() { Enabled =
false; }
1005 if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
1006 !Info.EvalStatus.HasSideEffects)
1007 Info.EvalStatus.Diag->clear();
1008 Info.EvalMode = OldMode;
1014 struct FoldOffsetRAII {
1016 EvalInfo::EvaluationMode OldMode;
1017 explicit FoldOffsetRAII(EvalInfo &Info)
1018 : Info(Info), OldMode(Info.EvalMode) {
1019 if (!Info.checkingPotentialConstantExpression())
1020 Info.EvalMode = EvalInfo::EM_OffsetFold;
1023 ~FoldOffsetRAII() { Info.EvalMode = OldMode; }
1028 class SpeculativeEvaluationRAII {
1029 EvalInfo *Info =
nullptr;
1031 bool OldIsSpeculativelyEvaluating;
1033 void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
1035 OldStatus = Other.OldStatus;
1036 OldIsSpeculativelyEvaluating = Other.OldIsSpeculativelyEvaluating;
1037 Other.Info =
nullptr;
1040 void maybeRestoreState() {
1044 Info->EvalStatus = OldStatus;
1045 Info->IsSpeculativelyEvaluating = OldIsSpeculativelyEvaluating;
1049 SpeculativeEvaluationRAII() =
default;
1051 SpeculativeEvaluationRAII(
1053 : Info(&Info), OldStatus(Info.EvalStatus),
1054 OldIsSpeculativelyEvaluating(Info.IsSpeculativelyEvaluating) {
1055 Info.EvalStatus.Diag = NewDiag;
1056 Info.IsSpeculativelyEvaluating =
true;
1059 SpeculativeEvaluationRAII(
const SpeculativeEvaluationRAII &Other) =
delete;
1060 SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
1061 moveFromAndCancel(std::move(Other));
1064 SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
1065 maybeRestoreState();
1066 moveFromAndCancel(std::move(Other));
1070 ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
1075 template<
bool IsFullExpression>
1078 unsigned OldStackSize;
1080 ScopeRAII(EvalInfo &Info)
1081 : Info(Info), OldStackSize(Info.CleanupStack.size()) {}
1088 static void cleanup(EvalInfo &Info,
unsigned OldStackSize) {
1089 unsigned NewEnd = OldStackSize;
1090 for (
unsigned I = OldStackSize, N = Info.CleanupStack.size();
1092 if (IsFullExpression && Info.CleanupStack[I].isLifetimeExtended()) {
1095 std::swap(Info.CleanupStack[I], Info.CleanupStack[NewEnd]);
1099 Info.CleanupStack[I].endLifetime();
1102 Info.CleanupStack.erase(Info.CleanupStack.begin() + NewEnd,
1103 Info.CleanupStack.end());
1106 typedef ScopeRAII<false> BlockScopeRAII;
1107 typedef ScopeRAII<true> FullExpressionRAII;
1110 bool SubobjectDesignator::checkSubobject(EvalInfo &Info,
const Expr *E,
1114 if (isOnePastTheEnd()) {
1115 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
1126 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
1128 Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
1133 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
1138 if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
1139 Info.CCEDiag(E, diag::note_constexpr_array_index)
1141 <<
static_cast<unsigned>(getMostDerivedArraySize());
1143 Info.CCEDiag(E, diag::note_constexpr_array_index)
1148 CallStackFrame::CallStackFrame(EvalInfo &Info,
SourceLocation CallLoc,
1151 : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
1152 Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
1153 Info.CurrentCall =
this;
1154 ++Info.CallStackDepth;
1157 CallStackFrame::~CallStackFrame() {
1158 assert(Info.CurrentCall ==
this &&
"calls retired out of order");
1159 --Info.CallStackDepth;
1160 Info.CurrentCall = Caller;
1163 APValue &CallStackFrame::createTemporary(
const void *Key,
1164 bool IsLifetimeExtended) {
1166 assert(Result.
isUninit() &&
"temporary created multiple times");
1167 Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended));
1171 static void describeCall(CallStackFrame *Frame, raw_ostream &Out);
1173 void EvalInfo::addCallStack(
unsigned Limit) {
1175 unsigned ActiveCalls = CallStackDepth - 1;
1176 unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart;
1177 if (Limit && Limit < ActiveCalls) {
1178 SkipStart = Limit / 2 + Limit % 2;
1179 SkipEnd = ActiveCalls - Limit / 2;
1183 unsigned CallIdx = 0;
1184 for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame;
1185 Frame = Frame->Caller, ++CallIdx) {
1187 if (CallIdx >= SkipStart && CallIdx < SkipEnd) {
1188 if (CallIdx == SkipStart) {
1190 addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed)
1191 << unsigned(ActiveCalls - Limit);
1198 if (
auto *CD = dyn_cast_or_null<CXXConstructorDecl>(Frame->Callee)) {
1199 if (CD->isInheritingConstructor()) {
1200 addDiag(Frame->CallLoc, diag::note_constexpr_inherited_ctor_call_here)
1207 llvm::raw_svector_ostream Out(Buffer);
1209 addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str();
1214 struct ComplexValue {
1219 APSInt IntReal, IntImag;
1220 APFloat FloatReal, FloatImag;
1222 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
1224 void makeComplexFloat() { IsInt =
false; }
1225 bool isComplexFloat()
const {
return !IsInt; }
1226 APFloat &getComplexFloatReal() {
return FloatReal; }
1227 APFloat &getComplexFloatImag() {
return FloatImag; }
1229 void makeComplexInt() { IsInt =
true; }
1230 bool isComplexInt()
const {
return IsInt; }
1231 APSInt &getComplexIntReal() {
return IntReal; }
1232 APSInt &getComplexIntImag() {
return IntImag; }
1235 if (isComplexFloat())
1236 v =
APValue(FloatReal, FloatImag);
1238 v =
APValue(IntReal, IntImag);
1240 void setFrom(
const APValue &v) {
1257 unsigned InvalidBase : 1;
1258 unsigned CallIndex : 31;
1265 unsigned getLValueCallIndex()
const {
return CallIndex; }
1266 SubobjectDesignator &getLValueDesignator() {
return Designator; }
1267 const SubobjectDesignator &getLValueDesignator()
const {
return Designator;}
1268 bool isNullPointer()
const {
return IsNullPtr;}
1270 void moveInto(
APValue &V)
const {
1271 if (Designator.Invalid)
1275 assert(!InvalidBase &&
"APValues can't handle invalid LValue bases");
1276 V =
APValue(Base, Offset, Designator.Entries,
1277 Designator.IsOnePastTheEnd, CallIndex, IsNullPtr);
1281 assert(V.
isLValue() &&
"Setting LValue from a non-LValue?");
1284 InvalidBase =
false;
1286 Designator = SubobjectDesignator(Ctx, V);
1294 const auto *E = B.get<
const Expr *>();
1295 assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
1296 "Unexpected type of invalid base");
1302 InvalidBase = BInvalid;
1304 Designator = SubobjectDesignator(getType(B));
1308 void setNull(
QualType PointerTy, uint64_t TargetVal) {
1309 Base = (
Expr *)
nullptr;
1311 InvalidBase =
false;
1323 bool checkNullPointer(EvalInfo &Info,
const Expr *E,
1325 if (Designator.Invalid)
1328 Info.CCEDiag(E, diag::note_constexpr_null_subobject)
1330 Designator.setInvalid();
1339 return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
1340 Designator.checkSubobject(Info, E, CSK);
1343 void addDecl(EvalInfo &Info,
const Expr *E,
1344 const Decl *D,
bool Virtual =
false) {
1345 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
1346 Designator.addDeclUnchecked(D, Virtual);
1348 void addUnsizedArray(EvalInfo &Info,
const Expr *E,
QualType ElemTy) {
1349 if (!Designator.Entries.empty()) {
1350 Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
1351 Designator.setInvalid();
1354 if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
1355 assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
1356 Designator.FirstEntryIsAnUnsizedArray =
true;
1357 Designator.addUnsizedArrayUnchecked(ElemTy);
1361 if (checkSubobject(Info, E, CSK_ArrayToPointer))
1362 Designator.addArrayUnchecked(CAT);
1364 void addComplex(EvalInfo &Info,
const Expr *E,
QualType EltTy,
bool Imag) {
1365 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
1366 Designator.addComplexUnchecked(EltTy, Imag);
1368 void clearIsNullPointer() {
1371 void adjustOffsetAndIndex(EvalInfo &Info,
const Expr *E,
1372 const APSInt &Index,
CharUnits ElementSize) {
1383 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
1386 if (checkNullPointer(Info, E, CSK_ArrayIndex))
1387 Designator.adjustIndex(Info, E, Index);
1388 clearIsNullPointer();
1393 clearIsNullPointer();
1400 DeclAndIsDerivedMember(Decl,
false), Path() {}
1405 return DeclAndIsDerivedMember.getPointer();
1408 bool isDerivedMember()
const {
1409 return DeclAndIsDerivedMember.getInt();
1413 return cast<CXXRecordDecl>(
1414 DeclAndIsDerivedMember.getPointer()->getDeclContext());
1417 void moveInto(
APValue &V)
const {
1418 V =
APValue(getDecl(), isDerivedMember(), Path);
1420 void setFrom(
const APValue &V) {
1426 Path.insert(Path.end(), P.begin(), P.end());
1432 llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
1440 assert(!Path.empty());
1442 if (Path.size() >= 2)
1443 Expected = Path[Path.size() - 2];
1445 Expected = getContainingRecord();
1462 if (!isDerivedMember()) {
1463 Path.push_back(Derived);
1466 if (!castBack(Derived))
1469 DeclAndIsDerivedMember.setInt(
false);
1477 DeclAndIsDerivedMember.setInt(
true);
1478 if (isDerivedMember()) {
1479 Path.push_back(Base);
1482 return castBack(Base);
1487 static bool operator==(
const MemberPtr &LHS,
const MemberPtr &RHS) {
1488 if (!LHS.getDecl() || !RHS.getDecl())
1489 return !LHS.getDecl() && !RHS.getDecl();
1490 if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
1492 return LHS.Path == RHS.Path;
1498 const LValue &This,
const Expr *E,
1499 bool AllowNonLiteralTypes =
false);
1501 bool InvalidBaseOK =
false);
1503 bool InvalidBaseOK =
false);
1523 if (Int.isUnsigned() || Int.isMinSignedValue()) {
1524 Int = Int.extend(Int.getBitWidth() + 1);
1525 Int.setIsSigned(
true);
1532 unsigned ArgIndex = 0;
1533 bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) &&
1534 !isa<CXXConstructorDecl>(Frame->Callee) &&
1535 cast<CXXMethodDecl>(Frame->Callee)->isInstance();
1538 Out << *Frame->Callee <<
'(';
1540 if (Frame->This && IsMemberCall) {
1542 Frame->This->moveInto(Val);
1544 Frame->This->Designator.MostDerivedType);
1546 Out <<
"->" << *Frame->Callee <<
'(';
1547 IsMemberCall =
false;
1551 E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) {
1552 if (ArgIndex > (
unsigned)IsMemberCall)
1556 const APValue &Arg = Frame->Arguments[ArgIndex];
1559 if (ArgIndex == 0 && IsMemberCall)
1560 Out <<
"->" << *Frame->Callee <<
'(';
1573 return Info.noteSideEffect();
1580 return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
1581 Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
1590 if (!B)
return true;
1594 if (
const VarDecl *VD = dyn_cast<VarDecl>(D))
1595 return VD->hasGlobalStorage();
1597 return isa<FunctionDecl>(D);
1600 const Expr *E = B.get<
const Expr*>();
1601 switch (E->getStmtClass()) {
1604 case Expr::CompoundLiteralExprClass: {
1608 case Expr::MaterializeTemporaryExprClass:
1611 return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() ==
SD_Static;
1613 case Expr::StringLiteralClass:
1614 case Expr::PredefinedExprClass:
1615 case Expr::ObjCStringLiteralClass:
1616 case Expr::ObjCEncodeExprClass:
1617 case Expr::CXXTypeidExprClass:
1618 case Expr::CXXUuidofExprClass:
1620 case Expr::CallExprClass:
1623 case Expr::AddrLabelExprClass:
1627 case Expr::BlockExprClass:
1628 return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures();
1629 case Expr::ImplicitValueInitExprClass:
1641 assert(Base &&
"no location for a null lvalue");
1644 Info.Note(VD->
getLocation(), diag::note_declared_at);
1647 diag::note_constexpr_temporary_here);
1654 QualType Type,
const LValue &LVal) {
1658 const SubobjectDesignator &
Designator = LVal.getLValueDesignator();
1664 if (Info.getLangOpts().CPlusPlus11) {
1666 Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
1667 << IsReferenceType << !Designator.Entries.empty()
1676 assert((Info.checkingPotentialConstantExpression() ||
1677 LVal.getLValueCallIndex() == 0) &&
1678 "have call index for global lvalue");
1681 if (
const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
1683 if (Var->getTLSKind())
1687 if (Var->hasAttr<DLLImportAttr>())
1690 if (
const auto *FD = dyn_cast<const FunctionDecl>(VD)) {
1701 if (Info.getLangOpts().CPlusPlus && FD->hasAttr<DLLImportAttr>())
1708 if (!IsReferenceType)
1719 if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
1721 Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
1722 << !Designator.Entries.empty() << !!VD << VD;
1736 const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
1739 return FD->isVirtual() || !FD->
hasAttr<DLLImportAttr>();
1745 const LValue *This =
nullptr) {
1762 if (This && Info.EvaluatingDecl == This->getLValueBase())
1766 if (Info.getLangOpts().CPlusPlus11)
1767 Info.FFDiag(E, diag::note_constexpr_nonliteral)
1770 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
1780 Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
1788 Type = AT->getValueType();
1812 if (
const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
1813 unsigned BaseIndex = 0;
1815 End = CD->bases_end(); I !=
End; ++I, ++BaseIndex) {
1821 for (
const auto *I : RD->
fields()) {
1822 if (I->isUnnamedBitfield())
1833 LVal.setFrom(Info.Ctx, Value);
1845 return LVal.Base.dyn_cast<
const ValueDecl*>();
1849 if (Value.CallIndex)
1851 const Expr *E = Value.Base.dyn_cast<
const Expr*>();
1852 return E && !isa<MaterializeTemporaryExpr>(E);
1857 return Decl && Decl->
isWeak();
1862 if (Decl && isa<VarDecl>(Decl)) {
1883 return !Decl || !Decl->
isWeak();
1891 Result = Val.
getInt().getBoolValue();
1917 llvm_unreachable(
"unknown APValue kind");
1922 assert(E->
isRValue() &&
"missing lvalue-to-rvalue conv in bool condition");
1929 template<
typename T>
1932 Info.CCEDiag(E, diag::note_constexpr_overflow)
1933 << SrcValue << DestType;
1934 return Info.noteUndefinedBehavior();
1938 QualType SrcType,
const APFloat &Value,
1939 QualType DestType, APSInt &Result) {
1940 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1944 Result = APSInt(DestWidth, !DestSigned);
1946 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
1947 & APFloat::opInvalidOp)
1957 if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
1958 APFloat::rmNearestTiesToEven, &ignored)
1959 & APFloat::opOverflow)
1966 const APSInt &Value) {
1967 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1968 APSInt Result =
Value;
1971 Result = Result.extOrTrunc(DestWidth);
1977 QualType SrcType,
const APSInt &Value,
1978 QualType DestType, APFloat &Result) {
1979 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
1980 if (Result.convertFromAPInt(Value, Value.isSigned(),
1981 APFloat::rmNearestTiesToEven)
1982 & APFloat::opOverflow)
1989 assert(FD->
isBitField() &&
"truncateBitfieldValue on non-bitfield");
1991 if (!Value.
isInt()) {
1995 assert(Value.
isLValue() &&
"integral value neither int nor lvalue?");
2000 APSInt &Int = Value.
getInt();
2001 unsigned OldBitWidth = Int.getBitWidth();
2003 if (NewBitWidth < OldBitWidth)
2004 Int = Int.trunc(NewBitWidth).extend(OldBitWidth);
2018 Res = SVal.
getFloat().bitcastToAPInt();
2023 unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
2025 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
2026 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
2027 Res = llvm::APInt::getNullValue(VecSize);
2030 llvm::APInt EltAsInt;
2034 EltAsInt = Elt.
getFloat().bitcastToAPInt();
2038 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2041 unsigned BaseEltSize = EltAsInt.getBitWidth();
2043 Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
2045 Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
2051 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2058 template<
typename Operation>
2060 const APSInt &LHS,
const APSInt &RHS,
2061 unsigned BitWidth, Operation Op,
2063 if (LHS.isUnsigned()) {
2064 Result = Op(LHS, RHS);
2068 APSInt
Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)),
false);
2069 Result = Value.trunc(LHS.getBitWidth());
2070 if (Result.extend(BitWidth) !=
Value) {
2071 if (Info.checkingForOverflow())
2072 Info.Ctx.getDiagnostics().Report(E->
getExprLoc(),
2073 diag::warn_integer_constant_overflow)
2074 << Result.toString(10) << E->
getType();
2091 std::multiplies<APSInt>(), Result);
2094 std::plus<APSInt>(), Result);
2097 std::minus<APSInt>(), Result);
2098 case BO_And: Result = LHS & RHS;
return true;
2099 case BO_Xor: Result = LHS ^ RHS;
return true;
2100 case BO_Or: Result = LHS | RHS;
return true;
2104 Info.FFDiag(E, diag::note_expr_divide_by_zero);
2107 Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
2110 if (RHS.isNegative() && RHS.isAllOnesValue() &&
2111 LHS.isSigned() && LHS.isMinSignedValue())
2112 return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
2116 if (Info.getLangOpts().OpenCL)
2118 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2119 static_cast<uint64_t
>(LHS.getBitWidth() - 1)),
2121 else if (RHS.isSigned() && RHS.isNegative()) {
2124 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2131 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2133 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2134 << RHS << E->
getType() << LHS.getBitWidth();
2135 }
else if (LHS.isSigned()) {
2138 if (LHS.isNegative())
2139 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
2140 else if (LHS.countLeadingZeros() < SA)
2141 Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
2147 if (Info.getLangOpts().OpenCL)
2149 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
2150 static_cast<uint64_t
>(LHS.getBitWidth() - 1)),
2152 else if (RHS.isSigned() && RHS.isNegative()) {
2155 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
2162 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
2164 Info.CCEDiag(E, diag::note_constexpr_large_shift)
2165 << RHS << E->
getType() << LHS.getBitWidth();
2170 case BO_LT: Result = LHS < RHS;
return true;
2171 case BO_GT: Result = LHS > RHS;
return true;
2172 case BO_LE: Result = LHS <= RHS;
return true;
2173 case BO_GE: Result = LHS >= RHS;
return true;
2174 case BO_EQ: Result = LHS == RHS;
return true;
2175 case BO_NE: Result = LHS != RHS;
return true;
2182 const APFloat &RHS) {
2188 LHS.multiply(RHS, APFloat::rmNearestTiesToEven);
2191 LHS.add(RHS, APFloat::rmNearestTiesToEven);
2194 LHS.subtract(RHS, APFloat::rmNearestTiesToEven);
2197 LHS.divide(RHS, APFloat::rmNearestTiesToEven);
2201 if (LHS.isInfinity() || LHS.isNaN()) {
2202 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
2203 return Info.noteUndefinedBehavior();
2212 unsigned TruncatedElements) {
2213 SubobjectDesignator &D = Result.Designator;
2216 if (TruncatedElements == D.Entries.size())
2218 assert(TruncatedElements >= D.MostDerivedPathLength &&
2219 "not casting to a derived class");
2220 if (!Result.checkSubobject(Info, E, CSK_Derived))
2225 for (
unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) {
2229 if (isVirtualBaseClass(D.Entries[I]))
2235 D.Entries.resize(TruncatedElements);
2245 RL = &Info.Ctx.getASTRecordLayout(Derived);
2248 Obj.getLValueOffset() += RL->getBaseClassOffset(Base);
2249 Obj.addDecl(Info, E, Base,
false);
2261 SubobjectDesignator &D = Obj.Designator;
2266 DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl();
2272 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
2274 Obj.addDecl(Info, E, BaseDecl,
true);
2282 PathI != PathE; ++PathI) {
2286 Type = (*PathI)->getType();
2298 RL = &Info.Ctx.getASTRecordLayout(FD->
getParent());
2302 LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)));
2303 LVal.addDecl(Info, E, FD);
2311 for (
const auto *
C : IFD->
chain())
2339 Size = Info.Ctx.getTypeSizeInChars(Type);
2351 APSInt Adjustment) {
2356 LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee);
2362 int64_t Adjustment) {
2364 APSInt::get(Adjustment));
2379 LVal.Offset += SizeOfComponent;
2381 LVal.addComplex(Info, E, EltTy, Imag);
2398 const VarDecl *VD, CallStackFrame *Frame,
2403 if (
const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) {
2406 if (Info.checkingPotentialConstantExpression())
2408 if (!Frame || !Frame->Arguments) {
2409 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2412 Result = &Frame->Arguments[PVD->getFunctionScopeIndex()];
2418 Result = Frame->getTemporary(VD);
2426 "missing value for local variable");
2427 if (Info.checkingPotentialConstantExpression())
2431 diag::note_unimplemented_constexpr_lambda_feature_ast)
2432 <<
"captures not currently allowed";
2443 if (!Info.checkingPotentialConstantExpression())
2444 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2450 if (Info.EvaluatingDecl.dyn_cast<
const ValueDecl*>() == VD) {
2451 Result = Info.EvaluatingDeclValue;
2458 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2466 Info.FFDiag(E, diag::note_constexpr_var_init_non_constant,
2467 Notes.size() + 1) << VD;
2468 Info.Note(VD->
getLocation(), diag::note_declared_at);
2469 Info.addNotes(Notes);
2472 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2473 Notes.size() + 1) << VD;
2474 Info.Note(VD->
getLocation(), diag::note_declared_at);
2475 Info.addNotes(Notes);
2494 E = Derived->
bases_end(); I != E; ++I, ++Index) {
2495 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
2499 llvm_unreachable(
"base class missing from derived class's bases list");
2506 if (
const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
2508 Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
2509 assert(Index <= Str.size() &&
"Index too large");
2510 return APSInt::getUnsigned(Str.c_str()[Index]);
2513 if (
auto PE = dyn_cast<PredefinedExpr>(Lit))
2514 Lit = PE->getFunctionName();
2517 Info.Ctx.getAsConstantArrayType(S->
getType());
2518 assert(CAT &&
"string literal isn't an array");
2519 QualType CharType = CAT->getElementType();
2520 assert(CharType->
isIntegerType() &&
"unexpected character type");
2524 if (Index < S->getLength())
2534 Info.Ctx.getAsConstantArrayType(S->
getType());
2535 assert(CAT &&
"string literal isn't an array");
2536 QualType CharType = CAT->getElementType();
2537 assert(CharType->
isIntegerType() &&
"unexpected character type");
2539 unsigned Elts = CAT->getSize().getZExtValue();
2555 assert(Index < Size);
2559 unsigned NewElts =
std::max(Index+1, OldElts * 2);
2564 for (
unsigned I = 0; I != OldElts; ++I)
2566 for (
unsigned I = OldElts; I != NewElts; ++I)
2570 Array.
swap(NewValue);
2585 for (
auto *Field : RD->
fields())
2589 for (
auto &BaseSpec : RD->
bases())
2607 for (
auto *Field : RD->
fields()) {
2612 if (Field->isMutable() &&
2614 Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1) << Field;
2615 Info.Note(Field->getLocation(), diag::note_declared_at);
2623 for (
auto &BaseSpec : RD->
bases())
2642 struct CompleteObject {
2648 CompleteObject() :
Value(
nullptr) {}
2650 :
Value(Value), Type(Type) {
2651 assert(Value &&
"missing value for complete object");
2654 explicit operator bool()
const {
return Value; }
2659 template<
typename Sub
objectHandler>
2660 typename SubobjectHandler::result_type
2662 const SubobjectDesignator &Sub, SubobjectHandler &handler) {
2665 return handler.failed();
2666 if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {
2667 if (Info.getLangOpts().CPlusPlus11)
2668 Info.FFDiag(E, Sub.isOnePastTheEnd()
2669 ? diag::note_constexpr_access_past_end
2670 : diag::note_constexpr_access_unsized_array)
2671 << handler.AccessKind;
2674 return handler.failed();
2682 for (
unsigned I = 0, N = Sub.Entries.size(); ; ++I) {
2684 if (!Info.checkingPotentialConstantExpression())
2685 Info.FFDiag(E, diag::note_constexpr_access_uninit) << handler.AccessKind;
2686 return handler.failed();
2696 return handler.failed();
2698 if (!handler.found(*O, ObjType))
2702 if (handler.AccessKind !=
AK_Read &&
2710 LastField =
nullptr;
2714 assert(CAT &&
"vla in literal type?");
2715 uint64_t Index = Sub.Entries[I].ArrayIndex;
2716 if (CAT->
getSize().ule(Index)) {
2719 if (Info.getLangOpts().CPlusPlus11)
2720 Info.FFDiag(E, diag::note_constexpr_access_past_end)
2721 << handler.AccessKind;
2724 return handler.failed();
2732 assert(I == N - 1 &&
"extracting subobject of character?");
2734 if (handler.AccessKind !=
AK_Read)
2738 return handler.foundString(*O, ObjType, Index);
2743 else if (handler.AccessKind !=
AK_Read) {
2750 uint64_t Index = Sub.Entries[I].ArrayIndex;
2752 if (Info.getLangOpts().CPlusPlus11)
2753 Info.FFDiag(E, diag::note_constexpr_access_past_end)
2754 << handler.AccessKind;
2757 return handler.failed();
2762 if (WasConstQualified)
2765 assert(I == N - 1 &&
"extracting subobject of scalar?");
2774 }
else if (
const FieldDecl *Field = getAsField(Sub.Entries[I])) {
2775 if (Field->isMutable() && handler.AccessKind ==
AK_Read) {
2776 Info.FFDiag(E, diag::note_constexpr_ltor_mutable, 1)
2778 Info.Note(Field->getLocation(), diag::note_declared_at);
2779 return handler.failed();
2788 Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member)
2789 << handler.AccessKind << Field << !UnionField << UnionField;
2790 return handler.failed();
2797 ObjType = Field->getType();
2798 if (WasConstQualified && !Field->isMutable())
2802 if (Info.getLangOpts().CPlusPlus) {
2804 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
2805 << handler.AccessKind << 2 << Field;
2806 Info.Note(Field->getLocation(), diag::note_declared_at);
2808 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
2810 return handler.failed();
2821 ObjType = Info.Ctx.getRecordType(Base);
2822 if (WasConstQualified)
2829 struct ExtractSubobjectHandler {
2835 typedef bool result_type;
2836 bool failed() {
return false; }
2841 bool found(APSInt &Value,
QualType SubobjType) {
2845 bool found(APFloat &Value,
QualType SubobjType) {
2849 bool foundString(
APValue &Subobj,
QualType SubobjType, uint64_t Character) {
2861 const CompleteObject &Obj,
2862 const SubobjectDesignator &Sub,
2864 ExtractSubobjectHandler Handler = { Info, Result };
2869 struct ModifySubobjectHandler {
2874 typedef bool result_type;
2880 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
2886 bool failed() {
return false; }
2888 if (!checkConst(SubobjType))
2891 Subobj.
swap(NewVal);
2894 bool found(APSInt &Value,
QualType SubobjType) {
2895 if (!checkConst(SubobjType))
2897 if (!NewVal.
isInt()) {
2905 bool found(APFloat &Value,
QualType SubobjType) {
2906 if (!checkConst(SubobjType))
2911 bool foundString(
APValue &Subobj,
QualType SubobjType, uint64_t Character) {
2912 llvm_unreachable(
"shouldn't encounter string elements with ExpandArrays");
2921 const CompleteObject &Obj,
2922 const SubobjectDesignator &Sub,
2924 ModifySubobjectHandler Handler = { Info, NewVal, E };
2931 const SubobjectDesignator &A,
2932 const SubobjectDesignator &B,
2933 bool &WasArrayIndex) {
2934 unsigned I = 0, N =
std::min(A.Entries.size(), B.Entries.size());
2935 for (; I != N; ++I) {
2939 if (A.Entries[I].ArrayIndex != B.Entries[I].ArrayIndex) {
2940 WasArrayIndex =
true;
2948 if (A.Entries[I].BaseOrMember != B.Entries[I].BaseOrMember) {
2949 WasArrayIndex =
false;
2952 if (
const FieldDecl *FD = getAsField(A.Entries[I]))
2954 ObjType = FD->getType();
2960 WasArrayIndex =
false;
2967 const SubobjectDesignator &A,
2968 const SubobjectDesignator &B) {
2969 if (A.Entries.size() != B.Entries.size())
2972 bool IsArray = A.MostDerivedIsArrayElement;
2973 if (IsArray && A.MostDerivedPathLength != A.Entries.size())
2982 return CommonLength >= A.Entries.size() - IsArray;
2990 Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
2991 return CompleteObject();
2994 CallStackFrame *Frame =
nullptr;
2995 if (LVal.CallIndex) {
2996 Frame = Info.getCallFrame(LVal.CallIndex);
2998 Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
2999 << AK << LVal.Base.is<
const ValueDecl*>();
3001 return CompleteObject();
3010 if (Info.getLangOpts().CPlusPlus)
3011 Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
3015 return CompleteObject();
3020 QualType BaseType = getType(LVal.Base);
3037 return CompleteObject();
3042 if (Info.getLangOpts().CPlusPlus) {
3043 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3045 Info.Note(VD->getLocation(), diag::note_declared_at);
3049 return CompleteObject();
3055 if (Info.getLangOpts().CPlusPlus14 &&
3056 VD == Info.EvaluatingDecl.dyn_cast<
const ValueDecl *>()) {
3062 Info.FFDiag(E, diag::note_constexpr_modify_global);
3063 return CompleteObject();
3069 (Info.getLangOpts().OpenCL &&
3071 if (Info.getLangOpts().CPlusPlus) {
3072 Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
3073 Info.Note(VD->
getLocation(), diag::note_declared_at);
3077 return CompleteObject();
3083 if (Info.getLangOpts().CPlusPlus11) {
3084 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3085 Info.Note(VD->
getLocation(), diag::note_declared_at);
3090 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD;
3094 if (Info.checkingPotentialConstantExpression() &&
3098 }
else if (Info.getLangOpts().CPlusPlus11) {
3099 Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
3100 Info.Note(VD->
getLocation(), diag::note_declared_at);
3104 return CompleteObject();
3109 return CompleteObject();
3111 const Expr *Base = LVal.Base.dyn_cast<
const Expr*>();
3115 dyn_cast<MaterializeTemporaryExpr>(Base)) {
3116 assert(MTE->getStorageDuration() ==
SD_Static &&
3117 "should have a frame for a non-global materialized temporary");
3134 const ValueDecl *ED = MTE->getExtendingDecl();
3137 !(VD && VD->getCanonicalDecl() == ED->getCanonicalDecl())) {
3138 Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
3139 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
3140 return CompleteObject();
3143 BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE,
false);
3144 assert(BaseVal &&
"got reference to unevaluated temporary");
3147 return CompleteObject();
3150 BaseVal = Frame->getTemporary(Base);
3151 assert(BaseVal &&
"missing value for temporary");
3156 if (Info.getLangOpts().CPlusPlus) {
3157 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
3159 Info.Note(Base->
getExprLoc(), diag::note_constexpr_temporary_here);
3163 return CompleteObject();
3170 if (Info.isEvaluatingConstructor(LVal.getLValueBase(), LVal.CallIndex)) {
3171 BaseType = Info.Ctx.getCanonicalType(BaseType);
3180 if ((Frame && Info.getLangOpts().CPlusPlus14 &&
3181 Info.EvalStatus.HasSideEffects) ||
3182 (AK !=
AK_Read && Info.IsSpeculativelyEvaluating))
3183 return CompleteObject();
3185 return CompleteObject(BaseVal, BaseType);
3201 const LValue &LVal,
APValue &RVal) {
3202 if (LVal.Designator.Invalid)
3206 const Expr *Base = LVal.Base.dyn_cast<
const Expr*>();
3217 if (!
Evaluate(Lit, Info, CLE->getInitializer()))
3219 CompleteObject LitObj(&Lit, Base->
getType());
3221 }
else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {
3226 CompleteObject StrObj(&Str, Base->
getType());
3238 if (LVal.Designator.Invalid)
3241 if (!Info.getLangOpts().CPlusPlus14) {
3256 struct CompoundAssignSubobjectHandler {
3265 typedef bool result_type;
3270 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3276 bool failed() {
return false; }
3280 return found(Subobj.
getInt(), SubobjType);
3282 return found(Subobj.
getFloat(), SubobjType);
3289 return foundPointer(Subobj, SubobjType);
3296 bool found(APSInt &Value,
QualType SubobjType) {
3297 if (!checkConst(SubobjType))
3314 bool found(APFloat &Value,
QualType SubobjType) {
3315 return checkConst(SubobjType) &&
3322 if (!checkConst(SubobjType))
3330 (Opcode != BO_Add && Opcode != BO_Sub)) {
3336 if (Opcode == BO_Sub)
3340 LVal.setFrom(Info.Ctx, Subobj);
3343 LVal.moveInto(Subobj);
3346 bool foundString(
APValue &Subobj,
QualType SubobjType, uint64_t Character) {
3347 llvm_unreachable(
"shouldn't encounter string elements here");
3356 EvalInfo &Info,
const Expr *E,
3359 if (LVal.Designator.Invalid)
3362 if (!Info.getLangOpts().CPlusPlus14) {
3368 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
3370 return Obj &&
findSubobject(Info, E, Obj, LVal.Designator, Handler);
3374 struct IncDecSubobjectHandler {
3380 typedef bool result_type;
3385 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;
3391 bool failed() {
return false; }
3402 return found(Subobj.
getInt(), SubobjType);
3404 return found(Subobj.
getFloat(), SubobjType);
3414 return foundPointer(Subobj, SubobjType);
3421 bool found(APSInt &Value,
QualType SubobjType) {
3422 if (!checkConst(SubobjType))
3432 if (Old) *Old =
APValue(Value);
3444 bool WasNegative = Value.isNegative();
3448 if (!WasNegative && Value.isNegative() &&
3450 APSInt ActualValue(Value,
true);
3456 if (WasNegative && !Value.isNegative() &&
3458 unsigned BitWidth = Value.getBitWidth();
3459 APSInt ActualValue(Value.sext(BitWidth + 1),
false);
3460 ActualValue.setBit(BitWidth);
3466 bool found(APFloat &Value,
QualType SubobjType) {
3467 if (!checkConst(SubobjType))
3470 if (Old) *Old =
APValue(Value);
3472 APFloat One(Value.getSemantics(), 1);
3474 Value.add(One, APFloat::rmNearestTiesToEven);
3476 Value.subtract(One, APFloat::rmNearestTiesToEven);
3480 if (!checkConst(SubobjType))
3492 LVal.setFrom(Info.Ctx, Subobj);
3496 LVal.moveInto(Subobj);
3499 bool foundString(
APValue &Subobj,
QualType SubobjType, uint64_t Character) {
3500 llvm_unreachable(
"shouldn't encounter string elements here");
3508 if (LVal.Designator.Invalid)
3511 if (!Info.getLangOpts().CPlusPlus14) {
3518 IncDecSubobjectHandler Handler = { Info, E, AK, Old };
3519 return Obj &&
findSubobject(Info, E, Obj, LVal.Designator, Handler);
3534 Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->
getType();
3553 bool IncludeMember =
true) {
3560 if (!MemPtr.getDecl()) {
3566 if (MemPtr.isDerivedMember()) {
3570 if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() >
3571 LV.Designator.Entries.size()) {
3575 unsigned PathLengthToMember =
3576 LV.Designator.Entries.size() - MemPtr.Path.size();
3577 for (
unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) {
3579 LV.Designator.Entries[PathLengthToMember + I]);
3589 PathLengthToMember))
3591 }
else if (!MemPtr.Path.empty()) {
3593 LV.Designator.Entries.reserve(LV.Designator.Entries.size() +
3594 MemPtr.Path.size() + IncludeMember);
3600 assert(RD &&
"member pointer access on non-class-type expression");
3602 for (
unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
3610 MemPtr.getContainingRecord()))
3615 if (IncludeMember) {
3616 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
3620 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
3624 llvm_unreachable(
"can't construct reference to bound member function");
3628 return MemPtr.getDecl();
3634 bool IncludeMember =
true) {
3638 if (Info.noteFailure()) {
3646 BO->
getRHS(), IncludeMember);
3653 SubobjectDesignator &D = Result.Designator;
3654 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
3662 if (D.MostDerivedPathLength + E->
path_size() > D.Entries.size()) {
3663 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3664 << D.MostDerivedType << TargetQT;
3670 unsigned NewEntriesSize = D.Entries.size() - E->
path_size();
3673 if (NewEntriesSize == D.MostDerivedPathLength)
3674 FinalType = D.MostDerivedType->getAsCXXRecordDecl();
3676 FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
3678 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3679 << D.MostDerivedType << TargetQT;
3710 Result.set(VD, Info.CurrentCall->Index);
3711 APValue &Val = Info.CurrentCall->createTemporary(VD,
true);
3715 Info.FFDiag(VD->
getLocStart(), diag::note_constexpr_uninitialized)
3737 if (
const VarDecl *VD = dyn_cast<VarDecl>(D))
3741 for (
auto *BD : DD->bindings())
3742 if (
auto *VD = BD->getHoldingVar())
3751 const Expr *Cond,
bool &Result) {
3752 FullExpressionRAII
Scope(Info);
3777 BlockScopeRAII
Scope(Info);
3780 return ESR_Succeeded;
3783 return ESR_Continue;
3786 case ESR_CaseNotFound:
3789 llvm_unreachable(
"Invalid EvalStmtResult!");
3795 BlockScopeRAII
Scope(Info);
3800 FullExpressionRAII Scope(Info);
3803 if (ESR != ESR_Succeeded)
3818 if (isa<DefaultStmt>(SC)) {
3823 const CaseStmt *CS = cast<CaseStmt>(SC);
3827 if (LHS <= Value && Value <= RHS) {
3834 return ESR_Succeeded;
3839 return ESR_Succeeded;
3845 case ESR_CaseNotFound:
3848 Info.FFDiag(Found->
getLocStart(), diag::note_constexpr_stmt_expr_unsupported);
3851 llvm_unreachable(
"Invalid EvalStmtResult!");
3857 if (!Info.nextStep(S))
3868 case Stmt::CompoundStmtClass:
3872 case Stmt::LabelStmtClass:
3873 case Stmt::AttributedStmtClass:
3874 case Stmt::DoStmtClass:
3877 case Stmt::CaseStmtClass:
3878 case Stmt::DefaultStmtClass:
3883 case Stmt::IfStmtClass: {
3886 const IfStmt *IS = cast<IfStmt>(S);
3890 BlockScopeRAII
Scope(Info);
3893 if (ESR != ESR_CaseNotFound || !IS->
getElse())
3898 case Stmt::WhileStmtClass: {
3901 if (ESR != ESR_Continue)
3906 case Stmt::ForStmtClass: {
3907 const ForStmt *FS = cast<ForStmt>(S);
3910 if (ESR != ESR_Continue)
3913 FullExpressionRAII IncScope(Info);
3920 case Stmt::DeclStmtClass:
3924 return ESR_CaseNotFound;
3930 if (
const Expr *E = dyn_cast<Expr>(S)) {
3933 FullExpressionRAII
Scope(Info);
3936 return ESR_Succeeded;
3942 case Stmt::NullStmtClass:
3943 return ESR_Succeeded;
3945 case Stmt::DeclStmtClass: {
3946 const DeclStmt *DS = cast<DeclStmt>(S);
3947 for (
const auto *DclIt : DS->
decls()) {
3951 FullExpressionRAII
Scope(Info);
3955 return ESR_Succeeded;
3958 case Stmt::ReturnStmtClass: {
3959 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
3960 FullExpressionRAII
Scope(Info);
3963 ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
3964 : Evaluate(Result.Value, Info, RetExpr)))
3966 return ESR_Returned;
3969 case Stmt::CompoundStmtClass: {
3970 BlockScopeRAII
Scope(Info);
3973 for (
const auto *BI : CS->
body()) {
3975 if (ESR == ESR_Succeeded)
3977 else if (ESR != ESR_CaseNotFound)
3980 return Case ? ESR_CaseNotFound : ESR_Succeeded;
3983 case Stmt::IfStmtClass: {
3984 const IfStmt *IS = cast<IfStmt>(S);
3987 BlockScopeRAII
Scope(Info);
3990 if (ESR != ESR_Succeeded)
3999 if (ESR != ESR_Succeeded)
4002 return ESR_Succeeded;
4005 case Stmt::WhileStmtClass: {
4006 const WhileStmt *WS = cast<WhileStmt>(S);
4008 BlockScopeRAII
Scope(Info);
4017 if (ESR != ESR_Continue)
4020 return ESR_Succeeded;
4023 case Stmt::DoStmtClass: {
4024 const DoStmt *DS = cast<DoStmt>(S);
4028 if (ESR != ESR_Continue)
4032 FullExpressionRAII CondScope(Info);
4036 return ESR_Succeeded;
4039 case Stmt::ForStmtClass: {
4040 const ForStmt *FS = cast<ForStmt>(S);
4041 BlockScopeRAII
Scope(Info);
4044 if (ESR != ESR_Succeeded)
4048 BlockScopeRAII Scope(Info);
4049 bool Continue =
true;
4057 if (ESR != ESR_Continue)
4061 FullExpressionRAII IncScope(Info);
4066 return ESR_Succeeded;
4069 case Stmt::CXXForRangeStmtClass: {
4071 BlockScopeRAII
Scope(Info);
4075 if (ESR != ESR_Succeeded)
4080 if (ESR != ESR_Succeeded)
4083 if (ESR != ESR_Succeeded)
4089 bool Continue =
true;
4090 FullExpressionRAII CondExpr(Info);
4098 BlockScopeRAII InnerScope(Info);
4100 if (ESR != ESR_Succeeded)
4105 if (ESR != ESR_Continue)
4113 return ESR_Succeeded;
4116 case Stmt::SwitchStmtClass:
4119 case Stmt::ContinueStmtClass:
4120 return ESR_Continue;
4122 case Stmt::BreakStmtClass:
4125 case Stmt::LabelStmtClass:
4126 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
4128 case Stmt::AttributedStmtClass:
4131 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
4134 case Stmt::CaseStmtClass:
4135 case Stmt::DefaultStmtClass:
4136 return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
4146 bool IsValueInitialization) {
4153 if (!CD->
isConstexpr() && !IsValueInitialization) {
4154 if (Info.getLangOpts().CPlusPlus11) {
4157 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
4159 Info.Note(CD->
getLocation(), diag::note_declared_at);
4161 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
4175 if (Info.checkingPotentialConstantExpression() && !Definition &&
4189 if (Info.getLangOpts().CPlusPlus11) {
4190 const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
4195 if (CD && CD->isInheritingConstructor()) {
4197 if (!Inherited->isConstexpr())
4198 DiagDecl = CD = Inherited;
4204 if (CD && CD->isInheritingConstructor())
4205 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
4206 << CD->getInheritedConstructor().getConstructor()->getParent();
4208 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
4210 Info.Note(DiagDecl->
getLocation(), diag::note_declared_at);
4212 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
4222 for (
auto *FD : RD->
fields()) {
4223 if (FD->isUnnamedBitfield())
4227 for (
auto &Base : RD->
bases())
4228 if (
hasFields(Base.getType()->getAsCXXRecordDecl()))
4240 bool Success =
true;
4243 if (!
Evaluate(ArgValues[I - Args.begin()], Info, *I)) {
4246 if (!Info.noteFailure())
4258 EvalInfo &Info,
APValue &Result,
4259 const LValue *ResultSlot) {
4260 ArgVector ArgValues(Args.size());
4264 if (!Info.CheckCallLimit(CallLoc))
4267 CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
4276 if (MD && MD->isDefaulted() &&
4277 (MD->getParent()->isUnion() ||
4278 (MD->isTrivial() &&
hasFields(MD->getParent())))) {
4280 (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
4282 RHS.setFrom(Info.Ctx, ArgValues[0]);
4290 This->moveInto(Result);
4294 MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields,
4295 Frame.LambdaThisCaptureField);
4300 if (ESR == ESR_Succeeded) {
4303 Info.FFDiag(Callee->
getLocEnd(), diag::note_constexpr_no_return);
4305 return ESR == ESR_Returned;
4312 EvalInfo &Info,
APValue &Result) {
4314 if (!Info.CheckCallLimit(CallLoc))
4319 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
4323 EvalInfo::EvaluatingConstructorRAII EvalObj(
4324 Info, {This.getLValueBase(), This.CallIndex});
4325 CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues);
4336 FullExpressionRAII InitScope(Info);
4355 RHS.setFrom(Info.Ctx, ArgValues[0]);
4370 BlockScopeRAII LifetimeExtendedScope(Info);
4372 bool Success =
true;
4373 unsigned BasesSeen = 0;
4377 for (
const auto *I : Definition->
inits()) {
4378 LValue Subobject = This;
4383 if (I->isBaseInitializer()) {
4384 QualType BaseType(I->getBaseClass(), 0);
4388 assert(!BaseIt->
isVirtual() &&
"virtual base for literal type");
4389 assert(Info.Ctx.hasSameType(BaseIt->
getType(), BaseType) &&
4390 "base class initializers not in expected order");
4394 BaseType->getAsCXXRecordDecl(), &Layout))
4397 }
else if ((FD = I->getMember())) {
4409 for (
auto *
C : IFD->chain()) {
4410 FD = cast<FieldDecl>(
C);
4433 llvm_unreachable(
"unknown base initializer kind");
4436 FullExpressionRAII InitScope(Info);
4442 if (!Info.noteFailure())
4455 EvalInfo &Info,
APValue &Result) {
4456 ArgVector ArgValues(Args.size());
4469 template <
class Derived>
4470 class ExprEvaluatorBase
4473 Derived &getDerived() {
return static_cast<Derived&
>(*this); }
4474 bool DerivedSuccess(
const APValue &V,
const Expr *E) {
4475 return getDerived().Success(V, E);
4477 bool DerivedZeroInitialization(
const Expr *E) {
4478 return getDerived().ZeroInitialization(E);
4484 template<
typename ConditionalOperator>
4486 assert(Info.checkingPotentialConstantExpression());
4491 SpeculativeEvaluationRAII Speculate(Info, &Diag);
4498 SpeculativeEvaluationRAII Speculate(Info, &Diag);
4505 Error(E, diag::note_constexpr_conditional_never_const);
4509 template<
typename ConditionalOperator>
4513 if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
4514 CheckPotentialConstantConditional(E);
4517 if (Info.noteFailure()) {
4525 return StmtVisitorTy::Visit(EvalExpr);
4531 typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
4534 return Info.CCEDiag(E, D);
4537 bool ZeroInitialization(
const Expr *E) {
return Error(E); }
4540 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
4542 EvalInfo &getEvalInfo() {
return Info; }
4551 return Error(E, diag::note_invalid_subexpr_in_const_expr);
4554 bool VisitStmt(
const Stmt *) {
4555 llvm_unreachable(
"Expression evaluator should not be called on stmts");
4557 bool VisitExpr(
const Expr *E) {
4562 {
return StmtVisitorTy::Visit(E->
getSubExpr()); }
4564 {
return StmtVisitorTy::Visit(E->
getSubExpr()); }
4566 {
return StmtVisitorTy::Visit(E->
getSubExpr()); }
4574 {
return StmtVisitorTy::Visit(E->
getExpr()); }
4579 return StmtVisitorTy::Visit(E->
getExpr());
4584 {
return StmtVisitorTy::Visit(E->
getSubExpr()); }
4587 CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
4588 return static_cast<Derived*
>(
this)->VisitCastExpr(E);
4591 CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
4592 return static_cast<Derived*
>(
this)->VisitCastExpr(E);
4601 VisitIgnoredValue(E->
getLHS());
4602 return StmtVisitorTy::Visit(E->
getRHS());
4612 return DerivedSuccess(Result, E);
4624 return HandleConditionalOperator(E);
4628 bool IsBcpCall =
false;
4635 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
4640 if (Info.checkingPotentialConstantExpression() && IsBcpCall)
4643 FoldConstant Fold(Info, IsBcpCall);
4644 if (!HandleConditionalOperator(E)) {
4645 Fold.keepDiagnostics();
4653 if (
APValue *Value = Info.CurrentCall->getTemporary(E))
4654 return DerivedSuccess(*Value, E);
4660 assert(0 &&
"OpaqueValueExpr recursively refers to itself");
4663 return StmtVisitorTy::Visit(Source);
4666 bool VisitCallExpr(
const CallExpr *E) {
4668 if (!handleCallExpr(E, Result,
nullptr))
4670 return DerivedSuccess(Result, E);
4674 const LValue *ResultSlot) {
4679 LValue *This =
nullptr, ThisVal;
4681 bool HasQualifier =
false;
4686 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
4690 Member = ME->getMemberDecl();
4692 HasQualifier = ME->hasQualifier();
4693 }
else if (
const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
4696 if (!Member)
return false;
4699 return Error(Callee);
4703 return Error(Callee);
4709 if (!Call.getLValueOffset().isZero())
4710 return Error(Callee);
4711 FD = dyn_cast_or_null<FunctionDecl>(
4712 Call.getLValueBase().dyn_cast<
const ValueDecl*>());
4714 return Error(Callee);
4717 if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
4735 Args = Args.slice(1);
4744 "Number of captures must be zero for conversion to function-ptr");
4755 "A generic lambda's static-invoker function must be a " 4756 "template specialization");
4759 LambdaCallOp->getDescribedFunctionTemplate();
4760 void *InsertPos =
nullptr;
4763 assert(CorrespondingCallOpSpecialization &&
4764 "We must always have a function call operator specialization " 4765 "that corresponds to our static invoker specialization");
4766 FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization);
4775 if (This && !This->checkSubobject(Info, E, CSK_This))
4780 if (This && !HasQualifier &&
4781 isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isVirtual())
4782 return Error(E, diag::note_constexpr_virtual_call);
4800 return DerivedZeroInitialization(E);
4802 return StmtVisitorTy::Visit(E->
getInit(0));
4806 return DerivedZeroInitialization(E);
4809 return DerivedZeroInitialization(E);
4812 return DerivedZeroInitialization(E);
4817 assert(!E->
isArrow() &&
"missing call to bound member function?");
4826 if (!FD)
return Error(E);
4831 CompleteObject Obj(&Val, BaseTy);
4833 Designator.addDeclUnchecked(FD);
4837 DerivedSuccess(Result, E);
4840 bool VisitCastExpr(
const CastExpr *E) {
4845 case CK_AtomicToNonAtomic: {
4852 return DerivedSuccess(AtomicVal, E);
4856 case CK_UserDefinedConversion:
4857 return StmtVisitorTy::Visit(E->
getSubExpr());
4859 case CK_LValueToRValue: {
4868 return DerivedSuccess(RVal, E);
4876 return VisitUnaryPostIncDec(UO);
4879 return VisitUnaryPostIncDec(UO);
4882 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4892 return DerivedSuccess(RVal, UO);
4895 bool VisitStmtExpr(
const StmtExpr *E) {
4898 if (Info.checkingForOverflow())
4901 BlockScopeRAII
Scope(Info);
4910 const Expr *FinalExpr = dyn_cast<
Expr>(*BI);
4912 Info.FFDiag((*BI)->getLocStart(),
4913 diag::note_constexpr_stmt_expr_unsupported);
4916 return this->Visit(FinalExpr);
4920 StmtResult Result = { ReturnValue,
nullptr };
4922 if (ESR != ESR_Succeeded) {
4926 if (ESR != ESR_Failed)
4927 Info.FFDiag((*BI)->getLocStart(),
4928 diag::note_constexpr_stmt_expr_unsupported);
4933 llvm_unreachable(
"Return from function from the loop above.");
4937 void VisitIgnoredValue(
const Expr *E) {
4942 void VisitIgnoredBaseExpression(
const Expr *E) {
4945 if (Info.getLangOpts().MSVCCompat && !E->
HasSideEffects(Info.Ctx))
4947 VisitIgnoredValue(E);
4957 template<
class Derived>
4958 class LValueExprEvaluatorBase
4959 :
public ExprEvaluatorBase<Derived> {
4963 typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy;
4964 typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy;
4971 bool evaluatePointer(
const Expr *E, LValue &Result) {
4976 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result,
bool InvalidBaseOK)
4977 : ExprEvaluatorBaseTy(Info),
Result(Result),
4978 InvalidBaseOK(InvalidBaseOK) {}
4981 Result.setFrom(this->Info.Ctx, V);
4997 EvalOK = this->Visit(E->
getBase());
5003 Result.setInvalid(E);
5010 FD->
getParent()->getCanonicalDecl() &&
"record / field mismatch");
5018 return this->
Error(E);
5025 return Success(RefValue, E);
5033 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5041 bool VisitCastExpr(
const CastExpr *E) {
5044 return ExprEvaluatorBaseTy::VisitCastExpr(E);
5046 case CK_DerivedToBase:
5047 case CK_UncheckedDerivedToBase:
5092 class LValueExprEvaluator
5093 :
public LValueExprEvaluatorBase<LValueExprEvaluator> {
5095 LValueExprEvaluator(EvalInfo &Info, LValue &Result,
bool InvalidBaseOK) :
5096 LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
5098 bool VisitVarDecl(
const Expr *E,
const VarDecl *VD);
5102 bool VisitPredefinedExpr(
const PredefinedExpr *E) {
return Success(E); }
5106 bool VisitStringLiteral(
const StringLiteral *E) {
return Success(E); }
5107 bool VisitObjCEncodeExpr(
const ObjCEncodeExpr *E) {
return Success(E); }
5115 return VisitUnaryPreIncDec(UO);
5118 return VisitUnaryPreIncDec(UO);
5123 bool VisitCastExpr(
const CastExpr *E) {
5126 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
5128 case CK_LValueBitCast:
5129 this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5132 Result.Designator.setInvalid();
5135 case CK_BaseToDerived:
5150 bool InvalidBaseOK) {
5153 return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5156 bool LValueExprEvaluator::VisitDeclRefExpr(
const DeclRefExpr *E) {
5160 return VisitVarDecl(E, VD);
5162 return Visit(BD->getBinding());
5167 bool LValueExprEvaluator::VisitVarDecl(
const Expr *E,
const VarDecl *VD) {
5174 if (
auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) {
5175 if (Info.checkingPotentialConstantExpression())
5178 Result = *Info.CurrentCall->This;
5185 if (FD->getType()->isReferenceType()) {
5190 Result.setFrom(Info.Ctx, RVal);
5195 CallStackFrame *Frame =
nullptr;
5203 if (Info.CurrentCall->Callee &&
5205 Frame = Info.CurrentCall;
5211 Result.set(VD, Frame->Index);
5221 if (!Info.checkingPotentialConstantExpression())
5222 Info.FFDiag(E, diag::note_constexpr_use_uninit_reference);
5225 return Success(*V, E);
5228 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
5234 skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
5237 for (
unsigned I = 0, N = CommaLHSs.size(); I != N; ++I)
5246 Value = Info.Ctx.getMaterializedTemporaryValue(E,
true);
5250 Value = &Info.CurrentCall->
5252 Result.set(E, Info.CurrentCall->Index);
5266 for (
unsigned I = Adjustments.size(); I != 0; ) {
5268 switch (Adjustments[I].
Kind) {
5273 Type = Adjustments[I].DerivedToBase.BasePath->getType();
5279 Type = Adjustments[I].Field->getType();
5284 Adjustments[I].Ptr.RHS))
5286 Type = Adjustments[I].Ptr.MPT->getPointeeType();
5296 assert((!Info.getLangOpts().CPlusPlus || E->
isFileScope()) &&
5297 "lvalue compound literal in c++?");
5303 bool LValueExprEvaluator::VisitCXXTypeidExpr(
const CXXTypeidExpr *E) {
5307 Info.FFDiag(E, diag::note_constexpr_typeid_polymorphic)
5313 bool LValueExprEvaluator::VisitCXXUuidofExpr(
const CXXUuidofExpr *E) {
5317 bool LValueExprEvaluator::VisitMemberExpr(
const MemberExpr *E) {
5320 VisitIgnoredBaseExpression(E->
getBase());
5321 return VisitVarDecl(E, VD);
5326 if (MD->isStatic()) {
5327 VisitIgnoredBaseExpression(E->
getBase());
5333 return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
5341 bool Success =
true;
5343 if (!Info.noteFailure())
5356 bool LValueExprEvaluator::VisitUnaryDeref(
const UnaryOperator *E) {
5360 bool LValueExprEvaluator::VisitUnaryReal(
const UnaryOperator *E) {
5369 bool LValueExprEvaluator::VisitUnaryImag(
const UnaryOperator *E) {
5371 "lvalue __imag__ on scalar?");
5378 bool LValueExprEvaluator::VisitUnaryPreIncDec(
const UnaryOperator *UO) {
5379 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5390 bool LValueExprEvaluator::VisitCompoundAssignOperator(
5392 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5398 if (!this->Visit(CAO->
getLHS())) {
5399 if (Info.noteFailure())
5413 bool LValueExprEvaluator::VisitBinAssign(
const BinaryOperator *E) {
5414 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
5419 if (!this->Visit(E->
getLHS())) {
5420 if (Info.noteFailure())
5444 llvm::APInt &Result) {
5445 const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
5448 assert(AllocSize && AllocSize->getElemSizeParam() != 0);
5449 unsigned SizeArgNo = AllocSize->getElemSizeParam() - 1;
5454 auto EvaluateAsSizeT = [&](
const Expr *E, APSInt &Into) {
5457 if (Into.isNegative() || !Into.isIntN(BitsInSizeT))
5459 Into = Into.zextOrSelf(BitsInSizeT);
5464 if (!EvaluateAsSizeT(Call->
getArg(SizeArgNo), SizeOfElem))
5467 if (!AllocSize->getNumElemsParam()) {
5468 Result = std::move(SizeOfElem);
5472 APSInt NumberOfElems;
5474 unsigned NumArgNo = AllocSize->getNumElemsParam() - 1;
5475 if (!EvaluateAsSizeT(Call->
getArg(NumArgNo), NumberOfElems))
5479 llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);
5483 Result = std::move(BytesAvailable);
5491 llvm::APInt &Result) {
5492 assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
5493 "Can't get the size of a non alloc_size function");
5494 const auto *Base = LVal.getLValueBase().get<
const Expr *>();
5495 const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
5514 dyn_cast_or_null<VarDecl>(Base.dyn_cast<
const ValueDecl *>());
5523 if (!tryUnwrapAllocSizeCall(E))
5528 Result.setInvalid(E);
5531 Result.addUnsizedArray(Info, E, Pointee);
5536 class PointerExprEvaluator
5537 :
public ExprEvaluatorBase<PointerExprEvaluator> {
5541 bool Success(
const Expr *E) {
5546 bool evaluateLValue(
const Expr *E, LValue &Result) {
5550 bool evaluatePointer(
const Expr *E, LValue &Result) {
5554 bool visitNonBuiltinCallExpr(
const CallExpr *E);
5557 PointerExprEvaluator(EvalInfo &info, LValue &Result,
bool InvalidBaseOK)
5558 : ExprEvaluatorBaseTy(info),
Result(Result),
5559 InvalidBaseOK(InvalidBaseOK) {}
5562 Result.setFrom(Info.Ctx, V);
5565 bool ZeroInitialization(
const Expr *E) {
5566 auto TargetVal = Info.Ctx.getTargetNullPointerValue(E->
getType());
5567 Result.setNull(E->
getType(), TargetVal);
5572 bool VisitCastExpr(
const CastExpr* E);
5575 {
return Success(E); }
5577 if (Info.noteFailure())
5582 {
return Success(E); }
5583 bool VisitCallExpr(
const CallExpr *E);
5584 bool VisitBuiltinCallExpr(
const CallExpr *E,
unsigned BuiltinOp);
5585 bool VisitBlockExpr(
const BlockExpr *E) {
5592 if (Info.checkingPotentialConstantExpression())
5594 if (!Info.CurrentCall->This) {
5595 if (Info.getLangOpts().CPlusPlus11)
5596 Info.FFDiag(E, diag::note_constexpr_this) << E->
isImplicit();
5601 Result = *Info.CurrentCall->This;
5610 Info.CurrentCall->LambdaThisCaptureField))
5613 if (Info.CurrentCall->LambdaThisCaptureField->getType()
5614 ->isPointerType()) {
5620 Result.setFrom(Info.Ctx, RVal);
5631 bool InvalidBaseOK) {
5633 return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
5636 bool PointerExprEvaluator::VisitBinaryOperator(
const BinaryOperator *E) {
5639 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
5644 std::swap(PExp, IExp);
5646 bool EvalPtrOK = evaluatePointer(PExp, Result);
5647 if (!EvalPtrOK && !Info.noteFailure())
5661 bool PointerExprEvaluator::VisitUnaryAddrOf(
const UnaryOperator *E) {
5665 bool PointerExprEvaluator::VisitCastExpr(
const CastExpr* E) {
5673 case CK_CPointerToObjCPointerCast:
5674 case CK_BlockPointerToObjCPointerCast:
5675 case CK_AnyPointerToBlockPointerCast:
5676 case CK_AddressSpaceConversion:
5677 if (!Visit(SubExpr))
5683 Result.Designator.setInvalid();
5685 CCEDiag(E, diag::note_constexpr_invalid_cast)
5688 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5690 if (E->
getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr)
5691 ZeroInitialization(E);
5694 case CK_DerivedToBase:
5695 case CK_UncheckedDerivedToBase:
5698 if (!Result.Base && Result.Offset.isZero())
5704 castAs<PointerType>()->getPointeeType(),
5707 case CK_BaseToDerived:
5710 if (!Result.Base && Result.Offset.isZero())
5714 case CK_NullToPointer:
5716 return ZeroInitialization(E);
5718 case CK_IntegralToPointer: {
5719 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
5725 if (Value.
isInt()) {
5726 unsigned Size = Info.Ctx.getTypeSize(E->
getType());
5727 uint64_t N = Value.
getInt().extOrTrunc(Size).getZExtValue();
5728 Result.Base = (
Expr*)
nullptr;
5729 Result.InvalidBase =
false;
5731 Result.CallIndex = 0;
5732 Result.Designator.setInvalid();
5733 Result.IsNullPtr =
false;
5737 Result.setFrom(Info.Ctx, Value);
5742 case CK_ArrayToPointerDecay: {
5744 if (!evaluateLValue(SubExpr, Result))
5747 Result.set(SubExpr, Info.CurrentCall->Index);
5748 if (!
EvaluateInPlace(Info.CurrentCall->createTemporary(SubExpr,
false),
5753 auto *AT = Info.Ctx.getAsArrayType(SubExpr->
getType());
5754 if (
auto *CAT = dyn_cast<ConstantArrayType>(AT))
5755 Result.addArray(Info, E, CAT);
5761 case CK_FunctionToPointerDecay:
5762 return evaluateLValue(SubExpr, Result);
5764 case CK_LValueToRValue: {
5773 return InvalidBaseOK &&
5775 return Success(RVal, E);
5779 return ExprEvaluatorBaseTy::VisitCastExpr(E);
5792 return Info.Ctx.toCharUnitsFromBits(
5793 Info.Ctx.getPreferredTypeAlign(T.
getTypePtr()));
5805 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
5806 return Info.Ctx.getDeclAlign(DRE->getDecl(),
5809 if (
const MemberExpr *ME = dyn_cast<MemberExpr>(E))
5810 return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
5817 bool PointerExprEvaluator::visitNonBuiltinCallExpr(
const CallExpr *E) {
5818 if (ExprEvaluatorBaseTy::VisitCallExpr(E))
5821 if (!(InvalidBaseOK && getAllocSizeAttr(E)))
5824 Result.setInvalid(E);
5826 Result.addUnsizedArray(Info, E, PointeeTy);
5830 bool PointerExprEvaluator::VisitCallExpr(
const CallExpr *E) {
5835 return VisitBuiltinCallExpr(E, BuiltinOp);
5837 return visitNonBuiltinCallExpr(E);
5840 bool PointerExprEvaluator::VisitBuiltinCallExpr(
const CallExpr *E,
5841 unsigned BuiltinOp) {
5842 switch (BuiltinOp) {
5843 case Builtin::BI__builtin_addressof:
5845 case Builtin::BI__builtin_assume_aligned: {
5852 LValue OffsetResult(Result);
5863 int64_t AdditionalOffset = -Offset.getZExtValue();
5868 if (OffsetResult.Base) {
5871 OffsetResult.Base.dyn_cast<
const ValueDecl*>()) {
5872 BaseAlignment = Info.Ctx.getDeclAlign(VD);
5878 if (BaseAlignment < Align) {
5879 Result.Designator.setInvalid();
5882 diag::note_constexpr_baa_insufficient_alignment) << 0
5890 if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {
5891 Result.Designator.setInvalid();
5895 diag::note_constexpr_baa_insufficient_alignment) << 1
5897 diag::note_constexpr_baa_value_insufficient_alignment))
5898 << (int)OffsetResult.Offset.getQuantity()
5906 case Builtin::BIstrchr:
5907 case Builtin::BIwcschr:
5908 case Builtin::BImemchr:
5909 case Builtin::BIwmemchr:
5910 if (Info.getLangOpts().CPlusPlus11)
5911 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
5913 << (std::string(
"'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) +
"'");
5915 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
5917 case Builtin::BI__builtin_strchr:
5918 case Builtin::BI__builtin_wcschr:
5919 case Builtin::BI__builtin_memchr:
5920 case Builtin::BI__builtin_char_memchr:
5921 case Builtin::BI__builtin_wmemchr: {
5922 if (!Visit(E->
getArg(0)))
5927 uint64_t MaxLength = uint64_t(-1);
5928 if (BuiltinOp != Builtin::BIstrchr &&
5929 BuiltinOp != Builtin::BIwcschr &&
5930 BuiltinOp != Builtin::BI__builtin_strchr &&
5931 BuiltinOp != Builtin::BI__builtin_wcschr) {
5935 MaxLength = N.getExtValue();
5942 uint64_t DesiredVal;
5943 bool StopAtNull =
false;
5944 switch (BuiltinOp) {
5945 case Builtin::BIstrchr:
5946 case Builtin::BI__builtin_strchr:
5953 return ZeroInitialization(E);
5956 case Builtin::BImemchr:
5957 case Builtin::BI__builtin_memchr:
5958 case Builtin::BI__builtin_char_memchr:
5962 DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue();
5965 case Builtin::BIwcschr:
5966 case Builtin::BI__builtin_wcschr:
5969 case Builtin::BIwmemchr:
5970 case Builtin::BI__builtin_wmemchr:
5972 DesiredVal = Desired.getZExtValue();
5976 for (; MaxLength; --MaxLength) {
5981 if (Char.
getInt().getZExtValue() == DesiredVal)
5983 if (StopAtNull && !Char.
getInt())
5989 return ZeroInitialization(E);
5993 return visitNonBuiltinCallExpr(E);
6002 class MemberPointerExprEvaluator
6003 :
public ExprEvaluatorBase<MemberPointerExprEvaluator> {
6007 Result = MemberPtr(D);
6012 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
6013 : ExprEvaluatorBaseTy(Info),
Result(Result) {}
6019 bool ZeroInitialization(
const Expr *E) {
6020 return Success((
const ValueDecl*)
nullptr);
6023 bool VisitCastExpr(
const CastExpr *E);
6031 return MemberPointerExprEvaluator(Info, Result).Visit(E);
6034 bool MemberPointerExprEvaluator::VisitCastExpr(
const CastExpr *E) {
6037 return ExprEvaluatorBaseTy::VisitCastExpr(E);
6039 case CK_NullToMemberPointer:
6041 return ZeroInitialization(E);
6043 case CK_BaseToDerivedMemberPointer: {
6051 typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter;
6053 PathI != PathE; ++PathI) {
6054 assert(!(*PathI)->isVirtual() &&
"memptr cast through vbase");
6055 const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
6056 if (!Result.castToDerived(Derived))
6065 case CK_DerivedToBaseMemberPointer:
6069 PathE = E->
path_end(); PathI != PathE; ++PathI) {
6070 assert(!(*PathI)->isVirtual() &&
"memptr cast through vbase");
6071 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6072 if (!Result.castToBase(Base))
6079 bool MemberPointerExprEvaluator::VisitUnaryAddrOf(
const UnaryOperator *E) {
6082 return Success(cast<DeclRefExpr>(E->
getSubExpr())->getDecl());
6090 class RecordExprEvaluator
6091 :
public ExprEvaluatorBase<RecordExprEvaluator> {
6096 RecordExprEvaluator(EvalInfo &info,
const LValue &This,
APValue &Result)
6097 : ExprEvaluatorBaseTy(info), This(This),
Result(Result) {}
6103 bool ZeroInitialization(
const Expr *E) {
6104 return ZeroInitialization(E, E->
getType());
6108 bool VisitCallExpr(
const CallExpr *E) {
6109 return handleCallExpr(E, Result, &This);
6111 bool VisitCastExpr(
const CastExpr *E);
6114 return VisitCXXConstructExpr(E, E->
getType());
6132 const LValue &This,
APValue &Result) {
6133 assert(!RD->
isUnion() &&
"Expected non-union class type");
6144 End = CD->bases_end(); I !=
End; ++I, ++Index) {
6145 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
6146 LValue Subobject = This;
6150 Result.getStructBase(Index)))
6155 for (
const auto *I : RD->
fields()) {
6157 if (I->getType()->isReferenceType())
6160 LValue Subobject = This;
6166 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
6173 bool RecordExprEvaluator::ZeroInitialization(
const Expr *E,
QualType T) {
6185 LValue Subobject = This;
6190 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
6193 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) {
6194 Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD;
6201 bool RecordExprEvaluator::VisitCastExpr(
const CastExpr *E) {
6204 return ExprEvaluatorBaseTy::VisitCastExpr(E);
6206 case CK_ConstructorConversion:
6209 case CK_DerivedToBase:
6210 case CK_UncheckedDerivedToBase: {
6218 APValue *Value = &DerivedObject;
6221 PathE = E->
path_end(); PathI != PathE; ++PathI) {
6222 assert(!(*PathI)->isVirtual() &&
"record rvalue with virtual base");
6223 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
6233 bool RecordExprEvaluator::VisitInitListExpr(
const InitListExpr *E) {
6255 LValue Subobject = This;
6260 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6261 isa<CXXDefaultInitExpr>(InitExpr));
6263 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
6267 if (Result.isUninit())
6270 unsigned ElementNo = 0;
6271 bool Success =
true;
6275 for (
const auto &Base : CXXRD->bases()) {
6276 assert(ElementNo < E->getNumInits() &&
"missing init for base class");
6279 LValue Subobject = This;
6283 APValue &FieldVal = Result.getStructBase(ElementNo);
6285 if (!Info.noteFailure())
6294 for (
const auto *Field : RD->
fields()) {
6297 if (Field->isUnnamedBitfield())
6300 LValue Subobject = This;
6307 Subobject, Field, &Layout))
6313 const Expr *Init = HaveInit ? E->
getInit(ElementNo++) : &VIE;
6316 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
6317 isa<CXXDefaultInitExpr>(Init));
6319 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6322 FieldVal, Field))) {
6323 if (!Info.noteFailure())
6342 if (!Result.isUninit())
6353 return ZeroInitialization(E, T);
6357 auto Body = FD->
getBody(Definition);
6365 = dyn_cast<MaterializeTemporaryExpr>(E->
getArg(0)))
6366 return Visit(ME->GetTemporaryExpr());
6368 if (ZeroInit && !ZeroInitialization(E, T))
6373 cast<CXXConstructorDecl>(Definition), Info,
6377 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
6379 if (!Info.CurrentCall) {
6380 assert(Info.checkingPotentialConstantExpression());
6389 auto Body = FD->
getBody(Definition);
6395 cast<CXXConstructorDecl>(Definition), Info,
6399 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
6409 Array.addArray(Info, E, ArrayType);
6418 if (!Field->getType()->isPointerType() ||
6419 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6425 Array.moveInto(Result.getStructField(0));
6430 if (Field->getType()->isPointerType() &&
6431 Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
6436 ArrayType->
getSize().getZExtValue()))
6438 Array.moveInto(Result.getStructField(1));
6439 }
else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
6441 Result.getStructField(1) =
APValue(APSInt(ArrayType->
getSize()));
6451 bool RecordExprEvaluator::VisitLambdaExpr(
const LambdaExpr *E) {
6455 if (Info.checkingPotentialConstantExpression())
return true;
6457 const size_t NumFields =
6462 "The number of lambda capture initializers should equal the number of " 6463 "fields within the closure type");
6470 bool Success =
true;
6471 for (
const auto *Field : ClosureClass->
fields()) {
6474 Expr *
const CurFieldInit = *CaptureInitIt++;
6481 APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
6483 if (!Info.keepEvaluatingAfterFailure())
6493 APValue &Result, EvalInfo &Info) {
6495 "can't evaluate expression as a record rvalue");
6496 return RecordExprEvaluator(Info, This, Result).Visit(E);
6507 class TemporaryExprEvaluator
6508 :
public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
6510 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
6511 LValueExprEvaluatorBaseTy(Info, Result,
false) {}
6514 bool VisitConstructExpr(
const Expr *E) {
6515 Result.set(E, Info.CurrentCall->Index);
6520 bool VisitCastExpr(
const CastExpr *E) {
6523 return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
6525 case CK_ConstructorConversion:
6530 return VisitConstructExpr(E);
6533 return VisitConstructExpr(E);
6535 bool VisitCallExpr(
const CallExpr *E) {
6536 return VisitConstructExpr(E);
6539 return VisitConstructExpr(E);
6542 return VisitConstructExpr(E);
6550 return TemporaryExprEvaluator(Info, Result).Visit(E);
6558 class VectorExprEvaluator
6559 :
public ExprEvaluatorBase<VectorExprEvaluator> {
6563 VectorExprEvaluator(EvalInfo &info,
APValue &Result)
6564 : ExprEvaluatorBaseTy(info),
Result(Result) {}
6569 Result =
APValue(V.data(), V.size());
6577 bool ZeroInitialization(
const Expr *E);
6581 bool VisitCastExpr(
const CastExpr* E);
6592 return VectorExprEvaluator(Info, Result).Visit(E);
6595 bool VectorExprEvaluator::VisitCastExpr(
const CastExpr *E) {
6603 case CK_VectorSplat: {
6609 Val =
APValue(std::move(IntResult));
6611 APFloat FloatResult(0.0);
6614 Val =
APValue(std::move(FloatResult));
6621 return Success(Elts, E);
6625 llvm::APInt SValInt;
6630 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
6631 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
6634 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
6635 unsigned FloatEltSize = EltSize;
6636 if (&Sem == &APFloat::x87DoubleExtended())
6638 for (
unsigned i = 0; i < NElts; i++) {
6641 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
6643 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
6644 Elts.push_back(
APValue(APFloat(Sem, Elt)));
6647 for (
unsigned i = 0; i < NElts; i++) {
6650 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
6652 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
6658 return Success(Elts, E);
6661 return ExprEvaluatorBaseTy::VisitCastExpr(E);
6666 VectorExprEvaluator::VisitInitListExpr(
const InitListExpr *E) {
6678 unsigned CountInits = 0, CountElts = 0;
6679 while (CountElts < NumElements) {
6681 if (CountInits < NumInits
6687 for (
unsigned j = 0; j < vlen; j++)
6691 llvm::APSInt sInt(32);
6692 if (CountInits < NumInits) {
6696 sInt = Info.Ctx.MakeIntValue(0, EltTy);
6697 Elements.push_back(
APValue(sInt));
6700 llvm::APFloat f(0.0);
6701 if (CountInits < NumInits) {
6705 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
6706 Elements.push_back(
APValue(f));
6711 return Success(Elements, E);
6715 VectorExprEvaluator::ZeroInitialization(
const Expr *E) {
6719 if (EltTy->isIntegerType())
6720 ZeroElement =
APValue(Info.Ctx.MakeIntValue(0, EltTy));
6723 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
6726 return Success(Elements, E);
6729 bool VectorExprEvaluator::VisitUnaryImag(
const UnaryOperator *E) {
6731 return ZeroInitialization(E);
6739 class ArrayExprEvaluator
6740 :
public ExprEvaluatorBase<ArrayExprEvaluator> {
6745 ArrayExprEvaluator(EvalInfo &Info,
const LValue &This,
APValue &Result)
6746 : ExprEvaluatorBaseTy(Info), This(This),
Result(Result) {}
6750 "expected array or string literal");
6755 bool ZeroInitialization(
const Expr *E) {
6757 Info.Ctx.getAsConstantArrayType(E->
getType());
6762 CAT->
getSize().getZExtValue());
6766 LValue Subobject = This;
6767 Subobject.addArray(Info, E, CAT);
6772 bool VisitCallExpr(
const CallExpr *E) {
6773 return handleCallExpr(E, Result, &This);
6779 const LValue &Subobject,
6785 APValue &Result, EvalInfo &Info) {
6787 return ArrayExprEvaluator(Info, This, Result).Visit(E);
6790 bool ArrayExprEvaluator::VisitInitListExpr(
const InitListExpr *E) {
6803 return Success(Val, E);
6806 bool Success =
true;
6808 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
6809 "zero-initialized array shouldn't have any initialized elts");
6811 if (Result.isArray() && Result.hasArrayFiller())
6812 Filler = Result.getArrayFiller();
6815 unsigned NumElts = CAT->
getSize().getZExtValue();
6820 if (NumEltsToInit != NumElts && !isa<ImplicitValueInitExpr>(FillerExpr))
6821 NumEltsToInit = NumElts;
6828 for (
unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
6829 Result.getArrayInitializedElt(I) = Filler;
6830 if (Result.hasArrayFiller())
6831 Result.getArrayFiller() = Filler;
6834 LValue Subobject = This;
6835 Subobject.addArray(Info, E, CAT);
6836 for (
unsigned Index = 0; Index != NumEltsToInit; ++Index) {
6840 Info, Subobject, Init) ||
6843 if (!Info.noteFailure())
6849 if (!Result.hasArrayFiller())
6854 assert(FillerExpr &&
"no array filler for incomplete init list");
6856 FillerExpr) && Success;
6867 uint64_t Elements = CAT->getSize().getZExtValue();
6870 LValue Subobject = This;
6871 Subobject.addArray(Info, E, CAT);
6873 bool Success =
true;
6874 for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
6878 CAT->getElementType(), 1)) {
6879 if (!Info.noteFailure())
6888 bool ArrayExprEvaluator::VisitCXXConstructExpr(
const CXXConstructExpr *E) {
6889 return VisitCXXConstructExpr(E, This, &Result, E->
getType());
6893 const LValue &Subobject,
6896 bool HadZeroInit = !Value->
isUninit();
6899 unsigned N = CAT->getSize().getZExtValue();
6909 for (
unsigned I = 0; I != N; ++I)
6913 LValue ArrayElt = Subobject;
6914 ArrayElt.addArray(Info, E, CAT);
6915 for (
unsigned I = 0; I != N; ++I)
6917 CAT->getElementType()) ||
6919 CAT->getElementType(), 1))
6928 return RecordExprEvaluator(Info, Subobject, *Value)
6929 .VisitCXXConstructExpr(E, Type);
6941 class IntExprEvaluator
6942 :
public ExprEvaluatorBase<IntExprEvaluator> {
6945 IntExprEvaluator(EvalInfo &info,
APValue &result)
6946 : ExprEvaluatorBaseTy(info),
Result(result) {}
6948 bool Success(
const llvm::APSInt &SI,
const Expr *E,
APValue &Result) {
6950 "Invalid evaluation result.");
6952 "Invalid evaluation result.");
6953 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->
getType()) &&
6954 "Invalid evaluation result.");
6958 bool Success(
const llvm::APSInt &SI,
const Expr *E) {
6959 return Success(SI, E, Result);
6962 bool Success(
const llvm::APInt &I,
const Expr *E,
APValue &Result) {
6964 "Invalid evaluation result.");
6965 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->
getType()) &&
6966 "Invalid evaluation result.");
6968 Result.
getInt().setIsUnsigned(
6972 bool Success(
const llvm::APInt &I,
const Expr *E) {
6973 return Success(I, E, Result);
6976 bool Success(uint64_t Value,
const Expr *E,
APValue &Result) {
6978 "Invalid evaluation result.");
6982 bool Success(uint64_t Value,
const Expr *E) {
6983 return Success(Value, E, Result);
6995 return Success(V.
getInt(), E);
6998 bool ZeroInitialization(
const Expr *E) {
return Success(0, E); }
7011 bool CheckReferencedDecl(
const Expr *E,
const Decl *D);
7013 if (CheckReferencedDecl(E, E->
getDecl()))
7016 return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
7020 VisitIgnoredBaseExpression(E->
getBase());
7024 return ExprEvaluatorBaseTy::VisitMemberExpr(E);
7027 bool VisitCallExpr(
const CallExpr *E);
7028 bool VisitBuiltinCallExpr(
const CallExpr *E,
unsigned BuiltinOp);
7033 bool VisitCastExpr(
const CastExpr* E);
7045 if (Info.ArrayInitIndex == uint64_t(-1)) {
7051 return Success(Info.ArrayInitIndex, E);
7056 return ZeroInitialization(E);
7092 return IntExprEvaluator(Info, Result).Visit(E);
7102 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
7112 bool IntExprEvaluator::CheckReferencedDecl(
const Expr* E,
const Decl* D) {
7116 bool SameSign = (ECD->getInitVal().isSigned()
7118 bool SameWidth = (ECD->getInitVal().getBitWidth()
7119 == Info.Ctx.getIntWidth(E->
getType()));
7120 if (SameSign && SameWidth)
7121 return Success(ECD->getInitVal(), E);
7125 llvm::APSInt Val = ECD->getInitVal();
7127 Val.setIsSigned(!ECD->getInitVal().isSigned());
7129 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->
getType()));
7130 return Success(Val, E);
7142 enum gcc_type_class {
7144 void_type_class, integer_type_class, char_type_class,
7145 enumeral_type_class, boolean_type_class,
7146 pointer_type_class, reference_type_class, offset_type_class,
7147 real_type_class, complex_type_class,
7148 function_type_class, method_type_class,
7149 record_type_class, union_type_class,
7150 array_type_class, string_type_class,
7157 return no_type_class;
7163 #define TYPE(ID, BASE) 7164 #define DEPENDENT_TYPE(ID, BASE) case Type::ID: 7165 #define NON_CANONICAL_TYPE(ID, BASE) case Type::ID: 7166 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID: 7167 #include "clang/AST/TypeNodes.def" 7168 llvm_unreachable(
"CallExpr::isBuiltinClassifyType(): unimplemented type");
7172 #define BUILTIN_TYPE(ID, SINGLETON_ID) 7173 #define SIGNED_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: return integer_type_class; 7174 #define FLOATING_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: return real_type_class; 7175 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: break; 7176 #include "clang/AST/BuiltinTypes.def" 7177 case BuiltinType::Void:
7178 return void_type_class;
7180 case BuiltinType::Bool:
7181 return boolean_type_class;
7183 case BuiltinType::Char_U:
7184 case BuiltinType::UChar:
7185 case BuiltinType::UShort:
7186 case BuiltinType::UInt:
7187 case BuiltinType::ULong:
7188 case BuiltinType::ULongLong:
7189 case BuiltinType::UInt128:
7190 return integer_type_class;
7192 case BuiltinType::NullPtr:
7193 return pointer_type_class;
7195 case BuiltinType::WChar_U:
7196 case BuiltinType::Char16:
7197 case BuiltinType::Char32:
7198 case BuiltinType::ObjCId:
7199 case BuiltinType::ObjCClass:
7200 case BuiltinType::ObjCSel:
7201 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 7202 case BuiltinType::Id: 7203 #include "clang/Basic/OpenCLImageTypes.def" 7204 case BuiltinType::OCLSampler:
7205 case BuiltinType::OCLEvent:
7206 case BuiltinType::OCLClkEvent:
7207 case BuiltinType::OCLQueue:
7208 case BuiltinType::OCLReserveID:
7209 case BuiltinType::Dependent:
7210 llvm_unreachable(
"CallExpr::isBuiltinClassifyType(): unimplemented type");
7215 return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class;
7219 return pointer_type_class;
7222 case Type::MemberPointer:
7224 return offset_type_class;
7229 return method_type_class;
7233 return complex_type_class;
7235 case Type::FunctionNoProto:
7236 case Type::FunctionProto:
7237 return LangOpts.CPlusPlus ? function_type_class : pointer_type_class;
7241 switch (RT->getDecl()->getTagKind()) {
7245 return record_type_class;
7248 return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class;
7251 return union_type_class;
7254 llvm_unreachable(
"CallExpr::isBuiltinClassifyType(): unimplemented type");
7256 case Type::ConstantArray:
7257 case Type::VariableArray:
7258 case Type::IncompleteArray:
7259 return LangOpts.CPlusPlus ? array_type_class : pointer_type_class;
7261 case Type::BlockPointer:
7262 case Type::LValueReference:
7263 case Type::RValueReference:
7265 case Type::ExtVector:
7267 case Type::DeducedTemplateSpecialization:
7268 case Type::ObjCObject:
7269 case Type::ObjCInterface:
7270 case Type::ObjCObjectPointer:
7273 llvm_unreachable(
"CallExpr::isBuiltinClassifyType(): unimplemented type");
7276 llvm_unreachable(
"CallExpr::isBuiltinClassifyType(): unimplemented type");
7284 template<
typename LValue>
7286 const Expr *E = LV.getLValueBase().template dyn_cast<
const Expr*>();
7287 return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero();
7323 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
7338 if (
const VarDecl *VD = dyn_cast<VarDecl>(D))
7340 }
else if (
const Expr *E = B.get<
const Expr*>()) {
7341 if (isa<CompoundLiteralExpr>(E))
7358 auto *Cast = dyn_cast<
CastExpr>(NoParens);
7359 if (Cast ==
nullptr)
7366 CastKind != CK_AddressSpaceConversion)
7369 auto *SubExpr = Cast->getSubExpr();
7370 if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue())
7391 assert(!LVal.Designator.Invalid);
7393 auto IsLastOrInvalidFieldDecl = [&Ctx](
const FieldDecl *FD,
bool &Invalid) {
7396 if (Invalid || Parent->
isUnion())
7402 auto &Base = LVal.getLValueBase();
7403 if (
auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<
const Expr *>())) {
7404 if (
auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
7406 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7408 }
else if (
auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) {
7409 for (
auto *FD : IFD->chain()) {
7411 if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid))
7419 if (LVal.Designator.FirstEntryIsAnUnsizedArray) {
7429 for (
unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
7430 const auto &Entry = LVal.Designator.Entries[I];
7436 const auto *CAT = cast<ConstantArrayType>(Ctx.
getAsArrayType(BaseType));
7437 uint64_t Index = Entry.ArrayIndex;
7438 if (Index + 1 != CAT->getSize())
7440 BaseType = CAT->getElementType();
7443 uint64_t Index = Entry.ArrayIndex;
7447 }
else if (
auto *FD = getAsField(Entry)) {
7449 if (!IsLastOrInvalidFieldDecl(FD, Invalid))
7453 assert(getAsBaseClass(Entry) &&
"Expecting cast to a base class");
7465 if (LVal.Designator.Invalid)
7468 if (!LVal.Designator.Entries.empty())
7469 return LVal.Designator.isMostDerivedAnUnsizedArray();
7471 if (!LVal.InvalidBase)
7476 const auto *E = LVal.Base.dyn_cast<
const Expr *>();
7477 return !E || !isa<MemberExpr>(E);
7483 const SubobjectDesignator &
Designator = LVal.Designator;
7495 return LVal.InvalidBase &&
7496 Designator.Entries.size() == Designator.MostDerivedPathLength &&
7497 Designator.MostDerivedIsArrayElement &&
7506 if (Int.ugt(CharUnitsMax))
7519 unsigned Type,
const LValue &LVal,
7532 if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) {
7534 if (Type == 3 && !DetermineForCompleteObject)
7537 llvm::APInt APEndOffset;
7538 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7542 if (LVal.InvalidBase)
7546 return CheckedHandleSizeof(BaseTy, EndOffset);
7550 const SubobjectDesignator &
Designator = LVal.Designator;
7562 llvm::APInt APEndOffset;
7563 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
7575 if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem))
7581 int64_t ElemsRemaining;
7582 if (Designator.MostDerivedIsArrayElement &&
7583 Designator.Entries.size() == Designator.MostDerivedPathLength) {
7584 uint64_t ArraySize = Designator.getMostDerivedArraySize();
7585 uint64_t ArrayIndex = Designator.Entries.back().ArrayIndex;
7586 ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex;
7588 ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1;
7591 EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining;
7601 EvalInfo &Info, uint64_t &Size) {
7608 SpeculativeEvaluationRAII SpeculativeEval(Info);
7609 FoldOffsetRAII Fold(Info);
7617 LVal.setFrom(Info.Ctx, RVal);
7625 if (LVal.getLValueOffset().isNegative()) {
7636 if (EndOffset <= LVal.getLValueOffset())
7639 Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
7643 bool IntExprEvaluator::VisitCallExpr(
const CallExpr *E) {
7645 return VisitBuiltinCallExpr(E, BuiltinOp);
7647 return ExprEvaluatorBaseTy::VisitCallExpr(E);
7650 bool IntExprEvaluator::VisitBuiltinCallExpr(
const CallExpr *E,
7651 unsigned BuiltinOp) {
7654 return ExprEvaluatorBaseTy::VisitCallExpr(E);
7656 case Builtin::BI__builtin_object_size: {
7660 assert(Type <= 3 &&
"unexpected type");
7664 return Success(Size, E);
7667 return Success((Type & 2) ? 0 : -1, E);
7671 switch (Info.EvalMode) {
7672 case EvalInfo::EM_ConstantExpression:
7673 case EvalInfo::EM_PotentialConstantExpression:
7674 case EvalInfo::EM_ConstantFold:
7675 case EvalInfo::EM_EvaluateForOverflow:
7676 case EvalInfo::EM_IgnoreSideEffects:
7677 case EvalInfo::EM_OffsetFold:
7680 case EvalInfo::EM_ConstantExpressionUnevaluated:
7681 case EvalInfo::EM_PotentialConstantExpressionUnevaluated:
7683 return Success((Type & 2) ? 0 : -1, E);
7686 llvm_unreachable(
"unexpected EvalMode");
7689 case Builtin::BI__builtin_bswap16:
7690 case Builtin::BI__builtin_bswap32:
7691 case Builtin::BI__builtin_bswap64: {
7696 return Success(Val.byteSwap(), E);
7699 case Builtin::BI__builtin_classify_type:
7706 case Builtin::BI__builtin_clz:
7707 case Builtin::BI__builtin_clzl:
7708 case Builtin::BI__builtin_clzll:
7709 case Builtin::BI__builtin_clzs: {
7716 return Success(Val.countLeadingZeros(), E);
7719 case Builtin::BI__builtin_constant_p:
7722 case Builtin::BI__builtin_ctz:
7723 case Builtin::BI__builtin_ctzl:
7724 case Builtin::BI__builtin_ctzll:
7725 case Builtin::BI__builtin_ctzs: {
7732 return Success(Val.countTrailingZeros(), E);
7735 case Builtin::BI__builtin_eh_return_data_regno: {
7737 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
7738 return Success(Operand, E);
7741 case Builtin::BI__builtin_expect:
7742 return Visit(E->
getArg(0));
7744 case Builtin::BI__builtin_ffs:
7745 case Builtin::BI__builtin_ffsl:
7746 case Builtin::BI__builtin_ffsll: {
7751 unsigned N = Val.countTrailingZeros();
7752 return Success(N == Val.getBitWidth() ? 0 : N + 1, E);
7755 case Builtin::BI__builtin_fpclassify: {
7760 switch (Val.getCategory()) {
7761 case APFloat::fcNaN: Arg = 0;
break;
7762 case APFloat::fcInfinity: Arg = 1;
break;
7763 case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2;
break;
7764 case APFloat::fcZero: Arg = 4;
break;
7766 return Visit(E->
getArg(Arg));
7769 case Builtin::BI__builtin_isinf_sign: {
7772 Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E);
7775 case Builtin::BI__builtin_isinf: {
7778 Success(Val.isInfinity() ? 1 : 0, E);
7781 case Builtin::BI__builtin_isfinite: {
7784 Success(Val.isFinite() ? 1 : 0, E);
7787 case Builtin::BI__builtin_isnan: {
7790 Success(Val.isNaN() ? 1 : 0, E);
7793 case Builtin::BI__builtin_isnormal: {
7796 Success(Val.isNormal() ? 1 : 0, E);
7799 case Builtin::BI__builtin_parity:
7800 case Builtin::BI__builtin_parityl:
7801 case Builtin::BI__builtin_parityll: {
7806 return Success(Val.countPopulation() % 2, E);
7809 case Builtin::BI__builtin_popcount:
7810 case Builtin::BI__builtin_popcountl:
7811 case Builtin::BI__builtin_popcountll: {
7816 return Success(Val.countPopulation(), E);
7819 case Builtin::BIstrlen:
7820 case Builtin::BIwcslen:
7822 if (Info.getLangOpts().CPlusPlus11)
7823 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
7825 << (std::string(
"'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) +
"'");
7827 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
7829 case Builtin::BI__builtin_strlen:
7830 case Builtin::BI__builtin_wcslen: {
7840 if (
const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
7841 String.getLValueBase().dyn_cast<
const Expr *>())) {
7844 StringRef Str = S->getBytes();
7845 int64_t Off = String.Offset.getQuantity();
7846 if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
7847 S->getCharByteWidth() == 1 &&
7849 Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) {
7850 Str = Str.substr(Off);
7852 StringRef::size_type Pos = Str.find(0);
7853 if (Pos != StringRef::npos)
7854 Str = Str.substr(0, Pos);
7856 return Success(Str.size(), E);
7863 for (uint64_t Strlen = 0; ; ++Strlen) {
7869 return Success(Strlen, E);
7875 case Builtin::BIstrcmp:
7876 case Builtin::BIwcscmp:
7877 case Builtin::BIstrncmp:
7878 case Builtin::BIwcsncmp:
7879 case Builtin::BImemcmp:
7880 case Builtin::BIwmemcmp:
7882 if (Info.getLangOpts().CPlusPlus11)
7883 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
7885 << (std::string(
"'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) +
"'");
7887 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
7889 case Builtin::BI__builtin_strcmp:
7890 case Builtin::BI__builtin_wcscmp:
7891 case Builtin::BI__builtin_strncmp:
7892 case Builtin::BI__builtin_wcsncmp:
7893 case Builtin::BI__builtin_memcmp:
7894 case Builtin::BI__builtin_wmemcmp: {
7895 LValue String1, String2;
7902 uint64_t MaxLength = uint64_t(-1);
7903 if (BuiltinOp != Builtin::BIstrcmp &&
7904 BuiltinOp != Builtin::BIwcscmp &&
7905 BuiltinOp != Builtin::BI__builtin_strcmp &&
7906 BuiltinOp != Builtin::BI__builtin_wcscmp) {
7910 MaxLength = N.getExtValue();
7912 bool StopAtNull = (BuiltinOp != Builtin::BImemcmp &&
7913 BuiltinOp != Builtin::BIwmemcmp &&
7914 BuiltinOp != Builtin::BI__builtin_memcmp &&
7915 BuiltinOp != Builtin::BI__builtin_wmemcmp);
7916 for (; MaxLength; --MaxLength) {
7923 return Success(Char1.
getInt() < Char2.
getInt() ? -1 : 1, E);
7924 if (StopAtNull && !Char1.
getInt())
7925 return Success(0, E);
7926 assert(!(StopAtNull && !Char2.
getInt()));
7932 return Success(0, E);
7935 case Builtin::BI__atomic_always_lock_free:
7936 case Builtin::BI__atomic_is_lock_free:
7937 case Builtin::BI__c11_atomic_is_lock_free: {
7955 unsigned InlineWidthBits =
7956 Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
7957 if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
7958 if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free ||
7964 return Success(1, E);
7967 castAs<PointerType>()->getPointeeType();
7969 Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
7971 return Success(1, E);
7976 return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
7977 Success(0, E) :
Error(E);
7979 case Builtin::BIomp_is_initial_device:
7981 return Success(Info.getLangOpts().OpenMPIsDevice ? 0 : 1, E);
7986 if (!A.getLValueBase())
7987 return !B.getLValueBase();
7988 if (!B.getLValueBase())
7991 if (A.getLValueBase().getOpaqueValue() !=
7992 B.getLValueBase().getOpaqueValue()) {
8002 A.getLValueCallIndex() == B.getLValueCallIndex();
8011 if (!LV.getLValueBase())
8016 if (!LV.getLValueDesignator().Invalid &&
8017 !LV.getLValueDesignator().isOnePastTheEnd())
8022 QualType Ty = getType(LV.getLValueBase());
8029 return LV.getLValueOffset() == Size;
8039 class DataRecursiveIntBinOpEvaluator {
8044 EvalResult() : Failed(
false) { }
8046 void swap(EvalResult &RHS) {
8048 Failed = RHS.Failed;
8055 EvalResult LHSResult;
8056 enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind }
Kind;
8059 Job(Job &&) =
default;
8061 void startSpeculativeEval(EvalInfo &Info) {
8062 SpecEvalRAII = SpeculativeEvaluationRAII(Info);
8066 SpeculativeEvaluationRAII SpecEvalRAII;
8071 IntExprEvaluator &IntEval;
8076 DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval,
APValue &Result)
8077 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
8094 EvalResult PrevResult;
8095 while (!Queue.empty())
8096 process(PrevResult);
8098 if (PrevResult.Failed)
return false;
8100 FinalResult.
swap(PrevResult.Val);
8105 bool Success(uint64_t Value,
const Expr *E,
APValue &Result) {
8106 return IntEval.Success(Value, E, Result);
8108 bool Success(
const APSInt &Value,
const Expr *E,
APValue &Result) {
8109 return IntEval.Success(Value, E, Result);
8112 return IntEval.Error(E);
8115 return IntEval.Error(E, D);
8119 return Info.CCEDiag(E, D);
8123 bool VisitBinOpLHSOnly(EvalResult &LHSResult,
const BinaryOperator *E,
8124 bool &SuppressRHSDiags);
8126 bool VisitBinOp(
const EvalResult &LHSResult,
const EvalResult &RHSResult,
8129 void EvaluateExpr(
const Expr *E, EvalResult &Result) {
8130 Result.Failed = !
Evaluate(Result.Val, Info, E);
8135 void process(EvalResult &Result);
8137 void enqueue(
const Expr *E) {
8139 Queue.resize(Queue.size()+1);
8141 Queue.back().Kind = Job::AnyExprKind;
8147 bool DataRecursiveIntBinOpEvaluator::
8148 VisitBinOpLHSOnly(EvalResult &LHSResult,
const BinaryOperator *E,
8149 bool &SuppressRHSDiags) {
8152 if (LHSResult.Failed)
8153 return Info.noteSideEffect();
8162 if (LHSAsBool == (E->
getOpcode() == BO_LOr)) {
8163 Success(LHSAsBool, E, LHSResult.Val);
8167 LHSResult.Failed =
true;
8171 if (!Info.noteSideEffect())
8177 SuppressRHSDiags =
true;
8186 if (LHSResult.Failed && !Info.noteFailure())
8197 assert(!LVal.
hasLValuePath() &&
"have designator for integer lvalue");
8200 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
8202 : Offset64 + Index64);
8205 bool DataRecursiveIntBinOpEvaluator::
8206 VisitBinOp(
const EvalResult &LHSResult,
const EvalResult &RHSResult,
8209 if (RHSResult.Failed)
8211 Result = RHSResult.Val;
8216 bool lhsResult, rhsResult;
8223 return Success(lhsResult || rhsResult, E, Result);
8225 return Success(lhsResult && rhsResult, E, Result);
8231 if (rhsResult == (E->
getOpcode() == BO_LOr))
8232 return Success(rhsResult, E, Result);
8242 if (LHSResult.Failed || RHSResult.Failed)
8245 const APValue &LHSVal = LHSResult.Val;
8246 const APValue &RHSVal = RHSResult.Val;
8270 if (!LHSExpr || !RHSExpr)
8274 if (!LHSAddrExpr || !RHSAddrExpr)
8278 RHSAddrExpr->getLabel()->getDeclContext())
8280 Result =
APValue(LHSAddrExpr, RHSAddrExpr);
8296 return Success(Value, E, Result);
8299 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
8300 Job &job = Queue.back();
8303 case Job::AnyExprKind: {
8304 if (
const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
8305 if (shouldEnqueue(Bop)) {
8306 job.Kind = Job::BinOpKind;
8307 enqueue(Bop->getLHS());
8312 EvaluateExpr(job.E, Result);
8317 case Job::BinOpKind: {
8319 bool SuppressRHSDiags =
false;
8320 if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
8324 if (SuppressRHSDiags)
8325 job.startSpeculativeEval(Info);
8326 job.LHSResult.swap(Result);
8327 job.Kind = Job::BinOpVisitedLHSKind;
8332 case Job::BinOpVisitedLHSKind: {
8336 Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
8342 llvm_unreachable(
"Invalid Job::Kind!");
8348 class DelayedNoteFailureRAII {
8353 DelayedNoteFailureRAII(EvalInfo &Info,
bool NoteFailure =
true)
8354 : Info(Info), NoteFailure(NoteFailure) {}
8355 ~DelayedNoteFailureRAII() {
8357 bool ContinueAfterFailure = Info.noteFailure();
8358 (void)ContinueAfterFailure;
8359 assert(ContinueAfterFailure &&
8360 "Shouldn't have kept evaluating on failure.");
8366 bool IntExprEvaluator::VisitBinaryOperator(
const BinaryOperator *E) {
8372 DelayedNoteFailureRAII MaybeNoteFailureLater(Info, E->
isAssignmentOp());
8373 if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E))
8374 return DataRecursiveIntBinOpEvaluator(*
this, Result).Traverse(E);
8380 ComplexValue LHS, RHS;
8389 LHS.makeComplexFloat();
8390 LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics());
8395 if (!LHSOK && !Info.noteFailure())
8401 RHS.makeComplexFloat();
8402 RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics());
8406 if (LHS.isComplexFloat()) {
8407 APFloat::cmpResult CR_r =
8408 LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
8409 APFloat::cmpResult CR_i =
8410 LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
8413 return Success((CR_r == APFloat::cmpEqual &&
8414 CR_i == APFloat::cmpEqual), E);
8417 "Invalid complex comparison.");
8418 return Success(((CR_r == APFloat::cmpGreaterThan ||
8419 CR_r == APFloat::cmpLessThan ||
8420 CR_r == APFloat::cmpUnordered) ||
8421 (CR_i == APFloat::cmpGreaterThan ||
8422 CR_i == APFloat::cmpLessThan ||
8423 CR_i == APFloat::cmpUnordered)), E);
8427 return Success((LHS.getComplexIntReal() == RHS.getComplexIntReal() &&
8428 LHS.getComplexIntImag() == RHS.getComplexIntImag()), E);
8431 "Invalid compex comparison.");
8432 return Success((LHS.getComplexIntReal() != RHS.getComplexIntReal() ||
8433 LHS.getComplexIntImag() != RHS.getComplexIntImag()), E);
8440 APFloat RHS(0.0), LHS(0.0);
8443 if (!LHSOK && !Info.noteFailure())
8449 APFloat::cmpResult CR = LHS.compare(RHS);
8453 llvm_unreachable(
"Invalid binary operator!");
8455 return Success(CR == APFloat::cmpLessThan, E);
8457 return Success(CR == APFloat::cmpGreaterThan, E);
8459 return Success(CR == APFloat::cmpLessThan || CR == APFloat::cmpEqual, E);
8461 return Success(CR == APFloat::cmpGreaterThan || CR == APFloat::cmpEqual,
8464 return Success(CR == APFloat::cmpEqual, E);
8466 return Success(CR == APFloat::cmpGreaterThan
8467 || CR == APFloat::cmpLessThan
8468 || CR == APFloat::cmpUnordered, E);
8474 LValue LHSValue, RHSValue;
8477 if (!LHSOK && !Info.noteFailure())
8488 if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
8490 const Expr *LHSExpr = LHSValue.Base.dyn_cast<
const Expr*>();
8491 const Expr *RHSExpr = RHSValue.Base.dyn_cast<
const Expr*>();
8492 if (!LHSExpr || !RHSExpr)
8496 if (!LHSAddrExpr || !RHSAddrExpr)
8500 RHSAddrExpr->getLabel()->getDeclContext())
8502 return Success(
APValue(LHSAddrExpr, RHSAddrExpr), E);
8511 if ((!LHSValue.Base && !LHSValue.Offset.isZero()) ||
8512 (!RHSValue.Base && !RHSValue.Offset.isZero()))
8519 LHSValue.Base && RHSValue.Base)
8527 if ((LHSValue.Base && LHSValue.Offset.isZero() &&
8529 (RHSValue.Base && RHSValue.Offset.isZero() &&
8541 return Success(E->
getOpcode() == BO_NE, E);
8544 const CharUnits &LHSOffset = LHSValue.getLValueOffset();
8545 const CharUnits &RHSOffset = RHSValue.getLValueOffset();
8547 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
8548 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
8555 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
8557 LHSDesignator, RHSDesignator))
8558 CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array);
8570 if (ElementSize.
isZero()) {
8571 Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size)
8585 llvm::APInt(65, (int64_t)LHSOffset.getQuantity(),
true),
false);
8587 llvm::APInt(65, (int64_t)RHSOffset.
getQuantity(),
true),
false);
8589 llvm::APInt(65, (int64_t)ElementSize.
getQuantity(),
true),
false);
8590 APSInt TrueResult = (LHS - RHS) / ElemSize;
8591 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->
getType()));
8593 if (Result.extend(65) != TrueResult &&
8596 return Success(Result, E);
8608 CCEDiag(E, diag::note_constexpr_void_comparison);
8618 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid &&
8623 RHSDesignator, WasArrayIndex);
8630 if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() &&
8631 Mismatch < RHSDesignator.Entries.size()) {
8632 const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]);
8633 const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]);
8635 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
8637 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
8638 << getAsBaseClass(LHSDesignator.Entries[Mismatch])
8641 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field)
8642 << getAsBaseClass(RHSDesignator.Entries[Mismatch])
8646 CCEDiag(E, diag::note_constexpr_pointer_comparison_differing_access)
8654 unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
8655 uint64_t CompareLHS = LHSOffset.getQuantity();
8657 assert(PtrSize <= 64 &&
"Unexpected pointer width");
8658 uint64_t Mask = ~0ULL >> (64 - PtrSize);
8666 QualType BaseTy = getType(LHSValue.Base);
8669 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
8671 if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit)
8676 default: llvm_unreachable(
"missing comparison operator");
8677 case BO_LT:
return Success(CompareLHS < CompareRHS, E);
8678 case BO_GT:
return Success(CompareLHS > CompareRHS, E);
8679 case BO_LE:
return Success(CompareLHS <= CompareRHS, E);
8680 case BO_GE:
return Success(CompareLHS >= CompareRHS, E);
8681 case BO_EQ:
return Success(CompareLHS == CompareRHS, E);
8682 case BO_NE:
return Success(CompareLHS != CompareRHS, E);
8688 assert(E->
isEqualityOp() &&
"unexpected member pointer operation");
8691 MemberPtr LHSValue, RHSValue;
8694 if (!LHSOK && !Info.noteFailure())
8703 if (!LHSValue.getDecl() || !RHSValue.getDecl()) {
8704 bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl();
8705 return Success(E->
getOpcode() == BO_EQ ? Equal : !Equal, E);
8710 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
8711 if (MD->isVirtual())
8712 CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
8713 if (
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
8714 if (MD->isVirtual())
8715 CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
8721 bool Equal = LHSValue == RHSValue;
8722 return Success(E->
getOpcode() == BO_EQ ? Equal : !Equal, E);
8727 assert(RHSTy->
isNullPtrType() &&
"missing pointer conversion");
8732 return Success(Opcode == BO_EQ || Opcode == BO_LE || Opcode == BO_GE, E);
8737 "DataRecursiveIntBinOpEvaluator should have handled integral types");
8739 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
8744 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
8765 return Success(n, E);
8767 return Success(1, E);
8780 return Success(Sizeof, E);
8785 Info.Ctx.toCharUnitsFromBits(
8791 llvm_unreachable(
"unknown expr/type trait");
8794 bool IntExprEvaluator::VisitOffsetOfExpr(
const OffsetOfExpr *OOE) {
8800 for (
unsigned i = 0; i != n; ++i) {
8808 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
8812 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
8813 Result += IdxResult.getSExtValue() * ElementSize;
8826 assert(i < RL.
getFieldCount() &&
"offsetof field in wrong type");
8833 llvm_unreachable(
"dependent __builtin_offsetof");
8849 CurrentType = BaseSpec->
getType();
8860 return Success(Result, OOE);
8863 bool IntExprEvaluator::VisitUnaryOperator(
const UnaryOperator *E) {
8879 if (!Result.isInt())
return Error(E);
8880 const APSInt &Value = Result.getInt();
8881 if (Value.isSigned() && Value.isMinSignedValue() &&
8885 return Success(-Value, E);
8890 if (!Result.isInt())
return Error(E);
8891 return Success(~Result.getInt(), E);
8897 return Success(!bres, E);
8904 bool IntExprEvaluator::VisitCastExpr(
const CastExpr *E) {
8910 case CK_BaseToDerived:
8911 case CK_DerivedToBase:
8912 case CK_UncheckedDerivedToBase:
8915 case CK_ArrayToPointerDecay:
8916 case CK_FunctionToPointerDecay:
8917 case CK_NullToPointer:
8918 case CK_NullToMemberPointer:
8919 case CK_BaseToDerivedMemberPointer:
8920 case CK_DerivedToBaseMemberPointer:
8921 case CK_ReinterpretMemberPointer:
8922 case CK_ConstructorConversion:
8923 case CK_IntegralToPointer:
8925 case CK_VectorSplat:
8926 case CK_IntegralToFloating:
8927 case CK_FloatingCast:
8928 case CK_CPointerToObjCPointerCast:
8929 case CK_BlockPointerToObjCPointerCast:
8930 case CK_AnyPointerToBlockPointerCast:
8931 case CK_ObjCObjectLValueCast:
8932 case CK_FloatingRealToComplex:
8933 case CK_FloatingComplexToReal:
8934 case CK_FloatingComplexCast:
8935 case CK_FloatingComplexToIntegralComplex:
8936 case CK_IntegralRealToComplex:
8937 case CK_IntegralComplexCast:
8938 case CK_IntegralComplexToFloatingComplex:
8939 case CK_BuiltinFnToFnPtr:
8940 case CK_ZeroToOCLEvent:
8941 case CK_ZeroToOCLQueue:
8942 case CK_NonAtomicToAtomic:
8943 case CK_AddressSpaceConversion:
8944 case CK_IntToOCLSampler:
8945 llvm_unreachable(
"invalid cast kind for integral value");
8949 case CK_LValueBitCast:
8950 case CK_ARCProduceObject:
8951 case CK_ARCConsumeObject:
8952 case CK_ARCReclaimReturnedObject:
8953 case CK_ARCExtendBlockObject:
8954 case CK_CopyAndAutoreleaseBlockObject:
8957 case CK_UserDefinedConversion:
8958 case CK_LValueToRValue:
8959 case CK_AtomicToNonAtomic:
8961 return ExprEvaluatorBaseTy::VisitCastExpr(E);
8963 case CK_MemberPointerToBoolean:
8964 case CK_PointerToBoolean:
8965 case CK_IntegralToBoolean:
8966 case CK_FloatingToBoolean:
8967 case CK_BooleanToSignedIntegral:
8968 case CK_FloatingComplexToBoolean:
8969 case CK_IntegralComplexToBoolean: {
8973 uint64_t IntResult = BoolResult;
8974 if (BoolResult && E->
getCastKind() == CK_BooleanToSignedIntegral)
8975 IntResult = (uint64_t)-1;
8976 return Success(IntResult, E);
8979 case CK_IntegralCast: {
8980 if (!Visit(SubExpr))
8983 if (!Result.isInt()) {
8989 if (Result.isAddrLabelDiff())
8990 return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
8992 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
8996 Result.getInt()), E);
8999 case CK_PointerToIntegral: {
9000 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
9006 if (LV.getLValueBase()) {
9011 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
9014 LV.Designator.setInvalid();
9015 LV.moveInto(Result);
9020 if (LV.isNullPointer())
9021 V = Info.Ctx.getTargetNullPointerValue(SrcType);
9023 V = LV.getLValueOffset().getQuantity();
9025 APSInt AsInt = Info.Ctx.MakeIntValue(V, SrcType);
9029 case CK_IntegralComplexToReal: {
9033 return Success(C.getComplexIntReal(), E);
9036 case CK_FloatingToIntegral: {
9044 return Success(Value, E);
9048 llvm_unreachable(
"unknown cast resulting in integral value");
9051 bool IntExprEvaluator::VisitUnaryReal(
const UnaryOperator *E) {
9056 if (!LV.isComplexInt())
9058 return Success(LV.getComplexIntReal(), E);
9064 bool IntExprEvaluator::VisitUnaryImag(
const UnaryOperator *E) {
9069 if (!LV.isComplexInt())
9071 return Success(LV.getComplexIntImag(), E);
9075 return Success(0, E);
9078 bool IntExprEvaluator::VisitSizeOfPackExpr(
const SizeOfPackExpr *E) {
9082 bool IntExprEvaluator::VisitCXXNoexceptExpr(
const CXXNoexceptExpr *E) {
9091 class FloatExprEvaluator
9092 :
public ExprEvaluatorBase<FloatExprEvaluator> {
9095 FloatExprEvaluator(EvalInfo &info, APFloat &result)
9096 : ExprEvaluatorBaseTy(info),
Result(result) {}
9103 bool ZeroInitialization(
const Expr *E) {
9104 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->
getType()));
9108 bool VisitCallExpr(
const CallExpr *E);
9113 bool VisitCastExpr(
const CastExpr *E);
9124 return FloatExprEvaluator(Info, Result).Visit(E);
9131 llvm::APFloat &Result) {
9133 if (!S)
return false;
9141 fill = llvm::APInt(32, 0);
9142 else if (S->
getString().getAsInteger(0, fill))
9147 Result = llvm::APFloat::getSNaN(Sem,
false, &fill);
9149 Result = llvm::APFloat::getQNaN(Sem,
false, &fill);
9157 Result = llvm::APFloat::getQNaN(Sem,
false, &fill);
9159 Result = llvm::APFloat::getSNaN(Sem,
false, &fill);
9165 bool FloatExprEvaluator::VisitCallExpr(
const CallExpr *E) {
9168 return ExprEvaluatorBaseTy::VisitCallExpr(E);
9170 case Builtin::BI__builtin_huge_val:
9171 case Builtin::BI__builtin_huge_valf:
9172 case Builtin::BI__builtin_huge_vall:
9173 case Builtin::BI__builtin_inf:
9174 case Builtin::BI__builtin_inff:
9175 case Builtin::BI__builtin_infl: {
9176 const llvm::fltSemantics &Sem =
9177 Info.Ctx.getFloatTypeSemantics(E->
getType());
9178 Result = llvm::APFloat::getInf(Sem);
9182 case Builtin::BI__builtin_nans:
9183 case Builtin::BI__builtin_nansf:
9184 case Builtin::BI__builtin_nansl:
9190 case Builtin::BI__builtin_nan:
9191 case Builtin::BI__builtin_nanf:
9192 case Builtin::BI__builtin_nanl:
9200 case Builtin::BI__builtin_fabs:
9201 case Builtin::BI__builtin_fabsf:
9202 case Builtin::BI__builtin_fabsl:
9206 if (Result.isNegative())
9207 Result.changeSign();
9214 case Builtin::BI__builtin_copysign:
9215 case Builtin::BI__builtin_copysignf:
9216 case Builtin::BI__builtin_copysignl: {
9221 Result.copySign(RHS);
9227 bool FloatExprEvaluator::VisitUnaryReal(
const UnaryOperator *E) {
9232 Result = CV.FloatReal;
9239 bool FloatExprEvaluator::VisitUnaryImag(
const UnaryOperator *E) {
9244 Result = CV.FloatImag;
9249 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->
getType());
9250 Result = llvm::APFloat::getZero(Sem);
9254 bool FloatExprEvaluator::VisitUnaryOperator(
const UnaryOperator *E) {
9256 default:
return Error(E);
9262 Result.changeSign();
9267 bool FloatExprEvaluator::VisitBinaryOperator(
const BinaryOperator *E) {
9269 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9273 if (!LHSOK && !Info.noteFailure())
9279 bool FloatExprEvaluator::VisitFloatingLiteral(
const FloatingLiteral *E) {
9284 bool FloatExprEvaluator::VisitCastExpr(
const CastExpr *E) {
9289 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9291 case CK_IntegralToFloating: {
9298 case CK_FloatingCast: {
9299 if (!Visit(SubExpr))
9305 case CK_FloatingComplexToReal: {
9309 Result = V.getComplexFloatReal();
9320 class ComplexExprEvaluator
9321 :
public ExprEvaluatorBase<ComplexExprEvaluator> {
9325 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
9326 : ExprEvaluatorBaseTy(info),
Result(Result) {}
9333 bool ZeroInitialization(
const Expr *E);
9340 bool VisitCastExpr(
const CastExpr *E);
9350 return ComplexExprEvaluator(Info, Result).Visit(E);
9353 bool ComplexExprEvaluator::ZeroInitialization(
const Expr *E) {
9356 Result.makeComplexFloat();
9357 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
9358 Result.FloatReal = Zero;
9359 Result.FloatImag = Zero;
9361 Result.makeComplexInt();
9362 APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
9363 Result.IntReal = Zero;
9364 Result.IntImag = Zero;
9369 bool ComplexExprEvaluator::VisitImaginaryLiteral(
const ImaginaryLiteral *E) {
9373 Result.makeComplexFloat();
9374 APFloat &Imag = Result.FloatImag;
9378 Result.FloatReal = APFloat(Imag.getSemantics());
9382 "Unexpected imaginary literal.");
9384 Result.makeComplexInt();
9385 APSInt &Imag = Result.IntImag;
9389 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
9394 bool ComplexExprEvaluator::VisitCastExpr(
const CastExpr *E) {
9398 case CK_BaseToDerived:
9399 case CK_DerivedToBase:
9400 case CK_UncheckedDerivedToBase:
9403 case CK_ArrayToPointerDecay:
9404 case CK_FunctionToPointerDecay:
9405 case CK_NullToPointer:
9406 case CK_NullToMemberPointer:
9407 case CK_BaseToDerivedMemberPointer:
9408 case CK_DerivedToBaseMemberPointer:
9409 case CK_MemberPointerToBoolean:
9410 case CK_ReinterpretMemberPointer:
9411 case CK_ConstructorConversion:
9412 case CK_IntegralToPointer:
9413 case CK_PointerToIntegral:
9414 case CK_PointerToBoolean:
9416 case CK_VectorSplat:
9417 case CK_IntegralCast:
9418 case CK_BooleanToSignedIntegral:
9419 case CK_IntegralToBoolean:
9420 case CK_IntegralToFloating:
9421 case CK_FloatingToIntegral:
9422 case CK_FloatingToBoolean:
9423 case CK_FloatingCast:
9424 case CK_CPointerToObjCPointerCast:
9425 case CK_BlockPointerToObjCPointerCast:
9426 case CK_AnyPointerToBlockPointerCast:
9427 case CK_ObjCObjectLValueCast:
9428 case CK_FloatingComplexToReal:
9429 case CK_FloatingComplexToBoolean:
9430 case CK_IntegralComplexToReal:
9431 case CK_IntegralComplexToBoolean:
9432 case CK_ARCProduceObject:
9433 case CK_ARCConsumeObject:
9434 case CK_ARCReclaimReturnedObject:
9435 case CK_ARCExtendBlockObject:
9436 case CK_CopyAndAutoreleaseBlockObject:
9437 case CK_BuiltinFnToFnPtr:
9438 case CK_ZeroToOCLEvent:
9439 case CK_ZeroToOCLQueue:
9440 case CK_NonAtomicToAtomic:
9441 case CK_AddressSpaceConversion:
9442 case CK_IntToOCLSampler:
9443 llvm_unreachable(
"invalid cast kind for complex value");
9445 case CK_LValueToRValue:
9446 case CK_AtomicToNonAtomic:
9448 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9451 case CK_LValueBitCast:
9452 case CK_UserDefinedConversion:
9455 case CK_FloatingRealToComplex: {
9456 APFloat &Real = Result.FloatReal;
9460 Result.makeComplexFloat();
9461 Result.FloatImag = APFloat(Real.getSemantics());
9465 case CK_FloatingComplexCast: {
9477 case CK_FloatingComplexToIntegralComplex: {
9484 Result.makeComplexInt();
9486 To, Result.IntReal) &&
9488 To, Result.IntImag);
9491 case CK_IntegralRealToComplex: {
9492 APSInt &Real = Result.IntReal;
9496 Result.makeComplexInt();
9497 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
9501 case CK_IntegralComplexCast: {
9514 case CK_IntegralComplexToFloatingComplex: {
9521 Result.makeComplexFloat();
9523 To, Result.FloatReal) &&
9525 To, Result.FloatImag);
9529 llvm_unreachable(
"unknown cast resulting in complex value");
9532 bool ComplexExprEvaluator::VisitBinaryOperator(
const BinaryOperator *E) {
9534 return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
9538 bool LHSReal =
false, RHSReal =
false;
9543 APFloat &Real = Result.FloatReal;
9546 Result.makeComplexFloat();
9547 Result.FloatImag = APFloat(Real.getSemantics());
9550 LHSOK = Visit(E->
getLHS());
9552 if (!LHSOK && !Info.noteFailure())
9558 APFloat &Real = RHS.FloatReal;
9561 RHS.makeComplexFloat();
9562 RHS.FloatImag = APFloat(Real.getSemantics());
9566 assert(!(LHSReal && RHSReal) &&
9567 "Cannot have both operands of a complex operation be real.");
9569 default:
return Error(E);
9571 if (Result.isComplexFloat()) {
9572 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
9573 APFloat::rmNearestTiesToEven);
9575 Result.getComplexFloatImag() = RHS.getComplexFloatImag();
9577 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
9578 APFloat::rmNearestTiesToEven);
9580 Result.getComplexIntReal() += RHS.getComplexIntReal();
9581 Result.getComplexIntImag() += RHS.getComplexIntImag();
9585 if (Result.isComplexFloat()) {
9586 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
9587 APFloat::rmNearestTiesToEven);
9589 Result.getComplexFloatImag() = RHS.getComplexFloatImag();
9590 Result.getComplexFloatImag().changeSign();
9591 }
else if (!RHSReal) {
9592 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
9593 APFloat::rmNearestTiesToEven);
9596 Result.getComplexIntReal() -= RHS.getComplexIntReal();
9597 Result.getComplexIntImag() -= RHS.getComplexIntImag();
9601 if (Result.isComplexFloat()) {
9606 ComplexValue LHS =
Result;
9607 APFloat &A = LHS.getComplexFloatReal();
9608 APFloat &B = LHS.getComplexFloatImag();
9609 APFloat &
C = RHS.getComplexFloatReal();
9610 APFloat &D = RHS.getComplexFloatImag();
9611 APFloat &ResR = Result.getComplexFloatReal();
9612 APFloat &ResI = Result.getComplexFloatImag();
9614 assert(!RHSReal &&
"Cannot have two real operands for a complex op!");
9617 }
else if (RHSReal) {
9629 if (ResR.isNaN() && ResI.isNaN()) {
9630 bool Recalc =
false;
9631 if (A.isInfinity() || B.isInfinity()) {
9632 A = APFloat::copySign(
9633 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
9634 B = APFloat::copySign(
9635 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
9637 C = APFloat::copySign(APFloat(C.getSemantics()), C);
9639 D = APFloat::copySign(APFloat(D.getSemantics()), D);
9642 if (C.isInfinity() || D.isInfinity()) {
9643 C = APFloat::copySign(
9644 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
9645 D = APFloat::copySign(
9646 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
9648 A = APFloat::copySign(APFloat(A.getSemantics()), A);
9650 B = APFloat::copySign(APFloat(B.getSemantics()), B);
9653 if (!Recalc && (AC.isInfinity() || BD.isInfinity() ||
9654 AD.isInfinity() || BC.isInfinity())) {
9656 A = APFloat::copySign(APFloat(A.getSemantics()), A);
9658 B = APFloat::copySign(APFloat(B.getSemantics()), B);
9660 C = APFloat::copySign(APFloat(C.getSemantics()), C);
9662 D = APFloat::copySign(APFloat(D.getSemantics()), D);
9666 ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D);
9667 ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C);
9672 ComplexValue LHS =
Result;
9673 Result.getComplexIntReal() =
9674 (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
9675 LHS.getComplexIntImag() * RHS.getComplexIntImag());
9676 Result.getComplexIntImag() =
9677 (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
9678 LHS.getComplexIntImag() * RHS.getComplexIntReal());
9682 if (Result.isComplexFloat()) {
9687 ComplexValue LHS =
Result;
9688 APFloat &A = LHS.getComplexFloatReal();
9689 APFloat &B = LHS.getComplexFloatImag();
9690 APFloat &
C = RHS.getComplexFloatReal();
9691 APFloat &D = RHS.getComplexFloatImag();
9692 APFloat &ResR = Result.getComplexFloatReal();
9693 APFloat &ResI = Result.getComplexFloatImag();
9700 B = APFloat::getZero(A.getSemantics());
9703 APFloat MaxCD = maxnum(
abs(C),
abs(D));
9704 if (MaxCD.isFinite()) {
9705 DenomLogB =
ilogb(MaxCD);
9706 C =
scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven);
9707 D =
scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven);
9709 APFloat Denom = C * C + D * D;
9710 ResR =
scalbn((A * C + B * D) / Denom, -DenomLogB,
9711 APFloat::rmNearestTiesToEven);
9712 ResI =
scalbn((B * C - A * D) / Denom, -DenomLogB,
9713 APFloat::rmNearestTiesToEven);
9714 if (ResR.isNaN() && ResI.isNaN()) {
9715 if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) {
9716 ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A;
9717 ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B;
9718 }
else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() &&
9720 A = APFloat::copySign(
9721 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A);
9722 B = APFloat::copySign(
9723 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B);
9724 ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D);
9725 ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D);
9726 }
else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) {
9727 C = APFloat::copySign(
9728 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C);
9729 D = APFloat::copySign(
9730 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D);
9731 ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D);
9732 ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D);
9737 if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0)
9738 return Error(E, diag::note_expr_divide_by_zero);
9740 ComplexValue LHS =
Result;
9741 APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
9742 RHS.getComplexIntImag() * RHS.getComplexIntImag();
9743 Result.getComplexIntReal() =
9744 (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
9745 LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
9746 Result.getComplexIntImag() =
9747 (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
9748 LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
9756 bool ComplexExprEvaluator::VisitUnaryOperator(
const UnaryOperator *E) {
9770 if (Result.isComplexFloat()) {
9771 Result.getComplexFloatReal().changeSign();
9772 Result.getComplexFloatImag().changeSign();
9775 Result.getComplexIntReal() = -Result.getComplexIntReal();
9776 Result.getComplexIntImag() = -Result.getComplexIntImag();
9780 if (Result.isComplexFloat())
9781 Result.getComplexFloatImag().changeSign();
9783 Result.getComplexIntImag() = -Result.getComplexIntImag();
9788 bool ComplexExprEvaluator::VisitInitListExpr(
const InitListExpr *E) {
9791 Result.makeComplexFloat();
9797 Result.makeComplexInt();
9805 return ExprEvaluatorBaseTy::VisitInitListExpr(E);
9814 class AtomicExprEvaluator :
9815 public ExprEvaluatorBase<AtomicExprEvaluator> {
9819 AtomicExprEvaluator(EvalInfo &Info,
const LValue *This,
APValue &Result)
9820 : ExprEvaluatorBaseTy(Info), This(This),
Result(Result) {}
9827 bool ZeroInitialization(
const Expr *E) {
9836 bool VisitCastExpr(
const CastExpr *E) {
9839 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9840 case CK_NonAtomicToAtomic:
9851 return AtomicExprEvaluator(Info, This, Result).Visit(E);
9860 class VoidExprEvaluator
9861 :
public ExprEvaluatorBase<VoidExprEvaluator> {
9863 VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
9865 bool Success(
const APValue &V,
const Expr *e) {
return true; }
9867 bool ZeroInitialization(
const Expr *E) {
return true; }
9869 bool VisitCastExpr(
const CastExpr *E) {
9872 return ExprEvaluatorBaseTy::VisitCastExpr(E);
9879 bool VisitCallExpr(
const CallExpr *E) {
9882 return ExprEvaluatorBaseTy::VisitCallExpr(E);
9883 case Builtin::BI__assume:
9884 case Builtin::BI__builtin_assume:
9894 return VoidExprEvaluator(Info).Visit(E);
9909 LV.moveInto(Result);
9914 if (!IntExprEvaluator(Info, Result).Visit(E))
9920 LV.moveInto(Result);
9922 llvm::APFloat F(0.0);
9939 LV.set(E, Info.CurrentCall->Index);
9940 APValue &Value = Info.CurrentCall->createTemporary(E,
false);
9946 LV.set(E, Info.CurrentCall->Index);
9947 APValue &Value = Info.CurrentCall->createTemporary(E,
false);
9952 if (!Info.getLangOpts().CPlusPlus11)
9953 Info.CCEDiag(E, diag::note_constexpr_nonliteral)
9961 LV.set(E, Info.CurrentCall->Index);
9962 APValue &Value = Info.CurrentCall->createTemporary(E,
false);
9969 }
else if (Info.getLangOpts().CPlusPlus11) {
9970 Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->
getType();
9973 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
9984 const Expr *E,
bool AllowNonLiteralTypes) {
10023 LV.setFrom(Info.Ctx, Result);
10038 L->getType()->isUnsignedIntegerType()));
10072 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
10091 if (!getType()->isIntegralOrEnumerationType())
10099 Result = ExprResult.Val.getInt();
10105 if (!getType()->isRealFloatingType())
10113 Result = ExprResult.Val.getFloat();
10118 EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
10126 LV.moveInto(Result.Val);
10135 if (isRValue() && (getType()->isArrayType() || getType()->
isRecordType()) &&
10140 EStatus.
Diag = &Notes;
10142 EvalInfo InitInfo(Ctx, EStatus, VD->
isConstexpr()
10143 ? EvalInfo::EM_ConstantExpression
10144 : EvalInfo::EM_ConstantFold);
10145 InitInfo.setEvaluatingDecl(VD, Value);
10182 EvalResult.Diag =
Diag;
10185 assert(Result &&
"Could not evaluate expression");
10186 assert(EvalResult.Val.isInt() &&
"Expression did not evaluate to integer");
10188 return EvalResult.Val.getInt();
10195 EvalInfo Info(Ctx, EvalResult, EvalInfo::EM_EvaluateForOverflow);
10201 assert(Val.isLValue());
10229 IK_ICEIfUnevaluated,
10245 static ICEDiag
Worst(ICEDiag A, ICEDiag B) {
return A.Kind >= B.Kind ? A : B; }
10257 assert(!E->
isValueDependent() &&
"Should not see value dependent exprs!");
10262 #define ABSTRACT_STMT(Node) 10263 #define STMT(Node, Base) case Expr::Node##Class: 10264 #define EXPR(Node, Base) 10265 #include "clang/AST/StmtNodes.inc" 10266 case Expr::PredefinedExprClass:
10267 case Expr::FloatingLiteralClass:
10268 case Expr::ImaginaryLiteralClass:
10269 case Expr::StringLiteralClass:
10270 case Expr::ArraySubscriptExprClass:
10271 case Expr::OMPArraySectionExprClass:
10272 case Expr::MemberExprClass:
10273 case Expr::CompoundAssignOperatorClass:
10274 case Expr::CompoundLiteralExprClass:
10275 case Expr::ExtVectorElementExprClass:
10276 case Expr::DesignatedInitExprClass:
10277 case Expr::ArrayInitLoopExprClass:
10278 case Expr::ArrayInitIndexExprClass:
10279 case Expr::NoInitExprClass:
10280 case Expr::DesignatedInitUpdateExprClass:
10281 case Expr::ImplicitValueInitExprClass:
10282 case Expr::ParenListExprClass:
10283 case Expr::VAArgExprClass:
10284 case Expr::AddrLabelExprClass:
10285 case Expr::StmtExprClass:
10286 case Expr::CXXMemberCallExprClass:
10287 case Expr::CUDAKernelCallExprClass:
10288 case Expr::CXXDynamicCastExprClass:
10289 case Expr::CXXTypeidExprClass:
10290 case Expr::CXXUuidofExprClass:
10291 case Expr::MSPropertyRefExprClass:
10292 case Expr::MSPropertySubscriptExprClass:
10293 case Expr::CXXNullPtrLiteralExprClass:
10294 case Expr::UserDefinedLiteralClass:
10295 case Expr::CXXThisExprClass:
10296 case Expr::CXXThrowExprClass:
10297 case Expr::CXXNewExprClass:
10298 case Expr::CXXDeleteExprClass:
10299 case Expr::CXXPseudoDestructorExprClass:
10300 case Expr::UnresolvedLookupExprClass:
10301 case Expr::TypoExprClass:
10302 case Expr::DependentScopeDeclRefExprClass:
10303 case Expr::CXXConstructExprClass:
10304 case Expr::CXXInheritedCtorInitExprClass:
10305 case Expr::CXXStdInitializerListExprClass:
10306 case Expr::CXXBindTemporaryExprClass:
10307 case Expr::ExprWithCleanupsClass:
10308 case Expr::CXXTemporaryObjectExprClass:
10309 case Expr::CXXUnresolvedConstructExprClass:
10310 case Expr::CXXDependentScopeMemberExprClass:
10311 case Expr::UnresolvedMemberExprClass:
10312 case Expr::ObjCStringLiteralClass:
10313 case Expr::ObjCBoxedExprClass:
10314 case Expr::ObjCArrayLiteralClass:
10315 case Expr::ObjCDictionaryLiteralClass:
10316 case Expr::ObjCEncodeExprClass:
10317 case Expr::ObjCMessageExprClass:
10318 case Expr::ObjCSelectorExprClass:
10319 case Expr::ObjCProtocolExprClass:
10320 case Expr::ObjCIvarRefExprClass:
10321 case Expr::ObjCPropertyRefExprClass:
10322 case Expr::ObjCSubscriptRefExprClass:
10323 case Expr::ObjCIsaExprClass:
10324 case Expr::ObjCAvailabilityCheckExprClass:
10325 case Expr::ShuffleVectorExprClass:
10326 case Expr::ConvertVectorExprClass:
10327 case Expr::BlockExprClass:
10329 case Expr::OpaqueValueExprClass:
10330 case Expr::PackExpansionExprClass:
10331 case Expr::SubstNonTypeTemplateParmPackExprClass:
10332 case Expr::FunctionParmPackExprClass:
10333 case Expr::AsTypeExprClass:
10334 case Expr::ObjCIndirectCopyRestoreExprClass:
10335 case Expr::MaterializeTemporaryExprClass:
10336 case Expr::PseudoObjectExprClass:
10337 case Expr::AtomicExprClass:
10338 case Expr::LambdaExprClass:
10339 case Expr::CXXFoldExprClass:
10340 case Expr::CoawaitExprClass:
10341 case Expr::DependentCoawaitExprClass:
10342 case Expr::CoyieldExprClass:
10345 case Expr::InitListExprClass: {
10351 if (cast<InitListExpr>(E)->getNumInits() == 1)
10352 return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx);
10356 case Expr::SizeOfPackExprClass:
10357 case Expr::GNUNullExprClass:
10361 case Expr::SubstNonTypeTemplateParmExprClass:
10363 CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
10365 case Expr::ParenExprClass:
10366 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
10367 case Expr::GenericSelectionExprClass:
10368 return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx);
10369 case Expr::IntegerLiteralClass:
10370 case Expr::CharacterLiteralClass:
10371 case Expr::ObjCBoolLiteralExprClass:
10372 case Expr::CXXBoolLiteralExprClass:
10373 case Expr::CXXScalarValueInitExprClass:
10374 case Expr::TypeTraitExprClass:
10375 case Expr::ArrayTypeTraitExprClass:
10376 case Expr::ExpressionTraitExprClass:
10377 case Expr::CXXNoexceptExprClass:
10379 case Expr::CallExprClass:
10380 case Expr::CXXOperatorCallExprClass: {
10384 const CallExpr *CE = cast<CallExpr>(E);
10389 case Expr::DeclRefExprClass: {
10390 if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
10398 if (isa<ParmVarDecl>(D))
10399 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10404 if (
const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
10405 if (!Dcl->getType()->isIntegralOrEnumerationType())
10406 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10414 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation());
10419 case Expr::UnaryOperatorClass: {
10446 case Expr::OffsetOfExprClass: {
10455 case Expr::UnaryExprOrTypeTraitExprClass: {
10462 case Expr::BinaryOperatorClass: {
10507 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
10510 return ICEDiag(IK_ICEIfUnevaluated, E->
getLocStart());
10511 if (REval.isSigned() && REval.isAllOnesValue()) {
10513 if (LEval.isMinSignedValue())
10514 return ICEDiag(IK_ICEIfUnevaluated, E->
getLocStart());
10522 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE)
10523 return ICEDiag(IK_ICEIfUnevaluated, E->
getLocStart());
10529 return Worst(LHSResult, RHSResult);
10535 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) {
10545 return Worst(LHSResult, RHSResult);
10550 case Expr::ImplicitCastExprClass:
10551 case Expr::CStyleCastExprClass:
10552 case Expr::CXXFunctionalCastExprClass:
10553 case Expr::CXXStaticCastExprClass:
10554 case Expr::CXXReinterpretCastExprClass:
10555 case Expr::CXXConstCastExprClass:
10556 case Expr::ObjCBridgedCastExprClass: {
10557 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
10558 if (isa<ExplicitCastExpr>(E)) {
10563 APSInt IgnoredVal(DestWidth, !DestSigned);
10568 if (FL->getValue().convertToInteger(IgnoredVal,
10569 llvm::APFloat::rmTowardZero,
10570 &Ignored) & APFloat::opInvalidOp)
10575 switch (cast<CastExpr>(E)->getCastKind()) {
10576 case CK_LValueToRValue:
10577 case CK_AtomicToNonAtomic:
10578 case CK_NonAtomicToAtomic:
10580 case CK_IntegralToBoolean:
10581 case CK_IntegralCast:
10587 case Expr::BinaryConditionalOperatorClass: {
10590 if (CommonResult.Kind == IK_NotICE)
return CommonResult;
10592 if (FalseResult.Kind == IK_NotICE)
return FalseResult;
10593 if (CommonResult.Kind == IK_ICEIfUnevaluated)
return CommonResult;
10594 if (FalseResult.Kind == IK_ICEIfUnevaluated &&
10596 return FalseResult;
10598 case Expr::ConditionalOperatorClass: {
10606 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
10609 if (CondResult.Kind == IK_NotICE)
10615 if (TrueResult.Kind == IK_NotICE)
10617 if (FalseResult.Kind == IK_NotICE)
10618 return FalseResult;
10619 if (CondResult.Kind == IK_ICEIfUnevaluated)
10621 if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE)
10627 return FalseResult;
10630 case Expr::CXXDefaultArgExprClass:
10631 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
10632 case Expr::CXXDefaultInitExprClass:
10633 return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx);
10634 case Expr::ChooseExprClass: {
10635 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx);
10639 llvm_unreachable(
"Invalid StmtClass!");
10645 llvm::APSInt *Value,
10656 if (!Result.
isInt()) {
10661 if (Value) *Value = Result.
getInt();
10671 if (D.Kind != IK_ICE) {
10672 if (Loc) *Loc = D.Loc;
10683 if (!isIntegerConstantExpr(Ctx, Loc))
10689 if (!EvaluateAsInt(Value, Ctx, SE_AllowSideEffects))
10690 llvm_unreachable(
"ICE cannot be evaluated!");
10695 return CheckICE(
this, Ctx).Kind == IK_ICE;
10707 Status.Diag = &Diags;
10708 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
10713 if (!Diags.empty()) {
10714 IsConstExpr =
false;
10715 if (Loc) *Loc = Diags[0].first;
10716 }
else if (!IsConstExpr) {
10718 if (Loc) *Loc = getExprLoc();
10721 return IsConstExpr;
10727 const Expr *This)
const {
10729 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
10732 const LValue *ThisPtr =
nullptr;
10736 assert(MD &&
"Don't provide `this` for non-methods.");
10737 assert(!MD->isStatic() &&
"Don't provide `this` for static methods.");
10740 ThisPtr = &ThisVal;
10741 if (Info.EvalStatus.HasSideEffects)
10745 ArgVector ArgValues(Args.size());
10748 if ((*I)->isValueDependent() ||
10749 !
Evaluate(ArgValues[I - Args.begin()], Info, *I))
10751 ArgValues[I - Args.begin()] =
APValue();
10752 if (Info.EvalStatus.HasSideEffects)
10757 CallStackFrame Frame(Info, Callee->
getLocation(), Callee, ThisPtr,
10759 return Evaluate(Value, Info,
this) && !Info.EvalStatus.HasSideEffects;
10772 Status.
Diag = &Diags;
10775 EvalInfo::EM_PotentialConstantExpression);
10784 This.set(&VIE, Info.CurrentCall->Index);
10792 Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
10797 Args, FD->
getBody(), Info, Scratch,
nullptr);
10800 return Diags.empty();
10808 Status.
Diag = &Diags;
10811 EvalInfo::EM_PotentialConstantExpressionUnevaluated);
10815 ArgVector ArgValues(0);
10819 "Failed to set up arguments for potential constant evaluation");
10820 CallStackFrame Frame(Info,
SourceLocation(), FD,
nullptr, ArgValues.data());
10824 return Diags.empty();
10828 unsigned Type)
const {
10829 if (!getType()->isPointerType())
10833 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
static Address castToBase(CodeGenFunction &CGF, QualType BaseTy, QualType ElTy, llvm::Type *BaseLVType, CharUnits BaseLVAlignment, llvm::Value *Addr)
static bool HandleConstructorCall(const Expr *E, const LValue &This, APValue *ArgValues, const CXXConstructorDecl *Definition, EvalInfo &Info, APValue &Result)
Evaluate a constructor call.
Defines the clang::ASTContext interface.
const BlockDecl * getBlockDecl() const
The null pointer literal (C++11 [lex.nullptr])
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
An instance of this class is created to represent a function declaration or definition.
Expr ** getArgs()
Retrieve the call arguments.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
const Stmt * getElse() const
static bool IsGlobalLValue(APValue::LValueBase B)
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
uint64_t getValue() const
bool isMemberPointerType() const
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
static Opcode getOpForCompoundAssignment(Opcode Opc)
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
bool hasCaptures() const
hasCaptures - True if this block (or its nested blocks) captures anything of local storage from its e...
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
unsigned getNumBases() const
Retrieves the number of base classes of this class.
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr *> &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
bool operator==(CanQual< T > x, CanQual< U > y)
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
bool isMemberDataPointerType() const
FunctionDecl * findSpecialization(ArrayRef< TemplateArgument > Args, void *&InsertPos)
Return the specialization with the provided arguments if it exists, otherwise return the insertion po...
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
CompoundStmt * getSubStmt()
const Expr * getInit(unsigned Init) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
Stmt - This represents one statement.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
IfStmt - This represents an if/then/else.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx, const VarDecl *VD, SmallVectorImpl< PartialDiagnosticAt > &Notes) const
EvaluateAsInitializer - Evaluate an expression as if it were the initializer of the given declaration...
bool isRealFloatingType() const
Floating point categories.
SourceLocation getLocStart() const LLVM_READONLY
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
void addConst()
Add the const type qualifier to this QualType.
ActionResult< Expr * > ExprResult
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
bool isRecordType() const
static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, EvalInfo &Info)
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
Decl - This represents one declaration (or definition), e.g.
__DEVICE__ long long abs(long long __n)
llvm::APFloat getValue() const
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool isVirtual() const
Determines whether the base class is a virtual base class (or not).
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic, and whose semantics are that of the sole contained initializer)?
static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result, Expr::SideEffectsKind SEK)
unsigned getFieldIndex() const
getFieldIndex - Returns the index of this field within its record, as appropriate for passing to ASTR...
ParenExpr - This represents a parethesized expression, e.g.
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
static bool extractSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, APValue &Result)
Extract the designated sub-object of an rvalue.
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
The base class of the type hierarchy.
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
DiagnosticsEngine & getDiagnostics() const
static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index, bool IsSub)
static bool IsConstNonVolatile(QualType T)
void * BaseOrMember
BaseOrMember - The FieldDecl or CXXRecordDecl indicating the next item in the path.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Represents a call to a C++ constructor.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
bool isZero() const
isZero - Test whether the quantity equals zero.
const TargetInfo & getTargetInfo() const
static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx, const LValue &LV)
Determine whether this is a pointer past the end of the complete object referred to by the lvalue...
llvm::DenseMap< Stmt *, Stmt * > MapTy
SourceLocation getLocEnd() const LLVM_READONLY
const Expr * getAnyInitializer() const
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
static const ValueDecl * HandleMemberPointerAccess(EvalInfo &Info, QualType LVType, LValue &LV, const Expr *RHS, bool IncludeMember=true)
HandleMemberPointerAccess - Evaluate a member access operation and build an lvalue referring to the r...
Describes the capture of a variable or of this, or of a C++1y init-capture.
ArrayRef< ParmVarDecl * >::const_iterator param_const_iterator
static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, EvalInfo &Info)
EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and produce either the intege...
Represents a C++ constructor within a class.
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal)
Check that this reference or pointer core constant expression is a valid value for an address or refe...
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
const Expr * getResultExpr() const
The generic selection's result expression.
QualType getElementType() const
const Expr * getSubExpr() const
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Expr * getIndexExpr(unsigned Idx)
static bool EvaluateDecl(EvalInfo &Info, const Decl *D)
const CXXBaseSpecifier *const * path_const_iterator
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
This file provides some common utility functions for processing Lambda related AST Constructs...
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
VarDecl - An instance of this class is created to represent a variable declaration or definition...
static void negateAsSigned(APSInt &Int)
Negate an APSInt in place, converting it to a signed form if necessary, and preserving its value (by ...
static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This, const Expr *E, bool AllowNonLiteralTypes=false)
EvaluateInPlace - Evaluate an expression in-place in an APValue.
QualType getReturnType() const
CompoundLiteralExpr - [C99 6.5.2.5].
static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E)
APFloat & getComplexFloatReal()
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
const T * getAs() const
Member-template getAs<specific type>'.
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
The "__interface" keyword.
ArrayRef< LValuePathEntry > getLValuePath() const
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx, const CallExpr *Call, llvm::APInt &Result)
Attempts to compute the number of bytes available at the pointer returned by a function with the allo...
bool isInvalidDecl() const
static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E)
Evaluate an expression to see if it had side-effects, and discard its result.
bool isAddrLabelDiff() const
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Expr * getExprOperand() const
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
static bool isAssignmentOp(Opcode Opc)
ParmVarDecl - Represents a parameter to a function.
static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int, CharUnits &Result)
Converts the given APInt to CharUnits, assuming the APInt is unsigned.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
The collection of all-type qualifiers we support.
bool isVariableArrayType() const
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
bool isLValueOnePastTheEnd() const
static bool HasSameBase(const LValue &A, const LValue &B)
const ValueDecl * getMemberPointerDecl() const
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
RecordDecl - Represents a struct/union/class.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, QualType Type, CharUnits &Size)
Get the size of the given type in char units.
Expr * getFalseExpr() const
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
FieldDecl * getField() const
For a field offsetof node, returns the field.
static bool TryEvaluateBuiltinNaN(const ASTContext &Context, QualType ResultTy, const Expr *Arg, bool SNaN, llvm::APFloat &Result)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
static bool EvaluateVector(const Expr *E, APValue &Result, EvalInfo &Info)
field_range fields() const
static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal)
Attempts to detect a user writing into a piece of memory that's impossible to figure out the size of ...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
bool isPowerOfTwo() const
isPowerOfTwo - Test whether the quantity is a power of two.
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
bool isReferenceType() const
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
unsigned getArraySize() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
unsigned getLValueCallIndex() const
static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E, const RecordDecl *RD, const LValue &This, APValue &Result)
Perform zero-initialization on an object of non-union class type.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
unsigned getCharByteWidth() const
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
static bool isRelationalOp(Opcode Opc)
static bool IsWeakLValue(const LValue &Value)
static ICEDiag CheckEvalInICE(const Expr *E, const ASTContext &Ctx)
Describes an C or C++ initializer list.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const
EvaluateAsBooleanCondition - Return true if this is a constant which we we can fold and convert to a ...
static const Expr * ignorePointerCastsAndParens(const Expr *E)
A more selective version of E->IgnoreParenCasts for tryEvaluateBuiltinObjectSize. ...
bool isBitField() const
Determines whether this field is a bitfield.
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
ForStmt - This represents a 'for (init;cond;inc)' stmt.
unsigned getLength() const
static bool isEqualityOp(Opcode Opc)
static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E, llvm::APInt &Res)
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isElidable() const
Whether this construction is elidable.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
static bool refersToCompleteObject(const LValue &LVal)
Tests to see if the LValue has a user-specified designator (that isn't necessarily valid)...
CharUnits - This is an opaque type for sizes expressed in character units.
APValue Val
Val - This is the value the expression can be folded to.
static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type, const LValue &LVal, APValue &RVal)
Perform an lvalue-to-rvalue conversion on the given glvalue.
static int EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts)
EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way as GCC.
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx, const FunctionDecl *Callee, ArrayRef< const Expr *> Args, const Expr *This=nullptr) const
EvaluateWithSubstitution - Evaluate an expression as if from the context of a call to the given funct...
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
ArrayRef< NamedDecl * > chain() const
path_iterator path_begin()
static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, LValue &Result)
HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on the provided lvalue...
static bool isRecordType(QualType T)
A builtin binary operation expression such as "x + y" or "x <= y".
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isComplexFloat() const
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
bool isComplexInt() const
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
void printPretty(raw_ostream &OS, ASTContext &Ctx, QualType Ty) const
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
ObjCStringLiteral, used for Objective-C string literals i.e.
static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, bool IsIncrement, APValue *Old)
Perform an increment or decrement on LVal.
Scope - A scope is a transient data structure that is used while parsing the program.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
field_iterator field_begin() const
unsigned getBitWidthValue(const ASTContext &Ctx) const
static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit, uint64_t Index)
Extract the value of a character from a string literal.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType)
Find the complete object to which an LValue refers.
base_class_iterator bases_begin()
Helper class for OffsetOfExpr.
static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E, LValue &LVal, QualType EltTy, bool Imag)
Update an lvalue to refer to a component of a complex number.
static void expandArray(APValue &Array, unsigned Index)
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const
isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C+...
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
bool isLambdaCallOperator(const CXXMethodDecl *MD)
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
APSInt & getComplexIntReal()
A binding in a decomposition declaration.
init_iterator init_begin()
Retrieve an iterator to the first initializer.
A default argument (C++ [dcl.fct.default]).
static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result)
Perform the given binary integer operation.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Represents the this expression in C++.
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
const Expr * getExpr() const
Get the initialization expression that will be used.
APValue & getVectorElt(unsigned I)
bool isLambdaStaticInvoker() const
Determine whether this is a lambda closure type's static member function that is used for the result ...
ConditionalOperator - The ?: ternary operator.
StringRef getString() const
static CharUnits One()
One - Construct a CharUnits quantity of one.
static bool handleCompoundAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, QualType PromotedLValType, BinaryOperatorKind Opcode, const APValue &RVal)
Perform a compound assignment of LVal <op>= RVal.
CompoundStmt - This represents a group of statements like { stmt stmt }.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info, const SwitchStmt *SS)
Evaluate a switch statement.
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
bool hasLValuePath() const
QualType getComputationLHSType() const
static unsigned FindDesignatorMismatch(QualType ObjType, const SubobjectDesignator &A, const SubobjectDesignator &B, bool &WasArrayIndex)
Find the position where two subobject designators diverge, or equivalently the length of the common i...
CastKind
CastKind - The kind of operation required for a conversion.
APValue & getArrayFiller()
Specifies that the expression should never be value-dependent.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
bool HasUndefinedBehavior
Whether the evaluation hit undefined behavior.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
CXXCtorInitializer *const * init_const_iterator
Iterates through the member/base initializer list.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
unsigned getValue() const
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool hasArrayFiller() const
capture_const_iterator captures_end() const
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
QualType getElementType() const
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Expr - This represents one expression.
bool isCopyOrMoveConstructor(unsigned &TypeQuals) const
Determine whether this is a copy or move constructor.
Allow any unmodeled side effect.
static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc, unsigned Type, const LValue &LVal, CharUnits &EndOffset)
Helper for tryEvaluateBuiltinObjectSize – Given an LValue, this will determine how many bytes exist ...
bool isDefaulted() const
Whether this function is defaulted per C++0x.
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
static bool HandleConversionToBool(const APValue &Val, bool &Result)
void EvaluateForOverflow(const ASTContext &Ctx) const
static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info)
Evaluate an expression of record type as a temporary.
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
const FunctionProtoType * T
static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result, const ASTContext &Ctx, bool &IsConst)
unsigned getPackLength() const
Retrieve the length of the parameter pack.
const T * castAs() const
Member-template castAs<specific type>.
static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, LValue &This)
Build an lvalue for the object argument of a member function call.
const Stmt * getThen() const
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
unsigned getNumInits() const
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Expr * getSubExpr() const
Get the initializer to use for each array element.
const Expr * getCallee() const
bool isNullPtrType() const
field_iterator field_end() const
QualType getArgumentType() const
DeclContext * getDeclContext()
uint32_t getCodeUnit(size_t i) const
AccessKinds
Kinds of access we can perform on an object, for diagnostics.
bool isAnyComplexType() const
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
TypeSourceInfo * getTypeSourceInfo() const
Represents an expression that computes the length of a parameter pack.
static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info, const Stmt *S, const SwitchCase *SC=nullptr)
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, EvalInfo &Info)
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
Defines the clang::TypeLoc interface and its subclasses.
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Kind getKind() const
Determine what kind of offsetof node this is.
static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl, const Expr *Cond, bool &Result)
Evaluate a condition (either a variable declaration or an expression).
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T)
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E, QualType T)
Diagnose an attempt to read from any unreadable field within the specified type, which might be a cla...
PartialDiagnostic::StorageAllocator & getDiagAllocator()
APValue & getStructField(unsigned i)
static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result, const RecordDecl *TruncatedType, unsigned TruncatedElements)
Cast an lvalue referring to a base subobject to a derived class, by truncating the lvalue's path to t...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
AccessKind
This enum distinguishes between different ways to access (read or write) a variable.
static bool IsStringLiteralCall(const CallExpr *E)
Should this call expression be treated as a string literal?
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Represents a GCC generic vector type.
bool isNullPointer() const
Represents a reference to a non-type template parameter that has been substituted with a template arg...
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
const OffsetOfNode & getComponent(unsigned Idx) const
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
APSInt & getComplexIntImag()
The result type of a method or function.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
const Expr * getSubExpr() const
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Stmt *const * const_body_iterator
static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E, const APSInt &LHS, const APSInt &RHS, unsigned BitWidth, Operation Op, APSInt &Result)
Perform the given integer operation, which is known to need at most BitWidth bits, and check for overflow in the original type (if that type was not an unsigned type).
const FieldDecl * getUnionField() const
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
DoStmt - This represents a 'do/while' stmt.
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
bool isVoidPointerType() const
bool isConstQualified() const
Determine whether this type is const-qualified.
static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, const FunctionDecl *Declaration, const FunctionDecl *Definition, const Stmt *Body)
CheckConstexprFunction - Check that a function can be called in a constant expression.
RecordDecl * getDecl() const
APValue & getStructBase(unsigned i)
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable's initializer, or NULL if the value is not yet kn...
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
static ICEDiag Worst(ICEDiag A, ICEDiag B)
APValue & getArrayInitializedElt(unsigned I)
A field in a dependent type, known only by its name.
QualType getCanonicalType() const
Represents a call to an inherited base class constructor from an inheriting constructor.
static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info)
unsigned path_size() const
const LValueBase getLValueBase() const
virtual bool isNan2008() const
Returns true if NaN encoding is IEEE 754-2008.
bool isGlobalLValue() const
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Encodes a location in the source.
LangAS getAddressSpace() const
Return the address space of this type.
static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type, const APValue &Value)
Check that this core constant expression value is a valid value for a constant expression.
Expr * getSubExpr() const
CastKind getCastKind() const
const SwitchCase * getSwitchCaseList() const
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
APValue & getUnionValue()
ASTContext & getASTContext() const LLVM_READONLY
static bool EvalPointerValueAsBool(const APValue &Value, bool &Result)
static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E, QualType DestType, QualType SrcType, const APSInt &Value)
QualType getElementType() const
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
static bool IsLiteralLValue(const LValue &Value)
Represents a static or instance method of a struct/union/class.
static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E, APFloat &LHS, BinaryOperatorKind Opcode, const APFloat &RHS)
Perform the given binary floating-point operation, in-place, on LHS.
static bool HandleFunctionCall(SourceLocation CallLoc, const FunctionDecl *Callee, const LValue *This, ArrayRef< const Expr *> Args, const Stmt *Body, EvalInfo &Info, APValue &Result, const LValue *ResultSlot)
Evaluate a function call.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isMemberPointer() const
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info, const Stmt *Body, const SwitchCase *Case=nullptr)
Evaluate the body of a loop, and translate the result as appropriate.
static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD)
static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E, APValue &Value, const FieldDecl *FD)
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
UnaryExprOrTypeTrait getKind() const
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
bool isMemberFunctionPointerType() const
static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal)
Checks to see if the given LValue's Designator is at the end of the LValue's record layout...
static const ValueDecl * GetLValueBaseDecl(const LValue &LVal)
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
TypeClass getTypeClass() const
static bool EvaluateRecord(const Expr *E, const LValue &This, APValue &Result, EvalInfo &Info)
static bool isLogicalOp(Opcode Opc)
An expression trait intrinsic.
static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, QualType DestType, APFloat &Result)
bool isVectorType() const
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E)
ObjCBoxedExpr - used for generalized expression boxing.
bool isArgumentType() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
bool isMemberPointerToDerivedMember() const
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
const Expr * getInitializer() const
CompoundAssignOperator - For compound assignments (e.g.
CXXConstructorDecl * getConstructor() const
Represents a C11 generic selection.
EvalStatus is a struct with detailed info about an evaluation in progress.
static bool HandleOverflow(EvalInfo &Info, const Expr *E, const T &SrcValue, QualType DestType)
AddrLabelExpr - The GNU address of label extension, representing &&label.
static bool EvaluateVoid(const Expr *E, EvalInfo &Info)
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base)
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Dataflow Directional Tag Classes.
static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, EvalInfo &Info)
static unsigned getBaseIndex(const CXXRecordDecl *Derived, const CXXRecordDecl *Base)
Get the base index of the given base class within an APValue representing the given derived class...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
[C99 6.4.2.2] - A predefined identifier such as func.
EvalResult is a struct with detailed info about an evaluated expression.
static bool isZeroSized(const LValue &Value)
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
void swap(APValue &RHS)
Swaps the contents of this and the given APValue.
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
AccessSpecifier getAccess() const
const Expr * getInit() const
A decomposition declaration.
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
StmtClass getStmtClass() const
static bool CheckLiteralType(EvalInfo &Info, const Expr *E, const LValue *This=nullptr)
Check that this core constant expression is of literal type, and if not, produce an appropriate diagn...
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
const Expr * getExpr() const
bool isBooleanType() const
unsigned getArrayInitializedElts() const
SourceLocation getLocStart() const LLVM_READONLY
A pointer to member type per C++ 8.3.3 - Pointers to members.
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base, LValue &Result)
Attempts to evaluate the given LValueBase as the result of a call to a function with the alloc_size a...
body_iterator body_begin()
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
bool isPtrMemOp() const
predicates to categorize the respective opcodes.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
const Stmt * getBody() const
llvm::APInt getValue() const
LabelDecl * getLabel() const
static bool CheckMemberPointerConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const APValue &Value)
Member pointers are constant expressions unless they point to a non-virtual dllimport member function...
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
SwitchStmt - This represents a 'switch' stmt.
bool isStringLiteralInit() const
unsigned getIntWidth(QualType T) const
bool isIncompleteArrayType() const
static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info, bool InvalidBaseOK=false)
bool HasSideEffects
Whether the evaluated expression has side effects.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Complex values, per C99 6.2.5p11.
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, const ASTRecordLayout *RL=nullptr)
bool checkInitIsICE() const
Determine whether the value of the initializer attached to this declaration is an integral constant e...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
static bool hasFields(const CXXRecordDecl *RD)
Determine if a class has any fields that might need to be copied by a trivial copy or move operation...
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
llvm::PointerUnion< const ValueDecl *, const Expr * > LValueBase
ObjCEncodeExpr, used for @encode in Objective-C.
static CharUnits GetAlignOfType(EvalInfo &Info, QualType T)
An implicit indirection through a C++ base class, when the field found is in a base class...
const llvm::APInt & getSize() const
static bool modifySubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, APValue &NewVal)
Update the designated sub-object of an rvalue to the given value.
bool isAtomicType() const
static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E, QualType SrcType, const APSInt &Value, QualType DestType, APFloat &Result)
bool isFunctionType() const
Expr * getReplacement() const
static bool isAdditiveOp(Opcode Opc)
Expr * getArg(unsigned Arg)
Return the specified argument.
Base for LValueReferenceType and RValueReferenceType.
static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info)
ActionResult< Stmt * > StmtResult
static bool EvaluateArray(const Expr *E, const LValue &This, APValue &Result, EvalInfo &Info)
static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E, QualType Type, LValue &Result)
SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler)
Find the designated sub-object of an rvalue.
static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj, const CXXRecordDecl *DerivedDecl, const CXXBaseSpecifier *Base)
SourceLocation getExprLoc() const LLVM_READONLY
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Represents a base class of a C++ class.
static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal, const FieldDecl *FD, const ASTRecordLayout *RL=nullptr)
Update LVal to refer to the given field, which must be a member of the type currently described by LV...
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
DeclStmt * getRangeStmt()
static bool isIncrementOp(Opcode Op)
unsigned getConstexprBacktraceLimit() const
Retrieve the maximum number of constexpr evaluation notes to emit along with a given diagnostic...
static bool EvaluateArgs(ArrayRef< const Expr *> Args, ArgVector &ArgValues, EvalInfo &Info)
EvaluateArgs - Evaluate the arguments to a function call.
A use of a default initializer in a constructor or in aggregate initialization.
A template argument list.
const SwitchCase * getNextSwitchCase() const
bool hasMutableFields() const
Determine whether this class, or any of its class subobjects, contains a mutable field.
static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E, LValue &LVal, const IndirectFieldDecl *IFD)
Update LVal to refer to the given indirect field.
ValueKind getKind() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
static bool EvaluateBuiltinConstantPForLValue(const LValue &LV)
EvaluateBuiltinConstantPForLValue - Determine the result of __builtin_constant_p when applied to the ...
bool hasUnaligned() const
APFloat & getComplexFloatImag()
Represents a C++ struct/union/class.
static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info)
Expr * getTrueExpr() const
Represents a loop initializing the elements of an array.
static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type, EvalInfo &Info, uint64_t &Size)
Tries to evaluate the __builtin_object_size for E.
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
static bool isReadByLvalueToRvalueConversion(QualType T)
Determine whether a type would actually be read by an lvalue-to-rvalue conversion.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx, const Expr *E, llvm::APSInt *Value, SourceLocation *Loc)
Evaluate an expression as a C++11 integral constant expression.
WhileStmt - This represents a 'while' stmt.
static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E, LValue &LVal, QualType EltTy, APSInt Adjustment)
Update a pointer value to model pointer arithmetic.
base_class_iterator bases_end()
llvm::PointerIntPair< const Decl *, 1, bool > BaseOrMemberType
unsigned kind
All of the diagnostics that can be emitted by the frontend.
This class is used for builtin types like 'int'.
static ICEDiag CheckICE(const Expr *E, const ASTContext &Ctx)
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
StringLiteral - This represents a string literal expression, e.g.
Defines the clang::TargetInfo interface.
bool isComplexIntegerType() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg)
EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to GCC as we can manage...
unsigned getNumElements() const
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
unsigned getNumComponents() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
A reference to a declared variable, function, enum, etc.
Designator - A designator in a C99 designated initializer.
bool isPointerType() const
static bool AreElementsOfSameArray(QualType ObjType, const SubobjectDesignator &A, const SubobjectDesignator &B)
Determine whether the given subobject designators refer to elements of the same array object...
static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info, bool InvalidBaseOK=false)
Evaluate an expression as an lvalue.
static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, APValue *&Result)
Try to evaluate the initializer for a variable declaration.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static void expandStringLiteral(EvalInfo &Info, const Expr *Lit, APValue &Result)
capture_const_iterator captures_begin() const
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
bool isLocalVarDecl() const
isLocalVarDecl - Returns true for local variable declarations other than parameters.
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluted - Return true if this expression might be usable in a constant expr...
DeclStmt * getLoopVarStmt()
unsigned getNumArgs() const
bool isFloatingType() const
const Expr * getCond() const
static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E, QualType SrcType, const APFloat &Value, QualType DestType, APSInt &Result)
A boolean literal, per ([C++ lex.bool] Boolean literals).
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Automatic storage duration (most local variables).
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr...
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
DeclStmt * getBeginStmt()
const Expr * getCond() const
bool isFunctionPointerType() const
SourceLocation getLocStart() const LLVM_READONLY
static bool isComparisonOp(Opcode Opc)
const LangOptions & getLangOpts() const
Represents the canonical version of C arrays with a specified constant size.
static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, QualType LValType, APValue &Val)
Perform an assignment of Val to LVal. Takes ownership of Val.
Defines enum values for all the target-independent builtin functions.
Declaration of a template function.
Represents an implicitly-generated value initialization of an object of a given type.
static void describeCall(CallStackFrame *Frame, raw_ostream &Out)
Produce a string describing the given constexpr call.
SourceLocation getLocation() const
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result=nullptr, SourceLocation *Loc=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
QualType getType() const
Return the type wrapped by this type source info.
static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc, const CXXConstructorDecl *CD, bool IsValueInitialization)
CheckTrivialDefaultConstructor - Check whether a constructor is a trivial default constructor...
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
CharUnits & getLValueOffset()
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result)
EvaluateAsRValue - Try to evaluate this expression, performing an implicit lvalue-to-rvalue cast if i...
QualType getType() const
Retrieves the type of the base class.
unsigned getVectorLength() const