[coroutines] Experimenting with __builtin_coro_frame_max_size

[modocache]

Summary

This commit implements a proposed addendum to the C++ Coroutines TS that
would allow users to query, at compile time, the maximum potential size
of a coroutine frame, from within the frontend.

The builtin_coro_frame_max_size allows users to access this size, for
coroutine lambdas, by passing in the type of the coroutine lambda into
the function from which builtin_coro_frame_max_size is called.
https://reviews.llvm.org/P8124 provides an example of such a program.

[modocache]

Thanks for the offline review @GorNishanov! This revision allows constexpr usages of __builtin_coro_frame_max_size.

[modocache]

Remove obsoleted code I accidentally included.

include/clang/AST/ASTContext.h

public:
 
   /// Get the size and alignment of the specified complete type in bits.
   TypeInfo getTypeInfo(const Type *T) const;
   TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); }
 
   /// Get default simd alignment of the specified complete type in bits.
   unsigned getOpenMPDefaultSimdAlign(QualType T) const;
 
+  /// Get maximum potential size of a coroutine frame for the given lambda type.
+  unsigned getCoroFrameMaxSize(QualType T) const;
+
   /// Return the size of the specified (complete) type \p T, in bits.
   uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; }
   uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }
 
   /// Return the size of the character type, in bits.
   uint64_t getCharWidth() const {
     return getTypeSize(CharTy);
   }

include/clang/AST/DeclCXX.h

public:
   }
 
   /// Returns the type of the \c this pointer.
   ///
   /// Should only be called for instance (i.e., non-static) methods. Note
   /// that for the call operator of a lambda closure type, this returns the
   /// desugared 'this' type (a pointer to the closure type), not the captured
   /// 'this' type.
-  QualType getThisType(ASTContext &C) const;
+  QualType getThisType(const ASTContext &C) const;
 
   static QualType getThisType(const FunctionProtoType *FPT,
                               const CXXRecordDecl *Decl);
 
   Qualifiers getTypeQualifiers() const {
     return getType()->getAs<FunctionProtoType>()->getTypeQuals();
   }
 

include/clang/Basic/DiagnosticSemaKinds.td

 def err_atomic_specifier_bad_type : Error<
   "_Atomic cannot be applied to "
   "%select{incomplete |array |function |reference |atomic |qualified |}0type "
   "%1 %select{||||||which is not trivially copyable}0">;
 
 // Expressions.
 def select_unary_expr_or_type_trait_kind : TextSubstitution<
   "%select{sizeof|alignof|vec_step|__builtin_omp_required_simd_align|"
-  "__alignof}0">;
+  "__alignof|__builtin_coro_frame_max_size}0">;
 def ext_sizeof_alignof_function_type : Extension<
   "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
   "to a function type">, InGroup<PointerArith>;
 def ext_sizeof_alignof_void_type : Extension<
   "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
   "to a void type">, InGroup<PointerArith>;
 def err_opencl_sizeof_alignof_type : Error<
   "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
   "to a void type">;
 def err_sizeof_alignof_incomplete_type : Error<
   "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
   "to an incomplete type %1">;
 def err_sizeof_alignof_function_type : Error<
   "invalid application of '%sub{select_unary_expr_or_type_trait_kind}0' "
   "to a function type">;
 def err_openmp_default_simd_align_expr : Error<
   "invalid application of '__builtin_omp_required_simd_align' to an expression, only type is allowed">;
+def err_coro_frame_max_size_expr : Error<
+  "invalid application of '__builtin_coro_frame_max_size' to an expression, only type is allowed">;
 def err_sizeof_alignof_typeof_bitfield : Error<
   "invalid application of '%select{sizeof|alignof|typeof}0' to bit-field">;
 def err_alignof_member_of_incomplete_type : Error<
   "invalid application of 'alignof' to a field of a class still being defined">;
 def err_vecstep_non_scalar_vector_type : Error<
   "'vec_step' requires built-in scalar or vector type, %0 invalid">;
