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" 19using namespace llvm; 20 21//===----------------------------------------------------------------------===// 22// Type Class Implementation 23//===----------------------------------------------------------------------===// 24 25Type *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. 43Type *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. 50bool 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/// 57bool 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/// 67bool 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// 80bool 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 113bool 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 132unsigned 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. 149unsigned 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. 156int 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. 171bool 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 200Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; } 201Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; } 202Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; } 203Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; } 204Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; } 205Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } 206Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } 207Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } 208Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } 209 210IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } 211IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } 212IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; } 213IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; } 214IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; } 215 216IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) { 217 return IntegerType::get(C, N); 218} 219 220PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) { 221 return getFloatTy(C)->getPointerTo(AS); 222} 223 224PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) { 225 return getDoubleTy(C)->getPointerTo(AS); 226} 227 228PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) { 229 return getX86_FP80Ty(C)->getPointerTo(AS); 230} 231 232PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) { 233 return getFP128Ty(C)->getPointerTo(AS); 234} 235 236PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) { 237 return getPPC_FP128Ty(C)->getPointerTo(AS); 238} 239 240PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) { 241 return getX86_MMXTy(C)->getPointerTo(AS); 242} 243 244PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) { 245 return getIntNTy(C, N)->getPointerTo(AS); 246} 247 248PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) { 249 return getInt1Ty(C)->getPointerTo(AS); 250} 251 252PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) { 253 return getInt8Ty(C)->getPointerTo(AS); 254} 255 256PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) { 257 return getInt16Ty(C)->getPointerTo(AS); 258} 259 260PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) { 261 return getInt32Ty(C)->getPointerTo(AS); 262} 263 264PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) { 265 return getInt64Ty(C)->getPointerTo(AS); 266} 267 268 269//===----------------------------------------------------------------------===// 270// IntegerType Implementation 271//===----------------------------------------------------------------------===// 272 273IntegerType *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 296bool IntegerType::isPowerOf2ByteWidth() const { 297 unsigned BitWidth = getBitWidth(); 298 return (BitWidth > 7) && isPowerOf2_32(BitWidth); 299} 300 301APInt IntegerType::getMask() const { 302 return APInt::getAllOnesValue(getBitWidth()); 303} 304 305//===----------------------------------------------------------------------===// 306// FunctionType Implementation 307//===----------------------------------------------------------------------===// 308 309FunctionType::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. 329FunctionType *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 354FunctionType *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. 361bool 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. 368bool FunctionType::isValidArgumentType(Type *ArgTy) { 369 return ArgTy->isFirstClassType(); 370} 371 372//===----------------------------------------------------------------------===// 373// StructType Implementation 374//===----------------------------------------------------------------------===// 375 376// Primitive Constructors. 377 378StructType *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 400void 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 415void 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 457StructType *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 464StructType *StructType::get(LLVMContext &Context, bool isPacked) { 465 return get(Context, llvm::ArrayRef<Type*>(), isPacked); 466} 467 468StructType *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 481StructType *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 488StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) { 489 return create(Context, Elements, StringRef()); 490} 491 492StructType *StructType::create(LLVMContext &Context) { 493 return create(Context, StringRef()); 494} 495 496 497StructType *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 504StructType *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 510StructType *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 524StringRef 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 531void 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 543bool 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. 550bool 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. 563StructType *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 576Type *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} 585Type *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} 593bool 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 606bool 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 618ArrayType::ArrayType(Type *ElType, uint64_t NumEl) 619 : SequentialType(ArrayTyID, ElType) { 620 NumElements = NumEl; 621} 622 623 624ArrayType *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 637bool ArrayType::isValidElementType(Type *ElemTy) { 638 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 639 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy(); 640} 641 642//===----------------------------------------------------------------------===// 643// VectorType Implementation 644//===----------------------------------------------------------------------===// 645 646VectorType::VectorType(Type *ElType, unsigned NumEl) 647 : SequentialType(VectorTyID, ElType) { 648 NumElements = NumEl; 649} 650 651VectorType *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 666bool VectorType::isValidElementType(Type *ElemTy) { 667 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy(); 668} 669 670//===----------------------------------------------------------------------===// 671// PointerType Implementation 672//===----------------------------------------------------------------------===// 673 674PointerType *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 690PointerType::PointerType(Type *E, unsigned AddrSpace) 691 : SequentialType(PointerTyID, E) { 692 setSubclassData(AddrSpace); 693} 694 695PointerType *Type::getPointerTo(unsigned addrs) { 696 return PointerType::get(this, addrs); 697} 698 699bool PointerType::isValidElementType(Type *ElemTy) { 700 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 701 !ElemTy->isMetadataTy(); 702} 703