1 //===-- llvm/DerivedTypes.h - Classes for handling data types ---*- 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 contains the declarations of classes that represent "derived 11 // types". These are things like "arrays of x" or "structure of x, y, z" or 12 // "function returning x taking (y,z) as parameters", etc... 13 // 14 // The implementations of these classes live in the Type.cpp file. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #ifndef LLVM_DERIVED_TYPES_H 19 #define LLVM_DERIVED_TYPES_H 20 21 #include "llvm/Type.h" 22 #include "llvm/Support/DataTypes.h" 23 24 namespace llvm { 25 26 class Value; 27 class APInt; 28 class LLVMContext; 29 template<typename T> class ArrayRef; 30 class StringRef; 31 32 /// Class to represent integer types. Note that this class is also used to 33 /// represent the built-in integer types: Int1Ty, Int8Ty, Int16Ty, Int32Ty and 34 /// Int64Ty. 35 /// @brief Integer representation type 36 class IntegerType : public Type { 37 friend class LLVMContextImpl; 38 39 protected: 40 explicit IntegerType(LLVMContext &C, unsigned NumBits) : Type(C, IntegerTyID){ 41 setSubclassData(NumBits); 42 } 43 public: 44 /// This enum is just used to hold constants we need for IntegerType. 45 enum { 46 MIN_INT_BITS = 1, ///< Minimum number of bits that can be specified 47 MAX_INT_BITS = (1<<23)-1 ///< Maximum number of bits that can be specified 48 ///< Note that bit width is stored in the Type classes SubclassData field 49 ///< which has 23 bits. This yields a maximum bit width of 8,388,607 bits. 50 }; 51 52 /// This static method is the primary way of constructing an IntegerType. 53 /// If an IntegerType with the same NumBits value was previously instantiated, 54 /// that instance will be returned. Otherwise a new one will be created. Only 55 /// one instance with a given NumBits value is ever created. 56 /// @brief Get or create an IntegerType instance. 57 static IntegerType *get(LLVMContext &C, unsigned NumBits); 58 59 /// @brief Get the number of bits in this IntegerType 60 unsigned getBitWidth() const { return getSubclassData(); } 61 62 /// getBitMask - Return a bitmask with ones set for all of the bits 63 /// that can be set by an unsigned version of this type. This is 0xFF for 64 /// i8, 0xFFFF for i16, etc. 65 uint64_t getBitMask() const { 66 return ~uint64_t(0UL) >> (64-getBitWidth()); 67 } 68 69 /// getSignBit - Return a uint64_t with just the most significant bit set (the 70 /// sign bit, if the value is treated as a signed number). 71 uint64_t getSignBit() const { 72 return 1ULL << (getBitWidth()-1); 73 } 74 75 /// For example, this is 0xFF for an 8 bit integer, 0xFFFF for i16, etc. 76 /// @returns a bit mask with ones set for all the bits of this type. 77 /// @brief Get a bit mask for this type. 78 APInt getMask() const; 79 80 /// This method determines if the width of this IntegerType is a power-of-2 81 /// in terms of 8 bit bytes. 82 /// @returns true if this is a power-of-2 byte width. 83 /// @brief Is this a power-of-2 byte-width IntegerType ? 84 bool isPowerOf2ByteWidth() const; 85 86 // Methods for support type inquiry through isa, cast, and dyn_cast. 87 static inline bool classof(const IntegerType *) { return true; } 88 static inline bool classof(const Type *T) { 89 return T->getTypeID() == IntegerTyID; 90 } 91 }; 92 93 94 /// FunctionType - Class to represent function types 95 /// 96 class FunctionType : public Type { 97 FunctionType(const FunctionType &); // Do not implement 98 const FunctionType &operator=(const FunctionType &); // Do not implement 99 FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs); 100 101 public: 102 /// FunctionType::get - This static method is the primary way of constructing 103 /// a FunctionType. 104 /// 105 static FunctionType *get(Type *Result, 106 ArrayRef<Type*> Params, bool isVarArg); 107 108 /// FunctionType::get - Create a FunctionType taking no parameters. 109 /// 110 static FunctionType *get(Type *Result, bool isVarArg); 111 112 /// isValidReturnType - Return true if the specified type is valid as a return 113 /// type. 114 static bool isValidReturnType(Type *RetTy); 115 116 /// isValidArgumentType - Return true if the specified type is valid as an 117 /// argument type. 118 static bool isValidArgumentType(Type *ArgTy); 119 120 bool isVarArg() const { return getSubclassData(); } 121 Type *getReturnType() const { return ContainedTys[0]; } 122 123 typedef Type::subtype_iterator param_iterator; 124 param_iterator param_begin() const { return ContainedTys + 1; } 125 param_iterator param_end() const { return &ContainedTys[NumContainedTys]; } 126 127 // Parameter type accessors. 128 Type *getParamType(unsigned i) const { return ContainedTys[i+1]; } 129 130 /// getNumParams - Return the number of fixed parameters this function type 131 /// requires. This does not consider varargs. 132 /// 133 unsigned getNumParams() const { return NumContainedTys - 1; } 134 135 // Methods for support type inquiry through isa, cast, and dyn_cast. 136 static inline bool classof(const FunctionType *) { return true; } 137 static inline bool classof(const Type *T) { 138 return T->getTypeID() == FunctionTyID; 139 } 140 }; 141 142 143 /// CompositeType - Common super class of ArrayType, StructType, PointerType 144 /// and VectorType. 145 class CompositeType : public Type { 146 protected: 147 explicit CompositeType(LLVMContext &C, TypeID tid) : Type(C, tid) { } 148 public: 149 150 /// getTypeAtIndex - Given an index value into the type, return the type of 151 /// the element. 152 /// 153 Type *getTypeAtIndex(const Value *V); 154 Type *getTypeAtIndex(unsigned Idx); 155 bool indexValid(const Value *V) const; 156 bool indexValid(unsigned Idx) const; 157 158 // Methods for support type inquiry through isa, cast, and dyn_cast. 159 static inline bool classof(const CompositeType *) { return true; } 160 static inline bool classof(const Type *T) { 161 return T->getTypeID() == ArrayTyID || 162 T->getTypeID() == StructTyID || 163 T->getTypeID() == PointerTyID || 164 T->getTypeID() == VectorTyID; 165 } 166 }; 167 168 169 /// StructType - Class to represent struct types. There are two different kinds 170 /// of struct types: Literal structs and Identified structs. 171 /// 172 /// Literal struct types (e.g. { i32, i32 }) are uniqued structurally, and must 173 /// always have a body when created. You can get one of these by using one of 174 /// the StructType::get() forms. 175 /// 176 /// Identified structs (e.g. %foo or %42) may optionally have a name and are not 177 /// uniqued. The names for identified structs are managed at the LLVMContext 178 /// level, so there can only be a single identified struct with a given name in 179 /// a particular LLVMContext. Identified structs may also optionally be opaque 180 /// (have no body specified). You get one of these by using one of the 181 /// StructType::create() forms. 182 /// 183 /// Independent of what kind of struct you have, the body of a struct type are 184 /// laid out in memory consequtively with the elements directly one after the 185 /// other (if the struct is packed) or (if not packed) with padding between the 186 /// elements as defined by TargetData (which is required to match what the code 187 /// generator for a target expects). 188 /// 189 class StructType : public CompositeType { 190 StructType(const StructType &); // Do not implement 191 const StructType &operator=(const StructType &); // Do not implement 192 StructType(LLVMContext &C) 193 : CompositeType(C, StructTyID), SymbolTableEntry(0) {} 194 enum { 195 // This is the contents of the SubClassData field. 196 SCDB_HasBody = 1, 197 SCDB_Packed = 2, 198 SCDB_IsLiteral = 4 199 }; 200 201 /// SymbolTableEntry - For a named struct that actually has a name, this is a 202 /// pointer to the symbol table entry (maintained by LLVMContext) for the 203 /// struct. This is null if the type is an literal struct or if it is 204 /// a identified type that has an empty name. 205 /// 206 void *SymbolTableEntry; 207 public: 208 ~StructType() { 209 delete [] ContainedTys; // Delete the body. 210 } 211 212 /// StructType::create - This creates an identified struct. 213 static StructType *create(LLVMContext &Context, StringRef Name); 214 static StructType *create(LLVMContext &Context); 215 216 static StructType *create(ArrayRef<Type*> Elements, 217 StringRef Name, 218 bool isPacked = false); 219 static StructType *create(ArrayRef<Type*> Elements); 220 static StructType *create(LLVMContext &Context, 221 ArrayRef<Type*> Elements, 222 StringRef Name, 223 bool isPacked = false); 224 static StructType *create(LLVMContext &Context, ArrayRef<Type*> Elements); 225 static StructType *create(StringRef Name, Type *elt1, ...) END_WITH_NULL; 226 227 /// StructType::get - This static method is the primary way to create a 228 /// literal StructType. 229 static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements, 230 bool isPacked = false); 231 232 /// StructType::get - Create an empty structure type. 233 /// 234 static StructType *get(LLVMContext &Context, bool isPacked = false); 235 236 /// StructType::get - This static method is a convenience method for creating 237 /// structure types by specifying the elements as arguments. Note that this 238 /// method always returns a non-packed struct, and requires at least one 239 /// element type. 240 static StructType *get(Type *elt1, ...) END_WITH_NULL; 241 242 bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; } 243 244 /// isLiteral - Return true if this type is uniqued by structural 245 /// equivalence, false if it is a struct definition. 246 bool isLiteral() const { return (getSubclassData() & SCDB_IsLiteral) != 0; } 247 248 /// isOpaque - Return true if this is a type with an identity that has no body 249 /// specified yet. These prints as 'opaque' in .ll files. 250 bool isOpaque() const { return (getSubclassData() & SCDB_HasBody) == 0; } 251 252 /// hasName - Return true if this is a named struct that has a non-empty name. 253 bool hasName() const { return SymbolTableEntry != 0; } 254 255 /// getName - Return the name for this struct type if it has an identity. 256 /// This may return an empty string for an unnamed struct type. Do not call 257 /// this on an literal type. 258 StringRef getName() const; 259 260 /// setName - Change the name of this type to the specified name, or to a name 261 /// with a suffix if there is a collision. Do not call this on an literal 262 /// type. 263 void setName(StringRef Name); 264 265 /// setBody - Specify a body for an opaque identified type. 266 void setBody(ArrayRef<Type*> Elements, bool isPacked = false); 267 void setBody(Type *elt1, ...) END_WITH_NULL; 268 269 /// isValidElementType - Return true if the specified type is valid as a 270 /// element type. 271 static bool isValidElementType(Type *ElemTy); 272 273 274 // Iterator access to the elements. 275 typedef Type::subtype_iterator element_iterator; 276 element_iterator element_begin() const { return ContainedTys; } 277 element_iterator element_end() const { return &ContainedTys[NumContainedTys];} 278 279 /// isLayoutIdentical - Return true if this is layout identical to the 280 /// specified struct. 281 bool isLayoutIdentical(StructType *Other) const; 282 283 // Random access to the elements 284 unsigned getNumElements() const { return NumContainedTys; } 285 Type *getElementType(unsigned N) const { 286 assert(N < NumContainedTys && "Element number out of range!"); 287 return ContainedTys[N]; 288 } 289 290 // Methods for support type inquiry through isa, cast, and dyn_cast. 291 static inline bool classof(const StructType *) { return true; } 292 static inline bool classof(const Type *T) { 293 return T->getTypeID() == StructTyID; 294 } 295 }; 296 297 /// SequentialType - This is the superclass of the array, pointer and vector 298 /// type classes. All of these represent "arrays" in memory. The array type 299 /// represents a specifically sized array, pointer types are unsized/unknown 300 /// size arrays, vector types represent specifically sized arrays that 301 /// allow for use of SIMD instructions. SequentialType holds the common 302 /// features of all, which stem from the fact that all three lay their 303 /// components out in memory identically. 304 /// 305 class SequentialType : public CompositeType { 306 Type *ContainedType; ///< Storage for the single contained type. 307 SequentialType(const SequentialType &); // Do not implement! 308 const SequentialType &operator=(const SequentialType &); // Do not implement! 309 310 protected: 311 SequentialType(TypeID TID, Type *ElType) 312 : CompositeType(ElType->getContext(), TID), ContainedType(ElType) { 313 ContainedTys = &ContainedType; 314 NumContainedTys = 1; 315 } 316 317 public: 318 Type *getElementType() const { return ContainedTys[0]; } 319 320 // Methods for support type inquiry through isa, cast, and dyn_cast. 321 static inline bool classof(const SequentialType *) { return true; } 322 static inline bool classof(const Type *T) { 323 return T->getTypeID() == ArrayTyID || 324 T->getTypeID() == PointerTyID || 325 T->getTypeID() == VectorTyID; 326 } 327 }; 328 329 330 /// ArrayType - Class to represent array types. 331 /// 332 class ArrayType : public SequentialType { 333 uint64_t NumElements; 334 335 ArrayType(const ArrayType &); // Do not implement 336 const ArrayType &operator=(const ArrayType &); // Do not implement 337 ArrayType(Type *ElType, uint64_t NumEl); 338 public: 339 /// ArrayType::get - This static method is the primary way to construct an 340 /// ArrayType 341 /// 342 static ArrayType *get(Type *ElementType, uint64_t NumElements); 343 344 /// isValidElementType - Return true if the specified type is valid as a 345 /// element type. 346 static bool isValidElementType(Type *ElemTy); 347 348 uint64_t getNumElements() const { return NumElements; } 349 350 // Methods for support type inquiry through isa, cast, and dyn_cast. 351 static inline bool classof(const ArrayType *) { return true; } 352 static inline bool classof(const Type *T) { 353 return T->getTypeID() == ArrayTyID; 354 } 355 }; 356 357 /// VectorType - Class to represent vector types. 358 /// 359 class VectorType : public SequentialType { 360 unsigned NumElements; 361 362 VectorType(const VectorType &); // Do not implement 363 const VectorType &operator=(const VectorType &); // Do not implement 364 VectorType(Type *ElType, unsigned NumEl); 365 public: 366 /// VectorType::get - This static method is the primary way to construct an 367 /// VectorType. 368 /// 369 static VectorType *get(Type *ElementType, unsigned NumElements); 370 371 /// VectorType::getInteger - This static method gets a VectorType with the 372 /// same number of elements as the input type, and the element type is an 373 /// integer type of the same width as the input element type. 374 /// 375 static VectorType *getInteger(VectorType *VTy) { 376 unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits(); 377 Type *EltTy = IntegerType::get(VTy->getContext(), EltBits); 378 return VectorType::get(EltTy, VTy->getNumElements()); 379 } 380 381 /// VectorType::getExtendedElementVectorType - This static method is like 382 /// getInteger except that the element types are twice as wide as the 383 /// elements in the input type. 384 /// 385 static VectorType *getExtendedElementVectorType(VectorType *VTy) { 386 unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits(); 387 Type *EltTy = IntegerType::get(VTy->getContext(), EltBits * 2); 388 return VectorType::get(EltTy, VTy->getNumElements()); 389 } 390 391 /// VectorType::getTruncatedElementVectorType - This static method is like 392 /// getInteger except that the element types are half as wide as the 393 /// elements in the input type. 394 /// 395 static VectorType *getTruncatedElementVectorType(VectorType *VTy) { 396 unsigned EltBits = VTy->getElementType()->getPrimitiveSizeInBits(); 397 assert((EltBits & 1) == 0 && 398 "Cannot truncate vector element with odd bit-width"); 399 Type *EltTy = IntegerType::get(VTy->getContext(), EltBits / 2); 400 return VectorType::get(EltTy, VTy->getNumElements()); 401 } 402 403 /// isValidElementType - Return true if the specified type is valid as a 404 /// element type. 405 static bool isValidElementType(Type *ElemTy); 406 407 /// @brief Return the number of elements in the Vector type. 408 unsigned getNumElements() const { return NumElements; } 409 410 /// @brief Return the number of bits in the Vector type. 411 unsigned getBitWidth() const { 412 return NumElements * getElementType()->getPrimitiveSizeInBits(); 413 } 414 415 // Methods for support type inquiry through isa, cast, and dyn_cast. 416 static inline bool classof(const VectorType *) { return true; } 417 static inline bool classof(const Type *T) { 418 return T->getTypeID() == VectorTyID; 419 } 420 }; 421 422 423 /// PointerType - Class to represent pointers. 424 /// 425 class PointerType : public SequentialType { 426 PointerType(const PointerType &); // Do not implement 427 const PointerType &operator=(const PointerType &); // Do not implement 428 explicit PointerType(Type *ElType, unsigned AddrSpace); 429 public: 430 /// PointerType::get - This constructs a pointer to an object of the specified 431 /// type in a numbered address space. 432 static PointerType *get(Type *ElementType, unsigned AddressSpace); 433 434 /// PointerType::getUnqual - This constructs a pointer to an object of the 435 /// specified type in the generic address space (address space zero). 436 static PointerType *getUnqual(Type *ElementType) { 437 return PointerType::get(ElementType, 0); 438 } 439 440 /// isValidElementType - Return true if the specified type is valid as a 441 /// element type. 442 static bool isValidElementType(Type *ElemTy); 443 444 /// @brief Return the address space of the Pointer type. 445 inline unsigned getAddressSpace() const { return getSubclassData(); } 446 447 // Implement support type inquiry through isa, cast, and dyn_cast. 448 static inline bool classof(const PointerType *) { return true; } 449 static inline bool classof(const Type *T) { 450 return T->getTypeID() == PointerTyID; 451 } 452 }; 453 454 } // End llvm namespace 455 456 #endif 457