1 //===- Type.cpp - Implement the Type class --------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the Type class for the IR library. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/IR/Type.h" 14 #include "LLVMContextImpl.h" 15 #include "llvm/ADT/APInt.h" 16 #include "llvm/ADT/None.h" 17 #include "llvm/ADT/SmallString.h" 18 #include "llvm/ADT/StringMap.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/IR/Constant.h" 21 #include "llvm/IR/Constants.h" 22 #include "llvm/IR/DerivedTypes.h" 23 #include "llvm/IR/LLVMContext.h" 24 #include "llvm/IR/Module.h" 25 #include "llvm/IR/Value.h" 26 #include "llvm/Support/Casting.h" 27 #include "llvm/Support/MathExtras.h" 28 #include "llvm/Support/TypeSize.h" 29 #include "llvm/Support/raw_ostream.h" 30 #include <cassert> 31 #include <utility> 32 33 using namespace llvm; 34 35 //===----------------------------------------------------------------------===// 36 // Type Class Implementation 37 //===----------------------------------------------------------------------===// 38 39 Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) { 40 switch (IDNumber) { 41 case VoidTyID : return getVoidTy(C); 42 case HalfTyID : return getHalfTy(C); 43 case BFloatTyID : return getBFloatTy(C); 44 case FloatTyID : return getFloatTy(C); 45 case DoubleTyID : return getDoubleTy(C); 46 case X86_FP80TyID : return getX86_FP80Ty(C); 47 case FP128TyID : return getFP128Ty(C); 48 case PPC_FP128TyID : return getPPC_FP128Ty(C); 49 case LabelTyID : return getLabelTy(C); 50 case MetadataTyID : return getMetadataTy(C); 51 case X86_MMXTyID : return getX86_MMXTy(C); 52 case X86_AMXTyID : return getX86_AMXTy(C); 53 case TokenTyID : return getTokenTy(C); 54 default: 55 return nullptr; 56 } 57 } 58 59 bool Type::isIntegerTy(unsigned Bitwidth) const { 60 return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth; 61 } 62 63 bool Type::isOpaquePointerTy() const { 64 if (auto *PTy = dyn_cast<PointerType>(this)) 65 return PTy->isOpaque(); 66 return false; 67 } 68 69 bool Type::canLosslesslyBitCastTo(Type *Ty) const { 70 // Identity cast means no change so return true 71 if (this == Ty) 72 return true; 73 74 // They are not convertible unless they are at least first class types 75 if (!this->isFirstClassType() || !Ty->isFirstClassType()) 76 return false; 77 78 // Vector -> Vector conversions are always lossless if the two vector types 79 // have the same size, otherwise not. 80 if (isa<VectorType>(this) && isa<VectorType>(Ty)) 81 return getPrimitiveSizeInBits() == Ty->getPrimitiveSizeInBits(); 82 83 // 64-bit fixed width vector types can be losslessly converted to x86mmx. 84 if (((isa<FixedVectorType>(this)) && Ty->isX86_MMXTy()) && 85 getPrimitiveSizeInBits().getFixedSize() == 64) 86 return true; 87 if ((isX86_MMXTy() && isa<FixedVectorType>(Ty)) && 88 Ty->getPrimitiveSizeInBits().getFixedSize() == 64) 89 return true; 90 91 // 8192-bit fixed width vector types can be losslessly converted to x86amx. 92 if (((isa<FixedVectorType>(this)) && Ty->isX86_AMXTy()) && 93 getPrimitiveSizeInBits().getFixedSize() == 8192) 94 return true; 95 if ((isX86_AMXTy() && isa<FixedVectorType>(Ty)) && 96 Ty->getPrimitiveSizeInBits().getFixedSize() == 8192) 97 return true; 98 99 // At this point we have only various mismatches of the first class types 100 // remaining and ptr->ptr. Just select the lossless conversions. Everything 101 // else is not lossless. Conservatively assume we can't losslessly convert 102 // between pointers with different address spaces. 103 if (auto *PTy = dyn_cast<PointerType>(this)) { 104 if (auto *OtherPTy = dyn_cast<PointerType>(Ty)) 105 return PTy->getAddressSpace() == OtherPTy->getAddressSpace(); 106 return false; 107 } 108 return false; // Other types have no identity values 109 } 110 111 bool Type::isEmptyTy() const { 112 if (auto *ATy = dyn_cast<ArrayType>(this)) { 113 unsigned NumElements = ATy->getNumElements(); 114 return NumElements == 0 || ATy->getElementType()->isEmptyTy(); 115 } 116 117 if (auto *STy = dyn_cast<StructType>(this)) { 118 unsigned NumElements = STy->getNumElements(); 119 for (unsigned i = 0; i < NumElements; ++i) 120 if (!STy->getElementType(i)->isEmptyTy()) 121 return false; 122 return true; 123 } 124 125 return false; 126 } 127 128 TypeSize Type::getPrimitiveSizeInBits() const { 129 switch (getTypeID()) { 130 case Type::HalfTyID: return TypeSize::Fixed(16); 131 case Type::BFloatTyID: return TypeSize::Fixed(16); 132 case Type::FloatTyID: return TypeSize::Fixed(32); 133 case Type::DoubleTyID: return TypeSize::Fixed(64); 134 case Type::X86_FP80TyID: return TypeSize::Fixed(80); 135 case Type::FP128TyID: return TypeSize::Fixed(128); 136 case Type::PPC_FP128TyID: return TypeSize::Fixed(128); 137 case Type::X86_MMXTyID: return TypeSize::Fixed(64); 138 case Type::X86_AMXTyID: return TypeSize::Fixed(8192); 139 case Type::IntegerTyID: 140 return TypeSize::Fixed(cast<IntegerType>(this)->getBitWidth()); 141 case Type::FixedVectorTyID: 142 case Type::ScalableVectorTyID: { 143 const VectorType *VTy = cast<VectorType>(this); 144 ElementCount EC = VTy->getElementCount(); 145 TypeSize ETS = VTy->getElementType()->getPrimitiveSizeInBits(); 146 assert(!ETS.isScalable() && "Vector type should have fixed-width elements"); 147 return {ETS.getFixedSize() * EC.getKnownMinValue(), EC.isScalable()}; 148 } 149 default: return TypeSize::Fixed(0); 150 } 151 } 152 153 unsigned Type::getScalarSizeInBits() const { 154 // It is safe to assume that the scalar types have a fixed size. 155 return getScalarType()->getPrimitiveSizeInBits().getFixedSize(); 156 } 157 158 int Type::getFPMantissaWidth() const { 159 if (auto *VTy = dyn_cast<VectorType>(this)) 160 return VTy->getElementType()->getFPMantissaWidth(); 161 assert(isFloatingPointTy() && "Not a floating point type!"); 162 if (getTypeID() == HalfTyID) return 11; 163 if (getTypeID() == BFloatTyID) return 8; 164 if (getTypeID() == FloatTyID) return 24; 165 if (getTypeID() == DoubleTyID) return 53; 166 if (getTypeID() == X86_FP80TyID) return 64; 167 if (getTypeID() == FP128TyID) return 113; 168 assert(getTypeID() == PPC_FP128TyID && "unknown fp type"); 169 return -1; 170 } 171 172 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const { 173 if (auto *ATy = dyn_cast<ArrayType>(this)) 174 return ATy->getElementType()->isSized(Visited); 175 176 if (auto *VTy = dyn_cast<VectorType>(this)) 177 return VTy->getElementType()->isSized(Visited); 178 179 return cast<StructType>(this)->isSized(Visited); 180 } 181 182 //===----------------------------------------------------------------------===// 183 // Primitive 'Type' data 184 //===----------------------------------------------------------------------===// 185 186 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; } 187 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; } 188 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; } 189 Type *Type::getBFloatTy(LLVMContext &C) { return &C.pImpl->BFloatTy; } 190 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; } 191 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; } 192 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; } 193 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; } 194 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } 195 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } 196 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } 197 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } 198 Type *Type::getX86_AMXTy(LLVMContext &C) { return &C.pImpl->X86_AMXTy; } 199 200 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } 201 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } 202 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; } 203 IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; } 204 IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; } 205 IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; } 206 207 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) { 208 return IntegerType::get(C, N); 209 } 210 211 PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) { 212 return getHalfTy(C)->getPointerTo(AS); 213 } 214 215 PointerType *Type::getBFloatPtrTy(LLVMContext &C, unsigned AS) { 216 return getBFloatTy(C)->getPointerTo(AS); 217 } 218 219 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) { 220 return getFloatTy(C)->getPointerTo(AS); 221 } 222 223 PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) { 224 return getDoubleTy(C)->getPointerTo(AS); 225 } 226 227 PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) { 228 return getX86_FP80Ty(C)->getPointerTo(AS); 229 } 230 231 PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) { 232 return getFP128Ty(C)->getPointerTo(AS); 233 } 234 235 PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) { 236 return getPPC_FP128Ty(C)->getPointerTo(AS); 237 } 238 239 PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) { 240 return getX86_MMXTy(C)->getPointerTo(AS); 241 } 242 243 PointerType *Type::getX86_AMXPtrTy(LLVMContext &C, unsigned AS) { 244 return getX86_AMXTy(C)->getPointerTo(AS); 245 } 246 247 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) { 248 return getIntNTy(C, N)->getPointerTo(AS); 249 } 250 251 PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) { 252 return getInt1Ty(C)->getPointerTo(AS); 253 } 254 255 PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) { 256 return getInt8Ty(C)->getPointerTo(AS); 257 } 258 259 PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) { 260 return getInt16Ty(C)->getPointerTo(AS); 261 } 262 263 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) { 264 return getInt32Ty(C)->getPointerTo(AS); 265 } 266 267 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) { 268 return getInt64Ty(C)->getPointerTo(AS); 269 } 270 271 //===----------------------------------------------------------------------===// 272 // IntegerType Implementation 273 //===----------------------------------------------------------------------===// 274 275 IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) { 276 assert(NumBits >= MIN_INT_BITS && "bitwidth too small"); 277 assert(NumBits <= MAX_INT_BITS && "bitwidth too large"); 278 279 // Check for the built-in integer types 280 switch (NumBits) { 281 case 1: return cast<IntegerType>(Type::getInt1Ty(C)); 282 case 8: return cast<IntegerType>(Type::getInt8Ty(C)); 283 case 16: return cast<IntegerType>(Type::getInt16Ty(C)); 284 case 32: return cast<IntegerType>(Type::getInt32Ty(C)); 285 case 64: return cast<IntegerType>(Type::getInt64Ty(C)); 286 case 128: return cast<IntegerType>(Type::getInt128Ty(C)); 287 default: 288 break; 289 } 290 291 IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits]; 292 293 if (!Entry) 294 Entry = new (C.pImpl->Alloc) IntegerType(C, NumBits); 295 296 return Entry; 297 } 298 299 APInt IntegerType::getMask() const { 300 return APInt::getAllOnesValue(getBitWidth()); 301 } 302 303 //===----------------------------------------------------------------------===// 304 // FunctionType Implementation 305 //===----------------------------------------------------------------------===// 306 307 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params, 308 bool IsVarArgs) 309 : Type(Result->getContext(), FunctionTyID) { 310 Type **SubTys = reinterpret_cast<Type**>(this+1); 311 assert(isValidReturnType(Result) && "invalid return type for function"); 312 setSubclassData(IsVarArgs); 313 314 SubTys[0] = Result; 315 316 for (unsigned i = 0, e = Params.size(); i != e; ++i) { 317 assert(isValidArgumentType(Params[i]) && 318 "Not a valid type for function argument!"); 319 SubTys[i+1] = Params[i]; 320 } 321 322 ContainedTys = SubTys; 323 NumContainedTys = Params.size() + 1; // + 1 for result type 324 } 325 326 // This is the factory function for the FunctionType class. 327 FunctionType *FunctionType::get(Type *ReturnType, 328 ArrayRef<Type*> Params, bool isVarArg) { 329 LLVMContextImpl *pImpl = ReturnType->getContext().pImpl; 330 const FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg); 331 FunctionType *FT; 332 // Since we only want to allocate a fresh function type in case none is found 333 // and we don't want to perform two lookups (one for checking if existent and 334 // one for inserting the newly allocated one), here we instead lookup based on 335 // Key and update the reference to the function type in-place to a newly 336 // allocated one if not found. 337 auto Insertion = pImpl->FunctionTypes.insert_as(nullptr, Key); 338 if (Insertion.second) { 339 // The function type was not found. Allocate one and update FunctionTypes 340 // in-place. 341 FT = (FunctionType *)pImpl->Alloc.Allocate( 342 sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1), 343 alignof(FunctionType)); 344 new (FT) FunctionType(ReturnType, Params, isVarArg); 345 *Insertion.first = FT; 346 } else { 347 // The function type was found. Just return it. 348 FT = *Insertion.first; 349 } 350 return FT; 351 } 352 353 FunctionType *FunctionType::get(Type *Result, bool isVarArg) { 354 return get(Result, None, isVarArg); 355 } 356 357 bool FunctionType::isValidReturnType(Type *RetTy) { 358 return !RetTy->isFunctionTy() && !RetTy->isLabelTy() && 359 !RetTy->isMetadataTy(); 360 } 361 362 bool FunctionType::isValidArgumentType(Type *ArgTy) { 363 return ArgTy->isFirstClassType(); 364 } 365 366 //===----------------------------------------------------------------------===// 367 // StructType Implementation 368 //===----------------------------------------------------------------------===// 369 370 // Primitive Constructors. 371 372 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes, 373 bool isPacked) { 374 LLVMContextImpl *pImpl = Context.pImpl; 375 const AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked); 376 377 StructType *ST; 378 // Since we only want to allocate a fresh struct type in case none is found 379 // and we don't want to perform two lookups (one for checking if existent and 380 // one for inserting the newly allocated one), here we instead lookup based on 381 // Key and update the reference to the struct type in-place to a newly 382 // allocated one if not found. 383 auto Insertion = pImpl->AnonStructTypes.insert_as(nullptr, Key); 384 if (Insertion.second) { 385 // The struct type was not found. Allocate one and update AnonStructTypes 386 // in-place. 387 ST = new (Context.pImpl->Alloc) StructType(Context); 388 ST->setSubclassData(SCDB_IsLiteral); // Literal struct. 389 ST->setBody(ETypes, isPacked); 390 *Insertion.first = ST; 391 } else { 392 // The struct type was found. Just return it. 393 ST = *Insertion.first; 394 } 395 396 return ST; 397 } 398 399 bool StructType::containsScalableVectorType() const { 400 for (Type *Ty : elements()) { 401 if (isa<ScalableVectorType>(Ty)) 402 return true; 403 if (auto *STy = dyn_cast<StructType>(Ty)) 404 if (STy->containsScalableVectorType()) 405 return true; 406 } 407 408 return false; 409 } 410 411 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) { 412 assert(isOpaque() && "Struct body already set!"); 413 414 setSubclassData(getSubclassData() | SCDB_HasBody); 415 if (isPacked) 416 setSubclassData(getSubclassData() | SCDB_Packed); 417 418 NumContainedTys = Elements.size(); 419 420 if (Elements.empty()) { 421 ContainedTys = nullptr; 422 return; 423 } 424 425 ContainedTys = Elements.copy(getContext().pImpl->Alloc).data(); 426 } 427 428 void StructType::setName(StringRef Name) { 429 if (Name == getName()) return; 430 431 StringMap<StructType *> &SymbolTable = getContext().pImpl->NamedStructTypes; 432 433 using EntryTy = StringMap<StructType *>::MapEntryTy; 434 435 // If this struct already had a name, remove its symbol table entry. Don't 436 // delete the data yet because it may be part of the new name. 437 if (SymbolTableEntry) 438 SymbolTable.remove((EntryTy *)SymbolTableEntry); 439 440 // If this is just removing the name, we're done. 441 if (Name.empty()) { 442 if (SymbolTableEntry) { 443 // Delete the old string data. 444 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator()); 445 SymbolTableEntry = nullptr; 446 } 447 return; 448 } 449 450 // Look up the entry for the name. 451 auto IterBool = 452 getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this)); 453 454 // While we have a name collision, try a random rename. 455 if (!IterBool.second) { 456 SmallString<64> TempStr(Name); 457 TempStr.push_back('.'); 458 raw_svector_ostream TmpStream(TempStr); 459 unsigned NameSize = Name.size(); 460 461 do { 462 TempStr.resize(NameSize + 1); 463 TmpStream << getContext().pImpl->NamedStructTypesUniqueID++; 464 465 IterBool = getContext().pImpl->NamedStructTypes.insert( 466 std::make_pair(TmpStream.str(), this)); 467 } while (!IterBool.second); 468 } 469 470 // Delete the old string data. 471 if (SymbolTableEntry) 472 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator()); 473 SymbolTableEntry = &*IterBool.first; 474 } 475 476 //===----------------------------------------------------------------------===// 477 // StructType Helper functions. 478 479 StructType *StructType::create(LLVMContext &Context, StringRef Name) { 480 StructType *ST = new (Context.pImpl->Alloc) StructType(Context); 481 if (!Name.empty()) 482 ST->setName(Name); 483 return ST; 484 } 485 486 StructType *StructType::get(LLVMContext &Context, bool isPacked) { 487 return get(Context, None, isPacked); 488 } 489 490 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements, 491 StringRef Name, bool isPacked) { 492 StructType *ST = create(Context, Name); 493 ST->setBody(Elements, isPacked); 494 return ST; 495 } 496 497 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) { 498 return create(Context, Elements, StringRef()); 499 } 500 501 StructType *StructType::create(LLVMContext &Context) { 502 return create(Context, StringRef()); 503 } 504 505 StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name, 506 bool isPacked) { 507 assert(!Elements.empty() && 508 "This method may not be invoked with an empty list"); 509 return create(Elements[0]->getContext(), Elements, Name, isPacked); 510 } 511 512 StructType *StructType::create(ArrayRef<Type*> Elements) { 513 assert(!Elements.empty() && 514 "This method may not be invoked with an empty list"); 515 return create(Elements[0]->getContext(), Elements, StringRef()); 516 } 517 518 bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const { 519 if ((getSubclassData() & SCDB_IsSized) != 0) 520 return true; 521 if (isOpaque()) 522 return false; 523 524 if (Visited && !Visited->insert(const_cast<StructType*>(this)).second) 525 return false; 526 527 // Okay, our struct is sized if all of the elements are, but if one of the 528 // elements is opaque, the struct isn't sized *yet*, but may become sized in 529 // the future, so just bail out without caching. 530 for (Type *Ty : elements()) { 531 // If the struct contains a scalable vector type, don't consider it sized. 532 // This prevents it from being used in loads/stores/allocas/GEPs. 533 if (isa<ScalableVectorType>(Ty)) 534 return false; 535 if (!Ty->isSized(Visited)) 536 return false; 537 } 538 539 // Here we cheat a bit and cast away const-ness. The goal is to memoize when 540 // we find a sized type, as types can only move from opaque to sized, not the 541 // other way. 542 const_cast<StructType*>(this)->setSubclassData( 543 getSubclassData() | SCDB_IsSized); 544 return true; 545 } 546 547 StringRef StructType::getName() const { 548 assert(!isLiteral() && "Literal structs never have names"); 549 if (!SymbolTableEntry) return StringRef(); 550 551 return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey(); 552 } 553 554 bool StructType::isValidElementType(Type *ElemTy) { 555 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 556 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() && 557 !ElemTy->isTokenTy(); 558 } 559 560 bool StructType::isLayoutIdentical(StructType *Other) const { 561 if (this == Other) return true; 562 563 if (isPacked() != Other->isPacked()) 564 return false; 565 566 return elements() == Other->elements(); 567 } 568 569 Type *StructType::getTypeAtIndex(const Value *V) const { 570 unsigned Idx = (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue(); 571 assert(indexValid(Idx) && "Invalid structure index!"); 572 return getElementType(Idx); 573 } 574 575 bool StructType::indexValid(const Value *V) const { 576 // Structure indexes require (vectors of) 32-bit integer constants. In the 577 // vector case all of the indices must be equal. 578 if (!V->getType()->isIntOrIntVectorTy(32)) 579 return false; 580 if (isa<ScalableVectorType>(V->getType())) 581 return false; 582 const Constant *C = dyn_cast<Constant>(V); 583 if (C && V->getType()->isVectorTy()) 584 C = C->getSplatValue(); 585 const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C); 586 return CU && CU->getZExtValue() < getNumElements(); 587 } 588 589 StructType *StructType::getTypeByName(LLVMContext &C, StringRef Name) { 590 return C.pImpl->NamedStructTypes.lookup(Name); 591 } 592 593 //===----------------------------------------------------------------------===// 594 // ArrayType Implementation 595 //===----------------------------------------------------------------------===// 596 597 ArrayType::ArrayType(Type *ElType, uint64_t NumEl) 598 : Type(ElType->getContext(), ArrayTyID), ContainedType(ElType), 599 NumElements(NumEl) { 600 ContainedTys = &ContainedType; 601 NumContainedTys = 1; 602 } 603 604 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) { 605 assert(isValidElementType(ElementType) && "Invalid type for array element!"); 606 607 LLVMContextImpl *pImpl = ElementType->getContext().pImpl; 608 ArrayType *&Entry = 609 pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)]; 610 611 if (!Entry) 612 Entry = new (pImpl->Alloc) ArrayType(ElementType, NumElements); 613 return Entry; 614 } 615 616 bool ArrayType::isValidElementType(Type *ElemTy) { 617 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 618 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() && 619 !ElemTy->isTokenTy() && !ElemTy->isX86_AMXTy() && 620 !isa<ScalableVectorType>(ElemTy); 621 } 622 623 //===----------------------------------------------------------------------===// 624 // VectorType Implementation 625 //===----------------------------------------------------------------------===// 626 627 VectorType::VectorType(Type *ElType, unsigned EQ, Type::TypeID TID) 628 : Type(ElType->getContext(), TID), ContainedType(ElType), 629 ElementQuantity(EQ) { 630 ContainedTys = &ContainedType; 631 NumContainedTys = 1; 632 } 633 634 VectorType *VectorType::get(Type *ElementType, ElementCount EC) { 635 if (EC.isScalable()) 636 return ScalableVectorType::get(ElementType, EC.getKnownMinValue()); 637 else 638 return FixedVectorType::get(ElementType, EC.getKnownMinValue()); 639 } 640 641 bool VectorType::isValidElementType(Type *ElemTy) { 642 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() || 643 ElemTy->isPointerTy(); 644 } 645 646 //===----------------------------------------------------------------------===// 647 // FixedVectorType Implementation 648 //===----------------------------------------------------------------------===// 649 650 FixedVectorType *FixedVectorType::get(Type *ElementType, unsigned NumElts) { 651 assert(NumElts > 0 && "#Elements of a VectorType must be greater than 0"); 652 assert(isValidElementType(ElementType) && "Element type of a VectorType must " 653 "be an integer, floating point, or " 654 "pointer type."); 655 656 auto EC = ElementCount::getFixed(NumElts); 657 658 LLVMContextImpl *pImpl = ElementType->getContext().pImpl; 659 VectorType *&Entry = ElementType->getContext() 660 .pImpl->VectorTypes[std::make_pair(ElementType, EC)]; 661 662 if (!Entry) 663 Entry = new (pImpl->Alloc) FixedVectorType(ElementType, NumElts); 664 return cast<FixedVectorType>(Entry); 665 } 666 667 //===----------------------------------------------------------------------===// 668 // ScalableVectorType Implementation 669 //===----------------------------------------------------------------------===// 670 671 ScalableVectorType *ScalableVectorType::get(Type *ElementType, 672 unsigned MinNumElts) { 673 assert(MinNumElts > 0 && "#Elements of a VectorType must be greater than 0"); 674 assert(isValidElementType(ElementType) && "Element type of a VectorType must " 675 "be an integer, floating point, or " 676 "pointer type."); 677 678 auto EC = ElementCount::getScalable(MinNumElts); 679 680 LLVMContextImpl *pImpl = ElementType->getContext().pImpl; 681 VectorType *&Entry = ElementType->getContext() 682 .pImpl->VectorTypes[std::make_pair(ElementType, EC)]; 683 684 if (!Entry) 685 Entry = new (pImpl->Alloc) ScalableVectorType(ElementType, MinNumElts); 686 return cast<ScalableVectorType>(Entry); 687 } 688 689 //===----------------------------------------------------------------------===// 690 // PointerType Implementation 691 //===----------------------------------------------------------------------===// 692 693 PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) { 694 assert(EltTy && "Can't get a pointer to <null> type!"); 695 assert(isValidElementType(EltTy) && "Invalid type for pointer element!"); 696 697 LLVMContextImpl *CImpl = EltTy->getContext().pImpl; 698 699 // Create opaque pointer for pointer to opaque pointer. 700 if (CImpl->ForceOpaquePointers || EltTy->isOpaquePointerTy()) 701 return get(EltTy->getContext(), AddressSpace); 702 703 // Since AddressSpace #0 is the common case, we special case it. 704 PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy] 705 : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)]; 706 707 if (!Entry) 708 Entry = new (CImpl->Alloc) PointerType(EltTy, AddressSpace); 709 return Entry; 710 } 711 712 PointerType *PointerType::get(LLVMContext &C, unsigned AddressSpace) { 713 LLVMContextImpl *CImpl = C.pImpl; 714 715 // Since AddressSpace #0 is the common case, we special case it. 716 PointerType *&Entry = 717 AddressSpace == 0 718 ? CImpl->PointerTypes[nullptr] 719 : CImpl->ASPointerTypes[std::make_pair(nullptr, AddressSpace)]; 720 721 if (!Entry) 722 Entry = new (CImpl->Alloc) PointerType(C, AddressSpace); 723 return Entry; 724 } 725 726 PointerType::PointerType(Type *E, unsigned AddrSpace) 727 : Type(E->getContext(), PointerTyID), PointeeTy(E) { 728 ContainedTys = &PointeeTy; 729 NumContainedTys = 1; 730 setSubclassData(AddrSpace); 731 } 732 733 PointerType::PointerType(LLVMContext &C, unsigned AddrSpace) 734 : Type(C, PointerTyID), PointeeTy(nullptr) { 735 setSubclassData(AddrSpace); 736 } 737 738 PointerType *Type::getPointerTo(unsigned AddrSpace) const { 739 return PointerType::get(const_cast<Type*>(this), AddrSpace); 740 } 741 742 bool PointerType::isValidElementType(Type *ElemTy) { 743 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && 744 !ElemTy->isMetadataTy() && !ElemTy->isTokenTy() && 745 !ElemTy->isX86_AMXTy(); 746 } 747 748 bool PointerType::isLoadableOrStorableType(Type *ElemTy) { 749 return isValidElementType(ElemTy) && !ElemTy->isFunctionTy(); 750 } 751