include/llvm/Support/PointerLikeTypeTraits.h

   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   static inline void *getAsVoidPointer(T* P) { return P; }
  37   static inline T *getFromVoidPointer(void *P) {
  38     return static_cast<T*>(P);
  39   }
  40
  41   /// Note, we assume here that malloc returns objects at least 8-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 = 3 };
  48 };
  49
  50 // Provide PointerLikeTypeTraits for const pointers.
  51 template<typename T>
  52 class PointerLikeTypeTraits<const T*> {
  53 public:
  54   static inline const void *getAsVoidPointer(const T* P) { return P; }
  55   static inline const T *getFromVoidPointer(const void *P) {
  56     return static_cast<const T*>(P);
  57   }
  58   enum { NumLowBitsAvailable = 3 };
  59 };
  60
  61 // Pointers to pointers are only 4-byte aligned on 32-bit systems.
  62 template<typename T>
  63 class PointerLikeTypeTraits<T**> {
  64 public:
  65   static inline void *getAsVoidPointer(T** P) { return P; }
  66   static inline T **getFromVoidPointer(void *P) {
  67     return static_cast<T**>(P);
  68   }
  69   enum { NumLowBitsAvailable = 2 };
  70 };
  71
  72
  73
  74
  75 // Provide PointerLikeTypeTraits for uintptr_t.
  76 template<>
  77 class PointerLikeTypeTraits<uintptr_t> {
  78 public:
  79   static inline void *getAsVoidPointer(uintptr_t P) {
  80     return reinterpret_cast<void*>(P);
  81   }
  82   static inline uintptr_t getFromVoidPointer(void *P) {
  83     return reinterpret_cast<uintptr_t>(P);
  84   }
  85   // No bits are available!
  86   enum { NumLowBitsAvailable = 0 };
  87 };
  88
  89 } // end namespace llvm
  90
  91 #endif