[WIP][AST] Allow ExprConstant to evaluate structs in C.

[efriedma]

Summary

Just a proof of concept to show this works. Handles all the examples from D76096, as far as I can tell.

[nickdesaulniers]

Looks like @erichkeane was in the neighborhood in 606a734755d1fb6c35a17680d0c251f834b79334 ("[PR47636] Fix tryEmitPrivate to handle non-constantarraytypes").

[tomhughes]

I took the tests from https://reviews.llvm.org/D76096 and combined it with this change. As mentioned in the last comment 606a734755d1fb6c35a17680d0c251f834b79334 causes conflicts, so I tried applying it to the commit just prior (f2efb5742cc9f74ad73987760651e3d23894a416). When running ninja clang-test, the following tests fail:

Failed Tests (8):
  Clang :: CodeGen/2009-06-14-anonymous-union-init.c
  Clang :: CodeGen/builtin-constant-p.c
  Clang :: CodeGen/pascal-string.c
  Clang :: CodeGenCXX/arm-swiftcall.cpp
  Clang :: Sema/array-init.c
  Clang :: Sema/builtins.c
  Clang :: Sema/const-eval.c
  Clang :: Sema/init.c

[nickdesaulniers]

Folded into D151587.

clang/lib/AST/ExprConstant.cpp

static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
 
   // 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
-  // performance problems. Only do so in C++11 for now.
-  if (Exp->isRValue() && (Exp->getType()->isArrayType() ||
-                          Exp->getType()->isRecordType()) &&
-      !Ctx.getLangOpts().CPlusPlus11) {
-    IsConst = false;
-    return true;
-  }
   return false;
 }
 
 static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result,
                                       Expr::SideEffectsKind SEK) {
   return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) ||
          (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
 }

 }
 
 bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
                                  const VarDecl *VD,
                             SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
-  // FIXME: Evaluating initializers for large array and record types can cause
-  // performance problems. Only do so in C++11 for now.
-  if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) &&
-      !Ctx.getLangOpts().CPlusPlus11)
-    return false;
-
   Expr::EvalStatus EStatus;
   EStatus.Diag = &Notes;
 
   EvalInfo Info(Ctx, EStatus, VD->isConstexpr()
                                       ? EvalInfo::EM_ConstantExpression
                                       : EvalInfo::EM_ConstantFold);
   Info.setEvaluatingDecl(VD, Value);
   Info.InConstantContext = true;

clang/lib/CodeGen/CGExprConstant.cpp

case APValue::AddrLabelDiff: {
     // address-of-label difference; make sure to truncate after
     // the subtraction.
     return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
   }
   case APValue::Struct:
   case APValue::Union:
     return ConstStructBuilder::BuildStruct(*this, Value, DestType);
   case APValue::Array: {
-    const ConstantArrayType *CAT =
-        CGM.getContext().getAsConstantArrayType(DestType);
+    const ArrayType *AT = CGM.getContext().getAsArrayType(DestType);
     unsigned NumElements = Value.getArraySize();
     unsigned NumInitElts = Value.getArrayInitializedElts();
 
     // Emit array filler, if there is one.
     llvm::Constant *Filler = nullptr;
     if (Value.hasArrayFiller()) {
       Filler = tryEmitAbstractForMemory(Value.getArrayFiller(),
-                                        CAT->getElementType());
+                                        AT->getElementType());
       if (!Filler)
         return nullptr;
     }
 
     // Emit initializer elements.
     SmallVector<llvm::Constant*, 16> Elts;
     if (Filler && Filler->isNullValue())
       Elts.reserve(NumInitElts + 1);
     else
       Elts.reserve(NumElements);
 
     llvm::Type *CommonElementType = nullptr;
     for (unsigned I = 0; I < NumInitElts; ++I) {
       llvm::Constant *C = tryEmitPrivateForMemory(
-          Value.getArrayInitializedElt(I), CAT->getElementType());
+          Value.getArrayInitializedElt(I), AT->getElementType());
       if (!C) return nullptr;
 
       if (I == 0)
         CommonElementType = C->getType();
       else if (C->getType() != CommonElementType)
         CommonElementType = nullptr;
       Elts.push_back(C);
     }
 
     // This means that the array type is probably "IncompleteType" or some
     // type that is not ConstantArray.
+    const ConstantArrayType *CAT =
+        CGM.getContext().getAsConstantArrayType(DestType);
     if (CAT == nullptr && CommonElementType == nullptr && !NumInitElts) {
       const ArrayType *AT = CGM.getContext().getAsArrayType(DestType);
       CommonElementType = CGM.getTypes().ConvertType(AT->getElementType());
       llvm::ArrayType *AType = llvm::ArrayType::get(CommonElementType,
                                                     NumElements);
       return llvm::ConstantAggregateZero::get(AType);
     }