philnik created this revision.
philnik added a reviewer: aaron.ballman.
Herald added a project: All.
philnik requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
This patch adds a new trait to allow standard libraries to forward `std::equal`
calls to `memcmp` in more cases.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D147175
Files:
clang/docs/LanguageExtensions.rst
clang/include/clang/AST/DeclCXX.h
clang/include/clang/AST/RecordLayout.h
clang/include/clang/AST/Type.h
clang/include/clang/Basic/TokenKinds.def
clang/lib/AST/RecordLayout.cpp
clang/lib/AST/RecordLayoutBuilder.cpp
clang/lib/AST/Type.cpp
clang/lib/Sema/SemaExprCXX.cpp
clang/test/SemaCXX/type-traits.cpp
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,139 @@
} // 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), "");
+
+struct TriviallyEqualityComparablePaddedOut : NotTriviallyEqualityComparableHasTailPadding {
+ 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
@@ -25,6 +25,7 @@
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/NonTrivialTypeVisitor.h"
#include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/RecordLayout.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/TypeVisitor.h"
@@ -2594,6 +2595,51 @@
}
}
+bool QualType::isTriviallyEqualityComparableType(const ASTContext &Context,
+ bool IgnoreTailPadding) const {
+ QualType CanonicalType = getCanonicalType();
+ if (CanonicalType->isIncompleteType())
+ return false;
+
+ if (CanonicalType->isSizelessBuiltinType())
+ return true;
+
+ if (CanonicalType->isIntegerType())
+ return true;
+
+ if (const auto *RecordDecl = CanonicalType->getAsCXXRecordDecl()) {
+ if (!RecordDecl->isStandardLayout() || RecordDecl->isUnion())
+ return false;
+
+ if (llvm::none_of(RecordDecl->methods(),
+ [](const CXXMethodDecl *MemberFunction) {
+ return MemberFunction->isOverloadedOperator() &&
+ MemberFunction->getOverloadedOperator() ==
+ OverloadedOperatorKind::OO_EqualEqual &&
+ MemberFunction->isDefaulted();
+ }))
+ return false;
+
+ if (!llvm::all_of(RecordDecl->bases(), [&](const CXXBaseSpecifier &base) {
+ return base.getType().isTriviallyEqualityComparableType(Context);
+ }))
+ return false;
+
+ if (!llvm::all_of(RecordDecl->fields(), [&](const FieldDecl *field) {
+ return field->getType().isTriviallyEqualityComparableType(Context);
+ }))
+ return false;
+
+ const ASTRecordLayout &RecordLayout =
+ Context.getASTRecordLayout(RecordDecl);
+
+ return !RecordLayout.mightHaveInternalPadding() &&
+ (!RecordLayout.mightHaveTailPadding() || IgnoreTailPadding);
+ }
+
+ return false;
+}
+
bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
return !Context.getLangOpts().ObjCAutoRefCount &&
Context.getLangOpts().ObjCWeak &&
Index: clang/lib/AST/RecordLayoutBuilder.cpp
===================================================================
--- clang/lib/AST/RecordLayoutBuilder.cpp
+++ clang/lib/AST/RecordLayoutBuilder.cpp
@@ -619,6 +619,9 @@
unsigned IsMsStruct : 1;
+ unsigned HasInternalPadding : 1 = false;
+ unsigned HasTailPadding : 1 = false;
+
/// UnfilledBitsInLastUnit - If the last field laid out was a bitfield,
/// this contains the number of bits in the last unit that can be used for
/// an adjacent bitfield if necessary. The unit in question is usually
@@ -2186,6 +2189,7 @@
if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
// Warn if padding was introduced to the struct/class/union.
if (getSizeInBits() > UnpaddedSize) {
+ HasTailPadding = true;
unsigned PadSize = getSizeInBits() - UnpaddedSize;
bool InBits = true;
if (PadSize % CharBitNum == 0) {
@@ -2283,6 +2287,7 @@
// Warn if padding was introduced to the struct/class.
if (!IsUnion && Offset > UnpaddedOffset) {
+ HasInternalPadding = true;
unsigned PadSize = Offset - UnpaddedOffset;
bool InBits = true;
if (PadSize % CharBitNum == 0) {
@@ -3307,8 +3312,8 @@
Builder.DataSize, Builder.FieldOffsets, Builder.NonVirtualSize,
Builder.Alignment, Builder.Alignment, CharUnits::Zero(),
Builder.PrimaryBase, false, Builder.SharedVBPtrBase,
- Builder.EndsWithZeroSizedObject, Builder.LeadsWithZeroSizedBase,
- Builder.Bases, Builder.VBases);
+ Builder.EndsWithZeroSizedObject, Builder.LeadsWithZeroSizedBase, true,
+ true, Builder.Bases, Builder.VBases);
} else {
Builder.layout(D);
NewEntry = new (*this) ASTRecordLayout(
@@ -3342,7 +3347,8 @@
NonVirtualSize, Builder.NonVirtualAlignment,
Builder.PreferredNVAlignment,
EmptySubobjects.SizeOfLargestEmptySubobject, Builder.PrimaryBase,
- Builder.PrimaryBaseIsVirtual, nullptr, false, false, Builder.Bases,
+ Builder.PrimaryBaseIsVirtual, nullptr, false, false,
+ Builder.HasInternalPadding, Builder.HasTailPadding, Builder.Bases,
Builder.VBases);
} else {
ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr);
Index: clang/lib/AST/RecordLayout.cpp
===================================================================
--- clang/lib/AST/RecordLayout.cpp
+++ clang/lib/AST/RecordLayout.cpp
@@ -51,13 +51,14 @@
CharUnits preferrednvalignment, CharUnits SizeOfLargestEmptySubobject,
const CXXRecordDecl *PrimaryBase, bool IsPrimaryBaseVirtual,
const CXXRecordDecl *BaseSharingVBPtr, bool EndsWithZeroSizedObject,
- bool LeadsWithZeroSizedBase, const BaseOffsetsMapTy &BaseOffsets,
+ bool LeadsWithZeroSizedBase, bool MightHaveInternalPadding,
+ bool MightHaveTailPadding, const BaseOffsetsMapTy &BaseOffsets,
const VBaseOffsetsMapTy &VBaseOffsets)
: Size(size), DataSize(datasize), Alignment(alignment),
PreferredAlignment(preferredAlignment),
UnadjustedAlignment(unadjustedAlignment),
RequiredAlignment(requiredAlignment),
- CXXInfo(new (Ctx) CXXRecordLayoutInfo) {
+ CXXInfo(new(Ctx) CXXRecordLayoutInfo) {
FieldOffsets.append(Ctx, fieldoffsets.begin(), fieldoffsets.end());
CXXInfo->PrimaryBase.setPointer(PrimaryBase);
@@ -74,6 +75,8 @@
CXXInfo->BaseSharingVBPtr = BaseSharingVBPtr;
CXXInfo->EndsWithZeroSizedObject = EndsWithZeroSizedObject;
CXXInfo->LeadsWithZeroSizedBase = LeadsWithZeroSizedBase;
+ CXXInfo->MightHaveInternalPadding = MightHaveInternalPadding;
+ CXXInfo->MightHaveTailPadding = MightHaveTailPadding;
#ifndef NDEBUG
if (const CXXRecordDecl *PrimaryBase = getPrimaryBase()) {
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,10 @@
/// 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,
+ bool IgnoreTailPadding = false) const;
+
/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;
Index: clang/include/clang/AST/RecordLayout.h
===================================================================
--- clang/include/clang/AST/RecordLayout.h
+++ clang/include/clang/AST/RecordLayout.h
@@ -128,6 +128,13 @@
/// has this property. Only used for MS-ABI.
bool LeadsWithZeroSizedBase : 1;
+ /// True if there could be padding between members of the record.
+ /// Tail-padding is ignored.
+ bool MightHaveInternalPadding : 1;
+
+ /// True if there could be tail padding.
+ bool MightHaveTailPadding : 1;
+
/// PrimaryBase - The primary base info for this record.
llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> PrimaryBase;
@@ -167,6 +174,7 @@
const CXXRecordDecl *PrimaryBase, bool IsPrimaryBaseVirtual,
const CXXRecordDecl *BaseSharingVBPtr,
bool EndsWithZeroSizedObject, bool LeadsWithZeroSizedBase,
+ bool MightHaveInternalPadding, bool MightHaveTailPadding,
const BaseOffsetsMapTy &BaseOffsets,
const VBaseOffsetsMapTy &VBaseOffsets);
@@ -319,6 +327,16 @@
return CXXInfo->LeadsWithZeroSizedBase;
}
+ bool mightHaveInternalPadding() const {
+ assert(CXXInfo && "Record layout does not have C++ specific info!");
+ return CXXInfo->MightHaveInternalPadding;
+ }
+
+ bool mightHaveTailPadding() const {
+ assert(CXXInfo && "Record layout does not have C++ specific info!");
+ return CXXInfo->MightHaveTailPadding;
+ }
+
/// getVBPtrOffset - Get the offset for virtual base table pointer.
/// This is only meaningful with the Microsoft ABI.
CharUnits getVBPtrOffset() 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/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
