Get rid of the old Expr::Evaluate variant.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@61260 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index c01c973..8aaea7a 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -763,9 +763,11 @@
// If this is a call to a builtin function, constant fold it otherwise
// reject it.
if (CE->isBuiltinCall()) {
- APValue ResultAP;
- if (CE->Evaluate(ResultAP, Ctx)) {
- Result = ResultAP.getInt();
+ EvalResult EvalResult;
+ if (CE->Evaluate(EvalResult, Ctx)) {
+ assert(!EvalResult.HasSideEffects &&
+ "Foldable builtin call should not have side effects!");
+ Result = EvalResult.Val.getInt();
break; // It is a constant, expand it.
}
}
diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 7a83d6c..6810167 100644
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -1194,19 +1194,6 @@
return true;
}
-bool Expr::Evaluate(APValue &Result, ASTContext &Ctx, bool *isEvaluated) const {
- EvalResult EvalResult;
-
- if (!Evaluate(EvalResult, Ctx))
- return false;
-
- Result = EvalResult.Val;
- if (isEvaluated)
- *isEvaluated = !EvalResult.HasSideEffects;
-
- return true;
-}
-
/// isEvaluatable - Call Evaluate to see if this expression can be constant
/// folded, but discard the result.
bool Expr::isEvaluatable(ASTContext &Ctx) const {
@@ -1215,10 +1202,10 @@
}
APSInt Expr::EvaluateAsInt(ASTContext &Ctx) const {
- APValue V;
- bool Result = Evaluate(V, Ctx);
+ EvalResult EvalResult;
+ bool Result = Evaluate(EvalResult, Ctx);
assert(Result && "Could not evaluate expression");
- assert(V.isInt() && "Expression did not evaluate to integer");
+ assert(EvalResult.Val.isInt() && "Expression did not evaluate to integer");
- return V.getInt();
+ return EvalResult.Val.getInt();
}
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 6c1af5f..86af210 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -1888,8 +1888,9 @@
// should always be able to do in theory). If so, we only require the
// specified arm of the conditional to be a constant. This is a horrible
// hack, but is require by real world code that uses __builtin_constant_p.
- APValue Val;
- if (!Exp->getCond()->Evaluate(Val, Context)) {
+ Expr::EvalResult EvalResult;
+ if (!Exp->getCond()->Evaluate(EvalResult, Context) ||
+ EvalResult.HasSideEffects) {
// If Evaluate couldn't fold it, CheckArithmeticConstantExpression
// won't be able to either. Use it to emit the diagnostic though.
bool Res = CheckArithmeticConstantExpression(Exp->getCond());
@@ -1899,7 +1900,7 @@
// Verify that the side following the condition is also a constant.
const Expr *TrueSide = Exp->getLHS(), *FalseSide = Exp->getRHS();
- if (Val.getInt() == 0)
+ if (EvalResult.Val.getInt() == 0)
std::swap(TrueSide, FalseSide);
if (TrueSide && CheckArithmeticConstantExpression(TrueSide))
@@ -2717,13 +2718,13 @@
const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
if (!VLATy) return QualType();
- APValue Result;
+ Expr::EvalResult EvalResult;
if (!VLATy->getSizeExpr() ||
- !VLATy->getSizeExpr()->Evaluate(Result, Context))
+ !VLATy->getSizeExpr()->Evaluate(EvalResult, Context))
return QualType();
- assert(Result.isInt() && "Size expressions must be integers!");
- llvm::APSInt &Res = Result.getInt();
+ assert(EvalResult.Val.isInt() && "Size expressions must be integers!");
+ llvm::APSInt &Res = EvalResult.Val.getInt();
if (Res > llvm::APSInt(Res.getBitWidth(), Res.isUnsigned()))
return Context.getConstantArrayType(VLATy->getElementType(),
Res, ArrayType::Normal, 0);