| // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -std=c++17 -fsycl-is-host -verify %s | |
| // RUN: %clang_cc1 -triple spirv64-unknown-unknown -fsyntax-only -std=c++17 -fsycl-is-device -verify %s | |
| // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -std=c++20 -fsycl-is-host -verify %s | |
| // RUN: %clang_cc1 -triple spirv64-unknown-unknown -fsyntax-only -std=c++20 -fsycl-is-device -verify %s | |
| // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -std=c++23 -fsycl-is-host -verify %s | |
| // RUN: %clang_cc1 -triple spirv64-unknown-unknown -fsyntax-only -std=c++23 -fsycl-is-device -verify %s | |
| // These tests validate diagnostics for invalid use of 'this' in the body of | |
| // a function declared with the sycl_kernel_entry_point attribute. | |
| template<typename T> struct remove_reference_t { | |
| using type = T; | |
| }; | |
| template<typename T> struct remove_reference_t<T&> { | |
| using type = T; | |
| }; | |
| namespace std { | |
| struct type_info { | |
| virtual ~type_info(); | |
| }; | |
| } // namespace std | |
| // A generic kernel launch function. | |
| template<typename KernelName, typename... Ts> | |
| void sycl_kernel_launch(const char *, Ts...) {} | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // Valid declarations. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| template<int, int=0> struct KN; | |
| struct S1 { | |
| [[clang::sycl_kernel_entry_point(KN<1>)]] void ok1() { | |
| (void)sizeof(this); | |
| } | |
| }; | |
| struct S2 { | |
| [[clang::sycl_kernel_entry_point(KN<2>)]] void ok2() { | |
| (void)noexcept(this); | |
| } | |
| }; | |
| struct S3 { | |
| [[clang::sycl_kernel_entry_point(KN<3>)]] void ok3() { | |
| decltype(this) x = nullptr; | |
| } | |
| }; | |
| struct S4 { | |
| static void smf(); | |
| [[clang::sycl_kernel_entry_point(KN<4>)]] void ok4() { | |
| remove_reference_t<decltype(*this)>::type::smf(); | |
| } | |
| }; | |
| struct S5 { | |
| int dm; | |
| void mf(); | |
| [[clang::sycl_kernel_entry_point(KN<5>)]] void ok5() { | |
| (void)typeid(*this); // S5 is not abstract, so 'this' is not evaluated. | |
| (void)typeid(dm); // 'int' is not an abstract class type; implicit 'this' is not evaluated. | |
| (void)typeid(mf()); // 'void' is not an abstract class type; implicit 'this' is not evaluated. | |
| } | |
| }; | |
| template<typename KN, bool B> | |
| struct S6 { | |
| void mf() noexcept(B); | |
| [[clang::sycl_kernel_entry_point(KN)]] void ok6() noexcept(noexcept(mf())) {} | |
| }; | |
| template void S6<KN<6,0>, false>::ok6(); | |
| template void S6<KN<6,1>, true>::ok6(); | |
| template<typename KN, bool B> | |
| struct S7 { | |
| void mf() noexcept(B); | |
| [[clang::sycl_kernel_entry_point(KN)]] void ok7() noexcept(noexcept(this->mf())) {} | |
| }; | |
| template void S7<KN<7,0>, false>::ok7(); | |
| template void S7<KN<7,1>, true>::ok7(); | |
| #if __cplusplus >= 202002L | |
| template<typename KN, typename T> | |
| struct S8 { | |
| void mf(T); | |
| [[clang::sycl_kernel_entry_point(KN)]] void ok8() requires(requires { mf(1); }) {} | |
| }; | |
| template void S8<KN<8>, int>::ok8(); | |
| template<typename KN, typename T> | |
| struct S9 { | |
| void mf(T); | |
| [[clang::sycl_kernel_entry_point(KN)]] void ok9() requires(requires { this->mf(1); }) {} | |
| }; | |
| template void S9<KN<9>, int>::ok9(); | |
| #endif | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // Invalid declarations. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| template<int, int=0> struct BADKN; | |
| // expected-error@+3 {{'this' cannot be used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| struct B1 { | |
| [[clang::sycl_kernel_entry_point(BADKN<1>)]] void bad1() { | |
| (void)this; | |
| } | |
| }; | |
| // expected-error@+4 {{'this' cannot be implicitly used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| struct B2 { | |
| int dm; | |
| [[clang::sycl_kernel_entry_point(BADKN<2>)]] void bad2() { | |
| (void)dm; | |
| } | |
| }; | |
| // expected-error@+4 {{'this' cannot be implicitly used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| struct B3 { | |
| void mf(); | |
| [[clang::sycl_kernel_entry_point(BADKN<3>)]] void bad3() { | |
| (void)mf(); | |
| } | |
| }; | |
| // expected-error@+4 {{'this' cannot be used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| struct B4 { | |
| virtual void vmf() = 0; | |
| [[clang::sycl_kernel_entry_point(BADKN<4>)]] void bad4() { | |
| (void)typeid(*this); // B4 is abstract, so 'this' is evaluated. | |
| } | |
| }; | |
| // A diagnostic is not currently issued for uninstantiated definitions. In this | |
| // case, a declaration is instantiated, but a definition isn't. A diagnostic | |
| // will be issued if a definition is instantiated (as the next test exercises). | |
| struct B5 { | |
| template<typename KN> | |
| [[clang::sycl_kernel_entry_point(KN)]] void bad5() { | |
| (void)this; | |
| } | |
| }; | |
| extern template void B5::bad5<BADKN<5>>(); | |
| // expected-error@+4 {{'this' cannot be used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| struct B6 { | |
| template<typename KN> | |
| [[clang::sycl_kernel_entry_point(KN)]] void bad6() { | |
| (void)this; | |
| } | |
| }; | |
| // expected-note@+1 {{in instantiation of function template specialization 'B6::bad6<BADKN<6>>' requested here}} | |
| template void B6::bad6<BADKN<6>>(); | |
| // A diagnostic is not currently issued for uninstantiated definitions. In this | |
| // case, a declaration is instantiated, but a definition isn't. A diagnostic | |
| // will be issued if a definition is instantiated (as the next test exercises). | |
| template<typename KN> | |
| struct B7 { | |
| [[clang::sycl_kernel_entry_point(KN)]] void bad7() { | |
| (void)this; | |
| } | |
| }; | |
| extern template void B7<BADKN<7>>::bad7(); | |
| // expected-error@+4 {{'this' cannot be used in a potentially evaluated expression in the body of a function declared with the 'clang::sycl_kernel_entry_point' attribute}} | |
| template<typename KN> | |
| struct B8 { | |
| [[clang::sycl_kernel_entry_point(KN)]] void bad8() { | |
| (void)this; | |
| } | |
| }; | |
| // expected-note@+1 {{in instantiation of member function 'B8<BADKN<8>>::bad8' requested here}} | |
| template void B8<BADKN<8>>::bad8(); | |
| #if __cplusplus >= 202302L | |
| struct B9 { | |
| // expected-error@+1 {{the 'clang::sycl_kernel_entry_point' attribute cannot be applied to a function with an explicit object parameter}} | |
| [[clang::sycl_kernel_entry_point(BADKN<9>)]] void bad9(this B9 self) { | |
| (void)self; | |
| } | |
| }; | |
| #endif |