Type.h revision 2a4a4b54ada1d998340a7e3364ac4d80fa783a82
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 bool Abstract; // True if type contains an OpaqueType 76 77protected: 78 /// ctor is protected, so only subclasses can create Type objects... 79 Type(const std::string &Name, PrimitiveID id); 80 virtual ~Type() {} 81 82 /// setName - Associate the name with this type in the symbol table, but don't 83 /// set the local name to be equal specified name. 84 /// 85 virtual void setName(const std::string &Name, SymbolTable *ST = 0); 86 87 /// Types can become nonabstract later, if they are refined. 88 /// 89 inline void setAbstract(bool Val) { Abstract = Val; } 90 91 /// isTypeAbstract - This method is used to calculate the Abstract bit. 92 /// 93 bool isTypeAbstract(); 94public: 95 virtual void print(std::ostream &O) const; 96 97 //===--------------------------------------------------------------------===// 98 // Property accessors for dealing with types... Some of these virtual methods 99 // are defined in private classes defined in Type.cpp for primitive types. 100 // 101 102 /// getPrimitiveID - Return the base type of the type. This will return one 103 /// of the PrimitiveID enum elements defined above. 104 /// 105 inline PrimitiveID getPrimitiveID() const { return ID; } 106 107 /// getUniqueID - Returns the UID of the type. This can be thought of as a 108 /// small integer version of the pointer to the type class. Two types that 109 /// are structurally different have different UIDs. This can be used for 110 /// indexing types into an array. 111 /// 112 inline unsigned getUniqueID() const { return UID; } 113 114 /// getDescription - Return the string representation of the type... 115 const std::string &getDescription() const; 116 117 /// isSigned - Return whether an integral numeric type is signed. This is 118 /// true for SByteTy, ShortTy, IntTy, LongTy. Note that this is not true for 119 /// Float and Double. 120 // 121 virtual bool isSigned() const { return 0; } 122 123 /// isUnsigned - Return whether a numeric type is unsigned. This is not quite 124 /// the complement of isSigned... nonnumeric types return false as they do 125 /// with isSigned. This returns true for UByteTy, UShortTy, UIntTy, and 126 /// ULongTy 127 /// 128 virtual bool isUnsigned() const { return 0; } 129 130 /// isInteger - Equilivent to isSigned() || isUnsigned(), but with only a 131 /// single virtual function invocation. 132 /// 133 virtual bool isInteger() const { return 0; } 134 135 /// isIntegral - Returns true if this is an integral type, which is either 136 /// BoolTy or one of the Integer types. 137 /// 138 bool isIntegral() const { return isInteger() || this == BoolTy; } 139 140 /// isFloatingPoint - Return true if this is one of the two floating point 141 /// types 142 bool isFloatingPoint() const { return ID == FloatTyID || ID == DoubleTyID; } 143 144 /// isAbstract - True if the type is either an Opaque type, or is a derived 145 /// type that includes an opaque type somewhere in it. 146 /// 147 inline bool isAbstract() const { return Abstract; } 148 149 /// isLosslesslyConvertibleTo - Return true if this type can be converted to 150 /// 'Ty' without any reinterpretation of bits. For example, uint to int. 151 /// 152 bool isLosslesslyConvertibleTo(const Type *Ty) const; 153 154 155 /// Here are some useful little methods to query what type derived types are 156 /// Note that all other types can just compare to see if this == Type::xxxTy; 157 /// 158 inline bool isPrimitiveType() const { return ID < FirstDerivedTyID; } 159 inline bool isDerivedType() const { return ID >= FirstDerivedTyID; } 160 161 /// isFirstClassType - Return true if the value is holdable in a register. 162 inline bool isFirstClassType() const { 163 return isPrimitiveType() || ID == PointerTyID; 164 } 165 166 /// isSized - Return true if it makes sense to take the size of this type. To 167 /// get the actual size for a particular target, it is reasonable to use the 168 /// TargetData subsystem to do this. 169 /// 170 bool isSized() const { 171 return ID != VoidTyID && ID != TypeTyID && 172 ID != FunctionTyID && ID != LabelTyID && ID != OpaqueTyID; 173 } 174 175 /// getPrimitiveSize - Return the basic size of this type if it is a primative 176 /// type. These are fixed by LLVM and are not target dependent. This will 177 /// return zero if the type does not have a size or is not a primitive type. 178 /// 179 unsigned getPrimitiveSize() const; 180 181 182 //===--------------------------------------------------------------------===// 183 // Type Iteration support 184 // 185 class TypeIterator; 186 typedef TypeIterator subtype_iterator; 187 inline subtype_iterator subtype_begin() const; // DEFINED BELOW 188 inline subtype_iterator subtype_end() const; // DEFINED BELOW 189 190 /// getContainedType - This method is used to implement the type iterator 191 /// (defined a the end of the file). For derived types, this returns the 192 /// types 'contained' in the derived type, returning 0 when 'i' becomes 193 /// invalid. This allows the user to iterate over the types in a struct, for 194 /// example, really easily. 195 /// 196 virtual const Type *getContainedType(unsigned i) const { return 0; } 197 198 /// getNumContainedTypes - Return the number of types in the derived type 199 virtual unsigned getNumContainedTypes() const { return 0; } 200 201 //===--------------------------------------------------------------------===// 202 // Static members exported by the Type class itself. Useful for getting 203 // instances of Type. 204 // 205 206 /// getPrimitiveType/getUniqueIDType - Return a type based on an identifier. 207 static const Type *getPrimitiveType(PrimitiveID IDNumber); 208 static const Type *getUniqueIDType(unsigned UID); 209 210 //===--------------------------------------------------------------------===// 211 // These are the builtin types that are always available... 212 // 213 static Type *VoidTy , *BoolTy; 214 static Type *SByteTy, *UByteTy, 215 *ShortTy, *UShortTy, 216 *IntTy , *UIntTy, 217 *LongTy , *ULongTy; 218 static Type *FloatTy, *DoubleTy; 219 220 static Type *TypeTy , *LabelTy; 221 222 /// Methods for support type inquiry through isa, cast, and dyn_cast: 223 static inline bool classof(const Type *T) { return true; } 224 static inline bool classof(const Value *V) { 225 return V->getValueType() == Value::TypeVal; 226 } 227 228#include "llvm/Type.def" 229 230private: 231 class TypeIterator : public bidirectional_iterator<const Type, ptrdiff_t> { 232 const Type * const Ty; 233 unsigned Idx; 234 235 typedef TypeIterator _Self; 236 public: 237 inline TypeIterator(const Type *ty, unsigned idx) : Ty(ty), Idx(idx) {} 238 inline ~TypeIterator() {} 239 240 inline bool operator==(const _Self& x) const { return Idx == x.Idx; } 241 inline bool operator!=(const _Self& x) const { return !operator==(x); } 242 243 inline pointer operator*() const { return Ty->getContainedType(Idx); } 244 inline pointer operator->() const { return operator*(); } 245 246 inline _Self& operator++() { ++Idx; return *this; } // Preincrement 247 inline _Self operator++(int) { // Postincrement 248 _Self tmp = *this; ++*this; return tmp; 249 } 250 251 inline _Self& operator--() { --Idx; return *this; } // Predecrement 252 inline _Self operator--(int) { // Postdecrement 253 _Self tmp = *this; --*this; return tmp; 254 } 255 }; 256}; 257 258inline Type::TypeIterator Type::subtype_begin() const { 259 return TypeIterator(this, 0); 260} 261 262inline Type::TypeIterator Type::subtype_end() const { 263 return TypeIterator(this, getNumContainedTypes()); 264} 265 266 267// Provide specializations of GraphTraits to be able to treat a type as a 268// graph of sub types... 269 270template <> struct GraphTraits<Type*> { 271 typedef Type NodeType; 272 typedef Type::subtype_iterator ChildIteratorType; 273 274 static inline NodeType *getEntryNode(Type *T) { return T; } 275 static inline ChildIteratorType child_begin(NodeType *N) { 276 return N->subtype_begin(); 277 } 278 static inline ChildIteratorType child_end(NodeType *N) { 279 return N->subtype_end(); 280 } 281}; 282 283template <> struct GraphTraits<const Type*> { 284 typedef const Type NodeType; 285 typedef Type::subtype_iterator ChildIteratorType; 286 287 static inline NodeType *getEntryNode(const Type *T) { return T; } 288 static inline ChildIteratorType child_begin(NodeType *N) { 289 return N->subtype_begin(); 290 } 291 static inline ChildIteratorType child_end(NodeType *N) { 292 return N->subtype_end(); 293 } 294}; 295 296template <> inline bool isa_impl<PointerType, Type>(const Type &Ty) { 297 return Ty.getPrimitiveID() == Type::PointerTyID; 298} 299 300#endif 301