Bug Summary

File:lib/IR/Type.cpp
Warning:line 427, column 5
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Type.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-7~svn329677/lib/IR -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/lib/IR -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/lib/IR/Type.cpp
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
33using namespace llvm;
34
35//===----------------------------------------------------------------------===//
36// Type Class Implementation
37//===----------------------------------------------------------------------===//
38
39Type *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
57bool Type::isIntegerTy(unsigned Bitwidth) const {
58 return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
59}
60
61bool 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
98bool 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
115unsigned 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
130unsigned Type::getScalarSizeInBits() const {
131 return getScalarType()->getPrimitiveSizeInBits();
132}
133
134int 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~svn329677/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~svn329677/lib/IR/Type.cpp"
, 143, __extension__ __PRETTY_FUNCTION__))
;
144 return -1;
145}
146
147bool 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
161Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
162Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
163Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
164Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
165Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
166Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
167Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
168Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
169Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
170Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
171Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
172
173IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
174IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
175IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
176IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
177IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
178IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
179
180IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
181 return IntegerType::get(C, N);
182}
183
184PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
185 return getHalfTy(C)->getPointerTo(AS);
186}
187
188PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
189 return getFloatTy(C)->getPointerTo(AS);
190}
191
192PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
193 return getDoubleTy(C)->getPointerTo(AS);
194}
195
196PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
197 return getX86_FP80Ty(C)->getPointerTo(AS);
198}
199
200PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
201 return getFP128Ty(C)->getPointerTo(AS);
202}
203
204PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
205 return getPPC_FP128Ty(C)->getPointerTo(AS);
206}
207
208PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
209 return getX86_MMXTy(C)->getPointerTo(AS);
210}
211
212PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
213 return getIntNTy(C, N)->getPointerTo(AS);
214}
215
216PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
217 return getInt1Ty(C)->getPointerTo(AS);
218}
219
220PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
221 return getInt8Ty(C)->getPointerTo(AS);
222}
223
224PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
225 return getInt16Ty(C)->getPointerTo(AS);
226}
227
228PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
229 return getInt32Ty(C)->getPointerTo(AS);
230}
231
232PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
233 return getInt64Ty(C)->getPointerTo(AS);
234}
235
236//===----------------------------------------------------------------------===//
237// IntegerType Implementation
238//===----------------------------------------------------------------------===//
239
240IntegerType *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~svn329677/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~svn329677/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
264bool IntegerType::isPowerOf2ByteWidth() const {
265 unsigned BitWidth = getBitWidth();
266 return (BitWidth > 7) && isPowerOf2_32(BitWidth);
267}
268
269APInt IntegerType::getMask() const {
270 return APInt::getAllOnesValue(getBitWidth());
271}
272
273//===----------------------------------------------------------------------===//
274// FunctionType Implementation
275//===----------------------------------------------------------------------===//
276
277FunctionType::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~svn329677/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~svn329677/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~svn329677/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.
297FunctionType *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
317FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
318 return get(Result, None, isVarArg);
319}
320
321bool FunctionType::isValidReturnType(Type *RetTy) {
322 return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
323 !RetTy->isMetadataTy();
324}
325
326bool FunctionType::isValidArgumentType(Type *ArgTy) {
327 return ArgTy->isFirstClassType();
328}
329
330//===----------------------------------------------------------------------===//
331// StructType Implementation
332//===----------------------------------------------------------------------===//
333
334// Primitive Constructors.
335
336StructType *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
356void 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~svn329677/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
373void 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
424StructType *StructType::create(LLVMContext &Context, StringRef Name) {
425 StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
3
'ST' initialized to a null pointer value
426 if (!Name.empty())
4
Assuming the condition is true
5
Taking true branch
427 ST->setName(Name);
6
Called C++ object pointer is null
428 return ST;
429}
430
431StructType *StructType::get(LLVMContext &Context, bool isPacked) {
432 return get(Context, None, isPacked);
433}
434
435StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
436 StringRef Name, bool isPacked) {
437 StructType *ST = create(Context, Name);
2
Calling 'StructType::create'
438 ST->setBody(Elements, isPacked);
439 return ST;
440}
441
442StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
443 return create(Context, Elements, StringRef());
444}
445
446StructType *StructType::create(LLVMContext &Context) {
447 return create(Context, StringRef());
448}
449
450StructType *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~svn329677/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~svn329677/lib/IR/Type.cpp"
, 453, __extension__ __PRETTY_FUNCTION__))
;
454 return create(Elements[0]->getContext(), Elements, Name, isPacked);
455}
456
457StructType *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~svn329677/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~svn329677/lib/IR/Type.cpp"
, 459, __extension__ __PRETTY_FUNCTION__))
;
460 return create(Elements[0]->getContext(), Elements, StringRef());
1
Calling 'StructType::create'
461}
462
463bool 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
487StringRef 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~svn329677/lib/IR/Type.cpp"
, 488, __extension__ __PRETTY_FUNCTION__))
;
489 if (!SymbolTableEntry) return StringRef();
490
491 return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
492}
493
494bool StructType::isValidElementType(Type *ElemTy) {
495 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
496 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
497 !ElemTy->isTokenTy();
498}
499
500bool 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
509StructType *Module::getTypeByName(StringRef Name) const {
510 return getContext().pImpl->NamedStructTypes.lookup(Name);
511}
512
513//===----------------------------------------------------------------------===//
514// CompositeType Implementation
515//===----------------------------------------------------------------------===//
516
517Type *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~svn329677/lib/IR/Type.cpp"
, 521, __extension__ __PRETTY_FUNCTION__))
;
522 return STy->getElementType(Idx);
523 }
524
525 return cast<SequentialType>(this)->getElementType();
526}
527
528Type *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~svn329677/lib/IR/Type.cpp"
, 530, __extension__ __PRETTY_FUNCTION__))
;
531 return STy->getElementType(Idx);
532 }
533
534 return cast<SequentialType>(this)->getElementType();
535}
536
537bool 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
554bool 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
565ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
566 : SequentialType(ArrayTyID, ElType, NumEl) {}
567
568ArrayType *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~svn329677/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
580bool 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
590VectorType::VectorType(Type *ElType, unsigned NumEl)
591 : SequentialType(VectorTyID, ElType, NumEl) {}
592
593VectorType *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~svn329677/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~svn329677/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~svn329677/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~svn329677/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
608bool VectorType::isValidElementType(Type *ElemTy) {
609 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
610 ElemTy->isPointerTy();
611}
612
613//===----------------------------------------------------------------------===//
614// PointerType Implementation
615//===----------------------------------------------------------------------===//
616
617PointerType *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~svn329677/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~svn329677/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
632PointerType::PointerType(Type *E, unsigned AddrSpace)
633 : Type(E->getContext(), PointerTyID), PointeeTy(E) {
634 ContainedTys = &PointeeTy;
635 NumContainedTys = 1;
636 setSubclassData(AddrSpace);
637}
638
639PointerType *Type::getPointerTo(unsigned addrs) const {
640 return PointerType::get(const_cast<Type*>(this), addrs);
641}
642
643bool PointerType::isValidElementType(Type *ElemTy) {
644 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
645 !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
646}
647
648bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
649 return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
650}