[Coroutines] Mark coroutine as nounwind if all the calls outside the try-catch wouldn't throw.

[ChuanqiXu]

Summary

A coroutine would generate following codes:

allocate memories;
if (allocation fails)
  return promise-type::get_return_object_on_allocation_failure();
promise-type promise promise-constructor-arguments ;
auto GRO = promise.get_return_object();
auto init_awaiter = promise.initial_suspend();
init_awaiter.await_ready();
init_awaiter.await_suspend(promise);
try {
    init_awaiter.await_resume();
    function-body
} catch (...) {
    promise.unhandled_exception();
}
co_await promise.final_suspend();

promise_type::final_suspend is guranteed to be noexcept.
So we could mark the coroutine as no-throw if all the followings are
no-throw:

• Promise Constructor.
• Parameter Copy/Move Constructor.
• Memory allocator
• promise-type::get_return_object_on_allocation_failure().
• promise.get_return_object().
• promise.initial_suspend(), init_awaiter.await_ready() and init_awaiter.await_suspend().
• promise.unhandled_exception()

Test Plan: check-llvm, cppcoro, folly

[junparser]

clang/lib/AST/StmtCXX.cpp

146

Without unhandled_exception, we current do not emit try-catch block to catch the exception, so it should return false here.

clang/lib/CodeGen/CGCoroutine.cpp

548

initial_suspend is outside of the try-catch in our implementation now. I'm not sure whether something has been changed here. please double check

[junparser]

we may also conside promise.get_return_object(), even parameter copy/move constructors?

[ChuanqiXu]

Address the comments.

[ChuanqiXu]

In D108277#2951823, @junparser wrote:

we may also conside promise.get_return_object(), even parameter copy/move constructors?

get_return_object() is covered in the try-catch. I forgot the parameter constructors. Will do.

clang/lib/CodeGen/CGCoroutine.cpp

548

Now the promise:: initial_suspend() and corresponding await_ready and await_suspend is outside of the try-catch. I had fixed it.

[ChuanqiXu]

Handle Param Moves.

[ChuanqiXu]

Sorry that I found get_return_object and get_return_object_on_allocation_failure are also outside of the try..catch block. Handled them in this revision.

[junparser]

what about allocation function?

BTW，with so many function to check, can we do this in ir level?

[ChuanqiXu]

Handle allocation function.

[ChuanqiXu]

In D108277#2959321, @junparser wrote:

what about allocation function?

BTW，with so many function to check, can we do this in ir level?

Sorry for forgetting the allocation function. After handle it, I think the list should be complete.

Maybe it is possible to do this in middle end. But it looks harder than this approach. I would add it to my to-do list.

[lxfind]

Thanks for working on this!
A few questions:

• Is this primarily an optimization, or does it also fix a bug?
• Does LLVM mid-end not have a nothrow attribute analysis pass? Doing this manually in the front-end seems a bit fragile (concerned about missing something)
• Do we expect those isXXXNoThrow methods to be called else where? If not, is there a reason we choose to put them in 6 separate functions, instead of one function?

[ChuanqiXu]

In D108277#2960350, @lxfind wrote:

Thanks for working on this!
A few questions:

• Is this primarily an optimization, or does it also fix a bug?

Yes, it is purely an optimization. On the one hand, this could convert invoke coro; into call coro;. On the other hand, it would reduce the exceptional path, which is helpful for other analysis.

• Does LLVM mid-end not have a nothrow attribute analysis pass? Doing this manually in the front-end seems a bit fragile (concerned about missing something)

From my perspective, the LLVM mid-end doesn't have a nothrow analysis pass as I expected in this patch. For example:

void bar();
void foo() {
    try {
        bar();
    } catch(...) {

    }
}
void baz() {
    try {
        foo();
    } catch(...) {

    }
}

foo wouldn't be marked as no-throw even if we use O3. BTW, if we mark bar() as noexcept, foo() and bad() would get optimized correctly.

• Do we expect those isXXXNoThrow methods to be called else where? If not, is there a reason we choose to put them in 6 separate functions, instead of one function?

The reason why I use 6 calls instead of 1 is that I think it is more clear. The 6 calls are easy to understand once the reader reads the comment. And if we use one function, I am afraid that the reader need one more jump to read the definition.

[rjmccall]

From your description, it sounds like the optimizer doesn't make any effort to compute nounwind bottom-up on the call graph. That seems like something that, if it can be fixed, would be a lot simpler and have a lot more general applicability than what you're doing here.

clang/lib/AST/Expr.cpp

3774 ↗

