Prevent IR-gen from emitting consteval declarations

[Tyker]

Summary

with this patch instead of emitting calls to consteval function. the IR-gen will emit a store of the already computed result.

[Tyker]

rebased

[rsmith]

clang/include/clang/AST/Expr.h

1057

Why do we need to treat indeterminate values specially here? Are we using that value inappropriately in ExprConstant?

clang/lib/AST/ExprConstant.cpp

6779–6780

I don't think this is really right, but perhaps the difference isn't observable right now. What I'm thinking of is a case like this:

consteval int do_stuff() {
  __builtin_produce_diagnostic("hello world\n");
  return 42;
}
constexpr int f() {
  int n = do_stuff();
  return n;
}
int k = f();

Here, I would expect that when we process the immediate invocation of do_stuff() in f, we would immediately evaluate it, including issuing its diagnostic. And then for all subsequent calls to f(), we would never re-evaluate it.

I can see a couple of ways this could work:

• Whenever we create a ConstantExpr, we always evaluate it and fill in the APValue result; it's never absent except perhaps in a window of time between forming that AST node and deciding for sure that we want to keep it (for nested immediate invocation handling).
• Whenever constant evaluation meets a ConstantExpr that doesn't have an associated result yet, it triggers that result to be computed and cached, as a separate evaluation.

I think the first of those two approaches is much better: lazily evaluating the ConstantExpr will require us to save update records if we're writing an AST file, and will mean we don't always have an obvious point where the side-effects from builtin consteval functions (eg, reflection-driven actions) happen.

So I think the right thing to do is probably to say that a ConstantExpr that hasn't yet had its APValue result filled in is non-constant for now, and to ensure that everywhere that creates a ConstantExpr always eventually either removes it again or fills in the result.

10706–10711

