[coroutines] Part 4b: Coroutine Devirtualization: Handle unwinding coro.resume and coro.destroy.

[GorNishanov]

Summary

This is the 4b patch in the coroutine series. CoroEaly pass now can lower coro.resume and coro.destroy intrinsics called via InvokeInst.

Documentation and overview is here: http://llvm.org/docs/Coroutines.html.

Upstreaming sequence (rough plan):

1. Add documentation. (https://reviews.llvm.org/D22603)
2. Add coroutine intrinsics. (https://reviews.llvm.org/D22659)
3. Add empty coroutine passes. (https://reviews.llvm.org/D22847)
4. Add coroutine devirtualization + tests.

a) Lower coro.resume and coro.destroy (https://reviews.llvm.org/D22998)
b) Handle invoke resumers <= we are here
c) Do devirtualization

5. Add CGSCC restart trigger + tests.
6. Add coroutine heap elision + tests.
7. Add the rest of the logic (split into more patches)

[majnemer]

lib/Transforms/Coroutines/CoroEarly.cpp

70–86

Why not throw &I into a CallSite? CallSite abstracts over call and invoke.

You would need to add getIntrinsicID to CallSite.

[GorNishanov]

Switch to iterating over CallSites per David Majnemer feedback, much prettier now!

[majnemer]

Would it be a major burden to fold this into 4a?

[GorNishanov]

lib/Transforms/Coroutines/CoroEarly.cpp

92–108

Good idea! Much prettier now.

(I can add getIntrinsicID to CallSite as a separate commit. It will save one line :-) in CoroEarly)

[GorNishanov]

Abandoning... Changes rolled in part4a

lib/IR/Verifier.cpp

if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
       // taken.
       Assert(
           !F->hasLLVMReservedName() ||
               i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0),
           "Cannot take the address of an intrinsic!", &I);
       Assert(
           !F->isIntrinsic() || isa<CallInst>(I) ||
               F->getIntrinsicID() == Intrinsic::donothing ||
+              F->getIntrinsicID() == Intrinsic::coro_resume ||
+              F->getIntrinsicID() == Intrinsic::coro_destroy ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
               F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
               F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
-          "Cannot invoke an intrinsic other than donothing, patchpoint or "
-          "statepoint",
+          "Cannot invoke an intrinsic other than donothing, patchpoint, "
+          "statepoint, coro_resume or coro_destroy",
           &I);
       Assert(F->getParent() == M, "Referencing function in another module!",
              &I, M, F, F->getParent());
     } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
       Assert(OpBB->getParent() == BB->getParent(),
              "Referring to a basic block in another function!", &I);
     } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
       Assert(OpArg->getParent() == BB->getParent(),

lib/Transforms/Coroutines/CoroEarly.cpp

if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
       case Intrinsic::coro_resume:
         lowerResumeOrDestroy(II, CoroSubFnInst::ResumeIndex);
         break;
       case Intrinsic::coro_destroy:
         lowerResumeOrDestroy(II, CoroSubFnInst::DestroyIndex);
         break;
       }
       Changed = true;
+      continue;
+    }
+
+    // The coro.resume and coro.destroy may be called via Invoke Instruction,
+    // and won't be lowered by the code above.
+
+    auto Inv = dyn_cast<InvokeInst>(&I);
+    if (!Inv)
+      continue;
+    auto CalledFn = Inv->getCalledFunction();
+    if (!CalledFn)
+      continue;
+    StringRef Name = CalledFn->getName();
+    if (!Name.startswith("llvm.coro"))
+      continue;
+    if (Name == CORO_RESUME_STR) {
+      lowerResumeOrDestroy(Inv, CoroSubFnInst::ResumeIndex);
+    } else {
+      assert(Name == CORO_DESTROY_STR && "Cannot invoke coroutine intrinsic "
+                                         "other than coro.resume and "
+                                         "coro.destroy");
+      lowerResumeOrDestroy(Inv, CoroSubFnInst::DestroyIndex);
     }
+    Changed = true;
   }
   return Changed;
 }
 
 // This pass has work to do only if we find intrinsics we are going to lower in
 // the module.
 std::unique_ptr<Lowerer> Lowerer::createIfNeeded(Module &M) {
   if (M.getNamedValue(CORO_RESUME_STR) || M.getNamedValue(CORO_DESTROY_STR))
     return llvm::make_unique<Lowerer>(M);
 
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 //                              Top Level Driver
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 struct CoroEarly : public FunctionPass {
   static char ID; // Pass identification, replacement for typeid.
   CoroEarly() : FunctionPass(ID) {}
 
   std::unique_ptr<Lowerer> L;
 
   bool doInitialization(Module &M) override {
     L = Lowerer::createIfNeeded(M);
     return false;
   }

test/Transforms/Coroutines/coro-early.ll

 ; CHECK-NEXT: %3 = bitcast i8* %2 to void (i8*)*
 ; CHECK-NEXT: call fastcc void %3(i8* %hdl)
   call void @llvm.coro.destroy(i8* %hdl)
 
   ret void
 ; CHECK-NEXT: ret void
 }
 
+; CHECK-LABEL: @eh
+define void @eh(i8* %hdl) personality i8* null {
+; CHECK-NEXT: entry
+entry:
+;  CHECK-NEXT: %0 = call i8* @llvm.coro.subfn.addr(i8* %hdl, i8 0)
+;  CHECK-NEXT: %1 = bitcast i8* %0 to void (i8*)*
+;  CHECK-NEXT: invoke fastcc void %1(i8* %hdl)
+  invoke void @llvm.coro.resume(i8* %hdl)
+          to label %cont unwind label %ehcleanup
+cont:
+  ret void
+
+ehcleanup:
+  %0 = cleanuppad within none []
+  cleanupret from %0 unwind to caller
+}
+
 declare void @llvm.coro.resume(i8*)
 declare void @llvm.coro.destroy(i8*)