(On Diff #368061)

If this is ultimately supposed to be a "does this expression throw" condition, doing that condition correctly is a lot more complicated than this. Some of the complexity in Sema::canThrow wouldn't be necessary here because it allows for dependent expressions, but a lot of it is.

[ChuanqiXu]

Address comments:

• Call one function in CGCoroutine.cpp::EmitCoroutineBody instead of 6 calls.
• Use Sema::canThrow to replace self-implemented Expr::hasMayThrowCall

[ChuanqiXu]

In D108277#2961770, @rjmccall wrote:

From your description, it sounds like the optimizer doesn't make any effort to compute nounwind bottom-up on the call graph. That seems like something that, if it can be fixed, would be a lot simpler and have a lot more general applicability than what you're doing here.

Yes. It is clear that if a pass to calculate the nounwind attribute in the middle end would be much more general than this one, which applies to coroutine only. And I am looking at the documents now : ). And I understand that it is a much higher bar to implement a pass and turn it on by default.
And I think this patch is still meaningful even after we had a pass to calculate nounwind attribute. Since this approach is faster. Thanks for the SemaCoroutine which would calculate the structure of coroutine body statement. We could check the corresponding node of the coroutine body statement directly.

[ChuanqiXu]

Remove unused header.

[junparser]

LGTM, @rjmccall @lxfind any other comments?

[rjmccall]

clang/include/clang/AST/StmtCXX.h

335

Please add a CoroutineStmtBitfields for this and NumParams. You can follow the pattern of e.g. LabelStmtBitfields.

464

You've written "class" instead of "method" here. Also, this isn't really a "helper" anything, it's just a query on the statement.

The name should be clear that you're really just talking about whether the initial "ramp" portion of the coroutine can throw.

Can a coroutine have a function-try-block as their body, and if so, what happens to exceptions from the generated ramp portion of the coroutine?

[ChuanqiXu]

• Refactor CoroutineBodyStmt::MayThrow and CoroutineBodyStmt::NumParams into Stmt::CoroutineBodyStmtBitfields.
• Rephrase the comment for CoroutineBodyStmt::mayThrow.

---

This revision also touched ASTWriter and ASTReader. But I didn't find the place to test for ASTStmtWriter and ASTStmtReader.

[ChuanqiXu]

clang/include/clang/AST/StmtCXX.h

335

Thanks for suggestion!

464

The name should be clear that you're really just talking about whether the initial "ramp" portion of the coroutine can throw.

This may not be precise. Since the condition should be whether the ramp part and the promise_type::unhandled_exception() can throw. So I think mayThrow tells whether or not the coroutine can throw.

Can a coroutine have a function-try-block as their body, and if so, what happens to exceptions from the generated ramp portion of the coroutine?

If that happens, the exceptions would be thrown to the caller of the coroutine instead of the catch block in the coroutine nor the corresponding promise_type::unhandled_exception().

[rjmccall]

We also have to worry about throwing destructors for all of the introduced variables, right?

I'm still not sold on the idea that we should be doing this in the frontend. I mean, your argument could really apply to any function, not just coroutines.

Alternatively, if we do want the frontend to compute a simple, local nounwind, we could probably do it in IRGen, not by inspecting the AST but by just remembering at the end of the function if we ever called EmitCallOrInvoke in a context that doesn't catch all exceptions.

clang/include/clang/AST/StmtCXX.h

464

This may not be precise. Since the condition should be whether the ramp part and the promise_type::unhandled_exception() can throw. So I think mayThrow tells whether or not the coroutine can throw.

Oh, I see your point, sorry about that.

clang/lib/CodeGen/CGCoroutine.cpp

572

This whole comment is out of place now, I think.

[ChuanqiXu]

In D108277#2968686, @rjmccall wrote:

We also have to worry about throwing destructors for all of the introduced variables, right?

I think what you mean is ~promise()? Did I understand right? It looks like that we indeed to forget that before.

I'm still not sold on the idea that we should be doing this in the frontend. I mean, your argument could really apply to any function, not just coroutines.

Alternatively, if we do want the frontend to compute a simple, local nounwind, we could probably do it in IRGen, not by inspecting the AST but by just remembering at the end of the function if we ever called EmitCallOrInvoke in a context that doesn't catch all exceptions.

Thanks for suggestion! The alternative makes sense to me. I would like to see actually how hard it is to implement this in middle end. And if it is really so hard, I would like to try your solution. Thanks again.

[ChuanqiXu]

Handled by @MaskRay at: https://reviews.llvm.org/D108905

