[Clang][Coroutines] Implement P2014R0 Option 1 behind -fcoroutines-aligned-alloc

[ychen]

Summary

Default off.

The allocation/deallocation function overload resolutions are following
the Issue #4 of http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p2014r0.pdf.

[ChuanqiXu]

Since D97915 would fix the problem that the variables in the frame may not be aligned, I think this option fcoroutines-aligned-alloc won't affect normal programmers other than language lawyers. Do you think so?

[ychen]

In D102147#2747611, @ChuanqiXu wrote:

Since D97915 would fix the problem that the variables in the frame may not be aligned, I think this option fcoroutines-aligned-alloc won't affect normal programmers other than language lawyers. Do you think so?

I think that's right that if all a user want is alignment, then fcoroutines-aligned-alloc may not be necessary. However if they define customed aligned allocators/dealllocators, this is needed to make it work.

[ChuanqiXu]

In D102147#2747939, @ychen wrote:

In D102147#2747611, @ChuanqiXu wrote:

Since D97915 would fix the problem that the variables in the frame may not be aligned, I think this option fcoroutines-aligned-alloc won't affect normal programmers other than language lawyers. Do you think so?

I think that's right that if all a user want is alignment, then fcoroutines-aligned-alloc may not be necessary. However if they define customed aligned allocators/dealllocators, this is needed to make it work.

I see. The overall idea looks good. I would try to look into the details.

[ychen]

• rebase

[ychen]

327141f was landed as an alternative.

clang/docs/ClangCommandLineReference.rst

 .. option:: -fconvergent-functions
 
 Assume functions may be convergent
 
 .. option:: -fcoroutines-ts, -fno-coroutines-ts
 
 Enable support for the C++ Coroutines TS
 
+.. option:: -fcoroutines-aligned-alloc, -fno-coroutines-aligned-alloc
+
+Enable support for using aligned allocation/deallocation for the C++ Coroutines TS
+
 .. option:: -fcoverage-mapping, -fno-coverage-mapping
 
 Generate coverage mapping to enable code coverage analysis
 
 .. option:: -fcreate-profile
 
 .. option:: -fcs-profile-generate
 

clang/include/clang/Basic/Builtins.def

 
 // Coroutine intrinsics.
 BUILTIN(__builtin_coro_resume, "vv*", "")
 BUILTIN(__builtin_coro_destroy, "vv*", "")
 BUILTIN(__builtin_coro_done, "bv*", "n")
 BUILTIN(__builtin_coro_promise, "v*v*IiIb", "n")
 
 BUILTIN(__builtin_coro_size, "z", "n")
+BUILTIN(__builtin_coro_align, "z", "n")
 BUILTIN(__builtin_coro_frame, "v*", "n")
 BUILTIN(__builtin_coro_noop, "v*", "n")
 BUILTIN(__builtin_coro_free, "v*v*", "n")
 
 BUILTIN(__builtin_coro_id, "v*Iiv*v*v*", "n")
 BUILTIN(__builtin_coro_alloc, "b", "n")
 BUILTIN(__builtin_coro_begin, "v*v*", "n")
 BUILTIN(__builtin_coro_end, "bv*Ib", "n")

clang/include/clang/Basic/LangOptions.def

 LANGOPT(RTTI              , 1, 1, "run-time type information")
 LANGOPT(RTTIData          , 1, 1, "emit run-time type information data")
 LANGOPT(MSBitfields       , 1, 0, "Microsoft-compatible structure layout")
 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
 LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")
 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
 LANGOPT(Coroutines        , 1, 0, "C++20 coroutines")
+LANGOPT(CoroutinesAlignedAlloc, 1, 0, "C++20 coroutines aligned allocation")
 LANGOPT(DllExportInlines  , 1, 1, "dllexported classes dllexport inline methods")
 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
 
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 
 COMPATIBLE_LANGOPT(RecoveryAST, 1, 1, "Preserve expressions in AST when encountering errors")
 COMPATIBLE_LANGOPT(RecoveryASTType, 1, 1, "Preserve the type in recovery expressions")
 

clang/include/clang/Driver/Options.td

defm autolink : BoolFOption<"autolink",
   NegFlag<SetFalse, [CC1Option], "Disable generation of linker directives for automatic library linking">,
   PosFlag<SetTrue>>;
 
 // C++ Coroutines TS
 defm coroutines_ts : BoolFOption<"coroutines-ts",
   LangOpts<"Coroutines">, Default<cpp20.KeyPath>,
   PosFlag<SetTrue, [CC1Option], "Enable support for the C++ Coroutines TS">,
   NegFlag<SetFalse>>;
+defm coroutines_aligned_alloc : BoolFOption<"coroutines-aligned-alloc",
+  LangOpts<"CoroutinesAlignedAlloc">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option], "Enable support for using aligned allocation/deallocation for the C++ Coroutines TS">,
+  NegFlag<SetFalse>>;
 
 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
     Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">,
     HelpText<"Embed LLVM bitcode (option: off, all, bitcode, marker)">,
     Values<"off,all,bitcode,marker">, NormalizedValuesScope<"CodeGenOptions">,
     NormalizedValues<["Embed_Off", "Embed_All", "Embed_Bitcode", "Embed_Marker"]>,
     MarshallingInfoEnum<CodeGenOpts<"EmbedBitcode">, "Embed_Off">;
 def fembed_bitcode : Flag<["-"], "fembed-bitcode">, Group<f_Group>,

clang/include/clang/Sema/Sema.h

bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
                                bool &PassAlignment, MultiExprArg PlaceArgs,
                                FunctionDecl *&OperatorNew,
                                FunctionDecl *&OperatorDelete,
                                bool Diagnose = true);
   void DeclareGlobalNewDelete();
   void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
                                        ArrayRef<QualType> Params);
 
