GCC 14 warns about these.
Details
Details
Diff Detail
Diff Detail
Unit Tests
Unit Tests
Event Timeline
Comment Actions
By full context, you mean the whole file with the diff included? Or something else?
//===- llvm/ADT/PointerSumType.h --------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_POINTERSUMTYPE_H
#define LLVM_ADT_POINTERSUMTYPE_H
#include "llvm/ADT/bit.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/PointerLikeTypeTraits.h"
#include <cassert>
#include <cstdint>
#include <type_traits>
namespace llvm {
/// A compile time pair of an integer tag and the pointer-like type which it
/// indexes within a sum type. Also allows the user to specify a particular
/// traits class for pointer types with custom behavior such as over-aligned
/// allocation.
template <uintptr_t N, typename PointerArgT,
typename TraitsArgT = PointerLikeTypeTraits<PointerArgT>>
struct PointerSumTypeMember {
enum { Tag = N };
using PointerT = PointerArgT;
using TraitsT = TraitsArgT;
};
namespace detail {
template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper;
} // end namespace detail
/// A sum type over pointer-like types.
///
/// This is a normal tagged union across pointer-like types that uses the low
/// bits of the pointers to store the tag.
///
/// Each member of the sum type is specified by passing a \c
/// PointerSumTypeMember specialization in the variadic member argument list.
/// This allows the user to control the particular tag value associated with
/// a particular type, use the same type for multiple different tags, and
/// customize the pointer-like traits used for a particular member. Note that
/// these *must* be specializations of \c PointerSumTypeMember, no other type
/// will suffice, even if it provides a compatible interface.
///
/// This type implements all of the comparison operators and even hash table
/// support by comparing the underlying storage of the pointer values. It
/// doesn't support delegating to particular members for comparisons.
///
/// It also default constructs to a zero tag with a null pointer, whatever that
/// would be. This means that the zero value for the tag type is significant
/// and may be desirable to set to a state that is particularly desirable to
/// default construct.
///
/// Having a supported zero-valued tag also enables getting the address of a
/// pointer stored with that tag provided it is stored in its natural bit
/// representation. This works because in the case of a zero-valued tag, the
/// pointer's value is directly stored into this object and we can expose the
/// address of that internal storage. This is especially useful when building an
/// `ArrayRef` of a single pointer stored in a sum type.
///
/// There is no support for constructing or accessing with a dynamic tag as
/// that would fundamentally violate the type safety provided by the sum type.
template <typename TagT, typename... MemberTs> class PointerSumType {
using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
// We keep both the raw value and the min tag value's pointer in a union. When
// the minimum tag value is zero, this allows code below to cleanly expose the
// address of the zero-tag pointer instead of just the zero-tag pointer
// itself. This is especially useful when building `ArrayRef`s out of a single
// pointer. However, we have to carefully access the union due to the active
// member potentially changing. When we *store* a new value, we directly
// access the union to allow us to store using the obvious types. However,
// when we *read* a value, we copy the underlying storage out to avoid relying
// on one member or the other being active.
union StorageT {
// Ensure we get a null default constructed value. We don't use a member
// initializer because some compilers seem to not implement those correctly
// for a union.
StorageT() : Value(0) {}
uintptr_t Value;
typename HelperT::template Lookup<HelperT::MinTag>::PointerT MinTagPointer;
};
StorageT Storage;
public:
constexpr PointerSumType() = default;
/// A typed setter to a given tagged member of the sum type.
template <TagT N>
void set(typename HelperT::template Lookup<N>::PointerT Pointer) {
void *V = HelperT::template Lookup<N>::TraitsT::getAsVoidPointer(Pointer);
assert((reinterpret_cast<uintptr_t>(V) & HelperT::TagMask) == 0 &&
"Pointer is insufficiently aligned to store the discriminant!");
Storage.Value = reinterpret_cast<uintptr_t>(V) | N;
}
/// A typed constructor for a specific tagged member of the sum type.
template <TagT N>
static PointerSumType
create(typename HelperT::template Lookup<N>::PointerT Pointer) {
PointerSumType Result;
Result.set<N>(Pointer);
return Result;
}
/// Clear the value to null with the min tag type.
void clear() { set<HelperT::MinTag>(nullptr); }
TagT getTag() const {
return static_cast<TagT>(getOpaqueValue() & HelperT::TagMask);
}
template <TagT N> bool is() const { return N == getTag(); }
template <TagT N> typename HelperT::template Lookup<N>::PointerT get() const {
void *P = is<N>() ? getVoidPtr() : nullptr;
return HelperT::template Lookup<N>::TraitsT::getFromVoidPointer(P);
}
template <TagT N>
typename HelperT::template Lookup<N>::PointerT cast() const {
assert(is<N>() && "This instance has a different active member.");
return HelperT::template Lookup<N>::TraitsT::getFromVoidPointer(
getVoidPtr());
}
/// If the tag is zero and the pointer's value isn't changed when being
/// stored, get the address of the stored value type-punned to the zero-tag's
/// pointer type.
typename HelperT::template Lookup<HelperT::MinTag>::PointerT const *
getAddrOfZeroTagPointer() const {
return const_cast<PointerSumType *>(this)->getAddrOfZeroTagPointer();
}
/// If the tag is zero and the pointer's value isn't changed when being
/// stored, get the address of the stored value type-punned to the zero-tag's
/// pointer type.
typename HelperT::template Lookup<HelperT::MinTag>::PointerT *
getAddrOfZeroTagPointer() {
static_assert(HelperT::MinTag == 0, "Non-zero minimum tag value!");
assert(is<HelperT::MinTag>() && "The active tag is not zero!");
// Store the initial value of the pointer when read out of our storage.
auto InitialPtr = get<HelperT::MinTag>();
// Now update the active member of the union to be the actual pointer-typed
// member so that accessing it indirectly through the returned address is
// valid.
Storage.MinTagPointer = InitialPtr;
// Finally, validate that this was a no-op as expected by reading it back
// out using the same underlying-storage read as above.
assert(InitialPtr == get<HelperT::MinTag>() &&
"Switching to typed storage changed the pointer returned!");
// Now we can correctly return an address to typed storage.
return &Storage.MinTagPointer;
}
explicit operator bool() const {
return getOpaqueValue() & HelperT::PointerMask;
}
bool operator==(const PointerSumType &R) const {
return getOpaqueValue() == R.getOpaqueValue();
}
bool operator!=(const PointerSumType &R) const {
return getOpaqueValue() != R.getOpaqueValue();
}
bool operator<(const PointerSumType &R) const {
return getOpaqueValue() < R.getOpaqueValue();
}
bool operator>(const PointerSumType &R) const {
return getOpaqueValue() > R.getOpaqueValue();
}
bool operator<=(const PointerSumType &R) const {
return getOpaqueValue() <= R.getOpaqueValue();
}
bool operator>=(const PointerSumType &R) const {
return getOpaqueValue() >= R.getOpaqueValue();
}
uintptr_t getOpaqueValue() const {
// Read the underlying storage of the union, regardless of the active
// member.
return bit_cast<uintptr_t>(Storage);
}
protected:
void *getVoidPtr() const {
return reinterpret_cast<void *>(getOpaqueValue() & HelperT::PointerMask);
}
};
namespace detail {
/// A helper template for implementing \c PointerSumType. It provides fast
/// compile-time lookup of the member from a particular tag value, along with
/// useful constants and compile time checking infrastructure..
template <typename TagT, typename... MemberTs>
struct PointerSumTypeHelper : MemberTs... {
// First we use a trick to allow quickly looking up information about
// a particular member of the sum type. This works because we arranged to
// have this type derive from all of the member type templates. We can select
// the matching member for a tag using type deduction during overload
// resolution.
template <TagT N, typename PointerT, typename TraitsT>
static PointerSumTypeMember<N, PointerT, TraitsT>
LookupOverload(PointerSumTypeMember<N, PointerT, TraitsT> *);
template <TagT N> static void LookupOverload(...);
template <TagT N> struct Lookup {
// Compute a particular member type by resolving the lookup helper overload.
using MemberT = decltype(
LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr)));
/// The Nth member's pointer type.
using PointerT = typename MemberT::PointerT;
/// The Nth member's traits type.
using TraitsT = typename MemberT::TraitsT;
};
// Next we need to compute the number of bits available for the discriminant
// by taking the min of the bits available for each member. Much of this
// would be amazingly easier with good constexpr support.
template <uintptr_t V, uintptr_t... Vs>
struct Min : std::integral_constant<
uintptr_t, (V < Min<Vs...>::value ? V : Min<Vs...>::value)> {
};
template <uintptr_t V>
struct Min<V> : std::integral_constant<uintptr_t, V> {};
enum { NumTagBits = Min<MemberTs::TraitsT::NumLowBitsAvailable...>::value };
// Also compute the smallest discriminant and various masks for convenience.
constexpr static TagT MinTag =
static_cast<TagT>(Min<MemberTs::Tag...>::value);
enum : uint64_t {
PointerMask = static_cast<uint64_t>(-1) << NumTagBits,
TagMask = ~PointerMask
};
// Finally we need a recursive template to do static checks of each
// member.
template <typename MemberT, typename... InnerMemberTs>
struct Checker : Checker<InnerMemberTs...> {
static_assert(MemberT::Tag < (1 << NumTagBits),
"This discriminant value requires too many bits!");
};
template <typename MemberT> struct Checker<MemberT> : std::true_type {
static_assert(MemberT::Tag < (1 << NumTagBits),
"This discriminant value requires too many bits!");
};
static_assert(Checker<MemberTs...>::value,
"Each member must pass the checker.");
};
} // end namespace detail
// Teach DenseMap how to use PointerSumTypes as keys.
template <typename TagT, typename... MemberTs>
struct DenseMapInfo<PointerSumType<TagT, MemberTs...>> {
using SumType = PointerSumType<TagT, MemberTs...>;
using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>;
enum { SomeTag = HelperT::MinTag };
using SomePointerT =
typename HelperT::template Lookup<HelperT::MinTag>::PointerT;
using SomePointerInfo = DenseMapInfo<SomePointerT>;
static inline SumType getEmptyKey() {
- return SumType::create<SomeTag>(SomePointerInfo::getEmptyKey());
+ return SumType::template create<SomeTag>(SomePointerInfo::getEmptyKey());
}
static inline SumType getTombstoneKey() {
- return SumType::create<SomeTag>(SomePointerInfo::getTombstoneKey());
+ return SumType::template create<SomeTag>(
+ SomePointerInfo::getTombstoneKey());
}
static unsigned getHashValue(const SumType &Arg) {
uintptr_t OpaqueValue = Arg.getOpaqueValue();
return DenseMapInfo<uintptr_t>::getHashValue(OpaqueValue);
}
static bool isEqual(const SumType &LHS, const SumType &RHS) {
return LHS == RHS;
}
};
} // end namespace llvm
#endif // LLVM_ADT_POINTERSUMTYPE_HComment Actions
diff --git a/llvm/include/llvm/ADT/PointerSumType.h b/llvm/include/llvm/ADT/PointerSumType.h index a7ef774e20..57f045035a 100644 --- a/llvm/include/llvm/ADT/PointerSumType.h +++ b/llvm/include/llvm/ADT/PointerSumType.h @@ -1,294 +1,295 @@ //===- llvm/ADT/PointerSumType.h --------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLVM_ADT_POINTERSUMTYPE_H #define LLVM_ADT_POINTERSUMTYPE_H #include "llvm/ADT/bit.h" #include "llvm/ADT/DenseMapInfo.h" #include "llvm/Support/PointerLikeTypeTraits.h" #include <cassert> #include <cstdint> #include <type_traits> namespace llvm { /// A compile time pair of an integer tag and the pointer-like type which it /// indexes within a sum type. Also allows the user to specify a particular /// traits class for pointer types with custom behavior such as over-aligned /// allocation. template <uintptr_t N, typename PointerArgT, typename TraitsArgT = PointerLikeTypeTraits<PointerArgT>> struct PointerSumTypeMember { enum { Tag = N }; using PointerT = PointerArgT; using TraitsT = TraitsArgT; }; namespace detail { template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper; } // end namespace detail /// A sum type over pointer-like types. /// /// This is a normal tagged union across pointer-like types that uses the low /// bits of the pointers to store the tag. /// /// Each member of the sum type is specified by passing a \c /// PointerSumTypeMember specialization in the variadic member argument list. /// This allows the user to control the particular tag value associated with /// a particular type, use the same type for multiple different tags, and /// customize the pointer-like traits used for a particular member. Note that /// these *must* be specializations of \c PointerSumTypeMember, no other type /// will suffice, even if it provides a compatible interface. /// /// This type implements all of the comparison operators and even hash table /// support by comparing the underlying storage of the pointer values. It /// doesn't support delegating to particular members for comparisons. /// /// It also default constructs to a zero tag with a null pointer, whatever that /// would be. This means that the zero value for the tag type is significant /// and may be desirable to set to a state that is particularly desirable to /// default construct. /// /// Having a supported zero-valued tag also enables getting the address of a /// pointer stored with that tag provided it is stored in its natural bit /// representation. This works because in the case of a zero-valued tag, the /// pointer's value is directly stored into this object and we can expose the /// address of that internal storage. This is especially useful when building an /// `ArrayRef` of a single pointer stored in a sum type. /// /// There is no support for constructing or accessing with a dynamic tag as /// that would fundamentally violate the type safety provided by the sum type. template <typename TagT, typename... MemberTs> class PointerSumType { using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>; // We keep both the raw value and the min tag value's pointer in a union. When // the minimum tag value is zero, this allows code below to cleanly expose the // address of the zero-tag pointer instead of just the zero-tag pointer // itself. This is especially useful when building `ArrayRef`s out of a single // pointer. However, we have to carefully access the union due to the active // member potentially changing. When we *store* a new value, we directly // access the union to allow us to store using the obvious types. However, // when we *read* a value, we copy the underlying storage out to avoid relying // on one member or the other being active. union StorageT { // Ensure we get a null default constructed value. We don't use a member // initializer because some compilers seem to not implement those correctly // for a union. StorageT() : Value(0) {} uintptr_t Value; typename HelperT::template Lookup<HelperT::MinTag>::PointerT MinTagPointer; }; StorageT Storage; public: constexpr PointerSumType() = default; /// A typed setter to a given tagged member of the sum type. template <TagT N> void set(typename HelperT::template Lookup<N>::PointerT Pointer) { void *V = HelperT::template Lookup<N>::TraitsT::getAsVoidPointer(Pointer); assert((reinterpret_cast<uintptr_t>(V) & HelperT::TagMask) == 0 && "Pointer is insufficiently aligned to store the discriminant!"); Storage.Value = reinterpret_cast<uintptr_t>(V) | N; } /// A typed constructor for a specific tagged member of the sum type. template <TagT N> static PointerSumType create(typename HelperT::template Lookup<N>::PointerT Pointer) { PointerSumType Result; Result.set<N>(Pointer); return Result; } /// Clear the value to null with the min tag type. void clear() { set<HelperT::MinTag>(nullptr); } TagT getTag() const { return static_cast<TagT>(getOpaqueValue() & HelperT::TagMask); } template <TagT N> bool is() const { return N == getTag(); } template <TagT N> typename HelperT::template Lookup<N>::PointerT get() const { void *P = is<N>() ? getVoidPtr() : nullptr; return HelperT::template Lookup<N>::TraitsT::getFromVoidPointer(P); } template <TagT N> typename HelperT::template Lookup<N>::PointerT cast() const { assert(is<N>() && "This instance has a different active member."); return HelperT::template Lookup<N>::TraitsT::getFromVoidPointer( getVoidPtr()); } /// If the tag is zero and the pointer's value isn't changed when being /// stored, get the address of the stored value type-punned to the zero-tag's /// pointer type. typename HelperT::template Lookup<HelperT::MinTag>::PointerT const * getAddrOfZeroTagPointer() const { return const_cast<PointerSumType *>(this)->getAddrOfZeroTagPointer(); } /// If the tag is zero and the pointer's value isn't changed when being /// stored, get the address of the stored value type-punned to the zero-tag's /// pointer type. typename HelperT::template Lookup<HelperT::MinTag>::PointerT * getAddrOfZeroTagPointer() { static_assert(HelperT::MinTag == 0, "Non-zero minimum tag value!"); assert(is<HelperT::MinTag>() && "The active tag is not zero!"); // Store the initial value of the pointer when read out of our storage. auto InitialPtr = get<HelperT::MinTag>(); // Now update the active member of the union to be the actual pointer-typed // member so that accessing it indirectly through the returned address is // valid. Storage.MinTagPointer = InitialPtr; // Finally, validate that this was a no-op as expected by reading it back // out using the same underlying-storage read as above. assert(InitialPtr == get<HelperT::MinTag>() && "Switching to typed storage changed the pointer returned!"); // Now we can correctly return an address to typed storage. return &Storage.MinTagPointer; } explicit operator bool() const { return getOpaqueValue() & HelperT::PointerMask; } bool operator==(const PointerSumType &R) const { return getOpaqueValue() == R.getOpaqueValue(); } bool operator!=(const PointerSumType &R) const { return getOpaqueValue() != R.getOpaqueValue(); } bool operator<(const PointerSumType &R) const { return getOpaqueValue() < R.getOpaqueValue(); } bool operator>(const PointerSumType &R) const { return getOpaqueValue() > R.getOpaqueValue(); } bool operator<=(const PointerSumType &R) const { return getOpaqueValue() <= R.getOpaqueValue(); } bool operator>=(const PointerSumType &R) const { return getOpaqueValue() >= R.getOpaqueValue(); } uintptr_t getOpaqueValue() const { // Read the underlying storage of the union, regardless of the active // member. return bit_cast<uintptr_t>(Storage); } protected: void *getVoidPtr() const { return reinterpret_cast<void *>(getOpaqueValue() & HelperT::PointerMask); } }; namespace detail { /// A helper template for implementing \c PointerSumType. It provides fast /// compile-time lookup of the member from a particular tag value, along with /// useful constants and compile time checking infrastructure.. template <typename TagT, typename... MemberTs> struct PointerSumTypeHelper : MemberTs... { // First we use a trick to allow quickly looking up information about // a particular member of the sum type. This works because we arranged to // have this type derive from all of the member type templates. We can select // the matching member for a tag using type deduction during overload // resolution. template <TagT N, typename PointerT, typename TraitsT> static PointerSumTypeMember<N, PointerT, TraitsT> LookupOverload(PointerSumTypeMember<N, PointerT, TraitsT> *); template <TagT N> static void LookupOverload(...); template <TagT N> struct Lookup { // Compute a particular member type by resolving the lookup helper overload. using MemberT = decltype( LookupOverload<N>(static_cast<PointerSumTypeHelper *>(nullptr))); /// The Nth member's pointer type. using PointerT = typename MemberT::PointerT; /// The Nth member's traits type. using TraitsT = typename MemberT::TraitsT; }; // Next we need to compute the number of bits available for the discriminant // by taking the min of the bits available for each member. Much of this // would be amazingly easier with good constexpr support. template <uintptr_t V, uintptr_t... Vs> struct Min : std::integral_constant< uintptr_t, (V < Min<Vs...>::value ? V : Min<Vs...>::value)> { }; template <uintptr_t V> struct Min<V> : std::integral_constant<uintptr_t, V> {}; enum { NumTagBits = Min<MemberTs::TraitsT::NumLowBitsAvailable...>::value }; // Also compute the smallest discriminant and various masks for convenience. constexpr static TagT MinTag = static_cast<TagT>(Min<MemberTs::Tag...>::value); enum : uint64_t { PointerMask = static_cast<uint64_t>(-1) << NumTagBits, TagMask = ~PointerMask }; // Finally we need a recursive template to do static checks of each // member. template <typename MemberT, typename... InnerMemberTs> struct Checker : Checker<InnerMemberTs...> { static_assert(MemberT::Tag < (1 << NumTagBits), "This discriminant value requires too many bits!"); }; template <typename MemberT> struct Checker<MemberT> : std::true_type { static_assert(MemberT::Tag < (1 << NumTagBits), "This discriminant value requires too many bits!"); }; static_assert(Checker<MemberTs...>::value, "Each member must pass the checker."); }; } // end namespace detail // Teach DenseMap how to use PointerSumTypes as keys. template <typename TagT, typename... MemberTs> struct DenseMapInfo<PointerSumType<TagT, MemberTs...>> { using SumType = PointerSumType<TagT, MemberTs...>; using HelperT = detail::PointerSumTypeHelper<TagT, MemberTs...>; enum { SomeTag = HelperT::MinTag }; using SomePointerT = typename HelperT::template Lookup<HelperT::MinTag>::PointerT; using SomePointerInfo = DenseMapInfo<SomePointerT>; static inline SumType getEmptyKey() { - return SumType::create<SomeTag>(SomePointerInfo::getEmptyKey()); + return SumType::template create<SomeTag>(SomePointerInfo::getEmptyKey()); } static inline SumType getTombstoneKey() { - return SumType::create<SomeTag>(SomePointerInfo::getTombstoneKey()); + return SumType::template create<SomeTag>( + SomePointerInfo::getTombstoneKey()); } static unsigned getHashValue(const SumType &Arg) { uintptr_t OpaqueValue = Arg.getOpaqueValue(); return DenseMapInfo<uintptr_t>::getHashValue(OpaqueValue); } static bool isEqual(const SumType &LHS, const SumType &RHS) { return LHS == RHS; } }; } // end namespace llvm #endif // LLVM_ADT_POINTERSUMTYPE_H
clang-format: please reformat the code