+def err_coro_frame_max_size_non_lambda_type : Error<
+  "invalid application of '__builtin_coro_frame_max_size' to a non-lambda type %0">;
+def err_coro_frame_max_size_not_coroutine_lambda : Error<
+  "invalid application of '__builtin_coro_frame_max_size' to a non-coroutine lambda type %0">;
+def err_coro_frame_max_size_lambda_missing_body : Error<
+  "invalid application of '__builtin_coro_frame_max_size' to a lambda type %0 without a body">;
 def err_offsetof_incomplete_type : Error<
   "offsetof of incomplete type %0">;
 def err_offsetof_record_type : Error<
   "offsetof requires struct, union, or class type, %0 invalid">;
 def err_offsetof_array_type : Error<"offsetof requires array type, %0 invalid">;
 def ext_offsetof_non_pod_type : ExtWarn<"offset of on non-POD type %0">,
   InGroup<InvalidOffsetof>;
 def ext_offsetof_non_standardlayout_type : ExtWarn<

include/clang/Basic/TokenKinds.def

 CXX11_KEYWORD(static_assert         , 0)
 CXX11_KEYWORD(thread_local          , 0)
 
 // C++2a / concepts TS keywords
 CONCEPTS_KEYWORD(concept)
 CONCEPTS_KEYWORD(requires)
 
 // C++ coroutines TS keywords
-KEYWORD(co_await                    , KEYCOROUTINES)
-KEYWORD(co_return                   , KEYCOROUTINES)
-KEYWORD(co_yield                    , KEYCOROUTINES)
+KEYWORD(co_await                     , KEYCOROUTINES)
+KEYWORD(co_return                    , KEYCOROUTINES)
+KEYWORD(co_yield                     , KEYCOROUTINES)
+KEYWORD(__builtin_coro_frame_max_size, KEYCOROUTINES)
 
 // C++ modules TS keywords
 MODULES_KEYWORD(module)
 MODULES_KEYWORD(import)
 
 // C++ char8_t proposal
 KEYWORD(char8_t                     , CHAR8SUPPORT)
 

include/clang/Basic/TypeTraits.h

enum UnaryExprOrTypeTrait {
     /// _Alignof and alignof return the required ABI alignment.
     UETT_AlignOf,
     UETT_VecStep,
     UETT_OpenMPRequiredSimdAlign,
     /// Used for GCC's __alignof.
     /// __alignof returns the preferred alignment of a type, the alignment
     /// clang will attempt to give an object of the type if allowed by ABI.
     UETT_PreferredAlignOf,
+    UETT_CoroFrameMaxSize,
   };
 }
 
 #endif

lib/AST/ASTContext.cpp

unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
   if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
        getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
       getTargetInfo().getABI() == "elfv1-qpx" &&
       T->isSpecificBuiltinType(BuiltinType::Double))
     SimdAlign = 256;
   return SimdAlign;
 }
 