+  // CUDA function call preference. Must be ordered numerically from
+  // worst to best.
+  enum CUDAFunctionPreference {
+    CFP_Never,      // Invalid caller/callee combination.
+    CFP_WrongSide,  // Calls from host-device to host or device
+                    // function that do not match current compilation
+                    // mode.
+    CFP_HostDevice, // Any calls to host/device functions.
+    CFP_SameSide,   // Calls from host-device to host or device
+                    // function matching current compilation mode.
+    CFP_Native,     // host-to-host or device-to-device calls.
+  };
+
+  struct UsualDeallocFnInfo {
+    UsualDeallocFnInfo();
+    UsualDeallocFnInfo(Sema &S, DeclAccessPair Found);
+    explicit operator bool() const { return FD; }
+    bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize,
+                      bool WantAlign) const;
+
+    DeclAccessPair Found;
+    FunctionDecl *FD;
+    bool Destroying, HasSizeT, HasAlignValT;
+    Sema::CUDAFunctionPreference CUDAPref;
+  };
+
+  static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD);
   bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
-                                DeclarationName Name, FunctionDecl* &Operator,
+                                DeclarationName Name, FunctionDecl *&Operator,
+                                const bool *WantSize = nullptr,
+                                const bool *WantAlign = nullptr,
                                 bool Diagnose = true);
-  FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
+  UsualDeallocFnInfo FindUsualDeallocationFunction(SourceLocation StartLoc,
                                                    bool CanProvideSize,
                                                    bool Overaligned,
                                                    DeclarationName Name);
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
                                                       CXXRecordDecl *RD);
 
   /// ActOnCXXDelete - Parsed a C++ 'delete' expression
   ExprResult ActOnCXXDelete(SourceLocation StartLoc,
                             bool UseGlobal, bool ArrayForm,
                             Expr *Operand);
   void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
public:
 
   /// Gets the CUDA target for the current context.
   CUDAFunctionTarget CurrentCUDATarget() {
     return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
   }
 
   static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);
 
-  // CUDA function call preference. Must be ordered numerically from
-  // worst to best.
-  enum CUDAFunctionPreference {
-    CFP_Never,      // Invalid caller/callee combination.
-    CFP_WrongSide,  // Calls from host-device to host or device
-                    // function that do not match current compilation
-                    // mode.
-    CFP_HostDevice, // Any calls to host/device functions.
-    CFP_SameSide,   // Calls from host-device to host or device
-                    // function matching current compilation mode.
-    CFP_Native,     // host-to-host or device-to-device calls.
-  };
-
   /// Identifies relative preference of a given Caller/Callee
   /// combination, based on their host/device attributes.
   /// \param Caller function which needs address of \p Callee.
   ///               nullptr in case of global context.
   /// \param Callee target function
   ///
   /// \returns preference value for particular Caller/Callee combination.
   CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,

clang/lib/CodeGen/CGBuiltin.cpp

   case Builtin::BI__builtin_coro_size: {
     auto & Context = getContext();
     auto SizeTy = Context.getSizeType();
     auto T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
     Function *F = CGM.getIntrinsic(Intrinsic::coro_size, T);
     return RValue::get(Builder.CreateCall(F));
   }
 
+  case Builtin::BI__builtin_coro_align: {
+    auto &Context = getContext();
+    auto SizeTy = Context.getSizeType();
+    auto *T = Builder.getIntNTy(Context.getTypeSize(SizeTy));
+    Function *F = CGM.getIntrinsic(Intrinsic::coro_align, T);
+    return RValue::get(Builder.CreateCall(F));
+  }
+
   case Builtin::BI__builtin_coro_id:
     return EmitCoroutineIntrinsic(E, Intrinsic::coro_id);
   case Builtin::BI__builtin_coro_promise:
     return EmitCoroutineIntrinsic(E, Intrinsic::coro_promise);
   case Builtin::BI__builtin_coro_resume:
     return EmitCoroutineIntrinsic(E, Intrinsic::coro_resume);
   case Builtin::BI__builtin_coro_frame:
     return EmitCoroutineIntrinsic(E, Intrinsic::coro_frame);

clang/lib/Driver/ToolChains/Clang.cpp

if (TC.IsEncodeExtendedBlockSignatureDefault())
     CmdArgs.push_back("-fencode-extended-block-signature");
 
   if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts,
                    false) &&
       types::isCXX(InputType)) {
     CmdArgs.push_back("-fcoroutines-ts");
   }
 
+  if (Args.hasFlag(options::OPT_fcoroutines_aligned_alloc,
+                   options::OPT_fno_coroutines_aligned_alloc, false) &&
+      types::isCXX(InputType)) {
+    CmdArgs.push_back("-fcoroutines-aligned-alloc");
+  }
+
   Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes,
                   options::OPT_fno_double_square_bracket_attributes);
 
   // -faccess-control is default.
   if (Args.hasFlag(options::OPT_fno_access_control,
                    options::OPT_faccess_control, false))
     CmdArgs.push_back("-fno-access-control");
 

