philnik updated this revision to Diff 510887.
philnik added a comment.
Remove formatting changes
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D147175/new/
https://reviews.llvm.org/D147175
Files:
clang/docs/LanguageExtensions.rst
clang/include/clang/AST/ASTContext.h
clang/include/clang/AST/DeclCXX.h
clang/include/clang/AST/Type.h
clang/include/clang/Basic/TokenKinds.def
clang/lib/AST/ASTContext.cpp
clang/lib/AST/Type.cpp
clang/lib/Sema/SemaExprCXX.cpp
clang/test/SemaCXX/type-traits.cpp
libcxx/include/__algorithm/equal.h
libcxx/include/__string/constexpr_c_functions.h
libcxx/include/__type_traits/is_equality_comparable.h
libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
Index: libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
===================================================================
--- libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
+++ libcxx/test/libcxx/type_traits/is_trivially_comparable.compile.pass.cpp
@@ -13,32 +13,32 @@
enum Enum : int {};
enum class EnumClass : int {};
-static_assert(std::__is_trivially_equality_comparable<int, int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<const int, int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int, const int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<const int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int, const int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<unsigned int, unsigned int>::value, "");
-static_assert(std::__is_trivially_equality_comparable<const unsigned int, unsigned int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<unsigned int, int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<unsigned int, unsigned int>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<const unsigned int, unsigned int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<unsigned int, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<long, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<int, long>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<long, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<int, long>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int*, int*>::value, "");
-static_assert(std::__is_trivially_equality_comparable<int*, void*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<int*, long*>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int*, int*>::value, "");
+static_assert(std::__libcpp_is_trivially_equality_comparable<int*, void*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<int*, long*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<Enum, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<EnumClass, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<Enum, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<EnumClass, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<double, long long>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<double, long long>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, int>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, int>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<float, float>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<double, double>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<long double, long double>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<float, float>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<double, double>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<long double, long double>::value, "");
struct S {
char c;
@@ -51,8 +51,8 @@
struct VirtualBase : virtual S {};
struct NonVirtualBase : S, S2 {};
-static_assert(!std::__is_trivially_equality_comparable<S*, VirtualBase*>::value, "");
-static_assert(!std::__is_trivially_equality_comparable<S2*, VirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S*, VirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S2*, VirtualBase*>::value, "");
// This is trivially_equality_comparable, but we can't detect it currently
-static_assert(!std::__is_trivially_equality_comparable<S*, NonVirtualBase*>::value, "");
+static_assert(!std::__libcpp_is_trivially_equality_comparable<S*, NonVirtualBase*>::value, "");
Index: libcxx/include/__type_traits/is_equality_comparable.h
===================================================================
--- libcxx/include/__type_traits/is_equality_comparable.h
+++ libcxx/include/__type_traits/is_equality_comparable.h
@@ -43,14 +43,14 @@
// always compared.
template <class _Tp, class _Up>
-struct __is_trivially_equality_comparable
+struct __libcpp_is_trivially_equality_comparable
: integral_constant<bool,
__is_equality_comparable<_Tp, _Up>::value && is_integral<_Tp>::value &&
is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value> {};
// TODO: Use is_pointer_inverconvertible_base_of
template <class _Tp, class _Up>
-struct __is_trivially_equality_comparable<_Tp*, _Up*>
+struct __libcpp_is_trivially_equality_comparable<_Tp*, _Up*>
: integral_constant<
bool,
__is_equality_comparable<_Tp*, _Up*>::value &&
Index: libcxx/include/__string/constexpr_c_functions.h
===================================================================
--- libcxx/include/__string/constexpr_c_functions.h
+++ libcxx/include/__string/constexpr_c_functions.h
@@ -39,7 +39,7 @@
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int
__constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
static_assert(
- __is_trivially_equality_comparable<_Tp, _Up>::value, "_Tp and _Up have to be trivially equality comparable");
+ __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value, "_Tp and _Up have to be trivially equality comparable");
if (__libcpp_is_constant_evaluated()) {
#ifdef _LIBCPP_COMPILER_CLANG_BASED
Index: libcxx/include/__algorithm/equal.h
===================================================================
--- libcxx/include/__algorithm/equal.h
+++ libcxx/include/__algorithm/equal.h
@@ -46,7 +46,7 @@
class _Up,
class _BinaryPredicate,
__enable_if_t<__is_trivial_equality_predicate<_BinaryPredicate, _Tp, _Up>::value && !is_volatile<_Tp>::value &&
- !is_volatile<_Up>::value && __is_trivially_equality_comparable<_Tp, _Up>::value,
+ !is_volatile<_Up>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
int> = 0>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
__equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate&) {
@@ -96,7 +96,7 @@
class _Proj2,
__enable_if_t<__is_trivial_equality_predicate<_Pred, _Tp, _Up>::value && __is_identity<_Proj1>::value &&
__is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
- __is_trivially_equality_comparable<_Tp, _Up>::value,
+ __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
int> = 0>
_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
_Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
Index: clang/test/SemaCXX/type-traits.cpp
===================================================================
--- clang/test/SemaCXX/type-traits.cpp
+++ clang/test/SemaCXX/type-traits.cpp
@@ -1,6 +1,7 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -Wno-defaulted-function-deleted %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
#define T(b) (b) ? 1 : -1
#define F(b) (b) ? -1 : 1
@@ -570,7 +571,11 @@
static_assert(__is_aggregate(DerivesAr), "");
static_assert(__is_aggregate(DerivesArNB), "");
static_assert(!__is_aggregate(HasCons), "");
+#if __cplusplus >= 202002L
+ static_assert(!__is_aggregate(HasDefaultCons), "");
+#else
static_assert(__is_aggregate(HasDefaultCons), "");
+#endif
static_assert(!__is_aggregate(HasExplicitDefaultCons), "");
static_assert(!__is_aggregate(HasInheritedCons), "");
static_assert(__is_aggregate(HasNoInheritedCons) == TrueAfterCpp14, "");
@@ -3055,6 +3060,148 @@
} // namespace is_trivially_relocatable
+namespace is_trivially_equality_comparable {
+struct ForwardDeclared; // expected-note {{forward declaration of 'is_trivially_equality_comparable::ForwardDeclared'}}
+static_assert(!__is_trivially_equality_comparable(ForwardDeclared), ""); // expected-error {{incomplete type 'ForwardDeclared' used in type trait expression}}
+
+static_assert(!__is_trivially_equality_comparable(void), "");
+static_assert(__is_trivially_equality_comparable(int), "");
+static_assert(!__is_trivially_equality_comparable(int[]), "");
+static_assert(__is_trivially_equality_comparable(int[3]), "");
+static_assert(!__is_trivially_equality_comparable(float), "");
+static_assert(!__is_trivially_equality_comparable(double), "");
+static_assert(!__is_trivially_equality_comparable(long double), "");
+
+struct TriviallyEqualityComparableNoDefaultedComparator {
+ int i;
+ int j;
+};
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparableNoDefaultedComparator), "");
+
+#if __cplusplus >= 202002L
+
+struct TriviallyEqualityComparable {
+ int i;
+ int j;
+
+ void func();
+ bool operator==(int) const { return false; }
+
+ bool operator==(const TriviallyEqualityComparable&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable), "");
+
+struct NotTriviallyEqualityComparableHasPadding {
+ short i;
+ int j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasPadding&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasPadding), "");
+
+struct NotTriviallyEqualityComparableHasFloat {
+ float i;
+ int j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasFloat&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasFloat), "");
+
+struct NotTriviallyEqualityComparableHasTailPadding {
+ int i;
+ char j;
+
+ bool operator==(const NotTriviallyEqualityComparableHasTailPadding&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableHasTailPadding), "");
+
+struct NotTriviallyEqualityComparableBase : NotTriviallyEqualityComparableHasTailPadding {
+ char j;
+
+ bool operator==(const NotTriviallyEqualityComparableBase&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBase), "");
+
+class TriviallyEqualityComparablePaddedOutBase {
+ int i;
+ char c;
+
+public:
+ bool operator==(const TriviallyEqualityComparablePaddedOutBase&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOutBase), "");
+
+struct TriviallyEqualityComparablePaddedOut : TriviallyEqualityComparablePaddedOutBase {
+ char j[3];
+
+ bool operator==(const TriviallyEqualityComparablePaddedOut&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparablePaddedOut), "");
+
+struct TriviallyEqualityComparable1 {
+ char i;
+
+ bool operator==(const TriviallyEqualityComparable1&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable1));
+
+struct TriviallyEqualityComparable2 {
+ int i;
+
+ bool operator==(const TriviallyEqualityComparable2&) const = default;
+};
+static_assert(__is_trivially_equality_comparable(TriviallyEqualityComparable2));
+
+struct NotTriviallyEqualityComparableTriviallyEqualityComparableBases
+ : TriviallyEqualityComparable1, TriviallyEqualityComparable2 {
+ bool operator==(const NotTriviallyEqualityComparableTriviallyEqualityComparableBases&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableTriviallyEqualityComparableBases));
+
+struct NotTriviallyEqualityComparableBitfield {
+ int i : 1;
+
+ bool operator==(const NotTriviallyEqualityComparableBitfield&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+
+// TODO: This is trivially equality comparable
+struct NotTriviallyEqualityComparableBitfieldFilled {
+ char i : __CHAR_BIT__;
+
+ bool operator==(const NotTriviallyEqualityComparableBitfieldFilled&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableBitfield));
+
+union U {
+ int i;
+
+ bool operator==(const U&) const = default;
+};
+
+struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion {
+ U u;
+
+ bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByUnion));
+
+struct NotTriviallyEqualityComparableExplicitlyDeleted {
+ int i;
+
+ bool operator==(const NotTriviallyEqualityComparableExplicitlyDeleted&) const = delete;
+};
+
+struct NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct {
+ NotTriviallyEqualityComparableExplicitlyDeleted u;
+
+ bool operator==(const NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct&) const = default;
+};
+static_assert(!__is_trivially_equality_comparable(NotTriviallyEqualityComparableImplicitlyDeletedOperatorByStruct));
+
+#endif // __cplusplus >= 202002L
+};
+
namespace can_pass_in_regs {
struct A { };
Index: clang/lib/Sema/SemaExprCXX.cpp
===================================================================
--- clang/lib/Sema/SemaExprCXX.cpp
+++ clang/lib/Sema/SemaExprCXX.cpp
@@ -4886,8 +4886,10 @@
case UTT_IsStandardLayout:
case UTT_IsPOD:
case UTT_IsLiteral:
- // By analogy, is_trivially_relocatable imposes the same constraints.
+ // By analogy, is_trivially_relocatable and is_trivially_equality_comparable
+ // impose the same constraints.
case UTT_IsTriviallyRelocatable:
+ case UTT_IsTriviallyEqualityComparable:
case UTT_CanPassInRegs:
// Per the GCC type traits documentation, T shall be a complete type, cv void,
// or an array of unknown bound. But GCC actually imposes the same constraints
@@ -5382,6 +5384,8 @@
return RD->canPassInRegisters();
Self.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) << T;
return false;
+ case UTT_IsTriviallyEqualityComparable:
+ return T.isTriviallyEqualityComparableType(C);
}
}
Index: clang/lib/AST/Type.cpp
===================================================================
--- clang/lib/AST/Type.cpp
+++ clang/lib/AST/Type.cpp
@@ -2594,6 +2594,47 @@
}
}
+static bool HasDefaultedEqualityComparison(const CXXRecordDecl *Decl) {
+ if (Decl->isUnion())
+ return false;
+
+ if (llvm::none_of(Decl->methods(), [](const CXXMethodDecl *MemberFunction) {
+ return MemberFunction->isOverloadedOperator() &&
+ MemberFunction->getOverloadedOperator() ==
+ OverloadedOperatorKind::OO_EqualEqual &&
+ MemberFunction->isDefaulted();
+ }))
+ return false;
+
+ return llvm::all_of(Decl->bases(),
+ [](const CXXBaseSpecifier &BS) {
+ if (!BS.getType()->isRecordType())
+ return true;
+ return HasDefaultedEqualityComparison(
+ BS.getType()->getAsCXXRecordDecl());
+ }) &&
+ llvm::all_of(Decl->fields(), [](const FieldDecl *FD) {
+ if (!FD->getType()->isRecordType())
+ return true;
+ return HasDefaultedEqualityComparison(
+ FD->getType()->getAsCXXRecordDecl());
+ });
+}
+
+bool QualType::isTriviallyEqualityComparableType(
+ const ASTContext &Context) const {
+ QualType CanonicalType = getCanonicalType();
+ if (CanonicalType->isIncompleteType() || CanonicalType->isDependentType())
+ return false;
+
+ if (const auto *RecordDecl = CanonicalType->getAsCXXRecordDecl()) {
+ if (!HasDefaultedEqualityComparison(CanonicalType->getAsCXXRecordDecl()))
+ return false;
+ }
+
+ return Context.hasUniqueObjectRepresentations(CanonicalType);
+}
+
bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
return !Context.getLangOpts().ObjCAutoRefCount &&
Context.getLangOpts().ObjCWeak &&
@@ -4599,9 +4640,9 @@
}
void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
- QualType Deduced, AutoTypeKeyword Keyword,
- bool IsDependent, ConceptDecl *CD,
- ArrayRef<TemplateArgument> Arguments) {
+ QualType Deduced, AutoTypeKeyword Keyword,
+ bool IsDependent, ConceptDecl *CD,
+ ArrayRef<TemplateArgument> Arguments) {
ID.AddPointer(Deduced.getAsOpaquePtr());
ID.AddInteger((unsigned)Keyword);
ID.AddBoolean(IsDependent);
Index: clang/lib/AST/ASTContext.cpp
===================================================================
--- clang/lib/AST/ASTContext.cpp
+++ clang/lib/AST/ASTContext.cpp
@@ -2762,12 +2762,14 @@
}
static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD) {
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCOpyable) {
assert(RD->isUnion() && "Must be union type");
CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
for (const auto *Field : RD->fields()) {
- if (!Context.hasUniqueObjectRepresentations(Field->getType()))
+ if (!Context.hasUniqueObjectRepresentations(Field->getType(),
+ CheckIfTriviallyCOpyable))
return false;
CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
if (FieldSize != UnionSize)
@@ -2790,21 +2792,25 @@
static std::optional<int64_t>
structHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD);
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCopyable);
static std::optional<int64_t>
-getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context) {
+getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context,
+ bool CheckIfTriviallyCopyable) {
if (Field->getType()->isRecordType()) {
const RecordDecl *RD = Field->getType()->getAsRecordDecl();
if (!RD->isUnion())
- return structHasUniqueObjectRepresentations(Context, RD);
+ return structHasUniqueObjectRepresentations(Context, RD,
+ CheckIfTriviallyCopyable);
}
// A _BitInt type may not be unique if it has padding bits
// but if it is a bitfield the padding bits are not used.
bool IsBitIntType = Field->getType()->isBitIntType();
if (!Field->getType()->isReferenceType() && !IsBitIntType &&
- !Context.hasUniqueObjectRepresentations(Field->getType()))
+ !Context.hasUniqueObjectRepresentations(Field->getType(),
+ CheckIfTriviallyCopyable))
return std::nullopt;
int64_t FieldSizeInBits =
@@ -2819,25 +2825,28 @@
return std::nullopt;
}
FieldSizeInBits = BitfieldSize;
- } else if (IsBitIntType &&
- !Context.hasUniqueObjectRepresentations(Field->getType())) {
+ } else if (IsBitIntType && !Context.hasUniqueObjectRepresentations(
+ Field->getType(), CheckIfTriviallyCopyable)) {
return std::nullopt;
}
return FieldSizeInBits;
}
static std::optional<int64_t>
-getSubobjectSizeInBits(const CXXRecordDecl *RD, const ASTContext &Context) {
- return structHasUniqueObjectRepresentations(Context, RD);
+getSubobjectSizeInBits(const CXXRecordDecl *RD, const ASTContext &Context,
+ bool CheckIfTriviallyCopyable) {
+ return structHasUniqueObjectRepresentations(Context, RD,
+ CheckIfTriviallyCopyable);
}
template <typename RangeT>
static std::optional<int64_t> structSubobjectsHaveUniqueObjectRepresentations(
const RangeT &Subobjects, int64_t CurOffsetInBits,
- const ASTContext &Context, const clang::ASTRecordLayout &Layout) {
+ const ASTContext &Context, const clang::ASTRecordLayout &Layout,
+ bool CheckIfTriviallyCopyable) {
for (const auto *Subobject : Subobjects) {
std::optional<int64_t> SizeInBits =
- getSubobjectSizeInBits(Subobject, Context);
+ getSubobjectSizeInBits(Subobject, Context, CheckIfTriviallyCopyable);
if (!SizeInBits)
return std::nullopt;
if (*SizeInBits != 0) {
@@ -2852,7 +2861,8 @@
static std::optional<int64_t>
structHasUniqueObjectRepresentations(const ASTContext &Context,
- const RecordDecl *RD) {
+ const RecordDecl *RD,
+ bool CheckIfTriviallyCopyable) {
assert(!RD->isUnion() && "Must be struct/class type");
const auto &Layout = Context.getASTRecordLayout(RD);
@@ -2873,8 +2883,8 @@
});
std::optional<int64_t> OffsetAfterBases =
- structSubobjectsHaveUniqueObjectRepresentations(Bases, CurOffsetInBits,
- Context, Layout);
+ structSubobjectsHaveUniqueObjectRepresentations(
+ Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);
if (!OffsetAfterBases)
return std::nullopt;
CurOffsetInBits = *OffsetAfterBases;
@@ -2882,7 +2892,8 @@
std::optional<int64_t> OffsetAfterFields =
structSubobjectsHaveUniqueObjectRepresentations(
- RD->fields(), CurOffsetInBits, Context, Layout);
+ RD->fields(), CurOffsetInBits, Context, Layout,
+ CheckIfTriviallyCopyable);
if (!OffsetAfterFields)
return std::nullopt;
CurOffsetInBits = *OffsetAfterFields;
@@ -2890,7 +2901,8 @@
return CurOffsetInBits;
}
-bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
+bool ASTContext::hasUniqueObjectRepresentations(
+ QualType Ty, bool CheckIfTriviallyCopyable) const {
// C++17 [meta.unary.prop]:
// The predicate condition for a template specialization
// has_unique_object_representations<T> shall be
@@ -2912,10 +2924,11 @@
// Arrays are unique only if their element type is unique.
if (Ty->isArrayType())
- return hasUniqueObjectRepresentations(getBaseElementType(Ty));
+ return hasUniqueObjectRepresentations(getBaseElementType(Ty),
+ CheckIfTriviallyCopyable);
// (9.1) - T is trivially copyable...
- if (!Ty.isTriviallyCopyableType(*this))
+ if (CheckIfTriviallyCopyable && !Ty.isTriviallyCopyableType(*this))
return false;
// All integrals and enums are unique.
@@ -2943,10 +2956,11 @@
return false;
if (Record->isUnion())
- return unionHasUniqueObjectRepresentations(*this, Record);
+ return unionHasUniqueObjectRepresentations(*this, Record,
+ CheckIfTriviallyCopyable);
- std::optional<int64_t> StructSize =
- structHasUniqueObjectRepresentations(*this, Record);
+ std::optional<int64_t> StructSize = structHasUniqueObjectRepresentations(
+ *this, Record, CheckIfTriviallyCopyable);
return StructSize && *StructSize == static_cast<int64_t>(getTypeSize(Ty));
}
Index: clang/include/clang/Basic/TokenKinds.def
===================================================================
--- clang/include/clang/Basic/TokenKinds.def
+++ clang/include/clang/Basic/TokenKinds.def
@@ -519,6 +519,7 @@
// Clang-only C++ Type Traits
TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
+TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
Index: clang/include/clang/AST/Type.h
===================================================================
--- clang/include/clang/AST/Type.h
+++ clang/include/clang/AST/Type.h
@@ -899,6 +899,9 @@
/// Return true if this is a trivially relocatable type.
bool isTriviallyRelocatableType(const ASTContext &Context) const;
+ /// Return true if this is a trivially equality comparable type.
+ bool isTriviallyEqualityComparableType(const ASTContext &Context) const;
+
/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;
Index: clang/include/clang/AST/DeclCXX.h
===================================================================
--- clang/include/clang/AST/DeclCXX.h
+++ clang/include/clang/AST/DeclCXX.h
@@ -1446,7 +1446,7 @@
}
/// Notify the class that this destructor is now selected.
- ///
+ ///
/// Important properties of the class depend on destructor properties. Since
/// C++20, it is possible to have multiple destructor declarations in a class
/// out of which one will be selected at the end.
Index: clang/include/clang/AST/ASTContext.h
===================================================================
--- clang/include/clang/AST/ASTContext.h
+++ clang/include/clang/AST/ASTContext.h
@@ -2488,7 +2488,9 @@
/// Return true if the specified type has unique object representations
/// according to (C++17 [meta.unary.prop]p9)
- bool hasUniqueObjectRepresentations(QualType Ty) const;
+ bool
+ hasUniqueObjectRepresentations(QualType Ty,
+ bool CheckIfTriviallyCopyable = true) const;
//===--------------------------------------------------------------------===//
// Type Operators
Index: clang/docs/LanguageExtensions.rst
===================================================================
--- clang/docs/LanguageExtensions.rst
+++ clang/docs/LanguageExtensions.rst
@@ -1507,6 +1507,9 @@
functionally equivalent to copying the underlying bytes and then dropping the
source object on the floor. This is true of trivial types and types which
were made trivially relocatable via the ``clang::trivial_abi`` attribute.
+* ``__is_trivially_equality_comparable`` (Clang): Returns true if comparing two
+ objects of the provided type is known to be equivalent to comparing their
+ value representations.
* ``__is_unbounded_array`` (C++, GNU, Microsoft, Embarcadero)
* ``__is_union`` (C++, GNU, Microsoft, Embarcadero)
* ``__is_unsigned`` (C++, Embarcadero):
@@ -4928,7 +4931,7 @@
`dump`
------
Accepts either a single identifier or an expression. When a single identifier is passed,
-the lookup results for the identifier are printed to `stderr`. When an expression is passed,
+the lookup results for the identifier are printed to `stderr`. When an expression is passed,
the AST for the expression is printed to `stderr`. The expression is an unevaluated operand,
so things like overload resolution and template instantiations are performed,
but the expression has no runtime effects.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
