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
getPrimitiveType(LLVMContext & C,TypeID IDNumber)39 Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
40 switch (IDNumber) {
41 case VoidTyID : return getVoidTy(C);
42 case HalfTyID : return getHalfTy(C);
43 case FloatTyID : return getFloatTy(C);
44 case DoubleTyID : return getDoubleTy(C);
45 case X86_FP80TyID : return getX86_FP80Ty(C);
46 case FP128TyID : return getFP128Ty(C);
47 case PPC_FP128TyID : return getPPC_FP128Ty(C);
48 case LabelTyID : return getLabelTy(C);
49 case MetadataTyID : return getMetadataTy(C);
50 case X86_MMXTyID : return getX86_MMXTy(C);
51 case TokenTyID : return getTokenTy(C);
52 default:
53 return nullptr;
54 }
55 }
56
isIntegerTy(unsigned Bitwidth) const57 bool Type::isIntegerTy(unsigned Bitwidth) const {
58 return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
59 }
60
canLosslesslyBitCastTo(Type * Ty) const61 bool Type::canLosslesslyBitCastTo(Type *Ty) const {
62 // Identity cast means no change so return true
63 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 return thisPTy->getBitWidth() == thatPTy->getBitWidth();
76 if (Ty->getTypeID() == Type::X86_MMXTyID &&
77 thisPTy->getBitWidth() == 64)
78 return true;
79 }
80
81 if (this->getTypeID() == Type::X86_MMXTyID)
82 if (auto *thatPTy = dyn_cast<VectorType>(Ty))
83 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 return PTy->getAddressSpace() == OtherPTy->getAddressSpace();
93 return false;
94 }
95 return false; // Other types have no identity values
96 }
97
isEmptyTy() const98 bool Type::isEmptyTy() const {
99 if (auto *ATy = dyn_cast<ArrayType>(this)) {
100 unsigned NumElements = ATy->getNumElements();
101 return NumElements == 0 || ATy->getElementType()->isEmptyTy();
102 }
103
104 if (auto *STy = dyn_cast<StructType>(this)) {
105 unsigned NumElements = STy->getNumElements();
106 for (unsigned i = 0; i < NumElements; ++i)
107 if (!STy->getElementType(i)->isEmptyTy())
108 return false;
109 return true;
110 }
111
112 return false;
113 }
114
getPrimitiveSizeInBits() const115 unsigned Type::getPrimitiveSizeInBits() const {
116 switch (getTypeID()) {
117 case Type::HalfTyID: return 16;
118 case Type::FloatTyID: return 32;
119 case Type::DoubleTyID: return 64;
120 case Type::X86_FP80TyID: return 80;
121 case Type::FP128TyID: return 128;
122 case Type::PPC_FP128TyID: return 128;
123 case Type::X86_MMXTyID: return 64;
124 case Type::IntegerTyID: return cast<IntegerType>(this)->getBitWidth();
125 case Type::VectorTyID: return cast<VectorType>(this)->getBitWidth();
126 default: return 0;
127 }
128 }
129
getScalarSizeInBits() const130 unsigned Type::getScalarSizeInBits() const {
131 return getScalarType()->getPrimitiveSizeInBits();
132 }
133
getFPMantissaWidth() const134 int Type::getFPMantissaWidth() const {
135 if (auto *VTy = dyn_cast<VectorType>(this))
136 return VTy->getElementType()->getFPMantissaWidth();
137 assert(isFloatingPointTy() && "Not a floating point type!");
138 if (getTypeID() == HalfTyID) return 11;
139 if (getTypeID() == FloatTyID) return 24;
140 if (getTypeID() == DoubleTyID) return 53;
141 if (getTypeID() == X86_FP80TyID) return 64;
142 if (getTypeID() == FP128TyID) return 113;
143 assert(getTypeID() == PPC_FP128TyID && "unknown fp type");
144 return -1;
145 }
146
isSizedDerivedType(SmallPtrSetImpl<Type * > * Visited) const147 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
148 if (auto *ATy = dyn_cast<ArrayType>(this))
149 return ATy->getElementType()->isSized(Visited);
150
151 if (auto *VTy = dyn_cast<VectorType>(this))
152 return VTy->getElementType()->isSized(Visited);
153
154 return cast<StructType>(this)->isSized(Visited);
155 }
156
157 //===----------------------------------------------------------------------===//
158 // Primitive 'Type' data
159 //===----------------------------------------------------------------------===//
160
getVoidTy(LLVMContext & C)161 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
getLabelTy(LLVMContext & C)162 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
getHalfTy(LLVMContext & C)163 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
getFloatTy(LLVMContext & C)164 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
getDoubleTy(LLVMContext & C)165 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
getMetadataTy(LLVMContext & C)166 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
getTokenTy(LLVMContext & C)167 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
getX86_FP80Ty(LLVMContext & C)168 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
getFP128Ty(LLVMContext & C)169 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
getPPC_FP128Ty(LLVMContext & C)170 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
getX86_MMXTy(LLVMContext & C)171 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
172
getInt1Ty(LLVMContext & C)173 IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
getInt8Ty(LLVMContext & C)174 IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
getInt16Ty(LLVMContext & C)175 IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
getInt32Ty(LLVMContext & C)176 IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
getInt64Ty(LLVMContext & C)177 IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
getInt128Ty(LLVMContext & C)178 IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
179
getIntNTy(LLVMContext & C,unsigned N)180 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
181 return IntegerType::get(C, N);
182 }
183
getHalfPtrTy(LLVMContext & C,unsigned AS)184 PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
185 return getHalfTy(C)->getPointerTo(AS);
186 }
187
getFloatPtrTy(LLVMContext & C,unsigned AS)188 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
189 return getFloatTy(C)->getPointerTo(AS);
190 }
191
getDoublePtrTy(LLVMContext & C,unsigned AS)192 PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
193 return getDoubleTy(C)->getPointerTo(AS);
194 }
195
getX86_FP80PtrTy(LLVMContext & C,unsigned AS)196 PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
197 return getX86_FP80Ty(C)->getPointerTo(AS);
198 }
199
getFP128PtrTy(LLVMContext & C,unsigned AS)200 PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
201 return getFP128Ty(C)->getPointerTo(AS);
202 }
203
getPPC_FP128PtrTy(LLVMContext & C,unsigned AS)204 PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
205 return getPPC_FP128Ty(C)->getPointerTo(AS);
206 }
207
getX86_MMXPtrTy(LLVMContext & C,unsigned AS)208 PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
209 return getX86_MMXTy(C)->getPointerTo(AS);
210 }
211
getIntNPtrTy(LLVMContext & C,unsigned N,unsigned AS)212 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
213 return getIntNTy(C, N)->getPointerTo(AS);
214 }
215
getInt1PtrTy(LLVMContext & C,unsigned AS)216 PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
217 return getInt1Ty(C)->getPointerTo(AS);
218 }
219
getInt8PtrTy(LLVMContext & C,unsigned AS)220 PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
221 return getInt8Ty(C)->getPointerTo(AS);
222 }
223
getInt16PtrTy(LLVMContext & C,unsigned AS)224 PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
225 return getInt16Ty(C)->getPointerTo(AS);
226 }
227
getInt32PtrTy(LLVMContext & C,unsigned AS)228 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
229 return getInt32Ty(C)->getPointerTo(AS);
230 }
231
getInt64PtrTy(LLVMContext & C,unsigned AS)232 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
233 return getInt64Ty(C)->getPointerTo(AS);
234 }
235
236 //===----------------------------------------------------------------------===//
237 // IntegerType Implementation
238 //===----------------------------------------------------------------------===//
239
get(LLVMContext & C,unsigned NumBits)240 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 switch (NumBits) {
246 case 1: return cast<IntegerType>(Type::getInt1Ty(C));
247 case 8: return cast<IntegerType>(Type::getInt8Ty(C));
248 case 16: return cast<IntegerType>(Type::getInt16Ty(C));
249 case 32: return cast<IntegerType>(Type::getInt32Ty(C));
250 case 64: return cast<IntegerType>(Type::getInt64Ty(C));
251 case 128: return cast<IntegerType>(Type::getInt128Ty(C));
252 default:
253 break;
254 }
255
256 IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
257
258 if (!Entry)
259 Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
260
261 return Entry;
262 }
263
isPowerOf2ByteWidth() const264 bool IntegerType::isPowerOf2ByteWidth() const {
265 unsigned BitWidth = getBitWidth();
266 return (BitWidth > 7) && isPowerOf2_32(BitWidth);
267 }
268
getMask() const269 APInt IntegerType::getMask() const {
270 return APInt::getAllOnesValue(getBitWidth());
271 }
272
273 //===----------------------------------------------------------------------===//
274 // FunctionType Implementation
275 //===----------------------------------------------------------------------===//
276
FunctionType(Type * Result,ArrayRef<Type * > Params,bool IsVarArgs)277 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
278 bool IsVarArgs)
279 : Type(Result->getContext(), FunctionTyID) {
280 Type **SubTys = reinterpret_cast<Type**>(this+1);
281 assert(isValidReturnType(Result) && "invalid return type for function");
282 setSubclassData(IsVarArgs);
283
284 SubTys[0] = Result;
285
286 for (unsigned i = 0, e = Params.size(); i != e; ++i) {
287 assert(isValidArgumentType(Params[i]) &&
288 "Not a valid type for function argument!");
289 SubTys[i+1] = Params[i];
290 }
291
292 ContainedTys = SubTys;
293 NumContainedTys = Params.size() + 1; // + 1 for result type
294 }
295
296 // This is the factory function for the FunctionType class.
get(Type * ReturnType,ArrayRef<Type * > Params,bool isVarArg)297 FunctionType *FunctionType::get(Type *ReturnType,
298 ArrayRef<Type*> Params, bool isVarArg) {
299 LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
300 FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
301 auto I = pImpl->FunctionTypes.find_as(Key);
302 FunctionType *FT;
303
304 if (I == pImpl->FunctionTypes.end()) {
305 FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
306 sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
307 alignof(FunctionType));
308 new (FT) FunctionType(ReturnType, Params, isVarArg);
309 pImpl->FunctionTypes.insert(FT);
310 } else {
311 FT = *I;
312 }
313
314 return FT;
315 }
316
get(Type * Result,bool isVarArg)317 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
318 return get(Result, None, isVarArg);
319 }
320
isValidReturnType(Type * RetTy)321 bool FunctionType::isValidReturnType(Type *RetTy) {
322 return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
323 !RetTy->isMetadataTy();
324 }
325
isValidArgumentType(Type * ArgTy)326 bool FunctionType::isValidArgumentType(Type *ArgTy) {
327 return ArgTy->isFirstClassType();
328 }
329
330 //===----------------------------------------------------------------------===//
331 // StructType Implementation
332 //===----------------------------------------------------------------------===//
333
334 // Primitive Constructors.
335
get(LLVMContext & Context,ArrayRef<Type * > ETypes,bool isPacked)336 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
337 bool isPacked) {
338 LLVMContextImpl *pImpl = Context.pImpl;
339 AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
340 auto I = pImpl->AnonStructTypes.find_as(Key);
341 StructType *ST;
342
343 if (I == pImpl->AnonStructTypes.end()) {
344 // Value not found. Create a new type!
345 ST = new (Context.pImpl->TypeAllocator) StructType(Context);
346 ST->setSubclassData(SCDB_IsLiteral); // Literal struct.
347 ST->setBody(ETypes, isPacked);
348 Context.pImpl->AnonStructTypes.insert(ST);
349 } else {
350 ST = *I;
351 }
352
353 return ST;
354 }
355
setBody(ArrayRef<Type * > Elements,bool isPacked)356 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
357 assert(isOpaque() && "Struct body already set!");
358
359 setSubclassData(getSubclassData() | SCDB_HasBody);
360 if (isPacked)
361 setSubclassData(getSubclassData() | SCDB_Packed);
362
363 NumContainedTys = Elements.size();
364
365 if (Elements.empty()) {
366 ContainedTys = nullptr;
367 return;
368 }
369
370 ContainedTys = Elements.copy(getContext().pImpl->TypeAllocator).data();
371 }
372
setName(StringRef Name)373 void StructType::setName(StringRef Name) {
374 if (Name == getName()) return;
375
376 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 if (SymbolTableEntry)
383 SymbolTable.remove((EntryTy *)SymbolTableEntry);
384
385 // If this is just removing the name, we're done.
386 if (Name.empty()) {
387 if (SymbolTableEntry) {
388 // Delete the old string data.
389 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
390 SymbolTableEntry = nullptr;
391 }
392 return;
393 }
394
395 // Look up the entry for the name.
396 auto IterBool =
397 getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
398
399 // While we have a name collision, try a random rename.
400 if (!IterBool.second) {
401 SmallString<64> TempStr(Name);
402 TempStr.push_back('.');
403 raw_svector_ostream TmpStream(TempStr);
404 unsigned NameSize = Name.size();
405
406 do {
407 TempStr.resize(NameSize + 1);
408 TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
409
410 IterBool = getContext().pImpl->NamedStructTypes.insert(
411 std::make_pair(TmpStream.str(), this));
412 } while (!IterBool.second);
413 }
414
415 // Delete the old string data.
416 if (SymbolTableEntry)
417 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
418 SymbolTableEntry = &*IterBool.first;
419 }
420
421 //===----------------------------------------------------------------------===//
422 // StructType Helper functions.
423
create(LLVMContext & Context,StringRef Name)424 StructType *StructType::create(LLVMContext &Context, StringRef Name) {
425 StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
426 if (!Name.empty())
427 ST->setName(Name);
428 return ST;
429 }
430
get(LLVMContext & Context,bool isPacked)431 StructType *StructType::get(LLVMContext &Context, bool isPacked) {
432 return get(Context, None, isPacked);
433 }
434
create(LLVMContext & Context,ArrayRef<Type * > Elements,StringRef Name,bool isPacked)435 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
436 StringRef Name, bool isPacked) {
437 StructType *ST = create(Context, Name);
438 ST->setBody(Elements, isPacked);
439 return ST;
440 }
441
create(LLVMContext & Context,ArrayRef<Type * > Elements)442 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
443 return create(Context, Elements, StringRef());
444 }
445
create(LLVMContext & Context)446 StructType *StructType::create(LLVMContext &Context) {
447 return create(Context, StringRef());
448 }
449
create(ArrayRef<Type * > Elements,StringRef Name,bool isPacked)450 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 return create(Elements[0]->getContext(), Elements, Name, isPacked);
455 }
456
create(ArrayRef<Type * > Elements)457 StructType *StructType::create(ArrayRef<Type*> Elements) {
458 assert(!Elements.empty() &&
459 "This method may not be invoked with an empty list");
460 return create(Elements[0]->getContext(), Elements, StringRef());
461 }
462
isSized(SmallPtrSetImpl<Type * > * Visited) const463 bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
464 if ((getSubclassData() & SCDB_IsSized) != 0)
465 return true;
466 if (isOpaque())
467 return false;
468
469 if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
470 return false;
471
472 // Okay, our struct is sized if all of the elements are, but if one of the
473 // elements is opaque, the struct isn't sized *yet*, but may become sized in
474 // the future, so just bail out without caching.
475 for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
476 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 return true;
485 }
486
getName() const487 StringRef StructType::getName() const {
488 assert(!isLiteral() && "Literal structs never have names");
489 if (!SymbolTableEntry) return StringRef();
490
491 return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
492 }
493
isValidElementType(Type * ElemTy)494 bool StructType::isValidElementType(Type *ElemTy) {
495 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
496 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
497 !ElemTy->isTokenTy();
498 }
499
isLayoutIdentical(StructType * Other) const500 bool StructType::isLayoutIdentical(StructType *Other) const {
501 if (this == Other) return true;
502
503 if (isPacked() != Other->isPacked())
504 return false;
505
506 return elements() == Other->elements();
507 }
508
getTypeByName(StringRef Name) const509 StructType *Module::getTypeByName(StringRef Name) const {
510 return getContext().pImpl->NamedStructTypes.lookup(Name);
511 }
512
513 //===----------------------------------------------------------------------===//
514 // CompositeType Implementation
515 //===----------------------------------------------------------------------===//
516
getTypeAtIndex(const Value * V) const517 Type *CompositeType::getTypeAtIndex(const Value *V) const {
518 if (auto *STy = dyn_cast<StructType>(this)) {
519 unsigned Idx =
520 (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
521 assert(indexValid(Idx) && "Invalid structure index!");
522 return STy->getElementType(Idx);
523 }
524
525 return cast<SequentialType>(this)->getElementType();
526 }
527
getTypeAtIndex(unsigned Idx) const528 Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
529 if (auto *STy = dyn_cast<StructType>(this)) {
530 assert(indexValid(Idx) && "Invalid structure index!");
531 return STy->getElementType(Idx);
532 }
533
534 return cast<SequentialType>(this)->getElementType();
535 }
536
indexValid(const Value * V) const537 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 if (!V->getType()->isIntOrIntVectorTy(32))
542 return false;
543 const Constant *C = dyn_cast<Constant>(V);
544 if (C && V->getType()->isVectorTy())
545 C = C->getSplatValue();
546 const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
547 return CU && CU->getZExtValue() < STy->getNumElements();
548 }
549
550 // Sequential types can be indexed by any integer.
551 return V->getType()->isIntOrIntVectorTy();
552 }
553
indexValid(unsigned Idx) const554 bool CompositeType::indexValid(unsigned Idx) const {
555 if (auto *STy = dyn_cast<StructType>(this))
556 return Idx < STy->getNumElements();
557 // Sequential types can be indexed by any integer.
558 return true;
559 }
560
561 //===----------------------------------------------------------------------===//
562 // ArrayType Implementation
563 //===----------------------------------------------------------------------===//
564
ArrayType(Type * ElType,uint64_t NumEl)565 ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
566 : SequentialType(ArrayTyID, ElType, NumEl) {}
567
get(Type * ElementType,uint64_t NumElements)568 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
569 assert(isValidElementType(ElementType) && "Invalid type for array element!");
570
571 LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
572 ArrayType *&Entry =
573 pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
574
575 if (!Entry)
576 Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
577 return Entry;
578 }
579
isValidElementType(Type * ElemTy)580 bool ArrayType::isValidElementType(Type *ElemTy) {
581 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
582 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
583 !ElemTy->isTokenTy();
584 }
585
586 //===----------------------------------------------------------------------===//
587 // VectorType Implementation
588 //===----------------------------------------------------------------------===//
589
VectorType(Type * ElType,unsigned NumEl)590 VectorType::VectorType(Type *ElType, unsigned NumEl)
591 : SequentialType(VectorTyID, ElType, NumEl) {}
592
get(Type * ElementType,unsigned NumElements)593 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 LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
600 VectorType *&Entry = ElementType->getContext().pImpl
601 ->VectorTypes[std::make_pair(ElementType, NumElements)];
602
603 if (!Entry)
604 Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
605 return Entry;
606 }
607
isValidElementType(Type * ElemTy)608 bool VectorType::isValidElementType(Type *ElemTy) {
609 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
610 ElemTy->isPointerTy();
611 }
612
613 //===----------------------------------------------------------------------===//
614 // PointerType Implementation
615 //===----------------------------------------------------------------------===//
616
get(Type * EltTy,unsigned AddressSpace)617 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 LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
622
623 // Since AddressSpace #0 is the common case, we special case it.
624 PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
625 : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
626
627 if (!Entry)
628 Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
629 return Entry;
630 }
631
PointerType(Type * E,unsigned AddrSpace)632 PointerType::PointerType(Type *E, unsigned AddrSpace)
633 : Type(E->getContext(), PointerTyID), PointeeTy(E) {
634 ContainedTys = &PointeeTy;
635 NumContainedTys = 1;
636 setSubclassData(AddrSpace);
637 }
638
getPointerTo(unsigned addrs) const639 PointerType *Type::getPointerTo(unsigned addrs) const {
640 return PointerType::get(const_cast<Type*>(this), addrs);
641 }
642
isValidElementType(Type * ElemTy)643 bool PointerType::isValidElementType(Type *ElemTy) {
644 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
645 !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
646 }
647
isLoadableOrStorableType(Type * ElemTy)648 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
649 return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
650 }
651