clang/lib/Sema/SemaCoroutine.cpp

 #include "clang/AST/StmtCXX.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallVector.h"
 
 using namespace clang;
 using namespace sema;
 
 static LookupResult lookupMember(Sema &S, const char *Name, CXXRecordDecl *RD,
                                  SourceLocation Loc, bool &Res) {
   DeclarationName DN = S.PP.getIdentifierInfo(Name);
   LookupResult LR(S, DN, Loc, Sema::LookupMemberName);
static Expr *buildStdNoThrowDeclRef(Sema &S, SourceLocation Loc) {
   ExprResult DR = S.BuildDeclRefExpr(VD, VD->getType(), VK_LValue, Loc);
   if (DR.isInvalid())
     return nullptr;
 
   return DR.get();
 }
 
 // Find an appropriate delete for the promise.
-static FunctionDecl *findDeleteForPromise(Sema &S, SourceLocation Loc,
-                                          QualType PromiseType) {
-  FunctionDecl *OperatorDelete = nullptr;
-
+static void
+findDeleteForPromise(Sema &S, SourceLocation Loc, QualType PromiseType,
+                     bool UseAlignedAlloc,
+                     Sema::UsualDeallocFnInfo &OperatorDelete,
+                     Sema::UsualDeallocFnInfo &AlignedOperatorDelete) {
   DeclarationName DeleteName =
       S.Context.DeclarationNames.getCXXOperatorName(OO_Delete);
 
+  // Try to find operator delete in class scope.
+
   auto *PointeeRD = PromiseType->getAsCXXRecordDecl();
   assert(PointeeRD && "PromiseType must be a CxxRecordDecl type");
+  LookupResult Found(S, DeleteName, Loc, S.LookupOrdinaryName);
+  S.LookupQualifiedName(Found, PointeeRD);
+  if (Found.isAmbiguous())
+    return;
 
-  if (S.FindDeallocationFunction(Loc, PointeeRD, DeleteName, OperatorDelete))
-    return nullptr;
+  Found.suppressDiagnostics();
+
+  for (auto I = Found.begin(), E = Found.end(); I != E; ++I) {
+    Sema::UsualDeallocFnInfo Info(S, I.getPair());
+    if (!Info || !Sema::isNonPlacementDeallocationFunction(S, Info.FD) ||
+        Info.CUDAPref == Sema::CFP_Never || Info.Destroying)
+      continue;
 
     if (!OperatorDelete) {
-    // Look for a global declaration.
-    const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
+      OperatorDelete = Info;
+      if (UseAlignedAlloc)
+        AlignedOperatorDelete = Info;
+      continue;
+    }
+
+    if (Info.isBetterThan(OperatorDelete, /*WantSize*/ true,
+                          /*WantAlign*/ false))
+      OperatorDelete = Info;
+
+    if (UseAlignedAlloc &&
+        Info.isBetterThan(AlignedOperatorDelete, /*WantSize*/ true,
+                          /*WantAlign*/ true))
+      AlignedOperatorDelete = Info;
+  }
+
+
+  if (!OperatorDelete) {
+    // Look for a global declaration.
     const bool Overaligned = false;
     OperatorDelete = S.FindUsualDeallocationFunction(Loc, CanProvideSize,
                                                      Overaligned, DeleteName);
   }
-  S.MarkFunctionReferenced(Loc, OperatorDelete);
-  return OperatorDelete;
+  S.MarkFunctionReferenced(Loc, OperatorDelete.FD);
+
+  if (!UseAlignedAlloc) {
+    AlignedOperatorDelete = OperatorDelete;
+    return;
   }
 
+  if (!AlignedOperatorDelete) {
+    // Look for a global declaration.
+    const bool Overaligned = true;
+    AlignedOperatorDelete = S.FindUsualDeallocationFunction(
+        Loc, CanProvideSize, Overaligned, DeleteName);
+  }
+  S.MarkFunctionReferenced(Loc, AlignedOperatorDelete.FD);
+}
 
 void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
   FunctionScopeInfo *Fn = getCurFunction();
   assert(Fn && Fn->isCoroutine() && "not a coroutine");
   if (!Body) {
     assert(FD->isInvalidDecl() &&
            "a null body is only allowed for invalid declarations");
     return;
bool CoroutineStmtBuilder::makeNewAndDeleteExpr() {
   // Form and check allocation and deallocation calls.
   assert(!IsPromiseDependentType &&
          "cannot make statement while the promise type is dependent");
   QualType PromiseType = Fn.CoroutinePromise->getType();
 
   if (S.RequireCompleteType(Loc, PromiseType, diag::err_incomplete_type))
     return false;
 
-  const bool RequiresNoThrowAlloc = ReturnStmtOnAllocFailure != nullptr;
-
-  // [dcl.fct.def.coroutine]/7
+  // [dcl.fct.def.coroutine]/9
   // Lookup allocation functions using a parameter list composed of the
   // requested size of the coroutine state being allocated, followed by
   // the coroutine function's arguments. If a matching allocation function
   // exists, use it. Otherwise, use an allocation function that just takes
   // the requested size.
 
-  FunctionDecl *OperatorNew = nullptr;
-  FunctionDecl *OperatorDelete = nullptr;
   FunctionDecl *UnusedResult = nullptr;
   bool PassAlignment = false;
+  FunctionDecl *OperatorNew = nullptr;
+  FunctionDecl *AlignedOperatorNew = nullptr;
   SmallVector<Expr *, 1> PlacementArgs;
+  SmallVector<Expr *, 1> AlignedPlacementArgs;
 
-  // [dcl.fct.def.coroutine]/7
+  // [dcl.fct.def.coroutine]/9
   // "The allocation function’s name is looked up in the scope of P.
   // [...] If the lookup finds an allocation function in the scope of P,
   // overload resolution is performed on a function call created by assembling
   // an argument list. The first argument is the amount of space requested,
   // and has type std::size_t. The lvalues p1 ... pn are the succeeding
   // arguments."
   //
   // ...where "p1 ... pn" are defined earlier as:
for (auto *PD : FD.parameters()) {
     ExprResult PDRefExpr =
         S.BuildDeclRefExpr(PD, PD->getOriginalType().getNonReferenceType(),
                            ExprValueKind::VK_LValue, PDLoc);
     if (PDRefExpr.isInvalid())
       return false;
 
     PlacementArgs.push_back(PDRefExpr.get());
   }
+
+  // Tentatively implement P2014R0 - "Proposed resolution for US061+US062 -
+  // aligned allocation of coroutine frames" Option 1.
+  const bool UseAlignedAlloc = S.getLangOpts().AlignedAllocation &&
+                               S.getLangOpts().CoroutinesAlignedAlloc;
+
+  if (UseAlignedAlloc) {
+    AlignedPlacementArgs = PlacementArgs;
+    PassAlignment = true;
     S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
                               /*DeleteScope*/ Sema::AFS_Both, PromiseType,
-                            /*isArray*/ false, PassAlignment, PlacementArgs,
-                            OperatorNew, UnusedResult, /*Diagnose*/ false);
+                              /*isArray*/ false, PassAlignment,
+                              AlignedPlacementArgs, AlignedOperatorNew,
+                              UnusedResult, /*Diagnose*/ false);
+  }
 
-  // [dcl.fct.def.coroutine]/7
+  // [dcl.fct.def.coroutine]/9
   // "If no matching function is found, overload resolution is performed again
   // on a function call created by passing just the amount of space required as
   // an argument of type std::size_t."
+  if (UseAlignedAlloc && !AlignedOperatorNew && !AlignedPlacementArgs.empty()) {
+    AlignedPlacementArgs.clear();
+    PassAlignment = true;
+    S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
+                              /*DeleteScope*/ Sema::AFS_Both, PromiseType,
+                              /*isArray*/ false, PassAlignment,
+                              AlignedPlacementArgs, AlignedOperatorNew,
+                              UnusedResult, /*Diagnose*/ false);
+  }
+
+  PassAlignment = false;
+  S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
+                            /*DeleteScope*/ Sema::AFS_Both, PromiseType,
+                            /*isArray*/ false, PassAlignment, PlacementArgs,
+                            OperatorNew, UnusedResult, /*Diagnose*/ false);
+
   if (!OperatorNew && !PlacementArgs.empty()) {
     PlacementArgs.clear();
+    PassAlignment = false;
     S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Class,
                               /*DeleteScope*/ Sema::AFS_Both, PromiseType,
                               /*isArray*/ false, PassAlignment, PlacementArgs,
                               OperatorNew, UnusedResult, /*Diagnose*/ false);
   }
 
