Line data    Source code

       1             : //===- llvm/Support/PointerLikeTypeTraits.h - Pointer Traits ----*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines the PointerLikeTypeTraits class.  This allows data
      11             : // structures to reason about pointers and other things that are pointer sized.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
      16             : #define LLVM_SUPPORT_POINTERLIKETYPETRAITS_H
      17             : 
      18             : #include "llvm/Support/DataTypes.h"
      19             : 
      20             : namespace llvm {
      21             :   
      22             : /// PointerLikeTypeTraits - This is a traits object that is used to handle
      23             : /// pointer types and things that are just wrappers for pointers as a uniform
      24             : /// entity.
      25             : template <typename T>
      26             : class PointerLikeTypeTraits {
      27             :   // getAsVoidPointer
      28             :   // getFromVoidPointer
      29             :   // getNumLowBitsAvailable
      30             : };
      31             : 
      32             : // Provide PointerLikeTypeTraits for non-cvr pointers.
      33             : template<typename T>
      34             : class PointerLikeTypeTraits<T*> {
      35             : public:
      36           0 :   static inline void *getAsVoidPointer(T* P) { return P; }
      37             :   static inline T *getFromVoidPointer(void *P) {
      38         234 :     return static_cast<T*>(P);
      39             :   }
      40             :   
      41             :   /// Note, we assume here that malloc returns objects at least 4-byte aligned.
      42             :   /// However, this may be wrong, or pointers may be from something other than
      43             :   /// malloc.  In this case, you should specialize this template to reduce this.
      44             :   ///
      45             :   /// All clients should use assertions to do a run-time check to ensure that
      46             :   /// this is actually true.
      47             :   enum { NumLowBitsAvailable = 2 };
      48             : };
      49             :   
      50             : // Provide PointerLikeTypeTraits for const pointers.
      51             : template<typename T>
      52             : class PointerLikeTypeTraits<const T*> {
      53             :   typedef PointerLikeTypeTraits<T*> NonConst;
      54             : 
      55             : public:
      56             :   static inline const void *getAsVoidPointer(const T* P) {
      57           7 :     return NonConst::getAsVoidPointer(const_cast<T*>(P));
      58             :   }
      59             :   static inline const T *getFromVoidPointer(const void *P) {
      60         160 :     return NonConst::getFromVoidPointer(const_cast<void*>(P));
      61             :   }
      62             :   enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
      63             : };
      64             : 
      65             : // Provide PointerLikeTypeTraits for uintptr_t.
      66             : template<>
      67             : class PointerLikeTypeTraits<uintptr_t> {
      68             : public:
      69             :   static inline void *getAsVoidPointer(uintptr_t P) {
      70             :     return reinterpret_cast<void*>(P);
      71             :   }
      72             :   static inline uintptr_t getFromVoidPointer(void *P) {
      73             :     return reinterpret_cast<uintptr_t>(P);
      74             :   }
      75             :   // No bits are available!
      76             :   enum { NumLowBitsAvailable = 0 };
      77             : };
      78             :   
      79             : } // end namespace llvm
      80             : 
      81             : #endif