PointerUnion.h revision 453f4f01302f00651aae2fc7658f6e23a2beadb0
12f1efd639c8659582d0df2b8f927a018b057037fJeffrey Yasskin//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- C++ -*-===// 22bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 32bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// The LLVM Compiler Infrastructure 42bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 52bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// This file is distributed under the University of Illinois Open Source 62bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// License. See LICENSE.TXT for details. 72bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 82bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson//===----------------------------------------------------------------------===// 95217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// 105217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// This file defines the PointerUnion class, which is a discriminated union of 115217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// pointer types. 125217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// 135217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson//===----------------------------------------------------------------------===// 142bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 152bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson#ifndef LLVM_ADT_POINTERUNION_H 162bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson#define LLVM_ADT_POINTERUNION_H 172bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 18f6670729aabc1fab85238d2b306a1c1767a807bbBill Wendling#include "llvm/ADT/PointerIntPair.h" 1948b2f3e4850cd27d54224cd42da8a160d6b95984Owen Anderson 20c34ebf65af0139eaf5cb0969fabcd32c0b6e1710Owen Andersonnamespace llvm { 21914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson 22001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson template <typename T> 232a4a6fecf0b8c92223f8fdf19545b564b7d3fcdeJay Foad struct PointerUnionTypeSelectorReturn { 24001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson typedef T Return; 25ce032b483ca96093b84f69178cdb2d047e124332Owen Anderson }; 26a1514e24cc24b050f53a12650e047799358833a1Chandler Carruth 27ad715f86c90b06cc4ab9e1336d1bc3bf13ecb16dJeffrey Yasskin /// \brief Get a type based on whether two types are the same or not. For: 28aad3fb7362aff151e97ad457005ea3f2872fe868Owen Anderson /// @code 290b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth /// typedef typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return Ret; 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth /// @endcode 310b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth /// Ret will be EQ type if T1 is same as T2 or NE type otherwise. 320b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth template <typename T1, typename T2, typename RET_EQ, typename RET_NE> 33a1514e24cc24b050f53a12650e047799358833a1Chandler Carruth struct PointerUnionTypeSelector { 34006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson typedef typename PointerUnionTypeSelectorReturn<RET_NE>::Return Return; 3516e298f98024bcff5c7219a96cac216114c30dadOwen Anderson }; 362bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 37eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson template <typename T, typename RET_EQ, typename RET_NE> 38001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> { 39914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson typedef typename PointerUnionTypeSelectorReturn<RET_EQ>::Return Return; 4012ddd409535b52a7fa5157ded9a4cedd161fedb6Benjamin Kramer }; 41001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 42ce032b483ca96093b84f69178cdb2d047e124332Owen Anderson template <typename T1, typename T2, typename RET_EQ, typename RET_NE> 43001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson struct PointerUnionTypeSelectorReturn< 4455c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE> > { 45001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson typedef typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return 46001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson Return; 47db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner }; 48db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner 49001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion 50001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// for the two template arguments. 51001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson template <typename PT1, typename PT2> 52001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson class PointerUnionUIntTraits { 53001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson public: 54001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static inline void *getAsVoidPointer(void *P) { return P; } 55ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth static inline void *getFromVoidPointer(void *P) { return P; } 56ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth enum { 57ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth PT1BitsAv = (int)(PointerLikeTypeTraits<PT1>::NumLowBitsAvailable), 58001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson PT2BitsAv = (int)(PointerLikeTypeTraits<PT2>::NumLowBitsAvailable), 59001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson NumLowBitsAvailable = PT1BitsAv < PT2BitsAv ? PT1BitsAv : PT2BitsAv 60001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson }; 61001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson }; 62ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth 63001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// PointerUnion - This implements a discriminated union of two pointer types, 64001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// and keeps the discriminator bit-mangled into the low bits of the pointer. 65001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// This allows the implementation to be extremely efficient in space, but 66001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// permits a very natural and type-safe API. 67001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// 68001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson /// Common use patterns would be something like this: 6955c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer /// PointerUnion<int*, float*> P; 70914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// P = (int*)0; 71914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0" 72914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// X = P.get<int*>(); // ok. 73914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// Y = P.get<float*>(); // runtime assertion failure. 74914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// Z = P.get<double*>(); // runtime assertion failure (regardless of tag) 75914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// P = (float*)0; 76914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// Y = P.get<float*>(); // ok. 77914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson /// X = P.get<int*>(); // runtime assertion failure. 78914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson template <typename PT1, typename PT2> 79ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth class PointerUnion { 80ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth public: 81ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth typedef PointerIntPair<void*, 1, bool, 82914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson PointerUnionUIntTraits<PT1,PT2> > ValTy; 83914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson private: 84914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson ValTy Val; 85914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson 86914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson struct IsPT1 { 87914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static const int Num = 0; 88914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson }; 89914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson struct IsPT2 { 90ed7692a136a9bcf513b91b7b5eb33a1e2d83e7eeChandler Carruth static const int Num = 1; 91914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson }; 92914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson template <typename T> 93914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson struct UNION_DOESNT_CONTAIN_TYPE { }; 94914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson 95914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson public: 96914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson PointerUnion() {} 9755c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer 98bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad PointerUnion(PT1 V) : Val( 99bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(V))) { 100bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 101bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad PointerUnion(PT2 V) : Val( 102bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(V)), 1) { 103bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 104bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 105bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// isNull - Return true if the pointer held in the union is null, 106bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// regardless of which type it is. 107bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad bool isNull() const { 108bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad // Convert from the void* to one of the pointer types, to make sure that 109bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad // we recursively strip off low bits if we have a nested PointerUnion. 110bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return !PointerLikeTypeTraits<PT1>::getFromVoidPointer(Val.getPointer()); 111bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 112bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad LLVM_EXPLICIT operator bool() const { return !isNull(); } 113bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 114bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// is<T>() return true if the Union currently holds the type matching T. 115bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad template<typename T> 116bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad int is() const { 117bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad typedef typename 118bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad ::llvm::PointerUnionTypeSelector<PT1, T, IsPT1, 119bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad ::llvm::PointerUnionTypeSelector<PT2, T, IsPT2, 120bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad UNION_DOESNT_CONTAIN_TYPE<T> > >::Return Ty; 121bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad int TyNo = Ty::Num; 122bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return static_cast<int>(Val.getInt()) == TyNo; 123bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 1240b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth 1250b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth /// get<T>() - Return the value of the specified pointer type. If the 1260b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth /// specified pointer type is incorrect, assert. 127bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad template<typename T> 128bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad T get() const { 129bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad assert(is<T>() && "Invalid accessor called"); 130bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return PointerLikeTypeTraits<T>::getFromVoidPointer(Val.getPointer()); 131bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 132bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 133bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// dyn_cast<T>() - If the current value is of the specified pointer type, 134bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// return it, otherwise return null. 135bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad template<typename T> 136bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad T dyn_cast() const { 137bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad if (is<T>()) return get<T>(); 138bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return T(); 139bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 140bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 14155c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer /// \brief If the union is set to the first pointer type get an address 142bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// pointing to it. 143bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad PT1 const *getAddrOfPtr1() const { 144bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return const_cast<PointerUnion *>(this)->getAddrOfPtr1(); 145bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 146bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 147bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// \brief If the union is set to the first pointer type get an address 148bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// pointing to it. 149bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad PT1 *getAddrOfPtr1() { 150bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad assert(is<PT1>() && "Val is not the first pointer"); 151bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad assert(get<PT1>() == Val.getPointer() && 152bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad "Can't get the address because PointerLikeTypeTraits changes the ptr"); 153bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return (PT1 *)Val.getAddrOfPointer(); 154bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 155bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 156bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// Assignment operators - Allow assigning into this union from either 157bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad /// pointer type, setting the discriminator to remember what it came from. 158bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const PointerUnion &operator=(const PT1 &RHS) { 159bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad Val.initWithPointer( 160bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const_cast<void *>(PointerLikeTypeTraits<PT1>::getAsVoidPointer(RHS))); 161bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return *this; 162bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 163bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const PointerUnion &operator=(const PT2 &RHS) { 164bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad Val.setPointerAndInt( 165bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad const_cast<void *>(PointerLikeTypeTraits<PT2>::getAsVoidPointer(RHS)), 166bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 1); 167bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return *this; 168bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 169bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 170bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad void *getOpaqueValue() const { return Val.getOpaqueValue(); } 171bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad static inline PointerUnion getFromOpaqueValue(void *VP) { 1720b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth PointerUnion V; 1730b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth V.Val = ValTy::getFromOpaqueValue(VP); 1740b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth return V; 1750b66c6fca22e85f732cf58f459a06c06833d1882Chandler Carruth } 176bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad }; 177bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 178bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad template<typename PT1, typename PT2> 179bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad bool operator==(PointerUnion<PT1, PT2> lhs, PointerUnion<PT1, PT2> rhs) { 180bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad return lhs.getOpaqueValue() == rhs.getOpaqueValue(); 181bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 182bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 183bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad // Teach SmallPtrSet that PointerUnion is "basically a pointer", that has 184bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad // # low bits available = min(PT1bits,PT2bits)-1. 185bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad template<typename PT1, typename PT2> 186bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad class PointerLikeTypeTraits<PointerUnion<PT1, PT2> > { 187bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad public: 188bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad static inline void * 189bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad getAsVoidPointer(const PointerUnion<PT1, PT2> &P) { 190611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer return P.getOpaqueValue(); 191611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer } 192611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer static inline PointerUnion<PT1, PT2> 193611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer getFromVoidPointer(void *P) { 194611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer return PointerUnion<PT1, PT2>::getFromOpaqueValue(P); 195611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer } 196611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer 197611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer // The number of bits available are the min of the two pointer types. 198611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer enum { 199611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer NumLowBitsAvailable = 200611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer PointerLikeTypeTraits<typename PointerUnion<PT1,PT2>::ValTy> 201611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer ::NumLowBitsAvailable 202611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer }; 203611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer }; 204611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer 205611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer 206611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer /// PointerUnion3 - This is a pointer union of three pointer types. See 207611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer /// documentation for PointerUnion for usage. 208611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer template <typename PT1, typename PT2, typename PT3> 209611afc0620aed7827b5fdf9072a1827952b684b6Benjamin Kramer class PointerUnion3 { 210b227925fa313428045f554187b0136d084d723f6Chris Lattner public: 211b227925fa313428045f554187b0136d084d723f6Chris Lattner typedef PointerUnion<PT1, PT2> InnerUnion; 21255c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer typedef PointerUnion<InnerUnion, PT3> ValTy; 213b227925fa313428045f554187b0136d084d723f6Chris Lattner private: 214b227925fa313428045f554187b0136d084d723f6Chris Lattner ValTy Val; 215b227925fa313428045f554187b0136d084d723f6Chris Lattner 216b227925fa313428045f554187b0136d084d723f6Chris Lattner struct IsInnerUnion { 217b227925fa313428045f554187b0136d084d723f6Chris Lattner ValTy Val; 218b227925fa313428045f554187b0136d084d723f6Chris Lattner IsInnerUnion(ValTy val) : Val(val) { } 219b227925fa313428045f554187b0136d084d723f6Chris Lattner template<typename T> 220b227925fa313428045f554187b0136d084d723f6Chris Lattner int is() const { 221b227925fa313428045f554187b0136d084d723f6Chris Lattner return Val.template is<InnerUnion>() && 222b227925fa313428045f554187b0136d084d723f6Chris Lattner Val.template get<InnerUnion>().template is<T>(); 223b227925fa313428045f554187b0136d084d723f6Chris Lattner } 224b227925fa313428045f554187b0136d084d723f6Chris Lattner template<typename T> 225b227925fa313428045f554187b0136d084d723f6Chris Lattner T get() const { 226b227925fa313428045f554187b0136d084d723f6Chris Lattner return Val.template get<InnerUnion>().template get<T>(); 227b227925fa313428045f554187b0136d084d723f6Chris Lattner } 228b227925fa313428045f554187b0136d084d723f6Chris Lattner }; 229b227925fa313428045f554187b0136d084d723f6Chris Lattner 230b227925fa313428045f554187b0136d084d723f6Chris Lattner struct IsPT3 { 231b227925fa313428045f554187b0136d084d723f6Chris Lattner ValTy Val; 232b227925fa313428045f554187b0136d084d723f6Chris Lattner IsPT3(ValTy val) : Val(val) { } 23355c06ae7afa3f862a6bb4a4441fe485c135f5b5eBenjamin Kramer template<typename T> 23412ddd409535b52a7fa5157ded9a4cedd161fedb6Benjamin Kramer int is() const { 23530268be89df6444f5ffb585439b3fbfec9055197Owen Anderson return Val.template is<T>(); 23630268be89df6444f5ffb585439b3fbfec9055197Owen Anderson } 23730268be89df6444f5ffb585439b3fbfec9055197Owen Anderson template<typename T> 23830268be89df6444f5ffb585439b3fbfec9055197Owen Anderson T get() const { 239f64c889cc94417322b0ff8ad1c61939183bf3c38Bob Wilson return Val.template get<T>(); 240f64c889cc94417322b0ff8ad1c61939183bf3c38Bob Wilson } 24142a4ee0a35b4672311c1b988bd883167de9f88cdChris Lattner }; 242001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 24348b2f3e4850cd27d54224cd42da8a160d6b95984Owen Anderson public: 244001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson PointerUnion3() {} 245001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 246914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson PointerUnion3(PT1 V) { 24748b2f3e4850cd27d54224cd42da8a160d6b95984Owen Anderson Val = InnerUnion(V); 248914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 2492c79ecbd704c656178ffa43d5a58ebe3ca188b40Bill Wendling PointerUnion3(PT2 V) { 250f6670729aabc1fab85238d2b306a1c1767a807bbBill Wendling Val = InnerUnion(V); 25118e7211068c9d2c6204512f9c468ee179818a4b6Bill Wendling } 2523467e30edf63b6d8a8d446186674ba9e4b7885a9Bill Wendling PointerUnion3(PT3 V) { 2530976e00fd1cbf4128daeb72efd8957d00383fda9Bill Wendling Val = V; 2543ecb447f52d169dea6663b95b5b5b43e9bb5826bBill Wendling } 2552c79ecbd704c656178ffa43d5a58ebe3ca188b40Bill Wendling 2565f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel /// isNull - Return true if the pointer held in the union is null, 2572c79ecbd704c656178ffa43d5a58ebe3ca188b40Bill Wendling /// regardless of which type it is. 2586f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin bool isNull() const { return Val.isNull(); } 2596f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin LLVM_EXPLICIT operator bool() const { return !isNull(); } 2606f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin 2616f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin /// is<T>() return true if the Union currently holds the type matching T. 2626f555ca2cd0bba50542adcbb131f541ae70d34cdJeffrey Yasskin template<typename T> 2635f4ac848d94b0a92e19ac7f2b3d0284d7d323173Devang Patel int is() const { 2649df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3. 2650631fce85050f8f633e5fd032875d9151e0db4daOwen Anderson typedef typename 2662cb395eae71dacda49ca3fe758618fc3e0701659Talin ::llvm::PointerUnionTypeSelector<PT1, T, IsInnerUnion, 267eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3 > 26816e298f98024bcff5c7219a96cac216114c30dadOwen Anderson >::Return Ty; 2692cb395eae71dacda49ca3fe758618fc3e0701659Talin return Ty(Val).template is<T>(); 270eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 271006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson 2722cb395eae71dacda49ca3fe758618fc3e0701659Talin /// get<T>() - Return the value of the specified pointer type. If the 273eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// specified pointer type is incorrect, assert. 2745bd68393ed87bcedc53f5998f1af9c906f5a1b4eOwen Anderson template<typename T> 2759df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner T get() const { 2769df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner assert(is<T>() && "Invalid accessor called"); 2779df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // If T is PT1/PT2 choose IsInnerUnion otherwise choose IsPT3. 2787e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson typedef typename 27927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ::llvm::PointerUnionTypeSelector<PT1, T, IsInnerUnion, 28027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ::llvm::PointerUnionTypeSelector<PT2, T, IsInnerUnion, IsPT3 > 28127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner >::Return Ty; 2822ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return Ty(Val).template get<T>(); 2832a4a6fecf0b8c92223f8fdf19545b564b7d3fcdeJay Foad } 2842a4a6fecf0b8c92223f8fdf19545b564b7d3fcdeJay Foad 285bf48a9b6db111fc14a8faef1adefbce5d807aaefJeffrey Yasskin /// dyn_cast<T>() - If the current value is of the specified pointer type, 2862a4a6fecf0b8c92223f8fdf19545b564b7d3fcdeJay Foad /// return it, otherwise return null. 2872a4a6fecf0b8c92223f8fdf19545b564b7d3fcdeJay Foad template<typename T> 288d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson T dyn_cast() const { 289f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson if (is<T>()) return get<T>(); 290f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson return T(); 291f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson } 292c34ebf65af0139eaf5cb0969fabcd32c0b6e1710Owen Anderson 293c34ebf65af0139eaf5cb0969fabcd32c0b6e1710Owen Anderson /// Assignment operators - Allow assigning into this union from either 29463a03cf58505aa839f721f212cd1518ebf133979Dan Gohman /// pointer type, setting the discriminator to remember what it came from. 295ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman const PointerUnion3 &operator=(const PT1 &RHS) { 2961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Val = InnerUnion(RHS); 2971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *this; 2989233b15d01ca62445bfc638f782243988c672e01Jeffrey Yasskin } 299ba3ddf391f5149b8fca073adc3cbca361353929cChris Lattner const PointerUnion3 &operator=(const PT2 &RHS) { 300ba3ddf391f5149b8fca073adc3cbca361353929cChris Lattner Val = InnerUnion(RHS); 301ba3ddf391f5149b8fca073adc3cbca361353929cChris Lattner return *this; 302ba3ddf391f5149b8fca073adc3cbca361353929cChris Lattner } 303ba3ddf391f5149b8fca073adc3cbca361353929cChris Lattner const PointerUnion3 &operator=(const PT3 &RHS) { 3041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Val = RHS; 3051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *this; 306bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad } 307bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad 308bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad void *getOpaqueValue() const { return Val.getOpaqueValue(); } 309bdf1748b12fa44b18b74ae71d68a9b964c4cb8c6Jay Foad static inline PointerUnion3 getFromOpaqueValue(void *VP) { 3101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner PointerUnion3 V; 3111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner V.Val = ValTy::getFromOpaqueValue(VP); 3121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return V; 3131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 3141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner }; 3151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Teach SmallPtrSet that PointerUnion3 is "basically a pointer", that has 3179233b15d01ca62445bfc638f782243988c672e01Jeffrey Yasskin // # low bits available = min(PT1bits,PT2bits,PT2bits)-2. 318ad715f86c90b06cc4ab9e1336d1bc3bf13ecb16dJeffrey Yasskin template<typename PT1, typename PT2, typename PT3> 3194d919438898d542850449235da7f6dc55e6ca152Owen Anderson class PointerLikeTypeTraits<PointerUnion3<PT1, PT2, PT3> > { 3204d919438898d542850449235da7f6dc55e6ca152Owen Anderson public: 3214c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman static inline void * 3224d919438898d542850449235da7f6dc55e6ca152Owen Anderson getAsVoidPointer(const PointerUnion3<PT1, PT2, PT3> &P) { 3234d919438898d542850449235da7f6dc55e6ca152Owen Anderson return P.getOpaqueValue(); 3244d919438898d542850449235da7f6dc55e6ca152Owen Anderson } 325081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner static inline PointerUnion3<PT1, PT2, PT3> 326081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner getFromVoidPointer(void *P) { 327081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner return PointerUnion3<PT1, PT2, PT3>::getFromOpaqueValue(P); 328081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner } 329081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner 330081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner // The number of bits available are the min of the two pointer types. 331081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner enum { 332081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner NumLowBitsAvailable = 333081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner PointerLikeTypeTraits<typename PointerUnion3<PT1, PT2, PT3>::ValTy> 334081134741b40b342fb2f85722c9cea5d412489a8Chris Lattner ::NumLowBitsAvailable 335b227925fa313428045f554187b0136d084d723f6Chris Lattner }; 336b227925fa313428045f554187b0136d084d723f6Chris Lattner }; 337b227925fa313428045f554187b0136d084d723f6Chris Lattner 338b227925fa313428045f554187b0136d084d723f6Chris Lattner /// PointerUnion4 - This is a pointer union of four pointer types. See 339b227925fa313428045f554187b0136d084d723f6Chris Lattner /// documentation for PointerUnion for usage. 340b227925fa313428045f554187b0136d084d723f6Chris Lattner template <typename PT1, typename PT2, typename PT3, typename PT4> 341b227925fa313428045f554187b0136d084d723f6Chris Lattner class PointerUnion4 { 342b227925fa313428045f554187b0136d084d723f6Chris Lattner public: 343b227925fa313428045f554187b0136d084d723f6Chris Lattner typedef PointerUnion<PT1, PT2> InnerUnion1; 344b227925fa313428045f554187b0136d084d723f6Chris Lattner typedef PointerUnion<PT3, PT4> InnerUnion2; 345b227925fa313428045f554187b0136d084d723f6Chris Lattner typedef PointerUnion<InnerUnion1, InnerUnion2> ValTy; 346b227925fa313428045f554187b0136d084d723f6Chris Lattner private: 347b227925fa313428045f554187b0136d084d723f6Chris Lattner ValTy Val; 348b227925fa313428045f554187b0136d084d723f6Chris Lattner public: 349b227925fa313428045f554187b0136d084d723f6Chris Lattner PointerUnion4() {} 350b227925fa313428045f554187b0136d084d723f6Chris Lattner 351b227925fa313428045f554187b0136d084d723f6Chris Lattner PointerUnion4(PT1 V) { 352b227925fa313428045f554187b0136d084d723f6Chris Lattner Val = InnerUnion1(V); 3534c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman } 3544c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman PointerUnion4(PT2 V) { 3554c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman Val = InnerUnion1(V); 3564c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman } 3574c8e74f0b75cb10820c45c86399fbd02e4a8832aMichael Ilseman PointerUnion4(PT3 V) { 358b227925fa313428045f554187b0136d084d723f6Chris Lattner Val = InnerUnion2(V); 359b227925fa313428045f554187b0136d084d723f6Chris Lattner } 360b227925fa313428045f554187b0136d084d723f6Chris Lattner PointerUnion4(PT4 V) { 3612f1efd639c8659582d0df2b8f927a018b057037fJeffrey Yasskin Val = InnerUnion2(V); 3622f1efd639c8659582d0df2b8f927a018b057037fJeffrey Yasskin } 3632bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 3642bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson /// isNull - Return true if the pointer held in the union is null, 3652bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson /// regardless of which type it is. 3662bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson bool isNull() const { return Val.isNull(); } 3675217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson LLVM_EXPLICIT operator bool() const { return !isNull(); } 368 369 /// is<T>() return true if the Union currently holds the type matching T. 370 template<typename T> 371 int is() const { 372 // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2. 373 typedef typename 374 ::llvm::PointerUnionTypeSelector<PT1, T, InnerUnion1, 375 ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1, InnerUnion2 > 376 >::Return Ty; 377 return Val.template is<Ty>() && 378 Val.template get<Ty>().template is<T>(); 379 } 380 381 /// get<T>() - Return the value of the specified pointer type. If the 382 /// specified pointer type is incorrect, assert. 383 template<typename T> 384 T get() const { 385 assert(is<T>() && "Invalid accessor called"); 386 // If T is PT1/PT2 choose InnerUnion1 otherwise choose InnerUnion2. 387 typedef typename 388 ::llvm::PointerUnionTypeSelector<PT1, T, InnerUnion1, 389 ::llvm::PointerUnionTypeSelector<PT2, T, InnerUnion1, InnerUnion2 > 390 >::Return Ty; 391 return Val.template get<Ty>().template get<T>(); 392 } 393 394 /// dyn_cast<T>() - If the current value is of the specified pointer type, 395 /// return it, otherwise return null. 396 template<typename T> 397 T dyn_cast() const { 398 if (is<T>()) return get<T>(); 399 return T(); 400 } 401 402 /// Assignment operators - Allow assigning into this union from either 403 /// pointer type, setting the discriminator to remember what it came from. 404 const PointerUnion4 &operator=(const PT1 &RHS) { 405 Val = InnerUnion1(RHS); 406 return *this; 407 } 408 const PointerUnion4 &operator=(const PT2 &RHS) { 409 Val = InnerUnion1(RHS); 410 return *this; 411 } 412 const PointerUnion4 &operator=(const PT3 &RHS) { 413 Val = InnerUnion2(RHS); 414 return *this; 415 } 416 const PointerUnion4 &operator=(const PT4 &RHS) { 417 Val = InnerUnion2(RHS); 418 return *this; 419 } 420 421 void *getOpaqueValue() const { return Val.getOpaqueValue(); } 422 static inline PointerUnion4 getFromOpaqueValue(void *VP) { 423 PointerUnion4 V; 424 V.Val = ValTy::getFromOpaqueValue(VP); 425 return V; 426 } 427 }; 428 429 // Teach SmallPtrSet that PointerUnion4 is "basically a pointer", that has 430 // # low bits available = min(PT1bits,PT2bits,PT2bits)-2. 431 template<typename PT1, typename PT2, typename PT3, typename PT4> 432 class PointerLikeTypeTraits<PointerUnion4<PT1, PT2, PT3, PT4> > { 433 public: 434 static inline void * 435 getAsVoidPointer(const PointerUnion4<PT1, PT2, PT3, PT4> &P) { 436 return P.getOpaqueValue(); 437 } 438 static inline PointerUnion4<PT1, PT2, PT3, PT4> 439 getFromVoidPointer(void *P) { 440 return PointerUnion4<PT1, PT2, PT3, PT4>::getFromOpaqueValue(P); 441 } 442 443 // The number of bits available are the min of the two pointer types. 444 enum { 445 NumLowBitsAvailable = 446 PointerLikeTypeTraits<typename PointerUnion4<PT1, PT2, PT3, PT4>::ValTy> 447 ::NumLowBitsAvailable 448 }; 449 }; 450} 451 452#endif 453