-  // [dcl.fct.def.coroutine]/7
+  if (UseAlignedAlloc && !AlignedOperatorNew && OperatorNew) {
+    AlignedOperatorNew = OperatorNew;
+    AlignedPlacementArgs = PlacementArgs;
+  }
+
+  // [dcl.fct.def.coroutine]/9
   // "The allocation function’s name is looked up in the scope of P. If this
   // lookup fails, the allocation function’s name is looked up in the global
   // scope."
+  if (UseAlignedAlloc && !AlignedOperatorNew) {
+    PassAlignment = true;
+    S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Global,
+                              /*DeleteScope*/ Sema::AFS_Both, PromiseType,
+                              /*isArray*/ false, PassAlignment,
+                              AlignedPlacementArgs, AlignedOperatorNew,
+                              UnusedResult);
+  }
+
   if (!OperatorNew) {
+    PassAlignment = false;
     S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Global,
                               /*DeleteScope*/ Sema::AFS_Both, PromiseType,
                               /*isArray*/ false, PassAlignment, PlacementArgs,
                               OperatorNew, UnusedResult);
   }
 
-  bool IsGlobalOverload =
-      OperatorNew && !isa<CXXRecordDecl>(OperatorNew->getDeclContext());
+  assert(OperatorNew);
+  assert(!UseAlignedAlloc || AlignedOperatorNew);
+
+  // [dcl.fct.def.coroutine]/10
+  // "The unqualified-id get_return_object_on_allocation_failure is looked up in
+  // the scope of class P by class member access lookup. If a declaration is
+  // found, then the result of a call to an allocation function used to obtain
+  // storage for the coroutine state is assumed to return nullptr if it fails to
+  // obtain storage, and if a global allocation function is selected, the
+  // ::operator new(size_t, nothrow_t) form shall be used."
+  auto FindNoThrowAlloc = [&](FunctionDecl *&Operator,
+                              SmallVector<Expr *, 1> &PlaceArgs,
+                              bool PassAlignment) {
+    // Check if the operator is globally overloaded.
+    if (isa<CXXRecordDecl>(Operator->getDeclContext()))
+      return true;
+
     // If we didn't find a class-local new declaration and non-throwing new
     // was is required then we need to lookup the non-throwing global operator
     // instead.
-  if (RequiresNoThrowAlloc && (!OperatorNew || IsGlobalOverload)) {
     auto *StdNoThrow = buildStdNoThrowDeclRef(S, Loc);
     if (!StdNoThrow)
       return false;
-    PlacementArgs = {StdNoThrow};
-    OperatorNew = nullptr;
+    PlaceArgs = {StdNoThrow};
+    Operator = nullptr;
+
     S.FindAllocationFunctions(Loc, SourceRange(), /*NewScope*/ Sema::AFS_Both,
                               /*DeleteScope*/ Sema::AFS_Both, PromiseType,
-                              /*isArray*/ false, PassAlignment, PlacementArgs,
-                              OperatorNew, UnusedResult);
-  }
+                              /*isArray*/ false, PassAlignment, PlaceArgs,
+                              Operator, UnusedResult);
+    return true;
+  };
 
-  if (!OperatorNew)
+  if (ReturnStmtOnAllocFailure) {
+    if (!FindNoThrowAlloc(OperatorNew, PlacementArgs, false))
+      return false;
+    if (UseAlignedAlloc &&
+        !FindNoThrowAlloc(AlignedOperatorNew, AlignedPlacementArgs, true))
       return false;
 
-  if (RequiresNoThrowAlloc) {
-    const auto *FT = OperatorNew->getType()->castAs<FunctionProtoType>();
-    if (!FT->isNothrow(/*ResultIfDependent*/ false)) {
-      S.Diag(OperatorNew->getLocation(),
+    auto DiagNoThrow = [&](FunctionDecl *Operator) {
+      if (!Operator)
+        return true;
+      const auto *FT = Operator->getType()->castAs<FunctionProtoType>();
+      if (FT->isNothrow(/*ResultIfDependent*/ false))
+        return true;
+      S.Diag(Operator->getLocation(),
              diag::err_coroutine_promise_new_requires_nothrow)
-          << OperatorNew;
+          << Operator;
       S.Diag(Loc, diag::note_coroutine_promise_call_implicitly_required)
-          << OperatorNew;
+          << Operator;
       return false;
-    }
-  }
+    };
 
-  if ((OperatorDelete = findDeleteForPromise(S, Loc, PromiseType)) == nullptr)
+    bool NoThrow = DiagNoThrow(OperatorNew);
+    NoThrow = DiagNoThrow(AlignedOperatorNew) || NoThrow;
+    if (!NoThrow)
       return false;
+  }
 
-  Expr *FramePtr =
-      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
+  Sema::UsualDeallocFnInfo OperatorDelete;
+  Sema::UsualDeallocFnInfo AlignedOperatorDelete;
+  findDeleteForPromise(S, Loc, PromiseType, UseAlignedAlloc, OperatorDelete,
+                       AlignedOperatorDelete);
+
+  // Make new call.
 
   Expr *FrameSize =
       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_size, {});
