[clang] [clang] Implement `__is_pointer_interconvertible_base_of()` (PR #88473)
Vlad Serebrennikov via cfe-commits
cfe-commits at lists.llvm.org
Thu Apr 11 22:27:00 PDT 2024
https://github.com/Endilll created https://github.com/llvm/llvm-project/pull/88473
This patch implements intrinsic that supports `std::is_pointer_interconvertible_base_of` type trait from [P0466R5](https://wg21.link/p0466r5) "Layout-compatibility and Pointer-interconvertibility Traits".
Normative wording:
> Comment: If `Base` and Derived are non-union class types and are not (possibly _cv_-qualified) versions of the same type, `Derived` is a complete type.
> Condition: `Derived` is unambiguously derived from `Base` without regard to _cv_-qualifiers, and each object of type `Derived` is pointer-interconvertible (6.7.2 [basic.compound]) with its `Base` subobject, or `Base` and `Derived` are not unions and name the same class type without regard to _cv_-qualifiers.
The paper also express the following intent:
> Note that is pointer interconvertible base of v<T,T> is always true under this wording, even though T is not derived from itself.
I find the treatment of unions in the wording contradictory to this intent, and I'm not able to find anything relevant in minutes or on the reflector. That said, this patch implements what the wording says, since it's very explicit about unions.
>From 84907542cecbe76b1971a50642d39ec4d1078687 Mon Sep 17 00:00:00 2001
From: Vlad Serebrennikov <serebrennikov.vladislav at gmail.com>
Date: Fri, 12 Apr 2024 08:18:06 +0300
Subject: [PATCH] [clang] Implement `__is_pointer_interconvertible_base_of()`
---
clang/include/clang/Basic/TokenKinds.def | 1 +
clang/include/clang/Sema/Sema.h | 2 +
clang/lib/Sema/SemaChecking.cpp | 21 ++++++
clang/lib/Sema/SemaExprCXX.cpp | 16 +++++
clang/test/SemaCXX/type-traits.cpp | 86 +++++++++++++++++++++++-
5 files changed, 125 insertions(+), 1 deletion(-)
diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def
index 800af0e6d04480..a27fbed358a60c 100644
--- a/clang/include/clang/Basic/TokenKinds.def
+++ b/clang/include/clang/Basic/TokenKinds.def
@@ -521,6 +521,7 @@ TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
TYPE_TRAIT_1(__has_unique_object_representations,
HasUniqueObjectRepresentations, KEYCXX)
TYPE_TRAIT_2(__is_layout_compatible, IsLayoutCompatible, KEYCXX)
+TYPE_TRAIT_2(__is_pointer_interconvertible_base_of, IsPointerInterconvertibleBaseOf, KEYCXX)
#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) KEYWORD(__##Trait, KEYCXX)
#include "clang/Basic/TransformTypeTraits.def"
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 0ee4f3c8e127f6..397c5ae8eee777 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -1975,6 +1975,8 @@ class Sema final : public SemaBase {
};
bool IsLayoutCompatible(QualType T1, QualType T2) const;
+ bool IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base,
+ const TypeSourceInfo *Derived);
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
const FunctionProtoType *Proto);
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index abfd9a3031577b..bbe82672183508 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -19710,6 +19710,27 @@ bool Sema::IsLayoutCompatible(QualType T1, QualType T2) const {
return isLayoutCompatible(getASTContext(), T1, T2);
}
+//===-------------- Pointer interconvertibility ----------------------------//
+
+bool Sema::IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base,
+ const TypeSourceInfo *Derived) {
+ QualType BaseT = Base->getType().getCanonicalType().getUnqualifiedType();
+ QualType DerivedT =
+ Derived->getType().getCanonicalType().getUnqualifiedType();
+
+ if (!BaseT->isUnionType() && !DerivedT->isUnionType() &&
+ getASTContext().hasSameType(BaseT, DerivedT))
+ return true;
+
+ if (!IsDerivedFrom(Derived->getTypeLoc().getBeginLoc(), DerivedT, BaseT))
+ return false;
+
+ if (DerivedT->getAsCXXRecordDecl()->isStandardLayout())
+ return true;
+
+ return false;
+}
+
//===--- CHECK: pointer_with_type_tag attribute: datatypes should match ----//
/// Given a type tag expression find the type tag itself.
diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp
index 12f42f66e5e21b..1416dab9eb3a0e 100644
--- a/clang/lib/Sema/SemaExprCXX.cpp
+++ b/clang/lib/Sema/SemaExprCXX.cpp
@@ -6082,6 +6082,22 @@ static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, const TypeSourceI
Self.Diag(Rhs->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)
<< 1 << tok::kw___is_layout_compatible;
return Self.IsLayoutCompatible(LhsT, RhsT);
+ }
+ case BTT_IsPointerInterconvertibleBaseOf: {
+ if (!LhsT->isUnionType() && !RhsT->isUnionType() &&
+ !Self.getASTContext().hasSameUnqualifiedType(LhsT, RhsT)) {
+ Self.RequireCompleteType(Rhs->getTypeLoc().getBeginLoc(), RhsT,
+ diag::err_incomplete_type);
+ }
+
+ if (LhsT->isVariableArrayType())
+ Self.Diag(Lhs->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)
+ << 1 << tok::kw___is_pointer_interconvertible_base_of;
+ if (RhsT->isVariableArrayType())
+ Self.Diag(Rhs->getTypeLoc().getBeginLoc(), diag::err_vla_unsupported)
+ << 1 << tok::kw___is_pointer_interconvertible_base_of;
+
+ return Self.IsPointerInterconvertibleBaseOf(Lhs, Rhs);
}
default: llvm_unreachable("not a BTT");
}
diff --git a/clang/test/SemaCXX/type-traits.cpp b/clang/test/SemaCXX/type-traits.cpp
index 421d3007d27ffe..7c22a7659de9e8 100644
--- a/clang/test/SemaCXX/type-traits.cpp
+++ b/clang/test/SemaCXX/type-traits.cpp
@@ -1740,7 +1740,7 @@ void is_layout_compatible(int n)
static_assert(!__is_layout_compatible(void, int));
static_assert(__is_layout_compatible(void, const void));
static_assert(__is_layout_compatible(void, volatile void));
- static_assert(__is_layout_compatible(const int, volatile int));
+ static_assert(__is_layout_compatible(const void, volatile void));
static_assert(__is_layout_compatible(int, int));
static_assert(__is_layout_compatible(int, const int));
static_assert(__is_layout_compatible(int, volatile int));
@@ -1839,6 +1839,90 @@ void is_layout_compatible(int n)
static_assert(!__is_layout_compatible(EnumClassForward, int));
}
+namespace IPIBO {
+struct Base {};
+struct Base2 {};
+struct Base3 : Base {};
+struct Base3Virtual : virtual Base {};
+struct Derived : Base {};
+struct DerivedIndirect : Base3 {};
+struct DerivedMultiple : Base, Base2 {};
+struct DerivedAmbiguous : Base, Base3 {};
+/* expected-warning at -1 {{direct base 'Base' is inaccessible due to ambiguity:
+ struct IPIBO::DerivedAmbiguous -> Base
+ struct IPIBO::DerivedAmbiguous -> Base3 -> Base}} */
+struct DerivedPrivate : private Base {};
+struct DerivedVirtual : virtual Base {};
+
+union Union {};
+union UnionIncomplete;
+struct StructIncomplete;
+
+void is_pointer_interconvertible_base_of(int n)
+{
+ static_assert(__is_pointer_interconvertible_base_of(Base, Derived));
+ static_assert(!__is_pointer_interconvertible_base_of(Base2, Derived));
+ static_assert(__is_pointer_interconvertible_base_of(Base, DerivedIndirect));
+ static_assert(__is_pointer_interconvertible_base_of(Base, DerivedMultiple));
+ static_assert(!__is_pointer_interconvertible_base_of(Base3, DerivedMultiple));
+ static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedAmbiguous));
+ static_assert(__is_pointer_interconvertible_base_of(Base, DerivedPrivate));
+ static_assert(!__is_pointer_interconvertible_base_of(Base, DerivedVirtual));
+ static_assert(!__is_pointer_interconvertible_base_of(Union, Union));
+ static_assert(!__is_pointer_interconvertible_base_of(UnionIncomplete, UnionIncomplete));
+ static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, StructIncomplete));
+ static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, const StructIncomplete));
+ static_assert(__is_pointer_interconvertible_base_of(StructIncomplete, volatile StructIncomplete));
+ static_assert(__is_pointer_interconvertible_base_of(const StructIncomplete, volatile StructIncomplete));
+ static_assert(!__is_pointer_interconvertible_base_of(CStruct2, CppStructNonStandardByBase2));
+ static_assert(__is_pointer_interconvertible_base_of(void, void));
+ static_assert(!__is_pointer_interconvertible_base_of(void, int));
+ static_assert(__is_pointer_interconvertible_base_of(void, const void));
+ static_assert(__is_pointer_interconvertible_base_of(void, volatile void));
+ static_assert(__is_pointer_interconvertible_base_of(const void, volatile void));
+ static_assert(__is_pointer_interconvertible_base_of(int, int));
+ static_assert(__is_pointer_interconvertible_base_of(int, const int));
+ 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));
+ static_assert(!__is_pointer_interconvertible_base_of(int, _Atomic int));
+ static_assert(__is_pointer_interconvertible_base_of(_Atomic(int), _Atomic int));
+ 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));
+ using function_type = void();
+ using function_type2 = void(char);
+ static_assert(__is_pointer_interconvertible_base_of(const function_type, const function_type));
+ // 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_type' (aka 'void ()') has no effect}}
+ static_assert(__is_pointer_interconvertible_base_of(function_type, const function_type));
+ // expected-warning at -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 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}}
+ static_assert(__is_pointer_interconvertible_base_of(int CStruct2::*, int CStruct2::*));
+ static_assert(!__is_pointer_interconvertible_base_of(int CStruct2::*, char CStruct2::*));
+ 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)));
+ static_assert(__is_pointer_interconvertible_base_of(int[], int[]));
+ static_assert(__is_pointer_interconvertible_base_of(int[2], int[2]));
+ static_assert(!__is_pointer_interconvertible_base_of(int[n], int[2]));
+ // expected-error at -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 at -1 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}
+ // expected-error at -2 {{variable length arrays are not supported in '__is_pointer_interconvertible_base_of'}}
+ static_assert(__is_pointer_interconvertible_base_of(int&, int&));
+ static_assert(!__is_pointer_interconvertible_base_of(int&, 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)));
+ static_assert(__is_pointer_interconvertible_base_of(void(*)(int), void(*)(int)));
+ static_assert(!__is_pointer_interconvertible_base_of(void(*)(int), void(*)(char)));
+}
+}
+
void is_signed()
{
//static_assert(__is_signed(char));
More information about the cfe-commits
mailing list