Use ConstantExpr cached APValues if present for code generation

[wchilders]

Summary

This patch allows code gen to use APValue Results from ConstantExprs.

There are some outstanding concerns I'll mark with inline comments.

This is the codegen "sister patch" of: https://reviews.llvm.org/D76438

[wchilders]

clang/lib/CodeGen/CGStmt.cpp

1098

This one is a bit weird, I think the comment explains it well, but I feel there should be a better way to handle this or if there are similar issues lurking elsewhere.

[Tyker]

clang/lib/CodeGen/CGExprConstant.cpp

1871 ↗

(On Diff #251438)

this looks like it is doing the same thing as llvm::Constant *ConstantEmitter::tryEmitAbstract(const APValue &value, QualType T) how is it different ?

[wchilders]

Updated to remove duplicated (and out dated) APValue generation logic, and fixed formatting issues. (Thanks for pointing out something was awry Tyker)

[wchilders]

Abandoned in favor of https://reviews.llvm.org/D76420

clang/include/clang/AST/Expr.h

public:
   static ConstantExpr *CreateEmpty(const ASTContext &Context,
                                    ResultStorageKind StorageKind,
                                    EmptyShell Empty);
 
   static ResultStorageKind getStorageKind(const APValue &Value);
   static ResultStorageKind getStorageKind(const Type *T,
                                           const ASTContext &Context);
 
+  SourceLocation getLocation() const { return getBeginLoc(); }
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return SubExpr->getBeginLoc();
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return SubExpr->getEndLoc();
   }
 
   static bool classof(const Stmt *T) {

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:
-    return EmitLValue(cast<ConstantExpr>(E)->getSubExpr());
+  case Expr::ConstantExprClass: {
+    const ConstantExpr *CE = cast<ConstantExpr>(E);
+
+    if (CE->hasAPValueResult()) {
+      QualType T = getContext().getPointerType(CE->getType());
+      llvm::Constant *C = ConstantEmitter(*this).emitAbstract(
+          CE->getLocation(), CE->getAPValueResult(), T);
+      ConstantAddress Addr(C, getContext().getTypeAlignInChars(T));
+      LValueBaseInfo BI;
+      return LValue::MakeAddr(Addr, T, getContext(), BI, TBAAAccessInfo());
+    }
+
+    return EmitLValue(CE->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) {
-    return Visit(E->getSubExpr());
+    if (E->hasAPValueResult()) {
+      // Create a temporary for the value and store the constant.
+      llvm::Constant *Const = ConstantEmitter(CGF).emitAbstract(
+          E->getLocation(), E->getAPValueResult(), E->getType());
+      Address Addr = CGF.CreateMemTemp(E->getType());
+      CGF.InitTempAlloca(Addr, Const);
+      RValue RV = RValue::getAggregate(Addr);
+      EmitFinalDestCopy(E->getType(), RV);
+    } else {
+      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); }
   void VisitCompoundLiteralExpr(CompoundLiteralExpr *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 (E->hasAPValueResult()) {
+      assert(!E->getType()->isVoidType());
+      return ConstantEmitter(CGF).emitAbstract(
+          E->getLocation(), E->getAPValueResult(), E->getType());
+    } else {
       return Visit(E->getSubExpr());
     }
+  }
   Value *VisitParenExpr(ParenExpr *PE) {
     return Visit(PE->getSubExpr());
   }
   Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
     return Visit(E->getReplacement());
   }
   Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
     return Visit(GE->getResultExpr());

clang/lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
   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)) {
+    // Constant expressions will emit their cached APValues, so
+    // we don't want to handle this here, as it will unwrap them,
+    // preventing the cached results from being used.
+    if (!isa<ConstantExpr>(fe)) {
       enterFullExpression(fe);
       RV = fe->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
     // constructed into the NRVO variable.