[coroutines] Add emission of initial and final suspends

[GorNishanov]

Added a CHECK that for a final suspend we correctly set "IsFinalSuspend" argument of @llvm.coro.suspend

[GorNishanov]

Pretty please. Gentle ping.

[GorNishanov]

Tiny ping

[GorNishanov]

Weakly (sp) ping

[GorNishanov]

soft ping

[GorNishanov]

@EricWF: Can you take a quick look? Just a sanity check. The change is rather trivial.

[rsmith]

LGTM

[GorNishanov]

r303603 = 12cdab350043e7ff931af5f13d3e3afe85b76628

[alekseyshl]

Leaks and warnings are reported in coro-await.cpp: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/1400/steps/check-clang%20asan/logs/stdio. Please fix.

[GorNishanov]

In D31608#762783, @alekseyshl wrote:

Leaks and warnings are reported in coro-await.cpp: http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/1400/steps/check-clang%20asan/logs/stdio. Please fix.

Thank you! The fix is incoming in a minute.

[GorNishanov]

Fixed:

r303714 = 8832327ab89f3668378d70d1c4e5a218446ce36e

lib/CodeGen/CGCoroutine.cpp

void CodeGenFunction::EmitCoroutineBody(const CoroutineBodyStmt &S) {
   CurCoro.Data->CleanupJD = getJumpDestInCurrentScope(RetBB);
   {
     CodeGenFunction::RunCleanupsScope ResumeScope(*this);
     EHStack.pushCleanup<CallCoroDelete>(NormalAndEHCleanup, S.getDeallocate());
 
     EmitStmt(S.getPromiseDeclStmt());
 
     CurCoro.Data->FinalJD = getJumpDestInCurrentScope(FinalBB);
+    // FIXME: Emit param moves and gro initialization.
 
-    // FIXME: Emit initial suspend and more before the body.
+
+    CurCoro.Data->CurrentAwaitKind = AwaitKind::Init;
+    EmitStmt(S.getInitSuspendStmt());
 
     CurCoro.Data->CurrentAwaitKind = AwaitKind::Normal;
     EmitStmt(S.getBody());
 
     // See if we need to generate final suspend.
     const bool CanFallthrough = Builder.GetInsertBlock();
     const bool HasCoreturns = CurCoro.Data->CoreturnCount > 0;
     if (CanFallthrough || HasCoreturns) {
       EmitBlock(FinalBB);
-      // FIXME: Emit final suspend.
+      CurCoro.Data->CurrentAwaitKind = AwaitKind::Final;
+      EmitStmt(S.getFinalSuspendStmt());
     }
   }
 
   EmitBlock(RetBB);
 
   // FIXME: Emit return for the coroutine return object.
 }
 

test/CodeGenCoroutines/coro-await.cpp

 template <typename Promise>
 struct coroutine_handle : coroutine_handle<> {
   static coroutine_handle from_address(void *);
 };
 
 }
 }
 
