1 //===- Type.cpp - Implement the Type class --------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Type class for the IR library.
12 //===----------------------------------------------------------------------===//
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"
35 //===----------------------------------------------------------------------===//
36 // Type Class Implementation
37 //===----------------------------------------------------------------------===//
39 Type *Type::getPrimitiveType(LLVMContext &C, TypeID 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);
57 bool Type::isIntegerTy(unsigned Bitwidth) const {
58 return isIntegerTy() && cast<IntegerType>(this)->getBitWidth() == Bitwidth;
61 bool Type::canLosslesslyBitCastTo(Type *Ty) const {
62 // Identity cast means no change so return true
66 // They are not convertible unless they are at least first class types
67 if (!this->isFirstClassType() || !Ty->isFirstClassType())
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)
81 if (this->getTypeID() == Type::X86_MMXTyID)
82 if (auto *thatPTy = dyn_cast<VectorType>(Ty))
83 if (thatPTy->getBitWidth() == 64)
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();
95 return false; // Other types have no identity values
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();
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())
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();
130 unsigned Type::getScalarSizeInBits() const {
131 return getScalarType()->getPrimitiveSizeInBits();
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!");
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");
147 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
148 if (auto *ATy = dyn_cast<ArrayType>(this))
149 return ATy->getElementType()->isSized(Visited);
151 if (auto *VTy = dyn_cast<VectorType>(this))
152 return VTy->getElementType()->isSized(Visited);
154 return cast<StructType>(this)->isSized(Visited);
157 //===----------------------------------------------------------------------===//
158 // Primitive 'Type' data
159 //===----------------------------------------------------------------------===//
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; }
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; }
180 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
181 return IntegerType::get(C, N);
184 PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
185 return getHalfTy(C)->getPointerTo(AS);
188 PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
189 return getFloatTy(C)->getPointerTo(AS);
192 PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
193 return getDoubleTy(C)->getPointerTo(AS);
196 PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
197 return getX86_FP80Ty(C)->getPointerTo(AS);
200 PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
201 return getFP128Ty(C)->getPointerTo(AS);
204 PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
205 return getPPC_FP128Ty(C)->getPointerTo(AS);
208 PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
209 return getX86_MMXTy(C)->getPointerTo(AS);
212 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
213 return getIntNTy(C, N)->getPointerTo(AS);
216 PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
217 return getInt1Ty(C)->getPointerTo(AS);
220 PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
221 return getInt8Ty(C)->getPointerTo(AS);
224 PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
225 return getInt16Ty(C)->getPointerTo(AS);
228 PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
229 return getInt32Ty(C)->getPointerTo(AS);
232 PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
233 return getInt64Ty(C)->getPointerTo(AS);
236 //===----------------------------------------------------------------------===//
237 // IntegerType Implementation
238 //===----------------------------------------------------------------------===//
240 IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) {
241 assert(NumBits >= MIN_INT_BITS && "bitwidth too small");
242 assert(NumBits <= MAX_INT_BITS && "bitwidth too large");
244 // Check for the built-in integer types
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));
256 IntegerType *&Entry = C.pImpl->IntegerTypes[NumBits];
259 Entry = new (C.pImpl->TypeAllocator) IntegerType(C, NumBits);
264 bool IntegerType::isPowerOf2ByteWidth() const {
265 unsigned BitWidth = getBitWidth();
266 return (BitWidth > 7) && isPowerOf2_32(BitWidth);
269 APInt IntegerType::getMask() const {
270 return APInt::getAllOnesValue(getBitWidth());
273 //===----------------------------------------------------------------------===//
274 // FunctionType Implementation
275 //===----------------------------------------------------------------------===//
277 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
279 : Type(Result->getContext(), FunctionTyID) {
280 Type **SubTys = reinterpret_cast<Type**>(this+1);
281 assert(isValidReturnType(Result) && "invalid return type for function");
282 setSubclassData(IsVarArgs);
286 for (unsigned i = 0, e = Params.size(); i != e; ++i) {
287 assert(isValidArgumentType(Params[i]) &&
288 "Not a valid type for function argument!");
289 SubTys[i+1] = Params[i];
292 ContainedTys = SubTys;
293 NumContainedTys = Params.size() + 1; // + 1 for result type
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 const FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
302 // Since we only want to allocate a fresh function type in case none is found
303 // and we don't want to perform two lookups (one for checking if existent and
304 // one for inserting the newly allocated one), here we instead lookup based on
305 // Key and update the reference to the function type in-place to a newly
306 // allocated one if not found.
307 auto Insertion = pImpl->FunctionTypes.insert_as(nullptr, Key);
308 if (Insertion.second) {
309 // The function type was not found. Allocate one and update FunctionTypes
311 FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
312 sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
313 alignof(FunctionType));
314 new (FT) FunctionType(ReturnType, Params, isVarArg);
315 *Insertion.first = FT;
317 // The function type was found. Just return it.
318 FT = *Insertion.first;
323 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
324 return get(Result, None, isVarArg);
327 bool FunctionType::isValidReturnType(Type *RetTy) {
328 return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
329 !RetTy->isMetadataTy();
332 bool FunctionType::isValidArgumentType(Type *ArgTy) {
333 return ArgTy->isFirstClassType();
336 //===----------------------------------------------------------------------===//
337 // StructType Implementation
338 //===----------------------------------------------------------------------===//
340 // Primitive Constructors.
342 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
344 LLVMContextImpl *pImpl = Context.pImpl;
345 const AnonStructTypeKeyInfo::KeyTy Key(ETypes, isPacked);
348 // Since we only want to allocate a fresh struct type in case none is found
349 // and we don't want to perform two lookups (one for checking if existent and
350 // one for inserting the newly allocated one), here we instead lookup based on
351 // Key and update the reference to the struct type in-place to a newly
352 // allocated one if not found.
353 auto Insertion = pImpl->AnonStructTypes.insert_as(nullptr, Key);
354 if (Insertion.second) {
355 // The struct type was not found. Allocate one and update AnonStructTypes
357 ST = new (Context.pImpl->TypeAllocator) StructType(Context);
358 ST->setSubclassData(SCDB_IsLiteral); // Literal struct.
359 ST->setBody(ETypes, isPacked);
360 *Insertion.first = ST;
362 // The struct type was found. Just return it.
363 ST = *Insertion.first;
369 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
370 assert(isOpaque() && "Struct body already set!");
372 setSubclassData(getSubclassData() | SCDB_HasBody);
374 setSubclassData(getSubclassData() | SCDB_Packed);
376 NumContainedTys = Elements.size();
378 if (Elements.empty()) {
379 ContainedTys = nullptr;
383 ContainedTys = Elements.copy(getContext().pImpl->TypeAllocator).data();
386 void StructType::setName(StringRef Name) {
387 if (Name == getName()) return;
389 StringMap<StructType *> &SymbolTable = getContext().pImpl->NamedStructTypes;
391 using EntryTy = StringMap<StructType *>::MapEntryTy;
393 // If this struct already had a name, remove its symbol table entry. Don't
394 // delete the data yet because it may be part of the new name.
395 if (SymbolTableEntry)
396 SymbolTable.remove((EntryTy *)SymbolTableEntry);
398 // If this is just removing the name, we're done.
400 if (SymbolTableEntry) {
401 // Delete the old string data.
402 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
403 SymbolTableEntry = nullptr;
408 // Look up the entry for the name.
410 getContext().pImpl->NamedStructTypes.insert(std::make_pair(Name, this));
412 // While we have a name collision, try a random rename.
413 if (!IterBool.second) {
414 SmallString<64> TempStr(Name);
415 TempStr.push_back('.');
416 raw_svector_ostream TmpStream(TempStr);
417 unsigned NameSize = Name.size();
420 TempStr.resize(NameSize + 1);
421 TmpStream << getContext().pImpl->NamedStructTypesUniqueID++;
423 IterBool = getContext().pImpl->NamedStructTypes.insert(
424 std::make_pair(TmpStream.str(), this));
425 } while (!IterBool.second);
428 // Delete the old string data.
429 if (SymbolTableEntry)
430 ((EntryTy *)SymbolTableEntry)->Destroy(SymbolTable.getAllocator());
431 SymbolTableEntry = &*IterBool.first;
434 //===----------------------------------------------------------------------===//
435 // StructType Helper functions.
437 StructType *StructType::create(LLVMContext &Context, StringRef Name) {
438 StructType *ST = new (Context.pImpl->TypeAllocator) StructType(Context);
444 StructType *StructType::get(LLVMContext &Context, bool isPacked) {
445 return get(Context, None, isPacked);
448 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
449 StringRef Name, bool isPacked) {
450 StructType *ST = create(Context, Name);
451 ST->setBody(Elements, isPacked);
455 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
456 return create(Context, Elements, StringRef());
459 StructType *StructType::create(LLVMContext &Context) {
460 return create(Context, StringRef());
463 StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name,
465 assert(!Elements.empty() &&
466 "This method may not be invoked with an empty list");
467 return create(Elements[0]->getContext(), Elements, Name, isPacked);
470 StructType *StructType::create(ArrayRef<Type*> Elements) {
471 assert(!Elements.empty() &&
472 "This method may not be invoked with an empty list");
473 return create(Elements[0]->getContext(), Elements, StringRef());
476 bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
477 if ((getSubclassData() & SCDB_IsSized) != 0)
482 if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
485 // Okay, our struct is sized if all of the elements are, but if one of the
486 // elements is opaque, the struct isn't sized *yet*, but may become sized in
487 // the future, so just bail out without caching.
488 for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
489 if (!(*I)->isSized(Visited))
492 // Here we cheat a bit and cast away const-ness. The goal is to memoize when
493 // we find a sized type, as types can only move from opaque to sized, not the
495 const_cast<StructType*>(this)->setSubclassData(
496 getSubclassData() | SCDB_IsSized);
500 StringRef StructType::getName() const {
501 assert(!isLiteral() && "Literal structs never have names");
502 if (!SymbolTableEntry) return StringRef();
504 return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
507 bool StructType::isValidElementType(Type *ElemTy) {
508 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
509 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
510 !ElemTy->isTokenTy();
513 bool StructType::isLayoutIdentical(StructType *Other) const {
514 if (this == Other) return true;
516 if (isPacked() != Other->isPacked())
519 return elements() == Other->elements();
522 StructType *Module::getTypeByName(StringRef Name) const {
523 return getContext().pImpl->NamedStructTypes.lookup(Name);
526 //===----------------------------------------------------------------------===//
527 // CompositeType Implementation
528 //===----------------------------------------------------------------------===//
530 Type *CompositeType::getTypeAtIndex(const Value *V) const {
531 if (auto *STy = dyn_cast<StructType>(this)) {
533 (unsigned)cast<Constant>(V)->getUniqueInteger().getZExtValue();
534 assert(indexValid(Idx) && "Invalid structure index!");
535 return STy->getElementType(Idx);
538 return cast<SequentialType>(this)->getElementType();
541 Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
542 if (auto *STy = dyn_cast<StructType>(this)) {
543 assert(indexValid(Idx) && "Invalid structure index!");
544 return STy->getElementType(Idx);
547 return cast<SequentialType>(this)->getElementType();
550 bool CompositeType::indexValid(const Value *V) const {
551 if (auto *STy = dyn_cast<StructType>(this)) {
552 // Structure indexes require (vectors of) 32-bit integer constants. In the
553 // vector case all of the indices must be equal.
554 if (!V->getType()->isIntOrIntVectorTy(32))
556 const Constant *C = dyn_cast<Constant>(V);
557 if (C && V->getType()->isVectorTy())
558 C = C->getSplatValue();
559 const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
560 return CU && CU->getZExtValue() < STy->getNumElements();
563 // Sequential types can be indexed by any integer.
564 return V->getType()->isIntOrIntVectorTy();
567 bool CompositeType::indexValid(unsigned Idx) const {
568 if (auto *STy = dyn_cast<StructType>(this))
569 return Idx < STy->getNumElements();
570 // Sequential types can be indexed by any integer.
574 //===----------------------------------------------------------------------===//
575 // ArrayType Implementation
576 //===----------------------------------------------------------------------===//
578 ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
579 : SequentialType(ArrayTyID, ElType, NumEl) {}
581 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
582 assert(isValidElementType(ElementType) && "Invalid type for array element!");
584 LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
586 pImpl->ArrayTypes[std::make_pair(ElementType, NumElements)];
589 Entry = new (pImpl->TypeAllocator) ArrayType(ElementType, NumElements);
593 bool ArrayType::isValidElementType(Type *ElemTy) {
594 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
595 !ElemTy->isMetadataTy() && !ElemTy->isFunctionTy() &&
596 !ElemTy->isTokenTy();
599 //===----------------------------------------------------------------------===//
600 // VectorType Implementation
601 //===----------------------------------------------------------------------===//
603 VectorType::VectorType(Type *ElType, unsigned NumEl)
604 : SequentialType(VectorTyID, ElType, NumEl) {}
606 VectorType *VectorType::get(Type *ElementType, unsigned NumElements) {
607 assert(NumElements > 0 && "#Elements of a VectorType must be greater than 0");
608 assert(isValidElementType(ElementType) && "Element type of a VectorType must "
609 "be an integer, floating point, or "
612 LLVMContextImpl *pImpl = ElementType->getContext().pImpl;
613 VectorType *&Entry = ElementType->getContext().pImpl
614 ->VectorTypes[std::make_pair(ElementType, NumElements)];
617 Entry = new (pImpl->TypeAllocator) VectorType(ElementType, NumElements);
621 bool VectorType::isValidElementType(Type *ElemTy) {
622 return ElemTy->isIntegerTy() || ElemTy->isFloatingPointTy() ||
623 ElemTy->isPointerTy();
626 //===----------------------------------------------------------------------===//
627 // PointerType Implementation
628 //===----------------------------------------------------------------------===//
630 PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) {
631 assert(EltTy && "Can't get a pointer to <null> type!");
632 assert(isValidElementType(EltTy) && "Invalid type for pointer element!");
634 LLVMContextImpl *CImpl = EltTy->getContext().pImpl;
636 // Since AddressSpace #0 is the common case, we special case it.
637 PointerType *&Entry = AddressSpace == 0 ? CImpl->PointerTypes[EltTy]
638 : CImpl->ASPointerTypes[std::make_pair(EltTy, AddressSpace)];
641 Entry = new (CImpl->TypeAllocator) PointerType(EltTy, AddressSpace);
645 PointerType::PointerType(Type *E, unsigned AddrSpace)
646 : Type(E->getContext(), PointerTyID), PointeeTy(E) {
647 ContainedTys = &PointeeTy;
649 setSubclassData(AddrSpace);
652 PointerType *Type::getPointerTo(unsigned addrs) const {
653 return PointerType::get(const_cast<Type*>(this), addrs);
656 bool PointerType::isValidElementType(Type *ElemTy) {
657 return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
658 !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
661 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
662 return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();