+namespace {
+class FrameSizeBuilder {
+  const ASTContext &Context;
+  uint64_t FrameSize = 0;
+
+public:
+  FrameSizeBuilder(const ASTContext &Context) : Context(Context) {}
+
+  uint64_t getFrameSize() const { return FrameSize; }
+
+  void addType(const QualType Ty) {
+    if ((FrameSize & (Context.getTypeAlign(Ty) - 1)) != 0)
+      FrameSize = llvm::alignTo(FrameSize,
+                                Context.getTypeAlignInChars(Ty).getQuantity());
+    FrameSize += Context.getTypeSizeInChars(Ty).getQuantity();
+  }
+
+  void addType(TargetInfo::IntType Ty) {
+    const TargetInfo &TI = Context.getTargetInfo();
+    if ((FrameSize & (TI.getTypeAlign(Ty) - 1)) != 0)
+      FrameSize = llvm::alignTo(
+          FrameSize,
+          Context.toCharUnitsFromBits(TI.getTypeAlign(Ty)).getQuantity());
+    FrameSize += TI.getTypeWidth(Ty);
+  }
+};
+
+class PotentialSpillsVisitor
+    : public RecursiveASTVisitor<PotentialSpillsVisitor> {
+  FrameSizeBuilder &Builder;
+  const QualType HandleTy;
+
+public:
+  PotentialSpillsVisitor(FrameSizeBuilder &Builder, QualType HandleTy)
+      : Builder(Builder), HandleTy(HandleTy) {}
+
+  bool shouldVisitImplicitCode() const { return true; }
+
+  // Add up the size of any variables explicitly declared within the
+  // coroutine, as well as the implicit __promise and __coro_gro variables.
+  bool VisitVarDecl(VarDecl *VD) {
+    Builder.addType(VD->getType());
+    return true;
+  }
+
+  // Add up the size of any temporaries materialized within the coroutine, as
+  // well as the implicit temporaries materialized when:
+  // 1. __promise.initial_suspend and .final_suspend are called to construct
+  //    awaitables
+  // 2. Coroutine handles are materialized via <handle_type>.from_address and
+  //    passed in as arguments to __builtin_coro_frame. Coroutine handles also
+  //    get bitcast to void* in LLVM IR and the bitcast spills, so the bitcast
+  //    also needs to be accounted for in the coroutine frame size
+  // 3. __promise.get_return_object is called to construct return objects
+  bool VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
+    QualType ETy = E->GetTemporaryExpr()->getType();
+    Builder.addType(ETy);
+
+    // LLVM spills the bitcast for this type, causing an additional increase
+    // in coroutine frame size.
+    if (ETy == HandleTy)
+      Builder.addType(ETy);
+
+    return true;
+  }
+};
+};
+
+unsigned ASTContext::getCoroFrameMaxSize(QualType T) const {
+  auto *TTy = cast<SubstTemplateTypeParmType>(T.getTypePtr());
+  auto *RTy = cast<RecordType>(TTy->getReplacementType().getTypePtr());
+  auto *RD = cast<CXXRecordDecl>(RTy->getDecl());
+  assert(RD->isLambda());
+
+  CXXMethodDecl *MD = RD->getLambdaCallOperator();
+  assert(MD->doesThisDeclarationHaveABody());
+
+  auto *CoroBody = cast<CoroutineBodyStmt>(MD->getBody());
+
+  // Build the maximum potential coroutine frame size, adding alignment padding
+  // as necessary.
+  FrameSizeBuilder Builder(*this);
+
+  // Add space for the two llvm.coro.subfn pointers LLVM adds to the coroutine
+  // frame.
+  Builder.addType(VoidPtrTy);
+  Builder.addType(VoidPtrTy);
+
+  // The coroutine resume index added by LLVM to the coroutine frame will use
+  // the smallest viable integer type, which in some cases might be i1 (1 byte)
+  // vs. i64 (8 bytes). So the maximum size here might be 7 bytes larger than
+  // actual.
+  Builder.addType(getTargetInfo().getInt64Type());
+
+  // Add space for the promise that LLVM adds to the coroutine frame.
+  auto *PromiseDecl = CoroBody->getPromiseDeclStmt();
+  QualType PromiseType;
+  if (auto *PromiseDeclStmt = dyn_cast<DeclStmt>(PromiseDecl))
+    if (auto *PromiseVarDecl =
+            dyn_cast<VarDecl>(PromiseDeclStmt->getSingleDecl()))
+      PromiseType = PromiseVarDecl->getType();
+  Builder.addType(PromiseType);
+
+  // Next, we add space for any and all variables or temporaries that may spill
+  // across suspend point boundaries, and thus may be moved onto the coroutine
+  // frame. In reality LLVM may elide many of these moves, but this function
+  // calculates the upper bound for the frame size, so we must be pessimistic
+  // and assume all variables end up on the frame.
+
+  // First, the implicit 'this' variable on the lambda.
+  Builder.addType(MD->getThisType(*this));
+
+  // Next, each of the  parameters to the lambda.
+  for (auto *PD : MD->parameters())
+    Builder.addType(PD->getType());
+
+  // Finally, any temporaries that may be materialized -- especially coroutine
+  // handles, for which LLVM introduces a bitcast and so must be counted twice.
+  QualType HandleTy;
+  if (auto *InitSuspend =
+          dyn_cast<ExprWithCleanups>(CoroBody->getInitSuspendStmt()))
+    if (auto *Coawait = dyn_cast<CoawaitExpr>(InitSuspend->getSubExpr()))
+      if (auto *AwaitSuspend =
+              dyn_cast<CXXMemberCallExpr>(Coawait->getSuspendExpr()))
+        if (auto *HandleCtor =
+                dyn_cast<CXXConstructExpr>(AwaitSuspend->getArg(0)))
+          if (auto *Cast = dyn_cast<ImplicitCastExpr>(HandleCtor->getArg(0)))
+            HandleTy = Cast->getSubExpr()->getType();
+  PotentialSpillsVisitor V(Builder, HandleTy);
+  V.TraverseStmt(CoroBody);
+
+  return Builder.getFrameSize();
+}
+
 /// toCharUnitsFromBits - Convert a size in bits to a size in characters.
 CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
   return CharUnits::fromQuantity(BitSize / getCharWidth());
 }
 
 /// toBits - Convert a size in characters to a size in characters.
 int64_t ASTContext::toBits(CharUnits CharSize) const {
   return CharSize.getQuantity() * getCharWidth();

lib/AST/ASTDumper.cpp

case UETT_AlignOf:
     OS << " alignof";
     break;
   case UETT_VecStep:
     OS << " vec_step";
     break;
   case UETT_OpenMPRequiredSimdAlign:
     OS << " __builtin_omp_required_simd_align";
     break;
+  case UETT_CoroFrameMaxSize:
+    OS << " __builtin_coro_frame_max_size";
+    break;
   case UETT_PreferredAlignOf:
     OS << " __alignof";
     break;
   }
   if (Node->isArgumentType())
     NodeDumper.dumpType(Node->getArgumentType());
 }
 