+  Expr *FrameAlign =
+      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_align, {});
 
-  // Make new call.
+  // Cast __builtin_coro_align return value to std::align_val_t.
+  if (UseAlignedAlloc) {
+    QualType AlignValT = S.Context.getTypeDeclType(S.getStdAlignValT());
+    FrameAlign =
+        S.BuildCStyleCastExpr(FrameAlign->getExprLoc(),
+                              S.Context.getTrivialTypeSourceInfo(AlignValT),
+                              FrameAlign->getExprLoc(), FrameAlign)
+            .get();
+  }
 
+  auto MakeNewCall = [&](FunctionDecl *Operator,
+                         SmallVector<Expr *, 1> &PlaceArgs, Expr *&Allocate) {
     ExprResult NewRef =
-      S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc);
+        S.BuildDeclRefExpr(Operator, Operator->getType(), VK_LValue, Loc);
     if (NewRef.isInvalid())
       return false;
 
     SmallVector<Expr *, 2> NewArgs(1, FrameSize);
-  for (auto Arg : PlacementArgs)
-    NewArgs.push_back(Arg);
+    if (Operator->getNumParams() > 1 &&
+        Operator->getParamDecl(1)->getType()->isAlignValT())
+      NewArgs.insert(NewArgs.begin() + 1, FrameAlign);
+    NewArgs.append(PlaceArgs);
 
     ExprResult NewExpr =
         S.BuildCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc);
     NewExpr = S.ActOnFinishFullExpr(NewExpr.get(), /*DiscardedValue*/ false);
     if (NewExpr.isInvalid())
       return false;
+    Allocate = NewExpr.get();
+    return true;
+  };
+
+  if (!MakeNewCall(OperatorNew, PlacementArgs, this->Allocate))
+    return false;
+
+  if (UseAlignedAlloc) {
+    if (!MakeNewCall(AlignedOperatorNew, AlignedPlacementArgs,
+                     this->AlignedAllocate))
+      return false;
+  } else {
+    this->AlignedAllocate = this->Allocate;
+  }
 
   // Make delete call.
 
-  QualType OpDeleteQualType = OperatorDelete->getType();
+  Expr *FramePtr =
+      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
+  Expr *CoroFree =
+      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_free, {FramePtr});
 
+  auto MakeDeleteCall = [&](const Sema::UsualDeallocFnInfo &Operator,
+                            Expr *&Deallocate) {
     ExprResult DeleteRef =
-      S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc);
+        S.BuildDeclRefExpr(Operator.FD, Operator.FD->getType(), VK_LValue, Loc);
     if (DeleteRef.isInvalid())
       return false;
 
-  Expr *CoroFree =
-      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_free, {FramePtr});
-
     SmallVector<Expr *, 2> DeleteArgs{CoroFree};
-
-  // Check if we need to pass the size.
-  const auto *OpDeleteType =
-      OpDeleteQualType.getTypePtr()->castAs<FunctionProtoType>();
-  if (OpDeleteType->getNumParams() > 1)
+    if (Operator.HasSizeT)
       DeleteArgs.push_back(FrameSize);
+    if (Operator.HasAlignValT)
+      DeleteArgs.push_back(FrameAlign);
 
     ExprResult DeleteExpr =
         S.BuildCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc);
     DeleteExpr =
         S.ActOnFinishFullExpr(DeleteExpr.get(), /*DiscardedValue*/ false);
     if (DeleteExpr.isInvalid())
       return false;
+    Deallocate = DeleteExpr.get();
+    return true;
+  };
 
-  this->Allocate = NewExpr.get();
-  this->AlignedAllocate = this->Allocate;
-  this->Deallocate = DeleteExpr.get();
+  if (!MakeDeleteCall(OperatorDelete, this->Deallocate))
+    return false;
+  if (UseAlignedAlloc) {
+    if (!MakeDeleteCall(AlignedOperatorDelete, this->AlignedDeallocate))
+      return false;
+  } else {
     this->AlignedDeallocate = this->Deallocate;
+  }
 
   return true;
 }
 
 bool CoroutineStmtBuilder::makeOnFallthrough() {
   assert(!IsPromiseDependentType &&
          "cannot make statement while the promise type is dependent");
 

clang/lib/Sema/SemaDeclCXX.cpp

bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
   ContextRAII MethodContext(*this, MD);
 
   // C++11 [class.dtor]p5:
   // -- for a virtual destructor, lookup of the non-array deallocation function
   //    results in an ambiguity or in a function that is deleted or inaccessible
   if (CSM == CXXDestructor && MD->isVirtual()) {
     FunctionDecl *OperatorDelete = nullptr;
     DeclarationName Name =
         Context.DeclarationNames.getCXXOperatorName(OO_Delete);
     if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
-                                 OperatorDelete, /*Diagnose*/false)) {
+                                 OperatorDelete, /*WantSize*/ nullptr,
+                                 /*WantAlign*/ nullptr,
+                                 /*Diagnose*/ false)) {
       if (Diagnose)
         Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
       return true;
     }
   }
 
   SpecialMemberDeletionInfo SMI(*this, MD, CSM, ICI, Diagnose);
 

clang/lib/Sema/SemaExprCXX.cpp

return llvm::none_of(PreventedBy, [&](const FunctionDecl *FD) {
     assert(FD->getNumParams() == 1 &&
            "Only single-operand functions should be in PreventedBy");
     return IdentifyCUDAPreference(Caller, FD) >= CFP_HostDevice;
   });
 }
 
 /// Determine whether the given function is a non-placement
 /// deallocation function.
-static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
+bool Sema::isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) {
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
     return S.isUsualDeallocationFunction(Method);
 
   if (FD->getOverloadedOperator() != OO_Delete &&
       FD->getOverloadedOperator() != OO_Array_Delete)
     return false;
 
   unsigned UsualParams = 1;
 
   if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() &&
       S.Context.hasSameUnqualifiedType(
           FD->getParamDecl(UsualParams)->getType(),
           S.Context.getSizeType()))
     ++UsualParams;
 
   if (S.getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() &&
       S.Context.hasSameUnqualifiedType(
           FD->getParamDecl(UsualParams)->getType(),
           S.Context.getTypeDeclType(S.getStdAlignValT())))
     ++UsualParams;
 
   return UsualParams == FD->getNumParams();
 }
 
