[clang] [OpenCLCpp] Avoid inferred adding address-space to function types (PR #153508)
via cfe-commits
cfe-commits at lists.llvm.org
Fri Aug 15 05:24:37 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
Author: None (piotrrak)
<details>
<summary>Changes</summary>
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 separate unrelated issue and won't be addressed in this change.
Note for reviewers:
I consider this change non-trivial and might have deeper consequnces in OpenCL drivers codegen in areas of intriniscs and blocks lowering CG, but it might affect vendor passes.
---
Patch is 81.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/153508.diff
3 Files Affected:
- (modified) clang/lib/Sema/SemaType.cpp (+6-4)
- (modified) clang/test/SemaCXX/type-traits.cpp (+462-29)
- (added) clang/test/SemaOpenCLCXX/address-space-traits.clcpp (+29)
``````````diff
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index d745cdbf0526f..70a52947ebad9 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -1794,9 +1794,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());
@@ -1835,7 +1837,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.
@@ -1912,7 +1914,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() &&
@@ -2767,7 +2769,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);
}
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 at -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 at -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 at -1 {{variable length arrays are not supported in '__is_layout_compatible'}}
static_assert(!__is_layout_compatible(int[n], int[n]));
// expected-error at -1 {{variable length arrays are not supported in '__is_layout_compatible'}}
// expected-error at -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 at -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 at -1 {{'const' qualifier on function type 'function_type' (aka 'void ()') has no effect}}
- // expected-warning at -2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}
+ // expected-noncl-warning at -2 {{'const' qualifier on function type 'function_type2' (aka 'void (char)') has no effect}}
+ // expected-cl-warning at -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))...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/153508
More information about the cfe-commits
mailing list