This override looks equivalent to the base class version. (The only difference appears to be whether IsConstantContext is set during the call to Success, but I don't think Success cares about that flag.) Can you remove this override?

clang/lib/CodeGen/CGExprConstant.cpp

1355–1356

I'm fine with having this check for now, but eventually I think we should do this for all ConstantExprs, regardless of whether they're immediate invocations.

1365

Can we assert that we succeeded here? This emission should never fail.

clang/lib/CodeGen/CGExprScalar.cpp

437–443

OK, so this is presumably handling the case where ScalarExprEmitter is used to emit an lvalue expression, under the understanding that when it reaches the eventual lvalue a load will be implicitly generated.

Looking for a CallExpr that returns a reference type is not the best way to handle this. It's brittle (it would break if tryEmitConstantExpr starts emitting more kinds of ConstantExpr or if we start supporting more kinds of immediate invocations) and we don't need to perform such a subtle check: instead, please just check whether E is an lvalue, and perform a load if so.

clang/lib/CodeGen/CGStmt.cpp

1092

Presumably it's OK to skip this for ConstantExpr because by definition the ConstantExpr node isn't tracking any block cleanups. If that's the case, should we rename this to enterExprWithCleanups and change it to take an ExprWithCleanups* rather than a FullExpr*?

clang/test/SemaCXX/cxx2a-consteval.cpp

1

Use -emit-llvm-only instead of -emit-llvm > /dev/null if you want to make sure that emission succeeds but don't want to check the IR.

[Tyker]

addressed comments

[Tyker]

clang/lib/AST/ExprConstant.cpp

6779–6780

ok seems reasonable.

clang/lib/CodeGen/CGExprConstant.cpp

1355–1356

this can be relaxed to hasAPValueResult without any change in behavior.

1365

from the comment on emitAbstract's declaration it seems to already be the case.

/// Emit the result of the given expression as an abstract constant,
/// asserting that it succeeded.  This is only safe to do when the
/// expression is known to be a constant expression with either a fairly
/// simple type or a known simple form.
llvm::Constant *emitAbstract(const Expr *E, QualType T);
llvm::Constant *emitAbstract(SourceLocation loc, const APValue &value,
                             QualType T);

clang/lib/CodeGen/CGExprScalar.cpp

437–443

we need to generate a load for rvalue-reference as well so i think we need to check wether E is a glvalue instead of just lvalue.

[Tyker]

[Tyker]

NFC

[rsmith]

Thanks! Looks good.

I'd like to eventually get to a point where every ConstantExpr that reaches code generation has hasAPValueResult() return true, but that doesn't need to be done now.

clang/lib/AST/ExprConstant.cpp

6779–6780

OK, so we're still evaluating through a not-yet-evaluated immediate invocation. This is subtle, but I think it's correct: when this happens, either we're in some enclosing immediate invocation, in which case we want to perform any side-effects from inside this ConstantExpr, or we're not, in which case those side-effects should be prohibited anyway.

clang/lib/CodeGen/CGExprConstant.cpp

1365

Given that this function can return nullptr on other control paths, I think it would be useful (as documentation of the intent) to assert(Res); here, even if emitAbstract already guarantees that.

clang/include/clang/AST/Expr.h

APValue::ValueKind getResultAPValueKind() const {
     return static_cast<APValue::ValueKind>(ConstantExprBits.APValueKind);
   }
   ResultStorageKind getResultStorageKind() const {
     return static_cast<ResultStorageKind>(ConstantExprBits.ResultKind);
   }
   bool isImmediateInvocation() const {
     return ConstantExprBits.IsImmediateInvocation;
   }
+  bool hasValue() const {
+    return ConstantExprBits.APValueKind != APValue::None &&
+           ConstantExprBits.APValueKind != APValue::Indeterminate;
+  }
+
   APValue getAPValueResult() const;
   APValue &getResultAsAPValue() const { return APValueResult(); }
   llvm::APSInt getResultAsAPSInt() const;
   // Iterators
   child_range children() { return child_range(&SubExpr, &SubExpr+1); }
   const_child_range children() const {
     return const_child_range(&SubExpr, &SubExpr + 1);
   }

clang/lib/AST/Expr.cpp

if (T->isIntegralOrEnumerationType() && Context.getTypeInfo(T).Width <= 64)
     return ConstantExpr::RSK_Int64;
   return ConstantExpr::RSK_APValue;
 }
 
 void ConstantExpr::DefaultInit(ResultStorageKind StorageKind) {
   ConstantExprBits.ResultKind = StorageKind;
   ConstantExprBits.APValueKind = APValue::None;
   ConstantExprBits.HasCleanup = false;
+  ConstantExprBits.IsImmediateInvocation = false;
   if (StorageKind == ConstantExpr::RSK_APValue)
     ::new (getTrailingObjects<APValue>()) APValue();
 }
 
 ConstantExpr::ConstantExpr(Expr *subexpr, ResultStorageKind StorageKind)
     : FullExpr(ConstantExprClass, subexpr) {
   DefaultInit(StorageKind);
 }
static Expr *IgnoreParensSingleStep(Expr *E) {
   }
 
   else if (auto *CE = dyn_cast<ChooseExpr>(E)) {
     if (!CE->isConditionDependent())
       return CE->getChosenSubExpr();
   }
 
   else if (auto *CE = dyn_cast<ConstantExpr>(E))
