diff --git a/clang/docs/ClangCommandLineReference.rst b/clang/docs/ClangCommandLineReference.rst
--- a/clang/docs/ClangCommandLineReference.rst
+++ b/clang/docs/ClangCommandLineReference.rst
@@ -1418,6 +1418,10 @@
 
 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
diff --git a/clang/include/clang/Basic/Builtins.def b/clang/include/clang/Basic/Builtins.def
--- a/clang/include/clang/Basic/Builtins.def
+++ b/clang/include/clang/Basic/Builtins.def
@@ -1583,6 +1583,7 @@
 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")
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -145,6 +145,7 @@
 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")
 
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -1105,6 +1105,10 @@
   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>">,
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -6256,13 +6256,42 @@
   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,
-                                              bool CanProvideSize,
-                                              bool Overaligned,
-                                              DeclarationName Name);
+  UsualDeallocFnInfo FindUsualDeallocationFunction(SourceLocation StartLoc,
+                                                   bool CanProvideSize,
+                                                   bool Overaligned,
+                                                   DeclarationName Name);
   FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
                                                       CXXRecordDecl *RD);
 
@@ -12146,19 +12175,6 @@
 
   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.
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -4486,6 +4486,14 @@
     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:
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -5895,6 +5895,12 @@
     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);
 
diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp
--- a/clang/lib/Sema/SemaCoroutine.cpp
+++ b/clang/lib/Sema/SemaCoroutine.cpp
@@ -25,6 +25,7 @@
 #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;
@@ -1060,30 +1061,71 @@
 }
 
 // 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) {
+      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;
+  }
+
+  const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
 
   if (!OperatorDelete) {
     // Look for a global declaration.
-    const bool CanProvideSize = S.isCompleteType(Loc, PromiseType);
     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();
@@ -1254,22 +1296,21 @@
   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
@@ -1309,123 +1350,230 @@
 
     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,
+                              AlignedPlacementArgs, AlignedOperatorNew,
+                              UnusedResult, /*Diagnose*/ false);
+  }
+
+  // [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);
 
-  // [dcl.fct.def.coroutine]/7
-  // "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 (!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());
-  // 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)) {
+  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.
     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)
-    return false;
+  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;
+    };
+
+    bool NoThrow = DiagNoThrow(OperatorNew);
+    NoThrow = DiagNoThrow(AlignedOperatorNew) || NoThrow;
+    if (!NoThrow)
       return false;
-    }
   }
 
-  if ((OperatorDelete = findDeleteForPromise(S, Loc, PromiseType)) == nullptr)
-    return false;
+  Sema::UsualDeallocFnInfo OperatorDelete;
+  Sema::UsualDeallocFnInfo AlignedOperatorDelete;
+  findDeleteForPromise(S, Loc, PromiseType, UseAlignedAlloc, OperatorDelete,
+                       AlignedOperatorDelete);
 
-  Expr *FramePtr =
-      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
+  // Make new call.
 
   Expr *FrameSize =
       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_size, {});
+  Expr *FrameAlign =
+      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_align, {});
+
+  // 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();
+  }
 
-  // Make new call.
+  auto MakeNewCall = [&](FunctionDecl *Operator,
+                         SmallVector<Expr *, 1> &PlaceArgs, Expr *&Allocate) {
+    ExprResult NewRef =
+        S.BuildDeclRefExpr(Operator, Operator->getType(), VK_LValue, Loc);
+    if (NewRef.isInvalid())
+      return false;
 
-  ExprResult NewRef =
-      S.BuildDeclRefExpr(OperatorNew, OperatorNew->getType(), VK_LValue, Loc);
-  if (NewRef.isInvalid())
-    return false;
+    SmallVector<Expr *, 2> NewArgs(1, FrameSize);
+    if (Operator->getNumParams() > 1 &&
+        Operator->getParamDecl(1)->getType()->isAlignValT())
+      NewArgs.insert(NewArgs.begin() + 1, FrameAlign);
+    NewArgs.append(PlaceArgs);
 
-  SmallVector<Expr *, 2> NewArgs(1, FrameSize);
-  for (auto Arg : PlacementArgs)
-    NewArgs.push_back(Arg);
+    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;
+  };
 
-  ExprResult NewExpr =
-      S.BuildCallExpr(S.getCurScope(), NewRef.get(), Loc, NewArgs, Loc);
-  NewExpr = S.ActOnFinishFullExpr(NewExpr.get(), /*DiscardedValue*/ false);
-  if (NewExpr.isInvalid())
+  if (!MakeNewCall(OperatorNew, PlacementArgs, this->Allocate))
     return false;
 
-  // Make delete call.
-
-  QualType OpDeleteQualType = OperatorDelete->getType();
+  if (UseAlignedAlloc) {
+    if (!MakeNewCall(AlignedOperatorNew, AlignedPlacementArgs,
+                     this->AlignedAllocate))
+      return false;
+  } else {
+    this->AlignedAllocate = this->Allocate;
+  }
 
-  ExprResult DeleteRef =
-      S.BuildDeclRefExpr(OperatorDelete, OpDeleteQualType, VK_LValue, Loc);
-  if (DeleteRef.isInvalid())
-    return false;
+  // Make delete call.
 
