File: | lib/IR/Type.cpp |
Warning: | line 346, column 5 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
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 | 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 | ||||
57 | bool Type::isIntegerTy(unsigned Bitwidth) const { | |||
58 | return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth; | |||
59 | } | |||
60 | ||||
61 | 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 | ||||
98 | 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 | ||||
115 | 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 | ||||
130 | unsigned Type::getScalarSizeInBits() const { | |||
131 | return getScalarType()->getPrimitiveSizeInBits(); | |||
132 | } | |||
133 | ||||
134 | 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!")(static_cast <bool> (isFloatingPointTy() && "Not a floating point type!" ) ? void (0) : __assert_fail ("isFloatingPointTy() && \"Not a floating point type!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 137, __extension__ __PRETTY_FUNCTION__)); | |||
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")(static_cast <bool> (getTypeID() == PPC_FP128TyID && "unknown fp type") ? void (0) : __assert_fail ("getTypeID() == PPC_FP128TyID && \"unknown fp type\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 143, __extension__ __PRETTY_FUNCTION__)); | |||
144 | return -1; | |||
145 | } | |||
146 | ||||
147 | 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 | ||||
161 | Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; } | |||
162 | Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; } | |||
163 | Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; } | |||
164 | Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; } | |||
165 | Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; } | |||
166 | Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; } | |||
167 | Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; } | |||
168 | Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; } | |||
169 | Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; } | |||
170 | Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; } | |||
171 | Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; } | |||
172 | ||||
173 | IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; } | |||
174 | IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; } | |||
175 | IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; } | |||
176 | IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; } | |||
177 | IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; } | |||
178 | IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; } | |||
179 | ||||
180 | IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) { | |||
181 | return IntegerType::get(C, N); | |||
182 | } | |||
183 | ||||
184 | PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) { | |||
185 | return getHalfTy(C)->getPointerTo(AS); | |||
186 | } | |||
187 | ||||
188 | PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) { | |||
189 | return getFloatTy(C)->getPointerTo(AS); | |||
190 | } | |||
191 | ||||
192 | PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) { | |||
193 | return getDoubleTy(C)->getPointerTo(AS); | |||
194 | } | |||
195 | ||||
196 | PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) { | |||
197 | return getX86_FP80Ty(C)->getPointerTo(AS); | |||
198 | } | |||
199 | ||||
200 | PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) { | |||
201 | return getFP128Ty(C)->getPointerTo(AS); | |||
202 | } | |||
203 | ||||
204 | PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) { | |||
205 | return getPPC_FP128Ty(C)->getPointerTo(AS); | |||
206 | } | |||
207 | ||||
208 | PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) { | |||
209 | return getX86_MMXTy(C)->getPointerTo(AS); | |||
210 | } | |||
211 | ||||
212 | PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) { | |||
213 | return getIntNTy(C, N)->getPointerTo(AS); | |||
214 | } | |||
215 | ||||
216 | PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) { | |||
217 | return getInt1Ty(C)->getPointerTo(AS); | |||
218 | } | |||
219 | ||||
220 | PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) { | |||
221 | return getInt8Ty(C)->getPointerTo(AS); | |||
222 | } | |||
223 | ||||
224 | PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) { | |||
225 | return getInt16Ty(C)->getPointerTo(AS); | |||
226 | } | |||
227 | ||||
228 | PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) { | |||
229 | return getInt32Ty(C)->getPointerTo(AS); | |||
230 | } | |||
231 | ||||
232 | PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) { | |||
233 | return getInt64Ty(C)->getPointerTo(AS); | |||
234 | } | |||
235 | ||||
236 | //===----------------------------------------------------------------------===// | |||
237 | // IntegerType Implementation | |||
238 | //===----------------------------------------------------------------------===// | |||
239 | ||||
240 | IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) { | |||
241 | assert(NumBits >= MIN_INT_BITS && "bitwidth too small")(static_cast <bool> (NumBits >= MIN_INT_BITS && "bitwidth too small") ? void (0) : __assert_fail ("NumBits >= MIN_INT_BITS && \"bitwidth too small\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 241, __extension__ __PRETTY_FUNCTION__)); | |||
242 | assert(NumBits <= MAX_INT_BITS && "bitwidth too large")(static_cast <bool> (NumBits <= MAX_INT_BITS && "bitwidth too large") ? void (0) : __assert_fail ("NumBits <= MAX_INT_BITS && \"bitwidth too large\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 242, __extension__ __PRETTY_FUNCTION__)); | |||
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 | ||||
264 | bool IntegerType::isPowerOf2ByteWidth() const { | |||
265 | unsigned BitWidth = getBitWidth(); | |||
266 | return (BitWidth > 7) && isPowerOf2_32(BitWidth); | |||
267 | } | |||
268 | ||||
269 | APInt IntegerType::getMask() const { | |||
270 | return APInt::getAllOnesValue(getBitWidth()); | |||
271 | } | |||
272 | ||||
273 | //===----------------------------------------------------------------------===// | |||
274 | // FunctionType Implementation | |||
275 | //===----------------------------------------------------------------------===// | |||
276 | ||||
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")(static_cast <bool> (isValidReturnType(Result) && "invalid return type for function") ? void (0) : __assert_fail ("isValidReturnType(Result) && \"invalid return type for function\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 281, __extension__ __PRETTY_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]) &&(static_cast <bool> (isValidArgumentType(Params[i]) && "Not a valid type for function argument!") ? void (0) : __assert_fail ("isValidArgumentType(Params[i]) && \"Not a valid type for function argument!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 288, __extension__ __PRETTY_FUNCTION__)) | |||
288 | "Not a valid type for function argument!")(static_cast <bool> (isValidArgumentType(Params[i]) && "Not a valid type for function argument!") ? void (0) : __assert_fail ("isValidArgumentType(Params[i]) && \"Not a valid type for function argument!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 288, __extension__ __PRETTY_FUNCTION__)); | |||
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. | |||
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 | ||||
317 | FunctionType *FunctionType::get(Type *Result, bool isVarArg) { | |||
318 | return get(Result, None, isVarArg); | |||
319 | } | |||
320 | ||||
321 | bool FunctionType::isValidReturnType(Type *RetTy) { | |||
322 | return !RetTy->isFunctionTy() && !RetTy->isLabelTy() && | |||
323 | !RetTy->isMetadataTy(); | |||
324 | } | |||
325 | ||||
326 | bool FunctionType::isValidArgumentType(Type *ArgTy) { | |||
327 | return ArgTy->isFirstClassType(); | |||
328 | } | |||
329 | ||||
330 | //===----------------------------------------------------------------------===// | |||
331 | // StructType Implementation | |||
332 | //===----------------------------------------------------------------------===// | |||
333 | ||||
334 | // Primitive Constructors. | |||
335 | ||||
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 | ||||
356 | void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) { | |||
357 | assert(isOpaque() && "Struct body already set!")(static_cast <bool> (isOpaque() && "Struct body already set!" ) ? void (0) : __assert_fail ("isOpaque() && \"Struct body already set!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 357, __extension__ __PRETTY_FUNCTION__)); | |||
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 | ||||
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 | ||||
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 | ||||
431 | StructType *StructType::get(LLVMContext &Context, bool isPacked) { | |||
432 | return get(Context, None, isPacked); | |||
| ||||
433 | } | |||
434 | ||||
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 | ||||
442 | StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) { | |||
443 | return create(Context, Elements, StringRef()); | |||
444 | } | |||
445 | ||||
446 | StructType *StructType::create(LLVMContext &Context) { | |||
447 | return create(Context, StringRef()); | |||
448 | } | |||
449 | ||||
450 | StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name, | |||
451 | bool isPacked) { | |||
452 | assert(!Elements.empty() &&(static_cast <bool> (!Elements.empty() && "This method may not be invoked with an empty list" ) ? void (0) : __assert_fail ("!Elements.empty() && \"This method may not be invoked with an empty list\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 453, __extension__ __PRETTY_FUNCTION__)) | |||
453 | "This method may not be invoked with an empty list")(static_cast <bool> (!Elements.empty() && "This method may not be invoked with an empty list" ) ? void (0) : __assert_fail ("!Elements.empty() && \"This method may not be invoked with an empty list\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 453, __extension__ __PRETTY_FUNCTION__)); | |||
454 | return create(Elements[0]->getContext(), Elements, Name, isPacked); | |||
455 | } | |||
456 | ||||
457 | StructType *StructType::create(ArrayRef<Type*> Elements) { | |||
458 | assert(!Elements.empty() &&(static_cast <bool> (!Elements.empty() && "This method may not be invoked with an empty list" ) ? void (0) : __assert_fail ("!Elements.empty() && \"This method may not be invoked with an empty list\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 459, __extension__ __PRETTY_FUNCTION__)) | |||
459 | "This method may not be invoked with an empty list")(static_cast <bool> (!Elements.empty() && "This method may not be invoked with an empty list" ) ? void (0) : __assert_fail ("!Elements.empty() && \"This method may not be invoked with an empty list\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 459, __extension__ __PRETTY_FUNCTION__)); | |||
460 | return create(Elements[0]->getContext(), Elements, StringRef()); | |||
461 | } | |||
462 | ||||
463 | 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 | ||||
487 | StringRef StructType::getName() const { | |||
488 | assert(!isLiteral() && "Literal structs never have names")(static_cast <bool> (!isLiteral() && "Literal structs never have names" ) ? void (0) : __assert_fail ("!isLiteral() && \"Literal structs never have names\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 488, __extension__ __PRETTY_FUNCTION__)); | |||
489 | if (!SymbolTableEntry) return StringRef(); | |||
490 | ||||
491 | return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey(); | |||
492 | } | |||
493 | ||||
494 | bool StructType::isValidElementType(Type *ElemTy) { | |||
495 | return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && | |||
496 | !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() && | |||
497 | !ElemTy->isTokenTy(); | |||
498 | } | |||
499 | ||||
500 | 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 | ||||
509 | StructType *Module::getTypeByName(StringRef Name) const { | |||
510 | return getContext().pImpl->NamedStructTypes.lookup(Name); | |||
511 | } | |||
512 | ||||
513 | //===----------------------------------------------------------------------===// | |||
514 | // CompositeType Implementation | |||
515 | //===----------------------------------------------------------------------===// | |||
516 | ||||
517 | 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!")(static_cast <bool> (indexValid(Idx) && "Invalid structure index!" ) ? void (0) : __assert_fail ("indexValid(Idx) && \"Invalid structure index!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 521, __extension__ __PRETTY_FUNCTION__)); | |||
522 | return STy->getElementType(Idx); | |||
523 | } | |||
524 | ||||
525 | return cast<SequentialType>(this)->getElementType(); | |||
526 | } | |||
527 | ||||
528 | Type *CompositeType::getTypeAtIndex(unsigned Idx) const{ | |||
529 | if (auto *STy = dyn_cast<StructType>(this)) { | |||
530 | assert(indexValid(Idx) && "Invalid structure index!")(static_cast <bool> (indexValid(Idx) && "Invalid structure index!" ) ? void (0) : __assert_fail ("indexValid(Idx) && \"Invalid structure index!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 530, __extension__ __PRETTY_FUNCTION__)); | |||
531 | return STy->getElementType(Idx); | |||
532 | } | |||
533 | ||||
534 | return cast<SequentialType>(this)->getElementType(); | |||
535 | } | |||
536 | ||||
537 | 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 | ||||
554 | 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 | ||||
565 | ArrayType::ArrayType(Type *ElType, uint64_t NumEl) | |||
566 | : SequentialType(ArrayTyID, ElType, NumEl) {} | |||
567 | ||||
568 | ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) { | |||
569 | assert(isValidElementType(ElementType) && "Invalid type for array element!")(static_cast <bool> (isValidElementType(ElementType) && "Invalid type for array element!") ? void (0) : __assert_fail ("isValidElementType(ElementType) && \"Invalid type for array element!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 569, __extension__ __PRETTY_FUNCTION__)); | |||
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 | ||||
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 | ||||
590 | VectorType::VectorType(Type *ElType, unsigned NumEl) | |||
591 | : SequentialType(VectorTyID, ElType, NumEl) {} | |||
592 | ||||
593 | VectorType *VectorType::get(Type *ElementType, unsigned NumElements) { | |||
594 | assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0")(static_cast <bool> (NumElements > 0 && "#Elements of a VectorType must be greater than 0" ) ? void (0) : __assert_fail ("NumElements > 0 && \"#Elements of a VectorType must be greater than 0\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 594, __extension__ __PRETTY_FUNCTION__)); | |||
595 | assert(isValidElementType(ElementType) && "Element type of a VectorType must "(static_cast <bool> (isValidElementType(ElementType) && "Element type of a VectorType must " "be an integer, floating point, or " "pointer type.") ? void (0) : __assert_fail ("isValidElementType(ElementType) && \"Element type of a VectorType must \" \"be an integer, floating point, or \" \"pointer type.\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 597, __extension__ __PRETTY_FUNCTION__)) | |||
596 | "be an integer, floating point, or "(static_cast <bool> (isValidElementType(ElementType) && "Element type of a VectorType must " "be an integer, floating point, or " "pointer type.") ? void (0) : __assert_fail ("isValidElementType(ElementType) && \"Element type of a VectorType must \" \"be an integer, floating point, or \" \"pointer type.\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 597, __extension__ __PRETTY_FUNCTION__)) | |||
597 | "pointer type.")(static_cast <bool> (isValidElementType(ElementType) && "Element type of a VectorType must " "be an integer, floating point, or " "pointer type.") ? void (0) : __assert_fail ("isValidElementType(ElementType) && \"Element type of a VectorType must \" \"be an integer, floating point, or \" \"pointer type.\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 597, __extension__ __PRETTY_FUNCTION__)); | |||
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 | ||||
608 | bool VectorType::isValidElementType(Type *ElemTy) { | |||
609 | return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() || | |||
610 | ElemTy->isPointerTy(); | |||
611 | } | |||
612 | ||||
613 | //===----------------------------------------------------------------------===// | |||
614 | // PointerType Implementation | |||
615 | //===----------------------------------------------------------------------===// | |||
616 | ||||
617 | PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) { | |||
618 | assert(EltTy && "Can't get a pointer to <null> type!")(static_cast <bool> (EltTy && "Can't get a pointer to <null> type!" ) ? void (0) : __assert_fail ("EltTy && \"Can't get a pointer to <null> type!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 618, __extension__ __PRETTY_FUNCTION__)); | |||
619 | assert(isValidElementType(EltTy) && "Invalid type for pointer element!")(static_cast <bool> (isValidElementType(EltTy) && "Invalid type for pointer element!") ? void (0) : __assert_fail ("isValidElementType(EltTy) && \"Invalid type for pointer element!\"" , "/build/llvm-toolchain-snapshot-7~svn338205/lib/IR/Type.cpp" , 619, __extension__ __PRETTY_FUNCTION__)); | |||
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 | ||||
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 | ||||
639 | PointerType *Type::getPointerTo(unsigned addrs) const { | |||
640 | return PointerType::get(const_cast<Type*>(this), addrs); | |||
641 | } | |||
642 | ||||
643 | bool PointerType::isValidElementType(Type *ElemTy) { | |||
644 | return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() && | |||
645 | !ElemTy->isMetadataTy() && !ElemTy->isTokenTy(); | |||
646 | } | |||
647 | ||||
648 | bool PointerType::isLoadableOrStorableType(Type *ElemTy) { | |||
649 | return isValidElementType(ElemTy) && !ElemTy->isFunctionTy(); | |||
650 | } |