+    if (!CE->hasValue())
       return CE->getSubExpr();
 
   return E;
 }
 
 static Expr *IgnoreNoopCastsSingleStep(const ASTContext &Ctx, Expr *E) {
   if (auto *CE = dyn_cast<CastExpr>(E)) {
     // We ignore integer <-> casts that are of the same width, ptr<->ptr and
     // ptr<->int casts of the same width. We also ignore all identity casts.

clang/lib/AST/ExprConstant.cpp

public:
 
   bool VisitStmt(const Stmt *) {
     llvm_unreachable("Expression evaluator should not be called on stmts");
   }
   bool VisitExpr(const Expr *E) {
     return Error(E);
   }
 
-  bool VisitConstantExpr(const ConstantExpr *E)
-    { return StmtVisitorTy::Visit(E->getSubExpr()); }
+  bool VisitConstantExpr(const ConstantExpr *E) {
+    llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext, true);
+    if (E->hasValue())
+      return DerivedSuccess(E->getAPValueResult(), E);
+    return StmtVisitorTy::Visit(E->getSubExpr());
+  }
+
   bool VisitParenExpr(const ParenExpr *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
   bool VisitUnaryExtension(const UnaryOperator *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
   bool VisitUnaryPlus(const UnaryOperator *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
   bool VisitChooseExpr(const ChooseExpr *E)
     { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
   // write to/read from.
   if (EndOffset <= LVal.getLValueOffset())
     Size = 0;
   else
     Size = (EndOffset - LVal.getLValueOffset()).getQuantity();
   return true;
 }
 
 bool IntExprEvaluator::VisitConstantExpr(const ConstantExpr *E) {
   llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext, true);
-  if (E->getResultAPValueKind() != APValue::None)
+  if (E->hasValue())
     return Success(E->getAPValueResult(), E);
   return ExprEvaluatorBaseTy::VisitConstantExpr(E);
 }
 
 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
   if (unsigned BuiltinOp = E->getBuiltinCallee())
     return VisitBuiltinCallExpr(E, BuiltinOp);
 
   return ExprEvaluatorBaseTy::VisitCallExpr(E);
 }
 

clang/lib/CodeGen/CGCall.cpp

CGF.Builder.CreateMemCpy(Casted, SrcCasted,
       false);
   return CGF.Builder.CreateLoad(Tmp);
 }
 
 // Function to store a first-class aggregate into memory.  We prefer to
 // store the elements rather than the aggregate to be more friendly to
 // fast-isel.
 // FIXME: Do we need to recurse here?
-static void BuildAggStore(CodeGenFunction &CGF, llvm::Value *Val,
-                          Address Dest, bool DestIsVolatile) {
+void CodeGenFunction::EmitAggregateStore(llvm::Value *Val, Address Dest,
+                                         bool DestIsVolatile) {
   // Prefer scalar stores to first-class aggregate stores.
-  if (llvm::StructType *STy =
-        dyn_cast<llvm::StructType>(Val->getType())) {
+  if (llvm::StructType *STy = dyn_cast<llvm::StructType>(Val->getType())) {
     for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
-      Address EltPtr = CGF.Builder.CreateStructGEP(Dest, i);
-      llvm::Value *Elt = CGF.Builder.CreateExtractValue(Val, i);
-      CGF.Builder.CreateStore(Elt, EltPtr, DestIsVolatile);
+      Address EltPtr = Builder.CreateStructGEP(Dest, i);
+      llvm::Value *Elt = Builder.CreateExtractValue(Val, i);
+      Builder.CreateStore(Elt, EltPtr, DestIsVolatile);
     }
   } else {
-    CGF.Builder.CreateStore(Val, Dest, DestIsVolatile);
+    Builder.CreateStore(Val, Dest, DestIsVolatile);
   }
 }
 
 /// CreateCoercedStore - Create a store to \arg DstPtr from \arg Src,
 /// where the source and destination may have different types.  The
 /// destination is known to be aligned to \arg DstAlign bytes.
 ///
 /// This safely handles the case when the src type is larger than the
if ((isa<llvm::IntegerType>(SrcTy) || isa<llvm::PointerType>(SrcTy)) &&
     return;
   }
 
   uint64_t DstSize = CGF.CGM.getDataLayout().getTypeAllocSize(DstTy);
 
   // If store is legal, just bitcast the src pointer.
   if (SrcSize <= DstSize) {
     Dst = CGF.Builder.CreateElementBitCast(Dst, SrcTy);
-    BuildAggStore(CGF, Src, Dst, DstIsVolatile);
+    CGF.EmitAggregateStore(Src, Dst, DstIsVolatile);
   } else {
     // Otherwise do coercion through memory. This is stupid, but
     // simple.
 
     // Generally SrcSize is never greater than DstSize, since this means we are
     // losing bits. However, this can happen in cases where the structure has
     // additional padding, for example due to a user specified alignment.
     //
case ABIArgInfo::Direct: {
         case TEK_Aggregate: {
           Address DestPtr = ReturnValue.getValue();
           bool DestIsVolatile = ReturnValue.isVolatile();
 
           if (!DestPtr.isValid()) {
             DestPtr = CreateMemTemp(RetTy, "agg.tmp");
             DestIsVolatile = false;
           }
-          BuildAggStore(*this, CI, DestPtr, DestIsVolatile);
+          EmitAggregateStore(CI, DestPtr, DestIsVolatile);
           return RValue::getAggregate(DestPtr);
         }
         case TEK_Scalar: {
           // If the argument doesn't match, perform a bitcast to coerce it.  This
           // can happen due to trivial type mismatches.
           llvm::Value *V = CI;
           if (V->getType() != RetIRTy)
             V = Builder.CreateBitCast(V, RetIRTy);

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitLValue(const Expr *E) {
   case Expr::UserDefinedLiteralClass:
     return EmitCallExprLValue(cast<CallExpr>(E));
   case Expr::CXXRewrittenBinaryOperatorClass:
     return EmitLValue(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());
   case Expr::VAArgExprClass:
     return EmitVAArgExprLValue(cast<VAArgExpr>(E));
   case Expr::DeclRefExprClass:
     return EmitDeclRefLValue(cast<DeclRefExpr>(E));
-  case Expr::ConstantExprClass:
+  case Expr::ConstantExprClass: {
+    const ConstantExpr *CE = cast<ConstantExpr>(E);
+    if (llvm::Value *Result = ConstantEmitter(*this).tryEmitConstantExpr(CE)) {
+      QualType RetType = cast<CallExpr>(CE->getSubExpr()->IgnoreImplicit())
+                             ->getCallReturnType(getContext());
+      return MakeNaturalAlignAddrLValue(Result, RetType);
+    }
     return EmitLValue(cast<ConstantExpr>(E)->getSubExpr());
+  }
   case Expr::ParenExprClass:
     return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
   case Expr::GenericSelectionExprClass:
     return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
   case Expr::PredefinedExprClass:
     return EmitPredefinedLValue(cast<PredefinedExpr>(E));
   case Expr::StringLiteralClass:
     return EmitStringLiteralLValue(cast<StringLiteral>(E));

clang/lib/CodeGen/CGExprAgg.cpp

public:
   }
   void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
   void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
   void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
     return Visit(E->getReplacement());
   }
 
   void VisitConstantExpr(ConstantExpr *E) {
+    if (llvm::Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
+      CGF.EmitAggregateStore(Result, Dest.getAddress(),
+                             E->getType().isVolatileQualified());
+      return;
+    }
     return Visit(E->getSubExpr());
   }
 
   // l-values.
   void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
   void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
   void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
   void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }

clang/lib/CodeGen/CGExprComplex.cpp

 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This contains code to emit Expr nodes with complex types as LLVM code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CGOpenMPRuntime.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
+#include "ConstantEmitter.h"
 #include "clang/AST/StmtVisitor.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Metadata.h"
 #include <algorithm>
 using namespace clang;
public:
   }
 
   ComplexPairTy VisitStmt(Stmt *S) {
     S->dump(CGF.getContext().getSourceManager());
     llvm_unreachable("Stmt can't have complex result type!");
   }
   ComplexPairTy VisitExpr(Expr *S);
   ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
+    if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E))
+      return ComplexPairTy(Result->getAggregateElement(0U),
+                           Result->getAggregateElement(1U));
     return Visit(E->getSubExpr());
   }
   ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
   ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
     return Visit(GE->getResultExpr());
   }
   ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
   ComplexPairTy

