Type.h revision 26199059268a05739c84ebf465fcdbf7ded861df
1//===-- llvm/Type.h - Classes for handling data types ------------*- C++ -*--=// 2// 3// This file contains the declaration of the Type class. For more "Type" type 4// stuff, look in DerivedTypes.h. 5// 6// Note that instances of the Type class are immutable: once they are created, 7// they are never changed. Also note that only one instance of a particular 8// type is ever created. Thus seeing if two types are equal is a matter of 9// doing a trivial pointer comparison. 10// 11// Types, once allocated, are never free'd. 12// 13// Opaque types are simple derived types with no state. There may be many 14// different Opaque type objects floating around, but two are only considered 15// identical if they are pointer equals of each other. This allows us to have 16// two opaque types that end up resolving to different concrete types later. 17// 18// Opaque types are also kinda wierd and scary and different because they have 19// to keep a list of uses of the type. When, through linking, parsing, or 20// bytecode reading, they become resolved, they need to find and update all 21// users of the unknown type, causing them to reference a new, more concrete 22// type. Opaque types are deleted when their use list dwindles to zero users. 23// 24//===----------------------------------------------------------------------===// 25 26#ifndef LLVM_TYPE_H 27#define LLVM_TYPE_H 28 29#include "llvm/Value.h" 30#include "Support/GraphTraits.h" 31#include "Support/iterator" 32 33class DerivedType; 34class FunctionType; 35class ArrayType; 36class PointerType; 37class StructType; 38class OpaqueType; 39 40class Type : public Value { 41public: 42 ///===-------------------------------------------------------------------===// 43 /// Definitions of all of the base types for the Type system. Based on this 44 /// value, you can cast to a "DerivedType" subclass (see DerivedTypes.h) 45 /// Note: If you add an element to this, you need to add an element to the 46 /// Type::getPrimitiveType function, or else things will break! 47 /// 48 enum PrimitiveID { 49 VoidTyID = 0 , BoolTyID, // 0, 1: Basics... 50 UByteTyID , SByteTyID, // 2, 3: 8 bit types... 51 UShortTyID , ShortTyID, // 4, 5: 16 bit types... 52 UIntTyID , IntTyID, // 6, 7: 32 bit types... 53 ULongTyID , LongTyID, // 8, 9: 64 bit types... 54 55 FloatTyID , DoubleTyID, // 10,11: Floating point types... 56 57 TypeTyID, // 12 : Type definitions 58 LabelTyID , // 13 : Labels... 59 60 // Derived types... see DerivedTypes.h file... 61 // Make sure FirstDerivedTyID stays up to date!!! 62 FunctionTyID , StructTyID, // Functions... Structs... 63 ArrayTyID , PointerTyID, // Array... pointer... 64 OpaqueTyID, // Opaque type instances... 65 //PackedTyID , // SIMD 'packed' format... TODO 66 //... 67 68 NumPrimitiveIDs, // Must remain as last defined ID 69 FirstDerivedTyID = FunctionTyID, 70 }; 71 72private: 73 PrimitiveID ID; // The current base type of this type... 74 unsigned UID; // The unique ID number for this class 75 std::string Desc; // The printed name of the string... 76 bool Abstract; // True if type contains an OpaqueType 77 bool Recursive; // True if the type is recursive 78 79protected: 80 /// ctor is protected, so only subclasses can create Type objects... 81 Type(const std::string &Name, PrimitiveID id); 82 virtual ~Type() {} 83 84 /// When types are refined, they update their description to be more concrete. 85 /// 86 inline void setDescription(const std::string &D) { Desc = D; } 87 88 /// setName - Associate the name with this type in the symbol table, but don't 89 /// set the local name to be equal specified name. 90 /// 91 virtual void setName(const std::string &Name, SymbolTable *ST = 0); 92 93 /// Types can become nonabstract later, if they are refined. 94 /// 95 inline void setAbstract(bool Val) { Abstract = Val; } 96 97 /// Types can become recursive later, if they are refined. 98 /// 99 inline void setRecursive(bool Val) { Recursive = Val; } 100 101public: 102 virtual void print(std::ostream &O) const; 103 104 //===--------------------------------------------------------------------===// 105 // Property accessors for dealing with types... Some of these virtual methods 106 // are defined in private classes defined in Type.cpp for primitive types. 107 // 108 109 /// getPrimitiveID - Return the base type of the type. This will return one 110 /// of the PrimitiveID enum elements defined above. 111 /// 112 inline PrimitiveID getPrimitiveID() const { return ID; } 113 114 /// getUniqueID - Returns the UID of the type. This can be thought of as a 115 /// small integer version of the pointer to the type class. Two types that 116 /// are structurally different have different UIDs. This can be used for 117 /// indexing types into an array. 118 /// 119 inline unsigned getUniqueID() const { return UID; } 120 121 /// getDescription - Return the string representation of the type... 122 inline const std::string &getDescription() const { return Desc; } 123 124 /// isSigned - Return whether a numeric type is signed. 125 virtual bool isSigned() const { return 0; } 126 127 /// isUnsigned - Return whether a numeric type is unsigned. This is not 128 /// quite the complement of isSigned... nonnumeric types return false as they 129 /// do with isSigned. 130 /// 131 virtual bool isUnsigned() const { return 0; } 132 133 /// isIntegral - Equilivent to isSigned() || isUnsigned, but with only a 134 /// single virtual function invocation. 135 /// 136 virtual bool isIntegral() const { return 0; } 137 138 /// isFloatingPoint - Return true if this is one of the two floating point 139 /// types 140 bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID; } 141 142 /// isAbstract - True if the type is either an Opaque type, or is a derived 143 /// type that includes an opaque type somewhere in it. 144 /// 145 inline bool isAbstract() const { return Abstract; } 146 147 /// isRecursive - True if the type graph contains a cycle. 148 /// 149 inline bool isRecursive() const { return Recursive; } 150 151 /// isLosslesslyConvertableTo - Return true if this type can be converted to 152 /// 'Ty' without any reinterpretation of bits. For example, uint to int. 153 /// 154 bool isLosslesslyConvertableTo(const Type *Ty) const; 155 156 157 /// Here are some useful little methods to query what type derived types are 158 /// Note that all other types can just compare to see if this == Type::xxxTy; 159 /// 160 inline bool isPrimitiveType() const { return ID < FirstDerivedTyID; } 161 inline bool isDerivedType() const { return ID >= FirstDerivedTyID; } 162 163 /// isFirstClassType - Return true if the value is holdable in a register. 164 inline bool isFirstClassType() const { 165 return isPrimitiveType() || ID == PointerTyID; 166 } 167 168 /// isSized - Return true if it makes sense to take the size of this type. To 169 /// get the actual size for a particular target, it is reasonable to use the 170 /// TargetData subsystem to do this. 171 /// 172 bool isSized() const { 173 return ID != VoidTyID && ID != TypeTyID && 174 ID != FunctionTyID && ID != LabelTyID && ID != OpaqueTyID; 175 } 176 177 /// getPrimitiveSize - Return the basic size of this type if it is a primative 178 /// type. These are fixed by LLVM and are not target dependant. This will 179 /// return zero if the type does not have a size or is not a primitive type. 180 /// 181 unsigned getPrimitiveSize() const; 182 183 184 //===--------------------------------------------------------------------===// 185 // Type Iteration support 186 // 187 class TypeIterator; 188 typedef TypeIterator subtype_iterator; 189 inline subtype_iterator subtype_begin() const; // DEFINED BELOW 190 inline subtype_iterator subtype_end() const; // DEFINED BELOW 191 192 /// getContainedType - This method is used to implement the type iterator 193 /// (defined a the end of the file). For derived types, this returns the 194 /// types 'contained' in the derived type, returning 0 when 'i' becomes 195 /// invalid. This allows the user to iterate over the types in a struct, for 196 /// example, really easily. 197 /// 198 virtual const Type *getContainedType(unsigned i) const { return 0; } 199 200 /// getNumContainedTypes - Return the number of types in the derived type 201 virtual unsigned getNumContainedTypes() const { return 0; } 202 203 //===--------------------------------------------------------------------===// 204 // Static members exported by the Type class itself. Useful for getting 205 // instances of Type. 206 // 207 208 /// getPrimitiveType/getUniqueIDType - Return a type based on an identifier. 209 static const Type *getPrimitiveType(PrimitiveID IDNumber); 210 static const Type *getUniqueIDType(unsigned UID); 211 212 //===--------------------------------------------------------------------===// 213 // These are the builtin types that are always available... 214 // 215 static Type *VoidTy , *BoolTy; 216 static Type *SByteTy, *UByteTy, 217 *ShortTy, *UShortTy, 218 *IntTy , *UIntTy, 219 *LongTy , *ULongTy; 220 static Type *FloatTy, *DoubleTy; 221 222 static Type *TypeTy , *LabelTy; 223 224 /// Methods for support type inquiry through isa, cast, and dyn_cast: 225 static inline bool classof(const Type *T) { return true; } 226 static inline bool classof(const Value *V) { 227 return V->getValueType() == Value::TypeVal; 228 } 229 230#include "llvm/Type.def" 231 232private: 233 class TypeIterator : public bidirectional_iterator<const Type, ptrdiff_t> { 234 const Type * const Ty; 235 unsigned Idx; 236 237 typedef TypeIterator _Self; 238 public: 239 inline TypeIterator(const Type *ty, unsigned idx) : Ty(ty), Idx(idx) {} 240 inline ~TypeIterator() {} 241 242 inline bool operator==(const _Self& x) const { return Idx == x.Idx; } 243 inline bool operator!=(const _Self& x) const { return !operator==(x); } 244 245 inline pointer operator*() const { return Ty->getContainedType(Idx); } 246 inline pointer operator->() const { return operator*(); } 247 248 inline _Self& operator++() { ++Idx; return *this; } // Preincrement 249 inline _Self operator++(int) { // Postincrement 250 _Self tmp = *this; ++*this; return tmp; 251 } 252 253 inline _Self& operator--() { --Idx; return *this; } // Predecrement 254 inline _Self operator--(int) { // Postdecrement 255 _Self tmp = *this; --*this; return tmp; 256 } 257 }; 258}; 259 260inline Type::TypeIterator Type::subtype_begin() const { 261 return TypeIterator(this, 0); 262} 263 264inline Type::TypeIterator Type::subtype_end() const { 265 return TypeIterator(this, getNumContainedTypes()); 266} 267 268 269// Provide specializations of GraphTraits to be able to treat a type as a 270// graph of sub types... 271 272template <> struct GraphTraits<Type*> { 273 typedef Type NodeType; 274 typedef Type::subtype_iterator ChildIteratorType; 275 276 static inline NodeType *getEntryNode(Type *T) { return T; } 277 static inline ChildIteratorType child_begin(NodeType *N) { 278 return N->subtype_begin(); 279 } 280 static inline ChildIteratorType child_end(NodeType *N) { 281 return N->subtype_end(); 282 } 283}; 284 285template <> struct GraphTraits<const Type*> { 286 typedef const Type NodeType; 287 typedef Type::subtype_iterator ChildIteratorType; 288 289 static inline NodeType *getEntryNode(const Type *T) { return T; } 290 static inline ChildIteratorType child_begin(NodeType *N) { 291 return N->subtype_begin(); 292 } 293 static inline ChildIteratorType child_end(NodeType *N) { 294 return N->subtype_end(); 295 } 296}; 297 298template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) { 299 return Ty.getPrimitiveID() == Type::PointerTyID; 300} 301 302#endif 303