[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

     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)
-    return;
+  const Expr *NewE = E->IgnoreParenImpCasts();
+  bool GNUNull = isa<GNUNullExpr>(NewE);
+  bool NullPtr = NewE->getType()->isNullPtrType();
+  if (!GNUNull && !NullPtr) return;
 
   // Return if target type is a safe conversion.
   if (T->isAnyPointerType() || T->isBlockPointerType() ||

   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 (GNUNull && Loc.isMacroID()) {
     StringRef MacroName = Lexer::getImmediateMacroNameForDiagnostics(
         Loc, S.SourceMgr, S.getLangOpts());
     if (MacroName == "NULL")

     return;
 
   S.Diag(Loc, diag::warn_impcast_null_pointer_to_integer)
-      << (NullKind == Expr::NPCK_CXX11_nullptr) << T << SourceRange(CC)
+      << NullPtr << T << SourceRange(CC)
       << FixItHint::CreateReplacement(Loc,
                                       S.getFixItZeroLiteralForType(T, Loc));
 }