This is (more?) usable by GDB pretty printers and seems nicer to write.
There's one tricky caveat that in C++14 (LLVM's codebase today) the
static constexpr member declaration is not a definition - so odr use of
this constant requires an out of line definition, which won't be
provided (that'd make all these trait classes more annoyidng/expensive
to maintain). But the use of this constant in the library implementation
is/should always be in a non-odr context - only two unit tests needed to
be touched to cope with this/avoid odr using these constants.
Based on/expanded from D72590 by Christian Sigg.
}
// qualifier information is encoded in the low bits.
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
} // namespace llvm
return clang::DeclGroupRef::getFromOpaquePtr(P);
}
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
} // namespace llvm
static void *getAsVoidPointer(Ptr P) { return P.getOpaqueValue(); }
static Ptr getFromVoidPointer(void *P) { return Ptr::getFromOpaqueValue(P); }
- enum {
- NumLowBitsAvailable = PointerLikeTypeTraits<T>::NumLowBitsAvailable - 1
- };
+ static constexpr int NumLowBitsAvailable =
+ PointerLikeTypeTraits<T>::NumLowBitsAvailable - 1;
};
} // namespace llvm
}
// No bits are available!
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
} // namespace llvm.
return static_cast< ::clang::Type*>(P);
}
- enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
+ static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};
template<>
return static_cast< ::clang::ExtQuals*>(P);
}
- enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
+ static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};
} // namespace llvm
}
// Various qualifiers go in low bits.
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
} // namespace llvm
return clang::Selector(reinterpret_cast<uintptr_t>(P));
}
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
// Provide PointerLikeTypeTraits for IdentifierInfo pointers, which
return static_cast<clang::IdentifierInfo*>(P);
}
- enum { NumLowBitsAvailable = 1 };
+ static constexpr int NumLowBitsAvailable = 1;
};
template<>
return static_cast<const clang::IdentifierInfo*>(P);
}
- enum { NumLowBitsAvailable = 1 };
+ static constexpr int NumLowBitsAvailable = 1;
};
} // namespace llvm
// Teach SmallPtrSet how to handle SourceLocation.
template<>
struct PointerLikeTypeTraits<clang::SourceLocation> {
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
static void *getAsVoidPointer(clang::SourceLocation L) {
return L.getPtrEncoding();
static inline void *getAsVoidPointer(T p) { return p; }
static inline T getFromVoidPointer(void *p) {return static_cast<T>(p);}
- enum { NumLowBitsAvailable = 2 };
+ static constexpr int NumLowBitsAvailable = 2;
};
}
result.Data = PairTy::getFromOpaqueValue(value);
return result;
}
- enum {
- NumLowBitsAvailable =
- llvm::PointerLikeTypeTraits<PairTy>::NumLowBitsAvailable
- };
+ static constexpr int NumLowBitsAvailable =
+ llvm::PointerLikeTypeTraits<PairTy>::NumLowBitsAvailable;
};
} // end namespace CodeGen
static inline T getFromVoidPointer(void *p) {
return T::getFromOpaqueValue(p);
}
- enum { NumLowBitsAvailable = T::NumLowBitsAvailable };
+ static constexpr int NumLowBitsAvailable = T::NumLowBitsAvailable;
};
} // end namespace llvm
template <class T>
struct PointerLikeTypeTraits<clang::OpaquePtr<T>> {
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
// FIXME: Doesn't work? return P.getAs< void >();
struct CacheAlignedPointerTraits {
static inline void *getAsVoidPointer(void *P) { return P; }
static inline void *getFromVoidPointer(void *P) { return P; }
- enum { NumLowBitsAvailable = Log2CacheLine };
+ static constexpr int NumLowBitsAvailable = Log2CacheLine;
};
PointerIntPair<void*, Log2CacheLine, unsigned, CacheAlignedPointerTraits> pip;
return T(reinterpret_cast<uintptr_t>(P), typename T::RawValueTag());
}
- enum { NumLowBitsAvailable = T::Shift };
+ static constexpr int NumLowBitsAvailable = T::Shift;
};
// Teach DenseMap how to use PointerEmbeddedInt objects as keys if the Int type
return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
}
- enum { NumLowBitsAvailable = PtrTraits::NumLowBitsAvailable - IntBits };
+ static constexpr int NumLowBitsAvailable =
+ PtrTraits::NumLowBitsAvailable - IntBits;
};
} // end namespace llvm
return (User *)P;
}
- enum { NumLowBitsAvailable = 1 };
+ static constexpr int NumLowBitsAvailable = 1;
};
// A type for the word following an array of hung-off Uses in memory, which is
return (Use **)P;
}
- enum { NumLowBitsAvailable = 2 };
+ static constexpr int NumLowBitsAvailable = 2;
};
private:
static inline void *getAsVoidPointer(T *P) { return P; }
static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
- enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
+ static constexpr int NumLowBitsAvailable =
+ detail::ConstantLog2<alignof(T)>::value;
};
template <> struct PointerLikeTypeTraits<void *> {
///
/// All clients should use assertions to do a run-time check to ensure that
/// this is actually true.
- enum { NumLowBitsAvailable = 2 };
+ static constexpr int NumLowBitsAvailable = 2;
};
// Provide PointerLikeTypeTraits for const things.
static inline const T getFromVoidPointer(const void *P) {
return NonConst::getFromVoidPointer(const_cast<void *>(P));
}
- enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+ static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
};
// Provide PointerLikeTypeTraits for const pointers.
static inline const T *getFromVoidPointer(const void *P) {
return NonConst::getFromVoidPointer(const_cast<void *>(P));
}
- enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+ static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
};
// Provide PointerLikeTypeTraits for uintptr_t.
return reinterpret_cast<uintptr_t>(P);
}
// No bits are available!
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
/// Provide suitable custom traits struct for function pointers.
/// potentially use alignment attributes on functions to satisfy that.
template <int Alignment, typename FunctionPointerT>
struct FunctionPointerLikeTypeTraits {
- enum { NumLowBitsAvailable = detail::ConstantLog2<Alignment>::value };
+ static constexpr int NumLowBitsAvailable =
+ detail::ConstantLog2<Alignment>::value;
static inline void *getAsVoidPointer(FunctionPointerT P) {
assert((reinterpret_cast<uintptr_t>(P) &
~((uintptr_t)-1 << NumLowBitsAvailable)) == 0 &&
static inline AlignedMap *getFromVoidPointer(void *P) {
return (AlignedMap *)P;
}
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
static_assert(alignof(AlignedMap) >= (1 << NumLowBitsAvailable),
"AlignedMap insufficiently aligned to have enough low bits.");
};
EXPECT_EQ(42, I);
EXPECT_EQ(43, I + 1);
- EXPECT_EQ(sizeof(uintptr_t) * CHAR_BIT - CHAR_BIT,
- PointerLikeTypeTraits<decltype(I)>::NumLowBitsAvailable);
+ EXPECT_EQ((int)sizeof(uintptr_t) * CHAR_BIT - CHAR_BIT,
+ (int)PointerLikeTypeTraits<decltype(I)>::NumLowBitsAvailable);
EXPECT_FALSE(I == J);
EXPECT_TRUE(I != J);
EXPECT_EQ(0U, Pair.getInt());
}
+// In real code this would be a word-sized integer limited to 31 bits.
+struct Fixnum31 {
+ uintptr_t Value;
+};
+struct FixnumPointerTraits {
+ static inline void *getAsVoidPointer(Fixnum31 Num) {
+ return reinterpret_cast<void *>(Num.Value << NumLowBitsAvailable);
+ }
+ static inline Fixnum31 getFromVoidPointer(void *P) {
+ // In real code this would assert that the value is in range.
+ return {reinterpret_cast<uintptr_t>(P) >> NumLowBitsAvailable};
+ }
+ static constexpr int NumLowBitsAvailable =
+ std::numeric_limits<uintptr_t>::digits - 31;
+};
TEST(PointerIntPairTest, ManyUnusedBits) {
- // In real code this would be a word-sized integer limited to 31 bits.
- struct Fixnum31 {
- uintptr_t Value;
- };
- class FixnumPointerTraits {
- public:
- static inline void *getAsVoidPointer(Fixnum31 Num) {
- return reinterpret_cast<void *>(Num.Value << NumLowBitsAvailable);
- }
- static inline Fixnum31 getFromVoidPointer(void *P) {
- // In real code this would assert that the value is in range.
- return { reinterpret_cast<uintptr_t>(P) >> NumLowBitsAvailable };
- }
- enum { NumLowBitsAvailable = std::numeric_limits<uintptr_t>::digits - 31 };
- };
PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits> pair;
EXPECT_EQ((uintptr_t)0, pair.getPointer().Value);
EXPECT_TRUE(pair.getInt());
EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
- PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
+ (int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
static_assert(
is_trivially_copyable<
}
// Note: We could steal more bits if the need arises.
- enum { NumLowBitsAvailable = 1 };
+ static constexpr int NumLowBitsAvailable = 1;
};
/// Pair of raw pointer and a boolean flag of whether the pointer holds a splat,
static inline mlir::Attribute getFromVoidPointer(void *ptr) {
return mlir::Attribute::getFromOpaquePointer(ptr);
}
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
};
template <>
static inline mlir::FuncOp getFromVoidPointer(void *P) {
return mlir::FuncOp::getFromOpaquePointer(P);
}
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
};
} // namespace llvm
static inline mlir::Identifier getFromVoidPointer(void *P) {
return mlir::Identifier::getFromOpaquePointer(P);
}
- enum { NumLowBitsAvailable = 2 };
+ static constexpr int NumLowBitsAvailable = 2;
};
} // end namespace llvm
static inline mlir::Location getFromVoidPointer(void *P) {
return mlir::Location::getFromOpaquePointer(P);
}
- enum {
- NumLowBitsAvailable =
- PointerLikeTypeTraits<mlir::Attribute>::NumLowBitsAvailable
- };
+ static constexpr int NumLowBitsAvailable =
+ PointerLikeTypeTraits<mlir::Attribute>::NumLowBitsAvailable;
};
} // namespace llvm
static inline mlir::ModuleOp getFromVoidPointer(void *P) {
return mlir::ModuleOp::getFromOpaquePointer(P);
}
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
};
} // end namespace llvm
static inline mlir::OperationName getFromVoidPointer(void *P) {
return mlir::OperationName::getFromOpaquePointer(P);
}
- enum {
- NumLowBitsAvailable = PointerLikeTypeTraits<
- mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable
- };
+ static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
+ mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable;
};
} // end namespace llvm
static inline mlir::Type getFromVoidPointer(void *P) {
return mlir::Type::getFromOpaquePointer(P);
}
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
};
} // namespace llvm
struct ImplTypeTraits : public llvm::PointerLikeTypeTraits<void *> {
// We know that all pointers within the ImplType are aligned by 8-bytes,
// meaning that we can steal up to 3 bits for the different values.
- enum { NumLowBitsAvailable = 3 };
+ static constexpr int NumLowBitsAvailable = 3;
};
using ImplType = llvm::PointerIntPair<void *, 2, Kind, ImplTypeTraits>;
static inline const Region *getFromVoidPointer(void *P) {
return (Region *)P;
}
- enum { NumLowBitsAvailable = 0 };
+ static constexpr int NumLowBitsAvailable = 0;
};
} // namespace llvm
projects / platform / upstream / llvm.git / commitdiff