[cfe-commits] r65525 - /cfe/trunk/lib/AST/ExprConstant.cpp

[Eli Friedman]

Author: efriedma
Date: Thu Feb 26 04:19:36 2009
New Revision: 65525

URL: http://llvm.org/viewvc/llvm-project?rev=65525&view=rev
Log:
Remove short-circuit evaluation and the extension warnings.  I'm 
pretty sure we want to keep constant expression verification outside of 
Evaluate. Because of that, the short-circuit evaluation doesn't 
generally make sense, and the comma warning doesn't make sense in its 
current form.


Modified:
    cfe/trunk/lib/AST/ExprConstant.cpp

Modified: cfe/trunk/lib/AST/ExprConstant.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ExprConstant.cpp?rev=65525&r1=65524&r2=65525&view=diff

==============================================================================
--- cfe/trunk/lib/AST/ExprConstant.cpp (original)
+++ cfe/trunk/lib/AST/ExprConstant.cpp Thu Feb 26 04:19:36 2009
@@ -42,12 +42,8 @@
   /// EvalResult - Contains information about the evaluation.
   Expr::EvalResult &EvalResult;
 
-  /// ShortCircuit - will be greater than zero if the current subexpression has
-  /// will not be evaluated because it's short-circuited (according to C rules).
-  unsigned ShortCircuit;
-
   EvalInfo(ASTContext &ctx, Expr::EvalResult& evalresult) : Ctx(ctx), 
-           EvalResult(evalresult), ShortCircuit(0) {}
+           EvalResult(evalresult) {}
 };
 
 
@@ -559,13 +555,6 @@
   IntExprEvaluator(EvalInfo &info, APValue &result)
     : Info(info), Result(result) {}
 
-  bool Extension(SourceLocation L, diag::kind D, const Expr *E) {
-    Info.EvalResult.DiagLoc = L;
-    Info.EvalResult.Diag = D;
-    Info.EvalResult.DiagExpr = E;
-    return true;  // still a constant.
-  }
-
   bool Success(const llvm::APSInt &SI, const Expr *E) {
     assert(E->getType()->isIntegralType() && "Invalid evaluation result.");
     assert(SI.isSigned() == E->getType()->isSignedIntegerType() &&
@@ -592,18 +581,7 @@
   }
 
   bool Error(SourceLocation L, diag::kind D, const Expr *E) {
-    // If this is in an unevaluated portion of the subexpression, ignore the
-    // error.
-    if (Info.ShortCircuit) {
-      // If error is ignored because the value isn't evaluated, get the real
-      // type at least to prevent errors downstream.
-      return Success(0, E);
-    }
-    
     // Take the first error.
-
-    // FIXME: This is wrong if we happen to have already emitted an
-    // extension diagnostic; in that case we should report this error.
     if (Info.EvalResult.Diag == 0) {
       Info.EvalResult.DiagLoc = L;
       Info.EvalResult.Diag = D;
@@ -792,14 +770,10 @@
     if (!Visit(E->getRHS()))
       return false;
 
-    if (!Info.ShortCircuit) {
-      // If we can't evaluate the LHS, it must be because it has 
-      // side effects.
-      if (!E->getLHS()->isEvaluatable(Info.Ctx))
-        Info.EvalResult.HasSideEffects = true;
-      
-      return Extension(E->getOperatorLoc(), diag::note_comma_in_ice, E);
-    }
+    // If we can't evaluate the LHS, it might have side effects;
+    // conservatively mark it.
+    if (!E->getLHS()->isEvaluatable(Info.Ctx))
+      Info.EvalResult.HasSideEffects = true;
 
     return true;
   }
@@ -812,19 +786,8 @@
     if (HandleConversionToBool(E->getLHS(), lhsResult, Info)) {
       // We were able to evaluate the LHS, see if we can get away with not
       // evaluating the RHS: 0 && X -> 0, 1 || X -> 1
-      if (lhsResult == (E->getOpcode() == BinaryOperator::LOr) || 
-          !lhsResult == (E->getOpcode() == BinaryOperator::LAnd)) {
-        Info.ShortCircuit++;
-        bool rhsEvaluated = HandleConversionToBool(E->getRHS(), rhsResult, Info);
-        Info.ShortCircuit--;
-        
-        // FIXME: Return an extension warning saying that the RHS could not be
-        // evaluated.
-        // if (!rhsEvaluated) ...
-        (void) rhsEvaluated;
-        
+      if (lhsResult == (E->getOpcode() == BinaryOperator::LOr))
         return Success(lhsResult, E);
-      }
 
       if (HandleConversionToBool(E->getRHS(), rhsResult, Info)) {
         if (E->getOpcode() == BinaryOperator::LOr)