1//===-- Type.cpp - Implement the Type class -------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Type class for the VMCore library.
11//
12//===----------------------------------------------------------------------===//
13
14#include "LLVMContextImpl.h"
15#include "llvm/Module.h"
16#include <algorithm>
17#include <cstdarg>
18#include "llvm/ADT/SmallString.h"
19using namespace llvm;
20
21//===----------------------------------------------------------------------===//
22//                         Type Class Implementation
23//===----------------------------------------------------------------------===//
24
25Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
26  switch (IDNumber) {
27  case VoidTyID      : return getVoidTy(C);
28  case FloatTyID     : return getFloatTy(C);
29  case DoubleTyID    : return getDoubleTy(C);
30  case X86_FP80TyID  : return getX86_FP80Ty(C);
31  case FP128TyID     : return getFP128Ty(C);
32  case PPC_FP128TyID : return getPPC_FP128Ty(C);
33  case LabelTyID     : return getLabelTy(C);
34  case MetadataTyID  : return getMetadataTy(C);
35  case X86_MMXTyID   : return getX86_MMXTy(C);
36  default:
37    return 0;
38  }
39}
40
41/// getScalarType - If this is a vector type, return the element type,
42/// otherwise return this.
43Type *Type::getScalarType() {
44  if (VectorType *VTy = dyn_cast<VectorType>(this))
45    return VTy->getElementType();
46  return this;
47}
48
49/// isIntegerTy - Return true if this is an IntegerType of the specified width.
50bool Type::isIntegerTy(unsigned Bitwidth) const {
51  return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
52}
53
54/// isIntOrIntVectorTy - Return true if this is an integer type or a vector of
55/// integer types.
56///
57bool Type::isIntOrIntVectorTy() const {
58  if (isIntegerTy())
59    return true;
60  if (ID != Type::VectorTyID) return false;
61
62  return cast<VectorType>(this)->getElementType()->isIntegerTy();
63}
64
65/// isFPOrFPVectorTy - Return true if this is a FP type or a vector of FP types.
66///
67bool Type::isFPOrFPVectorTy() const {
68  if (ID == Type::FloatTyID || ID == Type::DoubleTyID ||
69      ID == Type::FP128TyID || ID == Type::X86_FP80TyID ||
70      ID == Type::PPC_FP128TyID)
71    return true;
72  if (ID != Type::VectorTyID) return false;
73
74  return cast<VectorType>(this)->getElementType()->isFloatingPointTy();
75}
76
77// canLosslesslyBitCastTo - Return true if this type can be converted to
78// 'Ty' without any reinterpretation of bits.  For example, i8* to i32*.
79//
80bool Type::canLosslesslyBitCastTo(Type *Ty) const {
81  // Identity cast means no change so return true
82  if (this == Ty)
83    return true;
84
85  // They are not convertible unless they are at least first class types
86  if (!this->isFirstClassType() || !Ty->isFirstClassType())
87    return false;
88
89  // Vector -> Vector conversions are always lossless if the two vector types
90  // have the same size, otherwise not.  Also, 64-bit vector types can be
91  // converted to x86mmx.
92  if (const VectorType *thisPTy = dyn_cast<VectorType>(this)) {
93    if (const VectorType *thatPTy = dyn_cast<VectorType>(Ty))
94      return thisPTy->getBitWidth() == thatPTy->getBitWidth();
95    if (Ty->getTypeID() == Type::X86_MMXTyID &&
96        thisPTy->getBitWidth() == 64)
97      return true;
98  }
99
100  if (this->getTypeID() == Type::X86_MMXTyID)
101    if (const VectorType *thatPTy = dyn_cast<VectorType>(Ty))
102      if (thatPTy->getBitWidth() == 64)
103        return true;
104
105  // At this point we have only various mismatches of the first class types
106  // remaining and ptr->ptr. Just select the lossless conversions. Everything
107  // else is not lossless.
108  if (this->isPointerTy())
109    return Ty->isPointerTy();
110  return false;  // Other types have no identity values
111}
112
113bool Type::isEmptyTy() const {
114  const ArrayType *ATy = dyn_cast<ArrayType>(this);
115  if (ATy) {
116    unsigned NumElements = ATy->getNumElements();
117    return NumElements == 0 || ATy->getElementType()->isEmptyTy();
118  }
119
120  const StructType *STy = dyn_cast<StructType>(this);
121  if (STy) {
122    unsigned NumElements = STy->getNumElements();
123    for (unsigned i = 0; i < NumElements; ++i)
124      if (!STy->getElementType(i)->isEmptyTy())
125        return false;
126    return true;
127  }
128
129  return false;
130}
131
132unsigned Type::getPrimitiveSizeInBits() const {
133  switch (getTypeID()) {
134  case Type::FloatTyID: return 32;
135  case Type::DoubleTyID: return 64;
136  case Type::X86_FP80TyID: return 80;
137  case Type::FP128TyID: return 128;
138  case Type::PPC_FP128TyID: return 128;
139  case Type::X86_MMXTyID: return 64;
140  case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
141  case Type::VectorTyID:  return cast<VectorType>(this)->getBitWidth();
142  default: return 0;
143  }
144}
145
146/// getScalarSizeInBits - If this is a vector type, return the
147/// getPrimitiveSizeInBits value for the element type. Otherwise return the
148/// getPrimitiveSizeInBits value for this type.
149unsigned Type::getScalarSizeInBits() {
150  return getScalarType()->getPrimitiveSizeInBits();
151}
152
153/// getFPMantissaWidth - Return the width of the mantissa of this type.  This
154/// is only valid on floating point types.  If the FP type does not
155/// have a stable mantissa (e.g. ppc long double), this method returns -1.
156int Type::getFPMantissaWidth() const {
157  if (const VectorType *VTy = dyn_cast<VectorType>(this))
158    return VTy->getElementType()->getFPMantissaWidth();
159  assert(isFloatingPointTy() && "Not a floating point type!");
160  if (ID == FloatTyID) return 24;
161  if (ID == DoubleTyID) return 53;
162  if (ID == X86_FP80TyID) return 64;
163  if (ID == FP128TyID) return 113;
164  assert(ID == PPC_FP128TyID && "unknown fp type");
165  return -1;
166}
167
168/// isSizedDerivedType - Derived types like structures and arrays are sized
169/// iff all of the members of the type are sized as well.  Since asking for
170/// their size is relatively uncommon, move this operation out of line.
171bool Type::isSizedDerivedType() const {
172  if (this->isIntegerTy())
173    return true;
174
175  if (const ArrayType *ATy = dyn_cast<ArrayType>(this))
176    return ATy->getElementType()->isSized();
177
178  if (const VectorType *VTy = dyn_cast<VectorType>(this))
179    return VTy->getElementType()->isSized();
180
181  if (!this->isStructTy())
182    return false;
183
184  // Opaque structs have no size.
185  if (cast<StructType>(this)->isOpaque())
186    return false;
187
188  // Okay, our struct is sized if all of the elements are.
189  for (subtype_iterator I = subtype_begin(), E = subtype_end(); I != E; ++I)
190    if (!(*I)->isSized())
191      return false;
192
193  return true;
194}
195
196//===----------------------------------------------------------------------===//
197//                          Primitive 'Type' data
198//===----------------------------------------------------------------------===//
199
200Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
201Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
202Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
203Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
204Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
205Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
206Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
207Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
208Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
209
210IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
211IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
212IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
213IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
214IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
215
216IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
217  return IntegerType::get(C, N);
218}
219
220PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
221  return getFloatTy(C)->getPointerTo(AS);
222}
223
224PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
225  return getDoubleTy(C)->getPointerTo(AS);
226}
227
228PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
229  return getX86_FP80Ty(C)->getPointerTo(AS);
230}
231
232PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
233  return getFP128Ty(C)->getPointerTo(AS);
234}
235
236PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
237  return getPPC_FP128Ty(C)->getPointerTo(AS);
238}
239
240PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
241  return getX86_MMXTy(C)->getPointerTo(AS);
242}
243
244PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
245  return getIntNTy(C, N)->getPointerTo(AS);
246}
247
248PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
249  return getInt1Ty(C)->getPointerTo(AS);
250}
251
252PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
253  return getInt8Ty(C)->getPointerTo(AS);
254}
255
256PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
257  return getInt16Ty(C)->getPointerTo(AS);
258}
259
260PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
261  return getInt32Ty(C)->getPointerTo(AS);
262}
263
264PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
265  return getInt64Ty(C)->getPointerTo(AS);
266}
267
268
269//===----------------------------------------------------------------------===//
270//                       IntegerType Implementation
271//===----------------------------------------------------------------------===//
272
273IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) {
274  assert(NumBits >= MIN_INT_BITS && "bitwidth too small");
275  assert(NumBits <= MAX_INT_BITS && "bitwidth too large");
276
277  // Check for the built-in integer types
278  switch (NumBits) {
279  case  1: return cast<IntegerType>(Type::getInt1Ty(C));
280  case  8: return cast<IntegerType>(Type::getInt8Ty(C));
281  case 16: return cast<IntegerType>(Type::getInt16Ty(C));
282  case 32: return cast<IntegerType>(Type::getInt32Ty(C));
283  case 64: return cast<IntegerType>(Type::getInt64Ty(C));
284  default:
285    break;
286  }
287
288  IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
289
290  if (Entry == 0)
291    Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
292
293  return Entry;
294}
295
296bool IntegerType::isPowerOf2ByteWidth() const {
297  unsigned BitWidth = getBitWidth();
298  return (BitWidth > 7) && isPowerOf2_32(BitWidth);
299}
300
301APInt IntegerType::getMask() const {
302  return APInt::getAllOnesValue(getBitWidth());
303}
304
305//===----------------------------------------------------------------------===//
306//                       FunctionType Implementation
307//===----------------------------------------------------------------------===//
308
309FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
310                           bool IsVarArgs)
311  : Type(Result->getContext(), FunctionTyID) {
312  Type **SubTys = reinterpret_cast<Type**>(this+1);
313  assert(isValidReturnType(Result) && "invalid return type for function");
314  setSubclassData(IsVarArgs);
315
316  SubTys[0] = const_cast<Type*>(Result);
317
318  for (unsigned i = 0, e = Params.size(); i != e; ++i) {
319    assert(isValidArgumentType(Params[i]) &&
320           "Not a valid type for function argument!");
321    SubTys[i+1] = Params[i];
322  }
323
324  ContainedTys = SubTys;
325  NumContainedTys = Params.size() + 1; // + 1 for result type
326}
327
328// FunctionType::get - The factory function for the FunctionType class.
329FunctionType *FunctionType::get(Type *ReturnType,
330                                ArrayRef<Type*> Params, bool isVarArg) {
331  // TODO: This is brutally slow.
332  std::vector<Type*> Key;
333  Key.reserve(Params.size()+2);
334  Key.push_back(const_cast<Type*>(ReturnType));
335  for (unsigned i = 0, e = Params.size(); i != e; ++i)
336    Key.push_back(const_cast<Type*>(Params[i]));
337  if (isVarArg)
338    Key.push_back(0);
339
340  LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
341  FunctionType *&FT = pImpl->FunctionTypes[Key];
342
343  if (FT == 0) {
344    FT = (FunctionType*) pImpl->TypeAllocator.
345      Allocate(sizeof(FunctionType) + sizeof(Type*)*(Params.size()+1),
346               AlignOf<FunctionType>::Alignment);
347    new (FT) FunctionType(ReturnType, Params, isVarArg);
348  }
349
350  return FT;
351}
352
353
354FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
355  return get(Result, ArrayRef<Type *>(), isVarArg);
356}
357
358
359/// isValidReturnType - Return true if the specified type is valid as a return
360/// type.
361bool FunctionType::isValidReturnType(Type *RetTy) {
362  return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
363  !RetTy->isMetadataTy();
364}
365
366/// isValidArgumentType - Return true if the specified type is valid as an
367/// argument type.
368bool FunctionType::isValidArgumentType(Type *ArgTy) {
369  return ArgTy->isFirstClassType();
370}
371
372//===----------------------------------------------------------------------===//
373//                       StructType Implementation
374//===----------------------------------------------------------------------===//
375
376// Primitive Constructors.
377
378StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
379                            bool isPacked) {
380  // FIXME: std::vector is horribly inefficient for this probe.
381  std::vector<Type*> Key;
382  for (unsigned i = 0, e = ETypes.size(); i != e; ++i) {
383    assert(isValidElementType(ETypes[i]) &&
384           "Invalid type for structure element!");
385    Key.push_back(ETypes[i]);
386  }
387  if (isPacked)
388    Key.push_back(0);
389
390  StructType *&ST = Context.pImpl->AnonStructTypes[Key];
391  if (ST) return ST;
392
393  // Value not found.  Create a new type!
394  ST = new (Context.pImpl->TypeAllocator) StructType(Context);
395  ST->setSubclassData(SCDB_IsLiteral);  // Literal struct.
396  ST->setBody(ETypes, isPacked);
397  return ST;
398}
399
400void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
401  assert(isOpaque() && "Struct body already set!");
402
403  setSubclassData(getSubclassData() | SCDB_HasBody);
404  if (isPacked)
405    setSubclassData(getSubclassData() | SCDB_Packed);
406
407  Type **Elts = getContext().pImpl->
408    TypeAllocator.Allocate<Type*>(Elements.size());
409  memcpy(Elts, Elements.data(), sizeof(Elements[0])*Elements.size());
410
411  ContainedTys = Elts;
412  NumContainedTys = Elements.size();
413}
414
415void StructType::setName(StringRef Name) {
416  if (Name == getName()) return;
417
418  // If this struct already had a name, remove its symbol table entry.
419  if (SymbolTableEntry) {
420    getContext().pImpl->NamedStructTypes.erase(getName());
421    SymbolTableEntry = 0;
422  }
423
424  // If this is just removing the name, we're done.
425  if (Name.empty())
426    return;
427
428  // Look up the entry for the name.
429  StringMapEntry<StructType*> *Entry =
430    &getContext().pImpl->NamedStructTypes.GetOrCreateValue(Name);
431
432  // While we have a name collision, try a random rename.
433  if (Entry->getValue()) {
434    SmallString<64> TempStr(Name);
435    TempStr.push_back('.');
436    raw_svector_ostream TmpStream(TempStr);
437
438    do {
439      TempStr.resize(Name.size()+1);
440      TmpStream.resync();
441      TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
442
443      Entry = &getContext().pImpl->
444                 NamedStructTypes.GetOrCreateValue(TmpStream.str());
445    } while (Entry->getValue());
446  }
447
448  // Okay, we found an entry that isn't used.  It's us!
449  Entry->setValue(this);
450
451  SymbolTableEntry = Entry;
452}
453
454//===----------------------------------------------------------------------===//
455// StructType Helper functions.
456
457StructType *StructType::create(LLVMContext &Context, StringRef Name) {
458  StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
459  if (!Name.empty())
460    ST->setName(Name);
461  return ST;
462}
463
464StructType *StructType::get(LLVMContext &Context, bool isPacked) {
465  return get(Context, llvm::ArrayRef<Type*>(), isPacked);
466}
467
468StructType *StructType::get(Type *type, ...) {
469  assert(type != 0 && "Cannot create a struct type with no elements with this");
470  LLVMContext &Ctx = type->getContext();
471  va_list ap;
472  SmallVector<llvm::Type*, 8> StructFields;
473  va_start(ap, type);
474  while (type) {
475    StructFields.push_back(type);
476    type = va_arg(ap, llvm::Type*);
477  }
478  return llvm::StructType::get(Ctx, StructFields);
479}
480
481StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
482                               StringRef Name, bool isPacked) {
483  StructType *ST = create(Context, Name);
484  ST->setBody(Elements, isPacked);
485  return ST;
486}
487
488StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
489  return create(Context, Elements, StringRef());
490}
491
492StructType *StructType::create(LLVMContext &Context) {
493  return create(Context, StringRef());
494}
495
496
497StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name,
498                               bool isPacked) {
499  assert(!Elements.empty() &&
500         "This method may not be invoked with an empty list");
501  return create(Elements[0]->getContext(), Elements, Name, isPacked);
502}
503
504StructType *StructType::create(ArrayRef<Type*> Elements) {
505  assert(!Elements.empty() &&
506         "This method may not be invoked with an empty list");
507  return create(Elements[0]->getContext(), Elements, StringRef());
508}
509
510StructType *StructType::create(StringRef Name, Type *type, ...) {
511  assert(type != 0 && "Cannot create a struct type with no elements with this");
512  LLVMContext &Ctx = type->getContext();
513  va_list ap;
514  SmallVector<llvm::Type*, 8> StructFields;
515  va_start(ap, type);
516  while (type) {
517    StructFields.push_back(type);
518    type = va_arg(ap, llvm::Type*);
519  }
520  return llvm::StructType::create(Ctx, StructFields, Name);
521}
522
523
524StringRef StructType::getName() const {
525  assert(!isLiteral() && "Literal structs never have names");
526  if (SymbolTableEntry == 0) return StringRef();
527
528  return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
529}
530
531void StructType::setBody(Type *type, ...) {
532  assert(type != 0 && "Cannot create a struct type with no elements with this");
533  va_list ap;
534  SmallVector<llvm::Type*, 8> StructFields;
535  va_start(ap, type);
536  while (type) {
537    StructFields.push_back(type);
538    type = va_arg(ap, llvm::Type*);
539  }
540  setBody(StructFields);
541}
542
543bool StructType::isValidElementType(Type *ElemTy) {
544  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
545         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy();
546}
547
548/// isLayoutIdentical - Return true if this is layout identical to the
549/// specified struct.
550bool StructType::isLayoutIdentical(StructType *Other) const {
551  if (this == Other) return true;
552
553  if (isPacked() != Other->isPacked() ||
554      getNumElements() != Other->getNumElements())
555    return false;
556
557  return std::equal(element_begin(), element_end(), Other->element_begin());
558}
559
560
561/// getTypeByName - Return the type with the specified name, or null if there
562/// is none by that name.
563StructType *Module::getTypeByName(StringRef Name) const {
564  StringMap<StructType*>::iterator I =
565    getContext().pImpl->NamedStructTypes.find(Name);
566  if (I != getContext().pImpl->NamedStructTypes.end())
567    return I->second;
568  return 0;
569}
570
571
572//===----------------------------------------------------------------------===//
573//                       CompositeType Implementation
574//===----------------------------------------------------------------------===//
575
576Type *CompositeType::getTypeAtIndex(const Value *V) {
577  if (StructType *STy = dyn_cast<StructType>(this)) {
578    unsigned Idx = (unsigned)cast<ConstantInt>(V)->getZExtValue();
579    assert(indexValid(Idx) && "Invalid structure index!");
580    return STy->getElementType(Idx);
581  }
582
583  return cast<SequentialType>(this)->getElementType();
584}
585Type *CompositeType::getTypeAtIndex(unsigned Idx) {
586  if (StructType *STy = dyn_cast<StructType>(this)) {
587    assert(indexValid(Idx) && "Invalid structure index!");
588    return STy->getElementType(Idx);
589  }
590
591  return cast<SequentialType>(this)->getElementType();
592}
593bool CompositeType::indexValid(const Value *V) const {
594  if (const StructType *STy = dyn_cast<StructType>(this)) {
595    // Structure indexes require 32-bit integer constants.
596    if (V->getType()->isIntegerTy(32))
597      if (const ConstantInt *CU = dyn_cast<ConstantInt>(V))
598        return CU->getZExtValue() < STy->getNumElements();
599    return false;
600  }
601
602  // Sequential types can be indexed by any integer.
603  return V->getType()->isIntegerTy();
604}
605
606bool CompositeType::indexValid(unsigned Idx) const {
607  if (const StructType *STy = dyn_cast<StructType>(this))
608    return Idx < STy->getNumElements();
609  // Sequential types can be indexed by any integer.
610  return true;
611}
612
613
614//===----------------------------------------------------------------------===//
615//                           ArrayType Implementation
616//===----------------------------------------------------------------------===//
617
618ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
619  : SequentialType(ArrayTyID, ElType) {
620  NumElements = NumEl;
621}
622
623
624ArrayType *ArrayType::get(Type *elementType, uint64_t NumElements) {
625  Type *ElementType = const_cast<Type*>(elementType);
626  assert(isValidElementType(ElementType) && "Invalid type for array element!");
627
628  LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
629  ArrayType *&Entry =
630    pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
631
632  if (Entry == 0)
633    Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
634  return Entry;
635}
636
637bool ArrayType::isValidElementType(Type *ElemTy) {
638  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
639         !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy();
640}
641
642//===----------------------------------------------------------------------===//
643//                          VectorType Implementation
644//===----------------------------------------------------------------------===//
645
646VectorType::VectorType(Type *ElType, unsigned NumEl)
647  : SequentialType(VectorTyID, ElType) {
648  NumElements = NumEl;
649}
650
651VectorType *VectorType::get(Type *elementType, unsigned NumElements) {
652  Type *ElementType = const_cast<Type*>(elementType);
653  assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0");
654  assert(isValidElementType(ElementType) &&
655         "Elements of a VectorType must be a primitive type");
656
657  LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
658  VectorType *&Entry = ElementType->getContext().pImpl
659    ->VectorTypes[std::make_pair(ElementType, NumElements)];
660
661  if (Entry == 0)
662    Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
663  return Entry;
664}
665
666bool VectorType::isValidElementType(Type *ElemTy) {
667  return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy();
668}
669
670//===----------------------------------------------------------------------===//
671//                         PointerType Implementation
672//===----------------------------------------------------------------------===//
673
674PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) {
675  assert(EltTy && "Can't get a pointer to <null> type!");
676  assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
677
678  LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
679
680  // Since AddressSpace #0 is the common case, we special case it.
681  PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
682     : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
683
684  if (Entry == 0)
685    Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
686  return Entry;
687}
688
689
690PointerType::PointerType(Type *E, unsigned AddrSpace)
691  : SequentialType(PointerTyID, E) {
692  setSubclassData(AddrSpace);
693}
694
695PointerType *Type::getPointerTo(unsigned addrs) {
696  return PointerType::get(this, addrs);
697}
698
699bool PointerType::isValidElementType(Type *ElemTy) {
700  return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
701         !ElemTy->isMetadataTy();
702}
703