clang/include/clang/AST/Stmt.h

class SwitchCaseBitfields {
     /// Used by CaseStmt to store whether it is a case statement
     /// of the form case LHS ... RHS (a GNU extension).
     unsigned CaseStmtIsGNURange : 1;
 
     /// The location of the "case" or "default" keyword.
     SourceLocation KeywordLoc;
   };
 
+  class CoroutineBodyStmtBitfields {
+    friend class CoroutineBodyStmt;
+
+    unsigned : NumStmtBits;
+
+    unsigned NumParams : 32 - NumStmtBits - 1;
+    unsigned MayThrow : 1;
+  };
+
   //===--- Expression bitfields classes ---===//
 
   class ExprBitfields {
     friend class ASTStmtReader; // deserialization
     friend class AtomicExpr; // ctor
     friend class BlockDeclRefExpr; // ctor
     friend class CallExpr; // ctor
     friend class CXXConstructExpr; // ctor
union {
     WhileStmtBitfields WhileStmtBits;
     DoStmtBitfields DoStmtBits;
     ForStmtBitfields ForStmtBits;
     GotoStmtBitfields GotoStmtBits;
     ContinueStmtBitfields ContinueStmtBits;
     BreakStmtBitfields BreakStmtBits;
     ReturnStmtBitfields ReturnStmtBits;
     SwitchCaseBitfields SwitchCaseBits;
+    CoroutineBodyStmtBitfields CoroutineBodyBits;
 
     // Expressions
     ExprBitfields ExprBits;
     ConstantExprBitfields ConstantExprBits;
     PredefinedExprBitfields PredefinedExprBits;
     DeclRefExprBitfields DeclRefExprBits;
     FloatingLiteralBitfields FloatingLiteralBits;
     StringLiteralBitfields StringLiteralBits;

clang/include/clang/AST/StmtCXX.h

enum SubStmt {
     Allocate,      ///< Coroutine frame memory allocation.
     Deallocate,    ///< Coroutine frame memory deallocation.
     ReturnValue,   ///< Return value for thunk function: p.get_return_object().
     ResultDecl,    ///< Declaration holding the result of get_return_object.
     ReturnStmt,    ///< Return statement for the thunk function.
     ReturnStmtOnAllocFailure, ///< Return statement if allocation failed.
     FirstParamMove ///< First offset for move construction of parameter copies.
   };
-  unsigned NumParams;
 
   friend class ASTStmtReader;
   friend class ASTReader;
   friend TrailingObjects;
 
   Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
 
   Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
 
+  void setNumParams(unsigned Num) { CoroutineBodyBits.NumParams = Num; }
+  void setMayThrow(bool MayThrow) { CoroutineBodyBits.MayThrow = MayThrow; }
+
 public:
 
   struct CtorArgs {
     Stmt *Body = nullptr;
     Stmt *Promise = nullptr;
     Expr *InitialSuspend = nullptr;
     Expr *FinalSuspend = nullptr;
     Stmt *OnException = nullptr;
     Stmt *OnFallthrough = nullptr;
     Expr *Allocate = nullptr;
     Expr *Deallocate = nullptr;
     Expr *ReturnValue = nullptr;
     Stmt *ResultDecl = nullptr;
     Stmt *ReturnStmt = nullptr;
     Stmt *ReturnStmtOnAllocFailure = nullptr;
     ArrayRef<Stmt *> ParamMoves;
+    bool MayThrow = true;
   };
 
 private:
 
   CoroutineBodyStmt(CtorArgs const& Args);
 
 public:
   static CoroutineBodyStmt *Create(const ASTContext &C, CtorArgs const &Args);
Expr *getReturnValueInit() const {
     return cast<Expr>(getStoredStmts()[SubStmt::ReturnValue]);
   }
   Stmt *getResultDecl() const { return getStoredStmts()[SubStmt::ResultDecl]; }
   Stmt *getReturnStmt() const { return getStoredStmts()[SubStmt::ReturnStmt]; }
   Stmt *getReturnStmtOnAllocFailure() const {
     return getStoredStmts()[SubStmt::ReturnStmtOnAllocFailure];
   }
   ArrayRef<Stmt const *> getParamMoves() const {
-    return {getStoredStmts() + SubStmt::FirstParamMove, NumParams};
+    return {getStoredStmts() + SubStmt::FirstParamMove,
+            CoroutineBodyBits.NumParams};
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY {
     return getBody() ? getBody()->getBeginLoc()
                      : getPromiseDecl()->getBeginLoc();
   }
   SourceLocation getEndLoc() const LLVM_READONLY {
     return getBody() ? getBody()->getEndLoc() : getPromiseDecl()->getEndLoc();
   }
 
   child_range children() {
-    return child_range(getStoredStmts(),
-                       getStoredStmts() + SubStmt::FirstParamMove + NumParams);
+    return child_range(getStoredStmts(), getStoredStmts() +
+                                             SubStmt::FirstParamMove +
+                                             CoroutineBodyBits.NumParams);
   }
 
   const_child_range children() const {
     return const_child_range(getStoredStmts(), getStoredStmts() +
                                                    SubStmt::FirstParamMove +
-                                                   NumParams);
+                                                   CoroutineBodyBits.NumParams);
   }
 
+  unsigned getNumParams() const { return CoroutineBodyBits.NumParams; }
+
+  /// Queries that if the coroutine is possible to throw an exception.
+  ///
+  /// Note that the coroutine body would be wrapped by try-catch statement.
+  /// So the coroutine wouldn't throw if promise.unhandled_exception() and
+  /// initial "ramp" portion of the coroutine wouldn't throw.
+  /// In other words, coroutine wouldn't throw if all of followings are nothrow.
+  /// - Promise Constructor.
+  /// - Parameter Copy/Move Constructor.
+  /// - Memory allocator
+  /// - promise-type::get_return_object_on_allocation_failure().
+  /// - promise.get_return_object().
+  /// - promise.initial_suspend(), init_awaiter.await_ready() and
+  ///   init_awaiter.await_suspend().
+  /// - promise.unhandled_exception()
+  /// - promise.final_suspend()
+  bool mayThrow() const { return CoroutineBodyBits.MayThrow; }
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CoroutineBodyStmtClass;
   }
 };
 
 /// Represents a 'co_return' statement in the C++ Coroutines TS.
 ///
 /// This statament models the initialization of the coroutine promise
 /// (encapsulating the eventual notional return value) from an expression

