[clang] Short-circuit evaluation in ::EvaluateAsConstantExpr

[tbaeder]

Summary

This adds another case to FastEvaluateAsRValue() for boolean expressions as well as calls FastEvaluateAsRValue() in Expr::EvaluateAsConstantExpr() as well.

This way we can short-circuit evaluating simple integer and boolean literals here.

I don't have before/after numbers for compilation times, since my local builds have asan enabled (so valgrind doesn't work) and I lost access to the my asan-less build. But it shouldn't be worse than before... right?

Sorry, can't find better reviewers to add.

[erichkeane]

This seems to make sense to me. I'll accept, but please give others time to take a look.

[aaron.ballman]

LGTM

clang/lib/AST/ExprConstant.cpp

static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
   // containing vast quantities of these.
   if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
     Result.Val = APValue(APSInt(L->getValue(),
                                 L->getType()->isUnsignedIntegerType()));
     IsConst = true;
     return true;
   }
 
+  if (const auto *L = dyn_cast<CXXBoolLiteralExpr>(Exp)) {
+    Result.Val = APValue(APSInt(APInt(1, L->getValue())));
+    IsConst = true;
+    return true;
+  }
+
   // This case should be rare, but we need to check it before we check on
   // the type below.
   if (Exp->getType().isNull()) {
     IsConst = false;
     return true;
   }
 
   // FIXME: Evaluating values of large array and record types can cause
static bool EvaluateDestruction(const ASTContext &Ctx, APValue::LValueBase Base,
 
   return true;
 }
 
 bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
                                   ConstantExprKind Kind) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
+  bool IsConst;
+  if (FastEvaluateAsRValue(this, Result, Ctx, IsConst))
+    return true;
 
   ExprTimeTraceScope TimeScope(this, Ctx, "EvaluateAsConstantExpr");
   EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression;
   EvalInfo Info(Ctx, Result, EM);
   Info.InConstantContext = true;
 
   // The type of the object we're initializing is 'const T' for a class NTTP.
   QualType T = getType();