From d26527708b2b2f3b1d747f570efd10149d48364e Mon Sep 17 00:00:00 2001 From: Anders Carlsson Date: Mon, 1 Dec 2008 06:28:23 +0000 Subject: [PATCH] Revert change that made isNullPointerConstant start emitting warnings. We don't want that :) git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60333 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/Expr.h | 1 - lib/AST/Expr.cpp | 20 +++++++++----------- lib/Sema/Sema.h | 2 -- lib/Sema/SemaExpr.cpp | 24 ++---------------------- 4 files changed, 11 insertions(+), 36 deletions(-) diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h index 29a36a1ec8..932885eb30 100644 --- 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 4c86ce67ef..948dbc2418 100644 --- 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(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(this)) { // Ignore the ImplicitCastExpr type entirely. - return ICE->getSubExpr()->isNullPointerConstant(Result, Ctx); + return ICE->getSubExpr()->isNullPointerConstant(Ctx); } else if (const ParenExpr *PE = dyn_cast(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(this)) { // See through default argument expressions - return DefaultArg->getExpr()->isNullPointerConstant(Result, Ctx); + return DefaultArg->getExpr()->isNullPointerConstant(Ctx); } else if (isa(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 17af72ad9d..6f1cf8883b 100644 --- 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 fa4b71b5bd..0c17c75fce 100644 --- 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; -}