LCOV - code coverage report
Current view: top level - lib/IR - Type.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 231 265 87.2 %
Date: 2018-02-18 16:14:26 Functions: 67 77 87.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 IR library.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/IR/Type.h"
      15             : #include "LLVMContextImpl.h"
      16             : #include "llvm/ADT/APInt.h"
      17             : #include "llvm/ADT/None.h"
      18             : #include "llvm/ADT/SmallString.h"
      19             : #include "llvm/ADT/StringMap.h"
      20             : #include "llvm/ADT/StringRef.h"
      21             : #include "llvm/IR/Constant.h"
      22             : #include "llvm/IR/Constants.h"
      23             : #include "llvm/IR/DerivedTypes.h"
      24             : #include "llvm/IR/LLVMContext.h"
      25             : #include "llvm/IR/Module.h"
      26             : #include "llvm/IR/Value.h"
      27             : #include "llvm/Support/Casting.h"
      28             : #include "llvm/Support/MathExtras.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           0 : Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
      40           0 :   switch (IDNumber) {
      41           0 :   case VoidTyID      : return getVoidTy(C);
      42           0 :   case HalfTyID      : return getHalfTy(C);
      43           0 :   case FloatTyID     : return getFloatTy(C);
      44           0 :   case DoubleTyID    : return getDoubleTy(C);
      45           0 :   case X86_FP80TyID  : return getX86_FP80Ty(C);
      46           0 :   case FP128TyID     : return getFP128Ty(C);
      47           0 :   case PPC_FP128TyID : return getPPC_FP128Ty(C);
      48           0 :   case LabelTyID     : return getLabelTy(C);
      49           0 :   case MetadataTyID  : return getMetadataTy(C);
      50           0 :   case X86_MMXTyID   : return getX86_MMXTy(C);
      51           0 :   case TokenTyID     : return getTokenTy(C);
      52             :   default:
      53             :     return nullptr;
      54             :   }
      55             : }
      56             : 
      57    24271396 : bool Type::isIntegerTy(unsigned Bitwidth) const {
      58    47359597 :   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
      59             : }
      60             : 
      61        1948 : bool Type::canLosslesslyBitCastTo(Type *Ty) const {
      62             :   // Identity cast means no change so return true
      63        1948 :   if (this == Ty) 
      64             :     return true;
      65             :   
      66             :   // They are not convertible unless they are at least first class types
      67             :   if (!this->isFirstClassType() || !Ty->isFirstClassType())
      68             :     return false;
      69             : 
      70             :   // Vector -> Vector conversions are always lossless if the two vector types
      71             :   // have the same size, otherwise not.  Also, 64-bit vector types can be
      72             :   // converted to x86mmx.
      73             :   if (auto *thisPTy = dyn_cast<VectorType>(this)) {
      74             :     if (auto *thatPTy = dyn_cast<VectorType>(Ty))
      75           0 :       return thisPTy->getBitWidth() == thatPTy->getBitWidth();
      76           0 :     if (Ty->getTypeID() == Type::X86_MMXTyID &&
      77             :         thisPTy->getBitWidth() == 64)
      78             :       return true;
      79             :   }
      80             : 
      81           4 :   if (this->getTypeID() == Type::X86_MMXTyID)
      82             :     if (auto *thatPTy = dyn_cast<VectorType>(Ty))
      83           0 :       if (thatPTy->getBitWidth() == 64)
      84             :         return true;
      85             : 
      86             :   // At this point we have only various mismatches of the first class types
      87             :   // remaining and ptr->ptr. Just select the lossless conversions. Everything
      88             :   // else is not lossless. Conservatively assume we can't losslessly convert
      89             :   // between pointers with different address spaces.
      90             :   if (auto *PTy = dyn_cast<PointerType>(this)) {
      91             :     if (auto *OtherPTy = dyn_cast<PointerType>(Ty))
      92           3 :       return PTy->getAddressSpace() == OtherPTy->getAddressSpace();
      93             :     return false;
      94             :   }
      95             :   return false;  // Other types have no identity values
      96             : }
      97             : 
      98     2672365 : bool Type::isEmptyTy() const {
      99             :   if (auto *ATy = dyn_cast<ArrayType>(this)) {
     100         514 :     unsigned NumElements = ATy->getNumElements();
     101         514 :     return NumElements == 0 || ATy->getElementType()->isEmptyTy();
     102             :   }
     103             : 
     104             :   if (auto *STy = dyn_cast<StructType>(this)) {
     105             :     unsigned NumElements = STy->getNumElements();
     106       33365 :     for (unsigned i = 0; i < NumElements; ++i)
     107       33341 :       if (!STy->getElementType(i)->isEmptyTy())
     108             :         return false;
     109             :     return true;
     110             :   }
     111             : 
     112             :   return false;
     113             : }
     114             : 
     115    56506116 : unsigned Type::getPrimitiveSizeInBits() const {
     116    56506116 :   switch (getTypeID()) {
     117             :   case Type::HalfTyID: return 16;
     118      109948 :   case Type::FloatTyID: return 32;
     119       58055 :   case Type::DoubleTyID: return 64;
     120        1221 :   case Type::X86_FP80TyID: return 80;
     121        2859 :   case Type::FP128TyID: return 128;
     122         325 :   case Type::PPC_FP128TyID: return 128;
     123       20456 :   case Type::X86_MMXTyID: return 64;
     124    45971943 :   case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
     125      314170 :   case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
     126     9990770 :   default: return 0;
     127             :   }
     128             : }
     129             : 
     130    42435778 : unsigned Type::getScalarSizeInBits() const {
     131    42435778 :   return getScalarType()->getPrimitiveSizeInBits();
     132             : }
     133             : 
     134         406 : int Type::getFPMantissaWidth() const {
     135             :   if (auto *VTy = dyn_cast<VectorType>(this))
     136           4 :     return VTy->getElementType()->getFPMantissaWidth();
     137             :   assert(isFloatingPointTy() && "Not a floating point type!");
     138             :   if (getTypeID() == HalfTyID) return 11;
     139         392 :   if (getTypeID() == FloatTyID) return 24;
     140         214 :   if (getTypeID() == DoubleTyID) return 53;
     141          33 :   if (getTypeID() == X86_FP80TyID) return 64;
     142           1 :   if (getTypeID() == FP128TyID) return 113;
     143             :   assert(getTypeID() == PPC_FP128TyID && "unknown fp type");
     144           1 :   return -1;
     145             : }
     146             : 
     147    69002496 : bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
     148             :   if (auto *ATy = dyn_cast<ArrayType>(this))
     149    62832663 :     return ATy->getElementType()->isSized(Visited);
     150             : 
     151             :   if (auto *VTy = dyn_cast<VectorType>(this))
     152      922077 :     return VTy->getElementType()->isSized(Visited);
     153             : 
     154     5247756 :   return cast<StructType>(this)->isSized(Visited);
     155             : }
     156             : 
     157             : //===----------------------------------------------------------------------===//
     158             : //                          Primitive 'Type' data
     159             : //===----------------------------------------------------------------------===//
     160             : 
     161     5733404 : Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
     162     1713361 : Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
     163       74713 : Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
     164      556496 : Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
     165      327664 : Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
     166      247857 : Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
     167        3603 : Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
     168        6582 : Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
     169       12902 : Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
     170        1554 : Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
     171       27490 : Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
     172             : 
     173     3901343 : IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
     174     2977807 : IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
     175      597291 : IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
     176    19826239 : IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
     177    15516197 : IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
     178      567690 : IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
     179             : 
     180     1293172 : IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
     181     1293172 :   return IntegerType::get(C, N);
     182             : }
     183             : 
     184           0 : PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
     185           0 :   return getHalfTy(C)->getPointerTo(AS);
     186             : }
     187             : 
     188           0 : PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
     189           0 :   return getFloatTy(C)->getPointerTo(AS);
     190             : }
     191             : 
     192           0 : PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
     193           0 :   return getDoubleTy(C)->getPointerTo(AS);
     194             : }
     195             : 
     196           0 : PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
     197           0 :   return getX86_FP80Ty(C)->getPointerTo(AS);
     198             : }
     199             : 
     200           0 : PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
     201           0 :   return getFP128Ty(C)->getPointerTo(AS);
     202             : }
     203             : 
     204           0 : PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
     205           0 :   return getPPC_FP128Ty(C)->getPointerTo(AS);
     206             : }
     207             : 
     208           0 : PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
     209           0 :   return getX86_MMXTy(C)->getPointerTo(AS);
     210             : }
     211             : 
     212           4 : PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
     213           4 :   return getIntNTy(C, N)->getPointerTo(AS);
     214             : }
     215             : 
     216       13456 : PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
     217       13456 :   return getInt1Ty(C)->getPointerTo(AS);
     218             : }
     219             : 
     220      560927 : PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
     221      560927 :   return getInt8Ty(C)->getPointerTo(AS);
     222             : }
     223             : 
     224           0 : PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
     225           0 :   return getInt16Ty(C)->getPointerTo(AS);
     226             : }
     227             : 
     228        5954 : PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
     229        5954 :   return getInt32Ty(C)->getPointerTo(AS);
     230             : }
     231             : 
     232        4420 : PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
     233        4420 :   return getInt64Ty(C)->getPointerTo(AS);
     234             : }
     235             : 
     236             : //===----------------------------------------------------------------------===//
     237             : //                       IntegerType Implementation
     238             : //===----------------------------------------------------------------------===//
     239             : 
     240    30565358 : IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) {
     241             :   assert(NumBits >= MIN_INT_BITS && "bitwidth too small");
     242             :   assert(NumBits <= MAX_INT_BITS && "bitwidth too large");
     243             :   
     244             :   // Check for the built-in integer types
     245    30565358 :   switch (NumBits) {
     246      216518 :   case   1: return cast<IntegerType>(Type::getInt1Ty(C));
     247     1614951 :   case   8: return cast<IntegerType>(Type::getInt8Ty(C));
     248      485717 :   case  16: return cast<IntegerType>(Type::getInt16Ty(C));
     249    13866260 :   case  32: return cast<IntegerType>(Type::getInt32Ty(C));
     250    13109494 :   case  64: return cast<IntegerType>(Type::getInt64Ty(C));
     251      567499 :   case 128: return cast<IntegerType>(Type::getInt128Ty(C));
     252             :   default:
     253             :     break;
     254             :   }
     255             :   
     256      704919 :   IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
     257             : 
     258      704919 :   if (!Entry)
     259       32253 :     Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
     260             :   
     261      704919 :   return Entry;
     262             : }
     263             : 
     264           0 : bool IntegerType::isPowerOf2ByteWidth() const {
     265             :   unsigned BitWidth = getBitWidth();
     266           0 :   return (BitWidth > 7) && isPowerOf2_32(BitWidth);
     267             : }
     268             : 
     269         180 : APInt IntegerType::getMask() const {
     270         180 :   return APInt::getAllOnesValue(getBitWidth());
     271             : }
     272             : 
     273             : //===----------------------------------------------------------------------===//
     274             : //                       FunctionType Implementation
     275             : //===----------------------------------------------------------------------===//
     276             : 
     277      283363 : FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
     278      283363 :                            bool IsVarArgs)
     279             :   : Type(Result->getContext(), FunctionTyID) {
     280      283363 :   Type **SubTys = reinterpret_cast<Type**>(this+1);
     281             :   assert(isValidReturnType(Result) && "invalid return type for function");
     282             :   setSubclassData(IsVarArgs);
     283             : 
     284      283363 :   SubTys[0] = Result;
     285             : 
     286      807429 :   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
     287             :     assert(isValidArgumentType(Params[i]) &&
     288             :            "Not a valid type for function argument!");
     289     1048132 :     SubTys[i+1] = Params[i];
     290             :   }
     291             : 
     292      283363 :   ContainedTys = SubTys;
     293      283363 :   NumContainedTys = Params.size() + 1; // + 1 for result type
     294      283363 : }
     295             : 
     296             : // This is the factory function for the FunctionType class.
     297     1791821 : FunctionType *FunctionType::get(Type *ReturnType,
     298             :                                 ArrayRef<Type*> Params, bool isVarArg) {
     299     1791821 :   LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
     300     1791821 :   FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
     301             :   auto I = pImpl->FunctionTypes.find_as(Key);
     302             :   FunctionType *FT;
     303             : 
     304     1791821 :   if (I == pImpl->FunctionTypes.end()) {
     305      283363 :     FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
     306             :         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
     307             :         alignof(FunctionType));
     308      283363 :     new (FT) FunctionType(ReturnType, Params, isVarArg);
     309             :     pImpl->FunctionTypes.insert(FT);
     310             :   } else {
     311     1508458 :     FT = *I;
     312             :   }
     313             : 
     314     1791821 :   return FT;
     315             : }
     316             : 
     317       30722 : FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
     318       61444 :   return get(Result, None, isVarArg);
     319             : }
     320             : 
     321      401362 : bool FunctionType::isValidReturnType(Type *RetTy) {
     322      401362 :   return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
     323      401362 :   !RetTy->isMetadataTy();
     324             : }
     325             : 
     326      250358 : bool FunctionType::isValidArgumentType(Type *ArgTy) {
     327      250358 :   return ArgTy->isFirstClassType();
     328             : }
     329             : 
     330             : //===----------------------------------------------------------------------===//
     331             : //                       StructType Implementation
     332             : //===----------------------------------------------------------------------===//
     333             : 
     334             : // Primitive Constructors.
     335             : 
     336       87581 : StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes, 
     337             :                             bool isPacked) {
     338       87581 :   LLVMContextImpl *pImpl = Context.pImpl;
     339       87581 :   AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
     340             :   auto I = pImpl->AnonStructTypes.find_as(Key);
     341             :   StructType *ST;
     342             : 
     343       87581 :   if (I == pImpl->AnonStructTypes.end()) {
     344             :     // Value not found.  Create a new type!
     345       35658 :     ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     346             :     ST->setSubclassData(SCDB_IsLiteral);  // Literal struct.
     347       17829 :     ST->setBody(ETypes, isPacked);
     348       17829 :     Context.pImpl->AnonStructTypes.insert(ST);
     349             :   } else {
     350       69752 :     ST = *I;
     351             :   }
     352             : 
     353       87581 :   return ST;
     354             : }
     355             : 
     356       90006 : void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
     357             :   assert(isOpaque() && "Struct body already set!");
     358             :   
     359             :   setSubclassData(getSubclassData() | SCDB_HasBody);
     360       90006 :   if (isPacked)
     361             :     setSubclassData(getSubclassData() | SCDB_Packed);
     362             : 
     363       90006 :   NumContainedTys = Elements.size();
     364             : 
     365       90006 :   if (Elements.empty()) {
     366        3598 :     ContainedTys = nullptr;
     367        3598 :     return;
     368             :   }
     369             : 
     370       86408 :   ContainedTys = Elements.copy(getContext().pImpl->TypeAllocator).data();
     371             : }
     372             : 
     373       73774 : void StructType::setName(StringRef Name) {
     374       73774 :   if (Name == getName()) return;
     375             : 
     376       73774 :   StringMap<StructType *> &SymbolTable = getContext().pImpl->NamedStructTypes;
     377             : 
     378             :   using EntryTy = StringMap<StructType *>::MapEntryTy;
     379             : 
     380             :   // If this struct already had a name, remove its symbol table entry. Don't
     381             :   // delete the data yet because it may be part of the new name.
     382       73774 :   if (SymbolTableEntry)
     383             :     SymbolTable.remove((EntryTy *)SymbolTableEntry);
     384             : 
     385             :   // If this is just removing the name, we're done.
     386       73774 :   if (Name.empty()) {
     387          84 :     if (SymbolTableEntry) {
     388             :       // Delete the old string data.
     389             :       ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
     390          84 :       SymbolTableEntry = nullptr;
     391             :     }
     392             :     return;
     393             :   }
     394             :   
     395             :   // Look up the entry for the name.
     396             :   auto IterBool =
     397       73690 :       getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
     398             : 
     399             :   // While we have a name collision, try a random rename.
     400       73690 :   if (!IterBool.second) {
     401             :     SmallString<64> TempStr(Name);
     402        8327 :     TempStr.push_back('.');
     403             :     raw_svector_ostream TmpStream(TempStr);
     404        8327 :     unsigned NameSize = Name.size();
     405             :    
     406             :     do {
     407        8327 :       TempStr.resize(NameSize + 1);
     408        8327 :       TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
     409             : 
     410        8327 :       IterBool = getContext().pImpl->NamedStructTypes.insert(
     411        8327 :           std::make_pair(TmpStream.str(), this));
     412        8327 :     } while (!IterBool.second);
     413             :   }
     414             : 
     415             :   // Delete the old string data.
     416       73690 :   if (SymbolTableEntry)
     417             :     ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
     418       73690 :   SymbolTableEntry = &*IterBool.first;
     419             : }
     420             : 
     421             : //===----------------------------------------------------------------------===//
     422             : // StructType Helper functions.
     423             : 
     424       75279 : StructType *StructType::create(LLVMContext &Context, StringRef Name) {
     425       75279 :   StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     426       75279 :   if (!Name.empty())
     427       27299 :     ST->setName(Name);
     428       75279 :   return ST;
     429             : }
     430             : 
     431          56 : StructType *StructType::get(LLVMContext &Context, bool isPacked) {
     432         112 :   return get(Context, None, isPacked);
     433             : }
     434             : 
     435       16251 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
     436             :                                StringRef Name, bool isPacked) {
     437       16251 :   StructType *ST = create(Context, Name);
     438       16251 :   ST->setBody(Elements, isPacked);
     439       16251 :   return ST;
     440             : }
     441             : 
     442           3 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
     443           3 :   return create(Context, Elements, StringRef());
     444             : }
     445             : 
     446       42491 : StructType *StructType::create(LLVMContext &Context) {
     447       42491 :   return create(Context, StringRef());
     448             : }
     449             : 
     450       10943 : StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name,
     451             :                                bool isPacked) {
     452             :   assert(!Elements.empty() &&
     453             :          "This method may not be invoked with an empty list");
     454       10943 :   return create(Elements[0]->getContext(), Elements, Name, isPacked);
     455             : }
     456             : 
     457         165 : StructType *StructType::create(ArrayRef<Type*> Elements) {
     458             :   assert(!Elements.empty() &&
     459             :          "This method may not be invoked with an empty list");
     460         165 :   return create(Elements[0]->getContext(), Elements, StringRef());
     461             : }
     462             : 
     463     5247756 : bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
     464     5247756 :   if ((getSubclassData() & SCDB_IsSized) != 0)
     465             :     return true;
     466       43685 :   if (isOpaque())
     467             :     return false;
     468             : 
     469       43050 :   if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
     470             :     return false;
     471             : 
     472             :   // Okay, our struct is sized if all of the elements are, but if one of the
     473             :   // elements is opaque, the struct isn't sized *yet*, but may become sized in
     474             :   // the future, so just bail out without caching.
     475      261966 :   for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
     476      109484 :     if (!(*I)->isSized(Visited))
     477             :       return false;
     478             : 
     479             :   // Here we cheat a bit and cast away const-ness. The goal is to memoize when
     480             :   // we find a sized type, as types can only move from opaque to sized, not the
     481             :   // other way.
     482             :   const_cast<StructType*>(this)->setSubclassData(
     483             :     getSubclassData() | SCDB_IsSized);
     484       43021 :   return true;
     485             : }
     486             : 
     487     1328908 : StringRef StructType::getName() const {
     488             :   assert(!isLiteral() && "Literal structs never have names");
     489     1328908 :   if (!SymbolTableEntry) return StringRef();
     490             : 
     491             :   return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
     492             : }
     493             : 
     494      103103 : bool StructType::isValidElementType(Type *ElemTy) {
     495      103102 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     496      206205 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     497      103103 :          !ElemTy->isTokenTy();
     498             : }
     499             : 
     500        3534 : bool StructType::isLayoutIdentical(StructType *Other) const {
     501        3534 :   if (this == Other) return true;
     502             : 
     503        3534 :   if (isPacked() != Other->isPacked())
     504             :     return false;
     505             : 
     506        3508 :   return elements() == Other->elements();
     507             : }
     508             : 
     509          84 : StructType *Module::getTypeByName(StringRef Name) const {
     510          84 :   return getContext().pImpl->NamedStructTypes.lookup(Name);
     511             : }
     512             : 
     513             : //===----------------------------------------------------------------------===//
     514             : //                       CompositeType Implementation
     515             : //===----------------------------------------------------------------------===//
     516             : 
     517    30527849 : Type *CompositeType::getTypeAtIndex(const Value *V) const {
     518             :   if (auto *STy = dyn_cast<StructType>(this)) {
     519             :     unsigned Idx =
     520     6825620 :       (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
     521             :     assert(indexValid(Idx) && "Invalid structure index!");
     522     6825620 :     return STy->getElementType(Idx);
     523             :   }
     524             : 
     525    23702229 :   return cast<SequentialType>(this)->getElementType();
     526             : }
     527             : 
     528      783505 : Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
     529             :   if (auto *STy = dyn_cast<StructType>(this)) {
     530             :     assert(indexValid(Idx) && "Invalid structure index!");
     531      615566 :     return STy->getElementType(Idx);
     532             :   }
     533             : 
     534      167939 :   return cast<SequentialType>(this)->getElementType();
     535             : }
     536             : 
     537    14674170 : bool CompositeType::indexValid(const Value *V) const {
     538             :   if (auto *STy = dyn_cast<StructType>(this)) {
     539             :     // Structure indexes require (vectors of) 32-bit integer constants.  In the
     540             :     // vector case all of the indices must be equal.
     541     1964355 :     if (!V->getType()->isIntOrIntVectorTy(32))
     542             :       return false;
     543             :     const Constant *C = dyn_cast<Constant>(V);
     544     1964354 :     if (C && V->getType()->isVectorTy())
     545         245 :       C = C->getSplatValue();
     546             :     const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
     547     1964353 :     return CU && CU->getZExtValue() < STy->getNumElements();
     548             :   }
     549             : 
     550             :   // Sequential types can be indexed by any integer.
     551    12709815 :   return V->getType()->isIntOrIntVectorTy();
     552             : }
     553             : 
     554          14 : bool CompositeType::indexValid(unsigned Idx) const {
     555             :   if (auto *STy = dyn_cast<StructType>(this))
     556          14 :     return Idx < STy->getNumElements();
     557             :   // Sequential types can be indexed by any integer.
     558             :   return true;
     559             : }
     560             : 
     561             : //===----------------------------------------------------------------------===//
     562             : //                           ArrayType Implementation
     563             : //===----------------------------------------------------------------------===//
     564             : 
     565       83147 : ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
     566       83147 :   : SequentialType(ArrayTyID, ElType, NumEl) {}
     567             : 
     568      421113 : ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
     569             :   assert(isValidElementType(ElementType) && "Invalid type for array element!");
     570             : 
     571      421113 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     572             :   ArrayType *&Entry = 
     573      842226 :     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
     574             : 
     575      421113 :   if (!Entry)
     576      166293 :     Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
     577      421113 :   return Entry;
     578             : }
     579             : 
     580      124695 : bool ArrayType::isValidElementType(Type *ElemTy) {
     581      124694 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     582      249389 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     583      124695 :          !ElemTy->isTokenTy();
     584             : }
     585             : 
     586             : //===----------------------------------------------------------------------===//
     587             : //                          VectorType Implementation
     588             : //===----------------------------------------------------------------------===//
     589             : 
     590       49238 : VectorType::VectorType(Type *ElType, unsigned NumEl)
     591       98476 :   : SequentialType(VectorTyID, ElType, NumEl) {}
     592             : 
     593     3659696 : VectorType *VectorType::get(Type *ElementType, unsigned NumElements) {
     594             :   assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0");
     595             :   assert(isValidElementType(ElementType) && "Element type of a VectorType must "
     596             :                                             "be an integer, floating point, or "
     597             :                                             "pointer type.");
     598             : 
     599     3659696 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     600             :   VectorType *&Entry = ElementType->getContext().pImpl
     601     7319392 :     ->VectorTypes[std::make_pair(ElementType, NumElements)];
     602             : 
     603     3659696 :   if (!Entry)
     604       98476 :     Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
     605     3659696 :   return Entry;
     606             : }
     607             : 
     608     1511097 : bool VectorType::isValidElementType(Type *ElemTy) {
     609     1558330 :   return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
     610     1511097 :     ElemTy->isPointerTy();
     611             : }
     612             : 
     613             : //===----------------------------------------------------------------------===//
     614             : //                         PointerType Implementation
     615             : //===----------------------------------------------------------------------===//
     616             : 
     617    19735051 : PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) {
     618             :   assert(EltTy && "Can't get a pointer to <null> type!");
     619             :   assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
     620             :   
     621    19735051 :   LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
     622             :   
     623             :   // Since AddressSpace #0 is the common case, we special case it.
     624    19735051 :   PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
     625    19952577 :      : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
     626             : 
     627    19735051 :   if (!Entry)
     628     1118864 :     Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
     629    19735051 :   return Entry;
     630             : }
     631             : 
     632      559432 : PointerType::PointerType(Type *E, unsigned AddrSpace)
     633      559432 :   : Type(E->getContext(), PointerTyID), PointeeTy(E) {
     634      559432 :   ContainedTys = &PointeeTy;
     635      559432 :   NumContainedTys = 1;
     636             :   setSubclassData(AddrSpace);
     637      559432 : }
     638             : 
     639    12574825 : PointerType *Type::getPointerTo(unsigned addrs) const {
     640    12574825 :   return PointerType::get(const_cast<Type*>(this), addrs);
     641             : }
     642             : 
     643      862212 : bool PointerType::isValidElementType(Type *ElemTy) {
     644      862211 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     645     1724421 :          !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
     646             : }
     647             : 
     648       68666 : bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
     649      137332 :   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
     650             : }

Generated by: LCOV version 1.13