c36156de45
Fixes: https://github.com/llvm/llvm-project/issues/148953
Currently when coroutine return object type is const qualified, we don't
do direct emission. The regular emission logic assumed that the auto var
emission will always result in an `AllocaInst`. However, based on my
findings, NRVO var emissions don't result in `AllocaInst`s. Therefore,
this
[assertion](1a940bfff9/clang/lib/CodeGen/CGCoroutine.cpp (L712))
will fail.
Since the NRVOed returned object don't live on the coroutine frame, we
won't have the problem of it outliving the coroutine frame, therefore,
we can safely omit this metadata.
137 lines
4.5 KiB
C++
137 lines
4.5 KiB
C++
// Verifies lifetime of __gro local variable
|
|
// Verify that coroutine promise and allocated memory are freed up on exception.
|
|
// RUN: %clang_cc1 -std=c++20 -triple=x86_64-unknown-linux-gnu -emit-llvm -o - %s -disable-llvm-passes | FileCheck %s
|
|
|
|
#include "Inputs/coroutine.h"
|
|
|
|
using namespace std;
|
|
|
|
struct GroType {
|
|
~GroType();
|
|
operator int() noexcept;
|
|
};
|
|
|
|
template <> struct std::coroutine_traits<int> {
|
|
struct promise_type {
|
|
GroType get_return_object() noexcept;
|
|
suspend_always initial_suspend() noexcept;
|
|
suspend_always final_suspend() noexcept;
|
|
void return_void() noexcept;
|
|
promise_type();
|
|
~promise_type();
|
|
void unhandled_exception() noexcept;
|
|
};
|
|
};
|
|
|
|
struct Cleanup { ~Cleanup(); };
|
|
void doSomething() noexcept;
|
|
|
|
// CHECK: define{{.*}} i32 @_Z1fv(
|
|
int f() {
|
|
// CHECK: %[[RetVal:.+]] = alloca i32
|
|
// CHECK: %[[GroActive:.+]] = alloca i1
|
|
// CHECK: %[[CoroGro:.+]] = alloca %struct.GroType, {{.*}} !coro.outside.frame ![[OutFrameMetadata:.+]]
|
|
|
|
// CHECK: %[[Size:.+]] = call i64 @llvm.coro.size.i64()
|
|
// CHECK: call noalias noundef nonnull ptr @_Znwm(i64 noundef %[[Size]])
|
|
// CHECK: store i1 false, ptr %[[GroActive]]
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_typeC1Ev(
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_type17get_return_objectEv({{.*}} %[[CoroGro]]
|
|
// CHECK: store i1 true, ptr %[[GroActive]]
|
|
|
|
Cleanup cleanup;
|
|
doSomething();
|
|
co_return;
|
|
|
|
// CHECK: call void @_Z11doSomethingv(
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_type11return_voidEv(
|
|
// CHECK: call void @_ZN7CleanupD1Ev(
|
|
|
|
// Destroy promise and free the memory.
|
|
|
|
// CHECK: call void @_ZNSt16coroutine_traitsIiJEE12promise_typeD1Ev(
|
|
// CHECK: %[[Mem:.+]] = call ptr @llvm.coro.free(
|
|
// CHECK: %[[SIZE:.+]] = call i64 @llvm.coro.size.i64()
|
|
// CHECK: call void @_ZdlPvm(ptr noundef %[[Mem]], i64 noundef %[[SIZE]])
|
|
|
|
// Initialize retval from Gro and destroy Gro
|
|
// Note this also tests delaying initialization when Gro and function return
|
|
// types mismatch (see cwg2563).
|
|
|
|
// CHECK: %[[Conv:.+]] = call noundef i32 @_ZN7GroTypecviEv(
|
|
// CHECK: store i32 %[[Conv]], ptr %[[RetVal]]
|
|
// CHECK: %[[IsActive:.+]] = load i1, ptr %[[GroActive]]
|
|
// CHECK: br i1 %[[IsActive]], label %[[CleanupGro:.+]], label %[[Done:.+]]
|
|
|
|
// CHECK: [[CleanupGro]]:
|
|
// CHECK: call void @_ZN7GroTypeD1Ev(
|
|
// CHECK: br label %[[Done]]
|
|
|
|
// CHECK: [[Done]]:
|
|
// CHECK: %[[LoadRet:.+]] = load i32, ptr %[[RetVal]]
|
|
// CHECK: ret i32 %[[LoadRet]]
|
|
}
|
|
|
|
class invoker {
|
|
public:
|
|
class invoker_promise {
|
|
public:
|
|
invoker get_return_object() { return invoker{}; }
|
|
auto initial_suspend() { return suspend_always{}; }
|
|
auto final_suspend() noexcept { return suspend_always{}; }
|
|
void return_void() {}
|
|
void unhandled_exception() {}
|
|
};
|
|
using promise_type = invoker_promise;
|
|
invoker() {}
|
|
invoker(const invoker &) = delete;
|
|
invoker &operator=(const invoker &) = delete;
|
|
invoker(invoker &&) = delete;
|
|
invoker &operator=(invoker &&) = delete;
|
|
};
|
|
|
|
// According to cwg2563, matching GRO and function return type must allow
|
|
// for eager initialization and RVO.
|
|
// CHECK: define{{.*}} void @_Z1gv({{.*}} %[[AggRes:.+]])
|
|
invoker g() {
|
|
// CHECK: %[[ResultPtr:.+]] = alloca ptr
|
|
// CHECK-NEXT: %[[Promise:.+]] = alloca %"class.invoker::invoker_promise"
|
|
|
|
// CHECK: store ptr %[[AggRes]], ptr %[[ResultPtr]]
|
|
// CHECK: coro.init:
|
|
// CHECK: = call ptr @llvm.coro.begin
|
|
|
|
// delayed GRO pattern stores a GRO active flag, make sure to not emit it.
|
|
// CHECK-NOT: store i1 false, ptr
|
|
// CHECK: call void @_ZN7invoker15invoker_promise17get_return_objectEv({{.*}} %[[AggRes]]
|
|
co_return;
|
|
}
|
|
|
|
namespace gh148953 {
|
|
|
|
struct Task {
|
|
struct promise_type {
|
|
Task get_return_object();
|
|
std::suspend_always initial_suspend() { return {}; }
|
|
std::suspend_always final_suspend() noexcept { return {}; }
|
|
void return_void() {}
|
|
void unhandled_exception() {}
|
|
};
|
|
Task() {}
|
|
// Different from `invoker`, this Task is copy constructible.
|
|
Task(const Task&) {};
|
|
};
|
|
|
|
// NRVO on const qualified return type should work.
|
|
// CHECK: define{{.*}} void @_ZN8gh1489537exampleEv({{.*}} sret(%"struct.gh148953::Task") align 1 %[[NrvoRes:.+]])
|
|
const Task example() {
|
|
// CHECK: %[[ResultPtr:.+]] = alloca ptr
|
|
// CHECK: store ptr %[[NrvoRes]], ptr %[[ResultPtr]]
|
|
// CHECK: coro.init:
|
|
// CHECK: call void @_ZN8gh1489534Task12promise_type17get_return_objectEv({{.*}} %[[NrvoRes:.+]], {{.*}})
|
|
co_return;
|
|
}
|
|
|
|
} // namespace gh148953
|
|
// CHECK: ![[OutFrameMetadata]] = !{}
|