| Issue |
56679
|
| Summary |
PowerPC: fatal error: error in backend: failed to perform tail call elimination on a call site marked musttail
|
| Labels |
new issue
|
| Assignees |
|
| Reporter |
pkubaj
|
FreeBSD 13.1-RELEASE on powerpc / powerpc64 / powerpc64le
LLVM 14.0.6
```
namespace std {
template <bool, class, class _Then> using conditional_t = _Then;
void is_same_v();
template <class _Tp> using remove_cvref_t = _Tp;
template <class = void> struct coroutine_handle;
namespace experimental {
template <class R, class...> struct coroutine_traits : R {};
template <typename Promise>
struct coroutine_handle : std::coroutine_handle<Promise> {};
} // namespace experimental
template <> struct coroutine_handle<> {
coroutine_handle(decltype(nullptr));
void *address() noexcept;
};
template <class> struct coroutine_handle : coroutine_handle<> {
static coroutine_handle from_address(void *) noexcept;
};
struct suspend_always {
bool await_ready();
void await_suspend(coroutine_handle<>);
void await_resume();
};
inline namespace _LIBCPP_ABI_NAMESPACE {
template <long, class> struct tuple_element;
template <class...> class tuple;
template <class...> struct __tuple_types;
template <long _Ip, class... _Types>
struct tuple_element<_Ip, __tuple_types<_Types...>> {
typedef __type_pack_element<_Ip, _Types...> type;
};
template <long _Ip, class... _Tp> struct tuple_element<_Ip, tuple<_Tp...>> {
typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
};
template <long _Ip, class... _Tp>
using tuple_element_t = typename tuple_element<_Ip, _Tp...>::type;
} // namespace _LIBCPP_ABI_NAMESPACE
} // namespace std
namespace QCoro {
template <typename> class AsyncGenerator;
namespace detail {
class AsyncGeneratorYieldOperation;
struct AsyncGeneratorPromiseBase {
std::suspend_always initial_suspend();
AsyncGeneratorYieldOperation final_suspend() noexcept;
void unhandled_exception();
void return_void();
};
struct AsyncGeneratorYieldOperation {
bool await_ready() noexcept;
std::coroutine_handle<> await_suspend(std::coroutine_handle<>) noexcept;
void await_resume() noexcept;
};
struct IteratorAwaitableBase {
IteratorAwaitableBase(AsyncGeneratorPromiseBase, std::coroutine_handle<>);
void await_suspend(std::coroutine_handle<>);
};
struct AsyncGeneratorPromise : AsyncGeneratorPromiseBase {
AsyncGenerator<std::tuple<int, bool>> get_return_object();
};
} // namespace detail
template <typename> struct AsyncGenerator {
using promise_type = detail::AsyncGeneratorPromise;
auto begin() {
struct BeginIteratorAwaitable : detail::IteratorAwaitableBase {
detail::AsyncGeneratorPromise __trans_tmp_1;
BeginIteratorAwaitable(std::coroutine_handle<> producerCoroutine)
: IteratorAwaitableBase(__trans_tmp_1, producerCoroutine) {}
bool await_ready();
void await_resume();
};
return BeginIteratorAwaitable{nullptr};
}
};
} // namespace QCoro
class QWebSocket;
namespace QCoro::detail {
struct QCoroWebSocket {
AsyncGenerator<std::tuple<int>> binaryFrames();
QWebSocket *mWebSocket;
};
namespace concepts {
template <typename>
concept QObject = requires {
std::is_same_v;
};
} // namespace concepts
template <concepts::QObject, typename> struct QCoroSignalQueue;
} // namespace QCoro::detail
template <QCoro::detail::concepts::QObject T, typename FuncPtr>
auto qCoroSignalListener(T, FuncPtr)
-> QCoro::AsyncGenerator<QCoro::detail::QCoroSignalQueue<T, FuncPtr>>;
struct QWebSocket {
void binaryFrameReceived(int, bool);
};
using namespace QCoro::detail;
template <typename> struct signal_args;
template <typename T, typename R, typename... Args>
struct signal_args<R (T::*)(Args...)> {
using types = std::tuple<std::remove_cvref_t<Args>...>;
};
template <typename T> using signal_args_t = typename signal_args<T>::types;
template <typename> struct unwrapped_signal_args;
template <typename... Args> struct unwrapped_signal_args<std::tuple<Args...>> {
using args_tuple = std::tuple<std::remove_cvref_t<Args>...>;
using type =
std::conditional_t<0, std::tuple_element_t<0, args_tuple>, args_tuple>;
};
template <typename... Args>
using unwrapped_signal_args_t = typename unwrapped_signal_args<Args...>::type;
struct WebSocketSignalWatcher {
void ready();
};
template <typename Signal>
auto watcherGenerator(QWebSocket *, Signal)
-> QCoro::AsyncGenerator<unwrapped_signal_args_t<signal_args_t<Signal>>> {
void watcher();
auto signalListener =
qCoroSignalListener(watcher, &WebSocketSignalWatcher::ready);
co_await signalListener.begin();
}
int binaryFrames_timeout;
QCoro::AsyncGenerator<std::tuple<int>> QCoroWebSocket::binaryFrames() {
watcherGenerator(mWebSocket, &QWebSocket::binaryFrameReceived);
}
```
Build with:
`clang++14 -cc1 -triple powerpc-unknown-freebsd13.1 -emit-obj -std=gnu++20 qcorowebsocket-c2cb02.cpp`
![]()
_______________________________________________
llvm-bugs mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-bugs