clang/lib/AST/StmtCXX.cpp

 
 CoroutineBodyStmt *CoroutineBodyStmt::Create(const ASTContext &C, EmptyShell,
                                              unsigned NumParams) {
   std::size_t Size = totalSizeToAlloc<Stmt *>(
       CoroutineBodyStmt::FirstParamMove + NumParams);
 
   void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
   auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs());
-  Result->NumParams = NumParams;
+  Result->setNumParams(NumParams);
+  Result->setMayThrow(true);
   auto *ParamBegin = Result->getStoredStmts() + SubStmt::FirstParamMove;
   std::uninitialized_fill(ParamBegin, ParamBegin + NumParams,
                           static_cast<Stmt *>(nullptr));
   return Result;
 }
 
 CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
-    : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) {
+    : Stmt(CoroutineBodyStmtClass) {
+  CoroutineBodyBits.MayThrow = Args.MayThrow;
+  CoroutineBodyBits.NumParams = Args.ParamMoves.size();
   Stmt **SubStmts = getStoredStmts();
   SubStmts[CoroutineBodyStmt::Body] = Args.Body;
   SubStmts[CoroutineBodyStmt::Promise] = Args.Promise;
   SubStmts[CoroutineBodyStmt::InitSuspend] = Args.InitialSuspend;
   SubStmts[CoroutineBodyStmt::FinalSuspend] = Args.FinalSuspend;
   SubStmts[CoroutineBodyStmt::OnException] = Args.OnException;
   SubStmts[CoroutineBodyStmt::OnFallthrough] = Args.OnFallthrough;
   SubStmts[CoroutineBodyStmt::Allocate] = Args.Allocate;
   SubStmts[CoroutineBodyStmt::Deallocate] = Args.Deallocate;
   SubStmts[CoroutineBodyStmt::ReturnValue] = Args.ReturnValue;
   SubStmts[CoroutineBodyStmt::ResultDecl] = Args.ResultDecl;
   SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt;
   SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] =
       Args.ReturnStmtOnAllocFailure;
   std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
             const_cast<Stmt **>(getParamMoves().data()));
-}
+}
 No newline at end of file

clang/lib/CodeGen/CGCoroutine.cpp