lib/AST/DeclCXX.cpp

 QualType CXXMethodDecl::getThisType(const FunctionProtoType *FPT,
                                     const CXXRecordDecl *Decl) {
   ASTContext &C = Decl->getASTContext();
   QualType ClassTy = C.getTypeDeclType(Decl);
   ClassTy = C.getQualifiedType(ClassTy, FPT->getTypeQuals());
   return C.getPointerType(ClassTy);
 }
 
-QualType CXXMethodDecl::getThisType(ASTContext &C) const {
+QualType CXXMethodDecl::getThisType(const ASTContext &C) const {
   // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
   // If the member function is declared const, the type of this is const X*,
   // if the member function is declared volatile, the type of this is
   // volatile X*, and if the member function is declared const volatile,
   // the type of this is const volatile X*.
   assert(isInstance() && "No 'this' for static methods!");
 
   return CXXMethodDecl::getThisType(getType()->getAs<FunctionProtoType>(),

lib/AST/ExprConstant.cpp

bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
   }
   case UETT_OpenMPRequiredSimdAlign:
     assert(E->isArgumentType());
     return Success(
         Info.Ctx.toCharUnitsFromBits(
                     Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
             .getQuantity(),
         E);
+  case UETT_CoroFrameMaxSize: {
+    assert(E->isArgumentType());
+    return Success(Info.Ctx.getCoroFrameMaxSize(E->getArgumentType()), E);
+  }
   }
 
   llvm_unreachable("unknown expr/type trait");
 }
 
 bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
   CharUnits Result;
   unsigned n = OOE->getNumComponents();

lib/AST/ItaniumMangle.cpp

case UETT_AlignOf:
       break;
     case UETT_VecStep: {
       DiagnosticsEngine &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
                                      "cannot yet mangle vec_step expression");
       Diags.Report(DiagID);
       return;
     }
-    case UETT_OpenMPRequiredSimdAlign:
+    case UETT_OpenMPRequiredSimdAlign: {
       DiagnosticsEngine &Diags = Context.getDiags();
       unsigned DiagID = Diags.getCustomDiagID(
           DiagnosticsEngine::Error,
           "cannot yet mangle __builtin_omp_required_simd_align expression");
       Diags.Report(DiagID);
       return;
     }
+    case UETT_CoroFrameMaxSize: {
+      DiagnosticsEngine &Diags = Context.getDiags();
+      unsigned DiagID = Diags.getCustomDiagID(
+          DiagnosticsEngine::Error,
+          "cannot yet mangle __builtin_coro_frame_max_size expression");
+      Diags.Report(DiagID);
+      return;
+    }
+    }
     if (SAE->isArgumentType()) {
       Out << 't';
       mangleType(SAE->getArgumentType());
     } else {
       Out << 'z';
       mangleExpression(SAE->getArgumentExpr());
     }
     break;

lib/AST/StmtPrinter.cpp

case UETT_PreferredAlignOf:
     OS << "__alignof";
     break;
   case UETT_VecStep:
     OS << "vec_step";
     break;
   case UETT_OpenMPRequiredSimdAlign:
     OS << "__builtin_omp_required_simd_align";
     break;