+  Expr *FramePtr =
+      buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_frame, {});
   Expr *CoroFree =
       buildBuiltinCall(S, Loc, Builtin::BI__builtin_coro_free, {FramePtr});
 
-  SmallVector<Expr *, 2> DeleteArgs{CoroFree};
+  auto MakeDeleteCall = [&](const Sema::UsualDeallocFnInfo &Operator,
+                            Expr *&Deallocate) {
+    ExprResult DeleteRef =
+        S.BuildDeclRefExpr(Operator.FD, Operator.FD->getType(), VK_LValue, Loc);
+    if (DeleteRef.isInvalid())
+      return false;
 
-  // Check if we need to pass the size.
-  const auto *OpDeleteType =
-      OpDeleteQualType.getTypePtr()->castAs<FunctionProtoType>();
-  if (OpDeleteType->getNumParams() > 1)
-    DeleteArgs.push_back(FrameSize);
+    SmallVector<Expr *, 2> DeleteArgs{CoroFree};
+    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;
+  };
 
-  ExprResult DeleteExpr =
-      S.BuildCallExpr(S.getCurScope(), DeleteRef.get(), Loc, DeleteArgs, Loc);
-  DeleteExpr =
-      S.ActOnFinishFullExpr(DeleteExpr.get(), /*DiscardedValue*/ false);
-  if (DeleteExpr.isInvalid())
+  if (!MakeDeleteCall(OperatorDelete, this->Deallocate))
     return false;
-
-  this->Allocate = NewExpr.get();
-  this->AlignedAllocate = this->Allocate;
-  this->Deallocate = DeleteExpr.get();
-  this->AlignedDeallocate = this->Deallocate;
+  if (UseAlignedAlloc) {
+    if (!MakeDeleteCall(AlignedOperatorDelete, this->AlignedDeallocate))
+      return false;
+  } else {
+    this->AlignedDeallocate = this->Deallocate;
+  }
 
   return true;
 }
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -9210,9 +9210,11 @@
   if (CSM == CXXDestructor && MD->isVirtual()) {
     FunctionDecl *OperatorDelete = nullptr;
     DeclarationName Name =
-      Context.DeclarationNames.getCXXOperatorName(OO_Delete);
+        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;
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -1577,7 +1577,7 @@
 
 /// 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);
 
@@ -1602,71 +1602,61 @@
   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;
-      }
-
-      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;
-      }
+Sema::UsualDeallocFnInfo::UsualDeallocFnInfo() : Found(), FD(nullptr) {}
+Sema::UsualDeallocFnInfo::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;
+  }
 
-      // 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);
-    }
+  if (NumBaseParams < FD->getNumParams() &&
+      S.Context.hasSameUnqualifiedType(
+          FD->getParamDecl(NumBaseParams)->getType(),
+          S.Context.getSizeType())) {
+    ++NumBaseParams;
+    HasSizeT = true;
+  }
 
-    explicit operator bool() const { return FD; }
+  if (NumBaseParams < FD->getNumParams() &&
+      FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) {
+    ++NumBaseParams;
+    HasAlignValT = true;
+  }
 
-    bool 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;
+  // 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);
+}
 
-      // 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;
+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;
 
-      if (HasSizeT != Other.HasSizeT)
-        return HasSizeT == WantSize;
+  // 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;
 
-      // Use CUDA call preference as a tiebreaker.
-      return CUDAPref > Other.CUDAPref;
-    }
+  if (HasSizeT != Other.HasSizeT)
+    return HasSizeT == WantSize;
 
-    DeclAccessPair Found;
-    FunctionDecl *FD;
-    bool Destroying, HasSizeT, HasAlignValT;
-    Sema::CUDAFunctionPreference CUDAPref;
-  };
+  // Use CUDA call preference as a tiebreaker.
+  return CUDAPref > Other.CUDAPref;
 }
 
 /// Determine whether a type has new-extended alignment. This may be called when
@@ -1681,14 +1671,14 @@
 
 /// 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;
 
@@ -3075,10 +3065,10 @@
   }
 }
 
-FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
-                                                  bool CanProvideSize,
-                                                  bool Overaligned,
-                                                  DeclarationName Name) {
+Sema::UsualDeallocFnInfo
+Sema::FindUsualDeallocationFunction(SourceLocation StartLoc,
+                                    bool CanProvideSize, bool Overaligned,
+                                    DeclarationName Name) {
   DeclareGlobalNewDelete();
 
   LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName);
@@ -3091,7 +3081,7 @@
   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,
@@ -3107,13 +3097,16 @@
   // 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);
@@ -3123,13 +3116,16 @@
 
   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.
@@ -3621,7 +3617,8 @@
 
       // Look for a global declaration.
       OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize,
-                                                     Overaligned, DeleteName);
+                                                     Overaligned, DeleteName)
+                           .FD;
     }
 
     MarkFunctionReferenced(StartLoc, OperatorDelete);
diff --git a/clang/test/CodeGenCoroutines/coro-aligned-alloc.cpp b/clang/test/CodeGenCoroutines/coro-aligned-alloc.cpp
new file mode 100644
--- /dev/null
+++ b/clang/test/CodeGenCoroutines/coro-aligned-alloc.cpp
@@ -0,0 +1,199 @@
+// 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;
+}