+struct init_susp {
+  bool await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+struct final_susp {
+  bool await_ready();
+  void await_suspend(std::experimental::coroutine_handle<>);
+  void await_resume();
+};
+
 struct suspend_always {
   int stuff;
   bool await_ready();
   void await_suspend(std::experimental::coroutine_handle<>);
   void await_resume();
 };
 
 template<>
 struct std::experimental::coroutine_traits<void> {
   struct promise_type {
     void get_return_object();
-    suspend_always initial_suspend();
-    suspend_always final_suspend();
+    init_susp initial_suspend();
+    final_susp final_suspend();
     void return_void();
   };
 };
 
 // CHECK-LABEL: f0(
 extern "C" void f0() {
   // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
 
+  // See if initial_suspend was issued:
+  // ----------------------------------
+  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
+  // CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(%struct.init_susp*
+  // CHECK: %[[INITSP_ID:.+]] = call token @llvm.coro.save(
+  // CHECK: call i8 @llvm.coro.suspend(token %[[INITSP_ID]], i1 false)
+
   co_await suspend_always{};
   // See if we need to suspend:
   // --------------------------
   // CHECK: %[[READY:.+]] = call zeroext i1 @_ZN14suspend_always11await_readyEv(%struct.suspend_always* %[[AWAITABLE:.+]])
   // CHECK: br i1 %[[READY]], label %[[READY_BB:.+]], label %[[SUSPEND_BB:.+]]
 
   // If we are suspending:
   // ---------------------
   // CHECK: [[SUSPEND_BB]]:
   // CHECK: %[[SUSPEND_ID:.+]] = call token @llvm.coro.save(
   // ---------------------------
   // Build the coroutine handle and pass it to await_suspend
   // ---------------------------
   // CHECK: call i8* @_ZNSt12experimental16coroutine_handleINS_16coroutine_traitsIJvEE12promise_typeEE12from_addressEPv(i8* %[[FRAME]])
   //   ... many lines of code to coerce coroutine_handle into an i8* scalar
   // CHECK: %[[CH:.+]] = load i8*, i8** %{{.+}}
   // CHECK: call void @_ZN14suspend_always13await_suspendENSt12experimental16coroutine_handleIvEE(%struct.suspend_always* %[[AWAITABLE]], i8* %[[CH]])
   // -------------------------
+
   // Generate a suspend point:
   // -------------------------
   // CHECK: %[[OUTCOME:.+]] = call i8 @llvm.coro.suspend(token %[[SUSPEND_ID]], i1 false)
   // CHECK: switch i8 %[[OUTCOME]], label %[[RET_BB:.+]] [
   // CHECK:   i8 0, label %[[READY_BB]]
   // CHECK:   i8 1, label %[[CLEANUP_BB:.+]]
   // CHECK: ]
 
   // Cleanup code goes here:
   // -----------------------
   // CHECK: [[CLEANUP_BB]]:
 
   // When coroutine is resumed, call await_resume
   // --------------------------
   // CHECK: [[READY_BB]]:
   // CHECK:  call void @_ZN14suspend_always12await_resumeEv(%struct.suspend_always* %[[AWAITABLE]])
+
+  // See if final_suspend was issued:
+  // ----------------------------------
+  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type13final_suspendEv(
+  // CHECK-NEXT: call zeroext i1 @_ZN10final_susp11await_readyEv(%struct.final_susp*
+  // CHECK: %[[FINALSP_ID:.+]] = call token @llvm.coro.save(
+  // CHECK: call i8 @llvm.coro.suspend(token %[[FINALSP_ID]], i1 true)
 }
 
 struct suspend_maybe {
   float stuff;
   ~suspend_maybe();
   bool await_ready();
   bool await_suspend(std::experimental::coroutine_handle<>);
   void await_resume();
 };
 
 
 template<>
 struct std::experimental::coroutine_traits<void,int> {
   struct promise_type {
     void get_return_object();
-    suspend_always initial_suspend();
-    suspend_always final_suspend();
+    init_susp initial_suspend();
+    final_susp final_suspend();
     void return_void();
     suspend_maybe yield_value(int);
   };
 };
 
 // CHECK-LABEL: f1(
 extern "C" void f1(int) {
   // CHECK: %[[PROMISE:.+]] = alloca %"struct.std::experimental::coroutine_traits<void, int>::promise_type"
extern "C" void TestOpAwait() {
   co_await MyInt(42);
   // CHECK: call void @_Zaw5MyInt(i32 42)
   // CHECK: call i32 @_ZN13ScalarAwaiter12await_resumeEv(%struct.ScalarAwaiter* %
 
   co_await MyAgg{};
   // CHECK: call void @_ZN5MyAggawEv(%struct.MyAgg* %
   // CHECK: call void @_ZN11AggrAwaiter12await_resumeEv(%struct.Aggr* sret %
 }
+
+// CHECK-LABEL: EndlessLoop(
+extern "C" void EndlessLoop() {
+  // CHECK: %[[FRAME:.+]] = call i8* @llvm.coro.begin(
+
+  // See if initial_suspend was issued:
+  // ----------------------------------
+  // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type15initial_suspendEv(
+  // CHECK-NEXT: call zeroext i1 @_ZN9init_susp11await_readyEv(%struct.init_susp*
+
+  for (;;)
+    co_await suspend_always{};
+
+  // Verify that final_suspend was NOT issued:
+  // ----------------------------------
+  // CHECK-NOT: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_type13final_suspendEv(
+  // CHECK-NOT: call zeroext i1 @_ZN10final_susp11await_readyEv(%struct.final_susp*
+}

test/CodeGenCoroutines/coro-cleanup.cpp

 // Verify that coroutine promise and allocated memory are freed up on exception.
 // RUN: %clang_cc1 -std=c++1z -fcoroutines-ts -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -fexceptions -fcxx-exceptions -disable-llvm-passes | FileCheck %s
 
 namespace std::experimental {
 template <typename... T> struct coroutine_traits;
 
 template <class Promise = void> struct coroutine_handle {
   coroutine_handle() = default;
-  static coroutine_handle from_address(void *) { return {}; }
+  static coroutine_handle from_address(void *) noexcept;
 };
 template <> struct coroutine_handle<void> {
-  static coroutine_handle from_address(void *) { return {}; }
+  static coroutine_handle from_address(void *) noexcept;
   coroutine_handle() = default;
   template <class PromiseType>
   coroutine_handle(coroutine_handle<PromiseType>) {}
 };
 }
 
 struct suspend_always {
-  bool await_ready();
-  void await_suspend(std::experimental::coroutine_handle<>);
-  void await_resume();
+  bool await_ready() noexcept;
+  void await_suspend(std::experimental::coroutine_handle<>) noexcept;
+  void await_resume() noexcept;
 };
 
 template <> struct std::experimental::coroutine_traits<void> {
   struct promise_type {
     void get_return_object();
-    suspend_always initial_suspend();
-    suspend_always final_suspend();
+    suspend_always initial_suspend() noexcept;
+    suspend_always final_suspend() noexcept;
     void return_void();
     promise_type();
     ~promise_type();
     void unhandled_exception();
   };
 };
 
 struct Cleanup { ~Cleanup(); };
 void may_throw();
 
 // CHECK: define void @_Z1fv(
 void f() {
   // CHECK: call i8* @_Znwm(i64
 
   // If promise constructor throws, check that we free the memory.
 
   // CHECK: invoke void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_typeC1Ev(
   // CHECK-NEXT: to label %{{.+}} unwind label %[[DeallocPad:.+]]
 
+  // CHECK: [[DeallocPad]]:
+  // CHECK-NEXT: landingpad
+  // CHECK-NEXT:   cleanup
+  // CHECK: br label %[[Dealloc:.+]]
+
   Cleanup cleanup;
   may_throw();
 
   // if may_throw throws, check that we destroy the promise and free the memory.
 
   // CHECK: invoke void @_Z9may_throwv(
   // CHECK-NEXT: to label %{{.+}} unwind label %[[PromDtorPad:.+]]
 
-  // CHECK: [[DeallocPad]]:
-  // CHECK-NEXT: landingpad
-  // CHECK-NEXT:   cleanup
-  // CHECK: br label %[[Dealloc:.+]]
-
   // CHECK: [[PromDtorPad]]:
   // CHECK-NEXT: landingpad
   // CHECK-NEXT:   cleanup
   // CHECK: call void @_ZN7CleanupD1Ev(%struct.Cleanup*
   // CHECK: call void @_ZNSt12experimental16coroutine_traitsIJvEE12promise_typeD1Ev(
   // CHECK: br label %[[Dealloc]]
 
   // CHECK: [[Dealloc]]:
   // CHECK:   %[[Mem:.+]] = call i8* @llvm.coro.free(
   // CHECK:   call void @_ZdlPv(i8* %[[Mem]])
 
   co_return;
 }