[Coroutines] Remove lifetime intrinsics for spliied allocas in coroutine frames

Closing #56919

It is meaningless to preserve the lifetime markers for the spilled
allocas in the coroutine frames and it would block some optimizations
too.

Author: ChuanqiXu9

clang/test/CodeGenCoroutines/pr56919.cpp

@@ -0,0 +1,119 @@
+// Test for PR56919. Tests the destroy function contains the call to delete function only.
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 %s -O3 -S -o - | FileCheck %s
+
+#include "Inputs/coroutine.h"
+
+namespace std {
+
+template <typename T> struct remove_reference { using type = T; };
+template <typename T> struct remove_reference<T &> { using type = T; };
+template <typename T> struct remove_reference<T &&> { using type = T; };
+
+template <typename T>
+constexpr typename std::remove_reference<T>::type&& move(T &&t) noexcept {
+  return static_cast<typename std::remove_reference<T>::type &&>(t);
+}
+
+}
+
+template <typename T>
+class Task final {
+ public:
+  using value_type = T;
+
+  class promise_type final {
+   public: 
+    Task<void> get_return_object() { return Task<void>(std::coroutine_handle<promise_type>::from_promise(*this)); }
+
+    void unhandled_exception();
+
+    std::suspend_always initial_suspend() { return {}; }
+
+    auto await_transform(Task<void> co) {
+      return await_transform(std::move(co.handle_.promise()));
+    }
+
+    auto await_transform(promise_type&& awaited) {
+      struct Awaitable {
+        promise_type&& awaited;
+
+        bool await_ready() { return false; }
+
+        std::coroutine_handle<> await_suspend(
+            const std::coroutine_handle<> handle) {
+          // Register our handle to be resumed once the awaited promise's coroutine
+          // finishes, and then resume that coroutine.
+          awaited.registered_handle_ = handle;
+          return std::coroutine_handle<promise_type>::from_promise(awaited);
+        }
+
+        void await_resume() {}
+
+       private:
+      };
+
+      return Awaitable{std::move(awaited)};
+    }
+
+    void return_void() {}
+
+    // At final suspend resume our registered handle.
+    auto final_suspend() noexcept {
+      struct FinalSuspendAwaitable final {
+        bool await_ready() noexcept { return false; }
+
+        std::coroutine_handle<> await_suspend(
+            std::coroutine_handle<> h) noexcept {
+          return to_resume;
+        }
+
+        void await_resume() noexcept {}
+
+        std::coroutine_handle<> to_resume;
+      };
+
+      return FinalSuspendAwaitable{registered_handle_};
+    }
+
+   private:
+    std::coroutine_handle<promise_type> my_handle() {
+      return std::coroutine_handle<promise_type>::from_promise(*this);
+    }
+
+    std::coroutine_handle<> registered_handle_;
+  };
+
+  ~Task() {
+    // Teach llvm that we are only ever destroyed when the coroutine body is done,
+    // so there is no need for the jump table in the destroy function. Our coroutine
+    // library doesn't expose handles to the user, so we know this constraint isn't
+    // violated.
+    if (!handle_.done()) {
+      __builtin_unreachable();
+    }
+
+    handle_.destroy();
+  }
+
+ private:
+  explicit Task(const std::coroutine_handle<promise_type> handle)
+      : handle_(handle) {}
+
+  const std::coroutine_handle<promise_type> handle_;
+};
+
+Task<void> Qux() { co_return; }
+Task<void> Baz() { co_await Qux(); }
+Task<void> Bar() { co_await Baz(); }
+
+// CHECK: _Z3Quxv.destroy:{{.*}}
+// CHECK-NEXT: #
+// CHECK-NEXT: jmp	_ZdlPv
+
+// CHECK: _Z3Bazv.destroy:{{.*}}
+// CHECK-NEXT: #
+// CHECK-NEXT: jmp	_ZdlPv
+
+// CHECK: _Z3Barv.destroy:{{.*}}
+// CHECK-NEXT: #
+// CHECK-NEXT: jmp	_ZdlPv

llvm/lib/Transforms/Coroutines/CoroFrame.cpp

@@ -1777,8 +1777,15 @@ static void insertSpills(const FrameDataInfo &FrameData, coro::Shape &Shape) {
     for (auto *DVI : DIs)
       DVI->replaceUsesOfWith(Alloca, G);
 
-    for (Instruction *I : UsersToUpdate)
+    for (Instruction *I : UsersToUpdate) {
+      // It is meaningless to remain the lifetime intrinsics refer for the
+      // member of coroutine frames and the meaningless lifetime intrinsics
+      // are possible to block further optimizations.
+      if (I->isLifetimeStartOrEnd())
+        continue;
+
       I->replaceUsesOfWith(Alloca, G);
+    }
   }
   Builder.SetInsertPoint(Shape.getInsertPtAfterFramePtr());
   for (const auto &A : FrameData.Allocas) {

llvm/test/Transforms/Coroutines/coro-split-no-lieftime.ll

@@ -0,0 +1,62 @@
+; Tests that the meaningless lifetime intrinsics could be removed after corosplit.
+; RUN: opt < %s -passes='cgscc(coro-split),simplifycfg,early-cse' -S | FileCheck %s
+
+define ptr @f(i1 %n) presplitcoroutine {
+entry:
+  %x = alloca i64
+  %y = alloca i64
+  %id = call token @llvm.coro.id(i32 0, ptr null, ptr null, ptr null)
+  %size = call i32 @llvm.coro.size.i32()
+  %alloc = call ptr @malloc(i32 %size)
+  %hdl = call ptr @llvm.coro.begin(token %id, ptr %alloc)
+  br i1 %n, label %flag_true, label %flag_false
+
+flag_true:
+  call void @llvm.lifetime.start.p0(i64 8, ptr %x)
+  br label %merge
+
+flag_false:
+  call void @llvm.lifetime.start.p0(i64 8, ptr %y)
+  br label %merge
+
+merge:
+  %phi = phi ptr [ %x, %flag_true ], [ %y, %flag_false ]
+  store i8 1, ptr %phi
+  %sp1 = call i8 @llvm.coro.suspend(token none, i1 false)
+  switch i8 %sp1, label %suspend [i8 0, label %resume
+                                  i8 1, label %cleanup]
+resume:
+  call void @print(ptr %phi)
+  call void @llvm.lifetime.end.p0(i64 8, ptr %x)
+  call void @llvm.lifetime.end.p0(i64 8, ptr %y)
+  br label %cleanup
+
+cleanup:
+  %mem = call ptr @llvm.coro.free(token %id, ptr %hdl)
+  call void @free(ptr %mem)
+  br label %suspend
+
+suspend:
+  call i1 @llvm.coro.end(ptr %hdl, i1 0)
+  ret ptr %hdl
+}
+
+; CHECK-NOT: call{{.*}}@llvm.lifetime
+
+declare ptr @llvm.coro.free(token, ptr)
+declare i32 @llvm.coro.size.i32()
+declare i8  @llvm.coro.suspend(token, i1)
+declare void @llvm.coro.resume(ptr)
+declare void @llvm.coro.destroy(ptr)
+
+declare token @llvm.coro.id(i32, ptr, ptr, ptr)
+declare i1 @llvm.coro.alloc(token)
+declare ptr @llvm.coro.begin(token, ptr)
+declare i1 @llvm.coro.end(ptr, i1)
+
+declare void @llvm.lifetime.start.p0(i64, ptr nocapture)
+declare void @llvm.lifetime.end.p0(i64, ptr nocapture)
+
+declare void @print(ptr)
+declare noalias ptr @malloc(i32)
+declare void @free(ptr)