clang/lib/CodeGen/CGExprConstant.cpp

public:
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
 
   llvm::Constant *VisitStmt(Stmt *S, QualType T) {
     return nullptr;
   }
 
   llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) {
+    if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(CE))
+      return Result;
     return Visit(CE->getSubExpr(), T);
   }
 
   llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
     return Visit(PE->getSubExpr(), T);
   }
 
   llvm::Constant *

 
 llvm::Constant *
 ConstantEmitter::tryEmitAbstract(const APValue &value, QualType destType) {
   auto state = pushAbstract();
   auto C = tryEmitPrivate(value, destType);
   return validateAndPopAbstract(C, state);
 }
 
+llvm::Constant *ConstantEmitter::tryEmitConstantExpr(const ConstantExpr *CE) {
+  if (!CE->isImmediateInvocation())
+    return nullptr;
+  const Expr *Inner = CE->getSubExpr()->IgnoreImplicit();
+  QualType RetType;
+  if (auto *Call = dyn_cast<CallExpr>(Inner))
+    RetType = Call->getCallReturnType(CGF->getContext());
+  else if (auto *Ctor = dyn_cast<CXXConstructExpr>(Inner))
+    RetType = Ctor->getType();
+  llvm::Constant *Res =
+      emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(), RetType);
+  return Res;
+}
+
 llvm::Constant *
 ConstantEmitter::emitAbstract(const Expr *E, QualType destType) {
   auto state = pushAbstract();
   auto C = tryEmitPrivate(E, destType);
   C = validateAndPopAbstract(C, state);
   if (!C) {
     CGM.Error(E->getExprLoc(),
               "internal error: could not emit constant value \"abstractly\"");
ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
   }
 
   // Otherwise, it must be an expression.
   return Visit(base.get<const Expr*>());
 }
 
 ConstantLValue
 ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) {
+  if (llvm::Constant *Result = Emitter.tryEmitConstantExpr(E))
+    return Result;
   return Visit(E->getSubExpr());
 }
 
 ConstantLValue
 ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
   return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E);
 }
 