+  case UETT_CoroFrameMaxSize:
+    OS << "__builtin_coro_frame_max_size";
+    break;
   }
   if (Node->isArgumentType()) {
     OS << '(';
     Node->getArgumentType().print(OS, Policy);
     OS << ')';
   } else {
     OS << " ";
     PrintExpr(Node->getArgumentExpr());

lib/Parse/ParseExpr.cpp

#undef RTT_JOIN
   case tok::kw_alignof:    // unary-expression: 'alignof' '(' type-id ')'
   case tok::kw___alignof:  // unary-expression: '__alignof' unary-expression
                            // unary-expression: '__alignof' '(' type-name ')'
   case tok::kw_sizeof:     // unary-expression: 'sizeof' unary-expression
                            // unary-expression: 'sizeof' '(' type-name ')'
   case tok::kw_vec_step:   // unary-expression: OpenCL 'vec_step' expression
   // unary-expression: '__builtin_omp_required_simd_align' '(' type-name ')'
   case tok::kw___builtin_omp_required_simd_align:
+  // unary-exression: '__builtin_coro_frame_max_size' '(' type-name ')'
+  case tok::kw___builtin_coro_frame_max_size:
     return ParseUnaryExprOrTypeTraitExpression();
   case tok::ampamp: {      // unary-expression: '&&' identifier
     SourceLocation AmpAmpLoc = ConsumeToken();
     if (Tok.isNot(tok::identifier))
       return ExprError(Diag(Tok, diag::err_expected) << tok::identifier);
 
     if (getCurScope()->getFnParent() == nullptr)
       return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));

 ExprResult
 Parser::ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
                                            bool &isCastExpr,
                                            ParsedType &CastTy,
                                            SourceRange &CastRange) {
 
   assert(OpTok.isOneOf(tok::kw_typeof, tok::kw_sizeof, tok::kw___alignof,
                        tok::kw_alignof, tok::kw__Alignof, tok::kw_vec_step,
-                       tok::kw___builtin_omp_required_simd_align) &&
+                       tok::kw___builtin_omp_required_simd_align,
+                       tok::kw___builtin_coro_frame_max_size) &&
          "Not a typeof/sizeof/alignof/vec_step expression!");
 
   ExprResult Operand;
 
   // If the operand doesn't start with an '(', it must be an expression.
   if (Tok.isNot(tok::l_paren)) {
     // If construct allows a form without parenthesis, user may forget to put
     // pathenthesis around type name.

 /// [GNU]   '__alignof' unary-expression
 /// [GNU]   '__alignof' '(' type-name ')'
 /// [C11]   '_Alignof' '(' type-name ')'
 /// [C++11] 'alignof' '(' type-id ')'
 /// \endverbatim
 ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
   assert(Tok.isOneOf(tok::kw_sizeof, tok::kw___alignof, tok::kw_alignof,
                      tok::kw__Alignof, tok::kw_vec_step,
-                     tok::kw___builtin_omp_required_simd_align) &&
+                     tok::kw___builtin_omp_required_simd_align,
+                     tok::kw___builtin_coro_frame_max_size) &&
          "Not a sizeof/alignof/vec_step expression!");
   Token OpTok = Tok;
   ConsumeToken();
 
   // [C++11] 'sizeof' '...' '(' identifier ')'
   if (Tok.is(tok::ellipsis) && OpTok.is(tok::kw_sizeof)) {
     SourceLocation EllipsisLoc = ConsumeToken();
     SourceLocation LParenLoc, RParenLoc;
ExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {
   if (OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))
     ExprKind = UETT_AlignOf;
   else if (OpTok.is(tok::kw___alignof))
     ExprKind = UETT_PreferredAlignOf;
   else if (OpTok.is(tok::kw_vec_step))
     ExprKind = UETT_VecStep;
   else if (OpTok.is(tok::kw___builtin_omp_required_simd_align))
     ExprKind = UETT_OpenMPRequiredSimdAlign;
+  else if (OpTok.is(tok::kw___builtin_coro_frame_max_size))
+    ExprKind = UETT_CoroFrameMaxSize;
 
   if (isCastExpr)
     return Actions.ActOnUnaryExprOrTypeTraitExpr(OpTok.getLocation(),
                                                  ExprKind,
                                                  /*isType=*/true,
                                                  CastTy.getAsOpaquePtr(),
                                                  CastRange);
 

lib/Sema/SemaExpr.cpp

if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
     return true;
   }
 
   assert((T->isVoidType() || !T->isIncompleteType()) &&
          "Scalar types should always be complete");
   return false;
 }
 
