https://github.com/piotrrak updated
https://github.com/llvm/llvm-project/pull/153508
>From 7e6c169841ca612e01ca39e9f85ac4f87cf7c9d4 Mon Sep 17 00:00:00 2001
From: Piotr Rak <piotr....@gmail.com>
Date: Wed, 13 Aug 2025 22:00:22 +0200
Subject: [PATCH 1/2] [OpenCLCpp] Avoid inferred adding address-space to
function types
The default OpenCL address-space was added for function types, which was
breaking transform type builtins for function types, in particular:
- __remove_reference_t
- __remove_cvref
- __remove_pointer
This change fixes SemaCXX/type-traits.cpp pass for clc++ dialect.
(In feature set of clc++ and extension - ie. no VLA, _Atomic etc...)
There is still unaddressed issue with address space of member-fn-ptr
in __is_same trait builtin as address-space specified by user is
ignored on such types.
This is seperate unrelated issue and won't be addressed in this change.
---
clang/lib/Sema/SemaType.cpp | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 0985b5b565dab..cba71b62bbf33 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -1793,9 +1793,11 @@ bool Sema::CheckQualifiedFunctionForTypeId(QualType T,
SourceLocation Loc) {
}
// Helper to deduce addr space of a pointee type in OpenCL mode.
-static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType) {
+static QualType deduceOpenCLPointeeAddrSpace(Sema &S, QualType PointeeType,
+ bool IsBlock) {
if (!PointeeType->isUndeducedAutoType() && !PointeeType->isDependentType() &&
!PointeeType->isSamplerT() &&
+ (!PointeeType->isFunctionType() || IsBlock) &&
!PointeeType.hasAddressSpace())
PointeeType = S.getASTContext().getAddrSpaceQualType(
PointeeType, S.getASTContext().getDefaultOpenCLPointeeAddrSpace());
@@ -1834,7 +1836,7 @@ QualType Sema::BuildPointerType(QualType T,
T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false);
if (getLangOpts().OpenCL)
- T = deduceOpenCLPointeeAddrSpace(*this, T);
+ T = deduceOpenCLPointeeAddrSpace(*this, T, /*IsBlock*/ false);
// In WebAssembly, pointers to reference types and pointers to tables are
// illegal.
@@ -1911,7 +1913,7 @@ QualType Sema::BuildReferenceType(QualType T, bool
SpelledAsLValue,
T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true);
if (getLangOpts().OpenCL)
- T = deduceOpenCLPointeeAddrSpace(*this, T);
+ T = deduceOpenCLPointeeAddrSpace(*this, T, /*IsBlock*/ false);
// In WebAssembly, references to reference types and tables are illegal.
if (getASTContext().getTargetInfo().getTriple().isWasm() &&
@@ -2766,7 +2768,7 @@ QualType Sema::BuildBlockPointerType(QualType T,
return QualType();
if (getLangOpts().OpenCL)
- T = deduceOpenCLPointeeAddrSpace(*this, T);
+ T = deduceOpenCLPointeeAddrSpace(*this, T, /*IsBlock*/ true);
return Context.getBlockPointerType(T);
}
>From bfd989ddaaa3a3b4861d2acf67de0eeb4a7d8fb2 Mon Sep 17 00:00:00 2001
From: Piotr Rak <piotr....@gmail.com>
Date: Fri, 1 Aug 2025 12:23:54 +0200
Subject: [PATCH 2/2] [OpenCLCpp] Enable type-traits tests for clc++
---
clang/test/SemaCXX/type-traits.cpp | 491 ++++++++++++++++--
.../SemaOpenCLCXX/address-space-traits.clcpp | 29 ++
2 files changed, 491 insertions(+), 29 deletions(-)
create mode 100644 clang/test/SemaOpenCLCXX/address-space-traits.clcpp
diff --git a/clang/test/SemaCXX/type-traits.cpp
b/clang/test/SemaCXX/type-traits.cpp
index 3f0124755c674..96298f9156f90 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -1,8 +1,19 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify
-std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted
-Wno-c++17-extensions %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify
-std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted
-Wno-c++17-extensions %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify
-std=gnu++17 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted
%s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify
-std=gnu++20 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted
%s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only
-verify=expected,expected-noncl -std=gnu++11 -fblocks -Wno-deprecated-builtins
-Wno-defaulted-function-deleted -Wno-c++17-extensions %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only
-verify=expected,expected-noncl -std=gnu++14 -fblocks -Wno-deprecated-builtins
-Wno-defaulted-function-deleted -Wno-c++17-extensions %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only
-verify=expected,expected-noncl -std=gnu++17 -fblocks -Wno-deprecated-builtins
-Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only
-verify=expected,expected-noncl -std=gnu++20 -fblocks -Wno-deprecated-builtins
-Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple spirv64-none-none -fsyntax-only -fno-rtti
-verify=expected,expected-cl -cl-std=clc++2021 -Wno-deprecated-builtins
-Wno-defaulted-function-deleted
-cl-ext=+__cl_clang_variadic_functions,+__cl_clang_function_pointers,+__cl_clang_bitfields
-DVANILLAOPENCLCPLUSPLUS %s
+// RUN: %clang_cc1 -triple spirv64-none-none -fsyntax-only -fno-rtti
-verify=expected,expected-cl -cl-std=clc++2021 -Wno-deprecated-builtins
-Wno-defaulted-function-deleted
-cl-ext=+__cl_clang_variadic_functions,+__cl_clang_function_pointers,+__cl_clang_bitfields
-DEXTOPENCLCPLUSPLUS %s
+
+#if defined(EXTOPENCLCPLUSPLUS)
+#pragma OPENCL EXTENSION __cl_clang_variadic_functions : enable
+#pragma OPENCL EXTENSION __cl_clang_function_pointers : enable
+#pragma OPENCL EXTENSION __cl_clang_bitfields : enable
+#endif
+#if defined(EXTOPENCLCPLUSPLUS) || defined(VANILLAOPENCLCPLUSPLUS)
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+#endif
struct NonPOD { NonPOD(int); };
typedef NonPOD NonPODAr[10];
@@ -111,9 +122,16 @@ class HasProt { protected: int prot; };
struct HasRef { int i; int& ref; HasRef() : i(0), ref(i) {} };
struct HasRefAggregate { int i; int& ref; };
struct HasNonPOD { NonPOD np; };
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+struct HasVirt { virtual void Virt() {}; };
+#else
struct HasVirt { virtual void Virt() {}; };
+//expected-error@-1 {{virtual functions are not supported in C++ for OpenCL}}
+#endif
typedef NonPOD NonPODAr[10];
+#if !defined(VANILLAOPENCLCPLUSPLUS)
typedef HasVirt VirtAr[10];
+#endif
typedef NonPOD NonPODArNB[];
union NonPODUnion { int i; Derives n; };
struct DerivesHasCons : HasCons {};
@@ -123,7 +141,9 @@ struct DerivesHasDest : HasDest {};
struct DerivesHasPriv : HasPriv {};
struct DerivesHasProt : HasProt {};
struct DerivesHasRef : HasRef {};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct DerivesHasVirt : HasVirt {};
+#endif
struct DerivesHasMoveCtor : HasMoveCtor {};
struct HasNoThrowCopyAssign {
@@ -161,9 +181,14 @@ struct HasMultipleNoThrowCopy {
HasMultipleNoThrowCopy(volatile HasMultipleNoThrowCopy&) throw();
};
+#if defined(VANILLAOPENCLCPLUSPLUS)
+struct HasVirtDest { virtual ~HasVirtDest(); };
+//expected-error@-1 {{virtual functions are not supported in C++ for OpenCL}}
+#else
struct HasVirtDest { virtual ~HasVirtDest(); };
struct DerivedVirtDest : HasVirtDest {};
typedef HasVirtDest VirtDestAr[1];
+#endif
class AllPrivate {
AllPrivate() throw();
@@ -244,13 +269,17 @@ void is_pod()
static_assert(!__is_pod(HasMoveAssign));
static_assert(!__is_pod(HasDest));
static_assert(!__is_pod(HasRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_pod(HasVirt));
+#endif
static_assert(!__is_pod(DerivesHasCons));
static_assert(!__is_pod(DerivesHasCopyAssign));
static_assert(!__is_pod(DerivesHasMoveAssign));
static_assert(!__is_pod(DerivesHasDest));
static_assert(!__is_pod(DerivesHasRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_pod(DerivesHasVirt));
+#endif
static_assert(!__is_pod(NonPOD));
static_assert(!__is_pod(HasNonPOD));
static_assert(!__is_pod(NonPODAr));
@@ -266,11 +295,13 @@ void is_pod()
}
typedef Empty EmptyAr[10];
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct Bit0 { int : 0; };
struct Bit0Cons { int : 0; Bit0Cons(); };
struct AnonBitOnly { int : 3; };
struct BitOnly { int x : 3; };
struct DerivesVirt : virtual POD {};
+#endif
void is_empty()
{
@@ -284,8 +315,10 @@ void is_empty()
static_assert(__is_empty(HasOp));
static_assert(__is_empty(HasConv));
static_assert(__is_empty(HasAssign));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_empty(Bit0));
static_assert(__is_empty(Bit0Cons));
+#endif
static_assert(!__is_empty(Int));
static_assert(!__is_empty(POD));
@@ -293,9 +326,11 @@ void is_empty()
static_assert(!__is_empty(IncompleteUnion));
static_assert(!__is_empty(EmptyAr));
static_assert(!__is_empty(HasRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_empty(HasVirt));
static_assert(!__is_empty(AnonBitOnly));
static_assert(!__is_empty(BitOnly));
+#endif
static_assert(!__is_empty(void));
static_assert(!__is_empty(IntArNB));
static_assert(!__is_empty(HasAnonymousUnion));
@@ -442,13 +477,17 @@ void is_final()
}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
typedef HasVirt Polymorph;
struct InheritPolymorph : Polymorph {};
+#endif
void is_polymorphic()
{
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_polymorphic(Polymorph));
static_assert(__is_polymorphic(InheritPolymorph));
+#endif
static_assert(!__is_polymorphic(int));
static_assert(!__is_polymorphic(Union));
@@ -590,8 +629,10 @@ void is_aggregate()
static_assert(!__is_aggregate(HasProt));
static_assert(__is_aggregate(HasRefAggregate));
static_assert(__is_aggregate(HasNonPOD));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_aggregate(HasVirt));
static_assert(__is_aggregate(VirtAr));
+#endif
static_assert(__is_aggregate(HasInClassInit) == TrueAfterCpp11);
static_assert(!__is_aggregate(HasPrivateBase));
static_assert(!__is_aggregate(HasProtectedBase));
@@ -747,8 +788,10 @@ void is_bounded_array(int n) {
static_assert(!__is_bounded_array(void *));
static_assert(!__is_bounded_array(cvoid *));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
int t32[n];
(void)__is_bounded_array(decltype(t32)); // expected-error{{variable length
arrays are not supported in '__is_bounded_array'}}
+#endif
}
void is_unbounded_array(int n) {
@@ -780,8 +823,10 @@ void is_unbounded_array(int n) {
static_assert(!__is_unbounded_array(void *));
static_assert(!__is_unbounded_array(cvoid *));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
int t32[n];
(void)__is_unbounded_array(decltype(t32)); // expected-error{{variable
length arrays are not supported in '__is_unbounded_array'}}
+#endif
}
template <typename T> void tmpl_func(T&) {}
@@ -794,10 +839,15 @@ template <typename T> struct type_wrapper {
void is_function()
{
+#if !defined(VANILLAOPENCLCPLUSPLUS)&& !defined(EXTOPENCLCPLUSPLUS)
+ // Requires RTTI
static_assert(__is_function(type_wrapper<void(void)>::type));
static_assert(__is_function(typeof(tmpl_func<int>)));
+#endif
+#if !defined(VANILLAOPENCLCPLUSPLUS)
typedef void (*ptr_to_func_type)(void);
+#endif
static_assert(!__is_function(void));
static_assert(!__is_function(cvoid));
@@ -821,10 +871,12 @@ void is_function()
static_assert(!__is_function(Enum));
static_assert(!__is_function(void*));
static_assert(!__is_function(cvoid*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_function(void(*)()));
static_assert(!__is_function(ptr_to_func_type));
static_assert(!__is_function(type_wrapper<void(void)>::ptrtype));
static_assert(!__is_function(type_wrapper<void(void)>::reftype));
+#endif
}
void is_reference()
@@ -908,7 +960,9 @@ void is_object()
static_assert(__is_object(ClassType));
static_assert(__is_object(Enum));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_object(type_wrapper<void(void)>::type));
+#endif
static_assert(!__is_object(int&));
static_assert(!__is_object(void));
}
@@ -951,9 +1005,11 @@ void is_compound()
{
static_assert(__is_compound(void*));
static_assert(__is_compound(cvoid*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_compound(void (*)()));
static_assert(__is_compound(int StructWithMembers::*));
static_assert(__is_compound(void (StructWithMembers::*)()));
+#endif
static_assert(__is_compound(int&));
static_assert(__is_compound(Union));
static_assert(__is_compound(UnionAr));
@@ -997,7 +1053,10 @@ void is_pointer()
static_assert(__is_pointer(Union*));
static_assert(__is_pointer(UnionAr*));
static_assert(__is_pointer(StructWithMembers*));
+
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_pointer(void (*)()));
+#endif
static_assert(!__is_pointer(void));
static_assert(!__is_pointer(cvoid));
@@ -1013,7 +1072,9 @@ void is_pointer()
static_assert(!__is_pointer(UnionAr));
static_assert(!__is_pointer(StructWithMembers));
static_assert(!__is_pointer(int StructWithMembers::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_pointer(void (StructWithMembers::*) ()));
+#endif
}
void is_member_object_pointer()
@@ -1022,7 +1083,9 @@ void is_member_object_pointer()
static_assert(__is_member_object_pointer(int StructWithMembers::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_member_object_pointer(void (StructWithMembers::*) ()));
+#endif
static_assert(!__is_member_object_pointer(void*));
static_assert(!__is_member_object_pointer(cvoid*));
static_assert(!__is_member_object_pointer(cvoid*));
@@ -1049,14 +1112,18 @@ void is_member_object_pointer()
static_assert(!__is_member_object_pointer(Union));
static_assert(!__is_member_object_pointer(UnionAr));
static_assert(!__is_member_object_pointer(StructWithMembers));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_member_object_pointer(void (*)()));
+#endif
}
void is_member_function_pointer()
{
StructWithMembers x;
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_member_function_pointer(void (StructWithMembers::*) ()));
+#endif
static_assert(!__is_member_function_pointer(int StructWithMembers::*));
static_assert(!__is_member_function_pointer(void*));
@@ -1085,7 +1152,9 @@ void is_member_function_pointer()
static_assert(!__is_member_function_pointer(Union));
static_assert(!__is_member_function_pointer(UnionAr));
static_assert(!__is_member_function_pointer(StructWithMembers));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_member_function_pointer(void (*)()));
+#endif
}
void is_member_pointer()
@@ -1093,7 +1162,9 @@ void is_member_pointer()
StructWithMembers x;
static_assert(__is_member_pointer(int StructWithMembers::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_member_pointer(void (StructWithMembers::*) ()));
+#endif
static_assert(!__is_member_pointer(void*));
static_assert(!__is_member_pointer(cvoid*));
@@ -1121,7 +1192,9 @@ void is_member_pointer()
static_assert(!__is_member_pointer(Union));
static_assert(!__is_member_pointer(UnionAr));
static_assert(!__is_member_pointer(StructWithMembers));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_member_pointer(void (*)()));
+#endif
}
void is_const()
@@ -1392,12 +1465,14 @@ struct CppStructNonStandardByBase : CStruct {
int three;
int four;
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct CppStructNonStandardByVirt : CStruct {
virtual void method() {}
};
struct CppStructNonStandardByMemb : CStruct {
CppStructNonStandardByVirt member;
};
+#endif
struct CppStructNonStandardByProt : CStruct {
int five;
protected:
@@ -1429,8 +1504,10 @@ void is_standard_layout()
typedef CppStructNonStandardByBase CppStructNonStandardByBaseAr[4];
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_standard_layout(CppStructNonStandardByVirt));
static_assert(!__is_standard_layout(CppStructNonStandardByMemb));
+#endif
static_assert(!__is_standard_layout(CppStructNonStandardByProt));
static_assert(!__is_standard_layout(CppStructNonStandardByVirtBase));
static_assert(!__is_standard_layout(CppStructNonStandardByBase));
@@ -1445,6 +1522,7 @@ void is_standard_layout()
static_assert(!__is_standard_layout(void));
static_assert(!__is_standard_layout(const volatile void));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct HasAnonEmptyBitfield { int : 0; };
struct HasAnonBitfield { int : 4; };
struct DerivesFromBitfield : HasAnonBitfield {};
@@ -1456,6 +1534,7 @@ void is_standard_layout()
static_assert(__is_standard_layout(DerivesFromBitfield));
static_assert(!__is_standard_layout(DerivesFromBitfieldWithBitfield));
static_assert(!__is_standard_layout(DerivesFromBitfieldTwice));
+#endif
struct Empty {};
struct HasEmptyBase : Empty {};
@@ -1467,7 +1546,9 @@ void is_standard_layout()
struct HasEmptyBaseAsSubobjectOfMember3 : Empty { HoldsEmptyBase e[2]; };
struct HasEmptyIndirectBaseAsMember : HasEmptyBase { Empty e; };
struct HasEmptyIndirectBaseAsSecondMember : HasEmptyBase { int n; Empty e; };
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct HasEmptyIndirectBaseAfterBitfield : HasEmptyBase { int : 4; Empty e;
};
+#endif
static_assert(__is_standard_layout(Empty));
static_assert(__is_standard_layout(HasEmptyBase));
@@ -1478,7 +1559,9 @@ void is_standard_layout()
static_assert(!__is_standard_layout(HasEmptyBaseAsSubobjectOfMember3));
static_assert(!__is_standard_layout(HasEmptyIndirectBaseAsMember));
static_assert(__is_standard_layout(HasEmptyIndirectBaseAsSecondMember));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_standard_layout(HasEmptyIndirectBaseAfterBitfield)); //
FIXME: standard bug?
+#endif
struct StructWithEmptyFields {
int n;
@@ -1515,12 +1598,14 @@ struct CppStructNonStandardByBase2 : CStruct2 {
int three;
int four;
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct CppStructNonStandardByVirt2 : CStruct2 {
virtual void method() {}
};
struct CppStructNonStandardByMemb2 : CStruct2 {
CppStructNonStandardByVirt member;
};
+#endif
struct CppStructNonStandardByProt2 : CStruct2 {
int five;
protected:
@@ -1579,6 +1664,7 @@ struct CStructNested2 {
int b2;
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct CStructWithBitfelds {
int a : 5;
int : 0;
@@ -1598,6 +1684,7 @@ struct CStructWithBitfelds4 {
EnumLayout a : 5;
int : 0;
};
+#endif
union UnionLayout {
int a;
@@ -1694,22 +1781,29 @@ void is_layout_compatible(int n)
static_assert(__is_layout_compatible(int, volatile int));
static_assert(__is_layout_compatible(const int, volatile int));
static_assert(__is_layout_compatible(int *, int * __restrict));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
// Note: atomic qualification matters for layout compatibility.
+ // Note: OpenCL no _Atomic
static_assert(!__is_layout_compatible(int, _Atomic int));
static_assert(__is_layout_compatible(_Atomic(int), _Atomic int));
+#endif
static_assert(!__is_layout_compatible(int, unsigned int));
static_assert(!__is_layout_compatible(char, unsigned char));
static_assert(!__is_layout_compatible(char, signed char));
static_assert(!__is_layout_compatible(unsigned char, signed char));
static_assert(__is_layout_compatible(int[], int[]));
static_assert(__is_layout_compatible(int[2], int[2]));
+ // OpenCLCPP: No VLA
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__is_layout_compatible(int[n], int[2]));
// expected-error@-1 {{variable length arrays are not supported in
'__is_layout_compatible'}}
static_assert(!__is_layout_compatible(int[n], int[n]));
// expected-error@-1 {{variable length arrays are not supported in
'__is_layout_compatible'}}
// expected-error@-2 {{variable length arrays are not supported in
'__is_layout_compatible'}}
+#endif
static_assert(__is_layout_compatible(int&, int&));
static_assert(!__is_layout_compatible(int&, char&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_layout_compatible(void(int), void(int)));
static_assert(!__is_layout_compatible(void(int), void(char)));
static_assert(__is_layout_compatible(void(&)(int), void(&)(int)));
@@ -1725,7 +1819,9 @@ void is_layout_compatible(int n)
// expected-warning@-1 {{'const' qualifier on function type 'function_type'
(aka 'void ()') has no effect}}
static_assert(!__is_layout_compatible(const function_type, const
function_type2));
// expected-warning@-1 {{'const' qualifier on function type 'function_type'
(aka 'void ()') has no effect}}
- // expected-warning@-2 {{'const' qualifier on function type 'function_type2'
(aka 'void (char)') has no effect}}
+ // expected-noncl-warning@-2 {{'const' qualifier on function type
'function_type2' (aka 'void (char)') has no effect}}
+ // expected-cl-warning@-3 {{'const' qualifier on function type
'function_type2' (aka 'void (__private char)') has no effect}}
+#endif
static_assert(__is_layout_compatible(CStruct, CStruct2));
static_assert(__is_layout_compatible(CStruct, const CStruct2));
static_assert(__is_layout_compatible(CStruct, volatile CStruct2));
@@ -1734,26 +1830,34 @@ void is_layout_compatible(int n)
static_assert(__is_layout_compatible(CppEmptyStruct, CppEmptyStruct2));
static_assert(__is_layout_compatible(CppStructStandard, CppStructStandard2));
static_assert(!__is_layout_compatible(CppStructNonStandardByBase,
CppStructNonStandardByBase2));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_layout_compatible(CppStructNonStandardByVirt,
CppStructNonStandardByVirt2));
static_assert(!__is_layout_compatible(CppStructNonStandardByMemb,
CppStructNonStandardByMemb2));
+#endif
static_assert(!__is_layout_compatible(CppStructNonStandardByProt,
CppStructNonStandardByProt2));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_layout_compatible(CppStructNonStandardByVirtBase,
CppStructNonStandardByVirtBase2));
static_assert(!__is_layout_compatible(CppStructNonStandardBySameBase,
CppStructNonStandardBySameBase2));
static_assert(!__is_layout_compatible(CppStructNonStandardBy2ndVirtBase,
CppStructNonStandardBy2ndVirtBase2));
+#endif
static_assert(__is_layout_compatible(CStruct, CStructWithQualifiers));
static_assert(__is_layout_compatible(CStruct, CStructNoUniqueAddress) !=
bool(__has_cpp_attribute(no_unique_address)));
static_assert(__is_layout_compatible(CStructNoUniqueAddress,
CStructNoUniqueAddress2) != bool(__has_cpp_attribute(no_unique_address)));
static_assert(__is_layout_compatible(CStruct, CStructAlignment));
static_assert(!__is_layout_compatible(CStruct, CStructAlignedMembers));
static_assert(__is_layout_compatible(UnionNoOveralignedMembers,
UnionWithOveralignedMembers));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_layout_compatible(CStructWithBitfelds,
CStructWithBitfelds));
static_assert(__is_layout_compatible(CStructWithBitfelds,
CStructWithBitfelds2));
static_assert(!__is_layout_compatible(CStructWithBitfelds,
CStructWithBitfelds3));
static_assert(!__is_layout_compatible(CStructWithBitfelds,
CStructWithBitfelds4));
+#endif
static_assert(__is_layout_compatible(int CStruct2::*, int CStruct2::*));
static_assert(!__is_layout_compatible(int CStruct2::*, char CStruct2::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_layout_compatible(void(CStruct2::*)(int),
void(CStruct2::*)(int)));
static_assert(!__is_layout_compatible(void(CStruct2::*)(int),
void(CStruct2::*)(char)));
+#endif
static_assert(__is_layout_compatible(CStructNested, CStructNested2));
static_assert(__is_layout_compatible(UnionLayout, UnionLayout));
static_assert(!__is_layout_compatible(UnionLayout, UnionLayout2));
@@ -1844,12 +1948,15 @@ void is_pointer_interconvertible_base_of(int n)
static_assert(!__is_pointer_interconvertible_base_of(int, volatile int));
static_assert(!__is_pointer_interconvertible_base_of(const int, volatile
int));
static_assert(!__is_pointer_interconvertible_base_of(int *, int *
__restrict));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__is_pointer_interconvertible_base_of(int, _Atomic int));
static_assert(!__is_pointer_interconvertible_base_of(_Atomic(int), _Atomic
int));
+#endif
static_assert(!__is_pointer_interconvertible_base_of(int, unsigned int));
static_assert(!__is_pointer_interconvertible_base_of(char, unsigned char));
static_assert(!__is_pointer_interconvertible_base_of(char, signed char));
static_assert(!__is_pointer_interconvertible_base_of(unsigned char, signed
char));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
using function_type = void();
using function_type2 = void(char);
static_assert(!__is_pointer_interconvertible_base_of(const function_type,
const function_type));
@@ -1859,27 +1966,36 @@ void is_pointer_interconvertible_base_of(int n)
// expected-warning@-1 {{'const' qualifier on function type 'function_type'
(aka 'void ()') has no effect}}
static_assert(!__is_pointer_interconvertible_base_of(const function_type,
const function_type2));
// expected-warning@-1 {{'const' qualifier on function type 'function_type'
(aka 'void ()') has no effect}}
- // expected-warning@-2 {{'const' qualifier on function type 'function_type2'
(aka 'void (char)') has no effect}}
+ // expected-noncl-warning@-2 {{'const' qualifier on function type
'function_type2' (aka 'void (char)') has no effect}}
+ // expected-cl-warning@-3 {{'const' qualifier on function type
'function_type2' (aka 'void (__private char)') has no effect}}
+#endif
static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, int
CStruct2::*));
static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, char
CStruct2::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int),
void(CStruct2::*)(int)));
static_assert(!__is_pointer_interconvertible_base_of(void(CStruct2::*)(int),
void(CStruct2::*)(char)));
+#endif
static_assert(!__is_pointer_interconvertible_base_of(int[], int[]));
static_assert(!__is_pointer_interconvertible_base_of(int[], double[]));
static_assert(!__is_pointer_interconvertible_base_of(int[2], int[2]));
+ // OpenCLCPP: No VLA
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__is_pointer_interconvertible_base_of(int[n], int[2]));
// expected-error@-1 {{variable length arrays are not supported in
'__is_pointer_interconvertible_base_of'}}
static_assert(!__is_pointer_interconvertible_base_of(int[n], int[n]));
// expected-error@-1 {{variable length arrays are not supported in
'__is_pointer_interconvertible_base_of'}}
// expected-error@-2 {{variable length arrays are not supported in
'__is_pointer_interconvertible_base_of'}}
+#endif
static_assert(!__is_pointer_interconvertible_base_of(int&, int&));
static_assert(!__is_pointer_interconvertible_base_of(int&, char&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_pointer_interconvertible_base_of(void(int), void(int)));
static_assert(!__is_pointer_interconvertible_base_of(void(int), void(char)));
static_assert(!__is_pointer_interconvertible_base_of(void(&)(int),
void(&)(int)));
static_assert(!__is_pointer_interconvertible_base_of(void(&)(int),
void(&)(char)));
static_assert(!__is_pointer_interconvertible_base_of(void(*)(int),
void(*)(int)));
static_assert(!__is_pointer_interconvertible_base_of(void(*)(int),
void(*)(char)));
+#endif
}
}
@@ -1925,13 +2041,17 @@ struct UserDeletedDestructorInAggregate {
~UserDeletedDestructorInAggregate() = delete;
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct UserDeletedDestructorInNonAggregate {
virtual void NonAggregate();
~UserDeletedDestructorInNonAggregate() = delete;
};
+#endif
struct DeletedDestructorViaBaseInAggregate : UserDeletedDestructorInAggregate
{};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct DeletedDestructorViaBaseInNonAggregate :
UserDeletedDestructorInNonAggregate {};
+#endif
#if __cplusplus >= 202002L
template<bool B>
@@ -1975,10 +2095,13 @@ void is_implicit_lifetime(int n) {
static_assert(__builtin_is_implicit_lifetime(int*));
static_assert(__builtin_is_implicit_lifetime(int[]));
static_assert(__builtin_is_implicit_lifetime(int[5]));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(__builtin_is_implicit_lifetime(int[n]));
// expected-error@-1 {{variable length arrays are not supported in
'__builtin_is_implicit_lifetime'}}
+#endif
static_assert(__builtin_is_implicit_lifetime(Enum));
static_assert(__builtin_is_implicit_lifetime(EnumClass));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__builtin_is_implicit_lifetime(void()));
static_assert(!__builtin_is_implicit_lifetime(void() &));
static_assert(!__builtin_is_implicit_lifetime(void() const));
@@ -1990,6 +2113,7 @@ void is_implicit_lifetime(int n) {
static_assert(__builtin_is_implicit_lifetime(int
(UserDeclaredDestructor::*)() const));
static_assert(__builtin_is_implicit_lifetime(int
(UserDeclaredDestructor::*)() &));
static_assert(__builtin_is_implicit_lifetime(int
(UserDeclaredDestructor::*)() &&));
+#endif
static_assert(!__builtin_is_implicit_lifetime(IncompleteStruct));
// expected-error@-1 {{incomplete type 'IncompleteStruct' used in type trait
expression}}
static_assert(__builtin_is_implicit_lifetime(IncompleteStruct[]));
@@ -2005,9 +2129,13 @@ void is_implicit_lifetime(int n) {
static_assert(__builtin_is_implicit_lifetime(InheritedOnlyDefaultConstructorIsTrivial));
static_assert(__builtin_is_implicit_lifetime(InheritedAllContstructorsAreTrivial));
static_assert(__builtin_is_implicit_lifetime(UserDeletedDestructorInAggregate));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__builtin_is_implicit_lifetime(UserDeletedDestructorInNonAggregate));
+#endif
static_assert(__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInAggregate)
== __cplusplus >= 201703L);
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__builtin_is_implicit_lifetime(DeletedDestructorViaBaseInNonAggregate));
+#endif
#if __cplusplus >= 202002L
static_assert(__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<true>));
static_assert(!__builtin_is_implicit_lifetime(ConstrainedUserDeclaredDefaultConstructor<false>));
@@ -2015,14 +2143,18 @@ void is_implicit_lifetime(int n) {
static_assert(__builtin_is_implicit_lifetime(ConstrainedUserProvidedDestructor<false>));
#endif
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(__builtin_is_implicit_lifetime(__int128));
+#endif
static_assert(__builtin_is_implicit_lifetime(_BitInt(8)));
static_assert(__builtin_is_implicit_lifetime(_BitInt(128)));
static_assert(__builtin_is_implicit_lifetime(int[0]));
static_assert(__builtin_is_implicit_lifetime(StructWithFAM));
static_assert(__builtin_is_implicit_lifetime(StructWithZeroSizedArray));
static_assert(__builtin_is_implicit_lifetime(__fp16));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(__builtin_is_implicit_lifetime(__bf16));
+#endif
static_assert(__builtin_is_implicit_lifetime(_Complex double));
static_assert(__builtin_is_implicit_lifetime(float4));
static_assert(__builtin_is_implicit_lifetime(align_value_int));
@@ -2033,8 +2165,10 @@ void is_implicit_lifetime(int n) {
static_assert(__builtin_is_implicit_lifetime(int * _Nonnull));
static_assert(__builtin_is_implicit_lifetime(int * _Null_unspecified));
static_assert(__builtin_is_implicit_lifetime(int * _Nullable));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__builtin_is_implicit_lifetime(_Atomic int));
// expected-error@-1 {{atomic types are not supported in
'__builtin_is_implicit_lifetime'}}
+#endif
static_assert(__builtin_is_implicit_lifetime(int * __restrict));
}
@@ -2110,12 +2244,14 @@ struct HasMove {
HasMove(HasMove&& cp);
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct HasTemplateCons {
HasVirt Annoying;
template <typename T>
HasTemplateCons(const T&);
};
+#endif
void has_trivial_default_constructor() {
static_assert(__has_trivial_constructor(Int));
@@ -2141,10 +2277,14 @@ void has_trivial_default_constructor() {
static_assert(!__has_trivial_constructor(HasRef));
static_assert(!__has_trivial_constructor(HasCopy));
static_assert(!__has_trivial_constructor(IntRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_constructor(VirtAr));
+#endif
static_assert(!__has_trivial_constructor(void));
static_assert(!__has_trivial_constructor(cvoid));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_constructor(HasTemplateCons));
+#endif
static_assert(!__has_trivial_constructor(AllPrivate));
static_assert(!__has_trivial_constructor(ExtDefaulted));
}
@@ -2170,8 +2310,10 @@ void has_trivial_move_constructor() {
static_assert(__has_trivial_move_constructor(ACompleteType[]));
static_assert(!__has_trivial_move_constructor(AnIncompleteType[])); //
expected-error {{incomplete type}}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_move_constructor(HasVirt));
static_assert(!__has_trivial_move_constructor(DerivesVirt));
+#endif
static_assert(!__has_trivial_move_constructor(HasMoveCtor));
static_assert(!__has_trivial_move_constructor(DerivesHasMoveCtor));
static_assert(!__has_trivial_move_constructor(HasMemberMoveCtor));
@@ -2203,8 +2345,10 @@ void has_trivial_copy_constructor() {
static_assert(!__has_trivial_copy(AnIncompleteType[])); // expected-error
{{incomplete type}}
static_assert(!__has_trivial_copy(HasCopy));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_copy(HasTemplateCons));
static_assert(!__has_trivial_copy(VirtAr));
+#endif
static_assert(!__has_trivial_copy(void));
static_assert(!__has_trivial_copy(cvoid));
static_assert(!__has_trivial_copy(AllPrivate));
@@ -2237,7 +2381,9 @@ void has_trivial_copy_assignment() {
static_assert(!__has_trivial_assign(const Int));
static_assert(!__has_trivial_assign(ConstIntAr));
static_assert(!__has_trivial_assign(ConstIntArAr));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_assign(VirtAr));
+#endif
static_assert(!__has_trivial_assign(void));
static_assert(!__has_trivial_assign(cvoid));
static_assert(!__has_trivial_assign(AllPrivate));
@@ -2263,7 +2409,9 @@ void has_trivial_destructor() {
static_assert(__has_trivial_destructor(HasMoveAssign));
static_assert(__has_trivial_destructor(const Int));
static_assert(__has_trivial_destructor(DerivesAr));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_trivial_destructor(VirtAr));
+#endif
static_assert(__has_trivial_destructor(AllDefaulted));
static_assert(__has_trivial_destructor(AllDeleted));
static_assert(__has_trivial_destructor(DerivesHasRef));
@@ -2331,7 +2479,9 @@ void has_nothrow_assign() {
static_assert(!__has_nothrow_assign(const Int));
static_assert(!__has_nothrow_assign(ConstIntAr));
static_assert(!__has_nothrow_assign(ConstIntArAr));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_nothrow_assign(VirtAr));
+#endif
static_assert(!__has_nothrow_assign(void));
static_assert(!__has_nothrow_assign(cvoid));
static_assert(!__has_nothrow_assign(PR11110));
@@ -2386,8 +2536,10 @@ void has_trivial_move_assign() {
static_assert(__has_trivial_move_assign(ACompleteType[]));
static_assert(!__has_trivial_move_assign(AnIncompleteType[])); //
expected-error {{incomplete type}}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_trivial_move_assign(HasVirt));
static_assert(!__has_trivial_move_assign(DerivesVirt));
+#endif
static_assert(!__has_trivial_move_assign(HasMoveAssign));
static_assert(!__has_trivial_move_assign(DerivesHasMoveAssign));
static_assert(!__has_trivial_move_assign(HasMemberMoveAssign));
@@ -2415,8 +2567,10 @@ void has_nothrow_copy() {
static_assert(__has_nothrow_copy(HasMoveAssign));
static_assert(__has_nothrow_copy(HasNoThrowCopy));
static_assert(__has_nothrow_copy(HasMultipleNoThrowCopy));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_nothrow_copy(HasVirtDest));
static_assert(__has_nothrow_copy(HasTemplateCons));
+#endif
static_assert(__has_nothrow_copy(AllPrivate));
static_assert(__has_nothrow_copy(DerivesAr));
static_assert(__has_nothrow_copy(ACompleteType[]));
@@ -2424,7 +2578,9 @@ void has_nothrow_copy() {
static_assert(!__has_nothrow_copy(AnIncompleteType[])); // expected-error
{{incomplete type}}
static_assert(!__has_nothrow_copy(HasCopy));
static_assert(!__has_nothrow_copy(HasMultipleCopy));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_nothrow_copy(VirtAr));
+#endif
static_assert(!__has_nothrow_copy(void));
static_assert(!__has_nothrow_copy(cvoid));
}
@@ -2458,7 +2614,9 @@ void has_nothrow_constructor() {
static_assert(!__has_nothrow_constructor(IntRef));
static_assert(!__has_nothrow_constructor(void));
static_assert(!__has_nothrow_constructor(cvoid));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_nothrow_constructor(HasTemplateCons));
+#endif
static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor1));
static_assert(!__has_nothrow_constructor(HasMultipleDefaultConstructor2));
@@ -2484,13 +2642,17 @@ void has_virtual_destructor() {
static_assert(!__has_virtual_destructor(HasCopyAssign));
static_assert(!__has_virtual_destructor(HasMoveAssign));
static_assert(!__has_virtual_destructor(IntRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_virtual_destructor(VirtAr));
+#endif
static_assert(!__has_virtual_destructor(ACompleteType[]));
static_assert(!__has_virtual_destructor(AnIncompleteType[])); //
expected-error {{incomplete type}}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_virtual_destructor(HasVirtDest));
static_assert(__has_virtual_destructor(DerivedVirtDest));
static_assert(!__has_virtual_destructor(VirtDestAr));
+#endif
static_assert(!__has_virtual_destructor(void));
static_assert(!__has_virtual_destructor(cvoid));
static_assert(!__has_virtual_destructor(AllPrivate));
@@ -2594,7 +2756,9 @@ void is_virtual_base_of(int n) {
static_assert(!__builtin_is_virtual_base_of(class_forward, Empty));
static_assert(!__builtin_is_virtual_base_of(Base&, Derived&));
static_assert(!__builtin_is_virtual_base_of(Base[10], Derived[10]));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__builtin_is_virtual_base_of(Base[n], Derived[n])); //
expected-error 2 {{variable length arrays are not supported in
'__builtin_is_virtual_base_of'}}
+#endif
static_assert(!__builtin_is_virtual_base_of(int, int));
static_assert(!__builtin_is_virtual_base_of(int[], int[]));
static_assert(!__builtin_is_virtual_base_of(long, int));
@@ -2629,7 +2793,9 @@ void is_virtual_base_of(int n) {
static_assert(!__builtin_is_virtual_base_of(Union, Empty));
static_assert(!__builtin_is_virtual_base_of(int, Empty));
static_assert(!__builtin_is_virtual_base_of(Union, int));
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
static_assert(!__builtin_is_virtual_base_of(IncompleteStruct,
IncompleteStruct[n])); // expected-error {{variable length arrays are not
supported in '__builtin_is_virtual_base_of'}}
+#endif
}
template<class T, class U>
@@ -2752,7 +2918,9 @@ struct X0 {
template<typename U> X0(const X0<U>&);
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct Abstract { virtual void f() = 0; };
+#endif
void is_convertible_to() {
static_assert(__is_convertible_to(Int, Int));
@@ -2778,7 +2946,9 @@ void is_convertible_to() {
static_assert(!__is_convertible_to(Function, Function));
static_assert(!__is_convertible_to(PrivateCopy, PrivateCopy));
static_assert(__is_convertible_to(X0<int>, X0<float>));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_convertible_to(Abstract, Abstract));
+#endif
}
namespace is_convertible_to_instantiate {
@@ -2821,13 +2991,17 @@ void is_trivial()
static_assert(!__is_trivial(HasDest));
static_assert(!__is_trivial(HasRef));
static_assert(!__is_trivial(HasNonPOD));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_trivial(HasVirt));
+#endif
static_assert(!__is_trivial(DerivesHasCons));
static_assert(!__is_trivial(DerivesHasCopyAssign));
static_assert(!__is_trivial(DerivesHasMoveAssign));
static_assert(!__is_trivial(DerivesHasDest));
static_assert(!__is_trivial(DerivesHasRef));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_trivial(DerivesHasVirt));
+#endif
static_assert(!__is_trivial(void));
static_assert(!__is_trivial(cvoid));
}
@@ -2876,11 +3050,15 @@ void trivial_checks()
static_assert(!__is_trivially_copyable(HasCopyAssign));
static_assert(!__is_trivially_copyable(HasMoveAssign));
static_assert(!__is_trivially_copyable(HasDest));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_trivially_copyable(HasVirt));
+#endif
static_assert(!__is_trivially_copyable(DerivesHasCopyAssign));
static_assert(!__is_trivially_copyable(DerivesHasMoveAssign));
static_assert(!__is_trivially_copyable(DerivesHasDest));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__is_trivially_copyable(DerivesHasVirt));
+#endif
static_assert(!__is_trivially_copyable(void));
static_assert(!__is_trivially_copyable(cvoid));
@@ -3035,9 +3213,11 @@ void constructible_checks() {
static_assert(__is_constructible(NonPOD, int));
static_assert(!__is_nothrow_constructible(NonPOD, int));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
// PR19178
static_assert(!__is_constructible(Abstract));
static_assert(!__is_nothrow_constructible(Abstract));
+#endif
// PR20228
static_assert(__is_constructible(VariadicCtor,
@@ -3086,7 +3266,9 @@ void is_trivially_constructible_test() {
static_assert(!(is_trivially_constructible<int, int*>::value));
static_assert(!(is_trivially_constructible<NonTrivialDefault>::value));
static_assert(!(is_trivially_constructible<ThreeArgCtor, int*, char*,
int&>::value));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!(is_trivially_constructible<Abstract>::value)); // PR19178
+#endif
static_assert(__is_trivially_constructible(ACompleteType));
static_assert(!__is_trivially_constructible(AnIncompleteType)); //
expected-error {{incomplete type}}
@@ -3145,8 +3327,10 @@ void reference_binds_to_temporary_checks() {
static_assert((__reference_binds_to_temporary(const int &, long)));
// Test that function references are never considered bound to temporaries.
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__reference_binds_to_temporary(void(&)(), void()));
static_assert(!__reference_binds_to_temporary(void(&&)(), void()));
+#endif
}
@@ -3206,8 +3390,10 @@ void reference_constructs_from_temporary_checks() {
static_assert(__reference_constructs_from_temporary(const int &, long));
// Test that function references are never considered bound to temporaries.
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__reference_constructs_from_temporary(void(&&)(), void()));
static_assert(!__reference_constructs_from_temporary(void(&)(), void()));
+#endif
// LWG3819: reference_meows_from_temporary should not use is_meowible
static_assert(__reference_constructs_from_temporary(ConvertsFromNonMovable&&,
NonMovable) == __cplusplus >= 201703L);
@@ -3272,9 +3458,11 @@ void reference_converts_from_temporary_checks() {
static_assert(__reference_converts_from_temporary(const int &, long));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
// Test that function references are never considered bound to temporaries.
static_assert(!__reference_converts_from_temporary(void(&)(), void()));
static_assert(!__reference_converts_from_temporary(void(&&)(), void()));
+#endif
// LWG3819: reference_meows_from_temporary should not use is_meowible
static_assert(__reference_converts_from_temporary(ConvertsFromNonMovable&&,
NonMovable) == __cplusplus >= 201703L);
@@ -3399,19 +3587,25 @@
static_assert(__has_unique_object_representations(volatile int *), "as are point
static_assert(__has_unique_object_representations(const volatile int *), "as
are pointers");
class C {};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
using FP = int (*)(int);
using PMF = int (C::*)(int);
+#endif
using PMD = int C::*;
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_unique_object_representations(FP), "even function
pointers");
static_assert(__has_unique_object_representations(const FP), "even function
pointers");
static_assert(__has_unique_object_representations(volatile FP), "even function
pointers");
static_assert(__has_unique_object_representations(const volatile FP), "even
function pointers");
+#endif
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_unique_object_representations(PMF), "and pointer to
members");
static_assert(__has_unique_object_representations(const PMF), "and pointer to
members");
static_assert(__has_unique_object_representations(volatile PMF), "and pointer
to members");
static_assert(__has_unique_object_representations(const volatile PMF), "and
pointer to members");
+#endif
static_assert(__has_unique_object_representations(PMD), "and pointer to
members");
static_assert(__has_unique_object_representations(const PMD), "and pointer to
members");
@@ -3428,8 +3622,10 @@ static_assert(__has_unique_object_representations(int),
"yes, all integral types
static_assert(__has_unique_object_representations(unsigned int), "yes, all
integral types");
static_assert(__has_unique_object_representations(long), "yes, all integral
types");
static_assert(__has_unique_object_representations(unsigned long), "yes, all
integral types");
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__has_unique_object_representations(long long), "yes, all
integral types");
static_assert(__has_unique_object_representations(unsigned long long), "yes,
all integral types");
+#endif
static_assert(__has_unique_object_representations(wchar_t), "yes, all integral
types");
static_assert(__has_unique_object_representations(char16_t), "yes, all
integral types");
static_assert(__has_unique_object_representations(char32_t), "yes, all
integral types");
@@ -3565,6 +3761,7 @@ class EmptyInheritor : Compressed {};
static_assert(__has_unique_object_representations(EmptyInheritor), "As long as
the base has items, empty is ok");
+#if !defined(VANILLAOPENCLCPLUSPLUS)
class Dynamic {
virtual void A();
int i;
@@ -3577,6 +3774,7 @@ class InheritsDynamic : Dynamic {
};
static_assert(!__has_unique_object_representations(InheritsDynamic), "Dynamic
types are not valid");
+#endif
static_assert(__has_unique_object_representations(int[42]), "Arrays are fine,
as long as their value type is");
static_assert(__has_unique_object_representations(int[]), "Arrays are fine, as
long as their value type is");
@@ -3619,6 +3817,7 @@
static_assert(!__has_unique_object_representations(int(int) const &&), "Function
static_assert(!__has_unique_object_representations(int(int) volatile &&),
"Functions are not unique");
static_assert(!__has_unique_object_representations(int(int) const volatile
&&), "Functions are not unique");
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(!__has_unique_object_representations(int(int, ...)), "Functions
are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const),
"Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) volatile),
"Functions are not unique");
@@ -3631,6 +3830,7 @@
static_assert(!__has_unique_object_representations(int(int, ...) &&), "Functions
static_assert(!__has_unique_object_representations(int(int, ...) const &&),
"Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) volatile &&),
"Functions are not unique");
static_assert(!__has_unique_object_representations(int(int, ...) const
volatile &&), "Functions are not unique");
+#endif
void foo(){
static auto lambda = []() {};
@@ -3640,6 +3840,7 @@ void foo(){
static_assert(__has_unique_object_representations(decltype(lambda2)),
"Lambdas follow struct rules");
}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct PaddedBitfield {
char c : 6;
char d : 1;
@@ -3705,6 +3906,7 @@ struct GreaterSizeBitfield {
static_assert(sizeof(GreaterSizeBitfield) == 128, "Bitfield Size");
static_assert(!__has_unique_object_representations(GreaterSizeBitfield),
"Bitfield padding");
+#endif
struct StructWithRef {
int &I;
@@ -4051,6 +4253,7 @@ struct
NotTriviallyEqualityComparableTriviallyEqualityComparableBases
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct NotTriviallyEqualityComparableBitfield {
int i : 1;
@@ -4065,6 +4268,7 @@ struct NotTriviallyEqualityComparableBitfieldFilled {
bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const =
default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+#endif
union U {
int i;
@@ -4304,6 +4508,7 @@ struct
NotTriviallyEqualityComparableTriviallyEqualityComparableBases
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
struct NotTriviallyEqualityComparableBitfield {
int i : 1;
@@ -4318,6 +4523,7 @@ struct NotTriviallyEqualityComparableBitfieldFilled {
friend bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&,
const NotTriviallyEqualityComparableBitfieldFilled&) = default;
};
static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+#endif
union U {
int i;
@@ -4433,9 +4639,11 @@ void check_remove_const() {
static_assert(__is_same(remove_const_t<int const &>, int const &));
static_assert(__is_same(remove_const_t<int &&>, int &&));
static_assert(__is_same(remove_const_t<int const &&>, int const &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_const_t<int()>, int()));
static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()));
static_assert(__is_same(remove_const_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_const_t<S>, S));
static_assert(__is_same(remove_const_t<const S>, S));
@@ -4444,7 +4652,9 @@ void check_remove_const() {
static_assert(__is_same(remove_const_t<const volatile S>, volatile S));
static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S
*volatile __restrict));
static_assert(__is_same(remove_const_t<int S::*const>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()));
+#endif
}
template <class T> using remove_restrict_t = __remove_restrict(T);
@@ -4462,9 +4672,11 @@ void check_remove_restrict() {
static_assert(__is_same(remove_restrict_t<int &__restrict>, int &));
static_assert(__is_same(remove_restrict_t<int &&>, int &&));
static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_restrict_t<int()>, int()));
static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int
(*const volatile)()));
static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_restrict_t<S>, S));
static_assert(__is_same(remove_restrict_t<const S>, const S));
@@ -4472,7 +4684,9 @@ void check_remove_restrict() {
static_assert(__is_same(remove_restrict_t<S *__restrict>, S *));
static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S
*const volatile));
static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>,
int(S::*const volatile)()));
+#endif
}
template <class T> using remove_volatile_t = __remove_volatile(T);
@@ -4493,16 +4707,20 @@ void check_remove_volatile() {
static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &));
static_assert(__is_same(remove_volatile_t<int &&>, int &&));
static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile
&&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_volatile_t<int()>, int()));
static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()));
static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_volatile_t<S>, S));
static_assert(__is_same(remove_volatile_t<const S>, const S));
static_assert(__is_same(remove_volatile_t<volatile S>, S));
static_assert(__is_same(remove_volatile_t<const volatile S>, const S));
static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>,
int(S::*)()));
+#endif
}
template <class T> using remove_cv_t = __remove_cv(T);
@@ -4523,16 +4741,20 @@ void check_remove_cv() {
static_assert(__is_same(remove_cv_t<int const volatile &>, int const
volatile &));
static_assert(__is_same(remove_cv_t<int &&>, int &&));
static_assert(__is_same(remove_cv_t<int const volatile &&>, int const
volatile &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_cv_t<int()>, int()));
static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()));
static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_cv_t<S>, S));
static_assert(__is_same(remove_cv_t<const S>, S));
static_assert(__is_same(remove_cv_t<volatile S>, S));
static_assert(__is_same(remove_cv_t<const volatile S>, S));
static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>,
int(S::*)()));
+#endif
}
template <class T> using add_pointer_t = __add_pointer(T);
@@ -4549,16 +4771,20 @@ void add_pointer() {
static_assert(__is_same(add_pointer_t<int *>, int **));
static_assert(__is_same(add_pointer_t<int &>, int *));
static_assert(__is_same(add_pointer_t<int &&>, int *));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_pointer_t<int()>, int (*)()));
static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()));
static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()));
+#endif
static_assert(__is_same(add_pointer_t<S>, S *));
static_assert(__is_same(add_pointer_t<const S>, const S *));
static_assert(__is_same(add_pointer_t<volatile S>, volatile S *));
static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S
*));
static_assert(__is_same(add_pointer_t<int S::*>, int S::**));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()));
+#endif
static_assert(__is_same(add_pointer_t<int
__attribute__((address_space(1)))>, int __attribute__((address_space(1))) *));
static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>,
S __attribute__((address_space(2))) *));
@@ -4566,7 +4792,7 @@ void add_pointer() {
template <class T> using remove_pointer_t = __remove_pointer(T);
-void remove_pointer() {
+void remove_pointer_common() {
static_assert(__is_same(remove_pointer_t<void>, void));
static_assert(__is_same(remove_pointer_t<const void>, const void));
static_assert(__is_same(remove_pointer_t<volatile void>, volatile void));
@@ -4575,6 +4801,21 @@ void remove_pointer() {
static_assert(__is_same(remove_pointer_t<const int>, const int));
static_assert(__is_same(remove_pointer_t<volatile int>, volatile int));
static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile
int));
+
+ static_assert(__is_same(remove_pointer_t<S>, S));
+ static_assert(__is_same(remove_pointer_t<const S>, const S));
+ static_assert(__is_same(remove_pointer_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile
S));
+ static_assert(__is_same(remove_pointer_t<int S::*>, int S::*));
+
+ static_assert(__is_same(remove_pointer_t<int
__attribute__((address_space(1))) *>, int __attribute__((address_space(1)))));
+ static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2)))
*>, S __attribute__((address_space(2)))));
+
+}
+
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
+
+void remove_pointer_cpp() {
static_assert(__is_same(remove_pointer_t<int *>, int));
static_assert(__is_same(remove_pointer_t<const int *>, const int));
static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int));
@@ -4584,22 +4825,36 @@ void remove_pointer() {
static_assert(__is_same(remove_pointer_t<int *const volatile>, int));
static_assert(__is_same(remove_pointer_t<int &>, int &));
static_assert(__is_same(remove_pointer_t<int &&>, int &&));
+}
+
+#else
+
+void remove_pointer_clcpp() {
+ static_assert(__is_same(remove_pointer_t<int *>, __generic int));
+ static_assert(__is_same(remove_pointer_t<const int *>, __generic const int));
+ static_assert(__is_same(remove_pointer_t<volatile int *>, __generic volatile
int));
+ static_assert(__is_same(remove_pointer_t<const volatile int *>, __generic
const volatile int));
+ static_assert(__is_same(remove_pointer_t<int *const>, __generic int));
+ static_assert(__is_same(remove_pointer_t<int *volatile>, __generic int));
+ static_assert(__is_same(remove_pointer_t<int *const volatile>, __generic
int));
+ static_assert(__is_same(remove_pointer_t<int &>, __generic int &));
+ static_assert(__is_same(remove_pointer_t<int &&>, __generic int &&));
+
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_pointer_t<int()>, int()));
- static_assert(__is_same(remove_pointer_t<int (*)()>, int()));
+ // It is impossible to specify such type
+ static_assert(__is_same(remove_pointer_t<int (*)()>, int ()));
static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()));
-
- static_assert(__is_same(remove_pointer_t<S>, S));
- static_assert(__is_same(remove_pointer_t<const S>, const S));
- static_assert(__is_same(remove_pointer_t<volatile S>, volatile S));
- static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile
S));
- static_assert(__is_same(remove_pointer_t<int S::*>, int S::*));
+#endif
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()));
+#endif
- static_assert(__is_same(remove_pointer_t<int
__attribute__((address_space(1))) *>, int __attribute__((address_space(1)))));
- static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2)))
*>, S __attribute__((address_space(2)))));
-
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)));
+#endif
}
+#endif
template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T);
@@ -4615,16 +4870,20 @@ void add_lvalue_reference() {
static_assert(__is_same(add_lvalue_reference_t<int *>, int *&));
static_assert(__is_same(add_lvalue_reference_t<int &>, int &));
static_assert(__is_same(add_lvalue_reference_t<int &&>, int &)); //
reference collapsing
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()));
static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()));
static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(add_lvalue_reference_t<S>, S &));
static_assert(__is_same(add_lvalue_reference_t<const S>, const S &));
static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &));
static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const
volatile S &));
static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()));
+#endif
}
template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T);
@@ -4641,27 +4900,35 @@ void add_rvalue_reference() {
static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&));
static_assert(__is_same(add_rvalue_reference_t<int &>, int &)); // reference
collapsing
static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()));
static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()));
static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)())); //
reference collapsing
+#endif
static_assert(__is_same(add_rvalue_reference_t<S>, S &&));
static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&));
static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&));
static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const
volatile S &&));
static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::*
&&)()));
+#endif
}
template <class T> using remove_reference_t = __remove_reference_t(T);
-void check_remove_reference() {
+void check_remove_reference_common() {
static_assert(__is_same(remove_reference_t<void>, void));
static_assert(__is_same(remove_reference_t<const volatile void>, const
volatile void));
static_assert(__is_same(remove_reference_t<int>, int));
static_assert(__is_same(remove_reference_t<const int>, const int));
static_assert(__is_same(remove_reference_t<volatile int>, volatile int));
- static_assert(__is_same(remove_reference_t<const volatile int>, const
volatile int));
+}
+
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
+
+void check_remove_reference_cpp() {
static_assert(__is_same(remove_reference_t<int *>, int *));
static_assert(__is_same(remove_reference_t<int *const volatile>, int *const
volatile));
static_assert(__is_same(remove_reference_t<int const *const volatile>, int
const *const volatile));
@@ -4690,15 +4957,57 @@ void check_remove_reference() {
static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>,
int(S::*const volatile)() &));
}
+#else
+
+void check_remove_reference_clcpp() {
+ static_assert(__is_same(remove_reference_t<int *>, __generic int *));
+ static_assert(__is_same(remove_reference_t<int *const volatile>, __generic
int *const volatile));
+ static_assert(__is_same(remove_reference_t<int const *const volatile>,
__generic int const *const volatile));
+ static_assert(__is_same(remove_reference_t<int &>, __generic int));
+ static_assert(__is_same(remove_reference_t<int const volatile &>, __generic
int const volatile));
+ static_assert(__is_same(remove_reference_t<int &&>, __generic int));
+ static_assert(__is_same(remove_reference_t<int const volatile &&>, __generic
int const volatile));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(remove_reference_t<int()>, int()));
+ static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int
(*const volatile)()));
+ static_assert(__is_same(remove_reference_t<int (&)()>, int ()));
+#endif
+
+ static_assert(__is_same(remove_reference_t<S>, S));
+ static_assert(__is_same(remove_reference_t<S &>, __generic S));
+ static_assert(__is_same(remove_reference_t<S &&>, __generic S));
+ static_assert(__is_same(remove_reference_t<const S>, const S));
+ static_assert(__is_same(remove_reference_t<const S &>, __generic const S));
+ static_assert(__is_same(remove_reference_t<const S &&>, __generic const S));
+ static_assert(__is_same(remove_reference_t<volatile S>, volatile S));
+ static_assert(__is_same(remove_reference_t<volatile S &>, __generic volatile
S));
+ static_assert(__is_same(remove_reference_t<volatile S &&>, __generic
volatile S));
+ static_assert(__is_same(remove_reference_t<const volatile S>, const volatile
S));
+ static_assert(__is_same(remove_reference_t<const volatile S &>, __generic
const volatile S));
+ static_assert(__is_same(remove_reference_t<const volatile S &&>, __generic
const volatile S));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int
S::*__generic const volatile));
+ static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>,
int(S::*__generic const volatile)()));
+ static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>,
int(S::*__generic const volatile)() &));
+#endif
+}
+
+#endif
+
template <class T> using remove_cvref_t = __remove_cvref(T);
-void check_remove_cvref() {
+void check_remove_cvref_common() {
static_assert(__is_same(remove_cvref_t<void>, void));
static_assert(__is_same(remove_cvref_t<const volatile void>, void));
static_assert(__is_same(remove_cvref_t<int>, int));
static_assert(__is_same(remove_cvref_t<const int>, int));
static_assert(__is_same(remove_cvref_t<volatile int>, int));
static_assert(__is_same(remove_cvref_t<const volatile int>, int));
+}
+
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
+
+void check_remove_cvref_cpp() {
static_assert(__is_same(remove_cvref_t<int *>, int *));
static_assert(__is_same(remove_cvref_t<int *const volatile>, int *));
static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const
*));
@@ -4729,16 +5038,59 @@ void check_remove_cvref() {
static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>,
int(S::*)() &));
static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>,
int(S::*)() &&));
}
+#else
+void check_remove_cvref_clcpp() {
+ static_assert(__is_same(remove_cvref_t<int *>, __generic int *));
+ static_assert(__is_same(remove_cvref_t<int *const volatile>, __generic int
*));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile>, __generic
int const *));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile
__restrict>, __generic int const *__restrict));
+ static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>,
__generic int const *_Nonnull));
+ static_assert(__is_same(remove_cvref_t<int &>, __generic int));
+ static_assert(__is_same(remove_cvref_t<int const volatile &>, __generic
int));
+ static_assert(__is_same(remove_cvref_t<int &&>, __generic int));
+ static_assert(__is_same(remove_cvref_t<int const volatile &&>, __generic
int));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(remove_cvref_t<int()>, int()));
+ static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()));
+ static_assert(__is_same(remove_cvref_t<int (&)()>, int ()));
+#endif
+
+ static_assert(__is_same(remove_cvref_t<S>, S));
+ static_assert(__is_same(remove_cvref_t<S &>, __generic S));
+ static_assert(__is_same(remove_cvref_t<S &&>, __generic S));
+ static_assert(__is_same(remove_cvref_t<const S>, S));
+ static_assert(__is_same(remove_cvref_t<const S &>, __generic S));
+ static_assert(__is_same(remove_cvref_t<const S &&>, __generic S));
+ static_assert(__is_same(remove_cvref_t<volatile S>, S));
+ static_assert(__is_same(remove_cvref_t<volatile S &>, __generic S));
+ static_assert(__is_same(remove_cvref_t<volatile S &&>, __generic S));
+ static_assert(__is_same(remove_cvref_t<const volatile S>, S));
+ static_assert(__is_same(remove_cvref_t<const volatile S &>, __generic S));
+ static_assert(__is_same(remove_cvref_t<const volatile S &&>, __generic S));
+ static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ // TODO: Behaviour of those is most likely incorrect
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>,
int(S::*)()));
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>,
int(S::*)() &));
+ static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>,
int(S::*)() &&));
+#endif
+}
+#endif
template <class T> using decay_t = __decay(T);
-void check_decay() {
+void check_decay_common() {
static_assert(__is_same(decay_t<void>, void));
static_assert(__is_same(decay_t<const volatile void>, void));
static_assert(__is_same(decay_t<int>, int));
static_assert(__is_same(decay_t<const int>, int));
static_assert(__is_same(decay_t<volatile int>, int));
static_assert(__is_same(decay_t<const volatile int>, int));
+}
+
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
+
+void check_decay_cpp() {
static_assert(__is_same(decay_t<int *>, int *));
static_assert(__is_same(decay_t<int *const volatile>, int *));
static_assert(__is_same(decay_t<int *const volatile __restrict>, int *));
@@ -4775,6 +5127,55 @@ void check_decay() {
static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()));
static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*));
}
+#else
+
+typedef __generic int GenInt;
+typedef GenInt GenIntAr[10];
+typedef GenInt GenIntArNB[];
+
+void check_decay_clcpp() {
+ static_assert(__is_same(decay_t<__generic int *>, int *));
+ static_assert(__is_same(decay_t<int *const volatile>, int *));
+ static_assert(__is_same(decay_t<int *const volatile __restrict>, int *));
+ static_assert(__is_same(decay_t<int const *const volatile>, int const *));
+ static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int
const *));
+ static_assert(__is_same(decay_t<int &>, __generic int));
+ static_assert(__is_same(decay_t<int const volatile &>, __generic int));
+ static_assert(__is_same(decay_t<int &&>, __generic int));
+ static_assert(__is_same(decay_t<int const volatile &&>, __generic int));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(decay_t<int()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*const)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()));
+ static_assert(__is_same(decay_t<int (&)()>, int (*)()));
+#endif
+ static_assert(__is_same(decay_t<GenIntAr>, int *));
+ static_assert(__is_same(decay_t<GenIntArNB>, int *));
+
+ static_assert(__is_same(decay_t<S &>, __generic S));
+ static_assert(__is_same(decay_t<S &&>, __generic S));
+ static_assert(__is_same(decay_t<const S>, S));
+ static_assert(__is_same(decay_t<const S &>, __generic S));
+ static_assert(__is_same(decay_t<const S &&>, __generic S));
+ static_assert(__is_same(decay_t<volatile S>, S));
+ static_assert(__is_same(decay_t<volatile S &>, __generic S));
+ static_assert(__is_same(decay_t<volatile S &&>, __generic S));
+ static_assert(__is_same(decay_t<const volatile S>, S));
+ static_assert(__is_same(decay_t<const volatile S &>, __generic S));
+ static_assert(__is_same(decay_t<const volatile S &&>, __generic S));
+ static_assert(__is_same(decay_t<int S::*const volatile>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()));
+#endif
+ static_assert(__is_same(decay_t<int S::*const volatile &>, int
S::*__generic));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
+ static_assert(__is_same(decay_t<int (S::*const volatile &)()>,
int(S::*__generic)()));
+#endif
+ static_assert(__is_same(decay_t<int S::*const volatile &&>, int
S::*__generic));
+}
+#endif
template <class T> struct CheckAbominableFunction {};
template <class M>
@@ -4793,6 +5194,7 @@ struct CheckAbominableFunction<M S::*> {
}
};
+#if !defined(VANILLAOPENCLCPLUSPLUS)
void check_abominable_function() {
{ CheckAbominableFunction<int (S::*)() &> x; }
{ CheckAbominableFunction<int (S::*)() &&> x; }
@@ -4806,6 +5208,7 @@ void check_abominable_function() {
{ CheckAbominableFunction<int (S::*)() const volatile &> x; }
{ CheckAbominableFunction<int (S::*)() const volatile &&> x; }
}
+#endif
template <class T> using make_signed_t = __make_signed(T);
template <class T, class Expected>
@@ -4836,10 +5239,12 @@ enum UnscopedLongLong : long long {};
enum UnscopedULongLong : unsigned long long {};
enum class ScopedLongLong : long long {};
enum class ScopedULongLong : unsigned long long {};
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
enum class UnscopedInt128 : __int128 {};
enum class ScopedInt128 : __int128 {};
enum class UnscopedUInt128 : unsigned __int128 {};
enum class ScopedUInt128 : unsigned __int128 {};
+#endif
void make_signed() {
check_make_signed<char, signed char>();
@@ -4853,8 +5258,10 @@ void make_signed() {
check_make_signed<unsigned long, long>();
check_make_signed<long long, long long>();
check_make_signed<unsigned long long, long long>();
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
check_make_signed<__int128, __int128>();
check_make_signed<__uint128_t, __int128>();
+#endif
check_make_signed<_BitInt(65), _BitInt(65)>();
check_make_signed<unsigned _BitInt(65), _BitInt(65)>();
@@ -4872,6 +5279,7 @@ void make_signed() {
check_make_signed<UnscopedUChar, signed char>();
check_make_signed<ScopedUChar, signed char>();
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
check_make_signed<UnscopedLongLong, Int64>();
check_make_signed<UnscopedULongLong, Int64>();
check_make_signed<ScopedLongLong, Int64>();
@@ -4881,6 +5289,7 @@ void make_signed() {
check_make_signed<ScopedInt128, __int128>();
check_make_signed<UnscopedUInt128, __int128>();
check_make_signed<ScopedUInt128, __int128>();
+#endif
{ using ExpectedError = __make_signed(bool); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'bool'}}
@@ -4897,11 +5306,14 @@ void make_signed() {
{ using ExpectedError = __make_signed(void); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'void'}}
{ using ExpectedError = __make_signed(int *); }
- // expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int *'}}
+ // expected-noncl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int *'}}
+ // expected-cl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given '__generic int *'}}
{ using ExpectedError = __make_signed(int &); }
- // expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int &'}}
+ // expected-noncl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int &'}}
+ // expected-cl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given '__generic int &'}}
{ using ExpectedError = __make_signed(int &&); }
- // expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int &&'}}
+ // expected-noncl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int &&'}}
+ // expected-cl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given '__generic int &&'}}
{ using ExpectedError = __make_signed(float); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'float'}}
{ using ExpectedError = __make_signed(double); }
@@ -4911,11 +5323,14 @@ void make_signed() {
{ using ExpectedError = __make_signed(S); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'S'}}
{ using ExpectedError = __make_signed(S *); }
- // expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'S *'}}
+ // expected-noncl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'S *'}}
+ // expected-cl-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given '__generic S *'}}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
{ using ExpectedError = __make_signed(int S::*); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int S::*'}}
{ using ExpectedError = __make_signed(int(S::*)()); }
// expected-error@*:*{{'make_signed' is only compatible with non-bool
integers and enum types, but was given 'int (S::*)()'}}
+#endif
}
template <class T>
@@ -4941,8 +5356,10 @@ void make_unsigned() {
check_make_unsigned<unsigned long, unsigned long>();
check_make_unsigned<long long, unsigned long long>();
check_make_unsigned<unsigned long long, unsigned long long>();
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
check_make_unsigned<__int128, __uint128_t>();
check_make_unsigned<__uint128_t, __uint128_t>();
+#endif
check_make_unsigned<_BitInt(65), unsigned _BitInt(65)>();
check_make_unsigned<unsigned _BitInt(65), unsigned _BitInt(65)>();
@@ -4960,6 +5377,7 @@ void make_unsigned() {
check_make_unsigned<UnscopedUChar, unsigned char>();
check_make_unsigned<ScopedUChar, unsigned char>();
+#if !defined(VANILLAOPENCLCPLUSPLUS) && !defined(EXTOPENCLCPLUSPLUS)
check_make_unsigned<UnscopedLongLong, UInt64>();
check_make_unsigned<UnscopedULongLong, UInt64>();
check_make_unsigned<ScopedLongLong, UInt64>();
@@ -4969,6 +5387,7 @@ void make_unsigned() {
check_make_unsigned<ScopedInt128, unsigned __int128>();
check_make_unsigned<UnscopedUInt128, unsigned __int128>();
check_make_unsigned<ScopedUInt128, unsigned __int128>();
+#endif
{ using ExpectedError = __make_unsigned(bool); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'bool'}}
@@ -4985,11 +5404,14 @@ void make_unsigned() {
{ using ExpectedError = __make_unsigned(void); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'void'}}
{ using ExpectedError = __make_unsigned(int *); }
- // expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'int *'}}
+ // expected-noncl-error@*:*{{'make_unsigned' is only compatible with
non-bool integers and enum types, but was given 'int *'}}
+ // expected-cl-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given '__generic int *'}}
{ using ExpectedError = __make_unsigned(int &); }
- // expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'int &'}}
+ // expected-noncl-error@*:*{{'make_unsigned' is only compatible with
non-bool integers and enum types, but was given 'int &'}}
+ // expected-cl-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given '__generic int &'}}
{ using ExpectedError = __make_unsigned(int &&); }
- // expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'int &&'}}
+ // expected-noncl-error@*:*{{'make_unsigned' is only compatible with
non-bool integers and enum types, but was given 'int &&'}}
+ // expected-cl-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given '__generic int &&'}}
{ using ExpectedError = __make_unsigned(float); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'float'}}
{ using ExpectedError = __make_unsigned(double); }
@@ -4999,11 +5421,14 @@ void make_unsigned() {
{ using ExpectedError = __make_unsigned(S); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'S'}}
{ using ExpectedError = __make_unsigned(S *); }
- // expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'S *'}}
+ // expected-noncl-error@*:*{{'make_unsigned' is only compatible with
non-bool integers and enum types, but was given 'S *'}}
+ // expected-cl-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given '__generic S *'}}
+#if !defined(VANILLAOPENCLCPLUSPLUS)
{ using ExpectedError = __make_unsigned(int S::*); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'int S::*'}}
{ using ExpectedError = __make_unsigned(int(S::*)()); }
// expected-error@*:*{{'make_unsigned' is only compatible with non-bool
integers and enum types, but was given 'int (S::*)()'}}
+#endif
}
template <class T> using remove_extent_t = __remove_extent(T);
@@ -5030,13 +5455,17 @@ void remove_extent() {
static_assert(__is_same(remove_extent_t<int *>, int *));
static_assert(__is_same(remove_extent_t<int &>, int &));
static_assert(__is_same(remove_extent_t<int &&>, int &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_extent_t<int()>, int()));
static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()));
static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_extent_t<S>, S));
static_assert(__is_same(remove_extent_t<int S::*>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()));
+#endif
using SomeArray = int[1][2];
static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]));
@@ -5069,13 +5498,17 @@ void remove_all_extents() {
static_assert(__is_same(remove_all_extents_t<int *>, int *));
static_assert(__is_same(remove_all_extents_t<int &>, int &));
static_assert(__is_same(remove_all_extents_t<int &&>, int &&));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_all_extents_t<int()>, int()));
static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()));
static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()));
+#endif
static_assert(__is_same(remove_all_extents_t<S>, S));
static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*));
+#if !defined(VANILLAOPENCLCPLUSPLUS)
static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()));
+#endif
using SomeArray = int[1][2];
static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int));
diff --git a/clang/test/SemaOpenCLCXX/address-space-traits.clcpp
b/clang/test/SemaOpenCLCXX/address-space-traits.clcpp
new file mode 100644
index 0000000000000..adb71c2105ea8
--- /dev/null
+++ b/clang/test/SemaOpenCLCXX/address-space-traits.clcpp
@@ -0,0 +1,29 @@
+//RUN: %clang_cc1 %s -triple spirv64-unknown-unknown -pedantic -fsyntax-only
-verify -cl-ext=+__cl_clang_function_pointers,+__opencl_c_generic_address_space
+
+#pragma OPENCL EXTENSION __cl_clang_function_pointers : enable
+
+template <class T> using remove_pointer_t = __remove_pointer(T);
+static_assert(__is_same(remove_pointer_t<int (*)()>, int()));
+
+static_assert(__is_same(remove_pointer_t<int (*)()>, int()));
+
+static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()));
+
+template <class T> using remove_reference_t = __remove_reference_t(T);
+
+static_assert(__is_same(remove_reference_t<int (&)()>, int()));
+static_assert(__is_same(remove_reference_t<int (&)()>, void()));
+ // expected-error@-1 {{static assertion failed due to requirement
'__is_same(int (), void ())'}}
+
+static_assert(!__is_same(remove_reference_t<__add_lvalue_reference(int
(*)())>, int));
+
+struct S {
+ int foo() __local;
+};
+
+// FIXME: this fails since address-space is not preserved on member-function
when speciefied (2nd parameter)
+//static_assert(!__is_same(remove_pointer_t<decltype(&S::foo)>, int (S::*)()
const __local));
+//static_assert(__is_same(remove_pointer_t<decltype(&S::foo)>, int (S::*)()
__local));
+
+//static_assert(!__is_same(remove_reference_t<decltype(&S::foo)>, int (S::*)()
const __local));
+//static_assert(__is_same(remove_reference_t<decltype(&S::foo)>, int (S::*)()
__local));
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
