1 //===-- Type.cpp - Implement the Type class -------------------------------===// 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 implements the Type class for the VMCore library. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "LLVMContextImpl.h" 15 #include "llvm/Module.h" 16 #include <algorithm> 17 #include <cstdarg> 18 #include "llvm/ADT/SmallString.h" 19 using namespace llvm; 20 21 //===----------------------------------------------------------------------===// 22 // Type Class Implementation 23 //===----------------------------------------------------------------------===// 24 25 Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) { 26 switch (IDNumber) { 27 case VoidTyID : return getVoidTy(C); 28 case FloatTyID : return getFloatTy(C); 29 case DoubleTyID : return getDoubleTy(C); 30 case X86_FP80TyID : return getX86_FP80Ty(C); 31 case FP128TyID : return getFP128Ty(C); 32 case PPC_FP128TyID : return getPPC_FP128Ty(C); 33 case LabelTyID : return getLabelTy(C); 34 case MetadataTyID : return getMetadataTy(C); 35 case X86_MMXTyID : return getX86_MMXTy(C); 36 default: 37 return 0; 38 } 39 } 40 41 /// getScalarType - If this is a vector type, return the element type, 42 /// otherwise return this. 43 Type *Type::getScalarType() { 44 if (VectorType *VTy = dyn_cast<VectorType>(this)) 45 return VTy->getElementType(); 46 return this; 47 } 48 49 /// isIntegerTy - Return true if this is an IntegerType of the specified width. 50 bool Type::isIntegerTy(unsigned Bitwidth) const { 51 return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth; 52 } 53 54 /// isIntOrIntVectorTy - Return true if this is an integer type or a vector of 55 /// integer types. 56 /// 57 bool Type::isIntOrIntVectorTy() const { 58 if (isIntegerTy()) 59 return true; 60 if (ID != Type::VectorTyID) return false; 61 62 return cast<VectorType>(this)->getElementType()->isIntegerTy(); 63 } 64 65 /// isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP types. 66 /// 67 bool Type::isFPOrFPVectorTy() const { 68 if (ID == Type::FloatTyID || ID == Type::DoubleTyID || 69 ID == Type::FP128TyID || ID == Type::X86_FP80TyID || 70 ID == Type::PPC_FP128TyID) 71 return true; 72 if (ID != Type::VectorTyID) return false; 73 74 return cast<VectorType>(this)->getElementType()->isFloatingPointTy(); 75 } 76 77 // canLosslesslyBitCastTo - Return true if this type can be converted to 78 // 'Ty' without any reinterpretation of bits. For example, i8* to i32*. 79 // 80 bool Type::canLosslesslyBitCastTo(Type *Ty) const { 81 // Identity cast means no change so return true 82 if (this == Ty) 83 return true; 84 85 // They are not convertible unless they are at least first class types 86 if (!this->isFirstClassType() || !Ty->isFirstClassType()) 87 return false; 88 89 // Vector -> Vector conversions are always lossless if the two vector types 90 // have the same size, otherwise not. Also, 64-bit vector types can be 91 // converted to x86mmx. 92 if (const VectorType *thisPTy = dyn_cast<VectorType>(this)) { 93 if (const VectorType *thatPTy = dyn_cast<VectorType>(Ty)) 94 return thisPTy->getBitWidth() == thatPTy->getBitWidth(); 95 if (Ty->getTypeID() == Type::X86_MMXTyID && 96 thisPTy->getBitWidth() == 64) 97 return true; 98 } 99 100 if (this->getTypeID() == Type::X86_MMXTyID) 101 if (const VectorType *thatPTy = dyn_cast<VectorType>(Ty)) 102 if (thatPTy->getBitWidth() == 64) 103 return true; 104 105 // At this point we have only various mismatches of the first class types 106 // remaining and ptr->ptr. Just select the lossless conversions. Everything 107 // else is not lossless. 108 if (this->isPointerTy()) 109 return Ty->isPointerTy(); 110 return false; // Other types have no identity values 111 } 112 113 bool Type::isEmptyTy() const { 114 const ArrayType *ATy = dyn_cast<ArrayType>(this); 115 if (ATy) { 116 unsigned NumElements = ATy->getNumElements(); 117 return NumElements == 0 || ATy->getElementType()->isEmptyTy(); 118 } 119 120 const StructType *STy = dyn_cast<StructType>(this); 121 if (STy) { 122 unsigned NumElements = STy->getNumElements(); 123 for (unsigned i = 0; i < NumElements; ++i) 124 if (!STy->getElementType(i)->isEmptyTy()) 125 return false; 126 return true; 127 } 128 129 return false; 130 } 131 132 unsigned Type::getPrimitiveSizeInBits() const { 133 switch (getTypeID()) { 134 case Type::FloatTyID: return 32; 135 case Type::DoubleTyID: return 64; 136 case Type::X86_FP80TyID: return 80; 137 case Type::FP128TyID: return 128; 138 case Type::PPC_FP128TyID: return 128; 139 case Type::X86_MMXTyID: return 64; 140 case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth(); 141 case Type::VectorTyID: return cast<VectorType>(this)->getBitWidth(); 142 default: return 0; 143 } 144 } 145 146 /// getScalarSizeInBits - If this is a vector type, return the 147 /// getPrimitiveSizeInBits value for the element type. Otherwise return the 148 /// getPrimitiveSizeInBits value for this type. 149 unsigned Type::getScalarSizeInBits() { 150 return getScalarType()->getPrimitiveSizeInBits(); 151 } 152 153 /// getFPMantissaWidth - Return the width of the mantissa of this type. This 154 /// is only valid on floating point types. If the FP type does not 155 /// have a stable mantissa (e.g. ppc long double), this method returns -1. 156 int Type::getFPMantissaWidth() const { 157 if (const VectorType *VTy = dyn_cast<VectorType>(this)) 158 return VTy->getElementType()->getFPMantissaWidth(); 159 assert(isFloatingPointTy() && "Not a floating point type!"); 160 if (ID == FloatTyID) return 24; 161 if (ID == DoubleTyID) return 53; 162 if (ID == X86_FP80TyID) return 64; 163 if (ID == FP128TyID) return 113; 164 assert(ID == PPC_FP128TyID && "unknown fp type"); 165 return -1; 166 } 167 168 /// isSizedDerivedType - Derived types like structures and arrays are sized 169 /// iff all of the members of the type are sized as well. Since asking for 170 /// their size is relatively uncommon, move this operation out of line. 171 bool Type::isSizedDerivedType() const { 172 if (this->isIntegerTy()) 173 return true; 174 175 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 176 return ATy->getElementType()->isSized(); 177 178 if (const VectorType *VTy = dyn_cast<VectorType>(this)) 179 return VTy->getElementType()->isSized(); 180 181 if (!this->isStructTy()) 182 return false; 183 184 // Opaque structs have no size. 185 if (cast<StructType>(this)->isOpaque()) 186 return false; 187 188 // Okay, our struct is sized if all of the elements are. 189 for (subtype_iterator I = subtype_begin(), E = subtype_end(); I != E; ++I) 190 if (!(*I)->isSized()) 191 return false; 192 193 return true; 194 } 195 196 //===----------------------------------------------------------------------===// 197 // Primitive 'Type' data 198 //===----------------------------------------------------------------------===// 199 200 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; } 201 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; } 202 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; } 203 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; } 204 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; } 205 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } 206 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } 207 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } 208 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } 209 210 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } 211 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } 212 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; } 213 IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; } 214 IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; } 215 216 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) { 217 return IntegerType::get(C, N); 218 } 219 220 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) { 221 return getFloatTy(C)->getPointerTo(AS); 222 } 223 224 PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) { 225 return getDoubleTy(C)->getPointerTo(AS); 226 } 227 228 PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) { 229 return getX86_FP80Ty(C)->getPointerTo(AS); 230 } 231 232 PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) { 233 return getFP128Ty(C)->getPointerTo(AS); 234 } 235 236 PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) { 237 return getPPC_FP128Ty(C)->getPointerTo(AS); 238 } 239 240 PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) { 241 return getX86_MMXTy(C)->getPointerTo(AS); 242 } 243 244 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) { 245 return getIntNTy(C, N)->getPointerTo(AS); 246 } 247 248 PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) { 249 return getInt1Ty(C)->getPointerTo(AS); 250 } 251 252 PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) { 253 return getInt8Ty(C)->getPointerTo(AS); 254 } 255 256 PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) { 257 return getInt16Ty(C)->getPointerTo(AS); 258 } 259 260 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) { 261 return getInt32Ty(C)->getPointerTo(AS); 262 } 263 264 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) { 265 return getInt64Ty(C)->getPointerTo(AS); 266 } 267 268 269 //===----------------------------------------------------------------------===// 270 // IntegerType Implementation 271 //===----------------------------------------------------------------------===// 272 273 IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) { 274 assert(NumBits >= MIN_INT_BITS && "bitwidth too small"); 275 assert(NumBits <= MAX_INT_BITS && "bitwidth too large"); 276 277 // Check for the built-in integer types 278 switch (NumBits) { 279 case 1: return cast<IntegerType>(Type::getInt1Ty(C)); 280 case 8: return cast<IntegerType>(Type::getInt8Ty(C)); 281 case 16: return cast<IntegerType>(Type::getInt16Ty(C)); 282 case 32: return cast<IntegerType>(Type::getInt32Ty(C)); 283 case 64: return cast<IntegerType>(Type::getInt64Ty(C)); 284 default: 285 break; 286 } 287 288 IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits]; 289 290 if (Entry == 0) 291 Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits); 292 293 return Entry; 294 } 295 296 bool IntegerType::isPowerOf2ByteWidth() const { 297 unsigned BitWidth = getBitWidth(); 298 return (BitWidth > 7) && isPowerOf2_32(BitWidth); 299 } 300 301 APInt IntegerType::getMask() const { 302 return APInt::getAllOnesValue(getBitWidth()); 303 } 304 305 //===----------------------------------------------------------------------===// 306 // FunctionType Implementation 307 //===----------------------------------------------------------------------===// 308 309 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params, 310 bool IsVarArgs) 311 : Type(Result->getContext(), FunctionTyID) { 312 Type **SubTys = reinterpret_cast<Type**>(this+1); 313 assert(isValidReturnType(Result) && "invalid return type for function"); 314 setSubclassData(IsVarArgs); 315 316 SubTys[0] = const_cast<Type*>(Result); 317 318 for (unsigned i = 0, e = Params.size(); i != e; ++i) { 319 assert(isValidArgumentType(Params[i]) && 320 "Not a valid type for function argument!"); 321 SubTys[i+1] = Params[i]; 322 } 323 324 ContainedTys = SubTys; 325 NumContainedTys = Params.size() + 1; // + 1 for result type 326 } 327 328 // FunctionType::get - The factory function for the FunctionType class. 329 FunctionType *FunctionType::get(Type *ReturnType, 330 ArrayRef<Type*> Params, bool isVarArg) { 331 // TODO: This is brutally slow. 332 std::vector<Type*> Key; 333 Key.reserve(Params.size()+2); 334 Key.push_back(const_cast<Type*>(ReturnType)); 335 for (unsigned i = 0, e = Params.size(); i != e; ++i) 336 Key.push_back(const_cast<Type*>(Params[i])); 337 if (isVarArg) 338 Key.push_back(0); 339 340 LLVMContextImpl *pImpl = ReturnType->getContext().pImpl; 341 FunctionType *&FT = pImpl->FunctionTypes[Key]; 342 343 if (FT == 0) { 344 FT = (FunctionType*) pImpl->TypeAllocator. 345 Allocate(sizeof(FunctionType) + sizeof(Type*)*(Params.size()+1), 346 AlignOf<FunctionType>::Alignment); 347 new (FT) FunctionType(ReturnType, Params, isVarArg); 348 } 349 350 return FT; 351 } 352 353 354 FunctionType *FunctionType::get(Type *Result, bool isVarArg) { 355 return get(Result, ArrayRef<Type *>(), isVarArg); 356 } 357 358 359 /// isValidReturnType - Return true if the specified type is valid as a return 360 /// type. 361 bool FunctionType::isValidReturnType(Type *RetTy) { 362 return !RetTy->isFunctionTy() && !RetTy->isLabelTy() && 363 !RetTy->isMetadataTy(); 364 } 365 366 /// isValidArgumentType - Return true if the specified type is valid as an 367 /// argument type. 368 bool FunctionType::isValidArgumentType(Type *ArgTy) { 369 return ArgTy->isFirstClassType(); 370 } 371 372 //===----------------------------------------------------------------------===// 373 // StructType Implementation 374 //===----------------------------------------------------------------------===// 375 376 // Primitive Constructors. 377 378 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes, 379 bool isPacked) { 380 // FIXME: std::vector is horribly inefficient for this probe. 381 std::vector<Type*> Key; 382 for (unsigned i = 0, e = ETypes.size(); i != e; ++i) { 383 assert(isValidElementType(ETypes[i]) && 384 "Invalid type for structure element!"); 385 Key.push_back(ETypes[i]); 386 } 387 if (isPacked) 388 Key.push_back(0); 389 390 StructType *&ST = Context.pImpl->AnonStructTypes[Key]; 391 if (ST) return ST; 392 393 // Value not found. Create a new type! 394 ST = new (Context.pImpl->TypeAllocator) StructType(Context); 395 ST->setSubclassData(SCDB_IsLiteral); // Literal struct. 396 ST->setBody(ETypes, isPacked); 397 return ST; 398 } 399 400 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) { 401 assert(isOpaque() && "Struct body already set!"); 402 403 setSubclassData(getSubclassData() | SCDB_HasBody); 404 if (isPacked) 405 setSubclassData(getSubclassData() | SCDB_Packed); 406 407 Type **Elts = getContext().pImpl-> 408 TypeAllocator.Allocate<Type*>(Elements.size()); 409 memcpy(Elts, Elements.data(), sizeof(Elements[0])*Elements.size()); 410 411 ContainedTys = Elts; 412 NumContainedTys = Elements.size(); 413 } 414 415 void StructType::setName(StringRef Name) { 416 if (Name == getName()) return; 417 418 // If this struct already had a name, remove its symbol table entry. 419 if (SymbolTableEntry) { 420 getContext().pImpl->NamedStructTypes.erase(getName()); 421 SymbolTableEntry = 0; 422 } 423 424 // If this is just removing the name, we're done. 425 if (Name.empty()) 426 return; 427 428 // Look up the entry for the name. 429 StringMapEntry<StructType*> *Entry = 430 &getContext().pImpl->NamedStructTypes.GetOrCreateValue(Name); 431 432 // While we have a name collision, try a random rename. 433 if (Entry->getValue()) { 434 SmallString<64> TempStr(Name); 435 TempStr.push_back('.'); 436 raw_svector_ostream TmpStream(TempStr); 437 438 do { 439 TempStr.resize(Name.size()+1); 440 TmpStream.resync(); 441 TmpStream << getContext().pImpl->NamedStructTypesUniqueID++; 442 443 Entry = &getContext().pImpl-> 444 NamedStructTypes.GetOrCreateValue(TmpStream.str()); 445 } while (Entry->getValue()); 446 } 447 448 // Okay, we found an entry that isn't used. It's us! 449 Entry->setValue(this); 450 451 SymbolTableEntry = Entry; 452 } 453 454 //===----------------------------------------------------------------------===// 455 // StructType Helper functions. 456 457 StructType *StructType::create(LLVMContext &Context, StringRef Name) { 458 StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context); 459 if (!Name.empty()) 460 ST->setName(Name); 461 return ST; 462 } 463 464 StructType *StructType::get(LLVMContext &Context, bool isPacked) { 465 return get(Context, llvm::ArrayRef<Type*>(), isPacked); 466 } 467 468 StructType *StructType::get(Type *type, ...) { 469 assert(type != 0 && "Cannot create a struct type with no elements with this"); 470 LLVMContext &Ctx = type->getContext(); 471 va_list ap; 472 SmallVector<llvm::Type*, 8> StructFields; 473 va_start(ap, type); 474 while (type) { 475 StructFields.push_back(type); 476 type = va_arg(ap, llvm::Type*); 477 } 478 return llvm::StructType::get(Ctx, StructFields); 479 } 480 481 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements, 482 StringRef Name, bool isPacked) { 483 StructType *ST = create(Context, Name); 484 ST->setBody(Elements, isPacked); 485 return ST; 486 } 487 488 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) { 489 return create(Context, Elements, StringRef()); 490 } 491 492 StructType *StructType::create(LLVMContext &Context) { 493 return create(Context, StringRef()); 494 } 495 496 497 StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name, 498 bool isPacked) { 499 assert(!Elements.empty() && 500 "This method may not be invoked with an empty list"); 501 return create(Elements[0]->getContext(), Elements, Name, isPacked); 502 } 503 504 StructType *StructType::create(ArrayRef<Type*> Elements) { 505 assert(!Elements.empty() && 506 "This method may not be invoked with an empty list"); 507 return create(Elements[0]->getContext(), Elements, StringRef()); 508 } 509 510 StructType *StructType::create(StringRef Name, Type *type, ...) { 511 assert(type != 0 && "Cannot create a struct type with no elements with this"); 512 LLVMContext &Ctx = type->getContext(); 513 va_list ap; 514 SmallVector<llvm::Type*, 8> StructFields; 515 va_start(ap, type); 516 while (type) { 517 StructFields.push_back(type); 518 type = va_arg(ap, llvm::Type*); 519 } 520 return llvm::StructType::create(Ctx, StructFields, Name); 521 } 522 523 524 StringRef StructType::getName() const { 525 assert(!isLiteral() && "Literal structs never have names"); 526 if (SymbolTableEntry == 0) return StringRef(); 527 528 return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey(); 529 } 530 531 void StructType::setBody(Type *type, ...) { 532 assert(type != 0 && "Cannot create a struct type with no elements with this"); 533 va_list ap; 534 SmallVector<llvm::Type*, 8> StructFields; 535 va_start(ap, type); 536 while (type) { 537 StructFields.push_back(type); 538 type = va_arg(ap, llvm::Type*); 539 } 540 setBody(StructFields); 541 } 542 543 bool StructType::isValidElementType(Type *ElemTy) { 544 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 545 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy(); 546 } 547 548 /// isLayoutIdentical - Return true if this is layout identical to the 549 /// specified struct. 550 bool StructType::isLayoutIdentical(StructType *Other) const { 551 if (this == Other) return true; 552 553 if (isPacked() != Other->isPacked() || 554 getNumElements() != Other->getNumElements()) 555 return false; 556 557 return std::equal(element_begin(), element_end(), Other->element_begin()); 558 } 559 560 561 /// getTypeByName - Return the type with the specified name, or null if there 562 /// is none by that name. 563 StructType *Module::getTypeByName(StringRef Name) const { 564 StringMap<StructType*>::iterator I = 565 getContext().pImpl->NamedStructTypes.find(Name); 566 if (I != getContext().pImpl->NamedStructTypes.end()) 567 return I->second; 568 return 0; 569 } 570 571 572 //===----------------------------------------------------------------------===// 573 // CompositeType Implementation 574 //===----------------------------------------------------------------------===// 575 576 Type *CompositeType::getTypeAtIndex(const Value *V) { 577 if (StructType *STy = dyn_cast<StructType>(this)) { 578 unsigned Idx = (unsigned)cast<ConstantInt>(V)->getZExtValue(); 579 assert(indexValid(Idx) && "Invalid structure index!"); 580 return STy->getElementType(Idx); 581 } 582 583 return cast<SequentialType>(this)->getElementType(); 584 } 585 Type *CompositeType::getTypeAtIndex(unsigned Idx) { 586 if (StructType *STy = dyn_cast<StructType>(this)) { 587 assert(indexValid(Idx) && "Invalid structure index!"); 588 return STy->getElementType(Idx); 589 } 590 591 return cast<SequentialType>(this)->getElementType(); 592 } 593 bool CompositeType::indexValid(const Value *V) const { 594 if (const StructType *STy = dyn_cast<StructType>(this)) { 595 // Structure indexes require 32-bit integer constants. 596 if (V->getType()->isIntegerTy(32)) 597 if (const ConstantInt *CU = dyn_cast<ConstantInt>(V)) 598 return CU->getZExtValue() < STy->getNumElements(); 599 return false; 600 } 601 602 // Sequential types can be indexed by any integer. 603 return V->getType()->isIntegerTy(); 604 } 605 606 bool CompositeType::indexValid(unsigned Idx) const { 607 if (const StructType *STy = dyn_cast<StructType>(this)) 608 return Idx < STy->getNumElements(); 609 // Sequential types can be indexed by any integer. 610 return true; 611 } 612 613 614 //===----------------------------------------------------------------------===// 615 // ArrayType Implementation 616 //===----------------------------------------------------------------------===// 617 618 ArrayType::ArrayType(Type *ElType, uint64_t NumEl) 619 : SequentialType(ArrayTyID, ElType) { 620 NumElements = NumEl; 621 } 622 623 624 ArrayType *ArrayType::get(Type *elementType, uint64_t NumElements) { 625 Type *ElementType = const_cast<Type*>(elementType); 626 assert(isValidElementType(ElementType) && "Invalid type for array element!"); 627 628 LLVMContextImpl *pImpl = ElementType->getContext().pImpl; 629 ArrayType *&Entry = 630 pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)]; 631 632 if (Entry == 0) 633 Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements); 634 return Entry; 635 } 636 637 bool ArrayType::isValidElementType(Type *ElemTy) { 638 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 639 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy(); 640 } 641 642 //===----------------------------------------------------------------------===// 643 // VectorType Implementation 644 //===----------------------------------------------------------------------===// 645 646 VectorType::VectorType(Type *ElType, unsigned NumEl) 647 : SequentialType(VectorTyID, ElType) { 648 NumElements = NumEl; 649 } 650 651 VectorType *VectorType::get(Type *elementType, unsigned NumElements) { 652 Type *ElementType = const_cast<Type*>(elementType); 653 assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0"); 654 assert(isValidElementType(ElementType) && 655 "Elements of a VectorType must be a primitive type"); 656 657 LLVMContextImpl *pImpl = ElementType->getContext().pImpl; 658 VectorType *&Entry = ElementType->getContext().pImpl 659 ->VectorTypes[std::make_pair(ElementType, NumElements)]; 660 661 if (Entry == 0) 662 Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements); 663 return Entry; 664 } 665 666 bool VectorType::isValidElementType(Type *ElemTy) { 667 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy(); 668 } 669 670 //===----------------------------------------------------------------------===// 671 // PointerType Implementation 672 //===----------------------------------------------------------------------===// 673 674 PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) { 675 assert(EltTy && "Can't get a pointer to <null> type!"); 676 assert(isValidElementType(EltTy) && "Invalid type for pointer element!"); 677 678 LLVMContextImpl *CImpl = EltTy->getContext().pImpl; 679 680 // Since AddressSpace #0 is the common case, we special case it. 681 PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy] 682 : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)]; 683 684 if (Entry == 0) 685 Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace); 686 return Entry; 687 } 688 689 690 PointerType::PointerType(Type *E, unsigned AddrSpace) 691 : SequentialType(PointerTyID, E) { 692 setSubclassData(AddrSpace); 693 } 694 695 PointerType *Type::getPointerTo(unsigned addrs) { 696 return PointerType::get(this, addrs); 697 } 698 699 bool PointerType::isValidElementType(Type *ElemTy) { 700 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 701 !ElemTy->isMetadataTy(); 702 } 703