[clang][ConstantEmitter] have tryEmitPrivate try ConstExprEmitter fast-path first

[nickdesaulniers]

Summary

As suggested by @efriedma in:
https://reviews.llvm.org/D76096#4370369

Some minor code style fixes as well in
ConstantEmitter::tryEmitPrivateForVarInit.

[nickdesaulniers]

• one more style update

[efriedma]

Did you intentionally skip moving the ConstExprEmitter call in tryEmitPrivateForVarInit? (VarDecl::evaluateValue calls the constant evaluator.)

[nickdesaulniers]

In D151572#4376697, @efriedma wrote:

Did you intentionally skip moving the ConstExprEmitter call in tryEmitPrivateForVarInit? (VarDecl::evaluateValue calls the constant evaluator.)

Yes, I'll do that in a follow up patch as it results in quite a few test failures that I'm looking into now. Triple check my messages on LLVM Discord. ;)

[nickdesaulniers]

Squashed up into https://reviews.llvm.org/D151587.

clang/lib/CodeGen/CGExprConstant.cpp

if (Ty->isRecordType())
       }
   }
   InConstantContext = D.hasConstantInitialization();
 
   QualType destType = D.getType();
 
   // Try to emit the initializer.  Note that this can allow some things that
   // are not allowed by tryEmitPrivateForMemory alone.
-  if (auto value = D.evaluateValue()) {
+  if (APValue *value = D.evaluateValue())
     return tryEmitPrivateForMemory(*value, destType);
-  }
 
   // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
   // reference is a constant expression, and the reference binds to a temporary,
   // then constant initialization is performed. ConstExprEmitter will
   // incorrectly emit a prvalue constant in this case, and the calling code
   // interprets that as the (pointer) value of the reference, rather than the
   // desired value of the referee.
   if (destType->isReferenceType())
     return nullptr;
 
   const Expr *E = D.getInit();
   assert(E && "No initializer to emit");
 
-  auto nonMemoryDestType = getNonMemoryType(CGM, destType);
-  auto C =
-    ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), nonMemoryDestType);
-  return (C ? emitForMemory(C, destType) : nullptr);
+  QualType nonMemoryDestType = getNonMemoryType(CGM, destType);
+  if (llvm::Constant *C = ConstExprEmitter(*this).Visit(const_cast<Expr *>(E),
+                                                        nonMemoryDestType))
+    return emitForMemory(C, destType);
+  return nullptr;
 }
 
 llvm::Constant *
 ConstantEmitter::tryEmitAbstractForMemory(const Expr *E, QualType destType) {
   auto nonMemoryDestType = getNonMemoryType(CGM, destType);
   auto C = tryEmitAbstract(E, nonMemoryDestType);
   return (C ? emitForMemory(C, destType) : nullptr);
 }
llvm::Constant *ConstantEmitter::emitForMemory(CodeGenModule &CGM,
 
   return C;
 }
 
 llvm::Constant *ConstantEmitter::tryEmitPrivate(const Expr *E,
                                                 QualType destType) {
   assert(!destType->isVoidType() && "can't emit a void constant");
 
+  if (llvm::Constant *C =
+          ConstExprEmitter(*this).Visit(const_cast<Expr *>(E), destType))
+    return C;
+
   Expr::EvalResult Result;
 
   bool Success = false;
 
   if (destType->isReferenceType())
     Success = E->EvaluateAsLValue(Result, CGM.getContext());
   else
     Success = E->EvaluateAsRValue(Result, CGM.getContext(), InConstantContext);
 
-  llvm::Constant *C;
   if (Success && !Result.HasSideEffects)
-    C = tryEmitPrivate(Result.Val, destType);
-  else
-    C = ConstExprEmitter(*this).Visit(const_cast<Expr*>(E), destType);
+    return tryEmitPrivate(Result.Val, destType);
 
-  return C;
+  return nullptr;
 }
 
 llvm::Constant *CodeGenModule::getNullPointer(llvm::PointerType *T, QualType QT) {
   return getTargetCodeGenInfo().getNullPointer(*this, T, QT);
 }
 
 namespace {
 /// A struct which can be used to peephole certain kinds of finalization