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-09-23 13:06:45 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    49976566 : bool Type::isIntegerTy(unsigned Bitwidth) const {
      58    49976566 :   return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
      59             : }
      60             : 
      61        2208 : bool Type::canLosslesslyBitCastTo(Type *Ty) const {
      62             :   // Identity cast means no change so return true
      63        2208 :   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    16862668 : bool Type::isEmptyTy() const {
      99             :   if (auto *ATy = dyn_cast<ArrayType>(this)) {
     100         550 :     unsigned NumElements = ATy->getNumElements();
     101         550 :     return NumElements == 0 || ATy->getElementType()->isEmptyTy();
     102             :   }
     103             : 
     104             :   if (auto *STy = dyn_cast<StructType>(this)) {
     105      421606 :     unsigned NumElements = STy->getNumElements();
     106      421611 :     for (unsigned i = 0; i < NumElements; ++i)
     107      843184 :       if (!STy->getElementType(i)->isEmptyTy())
     108             :         return false;
     109             :     return true;
     110             :   }
     111             : 
     112             :   return false;
     113             : }
     114             : 
     115    98818665 : unsigned Type::getPrimitiveSizeInBits() const {
     116    98818665 :   switch (getTypeID()) {
     117             :   case Type::HalfTyID: return 16;
     118      168585 :   case Type::FloatTyID: return 32;
     119      101414 :   case Type::DoubleTyID: return 64;
     120        1827 :   case Type::X86_FP80TyID: return 80;
     121        3744 :   case Type::FP128TyID: return 128;
     122         325 :   case Type::PPC_FP128TyID: return 128;
     123       22528 :   case Type::X86_MMXTyID: return 64;
     124    82440882 :   case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
     125      460714 :   case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
     126    15564370 :   default: return 0;
     127             :   }
     128             : }
     129             : 
     130    69881061 : unsigned Type::getScalarSizeInBits() const {
     131    69881061 :   return getScalarType()->getPrimitiveSizeInBits();
     132             : }
     133             : 
     134         364 : 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         325 :   if (getTypeID() == FloatTyID) return 24;
     140         178 :   if (getTypeID() == DoubleTyID) return 53;
     141          34 :   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   147257930 : bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
     148             :   if (auto *ATy = dyn_cast<ArrayType>(this))
     149   130759445 :     return ATy->getElementType()->isSized(Visited);
     150             : 
     151             :   if (auto *VTy = dyn_cast<VectorType>(this))
     152     1085885 :     return VTy->getElementType()->isSized(Visited);
     153             : 
     154    15412600 :   return cast<StructType>(this)->isSized(Visited);
     155             : }
     156             : 
     157             : //===----------------------------------------------------------------------===//
     158             : //                          Primitive 'Type' data
     159             : //===----------------------------------------------------------------------===//
     160             : 
     161    27614092 : Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
     162     8672157 : Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
     163      101163 : Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
     164      702358 : Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
     165      442178 : Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
     166      387161 : Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
     167        4401 : Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
     168       69027 : Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
     169       17706 : Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
     170        1563 : 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    11004204 : IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
     174     9877304 : IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
     175      681818 : IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
     176    34439241 : IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
     177    35488694 : IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
     178      771090 : IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
     179             : 
     180     2845324 : IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
     181     2845324 :   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      138082 : PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
     217      138082 :   return getInt1Ty(C)->getPointerTo(AS);
     218             : }
     219             : 
     220      645379 : PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
     221      645379 :   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        6058 : PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
     229        6058 :   return getInt32Ty(C)->getPointerTo(AS);
     230             : }
     231             : 
     232      113017 : PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
     233      113017 :   return getInt64Ty(C)->getPointerTo(AS);
     234             : }
     235             : 
     236             : //===----------------------------------------------------------------------===//
     237             : //                       IntegerType Implementation
     238             : //===----------------------------------------------------------------------===//
     239             : 
     240    53501129 : 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    53501129 :   switch (NumBits) {
     246      414395 :   case   1: return cast<IntegerType>(Type::getInt1Ty(C));
     247     6981277 :   case   8: return cast<IntegerType>(Type::getInt8Ty(C));
     248      529725 :   case  16: return cast<IntegerType>(Type::getInt16Ty(C));
     249    20716611 :   case  32: return cast<IntegerType>(Type::getInt32Ty(C));
     250    23568820 :   case  64: return cast<IntegerType>(Type::getInt64Ty(C));
     251      770897 :   case 128: return cast<IntegerType>(Type::getInt128Ty(C));
     252             :   default:
     253             :     break;
     254             :   }
     255             : 
     256      519404 :   IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
     257             : 
     258      519404 :   if (!Entry)
     259       14137 :     Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
     260             : 
     261      519404 :   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      785103 : FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
     278      785103 :                            bool IsVarArgs)
     279      785103 :   : Type(Result->getContext(), FunctionTyID) {
     280      785103 :   Type **SubTys = reinterpret_cast<Type**>(this+1);
     281             :   assert(isValidReturnType(Result) && "invalid return type for function");
     282             :   setSubclassData(IsVarArgs);
     283             : 
     284      785103 :   SubTys[0] = Result;
     285             : 
     286     2186662 :   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
     287             :     assert(isValidArgumentType(Params[i]) &&
     288             :            "Not a valid type for function argument!");
     289     2803118 :     SubTys[i+1] = Params[i];
     290             :   }
     291             : 
     292      785103 :   ContainedTys = SubTys;
     293      785103 :   NumContainedTys = Params.size() + 1; // + 1 for result type
     294      785103 : }
     295             : 
     296             : // This is the factory function for the FunctionType class.
     297     8433637 : FunctionType *FunctionType::get(Type *ReturnType,
     298             :                                 ArrayRef<Type*> Params, bool isVarArg) {
     299     8433637 :   LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
     300     8433637 :   FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
     301             :   auto I = pImpl->FunctionTypes.find_as(Key);
     302             :   FunctionType *FT;
     303             : 
     304     8433637 :   if (I == pImpl->FunctionTypes.end()) {
     305      785103 :     FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
     306             :         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
     307             :         alignof(FunctionType));
     308      785104 :     new (FT) FunctionType(ReturnType, Params, isVarArg);
     309             :     pImpl->FunctionTypes.insert(FT);
     310             :   } else {
     311     7648534 :     FT = *I;
     312             :   }
     313             : 
     314     8433637 :   return FT;
     315             : }
     316             : 
     317      184003 : FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
     318      368006 :   return get(Result, None, isVarArg);
     319             : }
     320             : 
     321      490126 : bool FunctionType::isValidReturnType(Type *RetTy) {
     322      490126 :   return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
     323      490126 :   !RetTy->isMetadataTy();
     324             : }
     325             : 
     326      303293 : bool FunctionType::isValidArgumentType(Type *ArgTy) {
     327      303293 :   return ArgTy->isFirstClassType();
     328             : }
     329             : 
     330             : //===----------------------------------------------------------------------===//
     331             : //                       StructType Implementation
     332             : //===----------------------------------------------------------------------===//
     333             : 
     334             : // Primitive Constructors.
     335             : 
     336      480075 : StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
     337             :                             bool isPacked) {
     338      480075 :   LLVMContextImpl *pImpl = Context.pImpl;
     339      480075 :   AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
     340             :   auto I = pImpl->AnonStructTypes.find_as(Key);
     341             :   StructType *ST;
     342             : 
     343      480075 :   if (I == pImpl->AnonStructTypes.end()) {
     344             :     // Value not found.  Create a new type!
     345       31977 :     ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     346             :     ST->setSubclassData(SCDB_IsLiteral);  // Literal struct.
     347       31977 :     ST->setBody(ETypes, isPacked);
     348       31977 :     Context.pImpl->AnonStructTypes.insert(ST);
     349             :   } else {
     350      448098 :     ST = *I;
     351             :   }
     352             : 
     353      480075 :   return ST;
     354             : }
     355             : 
     356      297104 : void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
     357             :   assert(isOpaque() && "Struct body already set!");
     358             : 
     359             :   setSubclassData(getSubclassData() | SCDB_HasBody);
     360      297104 :   if (isPacked)
     361             :     setSubclassData(getSubclassData() | SCDB_Packed);
     362             : 
     363      297104 :   NumContainedTys = Elements.size();
     364             : 
     365      297104 :   if (Elements.empty()) {
     366       14522 :     ContainedTys = nullptr;
     367       14522 :     return;
     368             :   }
     369             : 
     370      282582 :   ContainedTys = Elements.copy(getContext().pImpl->TypeAllocator).data();
     371             : }
     372             : 
     373      267533 : void StructType::setName(StringRef Name) {
     374      267533 :   if (Name == getName()) return;
     375             : 
     376      267533 :   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      267533 :   if (SymbolTableEntry)
     383             :     SymbolTable.remove((EntryTy *)SymbolTableEntry);
     384             : 
     385             :   // If this is just removing the name, we're done.
     386      267533 :   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      267448 :       getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
     398             : 
     399             :   // While we have a name collision, try a random rename.
     400      267448 :   if (!IterBool.second) {
     401             :     SmallString<64> TempStr(Name);
     402      105766 :     TempStr.push_back('.');
     403             :     raw_svector_ostream TmpStream(TempStr);
     404      105766 :     unsigned NameSize = Name.size();
     405             : 
     406             :     do {
     407      105766 :       TempStr.resize(NameSize + 1);
     408      105766 :       TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
     409             : 
     410      105766 :       IterBool = getContext().pImpl->NamedStructTypes.insert(
     411      105766 :           std::make_pair(TmpStream.str(), this));
     412      105766 :     } while (!IterBool.second);
     413             :   }
     414             : 
     415             :   // Delete the old string data.
     416      267448 :   if (SymbolTableEntry)
     417             :     ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
     418      267448 :   SymbolTableEntry = &*IterBool.first;
     419             : }
     420             : 
     421             : //===----------------------------------------------------------------------===//
     422             : // StructType Helper functions.
     423             : 
     424      269652 : StructType *StructType::create(LLVMContext &Context, StringRef Name) {
     425      269652 :   StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
     426      269652 :   if (!Name.empty())
     427       26579 :     ST->setName(Name);
     428      269652 :   return ST;
     429             : }
     430             : 
     431         504 : StructType *StructType::get(LLVMContext &Context, bool isPacked) {
     432        1008 :   return get(Context, None, isPacked);
     433             : }
     434             : 
     435       35453 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
     436             :                                StringRef Name, bool isPacked) {
     437       35453 :   StructType *ST = create(Context, Name);
     438       35453 :   ST->setBody(Elements, isPacked);
     439       35453 :   return ST;
     440             : }
     441             : 
     442           3 : StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
     443           3 :   return create(Context, Elements, StringRef());
     444             : }
     445             : 
     446      216054 : StructType *StructType::create(LLVMContext &Context) {
     447      216054 :   return create(Context, StringRef());
     448             : }
     449             : 
     450        8608 : 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        8608 :   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    15412600 : bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
     464    15412600 :   if ((getSubclassData() & SCDB_IsSized) != 0)
     465             :     return true;
     466      147267 :   if (isOpaque())
     467             :     return false;
     468             : 
     469      146618 :   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      452112 :   for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
     476      305523 :     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      146589 :   return true;
     485             : }
     486             : 
     487     1600856 : StringRef StructType::getName() const {
     488             :   assert(!isLiteral() && "Literal structs never have names");
     489     1600856 :   if (!SymbolTableEntry) return StringRef();
     490             : 
     491             :   return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
     492             : }
     493             : 
     494      115721 : bool StructType::isValidElementType(Type *ElemTy) {
     495      115720 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     496      231441 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     497      115721 :          !ElemTy->isTokenTy();
     498             : }
     499             : 
     500       12888 : bool StructType::isLayoutIdentical(StructType *Other) const {
     501       12888 :   if (this == Other) return true;
     502             : 
     503       12888 :   if (isPacked() != Other->isPacked())
     504             :     return false;
     505             : 
     506       12799 :   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    77423501 : Type *CompositeType::getTypeAtIndex(const Value *V) const {
     518             :   if (auto *STy = dyn_cast<StructType>(this)) {
     519             :     unsigned Idx =
     520    21643940 :       (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
     521             :     assert(indexValid(Idx) && "Invalid structure index!");
     522    43287880 :     return STy->getElementType(Idx);
     523             :   }
     524             : 
     525    55779561 :   return cast<SequentialType>(this)->getElementType();
     526             : }
     527             : 
     528     2019889 : Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
     529             :   if (auto *STy = dyn_cast<StructType>(this)) {
     530             :     assert(indexValid(Idx) && "Invalid structure index!");
     531     3677354 :     return STy->getElementType(Idx);
     532             :   }
     533             : 
     534      181212 :   return cast<SequentialType>(this)->getElementType();
     535             : }
     536             : 
     537    47105279 : 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    19116316 :     if (!V->getType()->isIntOrIntVectorTy(32))
     542             :       return false;
     543             :     const Constant *C = dyn_cast<Constant>(V);
     544    19116314 :     if (C && V->getType()->isVectorTy())
     545         261 :       C = C->getSplatValue();
     546             :     const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
     547     9558155 :     return CU && CU->getZExtValue() < STy->getNumElements();
     548             :   }
     549             : 
     550             :   // Sequential types can be indexed by any integer.
     551    37547692 :   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      139444 : ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
     566      139444 :   : SequentialType(ArrayTyID, ElType, NumEl) {}
     567             : 
     568     1364313 : ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
     569             :   assert(isValidElementType(ElementType) && "Invalid type for array element!");
     570             : 
     571     1364313 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     572             :   ArrayType *&Entry =
     573     1364313 :     pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
     574             : 
     575     1364313 :   if (!Entry)
     576      139443 :     Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
     577     1364313 :   return Entry;
     578             : }
     579             : 
     580      132838 : bool ArrayType::isValidElementType(Type *ElemTy) {
     581      132837 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     582      265675 :          !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
     583      132838 :          !ElemTy->isTokenTy();
     584             : }
     585             : 
     586             : //===----------------------------------------------------------------------===//
     587             : //                          VectorType Implementation
     588             : //===----------------------------------------------------------------------===//
     589             : 
     590       65058 : VectorType::VectorType(Type *ElType, unsigned NumEl)
     591      130116 :   : SequentialType(VectorTyID, ElType, NumEl) {}
     592             : 
     593     5042131 : 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     5042131 :   LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
     600             :   VectorType *&Entry = ElementType->getContext().pImpl
     601     5042131 :     ->VectorTypes[std::make_pair(ElementType, NumElements)];
     602             : 
     603     5042131 :   if (!Entry)
     604       65058 :     Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
     605     5042131 :   return Entry;
     606             : }
     607             : 
     608     1933289 : bool VectorType::isValidElementType(Type *ElemTy) {
     609     1998006 :   return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
     610     1933289 :     ElemTy->isPointerTy();
     611             : }
     612             : 
     613             : //===----------------------------------------------------------------------===//
     614             : //                         PointerType Implementation
     615             : //===----------------------------------------------------------------------===//
     616             : 
     617    75729961 : 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    75729961 :   LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
     622             : 
     623             :   // Since AddressSpace #0 is the common case, we special case it.
     624    75729961 :   PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
     625      326624 :      : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
     626             : 
     627    75729961 :   if (!Entry)
     628     1474047 :     Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
     629    75729962 :   return Entry;
     630             : }
     631             : 
     632     1474048 : PointerType::PointerType(Type *E, unsigned AddrSpace)
     633     2948096 :   : Type(E->getContext(), PointerTyID), PointeeTy(E) {
     634     1474048 :   ContainedTys = &PointeeTy;
     635     1474048 :   NumContainedTys = 1;
     636             :   setSubclassData(AddrSpace);
     637     1474048 : }
     638             : 
     639    23644844 : PointerType *Type::getPointerTo(unsigned addrs) const {
     640    23644844 :   return PointerType::get(const_cast<Type*>(this), addrs);
     641             : }
     642             : 
     643      967007 : bool PointerType::isValidElementType(Type *ElemTy) {
     644      967007 :   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
     645     1934012 :          !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
     646             : }
     647             : 
     648       87250 : bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
     649       87250 :   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
     650             : }

Generated by: LCOV version 1.13