Lines Matching defs:Info
221 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
261 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E, uint64_t N);
263 void adjustIndex(EvalInfo &Info, const Expr *E, uint64_t N) {
268 diagnosePointerArithmetic(Info, E, Entries.back().ArrayIndex);
281 diagnosePointerArithmetic(Info, E, uint64_t(IsOnePastTheEnd) + N);
289 EvalInfo &Info;
317 CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
713 EvalInfo &Info;
718 explicit FoldConstant(EvalInfo &Info, bool Enabled)
719 : Info(Info),
721 HadNoPriorDiags(Info.EvalStatus.Diag &&
722 Info.EvalStatus.Diag->empty() &&
723 !Info.EvalStatus.HasSideEffects),
724 OldMode(Info.EvalMode) {
726 (Info.EvalMode == EvalInfo::EM_ConstantExpression ||
727 Info.EvalMode == EvalInfo::EM_ConstantExpressionUnevaluated))
728 Info.EvalMode = EvalInfo::EM_ConstantFold;
732 if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
733 !Info.EvalStatus.HasSideEffects)
734 Info.EvalStatus.Diag->clear();
735 Info.EvalMode = OldMode;
742 EvalInfo &Info;
746 SpeculativeEvaluationRAII(EvalInfo &Info,
748 : Info(Info), Old(Info.EvalStatus) {
749 Info.EvalStatus.Diag = NewDiag;
752 Info.EvalStatus.HasSideEffects = true;
755 Info.EvalStatus = Old;
763 EvalInfo &Info;
766 ScopeRAII(EvalInfo &Info)
767 : Info(Info), OldStackSize(Info.CleanupStack.size()) {}
771 cleanup(Info, OldStackSize);
774 static void cleanup(EvalInfo &Info, unsigned OldStackSize) {
776 for (unsigned I = OldStackSize, N = Info.CleanupStack.size();
778 if (IsFullExpression && Info.CleanupStack[I].isLifetimeExtended()) {
781 std::swap(Info.CleanupStack[I], Info.CleanupStack[NewEnd]);
785 Info.CleanupStack[I].endLifetime();
788 Info.CleanupStack.erase(Info.CleanupStack.begin() + NewEnd,
789 Info.CleanupStack.end());
796 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
801 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
809 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
812 Info.CCEDiag(E, diag::note_constexpr_array_index)
816 Info.CCEDiag(E, diag::note_constexpr_array_index)
821 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
824 : Info(Info), Caller(Info.CurrentCall), CallLoc(CallLoc), Callee(Callee),
825 Index(Info.NextCallIndex++), This(This), Arguments(Arguments) {
826 Info.CurrentCall = this;
827 ++Info.CallStackDepth;
831 assert(Info.CurrentCall == this && "calls retired out of order");
832 --Info.CallStackDepth;
833 Info.CurrentCall = Caller;
840 Info.CleanupStack.push_back(Cleanup(&Result, IsLifetimeExtended));
954 bool checkNullPointer(EvalInfo &Info, const Expr *E,
959 Info.CCEDiag(E, diag::note_constexpr_null_subobject)
969 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
972 if (!Info.getLangOpts().CPlusPlus11)
974 return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
975 Designator.checkSubobject(Info, E, CSK);
978 void addDecl(EvalInfo &Info, const Expr *E,
980 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
983 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
984 if (checkSubobject(Info, E, CSK_ArrayToPointer))
987 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
988 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
991 void adjustIndex(EvalInfo &Info, const Expr *E, uint64_t N) {
992 if (N && checkNullPointer(Info, E, CSK_ArrayIndex))
993 Designator.adjustIndex(Info, E, N);
1096 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
1097 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
1100 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info);
1101 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info);
1103 EvalInfo &Info);
1104 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
1105 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
1107 EvalInfo &Info);
1108 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1109 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
1110 static bool EvaluateAtomic(const Expr *E, APValue &Result, EvalInfo &Info);
1129 Val.printPretty(Out, Frame->Info.Ctx,
1143 Arg.printPretty(Out, Frame->Info.Ctx, Param->getType());
1155 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
1157 if (!Evaluate(Scratch, Info, E))
1159 return Info.noteSideEffect();
1233 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
1237 Info.Note(VD->getLocation(), diag::note_declared_at);
1239 Info.Note(Base.get<const Expr*>()->getExprLoc(),
1246 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
1257 if (Info.getLangOpts().CPlusPlus11) {
1259 Info.Diag(Loc, diag::note_constexpr_non_global, 1)
1262 NoteLValueLocation(Info, Base);
1264 Info.Diag(Loc);
1269 assert((Info.checkingPotentialConstantExpression() ||
1294 if (Info.getLangOpts().CPlusPlus && FD->hasAttr<DLLImportAttr>())
1307 Info.CCEDiag(Loc);
1314 Info.Diag(Loc, diag::note_constexpr_past_end, 1)
1316 NoteLValueLocation(Info, Base);
1324 static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
1326 if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx))
1332 if (Info.getLangOpts().CPlusPlus14 && This &&
1333 Info.EvaluatingDecl == This->getLValueBase())
1337 if (Info.getLangOpts().CPlusPlus11)
1338 Info.Diag(E, diag::note_constexpr_nonliteral)
1341 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1348 static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
1351 Info.Diag(DiagLoc, diag::note_constexpr_uninitialized)
1367 if (!CheckConstantExpression(Info, DiagLoc, EltTy,
1373 return CheckConstantExpression(Info, DiagLoc, EltTy,
1377 return CheckConstantExpression(Info, DiagLoc,
1387 if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1393 if (!CheckConstantExpression(Info, DiagLoc, I->getType(),
1401 LVal.setFrom(Info.Ctx, Value);
1402 return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal);
1486 EvalInfo &Info) {
1489 if (!Evaluate(Val, Info, E))
1495 static void HandleOverflow(EvalInfo &Info, const Expr *E,
1497 Info.CCEDiag(E, diag::note_constexpr_overflow)
1501 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
1504 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1512 HandleOverflow(Info, E, Value, DestType);
1516 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
1521 if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
1524 HandleOverflow(Info, E, Value, DestType);
1528 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
1531 unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
1540 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
1543 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
1547 HandleOverflow(Info, E, Value, DestType);
1551 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
1560 Info.Diag(E);
1566 unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx);
1572 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
1575 if (!Evaluate(SVal, Info, E))
1587 unsigned VecSize = Info.Ctx.getTypeSize(VecTy);
1589 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
1590 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
1602 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1615 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1623 static APSInt CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
1632 if (Info.checkingForOverflow())
1633 Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
1637 HandleOverflow(Info, E, Value, E->getType());
1643 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
1648 Info.Diag(E);
1651 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2,
1655 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
1659 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
1668 Info.Diag(E, diag::note_expr_divide_by_zero);
1674 HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1), E->getType());
1678 if (Info.getLangOpts().OpenCL)
1686 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
1695 Info.CCEDiag(E, diag::note_constexpr_large_shift)
1701 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;
1703 Info.CCEDiag(E, diag::note_constexpr_lshift_discards);
1709 if (Info.getLangOpts().OpenCL)
1717 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;
1726 Info.CCEDiag(E, diag::note_constexpr_large_shift)
1742 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E,
1747 Info.Diag(E);
1764 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();
1770 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
1780 if (!Result.checkSubobject(Info, E, CSK_Derived))
1787 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
1799 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
1805 RL = &Info.Ctx.getASTRecordLayout(Derived);
1809 Obj.addDecl(Info, E, Base, /*Virtual*/ false);
1813 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
1819 return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
1827 if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength))
1832 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
1834 Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
1838 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
1843 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
1853 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
1858 RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
1862 LVal.Offset += Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I));
1863 LVal.addDecl(Info, E, FD);
1868 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
1872 if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
1878 static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
1890 Info.Diag(Loc);
1894 Size = Info.Ctx.getTypeSizeInChars(Type);
1899 /// \param Info - Information about the ongoing evaluation.
1904 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
1908 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee))
1913 LVal.adjustIndex(Info, E, Adjustment);
1918 /// \param Info - Information about the ongoing evaluation.
1922 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
1927 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent))
1931 LVal.addComplex(Info, E, EltTy, Imag);
1937 /// \param Info Information about the ongoing evaluation.
1943 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
1951 if (Info.checkingPotentialConstantExpression())
1954 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1973 if (!Info.checkingPotentialConstantExpression())
1974 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1980 if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) {
1981 Result = Info.EvaluatingDeclValue;
1988 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
1996 Info.Diag(E, diag::note_constexpr_var_init_non_constant,
1998 Info.Note(VD->getLocation(), diag::note_declared_at);
1999 Info.addNotes(Notes);
2002 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant,
2004 Info.Note(VD->getLocation(), diag::note_declared_at);
2005 Info.addNotes(Notes);
2033 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
2040 Info.Ctx.getAsConstantArrayType(S->getType());
2045 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2053 static void expandStringLiteral(EvalInfo &Info, const Expr *Lit,
2057 Info.Ctx.getAsConstantArrayType(S->getType());
2065 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
2121 static bool diagnoseUnreadableFields(EvalInfo &Info, const Expr *E,
2137 Info.Diag(E, diag::note_constexpr_ltor_mutable, 1) << Field;
2138 Info.Note(Field->getLocation(), diag::note_declared_at);
2142 if (diagnoseUnreadableFields(Info, E, Field->getType()))
2147 if (diagnoseUnreadableFields(Info, E, BaseSpec.getType()))
2182 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
2188 if (Info.getLangOpts().CPlusPlus11)
2189 Info.Diag(E, diag::note_constexpr_access_past_end)
2192 Info.Diag(E);
2203 if (!Info.checkingPotentialConstantExpression())
2204 Info.Diag(E, diag::note_constexpr_access_uninit) << handler.AccessKind;
2214 diagnoseUnreadableFields(Info, E, ObjType))
2223 !truncateBitfieldValue(Info, E, *O, LastField))
2232 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
2238 if (Info.getLangOpts().CPlusPlus11)
2239 Info.Diag(E, diag::note_constexpr_access_past_end)
2242 Info.Diag(E);
2254 expandStringLiteral(Info, O->getLValueBase().get<const Expr *>(),
2271 if (Info.getLangOpts().CPlusPlus11)
2272 Info.Diag(E, diag::note_constexpr_access_past_end)
2275 Info.Diag(E);
2295 Info.Diag(E, diag::note_constexpr_ltor_mutable, 1)
2297 Info.Note(Field->getLocation(), diag::note_declared_at);
2307 Info.Diag(E, diag::note_constexpr_access_inactive_union_member)
2321 if (Info.getLangOpts().CPlusPlus) {
2323 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1)
2325 Info.Note(Field->getLocation(), diag::note_declared_at);
2327 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
2340 ObjType = Info.Ctx.getRecordType(Base);
2349 EvalInfo &Info;
2370 Info, Subobj.getLValueBase().get<const Expr *>(), Character));
2379 static bool extractSubobject(EvalInfo &Info, const Expr *E,
2383 ExtractSubobjectHandler Handler = { Info, Result };
2384 return findSubobject(Info, E, Obj, Sub, Handler);
2389 EvalInfo &Info;
2399 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT;
2418 Info.Diag(E);
2439 static bool modifySubobject(EvalInfo &Info, const Expr *E,
2443 ModifySubobjectHandler Handler = { Info, NewVal, E };
2444 return findSubobject(Info, E, Obj, Sub, Handler);
2505 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
2509 Info.Diag(E, diag::note_constexpr_access_null) << AK;
2515 Frame = Info.getCallFrame(LVal.CallIndex);
2517 Info.Diag(E, diag::note_constexpr_lifetime_ended, 1)
2519 NoteLValueLocation(Info, LVal.Base);
2529 if (Info.getLangOpts().CPlusPlus)
2530 Info.Diag(E, diag::note_constexpr_access_volatile_type)
2533 Info.Diag(E);
2551 if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
2555 Info.Diag(E);
2561 if (Info.getLangOpts().CPlusPlus) {
2562 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1)
2564 Info.Note(VD->getLocation(), diag::note_declared_at);
2566 Info.Diag(E);
2574 if (Info.getLangOpts().CPlusPlus14 &&
2575 VD == Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()) {
2581 Info.Diag(E, diag::note_constexpr_modify_global);
2587 if (Info.getLangOpts().CPlusPlus) {
2588 Info.Diag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;
2589 Info.Note(VD->getLocation(), diag::note_declared_at);
2591 Info.Diag(E);
2599 if (Info.getLangOpts().CPlusPlus11) {
2600 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
2601 Info.Note(VD->getLocation(), diag::note_declared_at);
2603 Info.CCEDiag(E);
2607 if (Info.getLangOpts().CPlusPlus11) {
2608 Info.Diag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD;
2609 Info.Note(VD->getLocation(), diag::note_declared_at);
2611 Info.Diag(E);
2617 if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal))
2642 const ValueDecl *VD = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>();
2647 Info.Diag(E, diag::note_constexpr_access_static_temporary, 1) << AK;
2648 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here);
2652 BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE, false);
2655 Info.Diag(E);
2665 if (Info.getLangOpts().CPlusPlus) {
2666 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1)
2668 Info.Note(Base->getExprLoc(), diag::note_constexpr_temporary_here);
2670 Info.Diag(E);
2680 if (LVal.getLValueBase() == Info.EvaluatingDecl) {
2681 BaseType = Info.Ctx.getCanonicalType(BaseType);
2690 if (Frame && Info.getLangOpts().CPlusPlus14 &&
2691 (Info.EvalStatus.HasSideEffects || Info.keepEvaluatingAfterFailure()))
2701 /// \param Info - Information about the ongoing evaluation.
2708 static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv,
2722 assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?");
2724 Info.Diag(Conv);
2728 if (!Evaluate(Lit, Info, CLE->getInitializer()))
2731 return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal);
2738 return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal);
2742 CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type);
2743 return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal);
2747 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
2752 if (!Info.getLangOpts().CPlusPlus14) {
2753 Info.Diag(E);
2757 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
2758 return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
2768 EvalInfo &Info;
2781 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT;
2797 Info.Diag(E);
2803 Info.Diag(E);
2814 Info.Diag(E);
2818 APSInt LHS = HandleIntToIntCast(Info, E, PromotedLHSType,
2820 if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS))
2822 Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
2827 HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType,
2829 handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) &&
2830 HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value);
2842 Info.Diag(E);
2851 LVal.setFrom(Info.Ctx, Subobj);
2852 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset))
2867 EvalInfo &Info, const Expr *E,
2873 if (!Info.getLangOpts().CPlusPlus14) {
2874 Info.Diag(E);
2878 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
2879 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
2881 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
2886 EvalInfo &Info;
2896 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT;
2928 Info.Diag(E);
2939 Info.Diag(E);
2960 isOverflowingIntegerType(Info.Ctx, SubobjType)) {
2962 HandleOverflow(Info, E, ActualValue, SubobjType);
2968 isOverflowingIntegerType(Info.Ctx, SubobjType)) {
2972 HandleOverflow(Info, E, ActualValue, SubobjType);
2998 Info.Diag(E);
3003 LVal.setFrom(Info.Ctx, Subobj);
3004 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType,
3017 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
3022 if (!Info.getLangOpts().CPlusPlus14) {
3023 Info.Diag(E);
3028 CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
3029 IncDecSubobjectHandler Handler = { Info, E, AK, Old };
3030 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
3034 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
3037 return EvaluatePointer(Object, This, Info);
3040 return EvaluateLValue(Object, This, Info);
3042 if (Object->getType()->isLiteralType(Info.Ctx))
3043 return EvaluateTemporary(Object, This, Info);
3045 Info.Diag(Object, diag::note_constexpr_nonliteral) << Object->getType();
3052 /// \param Info - Information about the ongoing evaluation.
3060 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3066 if (!EvaluateMemberPointer(RHS, MemPtr, Info))
3073 Info.Diag(RHS);
3083 Info.Diag(RHS);
3093 Info.Diag(RHS);
3099 if (!CastToDerivedClass(Info
3115 if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
3120 if (!HandleLValueDirectBase(Info, RHS, LV, RD,
3128 if (!HandleLValueMember(Info, RHS, LV, FD))
3132 if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
3142 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
3148 if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) {
3149 if (Info.keepEvaluatingAfterFailure()) {
3151 EvaluateMemberPointer(BO->getRHS(), MemPtr, Info);
3156 return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV,
3162 static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
3165 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
3174 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3189 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
3195 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
3215 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
3222 Result.set(VD, Info.CurrentCall->Index);
3223 APValue &Val = Info.CurrentCall->createTemporary(VD, true);
3227 Info.Diag(D->getLocStart(), diag::note_constexpr_uninitialized)
3236 if (!EvaluateInPlace(Val, Info, Result, InitE)) {
3248 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
3250 FullExpressionRAII Scope(Info);
3251 if (CondDecl && !EvaluateDecl(Info, CondDecl))
3253 return EvaluateAsBooleanCondition(Cond, Result, Info);
3256 static EvalStmtResult EvaluateStmt(APValue &Result, EvalInfo &Info,
3261 static EvalStmtResult EvaluateLoopBody(APValue &Result, EvalInfo &Info,
3264 BlockScopeRAII Scope(Info);
3265 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case)) {
3280 static EvalStmtResult EvaluateSwitch(APValue &Result, EvalInfo &Info,
3282 BlockScopeRAII Scope(Info);
3287 FullExpressionRAII Scope(Info);
3289 !EvaluateDecl(Info, SS->getConditionVariable()))
3291 if (!EvaluateInteger(SS->getCond(), Value, Info))
3306 APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
3307 APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
3319 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found)) {
3330 Info.Diag(Found->getLocStart(), diag::note_constexpr_stmt_expr_unsupported);
3337 static EvalStmtResult EvaluateStmt(APValue &Result, EvalInfo &Info,
3339 if (!Info.nextStep(S))
3372 BlockScopeRAII Scope(Info);
3374 EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case);
3377 return EvaluateStmt(Result, Info, IS->getElse(), Case);
3382 EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case);
3391 EvaluateLoopBody(Result, Info, FS->getBody(), Case);
3395 FullExpressionRAII IncScope(Info);
3396 if (!EvaluateIgnoredValue(Info, FS->getInc()))
3415 FullExpressionRAII Scope(Info);
3416 if (!EvaluateIgnoredValue(Info, E))
3421 Info.Diag(S->getLocStart());
3433 FullExpressionRAII Scope(Info);
3434 if (!EvaluateDecl(Info, DclIt) && !Info.keepEvaluatingAfterFailure())
3442 FullExpressionRAII Scope(Info);
3443 if (RetExpr && !Evaluate(Result, Info, RetExpr))
3449 BlockScopeRAII Scope(Info);
3453 EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
3466 BlockScopeRAII Scope(Info);
3468 if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
3472 EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
3482 BlockScopeRAII Scope(Info);
3484 if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(),
3490 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody());
3501 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
3506 FullExpressionRAII CondScope(Info);
3507 if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info))
3515 BlockScopeRAII Scope(Info);
3517 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
3522 BlockScopeRAII Scope(Info);
3524 if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(),
3530 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody());
3535 FullExpressionRAII IncScope(Info);
3536 if (!EvaluateIgnoredValue(Info, FS->getInc()))
3545 BlockScopeRAII Scope(Info);
3548 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt());
3553 ESR = EvaluateStmt(Result, Info, FS->getBeginEndStmt());
3561 FullExpressionRAII CondExpr(Info);
3562 if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info))
3569 BlockScopeRAII InnerScope(Info);
3570 ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt());
3575 ESR = EvaluateLoopBody(Result, Info, FS->getBody());
3580 if (!EvaluateIgnoredValue(Info, FS->getInc()))
3588 return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S));
3597 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case);
3602 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
3607 Info, cast<SwitchCase>(S)->getSubStmt(), Case);
3615 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
3625 if (Info.getLangOpts().CPlusPlus11) {
3628 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
3630 Info.Note(CD->getLocation(), diag::note_declared_at);
3632 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
3640 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
3645 if (Info.checkingPotentialConstantExpression() && !Definition &&
3658 if (Info.getLangOpts().CPlusPlus11) {
3662 Info.Diag(CallLoc, diag::note_constexpr_invalid_function, 1)
3665 Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
3667 Info.Diag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
3694 EvalInfo &Info) {
3698 if (!Evaluate(ArgValues[I - Args.begin()], Info, *I)) {
3701 if (!Info.keepEvaluatingAfterFailure())
3713 EvalInfo &Info, APValue &Result) {
3715 if (!EvaluateArgs(Args, ArgValues, Info))
3718 if (!Info.CheckCallLimit(CallLoc))
3721 CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
3735 RHS.setFrom(Info.Ctx, ArgValues[0]);
3737 if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(),
3740 if (!handleAssignment(Info, Args[0], *This, MD->getThisType(Info.Ctx),
3747 EvalStmtResult ESR = EvaluateStmt(Result, Info, Body);
3751 Info.Diag(Callee->getLocEnd(), diag::note_constexpr_no_return);
3760 EvalInfo &Info, APValue &Result) {
3762 if (!EvaluateArgs(Args, ArgValues, Info))
3765 if (!Info.CheckCallLimit(CallLoc))
3770 Info.Diag(CallLoc, diag::note_constexpr_virtual_base) << RD;
3774 CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues.data());
3780 FullExpressionRAII InitScope(Info);
3781 if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()))
3784 return EvaluateStmt(Result, Info, Definition->getBody()) != ESR_Failed;
3801 RHS.setFrom(Info.Ctx, ArgValues[0]);
3802 return handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(),
3812 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
3815 BlockScopeRAII LifetimeExtendedScope(Info);
3834 assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
3838 if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
3843 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout))
3870 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD))
3881 FullExpressionRAII InitScope(Info);
3882 if (!EvaluateInPlace(*Value, Info, Subobject, I->getInit()) ||
3883 (FD && FD->isBitField() && !truncateBitfieldValue(Info, I->getInit(),
3887 if (!Info.keepEvaluatingAfterFailure())
3894 EvaluateStmt(Result, Info, Definition->getBody()) != ESR_Failed;
3918 assert(Info.checkingPotentialConstantExpression());
3923 SpeculativeEvaluationRAII Speculate(Info, &Diag);
3942 if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
3943 if (Info.checkingPotentialConstantExpression())
3953 EvalInfo &Info;
3958 return Info.CCEDiag(E, D);
3964 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
3966 EvalInfo &getEvalInfo() { return Info; }
3971 Info.Diag(E, D);
4031 if (!HandleMemberPointerAccess(Info, E, Obj))
4034 if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
4044 if (!Evaluate(Info.CurrentCall->createTemporary(E->getOpaqueValue(), false),
4045 Info, E->getCommon()))
4064 if (Info.checkingPotentialConstantExpression() && IsBcpCall)
4067 FoldConstant Fold(Info, IsBcpCall);
4077 if (APValue *Value = Info.CurrentCall->getTemporary(E))
4104 if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
4111 Member = HandleMemberPointerAccess(Info, BE, ThisVal, false);
4122 if (!EvaluatePointer(Callee, Call, Info))
4142 if (!EvaluateObjectArgument(Info, Args[0], ThisVal))
4149 if (!Info.Ctx.hasSameType(CalleeType->getPointeeType(), FD->getType()))
4154 if (This && !This->checkSubobject(Info, E, CSK_This))
4167 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition) ||
4169 Info, Result))
4200 if (!Evaluate(Val, Info, E->getBase()))
4216 return extractSubobject(Info, E, Obj, Designator, Result) &&
4227 if (!EvaluateAtomic(E->getSubExpr(), AtomicVal, Info))
4238 if (!EvaluateLValue(E->getSubExpr(), LVal, Info))
4242 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(),
4259 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4263 if (!EvaluateLValue(UO->getSubExpr(), LVal, Info))
4266 if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(),
4275 if (Info.checkingForOverflow())
4278 BlockScopeRAII Scope(Info);
4286 Info.Diag((*BI)->getLocStart(),
4294 EvalStmtResult ESR = EvaluateStmt(ReturnValue, Info, *BI);
4300 Info.Diag((*BI)->getLocStart(),
4309 EvaluateIgnoredValue(Info, E);
4333 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result) :
4334 ExprEvaluatorBaseTy(Info), Result(Result) {}
4337 Result.setFrom(this->Info.Ctx, V);
4345 if (!EvaluatePointer(E->getBase(), Result, this->Info))
4350 if (!EvaluateTemporary(E->getBase(), Result, this->Info))
4364 if (!HandleLValueMember(this->Info, E, Result, FD))
4367 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
4374 if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
4389 return HandleMemberPointerAccess(this->Info, E, Result);
4405 return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(),
4447 LValueExprEvaluator(EvalInfo &Info, LValue &Result) :
4448 LValueExprEvaluatorBaseTy(Info, Result) {}
4490 return HandleBaseToDerivedCast(Info, E, Result);
4500 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info) {
4503 return LValueExprEvaluator(Info, Result).Visit(E);
4516 if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1)
4517 Frame = Info.CurrentCall;
4528 if (!evaluateVarDeclInit(Info, E, VD, Frame, V))
4531 if (!Info.checkingPotentialConstantExpression())
4532 Info.Diag(E, diag::note_constexpr_use_uninit_reference);
4548 if (!EvaluateIgnoredValue(Info, CommaLHSs[I]))
4556 Value = Info.Ctx.getMaterializedTemporaryValue(E, true);
4560 Value = &Info.CurrentCall->
4562 Result.set(E, Info.CurrentCall->Index);
4568 if (!EvaluateInPlace(*Value, Info, Result, Inner) ||
4570 !CheckConstantExpression(Info, E->getExprLoc(), Type, *Value))) {
4580 if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath,
4587 if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field))
4593 if (!HandleMemberPointerAccess(this->Info, Type, Result,
4606 assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?");
4616 Info.Diag(E, diag::note_constexpr_typeid_polymorphic)
4650 if (!EvaluatePointer(E->getBase(), Result, Info))
4654 if (!EvaluateInteger(E->getIdx(), Index, Info))
4657 return HandleLValueArrayAdjustment(Info, E, Result, E->getType(),
4662 return EvaluatePointer(E->getSubExpr(), Result, Info);
4670 HandleLValueComplexElement(Info, E, Result, E->getType(), false);
4679 HandleLValueComplexElement(Info, E, Result, E->getType(), true);
4684 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4691 this->Info, UO, Result, UO->getSubExpr()->getType(),
4697 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4704 if (Info.keepEvaluatingAfterFailure())
4705 Evaluate(RHS, this->Info, CAO->getRHS());
4709 if (!Evaluate(RHS, this->Info, CAO->getRHS()))
4713 this->Info, CAO,
4719 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
4725 if (Info.keepEvaluatingAfterFailure())
4726 Evaluate(NewVal, this->Info, E->getRHS());
4730 if (!Evaluate(NewVal, this->Info, E->getRHS()))
4733 return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),
4752 PointerExprEvaluator(EvalInfo &info, LValue &Result)
4753 : ExprEvaluatorBaseTy(info), Result(Result) {}
4756 Result.setFrom(Info.Ctx, V);
4780 if (Info.checkingPotentialConstantExpression())
4782 if (!Info.CurrentCall->This) {
4783 if (Info.getLangOpts().CPlusPlus11)
4784 Info.Diag(E, diag::note_constexpr_this) << E->isImplicit();
4786 Info.Diag(E);
4789 Result = *Info.CurrentCall->This;
4797 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info) {
4799 return PointerExprEvaluator(Info, Result).Visit(E);
4812 bool EvalPtrOK = EvaluatePointer(PExp, Result, Info);
4813 if (!EvalPtrOK && !Info.keepEvaluatingAfterFailure())
4817 if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK)
4825 return HandleLValueArrayAdjustment(Info, E, Result, Pointee,
4830 return EvaluateLValue(E->getSubExpr(), Result, Info);
4862 if (!EvaluatePointer(E->getSubExpr(), Result, Info))
4869 return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
4878 return HandleBaseToDerivedCast(Info, E, Result);
4888 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info))
4892 unsigned Size = Info.Ctx.getTypeSize(E->getType());
4901 Result.setFrom(Info.Ctx, Value);
4907 if (!EvaluateLValue(SubExpr, Result, Info))
4910 Result.set(SubExpr, Info.CurrentCall->Index);
4911 if (!EvaluateInPlace(Info.CurrentCall->createTemporary(SubExpr, false),
4912 Info, Result, SubExpr))
4917 = Info.Ctx.getAsConstantArrayType(SubExpr->getType()))
4918 Result.addArray(Info, E, CAT);
4924 return EvaluateLValue(SubExpr, Result, Info);
4930 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T) {
4938 return Info.Ctx.toCharUnitsFromBits(
4939 Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
4942 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E) {
4952 return Info.Ctx.getDeclAlign(DRE->getDecl(),
4956 return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
4959 return GetAlignOfType(Info, E->getType());
4968 return EvaluateLValue(E->getArg(0), Result, Info);
4973 if (!EvaluatePointer(E->getArg(0), Result, Info))
4978 if (!EvaluateInteger(E->getArg(1), Alignment, Info))
4984 if (!EvaluateInteger(E->getArg(2), Offset, Info))
4996 BaseAlignment = Info.Ctx.getDeclAlign(VD);
4999 GetAlignOfExpr(Info, OffsetResult.Base.get<const Expr*>());
5054 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
5055 : ExprEvaluatorBaseTy(Info), Result(Result) {}
5071 EvalInfo &Info) {
5073 return MemberPointerExprEvaluator(Info, Result).Visit(E);
5138 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
5139 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
5161 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
5170 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
5178 if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
5180 if (!HandleClassZeroInitialization(Info, E, Base, Subobject,
5192 if (!HandleLValueMember(Info, E, Subobject, I, &Layout))
5197 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
5217 if (!HandleLValueMember(Info, E, Subobject, *I))
5221 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
5225 Info.Diag(E, diag::note_constexpr_virtual_base) << RD;
5229 return HandleClassZeroInitialization(Info, E, RD, This, Result);
5243 if (!Evaluate(DerivedObject, Info, E->getSubExpr()))
5267 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
5284 if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
5288 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
5291 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
5312 if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E,
5318 ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
5322 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
5326 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
5327 (Field->isBitField() && !truncateBitfieldValue(Info, Init,
5329 if (!Info.keepEvaluatingAfterFailure())
5343 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
5362 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition))
5376 cast<CXXConstructorDecl>(Definition), Info,
5383 Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
5386 if (!EvaluateLValue(E->getSubExpr(), Array, Info))
5390 Array.addArray(Info, E, ArrayType);
5400 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
5412 Info.Ctx.hasSameType(Field->getType()->getPointeeType(),
5415 if (!HandleLValueArrayAdjustment(Info, E, Array,
5420 } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType()))
5433 APValue &Result, EvalInfo &Info) {
5436 return RecordExprEvaluator(Info, This, Result).Visit(E);
5450 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
5451 LValueExprEvaluatorBaseTy(Info, Result) {}
5455 Result.set(E, Info.CurrentCall->Index);
5456 return EvaluateInPlace(Info.CurrentCall->createTemporary(E, false),
5457 Info, Result, E);
5485 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
5487 return TemporaryExprEvaluator(Info, Result).Visit(E);
5500 VectorExprEvaluator(EvalInfo &info, APValue &Result)
5501 : ExprEvaluatorBaseTy(info), Result(Result) {}
5527 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
5529 return VectorExprEvaluator(Info, Result).Visit(E);
5544 if (!EvaluateInteger(SE, IntResult, Info))
5549 if (!EvaluateFloat(SE, F, Info))
5563 if (!EvalAndBitcastToAPInt(Info, SE, SValInt))
5567 unsigned EltSize = Info.Ctx.getTypeSize(EltTy);
5568 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
5571 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
5621 if (!EvaluateVector(E->getInit(CountInits), v, Info))
5630 if (!EvaluateInteger(E->getInit(CountInits), sInt, Info))
5633 sInt = Info.Ctx.MakeIntValue(0, EltTy);
5639 if (!EvaluateFloat(E->getInit(CountInits), f, Info))
5642 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy));
5657 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy));
5660 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)));
5682 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
5683 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
5694 Info.Ctx.getAsConstantArrayType(E->getType());
5704 Subobject.addArray(Info, E, CAT);
5706 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
5718 APValue &Result, EvalInfo &Info) {
5720 return ArrayExprEvaluator(Info, This, Result).Visit(E);
5724 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType());
5732 if (!EvaluateLValue(E->getInit(0), LV, Info))
5768 Subobject.addArray(Info, E, CAT);
5773 Info, Subobject, Init) ||
5774 !HandleLValueArrayAdjustment(Info, Init, Subobject,
5776 if (!Info.keepEvaluatingAfterFailure())
5788 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
5802 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
5818 ArrayElt.addArray(Info, E, CAT);
5822 !HandleLValueArrayAdjustment(Info, E, ArrayElt,
5835 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
5841 return EvaluateInPlace(*Value, Info, Subobject, &VIE);
5847 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition))
5852 if (!EvaluateInPlace(*Value, Info, Subobject, &VIE))
5859 Info, *Value);
5875 IntExprEvaluator(EvalInfo &info, APValue &result)
5876 : ExprEvaluatorBaseTy(info), Result(result) {}
5883 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
5895 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
5909 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
6012 EvalInfo &Info) {
6014 return IntExprEvaluator(Info, Result).Visit(E);
6017 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
6019 if (!EvaluateIntegerOrLValue(E, Val, Info))
6024 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
6041 == Info.Ctx.getIntWidth(E->getType()));
6051 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType()));
6157 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold);
6158 if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info)
6159 : EvaluatePointer(Arg, LV, Info)) &&
6189 SpeculativeEvaluationRAII SpeculativeEval(Info);
6190 if (!EvaluatePointer(E->getArg(0), Base, Info))
6200 if (!ExprType->EvaluateAsInt(TypeIntVaue, Info.Ctx))
6217 CharUnits Size = Info.Ctx.getTypeSizeInChars(T);
6239 if (E->getArg(0)->HasSideEffects(Info.Ctx)) {
6240 if (E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue() <= 1)
6247 switch (Info.EvalMode) {
6264 if (!EvaluateInteger(E->getArg(0), Val, Info))
6282 if (!EvaluateInteger(E->getArg(0), Val, Info))
6291 return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E);
6298 if (!EvaluateInteger(E->getArg(0), Val, Info))
6307 int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue();
6308 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand);
6319 if (!EvaluateInteger(E->getArg(0), Val, Info))
6328 if (!EvaluateFloat(E->getArg(5), Val, Info))
6342 return EvaluateFloat(E->getArg(0), Val, Info) &&
6348 return EvaluateFloat(E->getArg(0), Val, Info) &&
6354 return EvaluateFloat(E->getArg(0), Val, Info) &&
6360 return EvaluateFloat(E->getArg(0), Val, Info) &&
6366 return EvaluateFloat(E->getArg(0), Val, Info) &&
6374 if (!EvaluateInteger(E->getArg(0), Val, Info))
6384 if (!EvaluateInteger(E->getArg(0), Val, Info))
6392 if (Info.getLangOpts().CPlusPlus11)
6393 Info.CCEDiag(E, diag::note_constexpr_invalid_function)
6396 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
6402 if (!EvaluatePointer(E->getArg(0), String, Info))
6430 if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) ||
6435 if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1))
6444 if (!EvaluateInteger(E->getArg(0), SizeVal, Info))
6461 Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth();
6462 if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) {
6465 E->getArg(1)->isNullPointerConstant(Info.Ctx,
6474 Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
6555 void startSpeculativeEval(EvalInfo &Info) {
6556 OldEvalStatus = Info.EvalStatus;
6557 Info.EvalStatus.Diag = nullptr;
6558 StoredInfo = &Info;
6573 EvalInfo &Info;
6578 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
6618 return Info.CCEDiag(E, D);
6629 Result.Failed = !Evaluate(Result.Val, Info, E);
6652 return Info.noteSideEffect();
6670 if (!Info.noteSideEffect())
6685 if (LHSResult.Failed && !Info.keepEvaluatingAfterFailure())
6783 APSInt Value(Info.Ctx.getIntWidth(E->getType()),
6785 if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(),
6817 job.startSpeculativeEval(Info);
6838 if (!Info.keepEvaluatingAfterFailure() && E->isAssignmentOp())
6852 EvaluateLValue(E->getLHS(), LV, Info);
6855 LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info);
6861 LHSOK = EvaluateComplex(E->getLHS(), LHS, Info);
6863 if (!LHSOK && !Info.keepEvaluatingAfterFailure())
6867 if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK)
6871 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
6910 bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
6911 if (!LHSOK && !Info.keepEvaluatingAfterFailure())
6914 if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK)
6944 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info);
6945 if (!LHSOK && Info.keepEvaluatingAfterFailure())
6948 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK)
6997 isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) ||
6999 isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue)))
7033 if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize))
7040 Info.Diag(E, diag::note_constexpr_pointer_subtraction_zero_size)
7060 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
7063 HandleOverflow(Info, E, TrueResult, E->getType());
7122 unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy);
7137 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
7161 bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info);
7162 if (!LHSOK && Info.keepEvaluatingAfterFailure())
7165 if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK)
7217 return Success(GetAlignOfType(Info, E->getArgumentType()), E);
7219 return Success(GetAlignOfExpr(Info, E->getArgumentExpr()), E);
7246 if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof))
7267 if (!EvaluateInteger(Idx, IdxResult, Info))
7269 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
7273 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
7285 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
7288 Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
7307 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
7343 HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
7355 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
7428 if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info))
7444 return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType);
7446 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
7449 return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
7457 if (!EvaluatePointer(SubExpr, LV, Info))
7465 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType))
7473 APSInt AsInt = Info.Ctx.MakeIntValue(LV.getLValueOffset().getQuantity(),
7475 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E);
7480 if (!EvaluateComplex(SubExpr, C, Info))
7487 if (!EvaluateFloat(SubExpr, F, Info))
7491 if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value))
7503 if (!EvaluateComplex(E->getSubExpr(), LV, Info))
7516 if (!EvaluateComplex(E->getSubExpr(), LV, Info))
7544 FloatExprEvaluator(EvalInfo &info, APFloat &result)
7545 : ExprEvaluatorBaseTy(info), Result(result) {}
7553 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
7571 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
7573 return FloatExprEvaluator(Info, Result).Visit(E);
7626 Info.Ctx.getFloatTypeSemantics(E->getType());
7634 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
7644 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
7652 if (!EvaluateFloat(E->getArg(0), Result, Info))
7667 if (!EvaluateFloat(E->getArg(0), Result, Info) ||
7668 !EvaluateFloat(E->getArg(1), RHS, Info))
7679 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
7691 if (!EvaluateComplex(E->getSubExpr(), CV, Info))
7698 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
7707 return EvaluateFloat(E->getSubExpr(), Result, Info);
7709 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
7721 bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
7722 if (!LHSOK && !Info.keepEvaluatingAfterFailure())
7724 return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK &&
7725 handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
7742 return EvaluateInteger(SubExpr, IntResult, Info) &&
7743 HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult,
7750 return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(),
7756 if (!EvaluateComplex(SubExpr, V, Info))
7774 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
7775 : ExprEvaluatorBaseTy(info), Result(Result) {}
7797 EvalInfo &Info) {
7799 return ComplexExprEvaluator(Info, Result).Visit(E);
7806 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy));
7811 APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy);
7824 if (!EvaluateFloat(SubExpr, Imag, Info))
7835 if (!EvaluateInteger(SubExpr, Imag, Info))
7903 if (!EvaluateFloat(E->getSubExpr(), Real, Info))
7919 return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
7920 HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
7931 return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
7933 HandleFloatToIntCast(Info, E, From, Result.FloatImag,
7939 if (!EvaluateInteger(E->getSubExpr(), Real, Info))
7955 Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
7956 Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
7968 return HandleIntToFloatCast(Info, E, From, Result.IntReal,
7970 HandleIntToFloatCast(Info, E, From, Result.IntImag,
7990 LHSOK = EvaluateFloat(E->getLHS(), Real, Info);
7998 if (!LHSOK && !Info.keepEvaluatingAfterFailure())
8005 if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK)
8009 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK)
8236 if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
8238 if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
8242 if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
8244 if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
8262 AtomicExprEvaluator(EvalInfo &Info, APValue &Result)
8263 : ExprEvaluatorBaseTy(Info), Result(Result) {}
8273 return Evaluate(Result, Info, &VIE);
8281 return Evaluate(Result, Info, E->getSubExpr());
8287 static bool EvaluateAtomic(const Expr *E, APValue &Result, EvalInfo &Info) {
8289 return AtomicExprEvaluator(Info, Result).Visit(E);
8301 VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
8328 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
8330 return VoidExprEvaluator(Info).Visit(E);
8337 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
8343 if (!EvaluateLValue(E, LV, Info))
8347 if (!EvaluateVector(E, Result, Info))
8350 if (!IntExprEvaluator(Info, Result).Visit(E))
8354 if (!EvaluatePointer(E, LV, Info))
8359 if (!EvaluateFloat(E, F, Info))
8364 if (!EvaluateComplex(E, C, Info))
8369 if (!EvaluateMemberPointer(E, P, Info))
8375 LV.set(E, Info.CurrentCall->Index);
8376 APValue &Value = Info.CurrentCall->createTemporary(E, false);
8377 if (!EvaluateArray(E, LV, Value, Info))
8382 LV.set(E, Info.CurrentCall->Index);
8383 APValue &Value = Info.CurrentCall->createTemporary(E, false);
8384 if (!EvaluateRecord(E, LV, Value, Info))
8388 if (!Info.getLangOpts().CPlusPlus11)
8389 Info.CCEDiag(E, diag::note_constexpr_nonliteral)
8391 if (!EvaluateVoid(E, Info))
8394 if (!EvaluateAtomic(E, Result, Info))
8396 } else if (Info.getLangOpts().CPlusPlus11) {
8397 Info.Diag(E, diag::note_constexpr_nonliteral) << E->getType();
8400 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr);
8410 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
8414 if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
8421 return EvaluateArray(E, This, Result, Info);
8423 return EvaluateRecord(E, This, Result, Info);
8427 return Evaluate(Result, Info, E);
8432 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
8436 if (!CheckLiteralType(Info, E))
8439 if (!::Evaluate(Result, Info, E))
8444 LV.setFrom(Info.Ctx, Result);
8445 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
8450 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
8493 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects);
8494 return ::EvaluateAsRValue(Info, this, Result.Val);
8519 EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold);
8522 if (!EvaluateLValue(this, LV, Info) || Result.HasSideEffects ||
8523 !CheckLValueConstantExpression(Info, getExprLoc(),
8593 EvalInfo Info(Ctx, EvalResult, EvalInfo::EM_EvaluateForOverflow);
8594 (void)::EvaluateAsRValue(Info, this, EvalResult.Val);
9087 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
9090 bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch);
9107 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated);
9113 !Evaluate(ArgValues[I - Args.begin()], Info, *I))
9116 if (Info.EvalStatus.HasSideEffects)
9121 CallStackFrame Frame(Info, Callee->getLocation(), Callee, /*This*/nullptr,
9123 return Evaluate(Value, Info, this) && !Info.EvalStatus.HasSideEffects;
9138 EvalInfo Info(FD->getASTContext(), Status,
9147 ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
9148 This.set(&VIE, Info.CurrentCall->Index);
9158 Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
9159 HandleConstructorCall(Loc, This, Args, CD, Info, Scratch);
9162 Args, FD->getBody(), Info, Scratch);
9174 EvalInfo Info(FD->getASTContext(), Status,
9180 bool Success = EvaluateArgs(Args, ArgValues, Info);
9184 CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data());
9187 Evaluate(ResultScratch, Info, E);