static void emitBodyAndFallthrough(CodeGenFunction &CGF,
   CGF.EmitStmt(Body);
   const bool CanFallthrough = CGF.Builder.GetInsertBlock();
   if (CanFallthrough)
     if (Stmt *OnFallthrough = S.getFallthroughHandler())
       CGF.EmitStmt(OnFallthrough);
 }
 
 void CodeGenFunction::EmitCoroutineBody(const CoroutineBodyStmt &S) {
+  // A coroutine would generate following codes:
+  // ```
+  //    allocate memories;
+  //    if (allocation fails)
+  //      return promise-type::get_return_object_on_allocation_failure();
+  //    promise-type promise promise-constructor-arguments ;
+  //    auto GRO = promise.get_return_object();
+  //    auto init_awaiter = promise.initial_suspend();
+  //    init_awaiter.await_ready();
+  //    init_awaiter.await_suspend(promise);
+  //    try {
+  //        init_awaiter.await_resume();
+  //        function-body
+  //    } catch (...) {
+  //        promise.unhandled_exception();
+  //    }
+  //    co_await promise.final_suspend();
+  //  ```
+  //  promise_type::final_suspend is guranteed to be noexcept.
+  //  So we could mark the coroutine as no-throw if all the followings are
+  //  no-throw:
+  //    - Promise Constructor.
+  //    - Parameter Copy/Move Constructor.
+  //    - Memory allocator
+  //    - promise-type::get_return_object_on_allocation_failure().
+  //    - promise.get_return_object().
+  //    - promise.initial_suspend(), init_awaiter.await_ready() and
+  //    init_awaiter.await_suspend().
+  //    - promise.unhandled_exception()
+  if (!S.mayThrow())
+    CurFn->addFnAttr(llvm::Attribute::NoUnwind);
+
   auto *NullPtr = llvm::ConstantPointerNull::get(Builder.getInt8PtrTy());
   auto &TI = CGM.getContext().getTargetInfo();
   unsigned NewAlign = TI.getNewAlign() / TI.getCharWidth();
 
   auto *EntryBB = Builder.GetInsertBlock();
   auto *AllocBB = createBasicBlock("coro.alloc");
   auto *InitBB = createBasicBlock("coro.init");
   auto *FinalBB = createBasicBlock("coro.final");

clang/lib/Sema/CoroutineStmtBuilder.h

public:
   /// promise type in order to construct.
   ///
   /// For example different new/delete overloads are selected depending on
   /// if the promise type provides `unhandled_exception()`, and therefore they
   /// cannot be built until the promise type is complete so that we can perform
   /// name lookup.
   bool buildDependentStatements();
 
+  /// Calculating if the coroutine may throw an exception.
+  /// See CoroutineBodyStmt::mayThrow for details.
+  void buildMayThrow();
+
   bool isInvalid() const { return !this->IsValid; }
 
 private:
   bool makePromiseStmt();
   bool makeInitialAndFinalSuspend();
   bool makeNewAndDeleteExpr();
   bool makeOnFallthrough();
   bool makeOnException();
   bool makeReturnObject();
   bool makeGroDeclAndReturnStmt();
   bool makeReturnOnAllocFailure();
+  bool isMayThrow();
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_SEMA_COROUTINESTMTBUILDER_H

clang/lib/Sema/SemaCoroutine.cpp

if (Fn->FirstReturnLoc.isValid()) {
     Diag(Fn->FirstReturnLoc, diag::err_return_in_coroutine);
     Diag(Fn->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
             << Fn->getFirstCoroutineStmtKeyword();
   }
   CoroutineStmtBuilder Builder(*this, *FD, *Fn, Body);
   if (Builder.isInvalid() || !Builder.buildStatements())
     return FD->setInvalidDecl();
 
+  Builder.buildMayThrow();
   // Build body for the coroutine wrapper statement.
   Body = CoroutineBodyStmt::Create(Context, Builder);
 }
 
 CoroutineStmtBuilder::CoroutineStmtBuilder(Sema &S, FunctionDecl &FD,
                                            sema::FunctionScopeInfo &Fn,
                                            Stmt *Body)
     : S(S), FD(FD), Fn(Fn), Loc(FD.getLocation()),
bool CoroutineStmtBuilder::makeGroDeclAndReturnStmt() {
   }
   if (cast<clang::ReturnStmt>(ReturnStmt.get())->getNRVOCandidate() == GroDecl)
     GroDecl->setNRVOVariable(true);
 
   this->ReturnStmt = ReturnStmt.get();
   return true;
 }
 
