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 : }
|
