-//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines DenseMapInfo traits for DenseMap.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_ADT_DENSEMAPINFO_H
-#define LLVM_ADT_DENSEMAPINFO_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/PointerLikeTypeTraits.h"
-#include "llvm/Support/type_traits.h"
-
-namespace llvm {
-
-template<typename T>
-struct DenseMapInfo {
- //static inline T getEmptyKey();
- //static inline T getTombstoneKey();
- //static unsigned getHashValue(const T &Val);
- //static bool isEqual(const T &LHS, const T &RHS);
-};
-
-// Provide DenseMapInfo for all pointers.
-template<typename T>
-struct DenseMapInfo<T*> {
- static inline T* getEmptyKey() {
- uintptr_t Val = static_cast<uintptr_t>(-1);
- Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
- return reinterpret_cast<T*>(Val);
- }
- static inline T* getTombstoneKey() {
- uintptr_t Val = static_cast<uintptr_t>(-2);
- Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
- return reinterpret_cast<T*>(Val);
- }
- static unsigned getHashValue(const T *PtrVal) {
- return (unsigned((uintptr_t)PtrVal) >> 4) ^
- (unsigned((uintptr_t)PtrVal) >> 9);
- }
- static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
-};
-
-// Provide DenseMapInfo for chars.
-template<> struct DenseMapInfo<char> {
- static inline char getEmptyKey() { return ~0; }
- static inline char getTombstoneKey() { return ~0 - 1; }
- static unsigned getHashValue(const char& Val) { return Val * 37U; }
- static bool isEqual(const char &LHS, const char &RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for unsigned ints.
-template<> struct DenseMapInfo<unsigned> {
- static inline unsigned getEmptyKey() { return ~0U; }
- static inline unsigned getTombstoneKey() { return ~0U - 1; }
- static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
- static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for unsigned longs.
-template<> struct DenseMapInfo<unsigned long> {
- static inline unsigned long getEmptyKey() { return ~0UL; }
- static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }
- static unsigned getHashValue(const unsigned long& Val) {
- return (unsigned)(Val * 37UL);
- }
- static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for unsigned long longs.
-template<> struct DenseMapInfo<unsigned long long> {
- static inline unsigned long long getEmptyKey() { return ~0ULL; }
- static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }
- static unsigned getHashValue(const unsigned long long& Val) {
- return (unsigned)(Val * 37ULL);
- }
- static bool isEqual(const unsigned long long& LHS,
- const unsigned long long& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for ints.
-template<> struct DenseMapInfo<int> {
- static inline int getEmptyKey() { return 0x7fffffff; }
- static inline int getTombstoneKey() { return -0x7fffffff - 1; }
- static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }
- static bool isEqual(const int& LHS, const int& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for longs.
-template<> struct DenseMapInfo<long> {
- static inline long getEmptyKey() {
- return (1UL << (sizeof(long) * 8 - 1)) - 1UL;
- }
- static inline long getTombstoneKey() { return getEmptyKey() - 1L; }
- static unsigned getHashValue(const long& Val) {
- return (unsigned)(Val * 37UL);
- }
- static bool isEqual(const long& LHS, const long& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for long longs.
-template<> struct DenseMapInfo<long long> {
- static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }
- static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }
- static unsigned getHashValue(const long long& Val) {
- return (unsigned)(Val * 37ULL);
- }
- static bool isEqual(const long long& LHS,
- const long long& RHS) {
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for all pairs whose members have info.
-template<typename T, typename U>
-struct DenseMapInfo<std::pair<T, U> > {
- typedef std::pair<T, U> Pair;
- typedef DenseMapInfo<T> FirstInfo;
- typedef DenseMapInfo<U> SecondInfo;
-
- static inline Pair getEmptyKey() {
- return std::make_pair(FirstInfo::getEmptyKey(),
- SecondInfo::getEmptyKey());
- }
- static inline Pair getTombstoneKey() {
- return std::make_pair(FirstInfo::getTombstoneKey(),
- SecondInfo::getTombstoneKey());
- }
- static unsigned getHashValue(const Pair& PairVal) {
- uint64_t key = (uint64_t)FirstInfo::getHashValue(PairVal.first) << 32
- | (uint64_t)SecondInfo::getHashValue(PairVal.second);
- key += ~(key << 32);
- key ^= (key >> 22);
- key += ~(key << 13);
- key ^= (key >> 8);
- key += (key << 3);
- key ^= (key >> 15);
- key += ~(key << 27);
- key ^= (key >> 31);
- return (unsigned)key;
- }
- static bool isEqual(const Pair &LHS, const Pair &RHS) {
- return FirstInfo::isEqual(LHS.first, RHS.first) &&
- SecondInfo::isEqual(LHS.second, RHS.second);
- }
-};
-
-// Provide DenseMapInfo for StringRefs.
-template <> struct DenseMapInfo<StringRef> {
- static inline StringRef getEmptyKey() {
- return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)),
- 0);
- }
- static inline StringRef getTombstoneKey() {
- return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)),
- 0);
- }
- static unsigned getHashValue(StringRef Val) {
- assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
- assert(Val.data() != getTombstoneKey().data() &&
- "Cannot hash the tombstone key!");
- return (unsigned)(hash_value(Val));
- }
- static bool isEqual(StringRef LHS, StringRef RHS) {
- if (RHS.data() == getEmptyKey().data())
- return LHS.data() == getEmptyKey().data();
- if (RHS.data() == getTombstoneKey().data())
- return LHS.data() == getTombstoneKey().data();
- return LHS == RHS;
- }
-};
-
-// Provide DenseMapInfo for ArrayRefs.
-template <typename T> struct DenseMapInfo<ArrayRef<T>> {
- static inline ArrayRef<T> getEmptyKey() {
- return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)),
- size_t(0));
- }
- static inline ArrayRef<T> getTombstoneKey() {
- return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)),
- size_t(0));
- }
- static unsigned getHashValue(ArrayRef<T> Val) {
- assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");
- assert(Val.data() != getTombstoneKey().data() &&
- "Cannot hash the tombstone key!");
- return (unsigned)(hash_value(Val));
- }
- static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) {
- if (RHS.data() == getEmptyKey().data())
- return LHS.data() == getEmptyKey().data();
- if (RHS.data() == getTombstoneKey().data())
- return LHS.data() == getTombstoneKey().data();
- return LHS == RHS;
- }
-};
-
-} // end namespace llvm
-
-#endif
+//===- llvm/ADT/DenseMapInfo.h - Type traits for DenseMap -------*- C++ -*-===//\r
+//\r
+// The LLVM Compiler Infrastructure\r
+//\r
+// This file is distributed under the University of Illinois Open Source\r
+// License. See LICENSE.TXT for details.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+//\r
+// This file defines DenseMapInfo traits for DenseMap.\r
+//\r
+//===----------------------------------------------------------------------===//\r
+\r
+#ifndef LLVM_ADT_DENSEMAPINFO_H\r
+#define LLVM_ADT_DENSEMAPINFO_H\r
+\r
+#include "llvm/ADT/ArrayRef.h"\r
+#include "llvm/ADT/Hashing.h"\r
+#include "llvm/ADT/StringRef.h"\r
+#include "llvm/Support/PointerLikeTypeTraits.h"\r
+#include "llvm/Support/type_traits.h"\r
+\r
+namespace llvm {\r
+\r
+template<typename T>\r
+struct DenseMapInfo {\r
+ //static inline T getEmptyKey();\r
+ //static inline T getTombstoneKey();\r
+ //static unsigned getHashValue(const T &Val);\r
+ //static bool isEqual(const T &LHS, const T &RHS);\r
+};\r
+\r
+// Provide DenseMapInfo for all pointers.\r
+template<typename T>\r
+struct DenseMapInfo<T*> {\r
+ static inline T* getEmptyKey() {\r
+ uintptr_t Val = static_cast<uintptr_t>(-1);\r
+ Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;\r
+ return reinterpret_cast<T*>(Val);\r
+ }\r
+ static inline T* getTombstoneKey() {\r
+ uintptr_t Val = static_cast<uintptr_t>(-2);\r
+ Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;\r
+ return reinterpret_cast<T*>(Val);\r
+ }\r
+ static unsigned getHashValue(const T *PtrVal) {\r
+ return (unsigned((uintptr_t)PtrVal) >> 4) ^\r
+ (unsigned((uintptr_t)PtrVal) >> 9);\r
+ }\r
+ static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }\r
+};\r
+\r
+// Provide DenseMapInfo for chars.\r
+template<> struct DenseMapInfo<char> {\r
+ static inline char getEmptyKey() { return ~0; }\r
+ static inline char getTombstoneKey() { return ~0 - 1; }\r
+ static unsigned getHashValue(const char& Val) { return Val * 37U; }\r
+ static bool isEqual(const char &LHS, const char &RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for unsigned ints.\r
+template<> struct DenseMapInfo<unsigned> {\r
+ static inline unsigned getEmptyKey() { return ~0U; }\r
+ static inline unsigned getTombstoneKey() { return ~0U - 1; }\r
+ static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }\r
+ static bool isEqual(const unsigned& LHS, const unsigned& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for unsigned longs.\r
+template<> struct DenseMapInfo<unsigned long> {\r
+ static inline unsigned long getEmptyKey() { return ~0UL; }\r
+ static inline unsigned long getTombstoneKey() { return ~0UL - 1L; }\r
+ static unsigned getHashValue(const unsigned long& Val) {\r
+ return (unsigned)(Val * 37UL);\r
+ }\r
+ static bool isEqual(const unsigned long& LHS, const unsigned long& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for unsigned long longs.\r
+template<> struct DenseMapInfo<unsigned long long> {\r
+ static inline unsigned long long getEmptyKey() { return ~0ULL; }\r
+ static inline unsigned long long getTombstoneKey() { return ~0ULL - 1ULL; }\r
+ static unsigned getHashValue(const unsigned long long& Val) {\r
+ return (unsigned)(Val * 37ULL);\r
+ }\r
+ static bool isEqual(const unsigned long long& LHS,\r
+ const unsigned long long& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for ints.\r
+template<> struct DenseMapInfo<int> {\r
+ static inline int getEmptyKey() { return 0x7fffffff; }\r
+ static inline int getTombstoneKey() { return -0x7fffffff - 1; }\r
+ static unsigned getHashValue(const int& Val) { return (unsigned)(Val * 37U); }\r
+ static bool isEqual(const int& LHS, const int& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for longs.\r
+template<> struct DenseMapInfo<long> {\r
+ static inline long getEmptyKey() {\r
+ return (1UL << (sizeof(long) * 8 - 1)) - 1UL;\r
+ }\r
+ static inline long getTombstoneKey() { return getEmptyKey() - 1L; }\r
+ static unsigned getHashValue(const long& Val) {\r
+ return (unsigned)(Val * 37UL);\r
+ }\r
+ static bool isEqual(const long& LHS, const long& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for long longs.\r
+template<> struct DenseMapInfo<long long> {\r
+ static inline long long getEmptyKey() { return 0x7fffffffffffffffLL; }\r
+ static inline long long getTombstoneKey() { return -0x7fffffffffffffffLL-1; }\r
+ static unsigned getHashValue(const long long& Val) {\r
+ return (unsigned)(Val * 37ULL);\r
+ }\r
+ static bool isEqual(const long long& LHS,\r
+ const long long& RHS) {\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for all pairs whose members have info.\r
+template<typename T, typename U>\r
+struct DenseMapInfo<std::pair<T, U> > {\r
+ typedef std::pair<T, U> Pair;\r
+ typedef DenseMapInfo<T> FirstInfo;\r
+ typedef DenseMapInfo<U> SecondInfo;\r
+\r
+ static inline Pair getEmptyKey() {\r
+ return std::make_pair(FirstInfo::getEmptyKey(),\r
+ SecondInfo::getEmptyKey());\r
+ }\r
+ static inline Pair getTombstoneKey() {\r
+ return std::make_pair(FirstInfo::getTombstoneKey(),\r
+ SecondInfo::getTombstoneKey());\r
+ }\r
+ static unsigned getHashValue(const Pair& PairVal) {\r
+ uint64_t key = (uint64_t)FirstInfo::getHashValue(PairVal.first) << 32\r
+ | (uint64_t)SecondInfo::getHashValue(PairVal.second);\r
+ key += ~(key << 32);\r
+ key ^= (key >> 22);\r
+ key += ~(key << 13);\r
+ key ^= (key >> 8);\r
+ key += (key << 3);\r
+ key ^= (key >> 15);\r
+ key += ~(key << 27);\r
+ key ^= (key >> 31);\r
+ return (unsigned)key;\r
+ }\r
+ static bool isEqual(const Pair &LHS, const Pair &RHS) {\r
+ return FirstInfo::isEqual(LHS.first, RHS.first) &&\r
+ SecondInfo::isEqual(LHS.second, RHS.second);\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for StringRefs.\r
+template <> struct DenseMapInfo<StringRef> {\r
+ static inline StringRef getEmptyKey() {\r
+ return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(0)),\r
+ 0);\r
+ }\r
+ static inline StringRef getTombstoneKey() {\r
+ return StringRef(reinterpret_cast<const char *>(~static_cast<uintptr_t>(1)),\r
+ 0);\r
+ }\r
+ static unsigned getHashValue(StringRef Val) {\r
+ assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");\r
+ assert(Val.data() != getTombstoneKey().data() &&\r
+ "Cannot hash the tombstone key!");\r
+ return (unsigned)(hash_value(Val));\r
+ }\r
+ static bool isEqual(StringRef LHS, StringRef RHS) {\r
+ if (RHS.data() == getEmptyKey().data())\r
+ return LHS.data() == getEmptyKey().data();\r
+ if (RHS.data() == getTombstoneKey().data())\r
+ return LHS.data() == getTombstoneKey().data();\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+// Provide DenseMapInfo for ArrayRefs.\r
+template <typename T> struct DenseMapInfo<ArrayRef<T>> {\r
+ static inline ArrayRef<T> getEmptyKey() {\r
+ return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(0)),\r
+ size_t(0));\r
+ }\r
+ static inline ArrayRef<T> getTombstoneKey() {\r
+ return ArrayRef<T>(reinterpret_cast<const T *>(~static_cast<uintptr_t>(1)),\r
+ size_t(0));\r
+ }\r
+ static unsigned getHashValue(ArrayRef<T> Val) {\r
+ assert(Val.data() != getEmptyKey().data() && "Cannot hash the empty key!");\r
+ assert(Val.data() != getTombstoneKey().data() &&\r
+ "Cannot hash the tombstone key!");\r
+ return (unsigned)(hash_value(Val));\r
+ }\r
+ static bool isEqual(ArrayRef<T> LHS, ArrayRef<T> RHS) {\r
+ if (RHS.data() == getEmptyKey().data())\r
+ return LHS.data() == getEmptyKey().data();\r
+ if (RHS.data() == getTombstoneKey().data())\r
+ return LHS.data() == getTombstoneKey().data();\r
+ return LHS == RHS;\r
+ }\r
+};\r
+\r
+} // end namespace llvm\r
+\r
+#endif\r
OSDN Git Service