+void CoroutineStmtBuilder::buildMayThrow() {
+  if (this->Promise)
+    this->MayThrow = isMayThrow();
+}
+
+bool CoroutineStmtBuilder::isMayThrow() {
+  if (S.canThrow(this->Promise))
+    return true;
+
+  // For Initial Suspend, the await_resume part is in the try-catch
+  // with the remaining is out of the try-catch.
+  // So we choose not to check the await_resume.
+  auto *InitSuspendExpr =
+      isa<ExprWithCleanups>(this->InitialSuspend)
+          ? dyn_cast<CoroutineSuspendExpr>(
+                cast<ExprWithCleanups>(this->InitialSuspend)->getSubExpr())
+          : dyn_cast<CoroutineSuspendExpr>(this->InitialSuspend);
+
+  // Unimaged pattern. Return true conservatively.
+  if (!InitSuspendExpr)
+    return true;
+
+  if (S.canThrow(InitSuspendExpr->getCommonExpr()) ||
+      S.canThrow(InitSuspendExpr->getReadyExpr()) ||
+      S.canThrow(InitSuspendExpr->getSuspendExpr()))
+    return true;
+
+  if (this->OnException && S.canThrow(this->OnException))
+    return true;
+
+  if (S.canThrow(this->Allocate) || S.canThrow(this->ReturnValue))
+    return true;
+
+  if (this->ResultDecl) {
+    if (S.canThrow(this->ResultDecl) || S.canThrow(this->ReturnStmt))
+      return true;
+
+    if (this->ReturnStmtOnAllocFailure &&
+        S.canThrow(this->ReturnStmtOnAllocFailure))
+      return true;
+  }
+
+  if (llvm::any_of(this->ParamMoves, [&](const Stmt *ParamMove) {
+        return S.canThrow(ParamMove);
+      }))
+    return true;
+
+  assert(
+      !S.canThrow(this->FinalSuspend) &&
+      "promise_type::final_suspend should be noexcept by the language spec!");
+  return false;
+}
+
 // Create a static_cast\<T&&>(expr).
 static Expr *castForMoving(Sema &S, Expr *E, QualType T = QualType()) {
   if (T.isNull())
     T = E->getType();
   QualType TargetType = S.BuildReferenceType(
       T, /*SpelledAsLValue*/ false, SourceLocation(), DeclarationName());
   SourceLocation ExprLoc = E->getBeginLoc();
   TypeSourceInfo *TargetLoc =

clang/lib/Sema/TreeTransform.h

if (S->hasDependentPromiseType()) {
     if (auto *ReturnStmt = S->getReturnStmt()) {
       StmtResult Res = getDerived().TransformStmt(ReturnStmt);
       if (Res.isInvalid())
         return StmtError();
       Builder.ReturnStmt = Res.get();
     }
   }
 
+  Builder.buildMayThrow();
   return getDerived().RebuildCoroutineBodyStmt(Builder);
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
   ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
                                                         /*NotCopyInit*/false);

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
   }
 
   S->initialize(Record.getContext(), AsmStr, AsmToks,
                 Constraints, Exprs, Clobbers);
 }
 
 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
   VisitStmt(S);
-  assert(Record.peekInt() == S->NumParams);
-  Record.skipInts(1);
+  S->setNumParams(Record.readInt());
+  S->setMayThrow(Record.readInt());
   auto *StoredStmts = S->getStoredStmts();
   for (unsigned i = 0;
-       i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
+       i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->getNumParams(); ++i)
     StoredStmts[i] = Record.readSubStmt();
 }
 
 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
   VisitStmt(S);
   S->CoreturnLoc = Record.readSourceLocation();
   for (auto &SubStmt: S->SubStmts)
     SubStmt = Record.readSubStmt();

clang/lib/Serialization/ASTWriterStmt.cpp