-namespace {
-  struct UsualDeallocFnInfo {
-    UsualDeallocFnInfo() : Found(), FD(nullptr) {}
-    UsualDeallocFnInfo(Sema &S, DeclAccessPair Found)
-        : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())),
-          Destroying(false), HasSizeT(false), HasAlignValT(false),
-          CUDAPref(Sema::CFP_Native) {
-      // A function template declaration is never a usual deallocation function.
-      if (!FD)
-        return;
-      unsigned NumBaseParams = 1;
-      if (FD->isDestroyingOperatorDelete()) {
-        Destroying = true;
-        ++NumBaseParams;
-      }
+Sema::UsualDeallocFnInfo::UsualDeallocFnInfo() : Found(), FD(nullptr) {}
+Sema::UsualDeallocFnInfo::UsualDeallocFnInfo(Sema &S, DeclAccessPair Found)
 
-      if (NumBaseParams < FD->getNumParams() &&
-          S.Context.hasSameUnqualifiedType(
-              FD->getParamDecl(NumBaseParams)->getType(),
-              S.Context.getSizeType())) {
-        ++NumBaseParams;
-        HasSizeT = true;
-      }
 
-      if (NumBaseParams < FD->getNumParams() &&
-          FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
-        ++NumBaseParams;
-        HasAlignValT = true;
-      }
 
-      // In CUDA, determine how much we'd like / dislike to call this.
-      if (S.getLangOpts().CUDA)
-        if (auto *Caller = dyn_cast<FunctionDecl>(S.CurContext))
-          CUDAPref = S.IdentifyCUDAPreference(Caller, FD);
-    }
 
-    explicit operator bool() const { return FD; }
-
-    bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize,
+bool Sema::UsualDeallocFnInfo::isBetterThan(const UsualDeallocFnInfo &Other,
+                                            bool WantSize,
                                             bool WantAlign) const {
-      // C++ P0722:
-      //   A destroying operator delete is preferred over a non-destroying
-      //   operator delete.
-      if (Destroying != Other.Destroying)
-        return Destroying;
 
-      // C++17 [expr.delete]p10:
-      //   If the type has new-extended alignment, a function with a parameter
-      //   of type std::align_val_t is preferred; otherwise a function without
-      //   such a parameter is preferred
-      if (HasAlignValT != Other.HasAlignValT)
-        return HasAlignValT == WantAlign;
 
-      if (HasSizeT != Other.HasSizeT)
-        return HasSizeT == WantSize;
 
-      // Use CUDA call preference as a tiebreaker.
-      return CUDAPref > Other.CUDAPref;
-    }
 
-    DeclAccessPair Found;
-    FunctionDecl *FD;
-    bool Destroying, HasSizeT, HasAlignValT;
-    Sema::CUDAFunctionPreference CUDAPref;
-  };
-}
-
 /// Determine whether a type has new-extended alignment. This may be called when
 /// the type is incomplete (for a delete-expression with an incomplete pointee
 /// type), in which case it will conservatively return false if the alignment is
 /// not known.
 static bool hasNewExtendedAlignment(Sema &S, QualType AllocType) {
   return S.getLangOpts().AlignedAllocation &&
          S.getASTContext().getTypeAlignIfKnown(AllocType) >
              S.getASTContext().getTargetInfo().getNewAlign();
 }
 
 /// Select the correct "usual" deallocation function to use from a selection of
 /// deallocation functions (either global or class-scope).
-static UsualDeallocFnInfo resolveDeallocationOverload(
+static Sema::UsualDeallocFnInfo resolveDeallocationOverload(
     Sema &S, LookupResult &R, bool WantSize, bool WantAlign,
-    llvm::SmallVectorImpl<UsualDeallocFnInfo> *BestFns = nullptr) {
-  UsualDeallocFnInfo Best;
+    llvm::SmallVectorImpl<Sema::UsualDeallocFnInfo> *BestFns = nullptr) {
+  Sema::UsualDeallocFnInfo Best;
 
   for (auto I = R.begin(), E = R.end(); I != E; ++I) {
-    UsualDeallocFnInfo Info(S, I.getPair());
-    if (!Info || !isNonPlacementDeallocationFunction(S, Info.FD) ||
+    Sema::UsualDeallocFnInfo Info(S, I.getPair());
+    if (!Info || !Sema::isNonPlacementDeallocationFunction(S, Info.FD) ||
         Info.CUDAPref == Sema::CFP_Never)
       continue;
 
     if (!Best) {
       Best = Info;
       if (BestFns)
         BestFns->push_back(Info);
       continue;
void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
   else {
     // Host and device get their own declaration so each can be
     // defined or re-declared independently.
     CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(Context));
     CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(Context));
   }
 }
 
-FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
-                                                  bool CanProvideSize,
-                                                  bool Overaligned,
-                                                  DeclarationName Name) {
+Sema::UsualDeallocFnInfo
+Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
+                                    bool CanProvideSize, bool Overaligned,
   DeclareGlobalNewDelete();
 
   LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
   LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl());
 
   // FIXME: It's possible for this to result in ambiguity, through a
   // user-declared variadic operator delete or the enable_if attribute. We
   // should probably not consider those cases to be usual deallocation
   // functions. But for now we just make an arbitrary choice in that case.
   auto Result = resolveDeallocationOverload(*this, FoundDelete, CanProvideSize,
                                             Overaligned);
   assert(Result.FD && "operator delete missing from global scope?");
-  return Result.FD;
+  return Result;
 }
 
 FunctionDecl *Sema::FindDeallocationFunctionForDestructor(SourceLocation Loc,
                                                           CXXRecordDecl *RD) {
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Delete);
 
   FunctionDecl *OperatorDelete = nullptr;
   if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
     return nullptr;
   if (OperatorDelete)
     return OperatorDelete;
 
   // If there's no class-specific operator delete, look up the global
   // non-array delete.
   return FindUsualDeallocationFunction(
-      Loc, true, hasNewExtendedAlignment(*this, Context.getRecordType(RD)),
-      Name);
+             Loc, true,
+             hasNewExtendedAlignment(*this, Context.getRecordType(RD)), Name)
+      .FD;
 }
 
 bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
                                     DeclarationName Name,
