[Sema] Avoid isNullPointerConstant invocation

[justinstitt]

Summary

DiagnoseNullConversion is needlessly calling isNullPointerConstant which
is an expensive routine due to its calls to a constant evaluator --
which we don't need.

Building the Linux Kernel (x86_64) with this fix has improved build
times by ~2.1%. This is mainly due to the following methods no longer
needing to be called anywhere near as often:

1. ExprConstant::CheckICE (reduced CPU cycles by ~90%)
2. IntExprEvaluator::VisitBinaryOperator (reduced CPU cycles by ~50%)

[justinstitt]

use @rtrieu 's suggestion regarding not invoking isNullPointerConstant as opposed to checking for C++ lang opt.

[rtrieu]

I think this is a reasonable step for improving compile times. I put some suggestions for more descriptive names below (he said, after suggesting those names in the first place).

The description of this change should mention that expensive part is because isNullPointerConstant makes calls to a constant evaluator which we don't need.

clang/lib/Sema/SemaChecking.cpp

13343

Let's call this IsGNUNullExpr

13344

And let's call this HasNullPtrType

[justinstitt]

add more descriptive names, add more detail to revision summary.

[justinstitt]

move return to new line, as per clang-format.

[nickdesaulniers]

Awesome! This makes a measurable improvement in my Linux kernel build times!

Thanks for the patch, and thanks @rtrieu for suggestions that will improve C++ code compilation times as well.

I'll commit this for you since you don't yet have commit access.

Let's keep an eye on https://llvm-compile-time-tracker.com/compare.php to see how this does.

[nickdesaulniers]

https://llvm-compile-time-tracker.com/compare.php?from=0299ebc1bdc9fca176ebcacd590c90dc77a47551&to=333771f3558c81390a0e5d715ad8d1e419050b66&stat=cycles should be the link, once it gets picked up.

clang/lib/Sema/SemaChecking.cpp

bool IsSwapped = ((i > 0) &&
         IsImplicitBoolFloatConversion(S, TheCall->getArg(i - 1), false));
     IsSwapped |= ((i < (NumArgs - 1)) &&
         IsImplicitBoolFloatConversion(S, TheCall->getArg(i + 1), false));
     if (IsSwapped) {
       // Warn on this floating-point to bool conversion.
       DiagnoseImpCast(S, CurrA->IgnoreParenImpCasts(),
                       CurrA->getType(), CC,
                       diag::warn_impcast_floating_point_to_bool);
     }
   }
 }
 
 static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T,
                                    SourceLocation CC) {
   if (S.Diags.isIgnored(diag::warn_impcast_null_pointer_to_integer,
                         E->getExprLoc()))
     return;
 
   // Don't warn on functions which have return type nullptr_t.
   if (isa<CallExpr>(E))
     return;
 
   // Check for NULL (GNUNull) or nullptr (CXX11_nullptr).
-  const Expr::NullPointerConstantKind NullKind =
-      E->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull);
-  if (NullKind != Expr::NPCK_GNUNull && NullKind != Expr::NPCK_CXX11_nullptr)
+  const Expr *NewE = E->IgnoreParenImpCasts();
+  bool IsGNUNullExpr = isa<GNUNullExpr>(NewE);
+  bool HasNullPtrType = NewE->getType()->isNullPtrType();
+  if (!IsGNUNullExpr && !HasNullPtrType)
     return;
 
   // Return if target type is a safe conversion.
   if (T->isAnyPointerType() || T->isBlockPointerType() ||
       T->isMemberPointerType() || !T->isScalarType() || T->isNullPtrType())
     return;
 
   SourceLocation Loc = E->getSourceRange().getBegin();
 
   // Venture through the macro stacks to get to the source of macro arguments.
   // The new location is a better location than the complete location that was
   // passed in.
   Loc = S.SourceMgr.getTopMacroCallerLoc(Loc);
   CC = S.SourceMgr.getTopMacroCallerLoc(CC);
 
   // __null is usually wrapped in a macro.  Go up a macro if that is the case.
-  if (NullKind == Expr::NPCK_GNUNull && Loc.isMacroID()) {
+  if (IsGNUNullExpr && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroNameForDiagnostics(
         Loc, S.SourceMgr, S.getLangOpts());
     if (MacroName == "NULL")
       Loc = S.SourceMgr.getImmediateExpansionRange(Loc).getBegin();
   }
 
   // Only warn if the null and context location are in the same macro expansion.
   if (S.SourceMgr.getFileID(Loc) != S.SourceMgr.getFileID(CC))
     return;
 
   S.Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
-      << (NullKind == Expr::NPCK_CXX11_nullptr) << T << SourceRange(CC)
+      << HasNullPtrType << T << SourceRange(CC)
       << FixItHint::CreateReplacement(Loc,
                                       S.getFixItZeroLiteralForType(T, Loc));
 }
 
 static void checkObjCArrayLiteral(Sema &S, QualType TargetType,
                                   ObjCArrayLiteral *ArrayLiteral);
 
 static void