Lines Matching defs:Result
19 // * An evaluated result, valid only if constant folding has not failed.
23 // where it is possible to determine the evaluated result regardless.
817 // derived class of the class containing the original member, the result
871 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
872 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
876 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info);
877 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info);
878 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
880 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
881 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
882 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
884 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
1103 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
1107 Result = !Value.getLValueOffset().isZero();
1113 Result = true;
1118 static bool HandleConversionToBool(const APValue &Val, bool &Result) {
1123 Result = Val.getInt().getBoolValue();
1126 Result = !Val.getFloat().isZero();
1129 Result = Val.getComplexIntReal().getBoolValue() ||
1133 Result = !Val.getComplexFloatReal().isZero() ||
1137 return EvalPointerValueAsBool(Val, Result);
1139 Result = Val.getMemberPointerDecl();
1152 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
1158 return HandleConversionToBool(Val, Result);
1170 QualType DestType, APSInt &Result) {
1175 Result = APSInt(DestWidth, !DestSigned);
1177 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
1185 APFloat &Result) {
1186 APFloat Value = Result;
1188 if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType),
1199 APSInt Result = Value;
1202 Result = Result.extOrTrunc(DestWidth);
1203 Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType());
1204 return Result;
1209 QualType DestType, APFloat &Result) {
1210 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
1211 if (Result.convertFromAPInt(Value, Value.isSigned(),
1267 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
1270 SubobjectDesignator &D = Result.Designator;
1277 if (!Result.checkSubobject(Info, E, CSK_Derived))
1287 Result.Offset -= Layout.getVBaseClassOffset(Base);
1289 Result.Offset -= Layout.getBaseClassOffset(Base);
1423 CallStackFrame *Frame, APValue &Result) {
1435 Result = Frame->Arguments[PVD->getFunctionScopeIndex()];
1452 Result = *Info.EvaluatingDeclValue;
1453 return !Result.isUninit();
1479 Result = *VD->getEvaluatedValue();
1504 /// determine the expected signedness of the result -- a string literal used to
1769 // behavior is undefined so the result is not a constant expression.
1896 /// lvalue referring to the result.
1992 LValue &Result) {
1993 SubobjectDesignator &D = Result.Designator;
1994 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
2024 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize);
2039 static EvalStmtResult EvaluateStmt(APValue &Result, EvalInfo &Info,
2051 if (!Evaluate(Result, Info, RetExpr))
2060 EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
2150 EvalInfo &Info, APValue &Result) {
2159 Result, Info, Body) == ESR_Returned;
2166 EvalInfo &Info, APValue &Result) {
2185 return EvaluateInPlace(Result, Info, This, (*I)->getInit());
2197 RHS, Result);
2201 if (!RD->isUnion() && Result.isUninit())
2202 Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
2216 APValue *Value = &Result;
2232 Value = &Result.getStructBase(BasesSeen++);
2237 Result = APValue(FD);
2238 Value = &Result.getUnionValue();
2240 Value = &Result.getStructField(FD->getFieldIndex());
2419 APValue Result;
2420 if (!HandleLValueToRValueConversion(Info, E, E->getType(), Obj, Result))
2422 return DerivedSuccess(Result, E);
2440 // the result is a constant expression if it can be folded without
2554 APValue Result;
2558 Info, Result))
2561 return DerivedSuccess(Result, E);
2652 LValue &Result;
2657 Result.set(B);
2662 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result) :
2663 ExprEvaluatorBaseTy(Info), Result(Result) {}
2666 Result.setFrom(this->Info.Ctx, V);
2674 if (!EvaluatePointer(E->getBase(), Result, this->Info))
2679 if (!EvaluateTemporary(E->getBase(), Result, this->Info))
2693 if (!HandleLValueMember(this->Info, E, Result, FD))
2696 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
2703 if (!HandleLValueToRValueConversion(this->Info, E, MD->getType(), Result,
2718 return HandleMemberPointerAccess(this->Info, E, Result);
2738 if (!HandleLValueBase(this->Info, E, Result, Type->getAsCXXRecordDecl(),
2782 LValueExprEvaluator(EvalInfo &Info, LValue &Result) :
2783 LValueExprEvaluatorBaseTy(Info, Result) {}
2810 Result.Designator.setInvalid();
2816 return HandleBaseToDerivedCast(Info, E, Result);
2827 static bool EvaluateLValue(const Expr* E, LValue& Result, EvalInfo &Info) {
2831 return LValueExprEvaluator(Info, Result).Visit(E);
2845 Result.set(VD, Info.CurrentCall->Index);
2861 return EvaluateTemporary(E->GetTemporaryExpr(), Result, Info);
2863 Result.set(E, Info.CurrentCall->Index);
2865 Result, E->GetTemporaryExpr());
2873 if (!HandleLValueToRValueConversion(Info, E, E->getType(), Result,
2876 Result.set(E, Info.CurrentCall->Index);
2932 if (!EvaluatePointer(E->getBase(), Result, Info))
2942 return HandleLValueArrayAdjustment(Info, E, Result, E->getType(), IndexValue);
2946 return EvaluatePointer(E->getSubExpr(), Result, Info);
2954 HandleLValueComplexElement(Info, E, Result, E->getType(), false);
2963 HandleLValueComplexElement(Info, E, Result, E->getType(), true);
2974 LValue &Result;
2977 Result.set(E);
2982 PointerExprEvaluator(EvalInfo &info, LValue &Result)
2983 : ExprEvaluatorBaseTy(info), Result(Result) {}
2986 Result.setFrom(Info.Ctx, V);
3011 Result = *Info.CurrentCall->This;
3019 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info) {
3021 return PointerExprEvaluator(Info, Result).Visit(E);
3034 bool EvalPtrOK = EvaluatePointer(PExp, Result, Info);
3048 return HandleLValueArrayAdjustment(Info, E, Result, Pointee,
3053 return EvaluateLValue(E->getSubExpr(), Result, Info);
3073 Result.Designator.setInvalid();
3084 if (!EvaluatePointer(E->getSubExpr(), Result, Info))
3086 if (!Result.Base && Result.Offset.isZero())
3096 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
3108 if (!Result.Base && Result.Offset.isZero())
3110 return HandleBaseToDerivedCast(Info, E, Result);
3126 Result.Base = (Expr*)0;
3127 Result.Offset = CharUnits::fromQuantity(N);
3128 Result.CallIndex = 0;
3129 Result.Designator.setInvalid();
3133 Result.setFrom(Info.Ctx, Value);
3139 if (!EvaluateLValue(SubExpr, Result, Info))
3142 Result.set(SubExpr, Info.CurrentCall->Index);
3144 Info, Result, SubExpr))
3147 // The result is a pointer to the first element of the array.
3150 Result.addArray(Info, E, CAT);
3152 Result.Designator.setInvalid();
3156 return EvaluateLValue(SubExpr, Result, Info);
3176 MemberPtr &Result;
3179 Result = MemberPtr(D);
3184 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
3185 : ExprEvaluatorBaseTy(Info), Result(Result) {}
3188 Result.setFrom(V);
3200 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
3203 return MemberPointerExprEvaluator(Info, Result).Visit(E);
3228 if (!Result.castToDerived(Derived))
3232 if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
3244 if (!Result.castToBase(Base))
3265 APValue &Result;
3268 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
3269 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
3272 Result = V;
3292 const LValue &This, APValue &Result) {
3295 Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
3310 Result.getStructBase(Index)))
3327 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
3342 Result = APValue((const FieldDecl*)0);
3349 Result = APValue(*I);
3351 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE);
3359 return HandleClassZeroInitialization(Info, E, RD, This, Result);
3388 Result = *Value;
3405 Result = APValue(Field);
3417 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr);
3422 Result = APValue(APValue::UninitStruct(), 0,
3448 Result.getStructField(Field->getFieldIndex()),
3466 if (!Result.isUninit())
3474 Result = APValue((FieldDecl*)0);
3476 Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
3499 Result);
3503 APValue &Result, EvalInfo &Info) {
3506 return RecordExprEvaluator(Info, This, Result).Visit(E);
3520 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
3521 LValueExprEvaluatorBaseTy(Info, Result) {}
3525 Result.set(E, Info.CurrentCall->Index);
3526 return EvaluateInPlace(Info.CurrentCall->Temporaries[E], Info, Result, E);
3551 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
3553 return TemporaryExprEvaluator(Info, Result).Visit(E);
3563 APValue &Result;
3566 VectorExprEvaluator(EvalInfo &info, APValue &Result)
3567 : ExprEvaluatorBaseTy(info), Result(Result) {}
3572 Result = APValue(V.data(), V.size());
3577 Result
3593 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
3595 return VectorExprEvaluator(Info, Result).Visit(E);
3746 APValue &Result;
3749 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
3750 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
3755 Result = V;
3765 Result = APValue(APValue::UninitArray(), 0,
3767 if (!Result.hasArrayFiller()) return true;
3773 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
3782 APValue &Result, EvalInfo &Info) {
3784 return ArrayExprEvaluator(Info, This, Result).Visit(E);
3805 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) &&
3808 if (Result.isArray() && Result.hasArrayFiller())
3809 Filler = Result.getArrayFiller();
3811 Result = APValue(APValue::UninitArray(), E->getNumInits(),
3817 for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I)
3818 Result.getArrayInitializedElt(I) = Filler;
3819 if (Result.hasArrayFiller())
3820 Result.getArrayFiller() = Filler;
3828 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
3838 if (!Result.hasArrayFiller()) return Success;
3844 return EvaluateInPlace(Result.getArrayFiller(), Info,
3855 APValue *Value = &Result;
3924 APValue &Result;
3926 IntExprEvaluator(EvalInfo &info, APValue &result)
3927 : ExprEvaluatorBaseTy(info), Result(result) {}
3929 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
3931 "Invalid evaluation result.");
3933 "Invalid evaluation result.");
3935 "Invalid evaluation result.");
3936 Result = APValue(SI);
3940 return Success(SI, E, Result);
3943 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
3945 "Invalid evaluation result.");
3947 "Invalid evaluation result.");
3948 Result = APValue(APSInt(I));
3949 Result.getInt().setIsUnsigned(
3954 return Success(I, E, Result);
3957 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
3959 "Invalid evaluation result.");
3960 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
3964 return Success(Value, E, Result);
3973 Result = V;
4072 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
4075 return IntExprEvaluator(Info, Result).Visit(E);
4078 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
4088 Result = Val.getInt();
4174 /// EvaluateBuiltinConstantPForLValue - Determine the result of
4204 Expr::EvalResult Result;
4205 if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects)
4208 APValue &V = Result.Val;
4417 APSInt Result = Value.trunc(LHS.getBitWidth());
4418 if (Result.extend(BitWidth) != Value)
4420 return Result;
4472 DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
4473 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
4499 bool Success(uint64_t Value, const Expr *E, APValue &Result) {
4500 return IntEval.Success(Value, E, Result);
4502 bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
4503 return IntEval.Success(Value, E, Result);
4521 const BinaryOperator *E, APValue &Result);
4523 void EvaluateExpr(const Expr *E, EvalResult &Result) {
4524 Result.Failed = !Evaluate(Result
4525 if (Result.Failed)
4526 Result.Val = APValue();
4529 void process(EvalResult &Result);
4565 // We can't evaluate the LHS; however, sometimes the result
4585 const BinaryOperator *E, APValue &Result) {
4589 Result = RHSResult.Val;
4601 return Success(lhsResult || rhsResult, E, Result);
4603 return Success(lhsResult && rhsResult, E, Result);
4607 // We can't evaluate the LHS; however, sometimes the result
4610 return Success(rhsResult, E, Result);
4628 Result = LHSVal;
4632 Result.getLValueOffset() += AdditionalOffset;
4634 Result.getLValueOffset() -= AdditionalOffset;
4641 Result = RHSVal;
4642 Result.getLValueOffset() += CharUnits::fromQuantity(
4664 Result = APValue(LHSAddrExpr, RHSAddrExpr);
4682 Result);
4686 std::plus<APSInt>()), E, Result);
4690 std::minus<APSInt>()), E, Result);
4691 case BO_And: return Success(LHS & RHS, E, Result);
4692 case BO_Xor: return Success(LHS ^ RHS, E, Result);
4693 case BO_Or: return Success(LHS | RHS, E, Result);
4704 Result);
4730 return Success(LHS << SA, E, Result);
4749 return Success(LHS >> SA, E, Result);
4752 case BO_LT: return Success(LHS < RHS, E, Result);
4753 case BO_GT: return Success(LHS > RHS, E, Result);
4754 case BO_LE: return Success(LHS <= RHS, E, Result);
4755 case BO_GE: return Success(LHS >= RHS, E, Result);
4756 case BO_EQ: return Success(LHS == RHS, E, Result);
4757 case BO_NE: return Success(LHS != RHS, E, Result);
4761 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) {
4774 EvaluateExpr(job.E, Result);
4782 if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
4788 job.LHSResult.swap(Result);
4797 RHS.swap(Result);
4798 Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
4812 return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E);
4924 Result = APValue(LHSAddrExpr, RHSAddrExpr);
4938 // distinct addresses. In clang, the result of such a comparison is
4993 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType()));
4995 if (Result.extend(65) != TrueResult)
4997 return Success(Result, E);
5002 // result defined as follows: If both pointers represent the same
5003 // address or are both the null pointer value, the result is true if the
5004 // operator is <= or >= and false otherwise; otherwise the result is
5029 // Otherwise, the result is unspecified and thus the comparison is not a
5064 // compare pointers within the object in question; otherwise, the result
5110 // result is unspecified.
5130 // are compared, the result is true of the operator is <=, >= or ==, and
5145 // result shall be the alignment of the referenced type."
5172 /// a result as the expression's type.
5202 // the result is the size of the referenced type."
5217 CharUnits Result;
5235 Result += IdxResult.getSExtValue() * ElementSize;
5249 Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
5277 Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl()));
5282 return Success(Result, OOE);
5296 // The result is just the value.
5301 if (!Result.isInt()) return Error(E);
5302 const APSInt &Value = Result.getInt();
5311 if (!Result.isInt()) return Error(E);
5312 return Success(~Result.getInt(), E);
5324 /// result type is integer.
5396 if (!Result.isInt()) {
5402 if (Result.isAddrLabelDiff())
5409 Result.getInt()), E);
5428 LV.moveInto(Result);
5501 APFloat &Result;
5503 FloatExprEvaluator(EvalInfo &info, APFloat &result)
5504 : ExprEvaluatorBaseTy(info), Result(result) {}
5507 Result = V.getFloat();
5512 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
5530 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
5532 return FloatExprEvaluator(Info, Result).Visit(E);
5539 llvm::APFloat &Result) {
5554 Result = llvm::APFloat::getSNaN(Sem, false, &fill);
5556 Result = llvm::APFloat::getQNaN(Sem, false, &fill);
5573 Result = llvm::APFloat::getInf(Sem);
5581 true, Result))
5591 false, Result))
5598 if (!EvaluateFloat(E->getArg(0), Result, Info))
5601 if (Result.isNegative())
5602 Result.changeSign();
5609 if (!EvaluateFloat(E->getArg(0), Result, Info) ||
5612 Result.copySign(RHS);
5623 Result = CV.FloatReal;
5635 Result = CV.FloatImag;
5641 Result = llvm::APFloat::getZero(Sem);
5649 return EvaluateFloat(E->getSubExpr(), Result, Info);
5651 if (!EvaluateFloat(E->getSubExpr(), Result, Info))
5653 Result.changeSign();
5663 bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info);
5672 Result.multiply(RHS, APFloat::rmNearestTiesToEven);
5675 Result.add(RHS, APFloat::rmNearestTiesToEven);
5678 Result.subtract(RHS, APFloat::rmNearestTiesToEven);
5681 Result.divide(RHS, APFloat::rmNearestTiesToEven);
5685 if (Result.isInfinity() || Result.isNaN())
5686 CCEDiag(E, diag::note_constexpr_float_arithmetic) << Result.isNaN();
5691 Result = E->getValue();
5706 E->getType(), Result);
5713 Result);
5720 Result = V.getComplexFloatReal();
5733 ComplexValue &Result;
5736 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
5737 : ExprEvaluatorBaseTy(info), Result(Result) {}
5740 Result.setFrom(V);
5758 static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
5761 return ComplexExprEvaluator(Info, Result).Visit(E);
5767 Result.makeComplexFloat();
5769 Result.FloatReal = Zero;
5770 Result.FloatImag = Zero;
5772 Result.makeComplexInt();
5774 Result.IntReal = Zero;
5775 Result.IntImag = Zero;
5784 Result.makeComplexFloat();
5785 APFloat &Imag = Result.FloatImag;
5789 Result.FloatReal = APFloat(Imag.getSemantics());
5795 Result.makeComplexInt();
5796 APSInt &Imag = Result.IntImag;
5800 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned());
5862 APFloat &Real = Result.FloatReal;
5866 Result.makeComplexFloat();
5867 Result.FloatImag = APFloat(Real.getSemantics());
5879 return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
5880 HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
5890 Result.makeComplexInt();
5891 return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
5892 To, Result.IntReal) &&
5893 HandleFloatToIntCast(Info, E, From, Result.FloatImag,
5894 To, Result.IntImag);
5898 APSInt &Real = Result.IntReal;
5902 Result.makeComplexInt();
5903 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned());
5915 Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
5916 Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
5927 Result.makeComplexFloat();
5928 return HandleIntToFloatCast(Info, E, From, Result.IntReal,
5929 To, Result.FloatReal) &&
5930 HandleIntToFloatCast(Info, E, From, Result.IntImag,
5931 To, Result.FloatImag);
5950 assert(Result.isComplexFloat() == RHS.isComplexFloat() &&
5955 if (Result.isComplexFloat()) {
5956 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
5958 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(),
5961 Result.getComplexIntReal() += RHS.getComplexIntReal();
5962 Result.getComplexIntImag() += RHS.getComplexIntImag();
5966 if (Result.isComplexFloat()) {
5967 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(),
5969 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(),
5972 Result.getComplexIntReal() -= RHS.getComplexIntReal();
5973 Result.getComplexIntImag() -= RHS.getComplexIntImag();
5977 if (Result.isComplexFloat()) {
5978 ComplexValue LHS = Result;
5986 Result.getComplexFloatReal() = Tmp;
5989 Result.getComplexFloatReal().subtract(Tmp, APFloat::rmNearestTiesToEven);
5993 Result.getComplexFloatImag() = Tmp;
5996 Result.getComplexFloatImag().add(Tmp, APFloat::rmNearestTiesToEven);
5998 ComplexValue LHS = Result;
5999 Result.getComplexIntReal() =
6002 Result.getComplexIntImag() =
6008 if (Result.isComplexFloat()) {
6009 ComplexValue LHS = Result;
6014 APFloat &Res_r = Result.getComplexFloatReal();
6015 APFloat &Res_i = Result.getComplexFloatImag();
6040 ComplexValue LHS = Result;
6043 Result.getComplexIntReal() =
6046 Result.getComplexIntImag() =
6057 // Get the operand value into 'Result'.
6067 // The result is always just the subexpr.
6070 if (Result.isComplexFloat()) {
6071 Result.getComplexFloatReal().changeSign();
6072 Result.getComplexFloatImag().changeSign();
6075 Result.getComplexIntReal() = -Result.getComplexIntReal();
6076 Result.getComplexIntImag() = -Result.getComplexIntImag();
6080 if (Result.isComplexFloat())
6081 Result.getComplexFloatImag().changeSign();
6083 Result.getComplexIntImag() = -Result.getComplexIntImag();
6091 Result.makeComplexFloat();
6092 if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info))
6094 if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info))
6097 Result.makeComplexInt();
6098 if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info))
6100 if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info))
6142 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
6149 LV.moveInto(Result);
6151 if (!EvaluateVector(E, Result, Info))
6154 if (!IntExprEvaluator(Info, Result).Visit(E))
6160 LV.moveInto(Result);
6165 Result = APValue(F);
6170 C.moveInto(Result);
6175 P.moveInto(Result);
6182 Result = Info.CurrentCall->Temporaries[E];
6188 Result = Info.CurrentCall->Temporaries[E];
6211 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
6221 return EvaluateArray(E, This, Result, Info);
6223 return EvaluateRecord(E, This, Result, Info);
6227 return Evaluate(Result, Info, E);
6232 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
6236 if (!::Evaluate(Result, Info, E))
6241 LV.setFrom(Info.Ctx, Result);
6242 if (!HandleLValueToRValueConversion(Info, E, E->getType(), LV, Result))
6247 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result);
6253 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
6254 /// will be applied to the result.
6255 bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const {
6259 Result.Val = APValue(APSInt(L->getValue(),
6270 EvalInfo Info(Ctx, Result);
6271 return ::EvaluateAsRValue(Info, this, Result.Val);
6274 bool Expr::EvaluateAsBooleanCondition(bool &Result,
6278 HandleConversionToBool(Scratch.Val, Result);
6281 bool Expr::EvaluateAsInt(APSInt &Result, const ASTContext &Ctx,
6291 Result = ExprResult.Val.getInt();
6295 bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const {
6296 EvalInfo Info(Ctx, Result);
6299 if (!EvaluateLValue(this, LV, Info) || Result.HasSideEffects ||
6304 LV.moveInto(Result.Val);
6348 /// constant folded, but discard the result.
6350 EvalResult Result;
6351 return EvaluateAsRValue(Result, Ctx) && !Result.HasSideEffects;
6356 bool Result = EvaluateAsRValue(EvalResult, Ctx);
6357 (void)Result;
6358 assert(Result && "Could not evaluate expression");
6789 APValue Result;
6790 if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc))
6793 assert(Result.isInt() && "pointer cast to int is not an ICE");
6794 if (Value) *Value = Result.getInt();
6826 bool Expr::isCXX11ConstantExpr(ASTContext &Ctx, APValue *Result,
6839 bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch);
