Revert change that made isNullPointerConstant start emitting warnings. We don't want...

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60333 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 29a36a1ec8c4517183061ec42b02405eda3c067d..932885eb30dfb3571e17029cd21ab56d547f39a0 100644 (file)
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -181,7 +181,6 @@ public:
   /// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
   /// integer constant expression with the value zero, or if this is one that is
   /// cast to void*.
-  bool isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const;
   bool isNullPointerConstant(ASTContext &Ctx) const;
 
   /// hasGlobalStorage - Return true if this expression has static storage

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 4c86ce67efa26dbb8ea218a2ca51a8600f1a0653..948dbc241897106bf667003769e76e5b7362ddb0 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -1009,12 +1009,6 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
 /// cast to void*.
 bool Expr::isNullPointerConstant(ASTContext &Ctx) const
 {
-  EvalResult EvalResult;
-  
-  return isNullPointerConstant(EvalResult, Ctx);
-}
-
-bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
   // Strip off a cast to void*, if it exists. Except in C++.
   if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
     if (!Ctx.getLangOptions().CPlusPlus) {
@@ -1024,20 +1018,20 @@ bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
         if (Pointee.getCVRQualifiers() == 0 && 
             Pointee->isVoidType() &&                              // to void*
             CE->getSubExpr()->getType()->isIntegerType())         // from int.
-          return CE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+          return CE->getSubExpr()->isNullPointerConstant(Ctx);
       }
     }
   } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
     // Ignore the ImplicitCastExpr type entirely.
-    return ICE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
   } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
     // Accept ((void*)0) as a null pointer constant, as many other
     // implementations do.
-    return PE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+    return PE->getSubExpr()->isNullPointerConstant(Ctx);
   } else if (const CXXDefaultArgExpr *DefaultArg 
                = dyn_cast<CXXDefaultArgExpr>(this)) {
     // See through default argument expressions
-    return DefaultArg->getExpr()->isNullPointerConstant(Result, Ctx);
+    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
   } else if (isa<GNUNullExpr>(this)) {
     // The GNU __null extension is always a null pointer constant.
     return true;
@@ -1049,8 +1043,12 @@ bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
   
   // If we have an integer constant expression, we need to *evaluate* it and
   // test for the value 0.
+  // FIXME: We should probably return false if we're compiling in strict mode
+  // and Diag is not null (this indicates that the value was foldable but not
+  // an ICE.
+  EvalResult Result;
   return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
-      Result.Val.isInt() && Result.Val.getInt() == 0;
+        Result.Val.isInt() && Result.Val.getInt() == 0;
 }
 
 /// isBitField - Return true if this expression is a bit-field.

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 17af72ad9d84a25d6b42601a26674d155bde307d..6f1cf8883ba4b035c120f38e57b4c57dcfb82f5f 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -1352,8 +1352,6 @@ public:
   /// Can optionally return the value of the expression.
   bool VerifyIntegerConstantExpression(const Expr*E, llvm::APSInt *Result = 0);
 
-  bool isNullPointerConstant(const Expr *E);
-
   //===--------------------------------------------------------------------===//
   // Extra semantic analysis beyond the C type system
 private:

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index fa4b71b5bd75383369cd80ffece7d2d40d7664fb..0c17c75fceb29d4417bd6630335602f301ed08a8 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -1582,13 +1582,13 @@ inline QualType Sema::CheckConditionalOperands( // C99 6.5.15
   // the type of the other operand."
   if ((lexT->isPointerType() || lexT->isBlockPointerType() ||
        Context.isObjCObjectPointerType(lexT)) &&
-      isNullPointerConstant(rex)) {
+      rex->isNullPointerConstant(Context)) {
     ImpCastExprToType(rex, lexT); // promote the null to a pointer.
     return lexT;
   }
   if ((rexT->isPointerType() || rexT->isBlockPointerType() ||
        Context.isObjCObjectPointerType(rexT)) &&
-      isNullPointerConstant(lex)) {
+      lex->isNullPointerConstant(Context)) {
     ImpCastExprToType(lex, rexT); // promote the null to a pointer.
     return rexT;
   }
@@ -3706,23 +3706,3 @@ bool Sema::VerifyIntegerConstantExpression(const Expr* E, llvm::APSInt *Result)
     *Result = EvalResult.Val.getInt();
   return false;
 }
-
-bool Sema::isNullPointerConstant(const Expr *E)
-{
-  Expr::EvalResult EvalResult;
-  
-  if (!E->isNullPointerConstant(EvalResult, Context))
-    return false;
-  
-  if (EvalResult.Diag) {
-    Diag(E->getExprLoc(), diag::ext_null_pointer_expr_not_ice) << 
-      E->getSourceRange();
-
-    // Print the reason it's not a constant.
-    if (Diags.getDiagnosticLevel(diag::ext_null_pointer_expr_not_ice) != 
-        Diagnostic::Ignored)
-      Diag(EvalResult.DiagLoc, EvalResult.Diag);
-  }
-
-  return true;
-}