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

4 files changed, 17 insertions, 30 deletions

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index d3bf1b96d6..2f2ca04947 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -208,9 +208,6 @@ public:
   /// in Result.
   bool Evaluate(EvalResult &Result, ASTContext &Ctx) const;
 
-  // FIXME: We should come up with a better API for the isEvaluated case.
-  bool Evaluate(APValue& Result, ASTContext &Ctx, bool *isEvaluated = 0) const;
-
   /// isEvaluatable - Call Evaluate to see if this expression can be constant
   /// folded, but discard the result.
   bool isEvaluatable(ASTContext &Ctx) const;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index c01c973cf5..8aaea7ac9f 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -763,9 +763,11 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
     // 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 7a83d6c063..681016793f 100644
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -1194,19 +1194,6 @@ bool Expr::Evaluate(EvalResult &Result, ASTContext &Ctx) const {
   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 @@ bool Expr::isEvaluatable(ASTContext &Ctx) const {
 }
 
 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 6c1af5f878..86af21024b 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -1888,8 +1888,9 @@ bool Sema::CheckArithmeticConstantExpression(const Expr* Init) {
     // 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 @@ bool Sema::CheckArithmeticConstantExpression(const Expr* Init) {
     
     // 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 @@ static QualType TryToFixInvalidVariablyModifiedType(QualType T,
   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);