clang/lib/CodeGen/CGExprScalar.cpp

public:
 
   Value *VisitStmt(Stmt *S) {
     S->dump(CGF.getContext().getSourceManager());
     llvm_unreachable("Stmt can't have complex result type!");
   }
   Value *VisitExpr(Expr *S);
 
   Value *VisitConstantExpr(ConstantExpr *E) {
+    if (Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
+      QualType RetType = cast<CallExpr>(E->getSubExpr()->IgnoreImplicit())
+                             ->getCallReturnType(CGF.getContext());
+      if (RetType->isReferenceType()) {
+        return CGF.Builder.CreateLoad(Address(
+            Result, CGF.getContext().getTypeAlignInChars(
+                        cast<ReferenceType>(RetType)->getPointeeType())));
+      }
+      return Result;
+    }
     return Visit(E->getSubExpr());
   }
   Value *VisitParenExpr(ParenExpr *PE) {
     return Visit(PE->getSubExpr());
   }
   Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
     return Visit(E->getReplacement());
   }

clang/lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
   // Emit the result value, even if unused, to evaluate the side effects.
   const Expr *RV = S.getRetValue();
 
   // Treat block literals in a return expression as if they appeared
   // in their own scope.  This permits a small, easily-implemented
   // exception to our over-conservative rules about not jumping to
   // statements following block literals with non-trivial cleanups.
   RunCleanupsScope cleanupScope(*this);
