1 //===--- Type.cpp - Type representation and manipulation ------------------===// 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 type-related functionality. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/CharUnits.h" 16 #include "clang/AST/Type.h" 17 #include "clang/AST/DeclCXX.h" 18 #include "clang/AST/DeclObjC.h" 19 #include "clang/AST/DeclTemplate.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/PrettyPrinter.h" 22 #include "clang/AST/TypeVisitor.h" 23 #include "clang/Basic/Specifiers.h" 24 #include "llvm/ADT/APSInt.h" 25 #include "llvm/ADT/StringExtras.h" 26 #include "llvm/Support/raw_ostream.h" 27 #include <algorithm> 28 using namespace clang; 29 30 bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const { 31 return (*this != Other) && 32 // CVR qualifiers superset 33 (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) && 34 // ObjC GC qualifiers superset 35 ((getObjCGCAttr() == Other.getObjCGCAttr()) || 36 (hasObjCGCAttr() && !Other.hasObjCGCAttr())) && 37 // Address space superset. 38 ((getAddressSpace() == Other.getAddressSpace()) || 39 (hasAddressSpace()&& !Other.hasAddressSpace())) && 40 // Lifetime qualifier superset. 41 ((getObjCLifetime() == Other.getObjCLifetime()) || 42 (hasObjCLifetime() && !Other.hasObjCLifetime())); 43 } 44 45 const IdentifierInfo* QualType::getBaseTypeIdentifier() const { 46 const Type* ty = getTypePtr(); 47 NamedDecl *ND = NULL; 48 if (ty->isPointerType() || ty->isReferenceType()) 49 return ty->getPointeeType().getBaseTypeIdentifier(); 50 else if (ty->isRecordType()) 51 ND = ty->getAs<RecordType>()->getDecl(); 52 else if (ty->isEnumeralType()) 53 ND = ty->getAs<EnumType>()->getDecl(); 54 else if (ty->getTypeClass() == Type::Typedef) 55 ND = ty->getAs<TypedefType>()->getDecl(); 56 else if (ty->isArrayType()) 57 return ty->castAsArrayTypeUnsafe()-> 58 getElementType().getBaseTypeIdentifier(); 59 60 if (ND) 61 return ND->getIdentifier(); 62 return NULL; 63 } 64 65 bool QualType::isConstant(QualType T, ASTContext &Ctx) { 66 if (T.isConstQualified()) 67 return true; 68 69 if (const ArrayType *AT = Ctx.getAsArrayType(T)) 70 return AT->getElementType().isConstant(Ctx); 71 72 return false; 73 } 74 75 unsigned ConstantArrayType::getNumAddressingBits(ASTContext &Context, 76 QualType ElementType, 77 const llvm::APInt &NumElements) { 78 llvm::APSInt SizeExtended(NumElements, true); 79 unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType()); 80 SizeExtended = SizeExtended.extend(std::max(SizeTypeBits, 81 SizeExtended.getBitWidth()) * 2); 82 83 uint64_t ElementSize 84 = Context.getTypeSizeInChars(ElementType).getQuantity(); 85 llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize)); 86 TotalSize *= SizeExtended; 87 88 return TotalSize.getActiveBits(); 89 } 90 91 unsigned ConstantArrayType::getMaxSizeBits(ASTContext &Context) { 92 unsigned Bits = Context.getTypeSize(Context.getSizeType()); 93 94 // GCC appears to only allow 63 bits worth of address space when compiling 95 // for 64-bit, so we do the same. 96 if (Bits == 64) 97 --Bits; 98 99 return Bits; 100 } 101 102 DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context, 103 QualType et, QualType can, 104 Expr *e, ArraySizeModifier sm, 105 unsigned tq, 106 SourceRange brackets) 107 : ArrayType(DependentSizedArray, et, can, sm, tq, 108 (et->containsUnexpandedParameterPack() || 109 (e && e->containsUnexpandedParameterPack()))), 110 Context(Context), SizeExpr((Stmt*) e), Brackets(brackets) 111 { 112 } 113 114 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID, 115 const ASTContext &Context, 116 QualType ET, 117 ArraySizeModifier SizeMod, 118 unsigned TypeQuals, 119 Expr *E) { 120 ID.AddPointer(ET.getAsOpaquePtr()); 121 ID.AddInteger(SizeMod); 122 ID.AddInteger(TypeQuals); 123 E->Profile(ID, Context, true); 124 } 125 126 DependentSizedExtVectorType::DependentSizedExtVectorType(const 127 ASTContext &Context, 128 QualType ElementType, 129 QualType can, 130 Expr *SizeExpr, 131 SourceLocation loc) 132 : Type(DependentSizedExtVector, can, /*Dependent=*/true, 133 /*InstantiationDependent=*/true, 134 ElementType->isVariablyModifiedType(), 135 (ElementType->containsUnexpandedParameterPack() || 136 (SizeExpr && SizeExpr->containsUnexpandedParameterPack()))), 137 Context(Context), SizeExpr(SizeExpr), ElementType(ElementType), 138 loc(loc) 139 { 140 } 141 142 void 143 DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID, 144 const ASTContext &Context, 145 QualType ElementType, Expr *SizeExpr) { 146 ID.AddPointer(ElementType.getAsOpaquePtr()); 147 SizeExpr->Profile(ID, Context, true); 148 } 149 150 VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType, 151 VectorKind vecKind) 152 : Type(Vector, canonType, vecType->isDependentType(), 153 vecType->isInstantiationDependentType(), 154 vecType->isVariablyModifiedType(), 155 vecType->containsUnexpandedParameterPack()), 156 ElementType(vecType) 157 { 158 VectorTypeBits.VecKind = vecKind; 159 VectorTypeBits.NumElements = nElements; 160 } 161 162 VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements, 163 QualType canonType, VectorKind vecKind) 164 : Type(tc, canonType, vecType->isDependentType(), 165 vecType->isInstantiationDependentType(), 166 vecType->isVariablyModifiedType(), 167 vecType->containsUnexpandedParameterPack()), 168 ElementType(vecType) 169 { 170 VectorTypeBits.VecKind = vecKind; 171 VectorTypeBits.NumElements = nElements; 172 } 173 174 /// getArrayElementTypeNoTypeQual - If this is an array type, return the 175 /// element type of the array, potentially with type qualifiers missing. 176 /// This method should never be used when type qualifiers are meaningful. 177 const Type *Type::getArrayElementTypeNoTypeQual() const { 178 // If this is directly an array type, return it. 179 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 180 return ATy->getElementType().getTypePtr(); 181 182 // If the canonical form of this type isn't the right kind, reject it. 183 if (!isa<ArrayType>(CanonicalType)) 184 return 0; 185 186 // If this is a typedef for an array type, strip the typedef off without 187 // losing all typedef information. 188 return cast<ArrayType>(getUnqualifiedDesugaredType()) 189 ->getElementType().getTypePtr(); 190 } 191 192 /// getDesugaredType - Return the specified type with any "sugar" removed from 193 /// the type. This takes off typedefs, typeof's etc. If the outer level of 194 /// the type is already concrete, it returns it unmodified. This is similar 195 /// to getting the canonical type, but it doesn't remove *all* typedefs. For 196 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is 197 /// concrete. 198 QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) { 199 SplitQualType split = getSplitDesugaredType(T); 200 return Context.getQualifiedType(split.first, split.second); 201 } 202 203 QualType QualType::getSingleStepDesugaredType(const ASTContext &Context) const { 204 QualifierCollector Qs; 205 206 const Type *CurTy = Qs.strip(*this); 207 switch (CurTy->getTypeClass()) { 208 #define ABSTRACT_TYPE(Class, Parent) 209 #define TYPE(Class, Parent) \ 210 case Type::Class: { \ 211 const Class##Type *Ty = cast<Class##Type>(CurTy); \ 212 if (!Ty->isSugared()) \ 213 return *this; \ 214 return Context.getQualifiedType(Ty->desugar(), Qs); \ 215 break; \ 216 } 217 #include "clang/AST/TypeNodes.def" 218 } 219 220 return *this; 221 } 222 223 SplitQualType QualType::getSplitDesugaredType(QualType T) { 224 QualifierCollector Qs; 225 226 QualType Cur = T; 227 while (true) { 228 const Type *CurTy = Qs.strip(Cur); 229 switch (CurTy->getTypeClass()) { 230 #define ABSTRACT_TYPE(Class, Parent) 231 #define TYPE(Class, Parent) \ 232 case Type::Class: { \ 233 const Class##Type *Ty = cast<Class##Type>(CurTy); \ 234 if (!Ty->isSugared()) \ 235 return SplitQualType(Ty, Qs); \ 236 Cur = Ty->desugar(); \ 237 break; \ 238 } 239 #include "clang/AST/TypeNodes.def" 240 } 241 } 242 } 243 244 SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) { 245 SplitQualType split = type.split(); 246 247 // All the qualifiers we've seen so far. 248 Qualifiers quals = split.second; 249 250 // The last type node we saw with any nodes inside it. 251 const Type *lastTypeWithQuals = split.first; 252 253 while (true) { 254 QualType next; 255 256 // Do a single-step desugar, aborting the loop if the type isn't 257 // sugared. 258 switch (split.first->getTypeClass()) { 259 #define ABSTRACT_TYPE(Class, Parent) 260 #define TYPE(Class, Parent) \ 261 case Type::Class: { \ 262 const Class##Type *ty = cast<Class##Type>(split.first); \ 263 if (!ty->isSugared()) goto done; \ 264 next = ty->desugar(); \ 265 break; \ 266 } 267 #include "clang/AST/TypeNodes.def" 268 } 269 270 // Otherwise, split the underlying type. If that yields qualifiers, 271 // update the information. 272 split = next.split(); 273 if (!split.second.empty()) { 274 lastTypeWithQuals = split.first; 275 quals.addConsistentQualifiers(split.second); 276 } 277 } 278 279 done: 280 return SplitQualType(lastTypeWithQuals, quals); 281 } 282 283 QualType QualType::IgnoreParens(QualType T) { 284 // FIXME: this seems inherently un-qualifiers-safe. 285 while (const ParenType *PT = T->getAs<ParenType>()) 286 T = PT->getInnerType(); 287 return T; 288 } 289 290 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic 291 /// sugar off the given type. This should produce an object of the 292 /// same dynamic type as the canonical type. 293 const Type *Type::getUnqualifiedDesugaredType() const { 294 const Type *Cur = this; 295 296 while (true) { 297 switch (Cur->getTypeClass()) { 298 #define ABSTRACT_TYPE(Class, Parent) 299 #define TYPE(Class, Parent) \ 300 case Class: { \ 301 const Class##Type *Ty = cast<Class##Type>(Cur); \ 302 if (!Ty->isSugared()) return Cur; \ 303 Cur = Ty->desugar().getTypePtr(); \ 304 break; \ 305 } 306 #include "clang/AST/TypeNodes.def" 307 } 308 } 309 } 310 311 /// isVoidType - Helper method to determine if this is the 'void' type. 312 bool Type::isVoidType() const { 313 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 314 return BT->getKind() == BuiltinType::Void; 315 return false; 316 } 317 318 bool Type::isDerivedType() const { 319 switch (CanonicalType->getTypeClass()) { 320 case Pointer: 321 case VariableArray: 322 case ConstantArray: 323 case IncompleteArray: 324 case FunctionProto: 325 case FunctionNoProto: 326 case LValueReference: 327 case RValueReference: 328 case Record: 329 return true; 330 default: 331 return false; 332 } 333 } 334 bool Type::isClassType() const { 335 if (const RecordType *RT = getAs<RecordType>()) 336 return RT->getDecl()->isClass(); 337 return false; 338 } 339 bool Type::isStructureType() const { 340 if (const RecordType *RT = getAs<RecordType>()) 341 return RT->getDecl()->isStruct(); 342 return false; 343 } 344 bool Type::isStructureOrClassType() const { 345 if (const RecordType *RT = getAs<RecordType>()) 346 return RT->getDecl()->isStruct() || RT->getDecl()->isClass(); 347 return false; 348 } 349 bool Type::isVoidPointerType() const { 350 if (const PointerType *PT = getAs<PointerType>()) 351 return PT->getPointeeType()->isVoidType(); 352 return false; 353 } 354 355 bool Type::isUnionType() const { 356 if (const RecordType *RT = getAs<RecordType>()) 357 return RT->getDecl()->isUnion(); 358 return false; 359 } 360 361 bool Type::isComplexType() const { 362 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 363 return CT->getElementType()->isFloatingType(); 364 return false; 365 } 366 367 bool Type::isComplexIntegerType() const { 368 // Check for GCC complex integer extension. 369 return getAsComplexIntegerType(); 370 } 371 372 const ComplexType *Type::getAsComplexIntegerType() const { 373 if (const ComplexType *Complex = getAs<ComplexType>()) 374 if (Complex->getElementType()->isIntegerType()) 375 return Complex; 376 return 0; 377 } 378 379 QualType Type::getPointeeType() const { 380 if (const PointerType *PT = getAs<PointerType>()) 381 return PT->getPointeeType(); 382 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) 383 return OPT->getPointeeType(); 384 if (const BlockPointerType *BPT = getAs<BlockPointerType>()) 385 return BPT->getPointeeType(); 386 if (const ReferenceType *RT = getAs<ReferenceType>()) 387 return RT->getPointeeType(); 388 return QualType(); 389 } 390 391 const RecordType *Type::getAsStructureType() const { 392 // If this is directly a structure type, return it. 393 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 394 if (RT->getDecl()->isStruct()) 395 return RT; 396 } 397 398 // If the canonical form of this type isn't the right kind, reject it. 399 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 400 if (!RT->getDecl()->isStruct()) 401 return 0; 402 403 // If this is a typedef for a structure type, strip the typedef off without 404 // losing all typedef information. 405 return cast<RecordType>(getUnqualifiedDesugaredType()); 406 } 407 return 0; 408 } 409 410 const RecordType *Type::getAsUnionType() const { 411 // If this is directly a union type, return it. 412 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 413 if (RT->getDecl()->isUnion()) 414 return RT; 415 } 416 417 // If the canonical form of this type isn't the right kind, reject it. 418 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 419 if (!RT->getDecl()->isUnion()) 420 return 0; 421 422 // If this is a typedef for a union type, strip the typedef off without 423 // losing all typedef information. 424 return cast<RecordType>(getUnqualifiedDesugaredType()); 425 } 426 427 return 0; 428 } 429 430 ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base, 431 ObjCProtocolDecl * const *Protocols, 432 unsigned NumProtocols) 433 : Type(ObjCObject, Canonical, false, false, false, false), 434 BaseType(Base) 435 { 436 ObjCObjectTypeBits.NumProtocols = NumProtocols; 437 assert(getNumProtocols() == NumProtocols && 438 "bitfield overflow in protocol count"); 439 if (NumProtocols) 440 memcpy(getProtocolStorage(), Protocols, 441 NumProtocols * sizeof(ObjCProtocolDecl*)); 442 } 443 444 const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const { 445 // There is no sugar for ObjCObjectType's, just return the canonical 446 // type pointer if it is the right class. There is no typedef information to 447 // return and these cannot be Address-space qualified. 448 if (const ObjCObjectType *T = getAs<ObjCObjectType>()) 449 if (T->getNumProtocols() && T->getInterface()) 450 return T; 451 return 0; 452 } 453 454 bool Type::isObjCQualifiedInterfaceType() const { 455 return getAsObjCQualifiedInterfaceType() != 0; 456 } 457 458 const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const { 459 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 460 // type pointer if it is the right class. 461 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 462 if (OPT->isObjCQualifiedIdType()) 463 return OPT; 464 } 465 return 0; 466 } 467 468 const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const { 469 // There is no sugar for ObjCQualifiedClassType's, just return the canonical 470 // type pointer if it is the right class. 471 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 472 if (OPT->isObjCQualifiedClassType()) 473 return OPT; 474 } 475 return 0; 476 } 477 478 const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const { 479 if (const ObjCObjectPointerType *OPT = getAs<ObjCObjectPointerType>()) { 480 if (OPT->getInterfaceType()) 481 return OPT; 482 } 483 return 0; 484 } 485 486 const CXXRecordDecl *Type::getCXXRecordDeclForPointerType() const { 487 if (const PointerType *PT = getAs<PointerType>()) 488 if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>()) 489 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 490 return 0; 491 } 492 493 CXXRecordDecl *Type::getAsCXXRecordDecl() const { 494 if (const RecordType *RT = getAs<RecordType>()) 495 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 496 else if (const InjectedClassNameType *Injected 497 = getAs<InjectedClassNameType>()) 498 return Injected->getDecl(); 499 500 return 0; 501 } 502 503 namespace { 504 class GetContainedAutoVisitor : 505 public TypeVisitor<GetContainedAutoVisitor, AutoType*> { 506 public: 507 using TypeVisitor<GetContainedAutoVisitor, AutoType*>::Visit; 508 AutoType *Visit(QualType T) { 509 if (T.isNull()) 510 return 0; 511 return Visit(T.getTypePtr()); 512 } 513 514 // The 'auto' type itself. 515 AutoType *VisitAutoType(const AutoType *AT) { 516 return const_cast<AutoType*>(AT); 517 } 518 519 // Only these types can contain the desired 'auto' type. 520 AutoType *VisitPointerType(const PointerType *T) { 521 return Visit(T->getPointeeType()); 522 } 523 AutoType *VisitBlockPointerType(const BlockPointerType *T) { 524 return Visit(T->getPointeeType()); 525 } 526 AutoType *VisitReferenceType(const ReferenceType *T) { 527 return Visit(T->getPointeeTypeAsWritten()); 528 } 529 AutoType *VisitMemberPointerType(const MemberPointerType *T) { 530 return Visit(T->getPointeeType()); 531 } 532 AutoType *VisitArrayType(const ArrayType *T) { 533 return Visit(T->getElementType()); 534 } 535 AutoType *VisitDependentSizedExtVectorType( 536 const DependentSizedExtVectorType *T) { 537 return Visit(T->getElementType()); 538 } 539 AutoType *VisitVectorType(const VectorType *T) { 540 return Visit(T->getElementType()); 541 } 542 AutoType *VisitFunctionType(const FunctionType *T) { 543 return Visit(T->getResultType()); 544 } 545 AutoType *VisitParenType(const ParenType *T) { 546 return Visit(T->getInnerType()); 547 } 548 AutoType *VisitAttributedType(const AttributedType *T) { 549 return Visit(T->getModifiedType()); 550 } 551 }; 552 } 553 554 AutoType *Type::getContainedAutoType() const { 555 return GetContainedAutoVisitor().Visit(this); 556 } 557 558 bool Type::isIntegerType() const { 559 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 560 return BT->getKind() >= BuiltinType::Bool && 561 BT->getKind() <= BuiltinType::Int128; 562 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 563 // Incomplete enum types are not treated as integer types. 564 // FIXME: In C++, enum types are never integer types. 565 return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped(); 566 return false; 567 } 568 569 bool Type::hasIntegerRepresentation() const { 570 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 571 return VT->getElementType()->isIntegerType(); 572 else 573 return isIntegerType(); 574 } 575 576 /// \brief Determine whether this type is an integral type. 577 /// 578 /// This routine determines whether the given type is an integral type per 579 /// C++ [basic.fundamental]p7. Although the C standard does not define the 580 /// term "integral type", it has a similar term "integer type", and in C++ 581 /// the two terms are equivalent. However, C's "integer type" includes 582 /// enumeration types, while C++'s "integer type" does not. The \c ASTContext 583 /// parameter is used to determine whether we should be following the C or 584 /// C++ rules when determining whether this type is an integral/integer type. 585 /// 586 /// For cases where C permits "an integer type" and C++ permits "an integral 587 /// type", use this routine. 588 /// 589 /// For cases where C permits "an integer type" and C++ permits "an integral 590 /// or enumeration type", use \c isIntegralOrEnumerationType() instead. 591 /// 592 /// \param Ctx The context in which this type occurs. 593 /// 594 /// \returns true if the type is considered an integral type, false otherwise. 595 bool Type::isIntegralType(ASTContext &Ctx) const { 596 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 597 return BT->getKind() >= BuiltinType::Bool && 598 BT->getKind() <= BuiltinType::Int128; 599 600 if (!Ctx.getLangOptions().CPlusPlus) 601 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 602 return ET->getDecl()->isComplete(); // Complete enum types are integral in C. 603 604 return false; 605 } 606 607 bool Type::isIntegralOrEnumerationType() const { 608 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 609 return BT->getKind() >= BuiltinType::Bool && 610 BT->getKind() <= BuiltinType::Int128; 611 612 // Check for a complete enum type; incomplete enum types are not properly an 613 // enumeration type in the sense required here. 614 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 615 return ET->getDecl()->isComplete(); 616 617 return false; 618 } 619 620 bool Type::isIntegralOrUnscopedEnumerationType() const { 621 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 622 return BT->getKind() >= BuiltinType::Bool && 623 BT->getKind() <= BuiltinType::Int128; 624 625 // Check for a complete enum type; incomplete enum types are not properly an 626 // enumeration type in the sense required here. 627 // C++0x: However, if the underlying type of the enum is fixed, it is 628 // considered complete. 629 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 630 return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped(); 631 632 return false; 633 } 634 635 636 bool Type::isBooleanType() const { 637 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 638 return BT->getKind() == BuiltinType::Bool; 639 return false; 640 } 641 642 bool Type::isCharType() const { 643 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 644 return BT->getKind() == BuiltinType::Char_U || 645 BT->getKind() == BuiltinType::UChar || 646 BT->getKind() == BuiltinType::Char_S || 647 BT->getKind() == BuiltinType::SChar; 648 return false; 649 } 650 651 bool Type::isWideCharType() const { 652 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 653 return BT->getKind() == BuiltinType::WChar_S || 654 BT->getKind() == BuiltinType::WChar_U; 655 return false; 656 } 657 658 bool Type::isChar16Type() const { 659 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 660 return BT->getKind() == BuiltinType::Char16; 661 return false; 662 } 663 664 bool Type::isChar32Type() const { 665 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 666 return BT->getKind() == BuiltinType::Char32; 667 return false; 668 } 669 670 /// \brief Determine whether this type is any of the built-in character 671 /// types. 672 bool Type::isAnyCharacterType() const { 673 const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType); 674 if (BT == 0) return false; 675 switch (BT->getKind()) { 676 default: return false; 677 case BuiltinType::Char_U: 678 case BuiltinType::UChar: 679 case BuiltinType::WChar_U: 680 case BuiltinType::Char16: 681 case BuiltinType::Char32: 682 case BuiltinType::Char_S: 683 case BuiltinType::SChar: 684 case BuiltinType::WChar_S: 685 return true; 686 } 687 } 688 689 /// isSignedIntegerType - Return true if this is an integer type that is 690 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 691 /// an enum decl which has a signed representation 692 bool Type::isSignedIntegerType() const { 693 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 694 return BT->getKind() >= BuiltinType::Char_S && 695 BT->getKind() <= BuiltinType::Int128; 696 } 697 698 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { 699 // Incomplete enum types are not treated as integer types. 700 // FIXME: In C++, enum types are never integer types. 701 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped()) 702 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 703 } 704 705 return false; 706 } 707 708 bool Type::isSignedIntegerOrEnumerationType() const { 709 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 710 return BT->getKind() >= BuiltinType::Char_S && 711 BT->getKind() <= BuiltinType::Int128; 712 } 713 714 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { 715 if (ET->getDecl()->isComplete()) 716 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 717 } 718 719 return false; 720 } 721 722 bool Type::hasSignedIntegerRepresentation() const { 723 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 724 return VT->getElementType()->isSignedIntegerType(); 725 else 726 return isSignedIntegerType(); 727 } 728 729 /// isUnsignedIntegerType - Return true if this is an integer type that is 730 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 731 /// decl which has an unsigned representation 732 bool Type::isUnsignedIntegerType() const { 733 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 734 return BT->getKind() >= BuiltinType::Bool && 735 BT->getKind() <= BuiltinType::UInt128; 736 } 737 738 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { 739 // Incomplete enum types are not treated as integer types. 740 // FIXME: In C++, enum types are never integer types. 741 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped()) 742 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 743 } 744 745 return false; 746 } 747 748 bool Type::isUnsignedIntegerOrEnumerationType() const { 749 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 750 return BT->getKind() >= BuiltinType::Bool && 751 BT->getKind() <= BuiltinType::UInt128; 752 } 753 754 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { 755 if (ET->getDecl()->isComplete()) 756 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 757 } 758 759 return false; 760 } 761 762 bool Type::hasUnsignedIntegerRepresentation() const { 763 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 764 return VT->getElementType()->isUnsignedIntegerType(); 765 else 766 return isUnsignedIntegerType(); 767 } 768 769 bool Type::isHalfType() const { 770 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 771 return BT->getKind() == BuiltinType::Half; 772 // FIXME: Should we allow complex __fp16? Probably not. 773 return false; 774 } 775 776 bool Type::isFloatingType() const { 777 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 778 return BT->getKind() >= BuiltinType::Half && 779 BT->getKind() <= BuiltinType::LongDouble; 780 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 781 return CT->getElementType()->isFloatingType(); 782 return false; 783 } 784 785 bool Type::hasFloatingRepresentation() const { 786 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 787 return VT->getElementType()->isFloatingType(); 788 else 789 return isFloatingType(); 790 } 791 792 bool Type::isRealFloatingType() const { 793 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 794 return BT->isFloatingPoint(); 795 return false; 796 } 797 798 bool Type::isRealType() const { 799 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 800 return BT->getKind() >= BuiltinType::Bool && 801 BT->getKind() <= BuiltinType::LongDouble; 802 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 803 return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped(); 804 return false; 805 } 806 807 bool Type::isArithmeticType() const { 808 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 809 return BT->getKind() >= BuiltinType::Bool && 810 BT->getKind() <= BuiltinType::LongDouble; 811 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 812 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 813 // If a body isn't seen by the time we get here, return false. 814 // 815 // C++0x: Enumerations are not arithmetic types. For now, just return 816 // false for scoped enumerations since that will disable any 817 // unwanted implicit conversions. 818 return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete(); 819 return isa<ComplexType>(CanonicalType); 820 } 821 822 bool Type::isScalarType() const { 823 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 824 return BT->getKind() > BuiltinType::Void && 825 BT->getKind() <= BuiltinType::NullPtr; 826 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 827 // Enums are scalar types, but only if they are defined. Incomplete enums 828 // are not treated as scalar types. 829 return ET->getDecl()->isComplete(); 830 return isa<PointerType>(CanonicalType) || 831 isa<BlockPointerType>(CanonicalType) || 832 isa<MemberPointerType>(CanonicalType) || 833 isa<ComplexType>(CanonicalType) || 834 isa<ObjCObjectPointerType>(CanonicalType); 835 } 836 837 Type::ScalarTypeKind Type::getScalarTypeKind() const { 838 assert(isScalarType()); 839 840 const Type *T = CanonicalType.getTypePtr(); 841 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) { 842 if (BT->getKind() == BuiltinType::Bool) return STK_Bool; 843 if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer; 844 if (BT->isInteger()) return STK_Integral; 845 if (BT->isFloatingPoint()) return STK_Floating; 846 llvm_unreachable("unknown scalar builtin type"); 847 } else if (isa<PointerType>(T)) { 848 return STK_CPointer; 849 } else if (isa<BlockPointerType>(T)) { 850 return STK_BlockPointer; 851 } else if (isa<ObjCObjectPointerType>(T)) { 852 return STK_ObjCObjectPointer; 853 } else if (isa<MemberPointerType>(T)) { 854 return STK_MemberPointer; 855 } else if (isa<EnumType>(T)) { 856 assert(cast<EnumType>(T)->getDecl()->isComplete()); 857 return STK_Integral; 858 } else if (const ComplexType *CT = dyn_cast<ComplexType>(T)) { 859 if (CT->getElementType()->isRealFloatingType()) 860 return STK_FloatingComplex; 861 return STK_IntegralComplex; 862 } 863 864 llvm_unreachable("unknown scalar type"); 865 } 866 867 /// \brief Determines whether the type is a C++ aggregate type or C 868 /// aggregate or union type. 869 /// 870 /// An aggregate type is an array or a class type (struct, union, or 871 /// class) that has no user-declared constructors, no private or 872 /// protected non-static data members, no base classes, and no virtual 873 /// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 874 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 875 /// includes union types. 876 bool Type::isAggregateType() const { 877 if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) { 878 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl())) 879 return ClassDecl->isAggregate(); 880 881 return true; 882 } 883 884 return isa<ArrayType>(CanonicalType); 885 } 886 887 /// isConstantSizeType - Return true if this is not a variable sized type, 888 /// according to the rules of C99 6.7.5p3. It is not legal to call this on 889 /// incomplete types or dependent types. 890 bool Type::isConstantSizeType() const { 891 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 892 assert(!isDependentType() && "This doesn't make sense for dependent types"); 893 // The VAT must have a size, as it is known to be complete. 894 return !isa<VariableArrayType>(CanonicalType); 895 } 896 897 /// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 898 /// - a type that can describe objects, but which lacks information needed to 899 /// determine its size. 900 bool Type::isIncompleteType() const { 901 switch (CanonicalType->getTypeClass()) { 902 default: return false; 903 case Builtin: 904 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 905 // be completed. 906 return isVoidType(); 907 case Enum: 908 // An enumeration with fixed underlying type is complete (C++0x 7.2p3). 909 if (cast<EnumType>(CanonicalType)->getDecl()->isFixed()) 910 return false; 911 // Fall through. 912 case Record: 913 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 914 // forward declaration, but not a full definition (C99 6.2.5p22). 915 return !cast<TagType>(CanonicalType)->getDecl()->isCompleteDefinition(); 916 case ConstantArray: 917 // An array is incomplete if its element type is incomplete 918 // (C++ [dcl.array]p1). 919 // We don't handle variable arrays (they're not allowed in C++) or 920 // dependent-sized arrays (dependent types are never treated as incomplete). 921 return cast<ArrayType>(CanonicalType)->getElementType()->isIncompleteType(); 922 case IncompleteArray: 923 // An array of unknown size is an incomplete type (C99 6.2.5p22). 924 return true; 925 case ObjCObject: 926 return cast<ObjCObjectType>(CanonicalType)->getBaseType() 927 ->isIncompleteType(); 928 case ObjCInterface: 929 // ObjC interfaces are incomplete if they are @class, not @interface. 930 return cast<ObjCInterfaceType>(CanonicalType)->getDecl()->isForwardDecl(); 931 } 932 } 933 934 bool QualType::isPODType(ASTContext &Context) const { 935 // The compiler shouldn't query this for incomplete types, but the user might. 936 // We return false for that case. Except for incomplete arrays of PODs, which 937 // are PODs according to the standard. 938 if (isNull()) 939 return 0; 940 941 if ((*this)->isIncompleteArrayType()) 942 return Context.getBaseElementType(*this).isPODType(Context); 943 944 if ((*this)->isIncompleteType()) 945 return false; 946 947 if (Context.getLangOptions().ObjCAutoRefCount) { 948 switch (getObjCLifetime()) { 949 case Qualifiers::OCL_ExplicitNone: 950 return true; 951 952 case Qualifiers::OCL_Strong: 953 case Qualifiers::OCL_Weak: 954 case Qualifiers::OCL_Autoreleasing: 955 return false; 956 957 case Qualifiers::OCL_None: 958 break; 959 } 960 } 961 962 QualType CanonicalType = getTypePtr()->CanonicalType; 963 switch (CanonicalType->getTypeClass()) { 964 // Everything not explicitly mentioned is not POD. 965 default: return false; 966 case Type::VariableArray: 967 case Type::ConstantArray: 968 // IncompleteArray is handled above. 969 return Context.getBaseElementType(*this).isPODType(Context); 970 971 case Type::ObjCObjectPointer: 972 case Type::BlockPointer: 973 case Type::Builtin: 974 case Type::Complex: 975 case Type::Pointer: 976 case Type::MemberPointer: 977 case Type::Vector: 978 case Type::ExtVector: 979 return true; 980 981 case Type::Enum: 982 return true; 983 984 case Type::Record: 985 if (CXXRecordDecl *ClassDecl 986 = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl())) 987 return ClassDecl->isPOD(); 988 989 // C struct/union is POD. 990 return true; 991 } 992 } 993 994 bool QualType::isTrivialType(ASTContext &Context) const { 995 // The compiler shouldn't query this for incomplete types, but the user might. 996 // We return false for that case. Except for incomplete arrays of PODs, which 997 // are PODs according to the standard. 998 if (isNull()) 999 return 0; 1000 1001 if ((*this)->isArrayType()) 1002 return Context.getBaseElementType(*this).isTrivialType(Context); 1003 1004 // Return false for incomplete types after skipping any incomplete array 1005 // types which are expressly allowed by the standard and thus our API. 1006 if ((*this)->isIncompleteType()) 1007 return false; 1008 1009 if (Context.getLangOptions().ObjCAutoRefCount) { 1010 switch (getObjCLifetime()) { 1011 case Qualifiers::OCL_ExplicitNone: 1012 return true; 1013 1014 case Qualifiers::OCL_Strong: 1015 case Qualifiers::OCL_Weak: 1016 case Qualifiers::OCL_Autoreleasing: 1017 return false; 1018 1019 case Qualifiers::OCL_None: 1020 if ((*this)->isObjCLifetimeType()) 1021 return false; 1022 break; 1023 } 1024 } 1025 1026 QualType CanonicalType = getTypePtr()->CanonicalType; 1027 if (CanonicalType->isDependentType()) 1028 return false; 1029 1030 // C++0x [basic.types]p9: 1031 // Scalar types, trivial class types, arrays of such types, and 1032 // cv-qualified versions of these types are collectively called trivial 1033 // types. 1034 1035 // As an extension, Clang treats vector types as Scalar types. 1036 if (CanonicalType->isScalarType() || CanonicalType->isVectorType()) 1037 return true; 1038 if (const RecordType *RT = CanonicalType->getAs<RecordType>()) { 1039 if (const CXXRecordDecl *ClassDecl = 1040 dyn_cast<CXXRecordDecl>(RT->getDecl())) { 1041 // C++0x [class]p5: 1042 // A trivial class is a class that has a trivial default constructor 1043 if (!ClassDecl->hasTrivialDefaultConstructor()) return false; 1044 // and is trivially copyable. 1045 if (!ClassDecl->isTriviallyCopyable()) return false; 1046 } 1047 1048 return true; 1049 } 1050 1051 // No other types can match. 1052 return false; 1053 } 1054 1055 bool QualType::isTriviallyCopyableType(ASTContext &Context) const { 1056 if ((*this)->isArrayType()) 1057 return Context.getBaseElementType(*this).isTrivialType(Context); 1058 1059 if (Context.getLangOptions().ObjCAutoRefCount) { 1060 switch (getObjCLifetime()) { 1061 case Qualifiers::OCL_ExplicitNone: 1062 return true; 1063 1064 case Qualifiers::OCL_Strong: 1065 case Qualifiers::OCL_Weak: 1066 case Qualifiers::OCL_Autoreleasing: 1067 return false; 1068 1069 case Qualifiers::OCL_None: 1070 if ((*this)->isObjCLifetimeType()) 1071 return false; 1072 break; 1073 } 1074 } 1075 1076 // C++0x [basic.types]p9 1077 // Scalar types, trivially copyable class types, arrays of such types, and 1078 // cv-qualified versions of these types are collectively called trivial 1079 // types. 1080 1081 QualType CanonicalType = getCanonicalType(); 1082 if (CanonicalType->isDependentType()) 1083 return false; 1084 1085 // Return false for incomplete types after skipping any incomplete array types 1086 // which are expressly allowed by the standard and thus our API. 1087 if (CanonicalType->isIncompleteType()) 1088 return false; 1089 1090 // As an extension, Clang treats vector types as Scalar types. 1091 if (CanonicalType->isScalarType() || CanonicalType->isVectorType()) 1092 return true; 1093 1094 if (const RecordType *RT = CanonicalType->getAs<RecordType>()) { 1095 if (const CXXRecordDecl *ClassDecl = 1096 dyn_cast<CXXRecordDecl>(RT->getDecl())) { 1097 if (!ClassDecl->isTriviallyCopyable()) return false; 1098 } 1099 1100 return true; 1101 } 1102 1103 // No other types can match. 1104 return false; 1105 } 1106 1107 1108 1109 bool Type::isLiteralType() const { 1110 if (isDependentType()) 1111 return false; 1112 1113 // C++0x [basic.types]p10: 1114 // A type is a literal type if it is: 1115 // [...] 1116 // -- an array of literal type. 1117 // Extension: variable arrays cannot be literal types, since they're 1118 // runtime-sized. 1119 if (isVariableArrayType()) 1120 return false; 1121 const Type *BaseTy = getBaseElementTypeUnsafe(); 1122 assert(BaseTy && "NULL element type"); 1123 1124 // Return false for incomplete types after skipping any incomplete array 1125 // types; those are expressly allowed by the standard and thus our API. 1126 if (BaseTy->isIncompleteType()) 1127 return false; 1128 1129 // Objective-C lifetime types are not literal types. 1130 if (BaseTy->isObjCRetainableType()) 1131 return false; 1132 1133 // C++0x [basic.types]p10: 1134 // A type is a literal type if it is: 1135 // -- a scalar type; or 1136 // As an extension, Clang treats vector types as literal types. 1137 if (BaseTy->isScalarType() || BaseTy->isVectorType()) 1138 return true; 1139 // -- a reference type; or 1140 if (BaseTy->isReferenceType()) 1141 return true; 1142 // -- a class type that has all of the following properties: 1143 if (const RecordType *RT = BaseTy->getAs<RecordType>()) { 1144 // -- a trivial destructor, 1145 // -- every constructor call and full-expression in the 1146 // brace-or-equal-initializers for non-static data members (if any) 1147 // is a constant expression, 1148 // -- it is an aggregate type or has at least one constexpr 1149 // constructor or constructor template that is not a copy or move 1150 // constructor, and 1151 // -- all non-static data members and base classes of literal types 1152 // 1153 // We resolve DR1361 by ignoring the second bullet. 1154 if (const CXXRecordDecl *ClassDecl = 1155 dyn_cast<CXXRecordDecl>(RT->getDecl())) 1156 return ClassDecl->isLiteral(); 1157 1158 return true; 1159 } 1160 1161 return false; 1162 } 1163 1164 bool Type::isStandardLayoutType() const { 1165 if (isDependentType()) 1166 return false; 1167 1168 // C++0x [basic.types]p9: 1169 // Scalar types, standard-layout class types, arrays of such types, and 1170 // cv-qualified versions of these types are collectively called 1171 // standard-layout types. 1172 const Type *BaseTy = getBaseElementTypeUnsafe(); 1173 assert(BaseTy && "NULL element type"); 1174 1175 // Return false for incomplete types after skipping any incomplete array 1176 // types which are expressly allowed by the standard and thus our API. 1177 if (BaseTy->isIncompleteType()) 1178 return false; 1179 1180 // As an extension, Clang treats vector types as Scalar types. 1181 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true; 1182 if (const RecordType *RT = BaseTy->getAs<RecordType>()) { 1183 if (const CXXRecordDecl *ClassDecl = 1184 dyn_cast<CXXRecordDecl>(RT->getDecl())) 1185 if (!ClassDecl->isStandardLayout()) 1186 return false; 1187 1188 // Default to 'true' for non-C++ class types. 1189 // FIXME: This is a bit dubious, but plain C structs should trivially meet 1190 // all the requirements of standard layout classes. 1191 return true; 1192 } 1193 1194 // No other types can match. 1195 return false; 1196 } 1197 1198 // This is effectively the intersection of isTrivialType and 1199 // isStandardLayoutType. We implement it directly to avoid redundant 1200 // conversions from a type to a CXXRecordDecl. 1201 bool QualType::isCXX11PODType(ASTContext &Context) const { 1202 const Type *ty = getTypePtr(); 1203 if (ty->isDependentType()) 1204 return false; 1205 1206 if (Context.getLangOptions().ObjCAutoRefCount) { 1207 switch (getObjCLifetime()) { 1208 case Qualifiers::OCL_ExplicitNone: 1209 return true; 1210 1211 case Qualifiers::OCL_Strong: 1212 case Qualifiers::OCL_Weak: 1213 case Qualifiers::OCL_Autoreleasing: 1214 return false; 1215 1216 case Qualifiers::OCL_None: 1217 if (ty->isObjCLifetimeType()) 1218 return false; 1219 break; 1220 } 1221 } 1222 1223 // C++11 [basic.types]p9: 1224 // Scalar types, POD classes, arrays of such types, and cv-qualified 1225 // versions of these types are collectively called trivial types. 1226 const Type *BaseTy = ty->getBaseElementTypeUnsafe(); 1227 assert(BaseTy && "NULL element type"); 1228 1229 // Return false for incomplete types after skipping any incomplete array 1230 // types which are expressly allowed by the standard and thus our API. 1231 if (BaseTy->isIncompleteType()) 1232 return false; 1233 1234 // As an extension, Clang treats vector types as Scalar types. 1235 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true; 1236 if (const RecordType *RT = BaseTy->getAs<RecordType>()) { 1237 if (const CXXRecordDecl *ClassDecl = 1238 dyn_cast<CXXRecordDecl>(RT->getDecl())) { 1239 // C++11 [class]p10: 1240 // A POD struct is a non-union class that is both a trivial class [...] 1241 if (!ClassDecl->isTrivial()) return false; 1242 1243 // C++11 [class]p10: 1244 // A POD struct is a non-union class that is both a trivial class and 1245 // a standard-layout class [...] 1246 if (!ClassDecl->isStandardLayout()) return false; 1247 1248 // C++11 [class]p10: 1249 // A POD struct is a non-union class that is both a trivial class and 1250 // a standard-layout class, and has no non-static data members of type 1251 // non-POD struct, non-POD union (or array of such types). [...] 1252 // 1253 // We don't directly query the recursive aspect as the requiremets for 1254 // both standard-layout classes and trivial classes apply recursively 1255 // already. 1256 } 1257 1258 return true; 1259 } 1260 1261 // No other types can match. 1262 return false; 1263 } 1264 1265 bool Type::isPromotableIntegerType() const { 1266 if (const BuiltinType *BT = getAs<BuiltinType>()) 1267 switch (BT->getKind()) { 1268 case BuiltinType::Bool: 1269 case BuiltinType::Char_S: 1270 case BuiltinType::Char_U: 1271 case BuiltinType::SChar: 1272 case BuiltinType::UChar: 1273 case BuiltinType::Short: 1274 case BuiltinType::UShort: 1275 return true; 1276 default: 1277 return false; 1278 } 1279 1280 // Enumerated types are promotable to their compatible integer types 1281 // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2). 1282 if (const EnumType *ET = getAs<EnumType>()){ 1283 if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull() 1284 || ET->getDecl()->isScoped()) 1285 return false; 1286 1287 const BuiltinType *BT 1288 = ET->getDecl()->getPromotionType()->getAs<BuiltinType>(); 1289 return BT->getKind() == BuiltinType::Int 1290 || BT->getKind() == BuiltinType::UInt; 1291 } 1292 1293 return false; 1294 } 1295 1296 bool Type::isNullPtrType() const { 1297 if (const BuiltinType *BT = getAs<BuiltinType>()) 1298 return BT->getKind() == BuiltinType::NullPtr; 1299 return false; 1300 } 1301 1302 bool Type::isSpecifierType() const { 1303 // Note that this intentionally does not use the canonical type. 1304 switch (getTypeClass()) { 1305 case Builtin: 1306 case Record: 1307 case Enum: 1308 case Typedef: 1309 case Complex: 1310 case TypeOfExpr: 1311 case TypeOf: 1312 case TemplateTypeParm: 1313 case SubstTemplateTypeParm: 1314 case TemplateSpecialization: 1315 case Elaborated: 1316 case DependentName: 1317 case DependentTemplateSpecialization: 1318 case ObjCInterface: 1319 case ObjCObject: 1320 case ObjCObjectPointer: // FIXME: object pointers aren't really specifiers 1321 return true; 1322 default: 1323 return false; 1324 } 1325 } 1326 1327 ElaboratedTypeKeyword 1328 TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) { 1329 switch (TypeSpec) { 1330 default: return ETK_None; 1331 case TST_typename: return ETK_Typename; 1332 case TST_class: return ETK_Class; 1333 case TST_struct: return ETK_Struct; 1334 case TST_union: return ETK_Union; 1335 case TST_enum: return ETK_Enum; 1336 } 1337 } 1338 1339 TagTypeKind 1340 TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) { 1341 switch(TypeSpec) { 1342 case TST_class: return TTK_Class; 1343 case TST_struct: return TTK_Struct; 1344 case TST_union: return TTK_Union; 1345 case TST_enum: return TTK_Enum; 1346 } 1347 1348 llvm_unreachable("Type specifier is not a tag type kind."); 1349 return TTK_Union; 1350 } 1351 1352 ElaboratedTypeKeyword 1353 TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) { 1354 switch (Kind) { 1355 case TTK_Class: return ETK_Class; 1356 case TTK_Struct: return ETK_Struct; 1357 case TTK_Union: return ETK_Union; 1358 case TTK_Enum: return ETK_Enum; 1359 } 1360 llvm_unreachable("Unknown tag type kind."); 1361 } 1362 1363 TagTypeKind 1364 TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) { 1365 switch (Keyword) { 1366 case ETK_Class: return TTK_Class; 1367 case ETK_Struct: return TTK_Struct; 1368 case ETK_Union: return TTK_Union; 1369 case ETK_Enum: return TTK_Enum; 1370 case ETK_None: // Fall through. 1371 case ETK_Typename: 1372 llvm_unreachable("Elaborated type keyword is not a tag type kind."); 1373 } 1374 llvm_unreachable("Unknown elaborated type keyword."); 1375 } 1376 1377 bool 1378 TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) { 1379 switch (Keyword) { 1380 case ETK_None: 1381 case ETK_Typename: 1382 return false; 1383 case ETK_Class: 1384 case ETK_Struct: 1385 case ETK_Union: 1386 case ETK_Enum: 1387 return true; 1388 } 1389 llvm_unreachable("Unknown elaborated type keyword."); 1390 } 1391 1392 const char* 1393 TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) { 1394 switch (Keyword) { 1395 case ETK_None: return ""; 1396 case ETK_Typename: return "typename"; 1397 case ETK_Class: return "class"; 1398 case ETK_Struct: return "struct"; 1399 case ETK_Union: return "union"; 1400 case ETK_Enum: return "enum"; 1401 } 1402 1403 llvm_unreachable("Unknown elaborated type keyword."); 1404 return ""; 1405 } 1406 1407 DependentTemplateSpecializationType::DependentTemplateSpecializationType( 1408 ElaboratedTypeKeyword Keyword, 1409 NestedNameSpecifier *NNS, const IdentifierInfo *Name, 1410 unsigned NumArgs, const TemplateArgument *Args, 1411 QualType Canon) 1412 : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, true, true, 1413 /*VariablyModified=*/false, 1414 NNS && NNS->containsUnexpandedParameterPack()), 1415 NNS(NNS), Name(Name), NumArgs(NumArgs) { 1416 assert((!NNS || NNS->isDependent()) && 1417 "DependentTemplateSpecializatonType requires dependent qualifier"); 1418 for (unsigned I = 0; I != NumArgs; ++I) { 1419 if (Args[I].containsUnexpandedParameterPack()) 1420 setContainsUnexpandedParameterPack(); 1421 1422 new (&getArgBuffer()[I]) TemplateArgument(Args[I]); 1423 } 1424 } 1425 1426 void 1427 DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 1428 const ASTContext &Context, 1429 ElaboratedTypeKeyword Keyword, 1430 NestedNameSpecifier *Qualifier, 1431 const IdentifierInfo *Name, 1432 unsigned NumArgs, 1433 const TemplateArgument *Args) { 1434 ID.AddInteger(Keyword); 1435 ID.AddPointer(Qualifier); 1436 ID.AddPointer(Name); 1437 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) 1438 Args[Idx].Profile(ID, Context); 1439 } 1440 1441 bool Type::isElaboratedTypeSpecifier() const { 1442 ElaboratedTypeKeyword Keyword; 1443 if (const ElaboratedType *Elab = dyn_cast<ElaboratedType>(this)) 1444 Keyword = Elab->getKeyword(); 1445 else if (const DependentNameType *DepName = dyn_cast<DependentNameType>(this)) 1446 Keyword = DepName->getKeyword(); 1447 else if (const DependentTemplateSpecializationType *DepTST = 1448 dyn_cast<DependentTemplateSpecializationType>(this)) 1449 Keyword = DepTST->getKeyword(); 1450 else 1451 return false; 1452 1453 return TypeWithKeyword::KeywordIsTagTypeKind(Keyword); 1454 } 1455 1456 const char *Type::getTypeClassName() const { 1457 switch (TypeBits.TC) { 1458 #define ABSTRACT_TYPE(Derived, Base) 1459 #define TYPE(Derived, Base) case Derived: return #Derived; 1460 #include "clang/AST/TypeNodes.def" 1461 } 1462 1463 llvm_unreachable("Invalid type class."); 1464 return 0; 1465 } 1466 1467 const char *BuiltinType::getName(const PrintingPolicy &Policy) const { 1468 switch (getKind()) { 1469 case Void: return "void"; 1470 case Bool: return Policy.Bool ? "bool" : "_Bool"; 1471 case Char_S: return "char"; 1472 case Char_U: return "char"; 1473 case SChar: return "signed char"; 1474 case Short: return "short"; 1475 case Int: return "int"; 1476 case Long: return "long"; 1477 case LongLong: return "long long"; 1478 case Int128: return "__int128_t"; 1479 case UChar: return "unsigned char"; 1480 case UShort: return "unsigned short"; 1481 case UInt: return "unsigned int"; 1482 case ULong: return "unsigned long"; 1483 case ULongLong: return "unsigned long long"; 1484 case UInt128: return "__uint128_t"; 1485 case Half: return "half"; 1486 case Float: return "float"; 1487 case Double: return "double"; 1488 case LongDouble: return "long double"; 1489 case WChar_S: 1490 case WChar_U: return "wchar_t"; 1491 case Char16: return "char16_t"; 1492 case Char32: return "char32_t"; 1493 case NullPtr: return "nullptr_t"; 1494 case Overload: return "<overloaded function type>"; 1495 case BoundMember: return "<bound member function type>"; 1496 case Dependent: return "<dependent type>"; 1497 case UnknownAny: return "<unknown type>"; 1498 case ARCUnbridgedCast: return "<ARC unbridged cast type>"; 1499 case ObjCId: return "id"; 1500 case ObjCClass: return "Class"; 1501 case ObjCSel: return "SEL"; 1502 } 1503 1504 llvm_unreachable("Invalid builtin type."); 1505 return 0; 1506 } 1507 1508 QualType QualType::getNonLValueExprType(ASTContext &Context) const { 1509 if (const ReferenceType *RefType = getTypePtr()->getAs<ReferenceType>()) 1510 return RefType->getPointeeType(); 1511 1512 // C++0x [basic.lval]: 1513 // Class prvalues can have cv-qualified types; non-class prvalues always 1514 // have cv-unqualified types. 1515 // 1516 // See also C99 6.3.2.1p2. 1517 if (!Context.getLangOptions().CPlusPlus || 1518 (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType())) 1519 return getUnqualifiedType(); 1520 1521 return *this; 1522 } 1523 1524 StringRef FunctionType::getNameForCallConv(CallingConv CC) { 1525 switch (CC) { 1526 case CC_Default: 1527 llvm_unreachable("no name for default cc"); 1528 return ""; 1529 1530 case CC_C: return "cdecl"; 1531 case CC_X86StdCall: return "stdcall"; 1532 case CC_X86FastCall: return "fastcall"; 1533 case CC_X86ThisCall: return "thiscall"; 1534 case CC_X86Pascal: return "pascal"; 1535 case CC_AAPCS: return "aapcs"; 1536 case CC_AAPCS_VFP: return "aapcs-vfp"; 1537 } 1538 1539 llvm_unreachable("Invalid calling convention."); 1540 return ""; 1541 } 1542 1543 FunctionProtoType::FunctionProtoType(QualType result, const QualType *args, 1544 unsigned numArgs, QualType canonical, 1545 const ExtProtoInfo &epi) 1546 : FunctionType(FunctionProto, result, epi.Variadic, epi.TypeQuals, 1547 epi.RefQualifier, canonical, 1548 result->isDependentType(), 1549 result->isInstantiationDependentType(), 1550 result->isVariablyModifiedType(), 1551 result->containsUnexpandedParameterPack(), 1552 epi.ExtInfo), 1553 NumArgs(numArgs), NumExceptions(epi.NumExceptions), 1554 ExceptionSpecType(epi.ExceptionSpecType), 1555 HasAnyConsumedArgs(epi.ConsumedArguments != 0) 1556 { 1557 // Fill in the trailing argument array. 1558 QualType *argSlot = reinterpret_cast<QualType*>(this+1); 1559 for (unsigned i = 0; i != numArgs; ++i) { 1560 if (args[i]->isDependentType()) 1561 setDependent(); 1562 else if (args[i]->isInstantiationDependentType()) 1563 setInstantiationDependent(); 1564 1565 if (args[i]->containsUnexpandedParameterPack()) 1566 setContainsUnexpandedParameterPack(); 1567 1568 argSlot[i] = args[i]; 1569 } 1570 1571 if (getExceptionSpecType() == EST_Dynamic) { 1572 // Fill in the exception array. 1573 QualType *exnSlot = argSlot + numArgs; 1574 for (unsigned i = 0, e = epi.NumExceptions; i != e; ++i) { 1575 if (epi.Exceptions[i]->isDependentType()) 1576 setDependent(); 1577 else if (epi.Exceptions[i]->isInstantiationDependentType()) 1578 setInstantiationDependent(); 1579 1580 if (epi.Exceptions[i]->containsUnexpandedParameterPack()) 1581 setContainsUnexpandedParameterPack(); 1582 1583 exnSlot[i] = epi.Exceptions[i]; 1584 } 1585 } else if (getExceptionSpecType() == EST_ComputedNoexcept) { 1586 // Store the noexcept expression and context. 1587 Expr **noexSlot = reinterpret_cast<Expr**>(argSlot + numArgs); 1588 *noexSlot = epi.NoexceptExpr; 1589 1590 if (epi.NoexceptExpr) { 1591 if (epi.NoexceptExpr->isValueDependent() 1592 || epi.NoexceptExpr->isTypeDependent()) 1593 setDependent(); 1594 else if (epi.NoexceptExpr->isInstantiationDependent()) 1595 setInstantiationDependent(); 1596 } 1597 } 1598 1599 if (epi.ConsumedArguments) { 1600 bool *consumedArgs = const_cast<bool*>(getConsumedArgsBuffer()); 1601 for (unsigned i = 0; i != numArgs; ++i) 1602 consumedArgs[i] = epi.ConsumedArguments[i]; 1603 } 1604 } 1605 1606 FunctionProtoType::NoexceptResult 1607 FunctionProtoType::getNoexceptSpec(ASTContext &ctx) const { 1608 ExceptionSpecificationType est = getExceptionSpecType(); 1609 if (est == EST_BasicNoexcept) 1610 return NR_Nothrow; 1611 1612 if (est != EST_ComputedNoexcept) 1613 return NR_NoNoexcept; 1614 1615 Expr *noexceptExpr = getNoexceptExpr(); 1616 if (!noexceptExpr) 1617 return NR_BadNoexcept; 1618 if (noexceptExpr->isValueDependent()) 1619 return NR_Dependent; 1620 1621 llvm::APSInt value; 1622 bool isICE = noexceptExpr->isIntegerConstantExpr(value, ctx, 0, 1623 /*evaluated*/false); 1624 (void)isICE; 1625 assert(isICE && "AST should not contain bad noexcept expressions."); 1626 1627 return value.getBoolValue() ? NR_Nothrow : NR_Throw; 1628 } 1629 1630 bool FunctionProtoType::isTemplateVariadic() const { 1631 for (unsigned ArgIdx = getNumArgs(); ArgIdx; --ArgIdx) 1632 if (isa<PackExpansionType>(getArgType(ArgIdx - 1))) 1633 return true; 1634 1635 return false; 1636 } 1637 1638 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 1639 const QualType *ArgTys, unsigned NumArgs, 1640 const ExtProtoInfo &epi, 1641 const ASTContext &Context) { 1642 1643 // We have to be careful not to get ambiguous profile encodings. 1644 // Note that valid type pointers are never ambiguous with anything else. 1645 // 1646 // The encoding grammar begins: 1647 // type type* bool int bool 1648 // If that final bool is true, then there is a section for the EH spec: 1649 // bool type* 1650 // This is followed by an optional "consumed argument" section of the 1651 // same length as the first type sequence: 1652 // bool* 1653 // Finally, we have the ext info: 1654 // int 1655 // 1656 // There is no ambiguity between the consumed arguments and an empty EH 1657 // spec because of the leading 'bool' which unambiguously indicates 1658 // whether the following bool is the EH spec or part of the arguments. 1659 1660 ID.AddPointer(Result.getAsOpaquePtr()); 1661 for (unsigned i = 0; i != NumArgs; ++i) 1662 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 1663 // This method is relatively performance sensitive, so as a performance 1664 // shortcut, use one AddInteger call instead of four for the next four 1665 // fields. 1666 assert(!(unsigned(epi.Variadic) & ~1) && 1667 !(unsigned(epi.TypeQuals) & ~255) && 1668 !(unsigned(epi.RefQualifier) & ~3) && 1669 !(unsigned(epi.ExceptionSpecType) & ~7) && 1670 "Values larger than expected."); 1671 ID.AddInteger(unsigned(epi.Variadic) + 1672 (epi.TypeQuals << 1) + 1673 (epi.RefQualifier << 9) + 1674 (epi.ExceptionSpecType << 11)); 1675 if (epi.ExceptionSpecType == EST_Dynamic) { 1676 for (unsigned i = 0; i != epi.NumExceptions; ++i) 1677 ID.AddPointer(epi.Exceptions[i].getAsOpaquePtr()); 1678 } else if (epi.ExceptionSpecType == EST_ComputedNoexcept && epi.NoexceptExpr){ 1679 epi.NoexceptExpr->Profile(ID, Context, false); 1680 } 1681 if (epi.ConsumedArguments) { 1682 for (unsigned i = 0; i != NumArgs; ++i) 1683 ID.AddBoolean(epi.ConsumedArguments[i]); 1684 } 1685 epi.ExtInfo.Profile(ID); 1686 } 1687 1688 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, 1689 const ASTContext &Ctx) { 1690 Profile(ID, getResultType(), arg_type_begin(), NumArgs, getExtProtoInfo(), 1691 Ctx); 1692 } 1693 1694 QualType TypedefType::desugar() const { 1695 return getDecl()->getUnderlyingType(); 1696 } 1697 1698 TypeOfExprType::TypeOfExprType(Expr *E, QualType can) 1699 : Type(TypeOfExpr, can, E->isTypeDependent(), 1700 E->isInstantiationDependent(), 1701 E->getType()->isVariablyModifiedType(), 1702 E->containsUnexpandedParameterPack()), 1703 TOExpr(E) { 1704 } 1705 1706 bool TypeOfExprType::isSugared() const { 1707 return !TOExpr->isTypeDependent(); 1708 } 1709 1710 QualType TypeOfExprType::desugar() const { 1711 if (isSugared()) 1712 return getUnderlyingExpr()->getType(); 1713 1714 return QualType(this, 0); 1715 } 1716 1717 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID, 1718 const ASTContext &Context, Expr *E) { 1719 E->Profile(ID, Context, true); 1720 } 1721 1722 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can) 1723 : Type(Decltype, can, E->isTypeDependent(), 1724 E->isInstantiationDependent(), 1725 E->getType()->isVariablyModifiedType(), 1726 E->containsUnexpandedParameterPack()), 1727 E(E), 1728 UnderlyingType(underlyingType) { 1729 } 1730 1731 bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); } 1732 1733 QualType DecltypeType::desugar() const { 1734 if (isSugared()) 1735 return getUnderlyingType(); 1736 1737 return QualType(this, 0); 1738 } 1739 1740 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E) 1741 : DecltypeType(E, Context.DependentTy), Context(Context) { } 1742 1743 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, 1744 const ASTContext &Context, Expr *E) { 1745 E->Profile(ID, Context, true); 1746 } 1747 1748 TagType::TagType(TypeClass TC, const TagDecl *D, QualType can) 1749 : Type(TC, can, D->isDependentType(), 1750 /*InstantiationDependent=*/D->isDependentType(), 1751 /*VariablyModified=*/false, 1752 /*ContainsUnexpandedParameterPack=*/false), 1753 decl(const_cast<TagDecl*>(D)) {} 1754 1755 static TagDecl *getInterestingTagDecl(TagDecl *decl) { 1756 for (TagDecl::redecl_iterator I = decl->redecls_begin(), 1757 E = decl->redecls_end(); 1758 I != E; ++I) { 1759 if (I->isCompleteDefinition() || I->isBeingDefined()) 1760 return *I; 1761 } 1762 // If there's no definition (not even in progress), return what we have. 1763 return decl; 1764 } 1765 1766 UnaryTransformType::UnaryTransformType(QualType BaseType, 1767 QualType UnderlyingType, 1768 UTTKind UKind, 1769 QualType CanonicalType) 1770 : Type(UnaryTransform, CanonicalType, UnderlyingType->isDependentType(), 1771 UnderlyingType->isInstantiationDependentType(), 1772 UnderlyingType->isVariablyModifiedType(), 1773 BaseType->containsUnexpandedParameterPack()) 1774 , BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) 1775 {} 1776 1777 TagDecl *TagType::getDecl() const { 1778 return getInterestingTagDecl(decl); 1779 } 1780 1781 bool TagType::isBeingDefined() const { 1782 return getDecl()->isBeingDefined(); 1783 } 1784 1785 CXXRecordDecl *InjectedClassNameType::getDecl() const { 1786 return cast<CXXRecordDecl>(getInterestingTagDecl(Decl)); 1787 } 1788 1789 bool RecordType::classof(const TagType *TT) { 1790 return isa<RecordDecl>(TT->getDecl()); 1791 } 1792 1793 bool EnumType::classof(const TagType *TT) { 1794 return isa<EnumDecl>(TT->getDecl()); 1795 } 1796 1797 IdentifierInfo *TemplateTypeParmType::getIdentifier() const { 1798 return isCanonicalUnqualified() ? 0 : getDecl()->getIdentifier(); 1799 } 1800 1801 SubstTemplateTypeParmPackType:: 1802 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param, 1803 QualType Canon, 1804 const TemplateArgument &ArgPack) 1805 : Type(SubstTemplateTypeParmPack, Canon, true, true, false, true), 1806 Replaced(Param), 1807 Arguments(ArgPack.pack_begin()), NumArguments(ArgPack.pack_size()) 1808 { 1809 } 1810 1811 TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const { 1812 return TemplateArgument(Arguments, NumArguments); 1813 } 1814 1815 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) { 1816 Profile(ID, getReplacedParameter(), getArgumentPack()); 1817 } 1818 1819 void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID, 1820 const TemplateTypeParmType *Replaced, 1821 const TemplateArgument &ArgPack) { 1822 ID.AddPointer(Replaced); 1823 ID.AddInteger(ArgPack.pack_size()); 1824 for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 1825 PEnd = ArgPack.pack_end(); 1826 P != PEnd; ++P) 1827 ID.AddPointer(P->getAsType().getAsOpaquePtr()); 1828 } 1829 1830 bool TemplateSpecializationType:: 1831 anyDependentTemplateArguments(const TemplateArgumentListInfo &Args, 1832 bool &InstantiationDependent) { 1833 return anyDependentTemplateArguments(Args.getArgumentArray(), Args.size(), 1834 InstantiationDependent); 1835 } 1836 1837 bool TemplateSpecializationType:: 1838 anyDependentTemplateArguments(const TemplateArgumentLoc *Args, unsigned N, 1839 bool &InstantiationDependent) { 1840 for (unsigned i = 0; i != N; ++i) { 1841 if (Args[i].getArgument().isDependent()) { 1842 InstantiationDependent = true; 1843 return true; 1844 } 1845 1846 if (Args[i].getArgument().isInstantiationDependent()) 1847 InstantiationDependent = true; 1848 } 1849 return false; 1850 } 1851 1852 bool TemplateSpecializationType:: 1853 anyDependentTemplateArguments(const TemplateArgument *Args, unsigned N, 1854 bool &InstantiationDependent) { 1855 for (unsigned i = 0; i != N; ++i) { 1856 if (Args[i].isDependent()) { 1857 InstantiationDependent = true; 1858 return true; 1859 } 1860 1861 if (Args[i].isInstantiationDependent()) 1862 InstantiationDependent = true; 1863 } 1864 return false; 1865 } 1866 1867 TemplateSpecializationType:: 1868 TemplateSpecializationType(TemplateName T, 1869 const TemplateArgument *Args, unsigned NumArgs, 1870 QualType Canon, QualType AliasedType) 1871 : Type(TemplateSpecialization, 1872 Canon.isNull()? QualType(this, 0) : Canon, 1873 Canon.isNull()? T.isDependent() : Canon->isDependentType(), 1874 Canon.isNull()? T.isDependent() 1875 : Canon->isInstantiationDependentType(), 1876 false, T.containsUnexpandedParameterPack()), 1877 Template(T), NumArgs(NumArgs) { 1878 assert(!T.getAsDependentTemplateName() && 1879 "Use DependentTemplateSpecializationType for dependent template-name"); 1880 assert((T.getKind() == TemplateName::Template || 1881 T.getKind() == TemplateName::SubstTemplateTemplateParm || 1882 T.getKind() == TemplateName::SubstTemplateTemplateParmPack) && 1883 "Unexpected template name for TemplateSpecializationType"); 1884 bool InstantiationDependent; 1885 (void)InstantiationDependent; 1886 assert((!Canon.isNull() || 1887 T.isDependent() || 1888 anyDependentTemplateArguments(Args, NumArgs, 1889 InstantiationDependent)) && 1890 "No canonical type for non-dependent class template specialization"); 1891 1892 TemplateArgument *TemplateArgs 1893 = reinterpret_cast<TemplateArgument *>(this + 1); 1894 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1895 // Update dependent and variably-modified bits. 1896 // If the canonical type exists and is non-dependent, the template 1897 // specialization type can be non-dependent even if one of the type 1898 // arguments is. Given: 1899 // template<typename T> using U = int; 1900 // U<T> is always non-dependent, irrespective of the type T. 1901 if (Canon.isNull() && Args[Arg].isDependent()) 1902 setDependent(); 1903 else if (Args[Arg].isInstantiationDependent()) 1904 setInstantiationDependent(); 1905 1906 if (Args[Arg].getKind() == TemplateArgument::Type && 1907 Args[Arg].getAsType()->isVariablyModifiedType()) 1908 setVariablyModified(); 1909 if (Args[Arg].containsUnexpandedParameterPack()) 1910 setContainsUnexpandedParameterPack(); 1911 1912 new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]); 1913 } 1914 1915 // Store the aliased type if this is a type alias template specialization. 1916 bool IsTypeAlias = !AliasedType.isNull(); 1917 assert(IsTypeAlias == isTypeAlias() && 1918 "allocated wrong size for type alias"); 1919 if (IsTypeAlias) { 1920 TemplateArgument *Begin = reinterpret_cast<TemplateArgument *>(this + 1); 1921 *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType; 1922 } 1923 } 1924 1925 void 1926 TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 1927 TemplateName T, 1928 const TemplateArgument *Args, 1929 unsigned NumArgs, 1930 const ASTContext &Context) { 1931 T.Profile(ID); 1932 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) 1933 Args[Idx].Profile(ID, Context); 1934 } 1935 1936 bool TemplateSpecializationType::isTypeAlias() const { 1937 TemplateDecl *D = Template.getAsTemplateDecl(); 1938 return D && isa<TypeAliasTemplateDecl>(D); 1939 } 1940 1941 QualType 1942 QualifierCollector::apply(const ASTContext &Context, QualType QT) const { 1943 if (!hasNonFastQualifiers()) 1944 return QT.withFastQualifiers(getFastQualifiers()); 1945 1946 return Context.getQualifiedType(QT, *this); 1947 } 1948 1949 QualType 1950 QualifierCollector::apply(const ASTContext &Context, const Type *T) const { 1951 if (!hasNonFastQualifiers()) 1952 return QualType(T, getFastQualifiers()); 1953 1954 return Context.getQualifiedType(T, *this); 1955 } 1956 1957 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID, 1958 QualType BaseType, 1959 ObjCProtocolDecl * const *Protocols, 1960 unsigned NumProtocols) { 1961 ID.AddPointer(BaseType.getAsOpaquePtr()); 1962 for (unsigned i = 0; i != NumProtocols; i++) 1963 ID.AddPointer(Protocols[i]); 1964 } 1965 1966 void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) { 1967 Profile(ID, getBaseType(), qual_begin(), getNumProtocols()); 1968 } 1969 1970 namespace { 1971 1972 /// \brief The cached properties of a type. 1973 class CachedProperties { 1974 char linkage; 1975 char visibility; 1976 bool local; 1977 1978 public: 1979 CachedProperties(Linkage linkage, Visibility visibility, bool local) 1980 : linkage(linkage), visibility(visibility), local(local) {} 1981 1982 Linkage getLinkage() const { return (Linkage) linkage; } 1983 Visibility getVisibility() const { return (Visibility) visibility; } 1984 bool hasLocalOrUnnamedType() const { return local; } 1985 1986 friend CachedProperties merge(CachedProperties L, CachedProperties R) { 1987 return CachedProperties(minLinkage(L.getLinkage(), R.getLinkage()), 1988 minVisibility(L.getVisibility(), R.getVisibility()), 1989 L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType()); 1990 } 1991 }; 1992 } 1993 1994 static CachedProperties computeCachedProperties(const Type *T); 1995 1996 namespace clang { 1997 /// The type-property cache. This is templated so as to be 1998 /// instantiated at an internal type to prevent unnecessary symbol 1999 /// leakage. 2000 template <class Private> class TypePropertyCache { 2001 public: 2002 static CachedProperties get(QualType T) { 2003 return get(T.getTypePtr()); 2004 } 2005 2006 static CachedProperties get(const Type *T) { 2007 ensure(T); 2008 return CachedProperties(T->TypeBits.getLinkage(), 2009 T->TypeBits.getVisibility(), 2010 T->TypeBits.hasLocalOrUnnamedType()); 2011 } 2012 2013 static void ensure(const Type *T) { 2014 // If the cache is valid, we're okay. 2015 if (T->TypeBits.isCacheValid()) return; 2016 2017 // If this type is non-canonical, ask its canonical type for the 2018 // relevant information. 2019 if (!T->isCanonicalUnqualified()) { 2020 const Type *CT = T->getCanonicalTypeInternal().getTypePtr(); 2021 ensure(CT); 2022 T->TypeBits.CacheValidAndVisibility = 2023 CT->TypeBits.CacheValidAndVisibility; 2024 T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage; 2025 T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed; 2026 return; 2027 } 2028 2029 // Compute the cached properties and then set the cache. 2030 CachedProperties Result = computeCachedProperties(T); 2031 T->TypeBits.CacheValidAndVisibility = Result.getVisibility() + 1U; 2032 assert(T->TypeBits.isCacheValid() && 2033 T->TypeBits.getVisibility() == Result.getVisibility()); 2034 T->TypeBits.CachedLinkage = Result.getLinkage(); 2035 T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType(); 2036 } 2037 }; 2038 } 2039 2040 // Instantiate the friend template at a private class. In a 2041 // reasonable implementation, these symbols will be internal. 2042 // It is terrible that this is the best way to accomplish this. 2043 namespace { class Private {}; } 2044 typedef TypePropertyCache<Private> Cache; 2045 2046 static CachedProperties computeCachedProperties(const Type *T) { 2047 switch (T->getTypeClass()) { 2048 #define TYPE(Class,Base) 2049 #define NON_CANONICAL_TYPE(Class,Base) case Type::Class: 2050 #include "clang/AST/TypeNodes.def" 2051 llvm_unreachable("didn't expect a non-canonical type here"); 2052 2053 #define TYPE(Class,Base) 2054 #define DEPENDENT_TYPE(Class,Base) case Type::Class: 2055 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class: 2056 #include "clang/AST/TypeNodes.def" 2057 // Treat instantiation-dependent types as external. 2058 assert(T->isInstantiationDependentType()); 2059 return CachedProperties(ExternalLinkage, DefaultVisibility, false); 2060 2061 case Type::Builtin: 2062 // C++ [basic.link]p8: 2063 // A type is said to have linkage if and only if: 2064 // - it is a fundamental type (3.9.1); or 2065 return CachedProperties(ExternalLinkage, DefaultVisibility, false); 2066 2067 case Type::Record: 2068 case Type::Enum: { 2069 const TagDecl *Tag = cast<TagType>(T)->getDecl(); 2070 2071 // C++ [basic.link]p8: 2072 // - it is a class or enumeration type that is named (or has a name 2073 // for linkage purposes (7.1.3)) and the name has linkage; or 2074 // - it is a specialization of a class template (14); or 2075 NamedDecl::LinkageInfo LV = Tag->getLinkageAndVisibility(); 2076 bool IsLocalOrUnnamed = 2077 Tag->getDeclContext()->isFunctionOrMethod() || 2078 (!Tag->getIdentifier() && !Tag->getTypedefNameForAnonDecl()); 2079 return CachedProperties(LV.linkage(), LV.visibility(), IsLocalOrUnnamed); 2080 } 2081 2082 // C++ [basic.link]p8: 2083 // - it is a compound type (3.9.2) other than a class or enumeration, 2084 // compounded exclusively from types that have linkage; or 2085 case Type::Complex: 2086 return Cache::get(cast<ComplexType>(T)->getElementType()); 2087 case Type::Pointer: 2088 return Cache::get(cast<PointerType>(T)->getPointeeType()); 2089 case Type::BlockPointer: 2090 return Cache::get(cast<BlockPointerType>(T)->getPointeeType()); 2091 case Type::LValueReference: 2092 case Type::RValueReference: 2093 return Cache::get(cast<ReferenceType>(T)->getPointeeType()); 2094 case Type::MemberPointer: { 2095 const MemberPointerType *MPT = cast<MemberPointerType>(T); 2096 return merge(Cache::get(MPT->getClass()), 2097 Cache::get(MPT->getPointeeType())); 2098 } 2099 case Type::ConstantArray: 2100 case Type::IncompleteArray: 2101 case Type::VariableArray: 2102 return Cache::get(cast<ArrayType>(T)->getElementType()); 2103 case Type::Vector: 2104 case Type::ExtVector: 2105 return Cache::get(cast<VectorType>(T)->getElementType()); 2106 case Type::FunctionNoProto: 2107 return Cache::get(cast<FunctionType>(T)->getResultType()); 2108 case Type::FunctionProto: { 2109 const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 2110 CachedProperties result = Cache::get(FPT->getResultType()); 2111 for (FunctionProtoType::arg_type_iterator ai = FPT->arg_type_begin(), 2112 ae = FPT->arg_type_end(); ai != ae; ++ai) 2113 result = merge(result, Cache::get(*ai)); 2114 return result; 2115 } 2116 case Type::ObjCInterface: { 2117 NamedDecl::LinkageInfo LV = 2118 cast<ObjCInterfaceType>(T)->getDecl()->getLinkageAndVisibility(); 2119 return CachedProperties(LV.linkage(), LV.visibility(), false); 2120 } 2121 case Type::ObjCObject: 2122 return Cache::get(cast<ObjCObjectType>(T)->getBaseType()); 2123 case Type::ObjCObjectPointer: 2124 return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType()); 2125 case Type::Atomic: 2126 return Cache::get(cast<AtomicType>(T)->getValueType()); 2127 } 2128 2129 llvm_unreachable("unhandled type class"); 2130 2131 // C++ [basic.link]p8: 2132 // Names not covered by these rules have no linkage. 2133 return CachedProperties(NoLinkage, DefaultVisibility, false); 2134 } 2135 2136 /// \brief Determine the linkage of this type. 2137 Linkage Type::getLinkage() const { 2138 Cache::ensure(this); 2139 return TypeBits.getLinkage(); 2140 } 2141 2142 /// \brief Determine the linkage of this type. 2143 Visibility Type::getVisibility() const { 2144 Cache::ensure(this); 2145 return TypeBits.getVisibility(); 2146 } 2147 2148 bool Type::hasUnnamedOrLocalType() const { 2149 Cache::ensure(this); 2150 return TypeBits.hasLocalOrUnnamedType(); 2151 } 2152 2153 std::pair<Linkage,Visibility> Type::getLinkageAndVisibility() const { 2154 Cache::ensure(this); 2155 return std::make_pair(TypeBits.getLinkage(), TypeBits.getVisibility()); 2156 } 2157 2158 void Type::ClearLinkageCache() { 2159 TypeBits.CacheValidAndVisibility = 0; 2160 if (QualType(this, 0) != CanonicalType) 2161 CanonicalType->TypeBits.CacheValidAndVisibility = 0; 2162 } 2163 2164 Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const { 2165 if (isObjCARCImplicitlyUnretainedType()) 2166 return Qualifiers::OCL_ExplicitNone; 2167 return Qualifiers::OCL_Strong; 2168 } 2169 2170 bool Type::isObjCARCImplicitlyUnretainedType() const { 2171 assert(isObjCLifetimeType() && 2172 "cannot query implicit lifetime for non-inferrable type"); 2173 2174 const Type *canon = getCanonicalTypeInternal().getTypePtr(); 2175 2176 // Walk down to the base type. We don't care about qualifiers for this. 2177 while (const ArrayType *array = dyn_cast<ArrayType>(canon)) 2178 canon = array->getElementType().getTypePtr(); 2179 2180 if (const ObjCObjectPointerType *opt 2181 = dyn_cast<ObjCObjectPointerType>(canon)) { 2182 // Class and Class<Protocol> don't require retension. 2183 if (opt->getObjectType()->isObjCClass()) 2184 return true; 2185 } 2186 2187 return false; 2188 } 2189 2190 bool Type::isObjCNSObjectType() const { 2191 if (const TypedefType *typedefType = dyn_cast<TypedefType>(this)) 2192 return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>(); 2193 return false; 2194 } 2195 bool Type::isObjCRetainableType() const { 2196 return isObjCObjectPointerType() || 2197 isBlockPointerType() || 2198 isObjCNSObjectType(); 2199 } 2200 bool Type::isObjCIndirectLifetimeType() const { 2201 if (isObjCLifetimeType()) 2202 return true; 2203 if (const PointerType *OPT = getAs<PointerType>()) 2204 return OPT->getPointeeType()->isObjCIndirectLifetimeType(); 2205 if (const ReferenceType *Ref = getAs<ReferenceType>()) 2206 return Ref->getPointeeType()->isObjCIndirectLifetimeType(); 2207 if (const MemberPointerType *MemPtr = getAs<MemberPointerType>()) 2208 return MemPtr->getPointeeType()->isObjCIndirectLifetimeType(); 2209 return false; 2210 } 2211 2212 /// Returns true if objects of this type have lifetime semantics under 2213 /// ARC. 2214 bool Type::isObjCLifetimeType() const { 2215 const Type *type = this; 2216 while (const ArrayType *array = type->getAsArrayTypeUnsafe()) 2217 type = array->getElementType().getTypePtr(); 2218 return type->isObjCRetainableType(); 2219 } 2220 2221 /// \brief Determine whether the given type T is a "bridgable" Objective-C type, 2222 /// which is either an Objective-C object pointer type or an 2223 bool Type::isObjCARCBridgableType() const { 2224 return isObjCObjectPointerType() || isBlockPointerType(); 2225 } 2226 2227 /// \brief Determine whether the given type T is a "bridgeable" C type. 2228 bool Type::isCARCBridgableType() const { 2229 const PointerType *Pointer = getAs<PointerType>(); 2230 if (!Pointer) 2231 return false; 2232 2233 QualType Pointee = Pointer->getPointeeType(); 2234 return Pointee->isVoidType() || Pointee->isRecordType(); 2235 } 2236 2237 bool Type::hasSizedVLAType() const { 2238 if (!isVariablyModifiedType()) return false; 2239 2240 if (const PointerType *ptr = getAs<PointerType>()) 2241 return ptr->getPointeeType()->hasSizedVLAType(); 2242 if (const ReferenceType *ref = getAs<ReferenceType>()) 2243 return ref->getPointeeType()->hasSizedVLAType(); 2244 if (const ArrayType *arr = getAsArrayTypeUnsafe()) { 2245 if (isa<VariableArrayType>(arr) && 2246 cast<VariableArrayType>(arr)->getSizeExpr()) 2247 return true; 2248 2249 return arr->getElementType()->hasSizedVLAType(); 2250 } 2251 2252 return false; 2253 } 2254 2255 QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) { 2256 switch (type.getObjCLifetime()) { 2257 case Qualifiers::OCL_None: 2258 case Qualifiers::OCL_ExplicitNone: 2259 case Qualifiers::OCL_Autoreleasing: 2260 break; 2261 2262 case Qualifiers::OCL_Strong: 2263 return DK_objc_strong_lifetime; 2264 case Qualifiers::OCL_Weak: 2265 return DK_objc_weak_lifetime; 2266 } 2267 2268 /// Currently, the only destruction kind we recognize is C++ objects 2269 /// with non-trivial destructors. 2270 const CXXRecordDecl *record = 2271 type->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 2272 if (record && record->hasDefinition() && !record->hasTrivialDestructor()) 2273 return DK_cxx_destructor; 2274 2275 return DK_none; 2276 } 2277 2278 bool QualType::hasTrivialAssignment(ASTContext &Context, bool Copying) const { 2279 switch (getObjCLifetime()) { 2280 case Qualifiers::OCL_None: 2281 break; 2282 2283 case Qualifiers::OCL_ExplicitNone: 2284 return true; 2285 2286 case Qualifiers::OCL_Autoreleasing: 2287 case Qualifiers::OCL_Strong: 2288 case Qualifiers::OCL_Weak: 2289 return !Context.getLangOptions().ObjCAutoRefCount; 2290 } 2291 2292 if (const CXXRecordDecl *Record 2293 = getTypePtr()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) 2294 return Copying ? Record->hasTrivialCopyAssignment() : 2295 Record->hasTrivialMoveAssignment(); 2296 2297 return true; 2298 } 2299