[Coroutines] Mark every parameter

[ChuanqiXu]

If it would take times to mark parameter passed by value only, I think we could proceed with this one first. We can try to optimize it later. After all, correctness is most important.

clang/lib/CodeGen/CGCoroutine.cpp

if (ParamMoves.size() == FnArgs.size() && DI)
             {std::get<0>(Pair), std::get<1>(Pair)});
 
     // Create parameter copies. We do it before creating a promise, since an
     // evolution of coroutine TS may allow promise constructor to observe
     // parameter copies.
     for (auto *PM : S.getParamMoves()) {
       EmitStmt(PM);
       ParamReplacer.addCopy(cast<DeclStmt>(PM));
+      auto *Alloca = cast<llvm::AllocaInst>(
+          GetAddrOfLocalVar(cast<VarDecl>(cast<DeclStmt>(PM)->getSingleDecl()))
+              .getPointer());
+      auto *Cast = new llvm::BitCastInst(Alloca, VoidPtrTy, "",
+                                         Builder.GetInsertBlock());
+      Builder.CreateCall(CGM.getIntrinsic(llvm::Intrinsic::coro_mark_param),
+                         {Cast});
       // TODO: if(CoroParam(...)) need to surround ctor and dtor
       // for the copy, so that llvm can elide it if the copy is
       // not needed.
     }
 
     EmitStmt(S.getPromiseDeclStmt());
 
     Address PromiseAddr = GetAddrOfLocalVar(S.getPromiseDecl());

clang/test/CodeGenCoroutines/Inputs/coroutine.h

template <typename Promise> struct coroutine_handle : coroutine_handle<> {
   template <typename _PromiseT>
   bool operator!=(coroutine_handle<_PromiseT> const& _Left,
     coroutine_handle<_PromiseT> const& _Right) noexcept
   {
     return !(_Left == _Right);
   }
 
 struct suspend_always {
-  bool await_ready() { return false; }
-  void await_suspend(coroutine_handle<>) {}
-  void await_resume() {}
+  bool await_ready() noexcept { return false; }
+  void await_suspend(coroutine_handle<>) noexcept {}
+  void await_resume() noexcept {}
 };
 struct suspend_never {
   bool await_ready() noexcept { return true; }
   void await_suspend(coroutine_handle<>) noexcept {}
   void await_resume() noexcept {}
 };
 
 }}}

clang/test/CodeGenCoroutines/coro-param-memcpy.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++17 -O1 -fno-inline -emit-llvm %s -o - | FileCheck %s
+
+#include "Inputs/coroutine.h"
+
+struct task {
+  struct promise_type {
+    task get_return_object() { return {this}; }
+    std::experimental::suspend_always initial_suspend() { return {}; }
+    std::experimental::suspend_always final_suspend() noexcept { return {}; }
+    void return_void() {}
+    void unhandled_exception() {}
+  };
+  promise_type *promise;
+};
+
+namespace std::experimental {
+template <typename... Args>
+struct coroutine_traits<task, Args...> {
+  using promise_type = typename task::promise_type;
+};
+} // namespace std::experimental
+
+void *g = nullptr;
+
+struct A {
+  unsigned long long a = 1;
+  unsigned long long b;
+  unsigned int c;
+};
+
+task foo(A a1) {
+  A a2 = a1; // Necessary.
+  g = &a2;   // So the address isn't optimized out.
+  co_return;
+}
+
+// verify that the entire struct param is in the frame.
+// CHECK: %_Z3foo1A.Frame = type { void (%_Z3foo1A.Frame*)*, void (%_Z3foo1A.Frame*)*, %"struct.task::promise_type", i1, %"struct.std::experimental::coroutines_v1::suspend_always", [5 x i8], [24 x i8] }
+
+// CHECK-LABEL: define dso_local %"struct.task::promise_type"* @_Z3foo1A(
+// CHECK:         %[[FRAME:.+]] = call noalias nonnull i8* @_Znwm(
+// CHECK:         %[[PTR:.+]] = getelementptr inbounds i8, i8* %[[FRAME]], i64 24
+// CHECK:         %[[PARAM:.+]] = bitcast %struct.A* %a1 to i8*
+// CHECK:         call void @llvm.memcpy.p0i8.p0i8.i64(i8* noundef nonnull align 8 dereferenceable(24) %[[PTR]], i8* noundef nonnull align 8 dereferenceable(24) %[[PARAM]], i64 24, i1 false)

llvm/include/llvm/IR/Intrinsics.td

 
 // Coroutine Lowering Intrinsics. Used internally by coroutine passes.
 
 def int_coro_subfn_addr : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_i8_ty],
                                     [IntrReadMem, IntrArgMemOnly,
                                      ReadOnly<ArgIndex<0>>,
                                      NoCapture<ArgIndex<0>>]>;
 
+def int_coro_mark_param : Intrinsic<[], [llvm_ptr_ty], []>;
+
 ///===-------------------------- Other Intrinsics --------------------------===//
 //
 def int_trap : Intrinsic<[], [], [IntrNoReturn, IntrCold]>,
                GCCBuiltin<"__builtin_trap">;
 def int_debugtrap : Intrinsic<[]>,
                     GCCBuiltin<"__builtin_debugtrap">;
 def int_ubsantrap : Intrinsic<[], [llvm_i8_ty],
                               [IntrNoReturn, IntrCold, ImmArg<ArgIndex<0>>]>;

 
 // This instruction has no actual effect, though it is treated by the optimizer
 // has having opaque side effects. This may be inserted into loops to ensure
 // that they are not removed even if they turn out to be empty, for languages
 // which specify that infinite loops must be preserved.
 def int_sideeffect : DefaultAttrsIntrinsic<[], [], [IntrInaccessibleMemOnly, IntrWillReturn]>;
 
 // The pseudoprobe intrinsic works as a place holder to the block it probes.
-// Like the sideeffect intrinsic defined above, this intrinsic is treated by the 
-// optimizer as having opaque side effects so that it won't be get rid of or moved 
+// Like the sideeffect intrinsic defined above, this intrinsic is treated by the
+// optimizer as having opaque side effects so that it won't be get rid of or moved
 // out of the block it probes.
 def int_pseudoprobe : Intrinsic<[], [llvm_i64_ty, llvm_i64_ty, llvm_i32_ty, llvm_i64_ty],
                                     [IntrInaccessibleMemOnly, IntrWillReturn]>;
 
 // Intrinsics to support half precision floating point format
 let IntrProperties = [IntrNoMem, IntrWillReturn] in {
 def int_convert_to_fp16   : DefaultAttrsIntrinsic<[llvm_i16_ty], [llvm_anyfloat_ty]>;
 def int_convert_from_fp16 : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [llvm_i16_ty]>;

llvm/lib/Transforms/Coroutines/CoroSplit.cpp

namespace {
   };
 }
 
 static coro::Shape splitCoroutine(Function &F,
                                   SmallVectorImpl<Function *> &Clones,
                                   bool ReuseFrameSlot) {
   PrettyStackTraceFunction prettyStackTrace(F);
 
+  for (Instruction &I : make_early_inc_range(instructions(F)))
+    if (auto *II = dyn_cast<IntrinsicInst>(&I))
+      if (II->getIntrinsicID() == Intrinsic::coro_mark_param)
+        II->eraseFromParent();
+
   // The suspend-crossing algorithm in buildCoroutineFrame get tripped
   // up by uses in unreachable blocks, so remove them as a first pass.
   removeUnreachableBlocks(F);
 
   coro::Shape Shape(F, ReuseFrameSlot);
   if (!Shape.CoroBegin)
     return Shape;