1 //===- llvm/ADT/PointerEmbeddedInt.h ----------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_ADT_POINTEREMBEDDEDINT_H
11 #define LLVM_ADT_POINTEREMBEDDEDINT_H
13 #include "llvm/ADT/DenseMapInfo.h"
14 #include "llvm/Support/MathExtras.h"
15 #include "llvm/Support/PointerLikeTypeTraits.h"
19 #include <type_traits>
23 /// Utility to embed an integer into a pointer-like type. This is specifically
24 /// intended to allow embedding integers where fewer bits are required than
25 /// exist in a pointer, and the integer can participate in abstractions along
26 /// side other pointer-like types. For example it can be placed into a \c
27 /// PointerSumType or \c PointerUnion.
29 /// Note that much like pointers, an integer value of zero has special utility
30 /// due to boolean conversions. For example, a non-null value can be tested for
31 /// in the above abstractions without testing the particular active member.
32 /// Also, the default constructed value zero initializes the integer.
33 template <typename IntT, int Bits = sizeof(IntT) * CHAR_BIT>
34 class PointerEmbeddedInt {
37 // Note: This '<' is correct; using '<=' would result in some shifts
38 // overflowing their storage types.
39 static_assert(Bits < sizeof(uintptr_t) * CHAR_BIT,
40 "Cannot embed more bits than we have in a pointer!");
43 // We shift as many zeros into the value as we can while preserving the
44 // number of bits desired for the integer.
45 Shift = sizeof(uintptr_t) * CHAR_BIT - Bits,
47 // We also want to be able to mask out the preserved bits for asserts.
48 Mask = static_cast<uintptr_t>(-1) << Bits
52 explicit RawValueTag() = default;
55 friend struct PointerLikeTypeTraits<PointerEmbeddedInt>;
57 explicit PointerEmbeddedInt(uintptr_t Value, RawValueTag) : Value(Value) {}
60 PointerEmbeddedInt() = default;
62 PointerEmbeddedInt(IntT I) { *this = I; }
64 PointerEmbeddedInt &operator=(IntT I) {
65 assert((std::is_signed<IntT>::value ? isInt<Bits>(I) : isUInt<Bits>(I)) &&
66 "Integer has bits outside those preserved!");
67 Value = static_cast<uintptr_t>(I) << Shift;
71 // Note that this implicit conversion additionally allows all of the basic
72 // comparison operators to work transparently, etc.
73 operator IntT() const {
74 if (std::is_signed<IntT>::value)
75 return static_cast<IntT>(static_cast<intptr_t>(Value) >> Shift);
76 return static_cast<IntT>(Value >> Shift);
80 // Provide pointer like traits to support use with pointer unions and sum
82 template <typename IntT, int Bits>
83 struct PointerLikeTypeTraits<PointerEmbeddedInt<IntT, Bits>> {
84 using T = PointerEmbeddedInt<IntT, Bits>;
86 static inline void *getAsVoidPointer(const T &P) {
87 return reinterpret_cast<void *>(P.Value);
90 static inline T getFromVoidPointer(void *P) {
91 return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
94 static inline T getFromVoidPointer(const void *P) {
95 return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
98 enum { NumLowBitsAvailable = T::Shift };
101 // Teach DenseMap how to use PointerEmbeddedInt objects as keys if the Int type
102 // itself can be a key.
103 template <typename IntT, int Bits>
104 struct DenseMapInfo<PointerEmbeddedInt<IntT, Bits>> {
105 using T = PointerEmbeddedInt<IntT, Bits>;
106 using IntInfo = DenseMapInfo<IntT>;
108 static inline T getEmptyKey() { return IntInfo::getEmptyKey(); }
109 static inline T getTombstoneKey() { return IntInfo::getTombstoneKey(); }
111 static unsigned getHashValue(const T &Arg) {
112 return IntInfo::getHashValue(Arg);
115 static bool isEqual(const T &LHS, const T &RHS) { return LHS == RHS; }
118 } // end namespace llvm
120 #endif // LLVM_ADT_POINTEREMBEDDEDINT_H