-  if (const FullExpr *fe = dyn_cast_or_null<FullExpr>(RV)) {
-    enterFullExpression(fe);
-    RV = fe->getSubExpr();
+  if (const auto *EWC = dyn_cast_or_null<ExprWithCleanups>(RV)) {
+    enterFullExpression(EWC);
+    RV = EWC->getSubExpr();
   }
 
   // FIXME: Clean this up by using an LValue for ReturnTemp,
   // EmitStoreThroughLValue, and EmitAnyExpr.
   if (getLangOpts().ElideConstructors &&
       S.getNRVOCandidate() && S.getNRVOCandidate()->isNRVOVariable()) {
     // Apply the named return value optimization for this return statement,
     // which means doing nothing: the appropriate result has already been

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// of aggregate type.  The result is computed into the given slot,
   /// which may be null to indicate that the value is not needed.
   void EmitAggExpr(const Expr *E, AggValueSlot AS);
 
   /// EmitAggExprToLValue - Emit the computation of the specified expression of
   /// aggregate type into a temporary LValue.
   LValue EmitAggExprToLValue(const Expr *E);
 
+  /// Build all the stores needed to initialize an aggregate at Dest with the
+  /// value Val.
+  void EmitAggregateStore(llvm::Value *Val, Address Dest, bool DestIsVolatile);
+
   /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
   /// make sure it survives garbage collection until this point.
   void EmitExtendGCLifetime(llvm::Value *object);
 
   /// EmitComplexExpr - Emit the computation of the specified expression of
   /// complex type, returning the result.
   ComplexPairTy EmitComplexExpr(const Expr *E,
                                 bool IgnoreReal = false,

clang/lib/CodeGen/CodeGenModule.cpp

 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
 /// non-null, then this function will use the specified type if it has to
 /// create it (this occurs when we see a definition of the function).
 llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
                                                  llvm::Type *Ty,
                                                  bool ForVTable,
                                                  bool DontDefer,
                                               ForDefinition_t IsForDefinition) {
+  assert(!cast<FunctionDecl>(GD.getDecl())->isConsteval() &&
+         "consteval function should never be emitted");
   // If there was no specific requested type, just convert it now.
   if (!Ty) {
     const auto *FD = cast<FunctionDecl>(GD.getDecl());
     Ty = getTypes().ConvertType(FD->getType());
   }
 
   // Devirtualized destructor calls may come through here instead of via
   // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead

 }
 
 /// EmitTopLevelDecl - Emit code for a single top level declaration.
 void CodeGenModule::EmitTopLevelDecl(Decl *D) {
   // Ignore dependent declarations.
   if (D->isTemplated())
     return;
 
+  // Consteval function shouldn't be emitted.
+  if (auto *FD = dyn_cast<FunctionDecl>(D))
+    if (FD->isConsteval())
+      return;
+
   switch (D->getKind()) {
   case Decl::CXXConversion:
   case Decl::CXXMethod:
   case Decl::Function:
     EmitGlobal(getGlobalDecl(cast<FunctionDecl>(D)));
     // Always provide some coverage mapping
     // even for the functions that aren't emitted.
     AddDeferredUnusedCoverageMapping(D);

clang/lib/CodeGen/ConstantEmitter.h

public:
 
   /// Try to emit the result of the given expression as an abstract constant.
   llvm::Constant *tryEmitAbstract(const Expr *E, QualType T);
   llvm::Constant *tryEmitAbstractForMemory(const Expr *E, QualType T);
 
   llvm::Constant *tryEmitAbstract(const APValue &value, QualType T);
   llvm::Constant *tryEmitAbstractForMemory(const APValue &value, QualType T);
 
+  llvm::Constant *tryEmitConstantExpr(const ConstantExpr *CE);
+
   llvm::Constant *emitNullForMemory(QualType T) {
     return emitNullForMemory(CGM, T);
   }
   llvm::Constant *emitForMemory(llvm::Constant *C, QualType T) {
     return emitForMemory(CGM, C, T);
   }
 
   static llvm::Constant *emitNullForMemory(CodeGenModule &CGM, QualType T);

clang/lib/Sema/SemaExpr.cpp

if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
     if (auto *DeclRef =
             dyn_cast<DeclRefExpr>(Call->getCallee()->IgnoreImplicit()))
       ExprEvalContexts.back().ReferenceToConsteval.erase(DeclRef);
 
   E = MaybeCreateExprWithCleanups(E);
 
   ConstantExpr *Res = ConstantExpr::Create(
       getASTContext(), E.get(),
-      ConstantExpr::getStorageKind(E.get()->getType().getTypePtr(),
+      ConstantExpr::getStorageKind(Decl->getReturnType().getTypePtr(),
                                    getASTContext()),
       /*IsImmediateInvocation*/ true);
   ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
   return Res;
 }
 
 static void EvaluateAndDiagnoseImmediateInvocation(
     Sema &SemaRef, Sema::ImmediateInvocationCandidate Candidate) {

clang/test/CodeGenCXX/cxx2a-consteval.cpp

+// NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+// RUN: %clang_cc1 -emit-llvm %s -std=c++2a -o %t.ll
+// RUN: FileCheck -check-prefix=EVAL -input-file=%t.ll %s
+// RUN: FileCheck -check-prefix=EVAL-FN -input-file=%t.ll %s
+// RUN: FileCheck -check-prefix=EVAL-STATIC -input-file=%t.ll %s
+// RUN: %clang_cc1 -emit-llvm %s -Dconsteval="" -std=c++2a -o %t.ll
+// RUNA: FileCheck -check-prefix=EXPR -input-file=%t.ll %s
+
+// there is two version of symbol checks to ensure
+// that the symbol we are looking for are correct
+// EVAL-NOT: @__cxx_global_var_init()
+// EXPR: @__cxx_global_var_init()
+
+// EVAL-NOT: @_Z4ret7v()
+// EXPR: @_Z4ret7v()
+consteval int ret7() {
+  return 7;
+}
+
+int test_ret7() {
+// EVAL-FN-LABEL: @_Z9test_ret7v(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[I:%.*]] = alloca i32, align 4
+// EVAL-FN-NEXT:    store i32 7, i32* [[I]], align 4
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = load i32, i32* [[I]], align 4
+// EVAL-FN-NEXT:    ret i32 [[TMP0]]
+//
+  int i = ret7();
+  return i;
+}
+
+// EVAL-STATIC: @global_i = global i32 7, align 4
+int global_i = ret7();
+
+// EVAL-STATIC: @_ZL7i_const = internal constant i32 5, align 4
+constexpr int i_const = 5;
+
+// EVAL-NOT: @_Z4retIv()
+// EXPR: @_Z4retIv()
+consteval const int& retI() {
+  return i_const;
+}
+
+const int& test_retRefI() {
+// EVAL-FN-LABEL: @_Z12test_retRefIv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    ret i32* @_ZL7i_const
+//
+  return retI();
+}
+
+int test_retI() {
+// EVAL-FN-LABEL: @_Z9test_retIv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = load i32, i32* @_ZL7i_const, align 4
+// EVAL-FN-NEXT:    ret i32 [[TMP0]]
+//
+  return retI();
+}
+
+// EVAL-NOT: @_Z4retIv()
+// EXPR: @_Z4retIv()
+consteval const int* retIPtr() {
+  return &i_const;
+}
+
+int test_retIPtr() {
+// EVAL-FN-LABEL: @_Z12test_retIPtrv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = load i32, i32* @_ZL7i_const, align 4
+// EVAL-FN-NEXT:    ret i32 [[TMP0]]
+//
+  return *retIPtr();
+}
+
+const int* test_retPIPtr() {
+// EVAL-FN-LABEL: @_Z13test_retPIPtrv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    ret i32* @_ZL7i_const
+//
+  return retIPtr();
+}
+
+// EVAL-NOT: @_Z4retIv()
+// EXPR: @_Z4retIv()
+consteval const int&& retIRRef() {
+  return static_cast<const int&&>(i_const);
+}
+
+// EVAL-NOT: @_Z4retIv()
+// EXPR: @_Z4retIv()
+const int&& test_retIRRef() {
+  return static_cast<const int&&>(retIRRef());
+}
+
+int test_retIRRefI() {
+// EVAL-FN-LABEL: @_Z14test_retIRRefIv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = load i32, i32* @_ZL7i_const, align 4
+// EVAL-FN-NEXT:    ret i32 [[TMP0]]
+//
+  return retIRRef();
+}
+
+struct Agg {
+  int a;
+  long b;
+};
+
+// EVAL-NOT: @_Z6retAggv()
+// EXPR: @_Z6retAggv()
+consteval Agg retAgg() {
+  return {13, 17};
+}
+
+long test_retAgg() {
+// EVAL-FN-LABEL: @_Z11test_retAggv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[B:%.*]] = alloca i64, align 8
+// EVAL-FN-NEXT:    [[REF_TMP:%.*]] = alloca [[STRUCT_AGG:%.*]], align 8
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 0
+// EVAL-FN-NEXT:    store i32 13, i32* [[TMP0]], align 8
+// EVAL-FN-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 1
+// EVAL-FN-NEXT:    store i64 17, i64* [[TMP1]], align 8
+// EVAL-FN-NEXT:    store i64 17, i64* [[B]], align 8
+// EVAL-FN-NEXT:    [[TMP2:%.*]] = load i64, i64* [[B]], align 8
+// EVAL-FN-NEXT:    ret i64 [[TMP2]]
+//
+  long b = retAgg().b;
+  return b;
+}
+
+// EVAL-STATIC: @A = global %struct.Agg { i32 13, i64 17 }, align 8
+Agg A = retAgg();
+
+// EVAL-NOT: @_Z9retRefAggv()
+// EXPR: @_Z9retRefAggv()
+consteval const Agg& retRefAgg() {
+  const Agg& tmp = A;
+  return A;
+}
+
+long test_retRefAgg() {
+// EVAL-FN-LABEL: @_Z14test_retRefAggv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[B:%.*]] = alloca i64, align 8
+// EVAL-FN-NEXT:    [[REF_TMP:%.*]] = alloca [[STRUCT_AGG:%.*]], align 8
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 0
+// EVAL-FN-NEXT:    store i32 13, i32* [[TMP0]], align 8
+// EVAL-FN-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 1
+// EVAL-FN-NEXT:    store i64 17, i64* [[TMP1]], align 8
+// EVAL-FN-NEXT:    store i64 17, i64* [[B]], align 8
+// EVAL-FN-NEXT:    [[TMP2:%.*]] = load i64, i64* [[B]], align 8
+// EVAL-FN-NEXT:    ret i64 [[TMP2]]
+//
+  long b = retAgg().b;
+  return b;
+}
+
+// EVAL-NOT: define i64@_Z7is_constv()
+// EXPR: : define i64 @_Z7is_constv()
+consteval Agg is_const() {
+  return {5, 19 * __builtin_is_constant_evaluated()};
+}
+
+long test_is_const() {
+// EVAL-FN-LABEL: @_Z13test_is_constv(
+// EVAL-FN-NEXT:  entry:
+// EVAL-FN-NEXT:    [[B:%.*]] = alloca i64, align 8
+// EVAL-FN-NEXT:    [[REF_TMP:%.*]] = alloca [[STRUCT_AGG:%.*]], align 8
+// EVAL-FN-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 0
+// EVAL-FN-NEXT:    store i32 5, i32* [[TMP0]], align 8
+// EVAL-FN-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_AGG]], %struct.Agg* [[REF_TMP]], i32 0, i32 1
+// EVAL-FN-NEXT:    store i64 19, i64* [[TMP1]], align 8
+// EVAL-FN-NEXT:    store i64 19, i64* [[B]], align 8
+// EVAL-FN-NEXT:    [[TMP2:%.*]] = load i64, i64* [[B]], align 8
+// EVAL-FN-NEXT:    ret i64 [[TMP2]]
+//
+  long b = is_const().b;
+  return b;
+}
+
+// EVAL-NOT: @_ZN7AggCtorC
+// EXPR: @_ZN7AggCtorC
+struct AggCtor {
+  consteval AggCtor(int a = 3, long b = 5) : a(a * a), b(a * b) {}
+  int a;
+  long b;
+};
+
+long test_AggCtor() {
+// CHECK-LABEL: @_Z12test_AggCtorv(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[I:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[C:%.*]] = alloca [[STRUCT_AGGCTOR:%.*]], align 8
+// CHECK-NEXT:    store i32 2, i32* [[I]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds [[STRUCT_AGGCTOR]], %struct.AggCtor* [[C]], i32 0, i32 0
+// CHECK-NEXT:    store i32 4, i32* [[TMP0]], align 8
+// CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_AGGCTOR]], %struct.AggCtor* [[C]], i32 0, i32 1
+// CHECK-NEXT:    store i64 10, i64* [[TMP1]], align 8
+// CHECK-NEXT:    [[A:%.*]] = getelementptr inbounds [[STRUCT_AGGCTOR]], %struct.AggCtor* [[C]], i32 0, i32 0
+// CHECK-NEXT:    [[TMP2:%.*]] = load i32, i32* [[A]], align 8
+// CHECK-NEXT:    [[CONV:%.*]] = sext i32 [[TMP2]] to i64
+// CHECK-NEXT:    [[B:%.*]] = getelementptr inbounds [[STRUCT_AGGCTOR]], %struct.AggCtor* [[C]], i32 0, i32 1
+// CHECK-NEXT:    [[TMP3:%.*]] = load i64, i64* [[B]], align 8
+// CHECK-NEXT:    [[ADD:%.*]] = add nsw i64 [[CONV]], [[TMP3]]
+// CHECK-NEXT:    ret i64 [[ADD]]
+//
+  const int i = 2;
+  AggCtor C(i);
+  return C.a + C.b;
+}

clang/test/SemaCXX/cxx2a-consteval.cpp

-// RUN: %clang_cc1 -std=c++2a -fsyntax-only -Wno-unused-value %s -verify
+// RUN: %clang_cc1 -std=c++2a -emit-llvm -Wno-unused-value %s -verify > /dev/null
 
 typedef __SIZE_TYPE__ size_t;
 
 namespace basic_sema {
 
 consteval int f1(int i) {
   return i;
 }