-                                    FunctionDecl *&Operator, bool Diagnose) {
+                                    FunctionDecl *&Operator,
+                                    const bool *WantSize, const bool *WantAlign,
+                                    bool Diagnose) {
   LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName);
   // Try to find operator delete/operator delete[] in class scope.
   LookupQualifiedName(Found, RD);
 
   if (Found.isAmbiguous())
     return true;
 
   Found.suppressDiagnostics();
 
-  bool Overaligned = hasNewExtendedAlignment(*this, Context.getRecordType(RD));
+  bool Overaligned =
+      WantAlign ? *WantAlign
+                : hasNewExtendedAlignment(*this, Context.getRecordType(RD));
 
   // C++17 [expr.delete]p10:
   //   If the deallocation functions have class scope, the one without a
   //   parameter of type std::size_t is selected.
   llvm::SmallVector<UsualDeallocFnInfo, 4> Matches;
-  resolveDeallocationOverload(*this, Found, /*WantSize*/ false,
+  resolveDeallocationOverload(*this, Found,
+                              /*WantSize*/ WantSize ? *WantSize : false,
                               /*WantAlign*/ Overaligned, &Matches);
 
   // If we could find an overload, use it.
   if (Matches.size() == 1) {
     Operator = cast<CXXMethodDecl>(Matches[0].FD);
 
     // FIXME: DiagnoseUseOfDecl?
     if (Operator->isDeleted()) {
if (!OperatorDelete) {
       bool IsComplete = isCompleteType(StartLoc, Pointee);
       bool CanProvideSize =
           IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize ||
                          Pointee.isDestructedType());
       bool Overaligned = hasNewExtendedAlignment(*this, Pointee);
 
       // Look for a global declaration.
       OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
-                                                     Overaligned, DeleteName);
+                                                     Overaligned, DeleteName)
+                           .FD;
     }
 
     MarkFunctionReferenced(StartLoc, OperatorDelete);
 
     // Check access and ambiguity of destructor if we're going to call it.
     // Note that this is required even for a virtual delete.
     bool IsVirtualDelete = false;
     if (PointeeRD) {

clang/test/CodeGenCoroutines/coro-aligned-alloc.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -fcoroutines-aligned-alloc -std=c++17 \
+// RUN:    -Wno-coroutine-missing-unhandled-exception -emit-llvm %s -o - -disable-llvm-passes \
+// RUN:   | FileCheck %s
+
+namespace std {
+namespace experimental {
+template <typename... T>
+struct coroutine_traits; // expected-note {{declared here}}
+
+template <class Promise = void>
+struct coroutine_handle {
+  coroutine_handle() = default;
+  static coroutine_handle from_address(void *) noexcept { return {}; }
+};
+
+template <>
+struct coroutine_handle<void> {
+  static coroutine_handle from_address(void *) { return {}; }
+  coroutine_handle() = default;
+  template <class PromiseType>
+  coroutine_handle(coroutine_handle<PromiseType>) noexcept {}
+};
+
+} // end namespace experimental
+
+using size_t = decltype(sizeof(0));
+enum class align_val_t : size_t;
+
+} // end namespace std
+
+struct suspend_always {
+  bool await_ready() noexcept { return false; }
+  void await_suspend(std::experimental::coroutine_handle<>) noexcept {}
+  void await_resume() noexcept {}
+};
+
+struct global_new_delete_tag {};
+
+template<>
+struct std::experimental::coroutine_traits<void, global_new_delete_tag> {
+  struct promise_type {
+    void get_return_object() {}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+  };
+};
+
+// If class scope allocator/deallocator are not defined, use the default global
+// ones.
+// CHECK-LABEL: f0(
+extern "C" void f0(global_new_delete_tag) {
+  // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
+  // CHECK: %[[NeedAlloc:.+]] = call i1 @llvm.coro.alloc(token %[[ID]])
+  // CHECK: br i1 %[[NeedAlloc]], label %[[CheckAlignBB:.+]], label %[[InitBB:.+]]
+
+  // CHECK: [[CheckAlignBB]]:
+  // CHECK: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK: %[[CMP:.+]] = icmp ugt i64 %[[ALIGN]], 16
+  // CHECK: br i1 %[[CMP]], label %[[AlignAllocBB:.+]], label %[[AllocBB:.+]]
+
+  // CHECK: [[AllocBB]]:
+  // CHECK-NEXT: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
+  // CHECK-NEXT: %[[MEM:.+]] = call noalias nonnull i8* @_Znwm(i64 %[[SIZE]])
+  // CHECK-NEXT: br label %[[InitBB:.+]]
+
+  // CHECK: [[AlignAllocBB]]:
+  // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
+  // CHECK: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK: %[[MEM2:.+]] = call noalias nonnull i8* @_ZnwmSt11align_val_t(i64 %[[SIZE]], i64 %[[ALIGN]])
+  // CHECK: call void @llvm.assume(i1 true) [ "align"(i8* %[[MEM2]], i64 %[[ALIGN]]) ]
+  // CHECK: br label %[[InitBB]]
+
+  // CHECK: [[InitBB]]:
+  // CHECK: %[[PHI:.+]] = phi i8* [ null, %{{.+}} ], [ %[[MEM]], %[[AllocBB]] ], [ %[[MEM2]], %[[AlignAllocBB]] ]
+  // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(token %[[ID]], i8* %[[PHI]])
+
+  // CHECK: %[[MEM:.+]] = call i8* @llvm.coro.free(token %[[ID]], i8* %[[FRAME]])
+  // CHECK: %[[NeedDealloc:.+]] = icmp ne i8* %[[MEM]], null
+  // CHECK: br i1 %[[NeedDealloc]], label %[[CheckAlignBB:.+]], label %[[Afterwards:.+]]
+
+  // CHECK: [[CheckAlignBB]]:
+  // CHECK: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK: %[[CMP:.+]] = icmp ugt i64 %[[ALIGN]], 16
+  // CHECK: br i1 %[[CMP]], label %[[AlignedFreeBB:.+]], label %[[FreeBB:.+]]
+
+  // CHECK: [[FreeBB]]:
+  // CHECK-NEXT: call void @_ZdlPv(i8* %[[MEM]])
+  // CHECK-NEXT: br label %[[Afterwards]]
+
+  // CHECK: [[AlignedFreeBB]]:
+  // CHECK-NEXT: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK-NEXT: call void @_ZdlPvSt11align_val_t(i8* %[[MEM]], i64 %[[ALIGN]])
+  // CHECK-NEXT: br label %[[Afterwards]]
+
+  // CHECK: [[Afterwards]]:
+  // CHECK: ret void
+  co_return;
+}
+
+struct promise_new_delete_tag {};
+
+template<>
+struct std::experimental::coroutine_traits<void, promise_new_delete_tag> {
+  struct alignas(32) promise_type {
+    void *operator new(std::size_t);
+    void operator delete(void *);
+    void operator delete(void *, std::align_val_t);
+    void get_return_object() {}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+  };
+};
+
+// - If class-specific allocator/deallocator have precedence over global
+//   allocator/deallocator.
+// - Aligned deallocator is preferred over non-aligned deallocator for
+//   overaligned coroutine frame; Non-aligned deallocator is preferred over
+//   aligned deallocator for non-overaligned coroutine frame.
+// - Dynamically adjust alignment for alloc and dealloc if the selected
+//   allocator do not have std::align_val_t argument.
+// CHECK-LABEL: f1(
+extern "C" void f1(promise_new_delete_tag) {
+  // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
+  // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
+  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv22promise_new_delete_tagEE12promise_typenwEm(i64 %[[SIZE]])
+  // CHECK: call i64 @llvm.coro.align.i64()
+  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv22promise_new_delete_tagEE12promise_typenwEm(i64
+  // CHECK: call i8** @llvm.coro.raw.frame.ptr.addr()
+
+  // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
+  // CHECK: %[[MEM:.+]] = call i8* @llvm.coro.free(token %[[ID]], i8* %[[FRAME]])
+  // CHECK: %[[NeedDealloc:.+]] = icmp ne i8* %[[MEM]], null
+  // CHECK: br i1 %[[NeedDealloc]], label %[[CheckAlignBB:.+]], label %[[Afterwards:.+]]
+
+  // CHECK: [[CheckAlignBB]]:
+  // CHECK: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK: %[[CMP:.+]] = icmp ugt i64 %[[ALIGN]], 16
+  // CHECK: br i1 %[[CMP]], label %[[AlignedFreeBB:.+]], label %[[FreeBB:.+]]
+
+  // CHECK: [[FreeBB]]:
+  // CHECK-NEXT: call void @_ZNSt12experimental16coroutine_traitsIJv22promise_new_delete_tagEE12promise_typedlEPv(i8* %[[MEM]])
+  // CHECK-NEXT: br label %[[Afterwards]]
+
+  // CHECK: [[AlignedFreeBB]]:
+  // CHECK-NEXT: %[[OFFSET:.+]] = call i32 @llvm.coro.raw.frame.ptr.offset.i32()
+  // CHECK-NEXT: %[[ADDR:.+]] = getelementptr inbounds i8, i8* %[[MEM]], i32 %[[OFFSET]]
+  // CHECK-NEXT: %[[ADDR2:.+]] = bitcast i8* %[[ADDR]] to i8**
+  // CHECK-NEXT: %[[MEM:.+]] = load i8*, i8** %[[ADDR2]], align 8
+  // CHECK-NEXT: %[[ALIGN:.+]] = call i64 @llvm.coro.align.i64()
+  // CHECK-NEXT: call void @_ZNSt12experimental16coroutine_traitsIJv22promise_new_delete_tagEE12promise_typedlEPvSt11align_val_t(i8* %[[MEM]], i64 %[[ALIGN]])
+  // CHECK-NEXT: br label %[[Afterwards]]
+
+  // CHECK: [[Afterwards]]:
+  // CHECK: ret void
+  co_return;
+}
+
+struct promise_matching_placement_new_tag {};
+
+template <>
+struct std::experimental::coroutine_traits<void, promise_matching_placement_new_tag> {
+  struct promise_type {
+    void *operator new(std::size_t);
+    void *operator new(std::size_t, promise_matching_placement_new_tag,
+                       int, float, double);
+    void *operator new(std::size_t, std::align_val_t);
+    void *operator new(std::size_t, std::align_val_t,
+                       promise_matching_placement_new_tag,
+                       int, float, double);
+
+    void operator delete(void *, std::size_t);
+    void operator delete(void *, std::size_t, std::align_val_t);
+    void operator delete(void *);
+    void operator delete(void *, std::align_val_t);
+    void get_return_object() {}
+    suspend_always initial_suspend() { return {}; }
+    suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+  };
+};
+
+// Class-specific placement allocators have precedence over class-specific
+// allocators.
+// Sized class-specific deallocators have precedence over non-sized
+// class-specific deallocators.
+// CHECK-LABEL: f2(
+extern "C" void f2(promise_matching_placement_new_tag) {
+  // CHECK: %[[ID:.+]] = call token @llvm.coro.id(i32 16
+  // CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
+  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv34promise_matching_placement_new_tagEE12promise_typenwEm(i64 %[[SIZE]])
+  // CHECK: call i64 @llvm.coro.align.i64()
+  // CHECK: call i8* @_ZNSt12experimental16coroutine_traitsIJv34promise_matching_placement_new_tagEE12promise_typenwEmSt11align_val_t(i64
+
+  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJv34promise_matching_placement_new_tagEE12promise_typedlEPvm(i8*
+  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJv34promise_matching_placement_new_tagEE12promise_typedlEPvmSt11align_val_t(i8*
+  co_return;
+}