[NOT FOR REVIEW] Add a cache for constexpr function calls

[ChuanqiXu]

Summary

Try to address https://github.com/llvm/llvm-project/issues/61425.

There are multiple issues. See the above link for details.

clang/include/clang/AST/ASTContext.h

class ASTContext : public RefCountedBase<ASTContext> {
   mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
   mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
   mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
     SubstTemplateTemplateParms;
   mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
                                      ASTContext&>
     SubstTemplateTemplateParmPacks;
 
+  mutable llvm::DenseMap<unsigned, APValue> ExprEvalResultCache;
+
   /// The set of nested name specifiers.
   ///
   /// This set is managed by the NestedNameSpecifier class.
   mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
   mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;
 
   /// A cache mapping from RecordDecls to ASTRecordLayouts.
   ///
bool hasSameType(QualType T1, QualType T2) const {
     return getCanonicalType(T1) == getCanonicalType(T2);
   }
   bool hasSameType(const Type *T1, const Type *T2) const {
     return getCanonicalType(T1) == getCanonicalType(T2);
   }
 
   /// Determine whether the given expressions \p X and \p Y are equivalent.
   bool hasSameExpr(const Expr *X, const Expr *Y) const;
+  bool getCachedEvaluated(const Expr *X, APValue &Result) const;
+  void addExprResultToCache(const Expr *X, APValue &Result) const;
 
   /// Return this type as a completely-unqualified array type,
   /// capturing the qualifiers in \p Quals.
   ///
   /// This will remove the minimal amount of sugaring from the types, similar
   /// to the behavior of QualType::getUnqualifiedType().
   ///
   /// \param T is the qualified type, which may be an ArrayType

clang/lib/AST/ASTContext.cpp

 #include "clang/AST/ExprConcepts.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/Mangle.h"
 #include "clang/AST/MangleNumberingContext.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/ParentMapContext.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/RecordLayout.h"
+#include "clang/AST/ODRHash.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/AddressSpaces.h"
bool ASTContext::hasSameExpr(const Expr *X, const Expr *Y) const {
   if (!X || !Y)
     return false;
   llvm::FoldingSetNodeID IDX, IDY;
   X->Profile(IDX, *this, /*Canonical=*/true);
   Y->Profile(IDY, *this, /*Canonical=*/true);
   return IDX == IDY;
 }
 
+bool ASTContext::getCachedEvaluated(const Expr *X, APValue &Result) const {
+  assert (X && "We shouldn't evaluate on null expr.\n");
+
+  auto *CE = dyn_cast<CallExpr>(X);
+  if (!CE)
+    return false;
+  
+  auto *FD = CE->getDirectCallee();
+  if (!FD || !FD->isConstexpr())
+    return false;
+
+  llvm::FoldingSetNodeID ID;
+  X->Profile(ID, *this, /*Canonical=*/true);
+  unsigned HashValue = llvm::hash_combine(ID.ComputeHash(), const_cast<FunctionDecl*>(FD)->getODRHash());
+
+  auto Iter = ExprEvalResultCache.find(HashValue);
+  if (Iter == ExprEvalResultCache.end())
+    return false;
+
+  Result = Iter->second;
+  assert(Result.hasValue());
+  return true;
+}
+
+void ASTContext::addExprResultToCache(const Expr *X, APValue &Result) const {
+  if (!Result.hasValue())
+    return;
+
+  auto *CE = dyn_cast<CallExpr>(X);
+  if (!CE)
+    return;
+  
+  auto *FD = CE->getDirectCallee();
+  if (!FD || !FD->isConstexpr())
+    return;
+
+  assert (X && "We shouldn't evaluate on null expr.\n");
+  llvm::FoldingSetNodeID ID;
+  X->Profile(ID, *this, /*Canonical=*/true);
+  unsigned HashValue = llvm::hash_combine(ID.ComputeHash(), const_cast<FunctionDecl*>(FD)->getODRHash());
+
+  auto Iter = ExprEvalResultCache.find(HashValue);
+  assert(Iter == ExprEvalResultCache.end());
+  ExprEvalResultCache.insert({HashValue, Result});
+}
+
 // The getCommon* helpers return, for given 'same' X and Y entities given as
 // inputs, another entity which is also the 'same' as the inputs, but which
 // is closer to the canonical form of the inputs, each according to a given
 // criteria.
 // The getCommon*Checked variants are 'null inputs not-allowed' equivalents of
 // the regular ones.
 
 static Decl *getCommonDecl(Decl *X, Decl *Y) {

clang/lib/AST/ExprConstant.cpp

EvalInfo Info(Ctx, EStatus,
                     ? EvalInfo::EM_ConstantExpression
                     : EvalInfo::EM_ConstantFold);
   Info.setEvaluatingDecl(VD, Value);
   Info.InConstantContext = IsConstantInitialization;
 
   SourceLocation DeclLoc = VD->getLocation();
   QualType DeclTy = VD->getType();
 
+  if (Ctx.getCachedEvaluated(this, Value))
+    return CheckConstantExpression(Info, DeclLoc, DeclTy, Value,
+                                 ConstantExprKind::Normal) &&
+           CheckMemoryLeaks(Info);
+
   if (Info.EnableNewConstInterp) {
     auto &InterpCtx = const_cast<ASTContext &>(Ctx).getInterpContext();
     if (!InterpCtx.evaluateAsInitializer(Info, VD, Value))
       return false;
   } else {
     LValue LVal;
     LVal.set(VD);
 
     if (!EvaluateInPlace(Value, Info, LVal, this,
                          /*AllowNonLiteralTypes=*/true) ||
         EStatus.HasSideEffects)
       return false;
 
     // At this point, any lifetime-extended temporaries are completely
     // initialized.
     Info.performLifetimeExtension();
 
     if (!Info.discardCleanups())
       llvm_unreachable("Unhandled cleanup; missing full expression marker?");
   }
-  return CheckConstantExpression(Info, DeclLoc, DeclTy, Value,
+  auto Ret = CheckConstantExpression(Info, DeclLoc, DeclTy, Value,
                                  ConstantExprKind::Normal) &&
          CheckMemoryLeaks(Info);
+
+  if (Ret && Value.hasValue())
+    Ctx.addExprResultToCache(this, Value);
+
+  return Ret;
 }
 
 bool VarDecl::evaluateDestruction(
     SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
   Expr::EvalStatus EStatus;
   EStatus.Diag = &Notes;
 
   // Only treat the destruction as constant destruction if we formally have