for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
     Record.AddString(S->getInputConstraint(I));
   }
 
   Code = serialization::STMT_MSASM;
 }
 
 void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) {
   VisitStmt(CoroStmt);
-  Record.push_back(CoroStmt->getParamMoves().size());
+  assert(CoroStmt->getParamMoves().size() == CoroStmt->getNumParams());
+  Record.push_back(CoroStmt->getNumParams());
+  Record.push_back(CoroStmt->mayThrow());
   for (Stmt *S : CoroStmt->children())
     Record.AddStmt(S);
   Code = serialization::STMT_COROUTINE_BODY;
 }
 
 void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {
   VisitStmt(S);
   Record.AddSourceLocation(S->getKeywordLoc());

clang/test/CodeGenCoroutines/coro-nounwind.cpp

+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-pc-windows-msvc18.0.0 -emit-llvm %s -o - -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
+// RUN: %clang_cc1 -std=c++14 -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck --check-prefix=CHECK-LINUX %s
+
+#include "Inputs/coroutine.h"
+
+namespace coro = std::experimental::coroutines_v1;
+
+namespace std {
+
+struct nothrow_t {};
+constexpr nothrow_t nothrow = {};
+
+} // end namespace std
+
+// Required when get_return_object_on_allocation_failure() is defined by
+// the promise.
+void *operator new(__SIZE_TYPE__ __sz, const std::nothrow_t &) noexcept;
+void operator delete(void *__p, const std::nothrow_t &)noexcept;
+
+struct coro_nothrow_t {
+  struct promise_type {
+    coro_nothrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_nothrow_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?foo@@YA?AUcoro_nothrow_t{{.*}}#[[FOOATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3foov{{.*}}#[[FOOATTRNUM:[0-9]+]]
+
+coro_nothrow_t foo() {
+  co_return;
+}
+
+struct coro_ctor_maythrow_t {
+  struct promise_type {
+    coro_ctor_maythrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_ctor_maythrow_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+    promise_type();
+  };
+};
+
+// CHECK: define dso_local i8 @"?bar@@YA?AUcoro_ctor_maythrow_t{{.*}}#[[BARATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3barv() #[[BARATTRNUM:[0-9]+]]
+coro_ctor_maythrow_t bar() {
+  co_return;
+}
+
+struct coro_onexception_maythrow_t {
+  struct promise_type {
+    coro_onexception_maythrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_onexception_maythrow_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception();
+  };
+};
+
+// CHECK: define dso_local i8 @"?baz@@YA?AUcoro_onexception_maythrow_t{{.*}}#[[BAZATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3bazv() #[[BAZATTRNUM:[0-9]+]]
+coro_onexception_maythrow_t baz() {
+  co_return;
+}
+
+struct coro_initsuspend_maythrow_t {
+  struct promise_type {
+    coro_initsuspend_maythrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_initsuspend_maythrow_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend();
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f1@@YA?AUcoro_initsuspend_maythrow_t{{.*}}#[[F1ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z2f1v() #[[F1ATTRNUM:[0-9]+]]
+coro_initsuspend_maythrow_t f1() {
+  co_return;
+}
+
+struct coro_initsuspend_maythrow_t2 {
+  struct promise_type {
+    coro_initsuspend_maythrow_t2 get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_initsuspend_maythrow_t2 get_return_object_on_allocation_failure() noexcept;
+    struct init_awaiter {
+      bool await_ready();
+      void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+      void await_resume() noexcept;
+    };
+    init_awaiter initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f2@@YA?AUcoro_initsuspend_maythrow_t2{{.*}}#[[F2ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z2f2v() #[[F2ATTRNUM:[0-9]+]]
+coro_initsuspend_maythrow_t2 f2() {
+  co_return;
+}
+
+struct coro_initsuspend_maythrow_t3 {
+  struct promise_type {
+    coro_initsuspend_maythrow_t3 get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_initsuspend_maythrow_t3 get_return_object_on_allocation_failure() noexcept;
+    struct init_awaiter {
+      bool await_ready() noexcept;
+      void await_suspend(std::experimental::coroutine_handle<>);
+      void await_resume() noexcept;
+    };
+    init_awaiter initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f3@@YA?AUcoro_initsuspend_maythrow_t3{{.*}}#[[F3ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z2f3v() #[[F3ATTRNUM:[0-9]+]]
+coro_initsuspend_maythrow_t3 f3() {
+  co_return;
+}
+
+struct coro_initsuspend_maythrow_t4 {
+  struct promise_type {
+    coro_initsuspend_maythrow_t4 get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_initsuspend_maythrow_t4 get_return_object_on_allocation_failure() noexcept;
+    struct init_awaiter {
+      bool await_ready() noexcept;
+      void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+      void await_resume();
+    };
+    init_awaiter initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f4@@YA?AUcoro_initsuspend_maythrow_t4{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z2f4v() #[[FOOATTRNUM]]
+coro_initsuspend_maythrow_t4 f4() {
+  co_return;
+}
+
+class NoCopyMove {
+};
+
+// CHECK: define dso_local i8 @"?f5@@YA?AUcoro_nothrow_t{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z2f5{{.*}} #[[FOOATTRNUM]]
+coro_nothrow_t f5(NoCopyMove) {
+  co_return;
+}
+
+class MoveMayThrow {
+public:
+  MoveMayThrow(MoveMayThrow &&);
+};
+
+// CHECK: define dso_local i8 @"?f6@@YA?AUcoro_nothrow_t{{.*}}#[[F6ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z2f6{{.*}} #[[F6ATTRNUM:[0-9]+]]
+coro_nothrow_t f6(MoveMayThrow) {
+  co_return;
+}
+
+class MoveNoThrow {
+public:
+  MoveNoThrow(MoveNoThrow &&) noexcept;
+};
+
+// CHECK: define dso_local i8 @"?f7@@YA?AUcoro_nothrow_t{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z2f7{{.*}} #[[FOOATTRNUM]]
+coro_nothrow_t f7(MoveNoThrow) {
+  co_return;
+}
+
+class CopyMayThrow {
+public:
+  CopyMayThrow(CopyMayThrow &&);
+};
+
+// CHECK: define dso_local i8 @"?f8@@YA?AUcoro_nothrow_t{{.*}}#[[F8ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z2f8{{.*}} #[[F8ATTRNUM:[0-9]+]]
+coro_nothrow_t f8(CopyMayThrow) {
+  co_return;
+}
+
+class CopyNoThrow {
+public:
+  CopyNoThrow(CopyNoThrow &&) noexcept;
+};
+
+// CHECK: define dso_local i8 @"?f9@@YA?AUcoro_nothrow_t{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z2f9{{.*}} #[[FOOATTRNUM]]
+coro_nothrow_t f9(CopyNoThrow) {
+  co_return;
+}
+
+struct coro_gro_throw_t {
+  struct promise_type {
+    coro_gro_throw_t get_return_object() {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_gro_throw_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f10@@YA?AUcoro_gro_throw_t{{.*}}#[[F10ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3f10v{{.*}}#[[F10ATTRNUM:[0-9]+]]
+
+coro_gro_throw_t f10() {
+  co_return;
+}
+
+struct coro_grooaf_throw_t {
+  struct promise_type {
+    coro_grooaf_throw_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_grooaf_throw_t get_return_object_on_allocation_failure();
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f11@@YA?AUcoro_grooaf_throw_t{{.*}}#[[F11ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3f11v{{.*}}#[[F11ATTRNUM:[0-9]+]]
+
+coro_grooaf_throw_t f11() {
+  co_return;
+}
+
+struct coro_grooaf_nothrow_t {
+  struct promise_type {
+    coro_grooaf_nothrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    static coro_grooaf_nothrow_t get_return_object_on_allocation_failure() noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f12@@YA?AUcoro_grooaf_nothrow_t{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z3f12v{{.*}}#[[FOOATTRNUM]]
+
+coro_grooaf_nothrow_t f12() {
+  co_return;
+}
+
+struct coro_alloc_throw_t {
+  struct promise_type {
+    coro_alloc_throw_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f13@@YA?AUcoro_alloc_throw_t{{.*}}#[[F13ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3f13v{{.*}}#[[F13ATTRNUM:[0-9]+]]
+coro_alloc_throw_t f13() {
+  co_return;
+}
+
+struct coro_alloc_throw_t2 {
+  struct promise_type {
+    coro_alloc_throw_t2 get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    void *operator new(__SIZE_TYPE__);
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f14@@YA?AUcoro_alloc_throw_t2{{.*}}#[[F14ATTRNUM:[0-9]+]]
+// CHECK-LINUX: define dso_local void @_Z3f14v{{.*}}#[[F14ATTRNUM:[0-9]+]]
+coro_alloc_throw_t2 f14() {
+  co_return;
+}
+
+struct coro_alloc_nothrow_t {
+  struct promise_type {
+    coro_alloc_nothrow_t get_return_object() noexcept {
+      coro::coroutine_handle<promise_type>{};
+      return {};
+    }
+    void *operator new(__SIZE_TYPE__) noexcept;
+    coro::suspend_never initial_suspend() noexcept { return {}; }
+    coro::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() noexcept;
+  };
+};
+
+// CHECK: define dso_local i8 @"?f15@@YA?AUcoro_alloc_nothrow_t{{.*}}#[[FOOATTRNUM]]
+// CHECK-LINUX: define dso_local void @_Z3f15v{{.*}}#[[FOOATTRNUM]]
+coro_alloc_nothrow_t f15() {
+  co_return;
+}
+
+// CHECK: attributes #[[FOOATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[BARATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[BAZATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F1ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F2ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F3ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F6ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F8ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F10ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F11ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F13ATTRNUM]] = {{.*}}nounwind
+// CHECK-NOT: attributes #[[F14ATTRNUM]] = {{.*}}nounwind
+
+// CHECK-LINUX: attributes #[[FOOATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[BARATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[BAZATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F1ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F2ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F3ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F6ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F8ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F10ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F11ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F13ATTRNUM]] = {{.*}}nounwind
+// CHECK-LINUX-NOT: attributes #[[F14ATTRNUM]] = {{.*}}nounwind