LCOV - code coverage report
Current view: top level - lib/IR - Type.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 234 268 87.3 %
Date: 2018-10-20 13:21:21 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    49559389 : bool Type::isIntegerTy(unsigned Bitwidth) const {
      58    49559389 :   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
      59             : }
      60             : 
      61        2316 : bool Type::canLosslesslyBitCastTo(Type *Ty) const {
      62             :   // Identity cast means no change so return true
      63        2316 :   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           5 :   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           5 :       return PTy->getAddressSpace() == OtherPTy->getAddressSpace();
      93             :     return false;
      94             :   }
      95             :   return false;  // Other types have no identity values
      96             : }
      97             : 
      98    16704760 : bool Type::isEmptyTy() const {
      99             :   if (auto *ATy = dyn_cast<ArrayType>(this)) {
     100         572 :     unsigned NumElements = ATy->getNumElements();
     101         572 :     return NumElements == 0 || ATy->getElementType()->isEmptyTy();
     102             :   }
     103             : 
     104             :   if (auto *STy = dyn_cast<StructType>(this)) {
     105      416382 :     unsigned NumElements = STy->getNumElements();
     106      416387 :     for (unsigned i = 0; i < NumElements; ++i)
     107      832736 :       if (!STy->getElementType(i)->isEmptyTy())
     108             :         return false;
     109             :     return true;
     110             :   }
     111             : 
     112             :   return false;
     113             : }
     114             : 
     115    98578620 : unsigned Type::getPrimitiveSizeInBits() const {
     116    98578620 :   switch (getTypeID()) {
     117             :   case Type::HalfTyID: return 16;
     118      170721 :   case Type::FloatTyID: return 32;
     119      102875 :   case Type::DoubleTyID: return 64;
     120        1813 :   case Type::X86_FP80TyID: return 80;
     121        3804 :   case Type::FP128TyID: return 128;
     122         325 :   case Type::PPC_FP128TyID: return 128;
     123       22528 :   case Type::X86_MMXTyID: return 64;
     124    82344891 :   case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
     125      471387 :   case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
     126    15405920 :   default: return 0;
     127             :   }
     128             : }
     129             : 
     130    69315948 : unsigned Type::getScalarSizeInBits() const {
     131    69315948 :   return getScalarType()->getPrimitiveSizeInBits();
     132             : }
     133             : 
     134         365 : int Type::getFPMantissaWidth() const {
     135             :   if (auto *VTy = dyn_cast<VectorType>(this))
     136          24 :     return VTy->getElementType()->getFPMantissaWidth();
     137             :   assert(isFloatingPointTy() && "Not a floating point type!");
     138             :   if (getTypeID() == HalfTyID) return 11;
     139         326 :   if (getTypeID() == FloatTyID) return 24;
     140         180 :   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             :   return -1;
     145             : }
     146             : 
     147   145931542 : bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
     148             :   if (auto *ATy = dyn_cast<ArrayType>(this))
     149   129565516 :     return ATy->getElementType()->isSized(Visited);
     150             : 
     151             :   if (auto *VTy = dyn_cast<VectorType>(this))
     152     1084633 :     return VTy->getElementType()->isSized(Visited);
     153             : 
     154    15281393 :   return cast<StructType>(this)->isSized(Visited);
     155             : }
     156             : 
     157             : //===----------------------------------------------------------------------===//
     158             : //                          Primitive 'Type' data
     159             : //===----------------------------------------------------------------------===//
     160             : 
     161    27351466 : Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
     162     8613404 : Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
     163      100037 : Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
     164      706059 : Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
     165      444007 : Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
     166      274310 : Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
     167        4408 : Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
     168       68385 : Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
     169       17611 : Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
     170        1562 : Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
     171       29581 : Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
     172             : 
     173    10965163 : IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
     174     9676524 : IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
     175      682891 : IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
     176    33725014 : IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
     177    35539440 : IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
     178      765525 : IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
     179             : 
     180     2819268 : IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
     181     2819268 :   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           2 : PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
     213           2 :   return getIntNTy(C, N)->getPointerTo(AS);
     214             : }
     215             : 
     216      135120 : PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
     217      135120 :   return getInt1Ty(C)->getPointerTo(AS);
     218             : }
     219             : 
     220      642150 : PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
     221      642150 :   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        6062 : PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
     229        6062 :   return getInt32Ty(C)->getPointerTo(AS);
     230             : }
     231             : 
     232      112395 : PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
     233      112395 :   return getInt64Ty(C)->getPointerTo(AS);
     234             : }
     235             : 
     236             : //===----------------------------------------------------------------------===//
     237             : //                       IntegerType Implementation
     238             : //===----------------------------------------------------------------------===//
     239             : 
     240    52955949 : 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    52955949 :   switch (NumBits) {
     246      414246 :   case   1: return cast<IntegerType>(Type::getInt1Ty(C));
     247     6799130 :   case   8: return cast<IntegerType>(Type::getInt8Ty(C));
     248      531774 :   case  16: return cast<IntegerType>(Type::getInt16Ty(C));
     249    20194373 :   case  32: return cast<IntegerType>(Type::getInt32Ty(C));
     250    23697031 :   case  64: return cast<IntegerType>(Type::getInt64Ty(C));
     251      765332 :   case 128: return cast<IntegerType>(Type::getInt128Ty(C));
     252             :   default:
     253             :     break;
     254             :   }
     255             : 
     256      554063 :   IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
     257             : 
     258      554063 :   if (!Entry)
     259       14219 :     Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
     260             : 
     261      554063 :   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         474 : APInt IntegerType::getMask() const {
     270         474 :   return APInt::getAllOnesValue(getBitWidth());
     271             : }
     272             : 
     273             : //===----------------------------------------------------------------------===//
     274             : //                       FunctionType Implementation
     275             : //===----------------------------------------------------------------------===//
     276             : 
     277      764051 : FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
     278      764051 :                            bool IsVarArgs)
     279      764051 :   : Type(Result->getContext(), FunctionTyID) {
     280      764051 :   Type **SubTys = reinterpret_cast<Type**>(this+1);
     281             :   assert(isValidReturnType(Result) && "invalid return type for function");
     282             :   setSubclassData(IsVarArgs);
     283             : 
     284      764051 :   SubTys[0] = Result;
     285             : 
     286     2134144 :   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
     287             :     assert(isValidArgumentType(Params[i]) &&
     288             :            "Not a valid type for function argument!");
     289     2740186 :     SubTys[i+1] = Params[i];
     290             :   }
     291             : 
     292      764051 :   ContainedTys = SubTys;
     293      764051 :   NumContainedTys = Params.size() + 1; // + 1 for result type
     294      764051 : }
     295             : 
     296             : // This is the factory function for the FunctionType class.
     297     8240281 : FunctionType *FunctionType::get(Type *ReturnType,
     298             :                                 ArrayRef<Type*> Params, bool isVarArg) {
     299     8240281 :   LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
     300     8240281 :   FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
     301             :   auto I = pImpl->FunctionTypes.find_as(Key);
     302             :   FunctionType *FT;
     303             : 
     304     8240281 :   if (I == pImpl->FunctionTypes.end()) {
     305      764051 :     FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
     306             :         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
     307             :         alignof(FunctionType));
     308      764051 :     new (FT) FunctionType(ReturnType, Params, isVarArg);
     309             :     pImpl->FunctionTypes.insert(FT);
     310             :   } else {
     311     7476230 :     FT = *I;
     312             :   }
     313             : 
     314     8240281 :   return FT;
     315             : }
     316             : 
     317      179348 : FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
     318      358696 :   return get(Result, None, isVarArg);
     319             : }
     320             : 
     321      494615 : bool FunctionType::isValidReturnType(Type *RetTy) {
     322      494615 :   return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
     323      494615 :   !RetTy->isMetadataTy();
     324             : }
     325             : 
     326      306248 : bool FunctionType::isValidArgumentType(Type *ArgTy) {
     327      306248 :   return ArgTy->isFirstClassType();
     328             : }
     329             : 
     330             : //===----------------------------------------------------------------------===//
     331             : //                       StructType Implementation
     332             : //===----------------------------------------------------------------------===//
     333             : 
     334             : // Primitive Constructors.
     335             : 
     336      472901 : StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
     337             :                             bool isPacked) {
     338      472901 :   LLVMContextImpl *pImpl = Context.pImpl;
     339      472901 :   AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
     340             :   auto I = pImpl->AnonStructTypes.find_as(Key);
     341             :   StructType *ST;
     342             : 
     343      472901 :   if (I == pImpl->AnonStructTypes.end()) {
     344             :     // Value not found.  Create a new type!
     345       30894 :     ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     346             :     ST->setSubclassData(SCDB_IsLiteral);  // Literal struct.
     347       30894 :     ST->setBody(ETypes, isPacked);
     348       30894 :     Context.pImpl->AnonStructTypes.insert(ST);
     349             :   } else {
     350      442007 :     ST = *I;
     351             :   }
     352             : 
     353      472901 :   return ST;
     354             : }
     355             : 
     356      286884 : void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
     357             :   assert(isOpaque() && "Struct body already set!");
     358             : 
     359             :   setSubclassData(getSubclassData() | SCDB_HasBody);
     360      286884 :   if (isPacked)
     361             :     setSubclassData(getSubclassData() | SCDB_Packed);
     362             : 
     363      286884 :   NumContainedTys = Elements.size();
     364             : 
     365      286884 :   if (Elements.empty()) {
     366       13984 :     ContainedTys = nullptr;
     367       13984 :     return;
     368             :   }
     369             : 
     370      272900 :   ContainedTys = Elements.copy(getContext().pImpl->TypeAllocator).data();
     371             : }
     372             : 
     373      258278 : void StructType::setName(StringRef Name) {
     374      258278 :   if (Name == getName()) return;
     375             : 
     376      258278 :   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      258278 :   if (SymbolTableEntry)
     383             :     SymbolTable.remove((EntryTy *)SymbolTableEntry);
     384             : 
     385             :   // If this is just removing the name, we're done.
     386      258278 :   if (Name.empty()) {
     387          85 :     if (SymbolTableEntry) {
     388             :       // Delete the old string data.
     389             :       ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
     390          85 :       SymbolTableEntry = nullptr;
     391             :     }
     392          85 :     return;
     393             :   }
     394             : 
     395             :   // Look up the entry for the name.
     396             :   auto IterBool =
     397      258193 :       getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
     398             : 
     399             :   // While we have a name collision, try a random rename.
     400      258193 :   if (!IterBool.second) {
     401             :     SmallString<64> TempStr(Name);
     402      103268 :     TempStr.push_back('.');
     403             :     raw_svector_ostream TmpStream(TempStr);
     404      103268 :     unsigned NameSize = Name.size();
     405             : 
     406             :     do {
     407      103268 :       TempStr.resize(NameSize + 1);
     408      103268 :       TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
     409             : 
     410      103268 :       IterBool = getContext().pImpl->NamedStructTypes.insert(
     411      103268 :           std::make_pair(TmpStream.str(), this));
     412      103268 :     } while (!IterBool.second);
     413             :   }
     414             : 
     415             :   // Delete the old string data.
     416      258193 :   if (SymbolTableEntry)
     417             :     ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
     418      258193 :   SymbolTableEntry = &*IterBool.first;
     419             : }
     420             : 
     421             : //===----------------------------------------------------------------------===//
     422             : // StructType Helper functions.
     423             : 
     424      260398 : StructType *StructType::create(LLVMContext &Context, StringRef Name) {
     425      260398 :   StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     426      260398 :   if (!Name.empty())
     427       26371 :     ST->setName(Name);
     428      260398 :   return ST;
     429             : }
     430             : 
     431         504 : StructType *StructType::get(LLVMContext &Context, bool isPacked) {
     432        1008 :   return get(Context, None, isPacked);
     433             : }
     434             : 
     435       34457 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
     436             :                                StringRef Name, bool isPacked) {
     437       34457 :   StructType *ST = create(Context, Name);
     438       34457 :   ST->setBody(Elements, isPacked);
     439       34457 :   return ST;
     440             : }
     441             : 
     442           3 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
     443           3 :   return create(Context, Elements, StringRef());
     444             : }
     445             : 
     446      207798 : StructType *StructType::create(LLVMContext &Context) {
     447      207798 :   return create(Context, StringRef());
     448             : }
     449             : 
     450        8402 : 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        8402 :   return create(Elements[0]->getContext(), Elements, Name, isPacked);
     455             : }
     456             : 
     457         589 : StructType *StructType::create(ArrayRef<Type*> Elements) {
     458             :   assert(!Elements.empty() &&
     459             :          "This method may not be invoked with an empty list");
     460         589 :   return create(Elements[0]->getContext(), Elements, StringRef());
     461             : }
     462             : 
     463    15281393 : bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
     464    15281393 :   if ((getSubclassData() & SCDB_IsSized) != 0)
     465             :     return true;
     466      142559 :   if (isOpaque())
     467             :     return false;
     468             : 
     469      141910 :   if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
     470           6 :     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      440365 :   for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
     476      298484 :     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      141881 :   return true;
     485             : }
     486             : 
     487     1594370 : StringRef StructType::getName() const {
     488             :   assert(!isLiteral() && "Literal structs never have names");
     489     1594370 :   if (!SymbolTableEntry) return StringRef();
     490             : 
     491             :   return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
     492             : }
     493             : 
     494      115822 : bool StructType::isValidElementType(Type *ElemTy) {
     495      115821 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     496      231643 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     497      115822 :          !ElemTy->isTokenTy();
     498             : }
     499             : 
     500       11819 : bool StructType::isLayoutIdentical(StructType *Other) const {
     501       11819 :   if (this == Other) return true;
     502             : 
     503       11819 :   if (isPacked() != Other->isPacked())
     504             :     return false;
     505             : 
     506       11711 :   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    76826086 : Type *CompositeType::getTypeAtIndex(const Value *V) const {
     518             :   if (auto *STy = dyn_cast<StructType>(this)) {
     519             :     unsigned Idx =
     520    21563980 :       (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
     521             :     assert(indexValid(Idx) && "Invalid structure index!");
     522    43127960 :     return STy->getElementType(Idx);
     523             :   }
     524             : 
     525    55262106 :   return cast<SequentialType>(this)->getElementType();
     526             : }
     527             : 
     528     2002179 : Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
     529             :   if (auto *STy = dyn_cast<StructType>(this)) {
     530             :     assert(indexValid(Idx) && "Invalid structure index!");
     531     3644146 :     return STy->getElementType(Idx);
     532             :   }
     533             : 
     534      180106 :   return cast<SequentialType>(this)->getElementType();
     535             : }
     536             : 
     537    46698506 : 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    18990478 :     if (!V->getType()->isIntOrIntVectorTy(32))
     542             :       return false;
     543             :     const Constant *C = dyn_cast<Constant>(V);
     544    18990476 :     if (C && V->getType()->isVectorTy())
     545         261 :       C = C->getSplatValue();
     546             :     const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
     547     9495237 :     return CU && CU->getZExtValue() < STy->getNumElements();
     548             :   }
     549             : 
     550             :   // Sequential types can be indexed by any integer.
     551    37203838 :   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      137290 : ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
     566      137290 :   : SequentialType(ArrayTyID, ElType, NumEl) {}
     567             : 
     568     1362985 : ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
     569             :   assert(isValidElementType(ElementType) && "Invalid type for array element!");
     570             : 
     571     1362985 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     572             :   ArrayType *&Entry =
     573     1362985 :     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
     574             : 
     575     1362985 :   if (!Entry)
     576      137290 :     Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
     577     1362985 :   return Entry;
     578             : }
     579             : 
     580      133133 : bool ArrayType::isValidElementType(Type *ElemTy) {
     581      133132 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     582      266265 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     583      133133 :          !ElemTy->isTokenTy();
     584             : }
     585             : 
     586             : //===----------------------------------------------------------------------===//
     587             : //                          VectorType Implementation
     588             : //===----------------------------------------------------------------------===//
     589             : 
     590       65600 : VectorType::VectorType(Type *ElType, unsigned NumEl)
     591      131200 :   : SequentialType(VectorTyID, ElType, NumEl) {}
     592             : 
     593     5048821 : 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     5048821 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     600             :   VectorType *&Entry = ElementType->getContext().pImpl
     601     5048821 :     ->VectorTypes[std::make_pair(ElementType, NumElements)];
     602             : 
     603     5048821 :   if (!Entry)
     604       65600 :     Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
     605     5048821 :   return Entry;
     606             : }
     607             : 
     608     1940779 : bool VectorType::isValidElementType(Type *ElemTy) {
     609     2005737 :   return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
     610     1940779 :     ElemTy->isPointerTy();
     611             : }
     612             : 
     613             : //===----------------------------------------------------------------------===//
     614             : //                         PointerType Implementation
     615             : //===----------------------------------------------------------------------===//
     616             : 
     617    74855965 : 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    74855965 :   LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
     622             : 
     623             :   // Since AddressSpace #0 is the common case, we special case it.
     624    74855965 :   PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
     625      330250 :      : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
     626             : 
     627    74855965 :   if (!Entry)
     628     1436043 :     Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
     629    74855965 :   return Entry;
     630             : }
     631             : 
     632     1436043 : PointerType::PointerType(Type *E, unsigned AddrSpace)
     633     2872086 :   : Type(E->getContext(), PointerTyID), PointeeTy(E) {
     634     1436043 :   ContainedTys = &PointeeTy;
     635     1436043 :   NumContainedTys = 1;
     636             :   setSubclassData(AddrSpace);
     637     1436043 : }
     638             : 
     639    23430978 : PointerType *Type::getPointerTo(unsigned addrs) const {
     640    23430978 :   return PointerType::get(const_cast<Type*>(this), addrs);
     641             : }
     642             : 
     643      971211 : bool PointerType::isValidElementType(Type *ElemTy) {
     644      971210 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     645     1942419 :          !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
     646             : }
     647             : 
     648       87274 : bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
     649       87274 :   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
     650             : }

Generated by: LCOV version 1.13