+static bool CheckCoroFrameMaxSizeTraitOperandType(Sema &S, QualType T,
+                                                  SourceLocation Loc,
+                                                  SourceRange ArgRange) {
+  const RecordType *RTy = nullptr;
+  if (auto *TTy = dyn_cast<SubstTemplateTypeParmType>(T.getTypePtr()))
+    RTy = dyn_cast_or_null<RecordType>(TTy->getReplacementType().getTypePtr());
+  if (!RTy) {
+    S.Diag(Loc, diag::err_coro_frame_max_size_non_lambda_type) << T << ArgRange;
+    return true;
+  }
+
+  auto *RD = dyn_cast_or_null<CXXRecordDecl>(RTy->getDecl());
+  if (!RD || !RD->isLambda()) {
+    S.Diag(Loc, diag::err_coro_frame_max_size_non_lambda_type)
+        << T << ArgRange;
+    return true;
+  }
+
+  CXXMethodDecl *MD = RD->getLambdaCallOperator();
+  if (!MD->doesThisDeclarationHaveABody()) {
+    S.Diag(Loc, diag::err_coro_frame_max_size_lambda_missing_body)
+        << T << ArgRange;
+    return true;
+  }
+
+  auto *CoroBody = dyn_cast_or_null<CoroutineBodyStmt>(MD->getBody());
+  if (!CoroBody) {
+    S.Diag(Loc, diag::err_coro_frame_max_size_not_coroutine_lambda)
+        << T << ArgRange;
+    return true;
+  }
+
+  return false;
+}
+
 static bool CheckExtensionTraitOperandType(Sema &S, QualType T,
                                            SourceLocation Loc,
                                            SourceRange ArgRange,
                                            UnaryExprOrTypeTrait TraitKind) {
   // Invalid types must be hard errors for SFINAE in C++.
   if (S.LangOpts.CPlusPlus)
     return true;
 

 bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
                                             UnaryExprOrTypeTrait ExprKind) {
   QualType ExprTy = E->getType();
   assert(!ExprTy->isReferenceType());
 
   if (ExprKind == UETT_VecStep)
     return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(),
                                         E->getSourceRange());
+  else if (ExprKind == UETT_CoroFrameMaxSize)
+    return CheckCoroFrameMaxSizeTraitOperandType(*this, ExprTy, E->getExprLoc(),
+                                                 E->getSourceRange());
 
   // Whitelist some types as extensions
   if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
                                       E->getSourceRange(), ExprKind))
     return false;
 
   // 'alignof' applied to an expression only requires the base element type of
   // the expression to be complete. 'sizeof' requires the expression's type to
bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
   //     shall be the alignment of the referenced type.
   if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
     ExprType = Ref->getPointeeType();
 
   // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
   //   When alignof or _Alignof is applied to an array type, the result
   //   is the alignment of the element type.
   if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
-      ExprKind == UETT_OpenMPRequiredSimdAlign)
+      ExprKind == UETT_OpenMPRequiredSimdAlign ||
+      ExprKind == UETT_CoroFrameMaxSize)
     ExprType = Context.getBaseElementType(ExprType);
 
   if (ExprKind == UETT_VecStep)
     return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
+  else if (ExprKind == UETT_CoroFrameMaxSize)
+    return CheckCoroFrameMaxSizeTraitOperandType(*this, ExprType, OpLoc,
+                                                 ExprRange);
 
   // Whitelist some types as extensions
   if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
                                       ExprKind))
     return false;
 
   if (RequireCompleteType(OpLoc, ExprType,
                           diag::err_sizeof_alignof_incomplete_type,
Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
   bool isInvalid = false;
   if (E->isTypeDependent()) {
     // Delay type-checking for type-dependent expressions.
   } else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
     isInvalid = CheckAlignOfExpr(*this, E, ExprKind);
   } else if (ExprKind == UETT_VecStep) {
     isInvalid = CheckVecStepExpr(E);
   } else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
-      Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
-      isInvalid = true;
+  } else if (ExprKind == UETT_CoroFrameMaxSize) {
+    Diag(E->getExprLoc(), diag::err_coro_frame_max_size_expr);
+    isInvalid = true;
   } else if (E->refersToBitField()) {  // C99 6.5.3.4p1.
     Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
     isInvalid = true;
   } else {
     isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf);
   }
 
   if (isInvalid)