rename PointerLikeTypeInto to PointerLikeTypeTraits, add trait for

# low bits free, and move to its own header.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@67973 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 67 insertions, 29 deletions

diff --git a/include/llvm/ADT/PointerIntPair.h b/include/llvm/ADT/PointerIntPair.h
index 92259298ef..7b3283c96d 100644
--- a/include/llvm/ADT/PointerIntPair.h
+++ b/include/llvm/ADT/PointerIntPair.h
@@ -22,7 +22,7 @@ namespace llvm {
 template<typename T>
 struct DenseMapInfo;
 template<typename>
-class PointerLikeTypeInfo;
+class PointerLikeTypeTraits;
 
 /// PointerIntPair - This class implements a pair of a pointer and small
 /// integer.  It is designed to represent this in the space required by one
@@ -97,7 +97,7 @@ struct DenseMapInfo<PointerIntPair<PointerTy, IntBits, IntType> > {
 
 // Teach SmallPtrSet that PointerIntPair is "basically a pointer".
 template<typename PointerTy, unsigned IntBits, typename IntType>
-class PointerLikeTypeInfo<PointerIntPair<PointerTy, IntBits, IntType> > {
+class PointerLikeTypeTraits<PointerIntPair<PointerTy, IntBits, IntType> > {
 public:
   static inline void *
   getAsVoidPointer(const PointerIntPair<PointerTy, IntBits, IntType> &P) {
@@ -107,6 +107,7 @@ public:
   getFromVoidPointer(void *P) {
     return PointerIntPair<PointerTy, IntBits, IntType>::getFromOpaqueValue(P);
   }
+  static inline unsigned getNumLowBitsAvailable() { return 0; }
 };
 
 } // end namespace llvm
diff --git a/include/llvm/ADT/SmallPtrSet.h b/include/llvm/ADT/SmallPtrSet.h
index 47af22884d..a189de2c22 100644
--- a/include/llvm/ADT/SmallPtrSet.h
+++ b/include/llvm/ADT/SmallPtrSet.h
@@ -18,33 +18,9 @@
 #include <cassert>
 #include <cstring>
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
 
 namespace llvm {
-  
-/// PointerLikeTypeInfo - This is a traits object that is used to handle pointer
-/// types and things that are just wrappers for pointers as a uniform entity.
-template <typename T>
-class PointerLikeTypeInfo {
-  //getAsVoidPointer/getFromVoidPointer
-};
-
-// Provide PointerLikeTypeInfo for all pointers.
-template<typename T>
-class PointerLikeTypeInfo<T*> {
-public:
-  static inline void *getAsVoidPointer(T* P) { return P; }
-  static inline T *getFromVoidPointer(void *P) {
-    return static_cast<T*>(P);
-  }
-};
-template<typename T>
-class PointerLikeTypeInfo<const T*> {
-public:
-  static inline const void *getAsVoidPointer(const T* P) { return P; }
-  static inline const T *getFromVoidPointer(const void *P) {
-    return static_cast<const T*>(P);
-  }
-};
 
 class SmallPtrSetIteratorImpl;
 
@@ -193,7 +169,7 @@ protected:
 /// SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
 template<typename PtrTy>
 class SmallPtrSetIterator : public SmallPtrSetIteratorImpl {
-  typedef PointerLikeTypeInfo<PtrTy> PtrTraits;
+  typedef PointerLikeTypeTraits<PtrTy> PtrTraits;
 public:
   explicit SmallPtrSetIterator(const void *const *BP)
     : SmallPtrSetIteratorImpl(BP) {}
@@ -250,7 +226,7 @@ class SmallPtrSet : public SmallPtrSetImpl {
   // Make sure that SmallSize is a power of two, round up if not.
   enum { SmallSizePowTwo = NextPowerOfTwo<SmallSize>::Val };
   void *SmallArray[SmallSizePowTwo];
-  typedef PointerLikeTypeInfo<PtrType> PtrTraits;
+  typedef PointerLikeTypeTraits<PtrType> PtrTraits;
 public:
   SmallPtrSet() : SmallPtrSetImpl(NextPowerOfTwo<SmallSizePowTwo>::Val) {}
   SmallPtrSet(const SmallPtrSet &that) : SmallPtrSetImpl(that) {}
diff --git a/include/llvm/Support/PointerLikeTypeTraits.h b/include/llvm/Support/PointerLikeTypeTraits.h
new file mode 100644
index 0000000000..41b2302381
--- /dev/null
+++ b/include/llvm/Support/PointerLikeTypeTraits.h
@@ -0,0 +1,61 @@
+//===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- 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 the PointerLikeTypeTraits class.  This allows data
+// structures to reason about pointers and other things that are pointer sized.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
+#define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
+
+namespace llvm {
+  
+/// PointerLikeTypeTraits - This is a traits object that is used to handle
+/// pointer types and things that are just wrappers for pointers as a uniform
+/// entity.
+template <typename T>
+class PointerLikeTypeTraits {
+  // getAsVoidPointer
+  // getFromVoidPointer
+  // getNumLowBitsAvailable
+};
+
+// Provide PointerLikeTypeTraits for non-cvr pointers.
+template<typename T>
+class PointerLikeTypeTraits<T*> {
+public:
+  static inline void *getAsVoidPointer(T* P) { return P; }
+  static inline T *getFromVoidPointer(void *P) {
+    return static_cast<T*>(P);
+  }
+  
+  /// Note, we assume here that malloc returns objects at least 8-byte aligned.
+  /// However, this may be wrong, or pointers may be from something other than
+  /// malloc.  In this case, you should specialize this template to reduce this.
+  ///
+  /// All clients should use assertions to do a run-time check to ensure that
+  /// this is actually true.
+  static inline unsigned getNumLowBitsAvailable() { return 3; }
+};
+  
+// Provide PointerLikeTypeTraits for const pointers.
+template<typename T>
+class PointerLikeTypeTraits<const T*> {
+public:
+  static inline const void *getAsVoidPointer(const T* P) { return P; }
+  static inline const T *getFromVoidPointer(const void *P) {
+    return static_cast<const T*>(P);
+  }
+  static inline unsigned getNumLowBitsAvailable() { return 3; }
+};
+  
+} // end namespace llvm
+
+#endif