1//===- Type.cpp - Type representation and manipulation --------------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements type-related functionality. 10// 11//===----------------------------------------------------------------------===// 12 13#include "clang/AST/Type.h" 14#include "Linkage.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Attr.h" 17#include "clang/AST/CharUnits.h" 18#include "clang/AST/Decl.h" 19#include "clang/AST/DeclBase.h" 20#include "clang/AST/DeclCXX.h" 21#include "clang/AST/DeclFriend.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/DeclTemplate.h" 24#include "clang/AST/DependenceFlags.h" 25#include "clang/AST/Expr.h" 26#include "clang/AST/NestedNameSpecifier.h" 27#include "clang/AST/NonTrivialTypeVisitor.h" 28#include "clang/AST/PrettyPrinter.h" 29#include "clang/AST/TemplateBase.h" 30#include "clang/AST/TemplateName.h" 31#include "clang/AST/TypeVisitor.h" 32#include "clang/Basic/AddressSpaces.h" 33#include "clang/Basic/ExceptionSpecificationType.h" 34#include "clang/Basic/IdentifierTable.h" 35#include "clang/Basic/LLVM.h" 36#include "clang/Basic/LangOptions.h" 37#include "clang/Basic/Linkage.h" 38#include "clang/Basic/Specifiers.h" 39#include "clang/Basic/TargetCXXABI.h" 40#include "clang/Basic/TargetInfo.h" 41#include "clang/Basic/Visibility.h" 42#include "llvm/ADT/APInt.h" 43#include "llvm/ADT/APSInt.h" 44#include "llvm/ADT/ArrayRef.h" 45#include "llvm/ADT/FoldingSet.h" 46#include "llvm/ADT/SmallVector.h" 47#include "llvm/Support/Casting.h" 48#include "llvm/Support/ErrorHandling.h" 49#include "llvm/Support/MathExtras.h" 50#include "llvm/TargetParser/RISCVTargetParser.h" 51#include <algorithm> 52#include <cassert> 53#include <cstdint> 54#include <cstring> 55#include <optional> 56#include <type_traits> 57 58using namespace clang; 59 60bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const { 61 return (*this != Other) && 62 // CVR qualifiers superset 63 (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) && 64 // ObjC GC qualifiers superset 65 ((getObjCGCAttr() == Other.getObjCGCAttr()) || 66 (hasObjCGCAttr() && !Other.hasObjCGCAttr())) && 67 // Address space superset. 68 ((getAddressSpace() == Other.getAddressSpace()) || 69 (hasAddressSpace()&& !Other.hasAddressSpace())) && 70 // Lifetime qualifier superset. 71 ((getObjCLifetime() == Other.getObjCLifetime()) || 72 (hasObjCLifetime() && !Other.hasObjCLifetime())); 73} 74 75const IdentifierInfo* QualType::getBaseTypeIdentifier() const { 76 const Type* ty = getTypePtr(); 77 NamedDecl *ND = nullptr; 78 if (ty->isPointerType() || ty->isReferenceType()) 79 return ty->getPointeeType().getBaseTypeIdentifier(); 80 else if (ty->isRecordType()) 81 ND = ty->castAs<RecordType>()->getDecl(); 82 else if (ty->isEnumeralType()) 83 ND = ty->castAs<EnumType>()->getDecl(); 84 else if (ty->getTypeClass() == Type::Typedef) 85 ND = ty->castAs<TypedefType>()->getDecl(); 86 else if (ty->isArrayType()) 87 return ty->castAsArrayTypeUnsafe()-> 88 getElementType().getBaseTypeIdentifier(); 89 90 if (ND) 91 return ND->getIdentifier(); 92 return nullptr; 93} 94 95bool QualType::mayBeDynamicClass() const { 96 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl(); 97 return ClassDecl && ClassDecl->mayBeDynamicClass(); 98} 99 100bool QualType::mayBeNotDynamicClass() const { 101 const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl(); 102 return !ClassDecl || ClassDecl->mayBeNonDynamicClass(); 103} 104 105bool QualType::isConstant(QualType T, const ASTContext &Ctx) { 106 if (T.isConstQualified()) 107 return true; 108 109 if (const ArrayType *AT = Ctx.getAsArrayType(T)) 110 return AT->getElementType().isConstant(Ctx); 111 112 return T.getAddressSpace() == LangAS::opencl_constant; 113} 114 115std::optional<QualType::NonConstantStorageReason> 116QualType::isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, 117 bool ExcludeDtor) { 118 if (!isConstant(Ctx) && !(*this)->isReferenceType()) 119 return NonConstantStorageReason::NonConstNonReferenceType; 120 if (!Ctx.getLangOpts().CPlusPlus) 121 return std::nullopt; 122 if (const CXXRecordDecl *Record = 123 Ctx.getBaseElementType(*this)->getAsCXXRecordDecl()) { 124 if (!ExcludeCtor) 125 return NonConstantStorageReason::NonTrivialCtor; 126 if (Record->hasMutableFields()) 127 return NonConstantStorageReason::MutableField; 128 if (!Record->hasTrivialDestructor() && !ExcludeDtor) 129 return NonConstantStorageReason::NonTrivialDtor; 130 } 131 return std::nullopt; 132} 133 134// C++ [temp.dep.type]p1: 135// A type is dependent if it is... 136// - an array type constructed from any dependent type or whose 137// size is specified by a constant expression that is 138// value-dependent, 139ArrayType::ArrayType(TypeClass tc, QualType et, QualType can, 140 ArraySizeModifier sm, unsigned tq, const Expr *sz) 141 // Note, we need to check for DependentSizedArrayType explicitly here 142 // because we use a DependentSizedArrayType with no size expression as the 143 // type of a dependent array of unknown bound with a dependent braced 144 // initializer: 145 // 146 // template<int ...N> int arr[] = {N...}; 147 : Type(tc, can, 148 et->getDependence() | 149 (sz ? toTypeDependence( 150 turnValueToTypeDependence(sz->getDependence())) 151 : TypeDependence::None) | 152 (tc == VariableArray ? TypeDependence::VariablyModified 153 : TypeDependence::None) | 154 (tc == DependentSizedArray 155 ? TypeDependence::DependentInstantiation 156 : TypeDependence::None)), 157 ElementType(et) { 158 ArrayTypeBits.IndexTypeQuals = tq; 159 ArrayTypeBits.SizeModifier = llvm::to_underlying(sm); 160} 161 162unsigned ConstantArrayType::getNumAddressingBits(const ASTContext &Context, 163 QualType ElementType, 164 const llvm::APInt &NumElements) { 165 uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity(); 166 167 // Fast path the common cases so we can avoid the conservative computation 168 // below, which in common cases allocates "large" APSInt values, which are 169 // slow. 170 171 // If the element size is a power of 2, we can directly compute the additional 172 // number of addressing bits beyond those required for the element count. 173 if (llvm::isPowerOf2_64(ElementSize)) { 174 return NumElements.getActiveBits() + llvm::Log2_64(ElementSize); 175 } 176 177 // If both the element count and element size fit in 32-bits, we can do the 178 // computation directly in 64-bits. 179 if ((ElementSize >> 32) == 0 && NumElements.getBitWidth() <= 64 && 180 (NumElements.getZExtValue() >> 32) == 0) { 181 uint64_t TotalSize = NumElements.getZExtValue() * ElementSize; 182 return llvm::bit_width(TotalSize); 183 } 184 185 // Otherwise, use APSInt to handle arbitrary sized values. 186 llvm::APSInt SizeExtended(NumElements, true); 187 unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType()); 188 SizeExtended = SizeExtended.extend(std::max(SizeTypeBits, 189 SizeExtended.getBitWidth()) * 2); 190 191 llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize)); 192 TotalSize *= SizeExtended; 193 194 return TotalSize.getActiveBits(); 195} 196 197unsigned 198ConstantArrayType::getNumAddressingBits(const ASTContext &Context) const { 199 return getNumAddressingBits(Context, getElementType(), getSize()); 200} 201 202unsigned ConstantArrayType::getMaxSizeBits(const ASTContext &Context) { 203 unsigned Bits = Context.getTypeSize(Context.getSizeType()); 204 205 // Limit the number of bits in size_t so that maximal bit size fits 64 bit 206 // integer (see PR8256). We can do this as currently there is no hardware 207 // that supports full 64-bit virtual space. 208 if (Bits > 61) 209 Bits = 61; 210 211 return Bits; 212} 213 214void ConstantArrayType::Profile(llvm::FoldingSetNodeID &ID, 215 const ASTContext &Context, QualType ET, 216 const llvm::APInt &ArraySize, 217 const Expr *SizeExpr, ArraySizeModifier SizeMod, 218 unsigned TypeQuals) { 219 ID.AddPointer(ET.getAsOpaquePtr()); 220 ID.AddInteger(ArraySize.getZExtValue()); 221 ID.AddInteger(llvm::to_underlying(SizeMod)); 222 ID.AddInteger(TypeQuals); 223 ID.AddBoolean(SizeExpr != nullptr); 224 if (SizeExpr) 225 SizeExpr->Profile(ID, Context, true); 226} 227 228DependentSizedArrayType::DependentSizedArrayType(QualType et, QualType can, 229 Expr *e, ArraySizeModifier sm, 230 unsigned tq, 231 SourceRange brackets) 232 : ArrayType(DependentSizedArray, et, can, sm, tq, e), SizeExpr((Stmt *)e), 233 Brackets(brackets) {} 234 235void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID, 236 const ASTContext &Context, 237 QualType ET, 238 ArraySizeModifier SizeMod, 239 unsigned TypeQuals, 240 Expr *E) { 241 ID.AddPointer(ET.getAsOpaquePtr()); 242 ID.AddInteger(llvm::to_underlying(SizeMod)); 243 ID.AddInteger(TypeQuals); 244 E->Profile(ID, Context, true); 245} 246 247DependentVectorType::DependentVectorType(QualType ElementType, 248 QualType CanonType, Expr *SizeExpr, 249 SourceLocation Loc, VectorKind VecKind) 250 : Type(DependentVector, CanonType, 251 TypeDependence::DependentInstantiation | 252 ElementType->getDependence() | 253 (SizeExpr ? toTypeDependence(SizeExpr->getDependence()) 254 : TypeDependence::None)), 255 ElementType(ElementType), SizeExpr(SizeExpr), Loc(Loc) { 256 VectorTypeBits.VecKind = llvm::to_underlying(VecKind); 257} 258 259void DependentVectorType::Profile(llvm::FoldingSetNodeID &ID, 260 const ASTContext &Context, 261 QualType ElementType, const Expr *SizeExpr, 262 VectorKind VecKind) { 263 ID.AddPointer(ElementType.getAsOpaquePtr()); 264 ID.AddInteger(llvm::to_underlying(VecKind)); 265 SizeExpr->Profile(ID, Context, true); 266} 267 268DependentSizedExtVectorType::DependentSizedExtVectorType(QualType ElementType, 269 QualType can, 270 Expr *SizeExpr, 271 SourceLocation loc) 272 : Type(DependentSizedExtVector, can, 273 TypeDependence::DependentInstantiation | 274 ElementType->getDependence() | 275 (SizeExpr ? toTypeDependence(SizeExpr->getDependence()) 276 : TypeDependence::None)), 277 SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {} 278 279void 280DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID, 281 const ASTContext &Context, 282 QualType ElementType, Expr *SizeExpr) { 283 ID.AddPointer(ElementType.getAsOpaquePtr()); 284 SizeExpr->Profile(ID, Context, true); 285} 286 287DependentAddressSpaceType::DependentAddressSpaceType(QualType PointeeType, 288 QualType can, 289 Expr *AddrSpaceExpr, 290 SourceLocation loc) 291 : Type(DependentAddressSpace, can, 292 TypeDependence::DependentInstantiation | 293 PointeeType->getDependence() | 294 (AddrSpaceExpr ? toTypeDependence(AddrSpaceExpr->getDependence()) 295 : TypeDependence::None)), 296 AddrSpaceExpr(AddrSpaceExpr), PointeeType(PointeeType), loc(loc) {} 297 298void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID, 299 const ASTContext &Context, 300 QualType PointeeType, 301 Expr *AddrSpaceExpr) { 302 ID.AddPointer(PointeeType.getAsOpaquePtr()); 303 AddrSpaceExpr->Profile(ID, Context, true); 304} 305 306MatrixType::MatrixType(TypeClass tc, QualType matrixType, QualType canonType, 307 const Expr *RowExpr, const Expr *ColumnExpr) 308 : Type(tc, canonType, 309 (RowExpr ? (matrixType->getDependence() | TypeDependence::Dependent | 310 TypeDependence::Instantiation | 311 (matrixType->isVariablyModifiedType() 312 ? TypeDependence::VariablyModified 313 : TypeDependence::None) | 314 (matrixType->containsUnexpandedParameterPack() || 315 (RowExpr && 316 RowExpr->containsUnexpandedParameterPack()) || 317 (ColumnExpr && 318 ColumnExpr->containsUnexpandedParameterPack()) 319 ? TypeDependence::UnexpandedPack 320 : TypeDependence::None)) 321 : matrixType->getDependence())), 322 ElementType(matrixType) {} 323 324ConstantMatrixType::ConstantMatrixType(QualType matrixType, unsigned nRows, 325 unsigned nColumns, QualType canonType) 326 : ConstantMatrixType(ConstantMatrix, matrixType, nRows, nColumns, 327 canonType) {} 328 329ConstantMatrixType::ConstantMatrixType(TypeClass tc, QualType matrixType, 330 unsigned nRows, unsigned nColumns, 331 QualType canonType) 332 : MatrixType(tc, matrixType, canonType), NumRows(nRows), 333 NumColumns(nColumns) {} 334 335DependentSizedMatrixType::DependentSizedMatrixType(QualType ElementType, 336 QualType CanonicalType, 337 Expr *RowExpr, 338 Expr *ColumnExpr, 339 SourceLocation loc) 340 : MatrixType(DependentSizedMatrix, ElementType, CanonicalType, RowExpr, 341 ColumnExpr), 342 RowExpr(RowExpr), ColumnExpr(ColumnExpr), loc(loc) {} 343 344void DependentSizedMatrixType::Profile(llvm::FoldingSetNodeID &ID, 345 const ASTContext &CTX, 346 QualType ElementType, Expr *RowExpr, 347 Expr *ColumnExpr) { 348 ID.AddPointer(ElementType.getAsOpaquePtr()); 349 RowExpr->Profile(ID, CTX, true); 350 ColumnExpr->Profile(ID, CTX, true); 351} 352 353VectorType::VectorType(QualType vecType, unsigned nElements, QualType canonType, 354 VectorKind vecKind) 355 : VectorType(Vector, vecType, nElements, canonType, vecKind) {} 356 357VectorType::VectorType(TypeClass tc, QualType vecType, unsigned nElements, 358 QualType canonType, VectorKind vecKind) 359 : Type(tc, canonType, vecType->getDependence()), ElementType(vecType) { 360 VectorTypeBits.VecKind = llvm::to_underlying(vecKind); 361 VectorTypeBits.NumElements = nElements; 362} 363 364BitIntType::BitIntType(bool IsUnsigned, unsigned NumBits) 365 : Type(BitInt, QualType{}, TypeDependence::None), IsUnsigned(IsUnsigned), 366 NumBits(NumBits) {} 367 368DependentBitIntType::DependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr) 369 : Type(DependentBitInt, QualType{}, 370 toTypeDependence(NumBitsExpr->getDependence())), 371 ExprAndUnsigned(NumBitsExpr, IsUnsigned) {} 372 373bool DependentBitIntType::isUnsigned() const { 374 return ExprAndUnsigned.getInt(); 375} 376 377clang::Expr *DependentBitIntType::getNumBitsExpr() const { 378 return ExprAndUnsigned.getPointer(); 379} 380 381void DependentBitIntType::Profile(llvm::FoldingSetNodeID &ID, 382 const ASTContext &Context, bool IsUnsigned, 383 Expr *NumBitsExpr) { 384 ID.AddBoolean(IsUnsigned); 385 NumBitsExpr->Profile(ID, Context, true); 386} 387 388/// getArrayElementTypeNoTypeQual - If this is an array type, return the 389/// element type of the array, potentially with type qualifiers missing. 390/// This method should never be used when type qualifiers are meaningful. 391const Type *Type::getArrayElementTypeNoTypeQual() const { 392 // If this is directly an array type, return it. 393 if (const auto *ATy = dyn_cast<ArrayType>(this)) 394 return ATy->getElementType().getTypePtr(); 395 396 // If the canonical form of this type isn't the right kind, reject it. 397 if (!isa<ArrayType>(CanonicalType)) 398 return nullptr; 399 400 // If this is a typedef for an array type, strip the typedef off without 401 // losing all typedef information. 402 return cast<ArrayType>(getUnqualifiedDesugaredType()) 403 ->getElementType().getTypePtr(); 404} 405 406/// getDesugaredType - Return the specified type with any "sugar" removed from 407/// the type. This takes off typedefs, typeof's etc. If the outer level of 408/// the type is already concrete, it returns it unmodified. This is similar 409/// to getting the canonical type, but it doesn't remove *all* typedefs. For 410/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is 411/// concrete. 412QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) { 413 SplitQualType split = getSplitDesugaredType(T); 414 return Context.getQualifiedType(split.Ty, split.Quals); 415} 416 417QualType QualType::getSingleStepDesugaredTypeImpl(QualType type, 418 const ASTContext &Context) { 419 SplitQualType split = type.split(); 420 QualType desugar = split.Ty->getLocallyUnqualifiedSingleStepDesugaredType(); 421 return Context.getQualifiedType(desugar, split.Quals); 422} 423 424// Check that no type class is polymorphic. LLVM style RTTI should be used 425// instead. If absolutely needed an exception can still be added here by 426// defining the appropriate macro (but please don't do this). 427#define TYPE(CLASS, BASE) \ 428 static_assert(!std::is_polymorphic<CLASS##Type>::value, \ 429 #CLASS "Type should not be polymorphic!"); 430#include "clang/AST/TypeNodes.inc" 431 432// Check that no type class has a non-trival destructor. Types are 433// allocated with the BumpPtrAllocator from ASTContext and therefore 434// their destructor is not executed. 435// 436// FIXME: ConstantArrayType is not trivially destructible because of its 437// APInt member. It should be replaced in favor of ASTContext allocation. 438#define TYPE(CLASS, BASE) \ 439 static_assert(std::is_trivially_destructible<CLASS##Type>::value || \ 440 std::is_same<CLASS##Type, ConstantArrayType>::value, \ 441 #CLASS "Type should be trivially destructible!"); 442#include "clang/AST/TypeNodes.inc" 443 444QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const { 445 switch (getTypeClass()) { 446#define ABSTRACT_TYPE(Class, Parent) 447#define TYPE(Class, Parent) \ 448 case Type::Class: { \ 449 const auto *ty = cast<Class##Type>(this); \ 450 if (!ty->isSugared()) return QualType(ty, 0); \ 451 return ty->desugar(); \ 452 } 453#include "clang/AST/TypeNodes.inc" 454 } 455 llvm_unreachable("bad type kind!"); 456} 457 458SplitQualType QualType::getSplitDesugaredType(QualType T) { 459 QualifierCollector Qs; 460 461 QualType Cur = T; 462 while (true) { 463 const Type *CurTy = Qs.strip(Cur); 464 switch (CurTy->getTypeClass()) { 465#define ABSTRACT_TYPE(Class, Parent) 466#define TYPE(Class, Parent) \ 467 case Type::Class: { \ 468 const auto *Ty = cast<Class##Type>(CurTy); \ 469 if (!Ty->isSugared()) \ 470 return SplitQualType(Ty, Qs); \ 471 Cur = Ty->desugar(); \ 472 break; \ 473 } 474#include "clang/AST/TypeNodes.inc" 475 } 476 } 477} 478 479SplitQualType QualType::getSplitUnqualifiedTypeImpl(QualType type) { 480 SplitQualType split = type.split(); 481 482 // All the qualifiers we've seen so far. 483 Qualifiers quals = split.Quals; 484 485 // The last type node we saw with any nodes inside it. 486 const Type *lastTypeWithQuals = split.Ty; 487 488 while (true) { 489 QualType next; 490 491 // Do a single-step desugar, aborting the loop if the type isn't 492 // sugared. 493 switch (split.Ty->getTypeClass()) { 494#define ABSTRACT_TYPE(Class, Parent) 495#define TYPE(Class, Parent) \ 496 case Type::Class: { \ 497 const auto *ty = cast<Class##Type>(split.Ty); \ 498 if (!ty->isSugared()) goto done; \ 499 next = ty->desugar(); \ 500 break; \ 501 } 502#include "clang/AST/TypeNodes.inc" 503 } 504 505 // Otherwise, split the underlying type. If that yields qualifiers, 506 // update the information. 507 split = next.split(); 508 if (!split.Quals.empty()) { 509 lastTypeWithQuals = split.Ty; 510 quals.addConsistentQualifiers(split.Quals); 511 } 512 } 513 514 done: 515 return SplitQualType(lastTypeWithQuals, quals); 516} 517 518QualType QualType::IgnoreParens(QualType T) { 519 // FIXME: this seems inherently un-qualifiers-safe. 520 while (const auto *PT = T->getAs<ParenType>()) 521 T = PT->getInnerType(); 522 return T; 523} 524 525/// This will check for a T (which should be a Type which can act as 526/// sugar, such as a TypedefType) by removing any existing sugar until it 527/// reaches a T or a non-sugared type. 528template<typename T> static const T *getAsSugar(const Type *Cur) { 529 while (true) { 530 if (const auto *Sugar = dyn_cast<T>(Cur)) 531 return Sugar; 532 switch (Cur->getTypeClass()) { 533#define ABSTRACT_TYPE(Class, Parent) 534#define TYPE(Class, Parent) \ 535 case Type::Class: { \ 536 const auto *Ty = cast<Class##Type>(Cur); \ 537 if (!Ty->isSugared()) return 0; \ 538 Cur = Ty->desugar().getTypePtr(); \ 539 break; \ 540 } 541#include "clang/AST/TypeNodes.inc" 542 } 543 } 544} 545 546template <> const TypedefType *Type::getAs() const { 547 return getAsSugar<TypedefType>(this); 548} 549 550template <> const UsingType *Type::getAs() const { 551 return getAsSugar<UsingType>(this); 552} 553 554template <> const TemplateSpecializationType *Type::getAs() const { 555 return getAsSugar<TemplateSpecializationType>(this); 556} 557 558template <> const AttributedType *Type::getAs() const { 559 return getAsSugar<AttributedType>(this); 560} 561 562/// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic 563/// sugar off the given type. This should produce an object of the 564/// same dynamic type as the canonical type. 565const Type *Type::getUnqualifiedDesugaredType() const { 566 const Type *Cur = this; 567 568 while (true) { 569 switch (Cur->getTypeClass()) { 570#define ABSTRACT_TYPE(Class, Parent) 571#define TYPE(Class, Parent) \ 572 case Class: { \ 573 const auto *Ty = cast<Class##Type>(Cur); \ 574 if (!Ty->isSugared()) return Cur; \ 575 Cur = Ty->desugar().getTypePtr(); \ 576 break; \ 577 } 578#include "clang/AST/TypeNodes.inc" 579 } 580 } 581} 582 583bool Type::isClassType() const { 584 if (const auto *RT = getAs<RecordType>()) 585 return RT->getDecl()->isClass(); 586 return false; 587} 588 589bool Type::isStructureType() const { 590 if (const auto *RT = getAs<RecordType>()) 591 return RT->getDecl()->isStruct(); 592 return false; 593} 594 595bool Type::isObjCBoxableRecordType() const { 596 if (const auto *RT = getAs<RecordType>()) 597 return RT->getDecl()->hasAttr<ObjCBoxableAttr>(); 598 return false; 599} 600 601bool Type::isInterfaceType() const { 602 if (const auto *RT = getAs<RecordType>()) 603 return RT->getDecl()->isInterface(); 604 return false; 605} 606 607bool Type::isStructureOrClassType() const { 608 if (const auto *RT = getAs<RecordType>()) { 609 RecordDecl *RD = RT->getDecl(); 610 return RD->isStruct() || RD->isClass() || RD->isInterface(); 611 } 612 return false; 613} 614 615bool Type::isVoidPointerType() const { 616 if (const auto *PT = getAs<PointerType>()) 617 return PT->getPointeeType()->isVoidType(); 618 return false; 619} 620 621bool Type::isUnionType() const { 622 if (const auto *RT = getAs<RecordType>()) 623 return RT->getDecl()->isUnion(); 624 return false; 625} 626 627bool Type::isComplexType() const { 628 if (const auto *CT = dyn_cast<ComplexType>(CanonicalType)) 629 return CT->getElementType()->isFloatingType(); 630 return false; 631} 632 633bool Type::isComplexIntegerType() const { 634 // Check for GCC complex integer extension. 635 return getAsComplexIntegerType(); 636} 637 638bool Type::isScopedEnumeralType() const { 639 if (const auto *ET = getAs<EnumType>()) 640 return ET->getDecl()->isScoped(); 641 return false; 642} 643 644const ComplexType *Type::getAsComplexIntegerType() const { 645 if (const auto *Complex = getAs<ComplexType>()) 646 if (Complex->getElementType()->isIntegerType()) 647 return Complex; 648 return nullptr; 649} 650 651QualType Type::getPointeeType() const { 652 if (const auto *PT = getAs<PointerType>()) 653 return PT->getPointeeType(); 654 if (const auto *OPT = getAs<ObjCObjectPointerType>()) 655 return OPT->getPointeeType(); 656 if (const auto *BPT = getAs<BlockPointerType>()) 657 return BPT->getPointeeType(); 658 if (const auto *RT = getAs<ReferenceType>()) 659 return RT->getPointeeType(); 660 if (const auto *MPT = getAs<MemberPointerType>()) 661 return MPT->getPointeeType(); 662 if (const auto *DT = getAs<DecayedType>()) 663 return DT->getPointeeType(); 664 return {}; 665} 666 667const RecordType *Type::getAsStructureType() const { 668 // If this is directly a structure type, return it. 669 if (const auto *RT = dyn_cast<RecordType>(this)) { 670 if (RT->getDecl()->isStruct()) 671 return RT; 672 } 673 674 // If the canonical form of this type isn't the right kind, reject it. 675 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) { 676 if (!RT->getDecl()->isStruct()) 677 return nullptr; 678 679 // If this is a typedef for a structure type, strip the typedef off without 680 // losing all typedef information. 681 return cast<RecordType>(getUnqualifiedDesugaredType()); 682 } 683 return nullptr; 684} 685 686const RecordType *Type::getAsUnionType() const { 687 // If this is directly a union type, return it. 688 if (const auto *RT = dyn_cast<RecordType>(this)) { 689 if (RT->getDecl()->isUnion()) 690 return RT; 691 } 692 693 // If the canonical form of this type isn't the right kind, reject it. 694 if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) { 695 if (!RT->getDecl()->isUnion()) 696 return nullptr; 697 698 // If this is a typedef for a union type, strip the typedef off without 699 // losing all typedef information. 700 return cast<RecordType>(getUnqualifiedDesugaredType()); 701 } 702 703 return nullptr; 704} 705 706bool Type::isObjCIdOrObjectKindOfType(const ASTContext &ctx, 707 const ObjCObjectType *&bound) const { 708 bound = nullptr; 709 710 const auto *OPT = getAs<ObjCObjectPointerType>(); 711 if (!OPT) 712 return false; 713 714 // Easy case: id. 715 if (OPT->isObjCIdType()) 716 return true; 717 718 // If it's not a __kindof type, reject it now. 719 if (!OPT->isKindOfType()) 720 return false; 721 722 // If it's Class or qualified Class, it's not an object type. 723 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) 724 return false; 725 726 // Figure out the type bound for the __kindof type. 727 bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx) 728 ->getAs<ObjCObjectType>(); 729 return true; 730} 731 732bool Type::isObjCClassOrClassKindOfType() const { 733 const auto *OPT = getAs<ObjCObjectPointerType>(); 734 if (!OPT) 735 return false; 736 737 // Easy case: Class. 738 if (OPT->isObjCClassType()) 739 return true; 740 741 // If it's not a __kindof type, reject it now. 742 if (!OPT->isKindOfType()) 743 return false; 744 745 // If it's Class or qualified Class, it's a class __kindof type. 746 return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType(); 747} 748 749ObjCTypeParamType::ObjCTypeParamType(const ObjCTypeParamDecl *D, QualType can, 750 ArrayRef<ObjCProtocolDecl *> protocols) 751 : Type(ObjCTypeParam, can, toSemanticDependence(can->getDependence())), 752 OTPDecl(const_cast<ObjCTypeParamDecl *>(D)) { 753 initialize(protocols); 754} 755 756ObjCObjectType::ObjCObjectType(QualType Canonical, QualType Base, 757 ArrayRef<QualType> typeArgs, 758 ArrayRef<ObjCProtocolDecl *> protocols, 759 bool isKindOf) 760 : Type(ObjCObject, Canonical, Base->getDependence()), BaseType(Base) { 761 ObjCObjectTypeBits.IsKindOf = isKindOf; 762 763 ObjCObjectTypeBits.NumTypeArgs = typeArgs.size(); 764 assert(getTypeArgsAsWritten().size() == typeArgs.size() && 765 "bitfield overflow in type argument count"); 766 if (!typeArgs.empty()) 767 memcpy(getTypeArgStorage(), typeArgs.data(), 768 typeArgs.size() * sizeof(QualType)); 769 770 for (auto typeArg : typeArgs) { 771 addDependence(typeArg->getDependence() & ~TypeDependence::VariablyModified); 772 } 773 // Initialize the protocol qualifiers. The protocol storage is known 774 // after we set number of type arguments. 775 initialize(protocols); 776} 777 778bool ObjCObjectType::isSpecialized() const { 779 // If we have type arguments written here, the type is specialized. 780 if (ObjCObjectTypeBits.NumTypeArgs > 0) 781 return true; 782 783 // Otherwise, check whether the base type is specialized. 784 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) { 785 // Terminate when we reach an interface type. 786 if (isa<ObjCInterfaceType>(objcObject)) 787 return false; 788 789 return objcObject->isSpecialized(); 790 } 791 792 // Not specialized. 793 return false; 794} 795 796ArrayRef<QualType> ObjCObjectType::getTypeArgs() const { 797 // We have type arguments written on this type. 798 if (isSpecializedAsWritten()) 799 return getTypeArgsAsWritten(); 800 801 // Look at the base type, which might have type arguments. 802 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) { 803 // Terminate when we reach an interface type. 804 if (isa<ObjCInterfaceType>(objcObject)) 805 return {}; 806 807 return objcObject->getTypeArgs(); 808 } 809 810 // No type arguments. 811 return {}; 812} 813 814bool ObjCObjectType::isKindOfType() const { 815 if (isKindOfTypeAsWritten()) 816 return true; 817 818 // Look at the base type, which might have type arguments. 819 if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) { 820 // Terminate when we reach an interface type. 821 if (isa<ObjCInterfaceType>(objcObject)) 822 return false; 823 824 return objcObject->isKindOfType(); 825 } 826 827 // Not a "__kindof" type. 828 return false; 829} 830 831QualType ObjCObjectType::stripObjCKindOfTypeAndQuals( 832 const ASTContext &ctx) const { 833 if (!isKindOfType() && qual_empty()) 834 return QualType(this, 0); 835 836 // Recursively strip __kindof. 837 SplitQualType splitBaseType = getBaseType().split(); 838 QualType baseType(splitBaseType.Ty, 0); 839 if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>()) 840 baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx); 841 842 return ctx.getObjCObjectType(ctx.getQualifiedType(baseType, 843 splitBaseType.Quals), 844 getTypeArgsAsWritten(), 845 /*protocols=*/{}, 846 /*isKindOf=*/false); 847} 848 849ObjCInterfaceDecl *ObjCInterfaceType::getDecl() const { 850 ObjCInterfaceDecl *Canon = Decl->getCanonicalDecl(); 851 if (ObjCInterfaceDecl *Def = Canon->getDefinition()) 852 return Def; 853 return Canon; 854} 855 856const ObjCObjectPointerType *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals( 857 const ASTContext &ctx) const { 858 if (!isKindOfType() && qual_empty()) 859 return this; 860 861 QualType obj = getObjectType()->stripObjCKindOfTypeAndQuals(ctx); 862 return ctx.getObjCObjectPointerType(obj)->castAs<ObjCObjectPointerType>(); 863} 864 865namespace { 866 867/// Visitor used to perform a simple type transformation that does not change 868/// the semantics of the type. 869template <typename Derived> 870struct SimpleTransformVisitor : public TypeVisitor<Derived, QualType> { 871 ASTContext &Ctx; 872 873 QualType recurse(QualType type) { 874 // Split out the qualifiers from the type. 875 SplitQualType splitType = type.split(); 876 877 // Visit the type itself. 878 QualType result = static_cast<Derived *>(this)->Visit(splitType.Ty); 879 if (result.isNull()) 880 return result; 881 882 // Reconstruct the transformed type by applying the local qualifiers 883 // from the split type. 884 return Ctx.getQualifiedType(result, splitType.Quals); 885 } 886 887public: 888 explicit SimpleTransformVisitor(ASTContext &ctx) : Ctx(ctx) {} 889 890 // None of the clients of this transformation can occur where 891 // there are dependent types, so skip dependent types. 892#define TYPE(Class, Base) 893#define DEPENDENT_TYPE(Class, Base) \ 894 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); } 895#include "clang/AST/TypeNodes.inc" 896 897#define TRIVIAL_TYPE_CLASS(Class) \ 898 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); } 899#define SUGARED_TYPE_CLASS(Class) \ 900 QualType Visit##Class##Type(const Class##Type *T) { \ 901 if (!T->isSugared()) \ 902 return QualType(T, 0); \ 903 QualType desugaredType = recurse(T->desugar()); \ 904 if (desugaredType.isNull()) \ 905 return {}; \ 906 if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \ 907 return QualType(T, 0); \ 908 return desugaredType; \ 909 } 910 911 TRIVIAL_TYPE_CLASS(Builtin) 912 913 QualType VisitComplexType(const ComplexType *T) { 914 QualType elementType = recurse(T->getElementType()); 915 if (elementType.isNull()) 916 return {}; 917 918 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 919 return QualType(T, 0); 920 921 return Ctx.getComplexType(elementType); 922 } 923 924 QualType VisitPointerType(const PointerType *T) { 925 QualType pointeeType = recurse(T->getPointeeType()); 926 if (pointeeType.isNull()) 927 return {}; 928 929 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr()) 930 return QualType(T, 0); 931 932 return Ctx.getPointerType(pointeeType); 933 } 934 935 QualType VisitBlockPointerType(const BlockPointerType *T) { 936 QualType pointeeType = recurse(T->getPointeeType()); 937 if (pointeeType.isNull()) 938 return {}; 939 940 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr()) 941 return QualType(T, 0); 942 943 return Ctx.getBlockPointerType(pointeeType); 944 } 945 946 QualType VisitLValueReferenceType(const LValueReferenceType *T) { 947 QualType pointeeType = recurse(T->getPointeeTypeAsWritten()); 948 if (pointeeType.isNull()) 949 return {}; 950 951 if (pointeeType.getAsOpaquePtr() 952 == T->getPointeeTypeAsWritten().getAsOpaquePtr()) 953 return QualType(T, 0); 954 955 return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue()); 956 } 957 958 QualType VisitRValueReferenceType(const RValueReferenceType *T) { 959 QualType pointeeType = recurse(T->getPointeeTypeAsWritten()); 960 if (pointeeType.isNull()) 961 return {}; 962 963 if (pointeeType.getAsOpaquePtr() 964 == T->getPointeeTypeAsWritten().getAsOpaquePtr()) 965 return QualType(T, 0); 966 967 return Ctx.getRValueReferenceType(pointeeType); 968 } 969 970 QualType VisitMemberPointerType(const MemberPointerType *T) { 971 QualType pointeeType = recurse(T->getPointeeType()); 972 if (pointeeType.isNull()) 973 return {}; 974 975 if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr()) 976 return QualType(T, 0); 977 978 return Ctx.getMemberPointerType(pointeeType, T->getClass()); 979 } 980 981 QualType VisitConstantArrayType(const ConstantArrayType *T) { 982 QualType elementType = recurse(T->getElementType()); 983 if (elementType.isNull()) 984 return {}; 985 986 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 987 return QualType(T, 0); 988 989 return Ctx.getConstantArrayType(elementType, T->getSize(), T->getSizeExpr(), 990 T->getSizeModifier(), 991 T->getIndexTypeCVRQualifiers()); 992 } 993 994 QualType VisitVariableArrayType(const VariableArrayType *T) { 995 QualType elementType = recurse(T->getElementType()); 996 if (elementType.isNull()) 997 return {}; 998 999 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 1000 return QualType(T, 0); 1001 1002 return Ctx.getVariableArrayType(elementType, T->getSizeExpr(), 1003 T->getSizeModifier(), 1004 T->getIndexTypeCVRQualifiers(), 1005 T->getBracketsRange()); 1006 } 1007 1008 QualType VisitIncompleteArrayType(const IncompleteArrayType *T) { 1009 QualType elementType = recurse(T->getElementType()); 1010 if (elementType.isNull()) 1011 return {}; 1012 1013 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 1014 return QualType(T, 0); 1015 1016 return Ctx.getIncompleteArrayType(elementType, T->getSizeModifier(), 1017 T->getIndexTypeCVRQualifiers()); 1018 } 1019 1020 QualType VisitVectorType(const VectorType *T) { 1021 QualType elementType = recurse(T->getElementType()); 1022 if (elementType.isNull()) 1023 return {}; 1024 1025 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 1026 return QualType(T, 0); 1027 1028 return Ctx.getVectorType(elementType, T->getNumElements(), 1029 T->getVectorKind()); 1030 } 1031 1032 QualType VisitExtVectorType(const ExtVectorType *T) { 1033 QualType elementType = recurse(T->getElementType()); 1034 if (elementType.isNull()) 1035 return {}; 1036 1037 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 1038 return QualType(T, 0); 1039 1040 return Ctx.getExtVectorType(elementType, T->getNumElements()); 1041 } 1042 1043 QualType VisitConstantMatrixType(const ConstantMatrixType *T) { 1044 QualType elementType = recurse(T->getElementType()); 1045 if (elementType.isNull()) 1046 return {}; 1047 if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr()) 1048 return QualType(T, 0); 1049 1050 return Ctx.getConstantMatrixType(elementType, T->getNumRows(), 1051 T->getNumColumns()); 1052 } 1053 1054 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 1055 QualType returnType = recurse(T->getReturnType()); 1056 if (returnType.isNull()) 1057 return {}; 1058 1059 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr()) 1060 return QualType(T, 0); 1061 1062 return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo()); 1063 } 1064 1065 QualType VisitFunctionProtoType(const FunctionProtoType *T) { 1066 QualType returnType = recurse(T->getReturnType()); 1067 if (returnType.isNull()) 1068 return {}; 1069 1070 // Transform parameter types. 1071 SmallVector<QualType, 4> paramTypes; 1072 bool paramChanged = false; 1073 for (auto paramType : T->getParamTypes()) { 1074 QualType newParamType = recurse(paramType); 1075 if (newParamType.isNull()) 1076 return {}; 1077 1078 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr()) 1079 paramChanged = true; 1080 1081 paramTypes.push_back(newParamType); 1082 } 1083 1084 // Transform extended info. 1085 FunctionProtoType::ExtProtoInfo info = T->getExtProtoInfo(); 1086 bool exceptionChanged = false; 1087 if (info.ExceptionSpec.Type == EST_Dynamic) { 1088 SmallVector<QualType, 4> exceptionTypes; 1089 for (auto exceptionType : info.ExceptionSpec.Exceptions) { 1090 QualType newExceptionType = recurse(exceptionType); 1091 if (newExceptionType.isNull()) 1092 return {}; 1093 1094 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr()) 1095 exceptionChanged = true; 1096 1097 exceptionTypes.push_back(newExceptionType); 1098 } 1099 1100 if (exceptionChanged) { 1101 info.ExceptionSpec.Exceptions = 1102 llvm::ArrayRef(exceptionTypes).copy(Ctx); 1103 } 1104 } 1105 1106 if (returnType.getAsOpaquePtr() == T->getReturnType().getAsOpaquePtr() && 1107 !paramChanged && !exceptionChanged) 1108 return QualType(T, 0); 1109 1110 return Ctx.getFunctionType(returnType, paramTypes, info); 1111 } 1112 1113 QualType VisitParenType(const ParenType *T) { 1114 QualType innerType = recurse(T->getInnerType()); 1115 if (innerType.isNull()) 1116 return {}; 1117 1118 if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr()) 1119 return QualType(T, 0); 1120 1121 return Ctx.getParenType(innerType); 1122 } 1123 1124 SUGARED_TYPE_CLASS(Typedef) 1125 SUGARED_TYPE_CLASS(ObjCTypeParam) 1126 SUGARED_TYPE_CLASS(MacroQualified) 1127 1128 QualType VisitAdjustedType(const AdjustedType *T) { 1129 QualType originalType = recurse(T->getOriginalType()); 1130 if (originalType.isNull()) 1131 return {}; 1132 1133 QualType adjustedType = recurse(T->getAdjustedType()); 1134 if (adjustedType.isNull()) 1135 return {}; 1136 1137 if (originalType.getAsOpaquePtr() 1138 == T->getOriginalType().getAsOpaquePtr() && 1139 adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr()) 1140 return QualType(T, 0); 1141 1142 return Ctx.getAdjustedType(originalType, adjustedType); 1143 } 1144 1145 QualType VisitDecayedType(const DecayedType *T) { 1146 QualType originalType = recurse(T->getOriginalType()); 1147 if (originalType.isNull()) 1148 return {}; 1149 1150 if (originalType.getAsOpaquePtr() 1151 == T->getOriginalType().getAsOpaquePtr()) 1152 return QualType(T, 0); 1153 1154 return Ctx.getDecayedType(originalType); 1155 } 1156 1157 SUGARED_TYPE_CLASS(TypeOfExpr) 1158 SUGARED_TYPE_CLASS(TypeOf) 1159 SUGARED_TYPE_CLASS(Decltype) 1160 SUGARED_TYPE_CLASS(UnaryTransform) 1161 TRIVIAL_TYPE_CLASS(Record) 1162 TRIVIAL_TYPE_CLASS(Enum) 1163 1164 // FIXME: Non-trivial to implement, but important for C++ 1165 SUGARED_TYPE_CLASS(Elaborated) 1166 1167 QualType VisitAttributedType(const AttributedType *T) { 1168 QualType modifiedType = recurse(T->getModifiedType()); 1169 if (modifiedType.isNull()) 1170 return {}; 1171 1172 QualType equivalentType = recurse(T->getEquivalentType()); 1173 if (equivalentType.isNull()) 1174 return {}; 1175 1176 if (modifiedType.getAsOpaquePtr() 1177 == T->getModifiedType().getAsOpaquePtr() && 1178 equivalentType.getAsOpaquePtr() 1179 == T->getEquivalentType().getAsOpaquePtr()) 1180 return QualType(T, 0); 1181 1182 return Ctx.getAttributedType(T->getAttrKind(), modifiedType, 1183 equivalentType); 1184 } 1185 1186 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { 1187 QualType replacementType = recurse(T->getReplacementType()); 1188 if (replacementType.isNull()) 1189 return {}; 1190 1191 if (replacementType.getAsOpaquePtr() 1192 == T->getReplacementType().getAsOpaquePtr()) 1193 return QualType(T, 0); 1194 1195 return Ctx.getSubstTemplateTypeParmType(replacementType, 1196 T->getAssociatedDecl(), 1197 T->getIndex(), T->getPackIndex()); 1198 } 1199 1200 // FIXME: Non-trivial to implement, but important for C++ 1201 SUGARED_TYPE_CLASS(TemplateSpecialization) 1202 1203 QualType VisitAutoType(const AutoType *T) { 1204 if (!T->isDeduced()) 1205 return QualType(T, 0); 1206 1207 QualType deducedType = recurse(T->getDeducedType()); 1208 if (deducedType.isNull()) 1209 return {}; 1210 1211 if (deducedType.getAsOpaquePtr() 1212 == T->getDeducedType().getAsOpaquePtr()) 1213 return QualType(T, 0); 1214 1215 return Ctx.getAutoType(deducedType, T->getKeyword(), 1216 T->isDependentType(), /*IsPack=*/false, 1217 T->getTypeConstraintConcept(), 1218 T->getTypeConstraintArguments()); 1219 } 1220 1221 QualType VisitObjCObjectType(const ObjCObjectType *T) { 1222 QualType baseType = recurse(T->getBaseType()); 1223 if (baseType.isNull()) 1224 return {}; 1225 1226 // Transform type arguments. 1227 bool typeArgChanged = false; 1228 SmallVector<QualType, 4> typeArgs; 1229 for (auto typeArg : T->getTypeArgsAsWritten()) { 1230 QualType newTypeArg = recurse(typeArg); 1231 if (newTypeArg.isNull()) 1232 return {}; 1233 1234 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) 1235 typeArgChanged = true; 1236 1237 typeArgs.push_back(newTypeArg); 1238 } 1239 1240 if (baseType.getAsOpaquePtr() == T->getBaseType().getAsOpaquePtr() && 1241 !typeArgChanged) 1242 return QualType(T, 0); 1243 1244 return Ctx.getObjCObjectType( 1245 baseType, typeArgs, 1246 llvm::ArrayRef(T->qual_begin(), T->getNumProtocols()), 1247 T->isKindOfTypeAsWritten()); 1248 } 1249 1250 TRIVIAL_TYPE_CLASS(ObjCInterface) 1251 1252 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 1253 QualType pointeeType = recurse(T->getPointeeType()); 1254 if (pointeeType.isNull()) 1255 return {}; 1256 1257 if (pointeeType.getAsOpaquePtr() 1258 == T->getPointeeType().getAsOpaquePtr()) 1259 return QualType(T, 0); 1260 1261 return Ctx.getObjCObjectPointerType(pointeeType); 1262 } 1263 1264 QualType VisitAtomicType(const AtomicType *T) { 1265 QualType valueType = recurse(T->getValueType()); 1266 if (valueType.isNull()) 1267 return {}; 1268 1269 if (valueType.getAsOpaquePtr() 1270 == T->getValueType().getAsOpaquePtr()) 1271 return QualType(T, 0); 1272 1273 return Ctx.getAtomicType(valueType); 1274 } 1275 1276#undef TRIVIAL_TYPE_CLASS 1277#undef SUGARED_TYPE_CLASS 1278}; 1279 1280struct SubstObjCTypeArgsVisitor 1281 : public SimpleTransformVisitor<SubstObjCTypeArgsVisitor> { 1282 using BaseType = SimpleTransformVisitor<SubstObjCTypeArgsVisitor>; 1283 1284 ArrayRef<QualType> TypeArgs; 1285 ObjCSubstitutionContext SubstContext; 1286 1287 SubstObjCTypeArgsVisitor(ASTContext &ctx, ArrayRef<QualType> typeArgs, 1288 ObjCSubstitutionContext context) 1289 : BaseType(ctx), TypeArgs(typeArgs), SubstContext(context) {} 1290 1291 QualType VisitObjCTypeParamType(const ObjCTypeParamType *OTPTy) { 1292 // Replace an Objective-C type parameter reference with the corresponding 1293 // type argument. 1294 ObjCTypeParamDecl *typeParam = OTPTy->getDecl(); 1295 // If we have type arguments, use them. 1296 if (!TypeArgs.empty()) { 1297 QualType argType = TypeArgs[typeParam->getIndex()]; 1298 if (OTPTy->qual_empty()) 1299 return argType; 1300 1301 // Apply protocol lists if exists. 1302 bool hasError; 1303 SmallVector<ObjCProtocolDecl *, 8> protocolsVec; 1304 protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end()); 1305 ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec; 1306 return Ctx.applyObjCProtocolQualifiers( 1307 argType, protocolsToApply, hasError, true/*allowOnPointerType*/); 1308 } 1309 1310 switch (SubstContext) { 1311 case ObjCSubstitutionContext::Ordinary: 1312 case ObjCSubstitutionContext::Parameter: 1313 case ObjCSubstitutionContext::Superclass: 1314 // Substitute the bound. 1315 return typeParam->getUnderlyingType(); 1316 1317 case ObjCSubstitutionContext::Result: 1318 case ObjCSubstitutionContext::Property: { 1319 // Substitute the __kindof form of the underlying type. 1320 const auto *objPtr = 1321 typeParam->getUnderlyingType()->castAs<ObjCObjectPointerType>(); 1322 1323 // __kindof types, id, and Class don't need an additional 1324 // __kindof. 1325 if (objPtr->isKindOfType() || objPtr->isObjCIdOrClassType()) 1326 return typeParam->getUnderlyingType(); 1327 1328 // Add __kindof. 1329 const auto *obj = objPtr->getObjectType(); 1330 QualType resultTy = Ctx.getObjCObjectType( 1331 obj->getBaseType(), obj->getTypeArgsAsWritten(), obj->getProtocols(), 1332 /*isKindOf=*/true); 1333 1334 // Rebuild object pointer type. 1335 return Ctx.getObjCObjectPointerType(resultTy); 1336 } 1337 } 1338 llvm_unreachable("Unexpected ObjCSubstitutionContext!"); 1339 } 1340 1341 QualType VisitFunctionType(const FunctionType *funcType) { 1342 // If we have a function type, update the substitution context 1343 // appropriately. 1344 1345 //Substitute result type. 1346 QualType returnType = funcType->getReturnType().substObjCTypeArgs( 1347 Ctx, TypeArgs, ObjCSubstitutionContext::Result); 1348 if (returnType.isNull()) 1349 return {}; 1350 1351 // Handle non-prototyped functions, which only substitute into the result 1352 // type. 1353 if (isa<FunctionNoProtoType>(funcType)) { 1354 // If the return type was unchanged, do nothing. 1355 if (returnType.getAsOpaquePtr() == 1356 funcType->getReturnType().getAsOpaquePtr()) 1357 return BaseType::VisitFunctionType(funcType); 1358 1359 // Otherwise, build a new type. 1360 return Ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo()); 1361 } 1362 1363 const auto *funcProtoType = cast<FunctionProtoType>(funcType); 1364 1365 // Transform parameter types. 1366 SmallVector<QualType, 4> paramTypes; 1367 bool paramChanged = false; 1368 for (auto paramType : funcProtoType->getParamTypes()) { 1369 QualType newParamType = paramType.substObjCTypeArgs( 1370 Ctx, TypeArgs, ObjCSubstitutionContext::Parameter); 1371 if (newParamType.isNull()) 1372 return {}; 1373 1374 if (newParamType.getAsOpaquePtr() != paramType.getAsOpaquePtr()) 1375 paramChanged = true; 1376 1377 paramTypes.push_back(newParamType); 1378 } 1379 1380 // Transform extended info. 1381 FunctionProtoType::ExtProtoInfo info = funcProtoType->getExtProtoInfo(); 1382 bool exceptionChanged = false; 1383 if (info.ExceptionSpec.Type == EST_Dynamic) { 1384 SmallVector<QualType, 4> exceptionTypes; 1385 for (auto exceptionType : info.ExceptionSpec.Exceptions) { 1386 QualType newExceptionType = exceptionType.substObjCTypeArgs( 1387 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary); 1388 if (newExceptionType.isNull()) 1389 return {}; 1390 1391 if (newExceptionType.getAsOpaquePtr() != exceptionType.getAsOpaquePtr()) 1392 exceptionChanged = true; 1393 1394 exceptionTypes.push_back(newExceptionType); 1395 } 1396 1397 if (exceptionChanged) { 1398 info.ExceptionSpec.Exceptions = 1399 llvm::ArrayRef(exceptionTypes).copy(Ctx); 1400 } 1401 } 1402 1403 if (returnType.getAsOpaquePtr() == 1404 funcProtoType->getReturnType().getAsOpaquePtr() && 1405 !paramChanged && !exceptionChanged) 1406 return BaseType::VisitFunctionType(funcType); 1407 1408 return Ctx.getFunctionType(returnType, paramTypes, info); 1409 } 1410 1411 QualType VisitObjCObjectType(const ObjCObjectType *objcObjectType) { 1412 // Substitute into the type arguments of a specialized Objective-C object 1413 // type. 1414 if (objcObjectType->isSpecializedAsWritten()) { 1415 SmallVector<QualType, 4> newTypeArgs; 1416 bool anyChanged = false; 1417 for (auto typeArg : objcObjectType->getTypeArgsAsWritten()) { 1418 QualType newTypeArg = typeArg.substObjCTypeArgs( 1419 Ctx, TypeArgs, ObjCSubstitutionContext::Ordinary); 1420 if (newTypeArg.isNull()) 1421 return {}; 1422 1423 if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr()) { 1424 // If we're substituting based on an unspecialized context type, 1425 // produce an unspecialized type. 1426 ArrayRef<ObjCProtocolDecl *> protocols( 1427 objcObjectType->qual_begin(), objcObjectType->getNumProtocols()); 1428 if (TypeArgs.empty() && 1429 SubstContext != ObjCSubstitutionContext::Superclass) { 1430 return Ctx.getObjCObjectType( 1431 objcObjectType->getBaseType(), {}, protocols, 1432 objcObjectType->isKindOfTypeAsWritten()); 1433 } 1434 1435 anyChanged = true; 1436 } 1437 1438 newTypeArgs.push_back(newTypeArg); 1439 } 1440 1441 if (anyChanged) { 1442 ArrayRef<ObjCProtocolDecl *> protocols( 1443 objcObjectType->qual_begin(), objcObjectType->getNumProtocols()); 1444 return Ctx.getObjCObjectType(objcObjectType->getBaseType(), newTypeArgs, 1445 protocols, 1446 objcObjectType->isKindOfTypeAsWritten()); 1447 } 1448 } 1449 1450 return BaseType::VisitObjCObjectType(objcObjectType); 1451 } 1452 1453 QualType VisitAttributedType(const AttributedType *attrType) { 1454 QualType newType = BaseType::VisitAttributedType(attrType); 1455 if (newType.isNull()) 1456 return {}; 1457 1458 const auto *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr()); 1459 if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf) 1460 return newType; 1461 1462 // Find out if it's an Objective-C object or object pointer type; 1463 QualType newEquivType = newAttrType->getEquivalentType(); 1464 const ObjCObjectPointerType *ptrType = 1465 newEquivType->getAs<ObjCObjectPointerType>(); 1466 const ObjCObjectType *objType = ptrType 1467 ? ptrType->getObjectType() 1468 : newEquivType->getAs<ObjCObjectType>(); 1469 if (!objType) 1470 return newType; 1471 1472 // Rebuild the "equivalent" type, which pushes __kindof down into 1473 // the object type. 1474 newEquivType = Ctx.getObjCObjectType( 1475 objType->getBaseType(), objType->getTypeArgsAsWritten(), 1476 objType->getProtocols(), 1477 // There is no need to apply kindof on an unqualified id type. 1478 /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true); 1479 1480 // If we started with an object pointer type, rebuild it. 1481 if (ptrType) 1482 newEquivType = Ctx.getObjCObjectPointerType(newEquivType); 1483 1484 // Rebuild the attributed type. 1485 return Ctx.getAttributedType(newAttrType->getAttrKind(), 1486 newAttrType->getModifiedType(), newEquivType); 1487 } 1488}; 1489 1490struct StripObjCKindOfTypeVisitor 1491 : public SimpleTransformVisitor<StripObjCKindOfTypeVisitor> { 1492 using BaseType = SimpleTransformVisitor<StripObjCKindOfTypeVisitor>; 1493 1494 explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {} 1495 1496 QualType VisitObjCObjectType(const ObjCObjectType *objType) { 1497 if (!objType->isKindOfType()) 1498 return BaseType::VisitObjCObjectType(objType); 1499 1500 QualType baseType = objType->getBaseType().stripObjCKindOfType(Ctx); 1501 return Ctx.getObjCObjectType(baseType, objType->getTypeArgsAsWritten(), 1502 objType->getProtocols(), 1503 /*isKindOf=*/false); 1504 } 1505}; 1506 1507} // namespace 1508 1509bool QualType::UseExcessPrecision(const ASTContext &Ctx) { 1510 const BuiltinType *BT = getTypePtr()->getAs<BuiltinType>(); 1511 if (!BT) { 1512 const VectorType *VT = getTypePtr()->getAs<VectorType>(); 1513 if (VT) { 1514 QualType ElementType = VT->getElementType(); 1515 return ElementType.UseExcessPrecision(Ctx); 1516 } 1517 } else { 1518 switch (BT->getKind()) { 1519 case BuiltinType::Kind::Float16: { 1520 const TargetInfo &TI = Ctx.getTargetInfo(); 1521 if (TI.hasFloat16Type() && !TI.hasLegalHalfType() && 1522 Ctx.getLangOpts().getFloat16ExcessPrecision() != 1523 Ctx.getLangOpts().ExcessPrecisionKind::FPP_None) 1524 return true; 1525 break; 1526 } 1527 case BuiltinType::Kind::BFloat16: { 1528 const TargetInfo &TI = Ctx.getTargetInfo(); 1529 if (TI.hasBFloat16Type() && !TI.hasFullBFloat16Type() && 1530 Ctx.getLangOpts().getBFloat16ExcessPrecision() != 1531 Ctx.getLangOpts().ExcessPrecisionKind::FPP_None) 1532 return true; 1533 break; 1534 } 1535 default: 1536 return false; 1537 } 1538 } 1539 return false; 1540} 1541 1542/// Substitute the given type arguments for Objective-C type 1543/// parameters within the given type, recursively. 1544QualType QualType::substObjCTypeArgs(ASTContext &ctx, 1545 ArrayRef<QualType> typeArgs, 1546 ObjCSubstitutionContext context) const { 1547 SubstObjCTypeArgsVisitor visitor(ctx, typeArgs, context); 1548 return visitor.recurse(*this); 1549} 1550 1551QualType QualType::substObjCMemberType(QualType objectType, 1552 const DeclContext *dc, 1553 ObjCSubstitutionContext context) const { 1554 if (auto subs = objectType->getObjCSubstitutions(dc)) 1555 return substObjCTypeArgs(dc->getParentASTContext(), *subs, context); 1556 1557 return *this; 1558} 1559 1560QualType QualType::stripObjCKindOfType(const ASTContext &constCtx) const { 1561 // FIXME: Because ASTContext::getAttributedType() is non-const. 1562 auto &ctx = const_cast<ASTContext &>(constCtx); 1563 StripObjCKindOfTypeVisitor visitor(ctx); 1564 return visitor.recurse(*this); 1565} 1566 1567QualType QualType::getAtomicUnqualifiedType() const { 1568 if (const auto AT = getTypePtr()->getAs<AtomicType>()) 1569 return AT->getValueType().getUnqualifiedType(); 1570 return getUnqualifiedType(); 1571} 1572 1573std::optional<ArrayRef<QualType>> 1574Type::getObjCSubstitutions(const DeclContext *dc) const { 1575 // Look through method scopes. 1576 if (const auto method = dyn_cast<ObjCMethodDecl>(dc)) 1577 dc = method->getDeclContext(); 1578 1579 // Find the class or category in which the type we're substituting 1580 // was declared. 1581 const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc); 1582 const ObjCCategoryDecl *dcCategoryDecl = nullptr; 1583 ObjCTypeParamList *dcTypeParams = nullptr; 1584 if (dcClassDecl) { 1585 // If the class does not have any type parameters, there's no 1586 // substitution to do. 1587 dcTypeParams = dcClassDecl->getTypeParamList(); 1588 if (!dcTypeParams) 1589 return std::nullopt; 1590 } else { 1591 // If we are in neither a class nor a category, there's no 1592 // substitution to perform. 1593 dcCategoryDecl = dyn_cast<ObjCCategoryDecl>(dc); 1594 if (!dcCategoryDecl) 1595 return std::nullopt; 1596 1597 // If the category does not have any type parameters, there's no 1598 // substitution to do. 1599 dcTypeParams = dcCategoryDecl->getTypeParamList(); 1600 if (!dcTypeParams) 1601 return std::nullopt; 1602 1603 dcClassDecl = dcCategoryDecl->getClassInterface(); 1604 if (!dcClassDecl) 1605 return std::nullopt; 1606 } 1607 assert(dcTypeParams && "No substitutions to perform"); 1608 assert(dcClassDecl && "No class context"); 1609 1610 // Find the underlying object type. 1611 const ObjCObjectType *objectType; 1612 if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) { 1613 objectType = objectPointerType->getObjectType(); 1614 } else if (getAs<BlockPointerType>()) { 1615 ASTContext &ctx = dc->getParentASTContext(); 1616 objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {}) 1617 ->castAs<ObjCObjectType>(); 1618 } else { 1619 objectType = getAs<ObjCObjectType>(); 1620 } 1621 1622 /// Extract the class from the receiver object type. 1623 ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface() 1624 : nullptr; 1625 if (!curClassDecl) { 1626 // If we don't have a context type (e.g., this is "id" or some 1627 // variant thereof), substitute the bounds. 1628 return llvm::ArrayRef<QualType>(); 1629 } 1630 1631 // Follow the superclass chain until we've mapped the receiver type 1632 // to the same class as the context. 1633 while (curClassDecl != dcClassDecl) { 1634 // Map to the superclass type. 1635 QualType superType = objectType->getSuperClassType(); 1636 if (superType.isNull()) { 1637 objectType = nullptr; 1638 break; 1639 } 1640 1641 objectType = superType->castAs<ObjCObjectType>(); 1642 curClassDecl = objectType->getInterface(); 1643 } 1644 1645 // If we don't have a receiver type, or the receiver type does not 1646 // have type arguments, substitute in the defaults. 1647 if (!objectType || objectType->isUnspecialized()) { 1648 return llvm::ArrayRef<QualType>(); 1649 } 1650 1651 // The receiver type has the type arguments we want. 1652 return objectType->getTypeArgs(); 1653} 1654 1655bool Type::acceptsObjCTypeParams() const { 1656 if (auto *IfaceT = getAsObjCInterfaceType()) { 1657 if (auto *ID = IfaceT->getInterface()) { 1658 if (ID->getTypeParamList()) 1659 return true; 1660 } 1661 } 1662 1663 return false; 1664} 1665 1666void ObjCObjectType::computeSuperClassTypeSlow() const { 1667 // Retrieve the class declaration for this type. If there isn't one 1668 // (e.g., this is some variant of "id" or "Class"), then there is no 1669 // superclass type. 1670 ObjCInterfaceDecl *classDecl = getInterface(); 1671 if (!classDecl) { 1672 CachedSuperClassType.setInt(true); 1673 return; 1674 } 1675 1676 // Extract the superclass type. 1677 const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType(); 1678 if (!superClassObjTy) { 1679 CachedSuperClassType.setInt(true); 1680 return; 1681 } 1682 1683 ObjCInterfaceDecl *superClassDecl = superClassObjTy->getInterface(); 1684 if (!superClassDecl) { 1685 CachedSuperClassType.setInt(true); 1686 return; 1687 } 1688 1689 // If the superclass doesn't have type parameters, then there is no 1690 // substitution to perform. 1691 QualType superClassType(superClassObjTy, 0); 1692 ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList(); 1693 if (!superClassTypeParams) { 1694 CachedSuperClassType.setPointerAndInt( 1695 superClassType->castAs<ObjCObjectType>(), true); 1696 return; 1697 } 1698 1699 // If the superclass reference is unspecialized, return it. 1700 if (superClassObjTy->isUnspecialized()) { 1701 CachedSuperClassType.setPointerAndInt(superClassObjTy, true); 1702 return; 1703 } 1704 1705 // If the subclass is not parameterized, there aren't any type 1706 // parameters in the superclass reference to substitute. 1707 ObjCTypeParamList *typeParams = classDecl->getTypeParamList(); 1708 if (!typeParams) { 1709 CachedSuperClassType.setPointerAndInt( 1710 superClassType->castAs<ObjCObjectType>(), true); 1711 return; 1712 } 1713 1714 // If the subclass type isn't specialized, return the unspecialized 1715 // superclass. 1716 if (isUnspecialized()) { 1717 QualType unspecializedSuper 1718 = classDecl->getASTContext().getObjCInterfaceType( 1719 superClassObjTy->getInterface()); 1720 CachedSuperClassType.setPointerAndInt( 1721 unspecializedSuper->castAs<ObjCObjectType>(), 1722 true); 1723 return; 1724 } 1725 1726 // Substitute the provided type arguments into the superclass type. 1727 ArrayRef<QualType> typeArgs = getTypeArgs(); 1728 assert(typeArgs.size() == typeParams->size()); 1729 CachedSuperClassType.setPointerAndInt( 1730 superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs, 1731 ObjCSubstitutionContext::Superclass) 1732 ->castAs<ObjCObjectType>(), 1733 true); 1734} 1735 1736const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const { 1737 if (auto interfaceDecl = getObjectType()->getInterface()) { 1738 return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl) 1739 ->castAs<ObjCInterfaceType>(); 1740 } 1741 1742 return nullptr; 1743} 1744 1745QualType ObjCObjectPointerType::getSuperClassType() const { 1746 QualType superObjectType = getObjectType()->getSuperClassType(); 1747 if (superObjectType.isNull()) 1748 return superObjectType; 1749 1750 ASTContext &ctx = getInterfaceDecl()->getASTContext(); 1751 return ctx.getObjCObjectPointerType(superObjectType); 1752} 1753 1754const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const { 1755 // There is no sugar for ObjCObjectType's, just return the canonical 1756 // type pointer if it is the right class. There is no typedef information to 1757 // return and these cannot be Address-space qualified. 1758 if (const auto *T = getAs<ObjCObjectType>()) 1759 if (T->getNumProtocols() && T->getInterface()) 1760 return T; 1761 return nullptr; 1762} 1763 1764bool Type::isObjCQualifiedInterfaceType() const { 1765 return getAsObjCQualifiedInterfaceType() != nullptr; 1766} 1767 1768const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const { 1769 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 1770 // type pointer if it is the right class. 1771 if (const auto *OPT = getAs<ObjCObjectPointerType>()) { 1772 if (OPT->isObjCQualifiedIdType()) 1773 return OPT; 1774 } 1775 return nullptr; 1776} 1777 1778const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const { 1779 // There is no sugar for ObjCQualifiedClassType's, just return the canonical 1780 // type pointer if it is the right class. 1781 if (const auto *OPT = getAs<ObjCObjectPointerType>()) { 1782 if (OPT->isObjCQualifiedClassType()) 1783 return OPT; 1784 } 1785 return nullptr; 1786} 1787 1788const ObjCObjectType *Type::getAsObjCInterfaceType() const { 1789 if (const auto *OT = getAs<ObjCObjectType>()) { 1790 if (OT->getInterface()) 1791 return OT; 1792 } 1793 return nullptr; 1794} 1795 1796const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const { 1797 if (const auto *OPT = getAs<ObjCObjectPointerType>()) { 1798 if (OPT->getInterfaceType()) 1799 return OPT; 1800 } 1801 return nullptr; 1802} 1803 1804const CXXRecordDecl *Type::getPointeeCXXRecordDecl() const { 1805 QualType PointeeType; 1806 if (const auto *PT = getAs<PointerType>()) 1807 PointeeType = PT->getPointeeType(); 1808 else if (const auto *RT = getAs<ReferenceType>()) 1809 PointeeType = RT->getPointeeType(); 1810 else 1811 return nullptr; 1812 1813 if (const auto *RT = PointeeType->getAs<RecordType>()) 1814 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 1815 1816 return nullptr; 1817} 1818 1819CXXRecordDecl *Type::getAsCXXRecordDecl() const { 1820 return dyn_cast_or_null<CXXRecordDecl>(getAsTagDecl()); 1821} 1822 1823RecordDecl *Type::getAsRecordDecl() const { 1824 return dyn_cast_or_null<RecordDecl>(getAsTagDecl()); 1825} 1826 1827TagDecl *Type::getAsTagDecl() const { 1828 if (const auto *TT = getAs<TagType>()) 1829 return TT->getDecl(); 1830 if (const auto *Injected = getAs<InjectedClassNameType>()) 1831 return Injected->getDecl(); 1832 1833 return nullptr; 1834} 1835 1836bool Type::hasAttr(attr::Kind AK) const { 1837 const Type *Cur = this; 1838 while (const auto *AT = Cur->getAs<AttributedType>()) { 1839 if (AT->getAttrKind() == AK) 1840 return true; 1841 Cur = AT->getEquivalentType().getTypePtr(); 1842 } 1843 return false; 1844} 1845 1846namespace { 1847 1848 class GetContainedDeducedTypeVisitor : 1849 public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> { 1850 bool Syntactic; 1851 1852 public: 1853 GetContainedDeducedTypeVisitor(bool Syntactic = false) 1854 : Syntactic(Syntactic) {} 1855 1856 using TypeVisitor<GetContainedDeducedTypeVisitor, Type*>::Visit; 1857 1858 Type *Visit(QualType T) { 1859 if (T.isNull()) 1860 return nullptr; 1861 return Visit(T.getTypePtr()); 1862 } 1863 1864 // The deduced type itself. 1865 Type *VisitDeducedType(const DeducedType *AT) { 1866 return const_cast<DeducedType*>(AT); 1867 } 1868 1869 // Only these types can contain the desired 'auto' type. 1870 Type *VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { 1871 return Visit(T->getReplacementType()); 1872 } 1873 1874 Type *VisitElaboratedType(const ElaboratedType *T) { 1875 return Visit(T->getNamedType()); 1876 } 1877 1878 Type *VisitPointerType(const PointerType *T) { 1879 return Visit(T->getPointeeType()); 1880 } 1881 1882 Type *VisitBlockPointerType(const BlockPointerType *T) { 1883 return Visit(T->getPointeeType()); 1884 } 1885 1886 Type *VisitReferenceType(const ReferenceType *T) { 1887 return Visit(T->getPointeeTypeAsWritten()); 1888 } 1889 1890 Type *VisitMemberPointerType(const MemberPointerType *T) { 1891 return Visit(T->getPointeeType()); 1892 } 1893 1894 Type *VisitArrayType(const ArrayType *T) { 1895 return Visit(T->getElementType()); 1896 } 1897 1898 Type *VisitDependentSizedExtVectorType( 1899 const DependentSizedExtVectorType *T) { 1900 return Visit(T->getElementType()); 1901 } 1902 1903 Type *VisitVectorType(const VectorType *T) { 1904 return Visit(T->getElementType()); 1905 } 1906 1907 Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) { 1908 return Visit(T->getElementType()); 1909 } 1910 1911 Type *VisitConstantMatrixType(const ConstantMatrixType *T) { 1912 return Visit(T->getElementType()); 1913 } 1914 1915 Type *VisitFunctionProtoType(const FunctionProtoType *T) { 1916 if (Syntactic && T->hasTrailingReturn()) 1917 return const_cast<FunctionProtoType*>(T); 1918 return VisitFunctionType(T); 1919 } 1920 1921 Type *VisitFunctionType(const FunctionType *T) { 1922 return Visit(T->getReturnType()); 1923 } 1924 1925 Type *VisitParenType(const ParenType *T) { 1926 return Visit(T->getInnerType()); 1927 } 1928 1929 Type *VisitAttributedType(const AttributedType *T) { 1930 return Visit(T->getModifiedType()); 1931 } 1932 1933 Type *VisitMacroQualifiedType(const MacroQualifiedType *T) { 1934 return Visit(T->getUnderlyingType()); 1935 } 1936 1937 Type *VisitAdjustedType(const AdjustedType *T) { 1938 return Visit(T->getOriginalType()); 1939 } 1940 1941 Type *VisitPackExpansionType(const PackExpansionType *T) { 1942 return Visit(T->getPattern()); 1943 } 1944 }; 1945 1946} // namespace 1947 1948DeducedType *Type::getContainedDeducedType() const { 1949 return cast_or_null<DeducedType>( 1950 GetContainedDeducedTypeVisitor().Visit(this)); 1951} 1952 1953bool Type::hasAutoForTrailingReturnType() const { 1954 return isa_and_nonnull<FunctionType>( 1955 GetContainedDeducedTypeVisitor(true).Visit(this)); 1956} 1957 1958bool Type::hasIntegerRepresentation() const { 1959 if (const auto *VT = dyn_cast<VectorType>(CanonicalType)) 1960 return VT->getElementType()->isIntegerType(); 1961 if (CanonicalType->isSveVLSBuiltinType()) { 1962 const auto *VT = cast<BuiltinType>(CanonicalType); 1963 return VT->getKind() == BuiltinType::SveBool || 1964 (VT->getKind() >= BuiltinType::SveInt8 && 1965 VT->getKind() <= BuiltinType::SveUint64); 1966 } 1967 if (CanonicalType->isRVVVLSBuiltinType()) { 1968 const auto *VT = cast<BuiltinType>(CanonicalType); 1969 return (VT->getKind() >= BuiltinType::RvvInt8mf8 && 1970 VT->getKind() <= BuiltinType::RvvUint64m8); 1971 } 1972 1973 return isIntegerType(); 1974} 1975 1976/// Determine whether this type is an integral type. 1977/// 1978/// This routine determines whether the given type is an integral type per 1979/// C++ [basic.fundamental]p7. Although the C standard does not define the 1980/// term "integral type", it has a similar term "integer type", and in C++ 1981/// the two terms are equivalent. However, C's "integer type" includes 1982/// enumeration types, while C++'s "integer type" does not. The \c ASTContext 1983/// parameter is used to determine whether we should be following the C or 1984/// C++ rules when determining whether this type is an integral/integer type. 1985/// 1986/// For cases where C permits "an integer type" and C++ permits "an integral 1987/// type", use this routine. 1988/// 1989/// For cases where C permits "an integer type" and C++ permits "an integral 1990/// or enumeration type", use \c isIntegralOrEnumerationType() instead. 1991/// 1992/// \param Ctx The context in which this type occurs. 1993/// 1994/// \returns true if the type is considered an integral type, false otherwise. 1995bool Type::isIntegralType(const ASTContext &Ctx) const { 1996 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 1997 return BT->getKind() >= BuiltinType::Bool && 1998 BT->getKind() <= BuiltinType::Int128; 1999 2000 // Complete enum types are integral in C. 2001 if (!Ctx.getLangOpts().CPlusPlus) 2002 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) 2003 return ET->getDecl()->isComplete(); 2004 2005 return isBitIntType(); 2006} 2007 2008bool Type::isIntegralOrUnscopedEnumerationType() const { 2009 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2010 return BT->getKind() >= BuiltinType::Bool && 2011 BT->getKind() <= BuiltinType::Int128; 2012 2013 if (isBitIntType()) 2014 return true; 2015 2016 return isUnscopedEnumerationType(); 2017} 2018 2019bool Type::isUnscopedEnumerationType() const { 2020 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) 2021 return !ET->getDecl()->isScoped(); 2022 2023 return false; 2024} 2025 2026bool Type::isCharType() const { 2027 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2028 return BT->getKind() == BuiltinType::Char_U || 2029 BT->getKind() == BuiltinType::UChar || 2030 BT->getKind() == BuiltinType::Char_S || 2031 BT->getKind() == BuiltinType::SChar; 2032 return false; 2033} 2034 2035bool Type::isWideCharType() const { 2036 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2037 return BT->getKind() == BuiltinType::WChar_S || 2038 BT->getKind() == BuiltinType::WChar_U; 2039 return false; 2040} 2041 2042bool Type::isChar8Type() const { 2043 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 2044 return BT->getKind() == BuiltinType::Char8; 2045 return false; 2046} 2047 2048bool Type::isChar16Type() const { 2049 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2050 return BT->getKind() == BuiltinType::Char16; 2051 return false; 2052} 2053 2054bool Type::isChar32Type() const { 2055 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2056 return BT->getKind() == BuiltinType::Char32; 2057 return false; 2058} 2059 2060/// Determine whether this type is any of the built-in character 2061/// types. 2062bool Type::isAnyCharacterType() const { 2063 const auto *BT = dyn_cast<BuiltinType>(CanonicalType); 2064 if (!BT) return false; 2065 switch (BT->getKind()) { 2066 default: return false; 2067 case BuiltinType::Char_U: 2068 case BuiltinType::UChar: 2069 case BuiltinType::WChar_U: 2070 case BuiltinType::Char8: 2071 case BuiltinType::Char16: 2072 case BuiltinType::Char32: 2073 case BuiltinType::Char_S: 2074 case BuiltinType::SChar: 2075 case BuiltinType::WChar_S: 2076 return true; 2077 } 2078} 2079 2080/// isSignedIntegerType - Return true if this is an integer type that is 2081/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 2082/// an enum decl which has a signed representation 2083bool Type::isSignedIntegerType() const { 2084 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { 2085 return BT->getKind() >= BuiltinType::Char_S && 2086 BT->getKind() <= BuiltinType::Int128; 2087 } 2088 2089 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) { 2090 // Incomplete enum types are not treated as integer types. 2091 // FIXME: In C++, enum types are never integer types. 2092 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped()) 2093 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 2094 } 2095 2096 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType)) 2097 return IT->isSigned(); 2098 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType)) 2099 return IT->isSigned(); 2100 2101 return false; 2102} 2103 2104bool Type::isSignedIntegerOrEnumerationType() const { 2105 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { 2106 return BT->getKind() >= BuiltinType::Char_S && 2107 BT->getKind() <= BuiltinType::Int128; 2108 } 2109 2110 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) { 2111 if (ET->getDecl()->isComplete()) 2112 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 2113 } 2114 2115 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType)) 2116 return IT->isSigned(); 2117 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType)) 2118 return IT->isSigned(); 2119 2120 return false; 2121} 2122 2123bool Type::hasSignedIntegerRepresentation() const { 2124 if (const auto *VT = dyn_cast<VectorType>(CanonicalType)) 2125 return VT->getElementType()->isSignedIntegerOrEnumerationType(); 2126 else 2127 return isSignedIntegerOrEnumerationType(); 2128} 2129 2130/// isUnsignedIntegerType - Return true if this is an integer type that is 2131/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 2132/// decl which has an unsigned representation 2133bool Type::isUnsignedIntegerType() const { 2134 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { 2135 return BT->getKind() >= BuiltinType::Bool && 2136 BT->getKind() <= BuiltinType::UInt128; 2137 } 2138 2139 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) { 2140 // Incomplete enum types are not treated as integer types. 2141 // FIXME: In C++, enum types are never integer types. 2142 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped()) 2143 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 2144 } 2145 2146 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType)) 2147 return IT->isUnsigned(); 2148 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType)) 2149 return IT->isUnsigned(); 2150 2151 return false; 2152} 2153 2154bool Type::isUnsignedIntegerOrEnumerationType() const { 2155 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) { 2156 return BT->getKind() >= BuiltinType::Bool && 2157 BT->getKind() <= BuiltinType::UInt128; 2158 } 2159 2160 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) { 2161 if (ET->getDecl()->isComplete()) 2162 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 2163 } 2164 2165 if (const auto *IT = dyn_cast<BitIntType>(CanonicalType)) 2166 return IT->isUnsigned(); 2167 if (const auto *IT = dyn_cast<DependentBitIntType>(CanonicalType)) 2168 return IT->isUnsigned(); 2169 2170 return false; 2171} 2172 2173bool Type::hasUnsignedIntegerRepresentation() const { 2174 if (const auto *VT = dyn_cast<VectorType>(CanonicalType)) 2175 return VT->getElementType()->isUnsignedIntegerOrEnumerationType(); 2176 if (const auto *VT = dyn_cast<MatrixType>(CanonicalType)) 2177 return VT->getElementType()->isUnsignedIntegerOrEnumerationType(); 2178 if (CanonicalType->isSveVLSBuiltinType()) { 2179 const auto *VT = cast<BuiltinType>(CanonicalType); 2180 return VT->getKind() >= BuiltinType::SveUint8 && 2181 VT->getKind() <= BuiltinType::SveUint64; 2182 } 2183 return isUnsignedIntegerOrEnumerationType(); 2184} 2185 2186bool Type::isFloatingType() const { 2187 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2188 return BT->getKind() >= BuiltinType::Half && 2189 BT->getKind() <= BuiltinType::Ibm128; 2190 if (const auto *CT = dyn_cast<ComplexType>(CanonicalType)) 2191 return CT->getElementType()->isFloatingType(); 2192 return false; 2193} 2194 2195bool Type::hasFloatingRepresentation() const { 2196 if (const auto *VT = dyn_cast<VectorType>(CanonicalType)) 2197 return VT->getElementType()->isFloatingType(); 2198 if (const auto *MT = dyn_cast<MatrixType>(CanonicalType)) 2199 return MT->getElementType()->isFloatingType(); 2200 return isFloatingType(); 2201} 2202 2203bool Type::isRealFloatingType() const { 2204 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2205 return BT->isFloatingPoint(); 2206 return false; 2207} 2208 2209bool Type::isRealType() const { 2210 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2211 return BT->getKind() >= BuiltinType::Bool && 2212 BT->getKind() <= BuiltinType::Ibm128; 2213 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) 2214 return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped(); 2215 return isBitIntType(); 2216} 2217 2218bool Type::isArithmeticType() const { 2219 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) 2220 return BT->getKind() >= BuiltinType::Bool && 2221 BT->getKind() <= BuiltinType::Ibm128; 2222 if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) 2223 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 2224 // If a body isn't seen by the time we get here, return false. 2225 // 2226 // C++0x: Enumerations are not arithmetic types. For now, just return 2227 // false for scoped enumerations since that will disable any 2228 // unwanted implicit conversions. 2229 return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete(); 2230 return isa<ComplexType>(CanonicalType) || isBitIntType(); 2231} 2232 2233Type::ScalarTypeKind Type::getScalarTypeKind() const { 2234 assert(isScalarType()); 2235 2236 const Type *T = CanonicalType.getTypePtr(); 2237 if (const auto *BT = dyn_cast<BuiltinType>(T)) { 2238 if (BT->getKind() == BuiltinType::Bool) return STK_Bool; 2239 if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer; 2240 if (BT->isInteger()) return STK_Integral; 2241 if (BT->isFloatingPoint()) return STK_Floating; 2242 if (BT->isFixedPointType()) return STK_FixedPoint; 2243 llvm_unreachable("unknown scalar builtin type"); 2244 } else if (isa<PointerType>(T)) { 2245 return STK_CPointer; 2246 } else if (isa<BlockPointerType>(T)) { 2247 return STK_BlockPointer; 2248 } else if (isa<ObjCObjectPointerType>(T)) { 2249 return STK_ObjCObjectPointer; 2250 } else if (isa<MemberPointerType>(T)) { 2251 return STK_MemberPointer; 2252 } else if (isa<EnumType>(T)) { 2253 assert(cast<EnumType>(T)->getDecl()->isComplete()); 2254 return STK_Integral; 2255 } else if (const auto *CT = dyn_cast<ComplexType>(T)) { 2256 if (CT->getElementType()->isRealFloatingType()) 2257 return STK_FloatingComplex; 2258 return STK_IntegralComplex; 2259 } else if (isBitIntType()) { 2260 return STK_Integral; 2261 } 2262 2263 llvm_unreachable("unknown scalar type"); 2264} 2265 2266/// Determines whether the type is a C++ aggregate type or C 2267/// aggregate or union type. 2268/// 2269/// An aggregate type is an array or a class type (struct, union, or 2270/// class) that has no user-declared constructors, no private or 2271/// protected non-static data members, no base classes, and no virtual 2272/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 2273/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 2274/// includes union types. 2275bool Type::isAggregateType() const { 2276 if (const auto *Record = dyn_cast<RecordType>(CanonicalType)) { 2277 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl())) 2278 return ClassDecl->isAggregate(); 2279 2280 return true; 2281 } 2282 2283 return isa<ArrayType>(CanonicalType); 2284} 2285 2286/// isConstantSizeType - Return true if this is not a variable sized type, 2287/// according to the rules of C99 6.7.5p3. It is not legal to call this on 2288/// incomplete types or dependent types. 2289bool Type::isConstantSizeType() const { 2290 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 2291 assert(!isDependentType() && "This doesn't make sense for dependent types"); 2292 // The VAT must have a size, as it is known to be complete. 2293 return !isa<VariableArrayType>(CanonicalType); 2294} 2295 2296/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 2297/// - a type that can describe objects, but which lacks information needed to 2298/// determine its size. 2299bool Type::isIncompleteType(NamedDecl **Def) const { 2300 if (Def) 2301 *Def = nullptr; 2302 2303 switch (CanonicalType->getTypeClass()) { 2304 default: return false; 2305 case Builtin: 2306 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 2307 // be completed. 2308 return isVoidType(); 2309 case Enum: { 2310 EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl(); 2311 if (Def) 2312 *Def = EnumD; 2313 return !EnumD->isComplete(); 2314 } 2315 case Record: { 2316 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 2317 // forward declaration, but not a full definition (C99 6.2.5p22). 2318 RecordDecl *Rec = cast<RecordType>(CanonicalType)->getDecl(); 2319 if (Def) 2320 *Def = Rec; 2321 return !Rec->isCompleteDefinition(); 2322 } 2323 case ConstantArray: 2324 case VariableArray: 2325 // An array is incomplete if its element type is incomplete 2326 // (C++ [dcl.array]p1). 2327 // We don't handle dependent-sized arrays (dependent types are never treated 2328 // as incomplete). 2329 return cast<ArrayType>(CanonicalType)->getElementType() 2330 ->isIncompleteType(Def); 2331 case IncompleteArray: 2332 // An array of unknown size is an incomplete type (C99 6.2.5p22). 2333 return true; 2334 case MemberPointer: { 2335 // Member pointers in the MS ABI have special behavior in 2336 // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl 2337 // to indicate which inheritance model to use. 2338 auto *MPTy = cast<MemberPointerType>(CanonicalType); 2339 const Type *ClassTy = MPTy->getClass(); 2340 // Member pointers with dependent class types don't get special treatment. 2341 if (ClassTy->isDependentType()) 2342 return false; 2343 const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl(); 2344 ASTContext &Context = RD->getASTContext(); 2345 // Member pointers not in the MS ABI don't get special treatment. 2346 if (!Context.getTargetInfo().getCXXABI().isMicrosoft()) 2347 return false; 2348 // The inheritance attribute might only be present on the most recent 2349 // CXXRecordDecl, use that one. 2350 RD = RD->getMostRecentNonInjectedDecl(); 2351 // Nothing interesting to do if the inheritance attribute is already set. 2352 if (RD->hasAttr<MSInheritanceAttr>()) 2353 return false; 2354 return true; 2355 } 2356 case ObjCObject: 2357 return cast<ObjCObjectType>(CanonicalType)->getBaseType() 2358 ->isIncompleteType(Def); 2359 case ObjCInterface: { 2360 // ObjC interfaces are incomplete if they are @class, not @interface. 2361 ObjCInterfaceDecl *Interface 2362 = cast<ObjCInterfaceType>(CanonicalType)->getDecl(); 2363 if (Def) 2364 *Def = Interface; 2365 return !Interface->hasDefinition(); 2366 } 2367 } 2368} 2369 2370bool Type::isSizelessBuiltinType() const { 2371 if (isSizelessVectorType()) 2372 return true; 2373 2374 if (const BuiltinType *BT = getAs<BuiltinType>()) { 2375 switch (BT->getKind()) { 2376 // WebAssembly reference types 2377#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 2378#include "clang/Basic/WebAssemblyReferenceTypes.def" 2379 return true; 2380 default: 2381 return false; 2382 } 2383 } 2384 return false; 2385} 2386 2387bool Type::isWebAssemblyExternrefType() const { 2388 if (const auto *BT = getAs<BuiltinType>()) 2389 return BT->getKind() == BuiltinType::WasmExternRef; 2390 return false; 2391} 2392 2393bool Type::isWebAssemblyTableType() const { 2394 if (const auto *ATy = dyn_cast<ArrayType>(this)) 2395 return ATy->getElementType().isWebAssemblyReferenceType(); 2396 2397 if (const auto *PTy = dyn_cast<PointerType>(this)) 2398 return PTy->getPointeeType().isWebAssemblyReferenceType(); 2399 2400 return false; 2401} 2402 2403bool Type::isSizelessType() const { return isSizelessBuiltinType(); } 2404 2405bool Type::isSizelessVectorType() const { 2406 return isSVESizelessBuiltinType() || isRVVSizelessBuiltinType(); 2407} 2408 2409bool Type::isSVESizelessBuiltinType() const { 2410 if (const BuiltinType *BT = getAs<BuiltinType>()) { 2411 switch (BT->getKind()) { 2412 // SVE Types 2413#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 2414#include "clang/Basic/AArch64SVEACLETypes.def" 2415 return true; 2416 default: 2417 return false; 2418 } 2419 } 2420 return false; 2421} 2422 2423bool Type::isRVVSizelessBuiltinType() const { 2424 if (const BuiltinType *BT = getAs<BuiltinType>()) { 2425 switch (BT->getKind()) { 2426#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 2427#include "clang/Basic/RISCVVTypes.def" 2428 return true; 2429 default: 2430 return false; 2431 } 2432 } 2433 return false; 2434} 2435 2436bool Type::isSveVLSBuiltinType() const { 2437 if (const BuiltinType *BT = getAs<BuiltinType>()) { 2438 switch (BT->getKind()) { 2439 case BuiltinType::SveInt8: 2440 case BuiltinType::SveInt16: 2441 case BuiltinType::SveInt32: 2442 case BuiltinType::SveInt64: 2443 case BuiltinType::SveUint8: 2444 case BuiltinType::SveUint16: 2445 case BuiltinType::SveUint32: 2446 case BuiltinType::SveUint64: 2447 case BuiltinType::SveFloat16: 2448 case BuiltinType::SveFloat32: 2449 case BuiltinType::SveFloat64: 2450 case BuiltinType::SveBFloat16: 2451 case BuiltinType::SveBool: 2452 case BuiltinType::SveBoolx2: 2453 case BuiltinType::SveBoolx4: 2454 return true; 2455 default: 2456 return false; 2457 } 2458 } 2459 return false; 2460} 2461 2462QualType Type::getSveEltType(const ASTContext &Ctx) const { 2463 assert(isSveVLSBuiltinType() && "unsupported type!"); 2464 2465 const BuiltinType *BTy = castAs<BuiltinType>(); 2466 if (BTy->getKind() == BuiltinType::SveBool) 2467 // Represent predicates as i8 rather than i1 to avoid any layout issues. 2468 // The type is bitcasted to a scalable predicate type when casting between 2469 // scalable and fixed-length vectors. 2470 return Ctx.UnsignedCharTy; 2471 else 2472 return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType; 2473} 2474 2475bool Type::isRVVVLSBuiltinType() const { 2476 if (const BuiltinType *BT = getAs<BuiltinType>()) { 2477 switch (BT->getKind()) { 2478#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \ 2479 IsFP, IsBF) \ 2480 case BuiltinType::Id: \ 2481 return NF == 1; 2482#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \ 2483 case BuiltinType::Id: \ 2484 return true; 2485#include "clang/Basic/RISCVVTypes.def" 2486 default: 2487 return false; 2488 } 2489 } 2490 return false; 2491} 2492 2493QualType Type::getRVVEltType(const ASTContext &Ctx) const { 2494 assert(isRVVVLSBuiltinType() && "unsupported type!"); 2495 2496 const BuiltinType *BTy = castAs<BuiltinType>(); 2497 2498 switch (BTy->getKind()) { 2499#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \ 2500 case BuiltinType::Id: \ 2501 return Ctx.UnsignedCharTy; 2502 default: 2503 return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType; 2504#include "clang/Basic/RISCVVTypes.def" 2505 } 2506 2507 llvm_unreachable("Unhandled type"); 2508} 2509 2510bool QualType::isPODType(const ASTContext &Context) const { 2511 // C++11 has a more relaxed definition of POD. 2512 if (Context.getLangOpts().CPlusPlus11) 2513 return isCXX11PODType(Context); 2514 2515 return isCXX98PODType(Context); 2516} 2517 2518bool QualType::isCXX98PODType(const ASTContext &Context) const { 2519 // The compiler shouldn't query this for incomplete types, but the user might. 2520 // We return false for that case. Except for incomplete arrays of PODs, which 2521 // are PODs according to the standard. 2522 if (isNull()) 2523 return false; 2524 2525 if ((*this)->isIncompleteArrayType()) 2526 return Context.getBaseElementType(*this).isCXX98PODType(Context); 2527 2528 if ((*this)->isIncompleteType()) 2529 return false; 2530 2531 if (hasNonTrivialObjCLifetime()) 2532 return false; 2533 2534 QualType CanonicalType = getTypePtr()->CanonicalType; 2535 switch (CanonicalType->getTypeClass()) { 2536 // Everything not explicitly mentioned is not POD. 2537 default: return false; 2538 case Type::VariableArray: 2539 case Type::ConstantArray: 2540 // IncompleteArray is handled above. 2541 return Context.getBaseElementType(*this).isCXX98PODType(Context); 2542 2543 case Type::ObjCObjectPointer: 2544 case Type::BlockPointer: 2545 case Type::Builtin: 2546 case Type::Complex: 2547 case Type::Pointer: 2548 case Type::MemberPointer: 2549 case Type::Vector: 2550 case Type::ExtVector: 2551 case Type::BitInt: 2552 return true; 2553 2554 case Type::Enum: 2555 return true; 2556 2557 case Type::Record: 2558 if (const auto *ClassDecl = 2559 dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl())) 2560 return ClassDecl->isPOD(); 2561 2562 // C struct/union is POD. 2563 return true; 2564 } 2565} 2566 2567bool QualType::isTrivialType(const ASTContext &Context) const { 2568 // The compiler shouldn't query this for incomplete types, but the user might. 2569 // We return false for that case. Except for incomplete arrays of PODs, which 2570 // are PODs according to the standard. 2571 if (isNull()) 2572 return false; 2573 2574 if ((*this)->isArrayType()) 2575 return Context.getBaseElementType(*this).isTrivialType(Context); 2576 2577 if ((*this)->isSizelessBuiltinType()) 2578 return true; 2579 2580 // Return false for incomplete types after skipping any incomplete array 2581 // types which are expressly allowed by the standard and thus our API. 2582 if ((*this)->isIncompleteType()) 2583 return false; 2584 2585 if (hasNonTrivialObjCLifetime()) 2586 return false; 2587 2588 QualType CanonicalType = getTypePtr()->CanonicalType; 2589 if (CanonicalType->isDependentType()) 2590 return false; 2591 2592 // C++0x [basic.types]p9: 2593 // Scalar types, trivial class types, arrays of such types, and 2594 // cv-qualified versions of these types are collectively called trivial 2595 // types. 2596 2597 // As an extension, Clang treats vector types as Scalar types. 2598 if (CanonicalType->isScalarType() || CanonicalType->isVectorType()) 2599 return true; 2600 if (const auto *RT = CanonicalType->getAs<RecordType>()) { 2601 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 2602 // C++20 [class]p6: 2603 // A trivial class is a class that is trivially copyable, and 2604 // has one or more eligible default constructors such that each is 2605 // trivial. 2606 // FIXME: We should merge this definition of triviality into 2607 // CXXRecordDecl::isTrivial. Currently it computes the wrong thing. 2608 return ClassDecl->hasTrivialDefaultConstructor() && 2609 !ClassDecl->hasNonTrivialDefaultConstructor() && 2610 ClassDecl->isTriviallyCopyable(); 2611 } 2612 2613 return true; 2614 } 2615 2616 // No other types can match. 2617 return false; 2618} 2619 2620static bool isTriviallyCopyableTypeImpl(const QualType &type, 2621 const ASTContext &Context, 2622 bool IsCopyConstructible) { 2623 if (type->isArrayType()) 2624 return isTriviallyCopyableTypeImpl(Context.getBaseElementType(type), 2625 Context, IsCopyConstructible); 2626 2627 if (type.hasNonTrivialObjCLifetime()) 2628 return false; 2629 2630 // C++11 [basic.types]p9 - See Core 2094 2631 // Scalar types, trivially copyable class types, arrays of such types, and 2632 // cv-qualified versions of these types are collectively 2633 // called trivially copy constructible types. 2634 2635 QualType CanonicalType = type.getCanonicalType(); 2636 if (CanonicalType->isDependentType()) 2637 return false; 2638 2639 if (CanonicalType->isSizelessBuiltinType()) 2640 return true; 2641 2642 // Return false for incomplete types after skipping any incomplete array types 2643 // which are expressly allowed by the standard and thus our API. 2644 if (CanonicalType->isIncompleteType()) 2645 return false; 2646 2647 // As an extension, Clang treats vector types as Scalar types. 2648 if (CanonicalType->isScalarType() || CanonicalType->isVectorType()) 2649 return true; 2650 2651 if (const auto *RT = CanonicalType->getAs<RecordType>()) { 2652 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 2653 if (IsCopyConstructible) { 2654 return ClassDecl->isTriviallyCopyConstructible(); 2655 } else { 2656 return ClassDecl->isTriviallyCopyable(); 2657 } 2658 } 2659 return true; 2660 } 2661 // No other types can match. 2662 return false; 2663} 2664 2665bool QualType::isTriviallyCopyableType(const ASTContext &Context) const { 2666 return isTriviallyCopyableTypeImpl(*this, Context, 2667 /*IsCopyConstructible=*/false); 2668} 2669 2670bool QualType::isTriviallyCopyConstructibleType( 2671 const ASTContext &Context) const { 2672 return isTriviallyCopyableTypeImpl(*this, Context, 2673 /*IsCopyConstructible=*/true); 2674} 2675 2676bool QualType::isTriviallyRelocatableType(const ASTContext &Context) const { 2677 QualType BaseElementType = Context.getBaseElementType(*this); 2678 2679 if (BaseElementType->isIncompleteType()) { 2680 return false; 2681 } else if (!BaseElementType->isObjectType()) { 2682 return false; 2683 } else if (const auto *RD = BaseElementType->getAsRecordDecl()) { 2684 return RD->canPassInRegisters(); 2685 } else { 2686 switch (isNonTrivialToPrimitiveDestructiveMove()) { 2687 case PCK_Trivial: 2688 return !isDestructedType(); 2689 case PCK_ARCStrong: 2690 return true; 2691 default: 2692 return false; 2693 } 2694 } 2695} 2696 2697static bool 2698HasNonDeletedDefaultedEqualityComparison(const CXXRecordDecl *Decl) { 2699 if (Decl->isUnion()) 2700 return false; 2701 if (Decl->isLambda()) 2702 return Decl->isCapturelessLambda(); 2703 2704 auto IsDefaultedOperatorEqualEqual = [&](const FunctionDecl *Function) { 2705 return Function->getOverloadedOperator() == 2706 OverloadedOperatorKind::OO_EqualEqual && 2707 Function->isDefaulted() && Function->getNumParams() > 0 && 2708 (Function->getParamDecl(0)->getType()->isReferenceType() || 2709 Decl->isTriviallyCopyable()); 2710 }; 2711 2712 if (llvm::none_of(Decl->methods(), IsDefaultedOperatorEqualEqual) && 2713 llvm::none_of(Decl->friends(), [&](const FriendDecl *Friend) { 2714 if (NamedDecl *ND = Friend->getFriendDecl()) { 2715 return ND->isFunctionOrFunctionTemplate() && 2716 IsDefaultedOperatorEqualEqual(ND->getAsFunction()); 2717 } 2718 return false; 2719 })) 2720 return false; 2721 2722 return llvm::all_of(Decl->bases(), 2723 [](const CXXBaseSpecifier &BS) { 2724 if (const auto *RD = BS.getType()->getAsCXXRecordDecl()) 2725 return HasNonDeletedDefaultedEqualityComparison(RD); 2726 return true; 2727 }) && 2728 llvm::all_of(Decl->fields(), [](const FieldDecl *FD) { 2729 auto Type = FD->getType(); 2730 if (Type->isArrayType()) 2731 Type = Type->getBaseElementTypeUnsafe()->getCanonicalTypeUnqualified(); 2732 2733 if (Type->isReferenceType() || Type->isEnumeralType()) 2734 return false; 2735 if (const auto *RD = Type->getAsCXXRecordDecl()) 2736 return HasNonDeletedDefaultedEqualityComparison(RD); 2737 return true; 2738 }); 2739} 2740 2741bool QualType::isTriviallyEqualityComparableType( 2742 const ASTContext &Context) const { 2743 QualType CanonicalType = getCanonicalType(); 2744 if (CanonicalType->isIncompleteType() || CanonicalType->isDependentType() || 2745 CanonicalType->isEnumeralType() || CanonicalType->isArrayType()) 2746 return false; 2747 2748 if (const auto *RD = CanonicalType->getAsCXXRecordDecl()) { 2749 if (!HasNonDeletedDefaultedEqualityComparison(RD)) 2750 return false; 2751 } 2752 2753 return Context.hasUniqueObjectRepresentations( 2754 CanonicalType, /*CheckIfTriviallyCopyable=*/false); 2755} 2756 2757bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const { 2758 return !Context.getLangOpts().ObjCAutoRefCount && 2759 Context.getLangOpts().ObjCWeak && 2760 getObjCLifetime() != Qualifiers::OCL_Weak; 2761} 2762 2763bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD) { 2764 return RD->hasNonTrivialToPrimitiveDefaultInitializeCUnion(); 2765} 2766 2767bool QualType::hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD) { 2768 return RD->hasNonTrivialToPrimitiveDestructCUnion(); 2769} 2770 2771bool QualType::hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD) { 2772 return RD->hasNonTrivialToPrimitiveCopyCUnion(); 2773} 2774 2775bool QualType::isWebAssemblyReferenceType() const { 2776 return isWebAssemblyExternrefType() || isWebAssemblyFuncrefType(); 2777} 2778 2779bool QualType::isWebAssemblyExternrefType() const { 2780 return getTypePtr()->isWebAssemblyExternrefType(); 2781} 2782 2783bool QualType::isWebAssemblyFuncrefType() const { 2784 return getTypePtr()->isFunctionPointerType() && 2785 getAddressSpace() == LangAS::wasm_funcref; 2786} 2787 2788QualType::PrimitiveDefaultInitializeKind 2789QualType::isNonTrivialToPrimitiveDefaultInitialize() const { 2790 if (const auto *RT = 2791 getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>()) 2792 if (RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) 2793 return PDIK_Struct; 2794 2795 switch (getQualifiers().getObjCLifetime()) { 2796 case Qualifiers::OCL_Strong: 2797 return PDIK_ARCStrong; 2798 case Qualifiers::OCL_Weak: 2799 return PDIK_ARCWeak; 2800 default: 2801 return PDIK_Trivial; 2802 } 2803} 2804 2805QualType::PrimitiveCopyKind QualType::isNonTrivialToPrimitiveCopy() const { 2806 if (const auto *RT = 2807 getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>()) 2808 if (RT->getDecl()->isNonTrivialToPrimitiveCopy()) 2809 return PCK_Struct; 2810 2811 Qualifiers Qs = getQualifiers(); 2812 switch (Qs.getObjCLifetime()) { 2813 case Qualifiers::OCL_Strong: 2814 return PCK_ARCStrong; 2815 case Qualifiers::OCL_Weak: 2816 return PCK_ARCWeak; 2817 default: 2818 return Qs.hasVolatile() ? PCK_VolatileTrivial : PCK_Trivial; 2819 } 2820} 2821 2822QualType::PrimitiveCopyKind 2823QualType::isNonTrivialToPrimitiveDestructiveMove() const { 2824 return isNonTrivialToPrimitiveCopy(); 2825} 2826 2827bool Type::isLiteralType(const ASTContext &Ctx) const { 2828 if (isDependentType()) 2829 return false; 2830 2831 // C++1y [basic.types]p10: 2832 // A type is a literal type if it is: 2833 // -- cv void; or 2834 if (Ctx.getLangOpts().CPlusPlus14 && isVoidType()) 2835 return true; 2836 2837 // C++11 [basic.types]p10: 2838 // A type is a literal type if it is: 2839 // [...] 2840 // -- an array of literal type other than an array of runtime bound; or 2841 if (isVariableArrayType()) 2842 return false; 2843 const Type *BaseTy = getBaseElementTypeUnsafe(); 2844 assert(BaseTy && "NULL element type"); 2845 2846 // Return false for incomplete types after skipping any incomplete array 2847 // types; those are expressly allowed by the standard and thus our API. 2848 if (BaseTy->isIncompleteType()) 2849 return false; 2850 2851 // C++11 [basic.types]p10: 2852 // A type is a literal type if it is: 2853 // -- a scalar type; or 2854 // As an extension, Clang treats vector types and complex types as 2855 // literal types. 2856 if (BaseTy->isScalarType() || BaseTy->isVectorType() || 2857 BaseTy->isAnyComplexType()) 2858 return true; 2859 // -- a reference type; or 2860 if (BaseTy->isReferenceType()) 2861 return true; 2862 // -- a class type that has all of the following properties: 2863 if (const auto *RT = BaseTy->getAs<RecordType>()) { 2864 // -- a trivial destructor, 2865 // -- every constructor call and full-expression in the 2866 // brace-or-equal-initializers for non-static data members (if any) 2867 // is a constant expression, 2868 // -- it is an aggregate type or has at least one constexpr 2869 // constructor or constructor template that is not a copy or move 2870 // constructor, and 2871 // -- all non-static data members and base classes of literal types 2872 // 2873 // We resolve DR1361 by ignoring the second bullet. 2874 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) 2875 return ClassDecl->isLiteral(); 2876 2877 return true; 2878 } 2879 2880 // We treat _Atomic T as a literal type if T is a literal type. 2881 if (const auto *AT = BaseTy->getAs<AtomicType>()) 2882 return AT->getValueType()->isLiteralType(Ctx); 2883 2884 // If this type hasn't been deduced yet, then conservatively assume that 2885 // it'll work out to be a literal type. 2886 if (isa<AutoType>(BaseTy->getCanonicalTypeInternal())) 2887 return true; 2888 2889 return false; 2890} 2891 2892bool Type::isStructuralType() const { 2893 // C++20 [temp.param]p6: 2894 // A structural type is one of the following: 2895 // -- a scalar type; or 2896 // -- a vector type [Clang extension]; or 2897 if (isScalarType() || isVectorType()) 2898 return true; 2899 // -- an lvalue reference type; or 2900 if (isLValueReferenceType()) 2901 return true; 2902 // -- a literal class type [...under some conditions] 2903 if (const CXXRecordDecl *RD = getAsCXXRecordDecl()) 2904 return RD->isStructural(); 2905 return false; 2906} 2907 2908bool Type::isStandardLayoutType() const { 2909 if (isDependentType()) 2910 return false; 2911 2912 // C++0x [basic.types]p9: 2913 // Scalar types, standard-layout class types, arrays of such types, and 2914 // cv-qualified versions of these types are collectively called 2915 // standard-layout types. 2916 const Type *BaseTy = getBaseElementTypeUnsafe(); 2917 assert(BaseTy && "NULL element type"); 2918 2919 // Return false for incomplete types after skipping any incomplete array 2920 // types which are expressly allowed by the standard and thus our API. 2921 if (BaseTy->isIncompleteType()) 2922 return false; 2923 2924 // As an extension, Clang treats vector types as Scalar types. 2925 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true; 2926 if (const auto *RT = BaseTy->getAs<RecordType>()) { 2927 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) 2928 if (!ClassDecl->isStandardLayout()) 2929 return false; 2930 2931 // Default to 'true' for non-C++ class types. 2932 // FIXME: This is a bit dubious, but plain C structs should trivially meet 2933 // all the requirements of standard layout classes. 2934 return true; 2935 } 2936 2937 // No other types can match. 2938 return false; 2939} 2940 2941// This is effectively the intersection of isTrivialType and 2942// isStandardLayoutType. We implement it directly to avoid redundant 2943// conversions from a type to a CXXRecordDecl. 2944bool QualType::isCXX11PODType(const ASTContext &Context) const { 2945 const Type *ty = getTypePtr(); 2946 if (ty->isDependentType()) 2947 return false; 2948 2949 if (hasNonTrivialObjCLifetime()) 2950 return false; 2951 2952 // C++11 [basic.types]p9: 2953 // Scalar types, POD classes, arrays of such types, and cv-qualified 2954 // versions of these types are collectively called trivial types. 2955 const Type *BaseTy = ty->getBaseElementTypeUnsafe(); 2956 assert(BaseTy && "NULL element type"); 2957 2958 if (BaseTy->isSizelessBuiltinType()) 2959 return true; 2960 2961 // Return false for incomplete types after skipping any incomplete array 2962 // types which are expressly allowed by the standard and thus our API. 2963 if (BaseTy->isIncompleteType()) 2964 return false; 2965 2966 // As an extension, Clang treats vector types as Scalar types. 2967 if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true; 2968 if (const auto *RT = BaseTy->getAs<RecordType>()) { 2969 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 2970 // C++11 [class]p10: 2971 // A POD struct is a non-union class that is both a trivial class [...] 2972 if (!ClassDecl->isTrivial()) return false; 2973 2974 // C++11 [class]p10: 2975 // A POD struct is a non-union class that is both a trivial class and 2976 // a standard-layout class [...] 2977 if (!ClassDecl->isStandardLayout()) return false; 2978 2979 // C++11 [class]p10: 2980 // A POD struct is a non-union class that is both a trivial class and 2981 // a standard-layout class, and has no non-static data members of type 2982 // non-POD struct, non-POD union (or array of such types). [...] 2983 // 2984 // We don't directly query the recursive aspect as the requirements for 2985 // both standard-layout classes and trivial classes apply recursively 2986 // already. 2987 } 2988 2989 return true; 2990 } 2991 2992 // No other types can match. 2993 return false; 2994} 2995 2996bool Type::isNothrowT() const { 2997 if (const auto *RD = getAsCXXRecordDecl()) { 2998 IdentifierInfo *II = RD->getIdentifier(); 2999 if (II && II->isStr("nothrow_t") && RD->isInStdNamespace()) 3000 return true; 3001 } 3002 return false; 3003} 3004 3005bool Type::isAlignValT() const { 3006 if (const auto *ET = getAs<EnumType>()) { 3007 IdentifierInfo *II = ET->getDecl()->getIdentifier(); 3008 if (II && II->isStr("align_val_t") && ET->getDecl()->isInStdNamespace()) 3009 return true; 3010 } 3011 return false; 3012} 3013 3014bool Type::isStdByteType() const { 3015 if (const auto *ET = getAs<EnumType>()) { 3016 IdentifierInfo *II = ET->getDecl()->getIdentifier(); 3017 if (II && II->isStr("byte") && ET->getDecl()->isInStdNamespace()) 3018 return true; 3019 } 3020 return false; 3021} 3022 3023bool Type::isSpecifierType() const { 3024 // Note that this intentionally does not use the canonical type. 3025 switch (getTypeClass()) { 3026 case Builtin: 3027 case Record: 3028 case Enum: 3029 case Typedef: 3030 case Complex: 3031 case TypeOfExpr: 3032 case TypeOf: 3033 case TemplateTypeParm: 3034 case SubstTemplateTypeParm: 3035 case TemplateSpecialization: 3036 case Elaborated: 3037 case DependentName: 3038 case DependentTemplateSpecialization: 3039 case ObjCInterface: 3040 case ObjCObject: 3041 return true; 3042 default: 3043 return false; 3044 } 3045} 3046 3047ElaboratedTypeKeyword 3048TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) { 3049 switch (TypeSpec) { 3050 default: 3051 return ElaboratedTypeKeyword::None; 3052 case TST_typename: 3053 return ElaboratedTypeKeyword::Typename; 3054 case TST_class: 3055 return ElaboratedTypeKeyword::Class; 3056 case TST_struct: 3057 return ElaboratedTypeKeyword::Struct; 3058 case TST_interface: 3059 return ElaboratedTypeKeyword::Interface; 3060 case TST_union: 3061 return ElaboratedTypeKeyword::Union; 3062 case TST_enum: 3063 return ElaboratedTypeKeyword::Enum; 3064 } 3065} 3066 3067TagTypeKind 3068TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) { 3069 switch(TypeSpec) { 3070 case TST_class: 3071 return TagTypeKind::Class; 3072 case TST_struct: 3073 return TagTypeKind::Struct; 3074 case TST_interface: 3075 return TagTypeKind::Interface; 3076 case TST_union: 3077 return TagTypeKind::Union; 3078 case TST_enum: 3079 return TagTypeKind::Enum; 3080 } 3081 3082 llvm_unreachable("Type specifier is not a tag type kind."); 3083} 3084 3085ElaboratedTypeKeyword 3086TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) { 3087 switch (Kind) { 3088 case TagTypeKind::Class: 3089 return ElaboratedTypeKeyword::Class; 3090 case TagTypeKind::Struct: 3091 return ElaboratedTypeKeyword::Struct; 3092 case TagTypeKind::Interface: 3093 return ElaboratedTypeKeyword::Interface; 3094 case TagTypeKind::Union: 3095 return ElaboratedTypeKeyword::Union; 3096 case TagTypeKind::Enum: 3097 return ElaboratedTypeKeyword::Enum; 3098 } 3099 llvm_unreachable("Unknown tag type kind."); 3100} 3101 3102TagTypeKind 3103TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) { 3104 switch (Keyword) { 3105 case ElaboratedTypeKeyword::Class: 3106 return TagTypeKind::Class; 3107 case ElaboratedTypeKeyword::Struct: 3108 return TagTypeKind::Struct; 3109 case ElaboratedTypeKeyword::Interface: 3110 return TagTypeKind::Interface; 3111 case ElaboratedTypeKeyword::Union: 3112 return TagTypeKind::Union; 3113 case ElaboratedTypeKeyword::Enum: 3114 return TagTypeKind::Enum; 3115 case ElaboratedTypeKeyword::None: // Fall through. 3116 case ElaboratedTypeKeyword::Typename: 3117 llvm_unreachable("Elaborated type keyword is not a tag type kind."); 3118 } 3119 llvm_unreachable("Unknown elaborated type keyword."); 3120} 3121 3122bool 3123TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) { 3124 switch (Keyword) { 3125 case ElaboratedTypeKeyword::None: 3126 case ElaboratedTypeKeyword::Typename: 3127 return false; 3128 case ElaboratedTypeKeyword::Class: 3129 case ElaboratedTypeKeyword::Struct: 3130 case ElaboratedTypeKeyword::Interface: 3131 case ElaboratedTypeKeyword::Union: 3132 case ElaboratedTypeKeyword::Enum: 3133 return true; 3134 } 3135 llvm_unreachable("Unknown elaborated type keyword."); 3136} 3137 3138StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) { 3139 switch (Keyword) { 3140 case ElaboratedTypeKeyword::None: 3141 return {}; 3142 case ElaboratedTypeKeyword::Typename: 3143 return "typename"; 3144 case ElaboratedTypeKeyword::Class: 3145 return "class"; 3146 case ElaboratedTypeKeyword::Struct: 3147 return "struct"; 3148 case ElaboratedTypeKeyword::Interface: 3149 return "__interface"; 3150 case ElaboratedTypeKeyword::Union: 3151 return "union"; 3152 case ElaboratedTypeKeyword::Enum: 3153 return "enum"; 3154 } 3155 3156 llvm_unreachable("Unknown elaborated type keyword."); 3157} 3158 3159DependentTemplateSpecializationType::DependentTemplateSpecializationType( 3160 ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, 3161 const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args, QualType Canon) 3162 : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon, 3163 TypeDependence::DependentInstantiation | 3164 (NNS ? toTypeDependence(NNS->getDependence()) 3165 : TypeDependence::None)), 3166 NNS(NNS), Name(Name) { 3167 DependentTemplateSpecializationTypeBits.NumArgs = Args.size(); 3168 assert((!NNS || NNS->isDependent()) && 3169 "DependentTemplateSpecializatonType requires dependent qualifier"); 3170 auto *ArgBuffer = const_cast<TemplateArgument *>(template_arguments().data()); 3171 for (const TemplateArgument &Arg : Args) { 3172 addDependence(toTypeDependence(Arg.getDependence() & 3173 TemplateArgumentDependence::UnexpandedPack)); 3174 3175 new (ArgBuffer++) TemplateArgument(Arg); 3176 } 3177} 3178 3179void 3180DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 3181 const ASTContext &Context, 3182 ElaboratedTypeKeyword Keyword, 3183 NestedNameSpecifier *Qualifier, 3184 const IdentifierInfo *Name, 3185 ArrayRef<TemplateArgument> Args) { 3186 ID.AddInteger(llvm::to_underlying(Keyword)); 3187 ID.AddPointer(Qualifier); 3188 ID.AddPointer(Name); 3189 for (const TemplateArgument &Arg : Args) 3190 Arg.Profile(ID, Context); 3191} 3192 3193bool Type::isElaboratedTypeSpecifier() const { 3194 ElaboratedTypeKeyword Keyword; 3195 if (const auto *Elab = dyn_cast<ElaboratedType>(this)) 3196 Keyword = Elab->getKeyword(); 3197 else if (const auto *DepName = dyn_cast<DependentNameType>(this)) 3198 Keyword = DepName->getKeyword(); 3199 else if (const auto *DepTST = 3200 dyn_cast<DependentTemplateSpecializationType>(this)) 3201 Keyword = DepTST->getKeyword(); 3202 else 3203 return false; 3204 3205 return TypeWithKeyword::KeywordIsTagTypeKind(Keyword); 3206} 3207 3208const char *Type::getTypeClassName() const { 3209 switch (TypeBits.TC) { 3210#define ABSTRACT_TYPE(Derived, Base) 3211#define TYPE(Derived, Base) case Derived: return #Derived; 3212#include "clang/AST/TypeNodes.inc" 3213 } 3214 3215 llvm_unreachable("Invalid type class."); 3216} 3217 3218StringRef BuiltinType::getName(const PrintingPolicy &Policy) const { 3219 switch (getKind()) { 3220 case Void: 3221 return "void"; 3222 case Bool: 3223 return Policy.Bool ? "bool" : "_Bool"; 3224 case Char_S: 3225 return "char"; 3226 case Char_U: 3227 return "char"; 3228 case SChar: 3229 return "signed char"; 3230 case Short: 3231 return "short"; 3232 case Int: 3233 return "int"; 3234 case Long: 3235 return "long"; 3236 case LongLong: 3237 return "long long"; 3238 case Int128: 3239 return "__int128"; 3240 case UChar: 3241 return "unsigned char"; 3242 case UShort: 3243 return "unsigned short"; 3244 case UInt: 3245 return "unsigned int"; 3246 case ULong: 3247 return "unsigned long"; 3248 case ULongLong: 3249 return "unsigned long long"; 3250 case UInt128: 3251 return "unsigned __int128"; 3252 case Half: 3253 return Policy.Half ? "half" : "__fp16"; 3254 case BFloat16: 3255 return "__bf16"; 3256 case Float: 3257 return "float"; 3258 case Double: 3259 return "double"; 3260 case LongDouble: 3261 return "long double"; 3262 case ShortAccum: 3263 return "short _Accum"; 3264 case Accum: 3265 return "_Accum"; 3266 case LongAccum: 3267 return "long _Accum"; 3268 case UShortAccum: 3269 return "unsigned short _Accum"; 3270 case UAccum: 3271 return "unsigned _Accum"; 3272 case ULongAccum: 3273 return "unsigned long _Accum"; 3274 case BuiltinType::ShortFract: 3275 return "short _Fract"; 3276 case BuiltinType::Fract: 3277 return "_Fract"; 3278 case BuiltinType::LongFract: 3279 return "long _Fract"; 3280 case BuiltinType::UShortFract: 3281 return "unsigned short _Fract"; 3282 case BuiltinType::UFract: 3283 return "unsigned _Fract"; 3284 case BuiltinType::ULongFract: 3285 return "unsigned long _Fract"; 3286 case BuiltinType::SatShortAccum: 3287 return "_Sat short _Accum"; 3288 case BuiltinType::SatAccum: 3289 return "_Sat _Accum"; 3290 case BuiltinType::SatLongAccum: 3291 return "_Sat long _Accum"; 3292 case BuiltinType::SatUShortAccum: 3293 return "_Sat unsigned short _Accum"; 3294 case BuiltinType::SatUAccum: 3295 return "_Sat unsigned _Accum"; 3296 case BuiltinType::SatULongAccum: 3297 return "_Sat unsigned long _Accum"; 3298 case BuiltinType::SatShortFract: 3299 return "_Sat short _Fract"; 3300 case BuiltinType::SatFract: 3301 return "_Sat _Fract"; 3302 case BuiltinType::SatLongFract: 3303 return "_Sat long _Fract"; 3304 case BuiltinType::SatUShortFract: 3305 return "_Sat unsigned short _Fract"; 3306 case BuiltinType::SatUFract: 3307 return "_Sat unsigned _Fract"; 3308 case BuiltinType::SatULongFract: 3309 return "_Sat unsigned long _Fract"; 3310 case Float16: 3311 return "_Float16"; 3312 case Float128: 3313 return "__float128"; 3314 case Ibm128: 3315 return "__ibm128"; 3316 case WChar_S: 3317 case WChar_U: 3318 return Policy.MSWChar ? "__wchar_t" : "wchar_t"; 3319 case Char8: 3320 return "char8_t"; 3321 case Char16: 3322 return "char16_t"; 3323 case Char32: 3324 return "char32_t"; 3325 case NullPtr: 3326 return Policy.NullptrTypeInNamespace ? "std::nullptr_t" : "nullptr_t"; 3327 case Overload: 3328 return "<overloaded function type>"; 3329 case BoundMember: 3330 return "<bound member function type>"; 3331 case PseudoObject: 3332 return "<pseudo-object type>"; 3333 case Dependent: 3334 return "<dependent type>"; 3335 case UnknownAny: 3336 return "<unknown type>"; 3337 case ARCUnbridgedCast: 3338 return "<ARC unbridged cast type>"; 3339 case BuiltinFn: 3340 return "<builtin fn type>"; 3341 case ObjCId: 3342 return "id"; 3343 case ObjCClass: 3344 return "Class"; 3345 case ObjCSel: 3346 return "SEL"; 3347#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 3348 case Id: \ 3349 return "__" #Access " " #ImgType "_t"; 3350#include "clang/Basic/OpenCLImageTypes.def" 3351 case OCLSampler: 3352 return "sampler_t"; 3353 case OCLEvent: 3354 return "event_t"; 3355 case OCLClkEvent: 3356 return "clk_event_t"; 3357 case OCLQueue: 3358 return "queue_t"; 3359 case OCLReserveID: 3360 return "reserve_id_t"; 3361 case IncompleteMatrixIdx: 3362 return "<incomplete matrix index type>"; 3363 case OMPArraySection: 3364 return "<OpenMP array section type>"; 3365 case OMPArrayShaping: 3366 return "<OpenMP array shaping type>"; 3367 case OMPIterator: 3368 return "<OpenMP iterator type>"; 3369#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 3370 case Id: \ 3371 return #ExtType; 3372#include "clang/Basic/OpenCLExtensionTypes.def" 3373#define SVE_TYPE(Name, Id, SingletonId) \ 3374 case Id: \ 3375 return Name; 3376#include "clang/Basic/AArch64SVEACLETypes.def" 3377#define PPC_VECTOR_TYPE(Name, Id, Size) \ 3378 case Id: \ 3379 return #Name; 3380#include "clang/Basic/PPCTypes.def" 3381#define RVV_TYPE(Name, Id, SingletonId) \ 3382 case Id: \ 3383 return Name; 3384#include "clang/Basic/RISCVVTypes.def" 3385#define WASM_TYPE(Name, Id, SingletonId) \ 3386 case Id: \ 3387 return Name; 3388#include "clang/Basic/WebAssemblyReferenceTypes.def" 3389 } 3390 3391 llvm_unreachable("Invalid builtin type."); 3392} 3393 3394QualType QualType::getNonPackExpansionType() const { 3395 // We never wrap type sugar around a PackExpansionType. 3396 if (auto *PET = dyn_cast<PackExpansionType>(getTypePtr())) 3397 return PET->getPattern(); 3398 return *this; 3399} 3400 3401QualType QualType::getNonLValueExprType(const ASTContext &Context) const { 3402 if (const auto *RefType = getTypePtr()->getAs<ReferenceType>()) 3403 return RefType->getPointeeType(); 3404 3405 // C++0x [basic.lval]: 3406 // Class prvalues can have cv-qualified types; non-class prvalues always 3407 // have cv-unqualified types. 3408 // 3409 // See also C99 6.3.2.1p2. 3410 if (!Context.getLangOpts().CPlusPlus || 3411 (!getTypePtr()->isDependentType() && !getTypePtr()->isRecordType())) 3412 return getUnqualifiedType(); 3413 3414 return *this; 3415} 3416 3417StringRef FunctionType::getNameForCallConv(CallingConv CC) { 3418 switch (CC) { 3419 case CC_C: return "cdecl"; 3420 case CC_X86StdCall: return "stdcall"; 3421 case CC_X86FastCall: return "fastcall"; 3422 case CC_X86ThisCall: return "thiscall"; 3423 case CC_X86Pascal: return "pascal"; 3424 case CC_X86VectorCall: return "vectorcall"; 3425 case CC_Win64: return "ms_abi"; 3426 case CC_X86_64SysV: return "sysv_abi"; 3427 case CC_X86RegCall : return "regcall"; 3428 case CC_AAPCS: return "aapcs"; 3429 case CC_AAPCS_VFP: return "aapcs-vfp"; 3430 case CC_AArch64VectorCall: return "aarch64_vector_pcs"; 3431 case CC_AArch64SVEPCS: return "aarch64_sve_pcs"; 3432 case CC_AMDGPUKernelCall: return "amdgpu_kernel"; 3433 case CC_IntelOclBicc: return "intel_ocl_bicc"; 3434 case CC_SpirFunction: return "spir_function"; 3435 case CC_OpenCLKernel: return "opencl_kernel"; 3436 case CC_Swift: return "swiftcall"; 3437 case CC_SwiftAsync: return "swiftasynccall"; 3438 case CC_PreserveMost: return "preserve_most"; 3439 case CC_PreserveAll: return "preserve_all"; 3440 case CC_M68kRTD: return "m68k_rtd"; 3441 } 3442 3443 llvm_unreachable("Invalid calling convention."); 3444} 3445 3446void FunctionProtoType::ExceptionSpecInfo::instantiate() { 3447 assert(Type == EST_Uninstantiated); 3448 NoexceptExpr = 3449 cast<FunctionProtoType>(SourceTemplate->getType())->getNoexceptExpr(); 3450 Type = EST_DependentNoexcept; 3451} 3452 3453FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params, 3454 QualType canonical, 3455 const ExtProtoInfo &epi) 3456 : FunctionType(FunctionProto, result, canonical, result->getDependence(), 3457 epi.ExtInfo) { 3458 FunctionTypeBits.FastTypeQuals = epi.TypeQuals.getFastQualifiers(); 3459 FunctionTypeBits.RefQualifier = epi.RefQualifier; 3460 FunctionTypeBits.NumParams = params.size(); 3461 assert(getNumParams() == params.size() && "NumParams overflow!"); 3462 FunctionTypeBits.ExceptionSpecType = epi.ExceptionSpec.Type; 3463 FunctionTypeBits.HasExtParameterInfos = !!epi.ExtParameterInfos; 3464 FunctionTypeBits.Variadic = epi.Variadic; 3465 FunctionTypeBits.HasTrailingReturn = epi.HasTrailingReturn; 3466 3467 if (epi.requiresFunctionProtoTypeExtraBitfields()) { 3468 FunctionTypeBits.HasExtraBitfields = true; 3469 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>(); 3470 ExtraBits = FunctionTypeExtraBitfields(); 3471 } else { 3472 FunctionTypeBits.HasExtraBitfields = false; 3473 } 3474 3475 if (epi.requiresFunctionProtoTypeArmAttributes()) { 3476 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>(); 3477 ArmTypeAttrs = FunctionTypeArmAttributes(); 3478 3479 // Also set the bit in FunctionTypeExtraBitfields 3480 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>(); 3481 ExtraBits.HasArmTypeAttributes = true; 3482 } 3483 3484 // Fill in the trailing argument array. 3485 auto *argSlot = getTrailingObjects<QualType>(); 3486 for (unsigned i = 0; i != getNumParams(); ++i) { 3487 addDependence(params[i]->getDependence() & 3488 ~TypeDependence::VariablyModified); 3489 argSlot[i] = params[i]; 3490 } 3491 3492 // Propagate the SME ACLE attributes. 3493 if (epi.AArch64SMEAttributes != SME_NormalFunction) { 3494 auto &ArmTypeAttrs = *getTrailingObjects<FunctionTypeArmAttributes>(); 3495 assert(epi.AArch64SMEAttributes <= SME_AttributeMask && 3496 "Not enough bits to encode SME attributes"); 3497 ArmTypeAttrs.AArch64SMEAttributes = epi.AArch64SMEAttributes; 3498 } 3499 3500 // Fill in the exception type array if present. 3501 if (getExceptionSpecType() == EST_Dynamic) { 3502 auto &ExtraBits = *getTrailingObjects<FunctionTypeExtraBitfields>(); 3503 size_t NumExceptions = epi.ExceptionSpec.Exceptions.size(); 3504 assert(NumExceptions <= 1023 && "Not enough bits to encode exceptions"); 3505 ExtraBits.NumExceptionType = NumExceptions; 3506 3507 assert(hasExtraBitfields() && "missing trailing extra bitfields!"); 3508 auto *exnSlot = 3509 reinterpret_cast<QualType *>(getTrailingObjects<ExceptionType>()); 3510 unsigned I = 0; 3511 for (QualType ExceptionType : epi.ExceptionSpec.Exceptions) { 3512 // Note that, before C++17, a dependent exception specification does 3513 // *not* make a type dependent; it's not even part of the C++ type 3514 // system. 3515 addDependence( 3516 ExceptionType->getDependence() & 3517 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack)); 3518 3519 exnSlot[I++] = ExceptionType; 3520 } 3521 } 3522 // Fill in the Expr * in the exception specification if present. 3523 else if (isComputedNoexcept(getExceptionSpecType())) { 3524 assert(epi.ExceptionSpec.NoexceptExpr && "computed noexcept with no expr"); 3525 assert((getExceptionSpecType() == EST_DependentNoexcept) == 3526 epi.ExceptionSpec.NoexceptExpr->isValueDependent()); 3527 3528 // Store the noexcept expression and context. 3529 *getTrailingObjects<Expr *>() = epi.ExceptionSpec.NoexceptExpr; 3530 3531 addDependence( 3532 toTypeDependence(epi.ExceptionSpec.NoexceptExpr->getDependence()) & 3533 (TypeDependence::Instantiation | TypeDependence::UnexpandedPack)); 3534 } 3535 // Fill in the FunctionDecl * in the exception specification if present. 3536 else if (getExceptionSpecType() == EST_Uninstantiated) { 3537 // Store the function decl from which we will resolve our 3538 // exception specification. 3539 auto **slot = getTrailingObjects<FunctionDecl *>(); 3540 slot[0] = epi.ExceptionSpec.SourceDecl; 3541 slot[1] = epi.ExceptionSpec.SourceTemplate; 3542 // This exception specification doesn't make the type dependent, because 3543 // it's not instantiated as part of instantiating the type. 3544 } else if (getExceptionSpecType() == EST_Unevaluated) { 3545 // Store the function decl from which we will resolve our 3546 // exception specification. 3547 auto **slot = getTrailingObjects<FunctionDecl *>(); 3548 slot[0] = epi.ExceptionSpec.SourceDecl; 3549 } 3550 3551 // If this is a canonical type, and its exception specification is dependent, 3552 // then it's a dependent type. This only happens in C++17 onwards. 3553 if (isCanonicalUnqualified()) { 3554 if (getExceptionSpecType() == EST_Dynamic || 3555 getExceptionSpecType() == EST_DependentNoexcept) { 3556 assert(hasDependentExceptionSpec() && "type should not be canonical"); 3557 addDependence(TypeDependence::DependentInstantiation); 3558 } 3559 } else if (getCanonicalTypeInternal()->isDependentType()) { 3560 // Ask our canonical type whether our exception specification was dependent. 3561 addDependence(TypeDependence::DependentInstantiation); 3562 } 3563 3564 // Fill in the extra parameter info if present. 3565 if (epi.ExtParameterInfos) { 3566 auto *extParamInfos = getTrailingObjects<ExtParameterInfo>(); 3567 for (unsigned i = 0; i != getNumParams(); ++i) 3568 extParamInfos[i] = epi.ExtParameterInfos[i]; 3569 } 3570 3571 if (epi.TypeQuals.hasNonFastQualifiers()) { 3572 FunctionTypeBits.HasExtQuals = 1; 3573 *getTrailingObjects<Qualifiers>() = epi.TypeQuals; 3574 } else { 3575 FunctionTypeBits.HasExtQuals = 0; 3576 } 3577 3578 // Fill in the Ellipsis location info if present. 3579 if (epi.Variadic) { 3580 auto &EllipsisLoc = *getTrailingObjects<SourceLocation>(); 3581 EllipsisLoc = epi.EllipsisLoc; 3582 } 3583} 3584 3585bool FunctionProtoType::hasDependentExceptionSpec() const { 3586 if (Expr *NE = getNoexceptExpr()) 3587 return NE->isValueDependent(); 3588 for (QualType ET : exceptions()) 3589 // A pack expansion with a non-dependent pattern is still dependent, 3590 // because we don't know whether the pattern is in the exception spec 3591 // or not (that depends on whether the pack has 0 expansions). 3592 if (ET->isDependentType() || ET->getAs<PackExpansionType>()) 3593 return true; 3594 return false; 3595} 3596 3597bool FunctionProtoType::hasInstantiationDependentExceptionSpec() const { 3598 if (Expr *NE = getNoexceptExpr()) 3599 return NE->isInstantiationDependent(); 3600 for (QualType ET : exceptions()) 3601 if (ET->isInstantiationDependentType()) 3602 return true; 3603 return false; 3604} 3605 3606CanThrowResult FunctionProtoType::canThrow() const { 3607 switch (getExceptionSpecType()) { 3608 case EST_Unparsed: 3609 case EST_Unevaluated: 3610 llvm_unreachable("should not call this with unresolved exception specs"); 3611 3612 case EST_DynamicNone: 3613 case EST_BasicNoexcept: 3614 case EST_NoexceptTrue: 3615 case EST_NoThrow: 3616 return CT_Cannot; 3617 3618 case EST_None: 3619 case EST_MSAny: 3620 case EST_NoexceptFalse: 3621 return CT_Can; 3622 3623 case EST_Dynamic: 3624 // A dynamic exception specification is throwing unless every exception 3625 // type is an (unexpanded) pack expansion type. 3626 for (unsigned I = 0; I != getNumExceptions(); ++I) 3627 if (!getExceptionType(I)->getAs<PackExpansionType>()) 3628 return CT_Can; 3629 return CT_Dependent; 3630 3631 case EST_Uninstantiated: 3632 case EST_DependentNoexcept: 3633 return CT_Dependent; 3634 } 3635 3636 llvm_unreachable("unexpected exception specification kind"); 3637} 3638 3639bool FunctionProtoType::isTemplateVariadic() const { 3640 for (unsigned ArgIdx = getNumParams(); ArgIdx; --ArgIdx) 3641 if (isa<PackExpansionType>(getParamType(ArgIdx - 1))) 3642 return true; 3643 3644 return false; 3645} 3646 3647void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 3648 const QualType *ArgTys, unsigned NumParams, 3649 const ExtProtoInfo &epi, 3650 const ASTContext &Context, bool Canonical) { 3651 // We have to be careful not to get ambiguous profile encodings. 3652 // Note that valid type pointers are never ambiguous with anything else. 3653 // 3654 // The encoding grammar begins: 3655 // type type* bool int bool 3656 // If that final bool is true, then there is a section for the EH spec: 3657 // bool type* 3658 // This is followed by an optional "consumed argument" section of the 3659 // same length as the first type sequence: 3660 // bool* 3661 // This is followed by the ext info: 3662 // int 3663 // Finally we have a trailing return type flag (bool) 3664 // combined with AArch64 SME Attributes, to save space: 3665 // int 3666 // 3667 // There is no ambiguity between the consumed arguments and an empty EH 3668 // spec because of the leading 'bool' which unambiguously indicates 3669 // whether the following bool is the EH spec or part of the arguments. 3670 3671 ID.AddPointer(Result.getAsOpaquePtr()); 3672 for (unsigned i = 0; i != NumParams; ++i) 3673 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 3674 // This method is relatively performance sensitive, so as a performance 3675 // shortcut, use one AddInteger call instead of four for the next four 3676 // fields. 3677 assert(!(unsigned(epi.Variadic) & ~1) && 3678 !(unsigned(epi.RefQualifier) & ~3) && 3679 !(unsigned(epi.ExceptionSpec.Type) & ~15) && 3680 "Values larger than expected."); 3681 ID.AddInteger(unsigned(epi.Variadic) + 3682 (epi.RefQualifier << 1) + 3683 (epi.ExceptionSpec.Type << 3)); 3684 ID.Add(epi.TypeQuals); 3685 if (epi.ExceptionSpec.Type == EST_Dynamic) { 3686 for (QualType Ex : epi.ExceptionSpec.Exceptions) 3687 ID.AddPointer(Ex.getAsOpaquePtr()); 3688 } else if (isComputedNoexcept(epi.ExceptionSpec.Type)) { 3689 epi.ExceptionSpec.NoexceptExpr->Profile(ID, Context, Canonical); 3690 } else if (epi.ExceptionSpec.Type == EST_Uninstantiated || 3691 epi.ExceptionSpec.Type == EST_Unevaluated) { 3692 ID.AddPointer(epi.ExceptionSpec.SourceDecl->getCanonicalDecl()); 3693 } 3694 if (epi.ExtParameterInfos) { 3695 for (unsigned i = 0; i != NumParams; ++i) 3696 ID.AddInteger(epi.ExtParameterInfos[i].getOpaqueValue()); 3697 } 3698 3699 epi.ExtInfo.Profile(ID); 3700 ID.AddInteger((epi.AArch64SMEAttributes << 1) | epi.HasTrailingReturn); 3701} 3702 3703void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, 3704 const ASTContext &Ctx) { 3705 Profile(ID, getReturnType(), param_type_begin(), getNumParams(), 3706 getExtProtoInfo(), Ctx, isCanonicalUnqualified()); 3707} 3708 3709TypedefType::TypedefType(TypeClass tc, const TypedefNameDecl *D, 3710 QualType Underlying, QualType can) 3711 : Type(tc, can, toSemanticDependence(can->getDependence())), 3712 Decl(const_cast<TypedefNameDecl *>(D)) { 3713 assert(!isa<TypedefType>(can) && "Invalid canonical type"); 3714 TypedefBits.hasTypeDifferentFromDecl = !Underlying.isNull(); 3715 if (!typeMatchesDecl()) 3716 *getTrailingObjects<QualType>() = Underlying; 3717} 3718 3719QualType TypedefType::desugar() const { 3720 return typeMatchesDecl() ? Decl->getUnderlyingType() 3721 : *getTrailingObjects<QualType>(); 3722} 3723 3724UsingType::UsingType(const UsingShadowDecl *Found, QualType Underlying, 3725 QualType Canon) 3726 : Type(Using, Canon, toSemanticDependence(Canon->getDependence())), 3727 Found(const_cast<UsingShadowDecl *>(Found)) { 3728 UsingBits.hasTypeDifferentFromDecl = !Underlying.isNull(); 3729 if (!typeMatchesDecl()) 3730 *getTrailingObjects<QualType>() = Underlying; 3731} 3732 3733QualType UsingType::getUnderlyingType() const { 3734 return typeMatchesDecl() 3735 ? QualType( 3736 cast<TypeDecl>(Found->getTargetDecl())->getTypeForDecl(), 0) 3737 : *getTrailingObjects<QualType>(); 3738} 3739 3740QualType MacroQualifiedType::desugar() const { return getUnderlyingType(); } 3741 3742QualType MacroQualifiedType::getModifiedType() const { 3743 // Step over MacroQualifiedTypes from the same macro to find the type 3744 // ultimately qualified by the macro qualifier. 3745 QualType Inner = cast<AttributedType>(getUnderlyingType())->getModifiedType(); 3746 while (auto *InnerMQT = dyn_cast<MacroQualifiedType>(Inner)) { 3747 if (InnerMQT->getMacroIdentifier() != getMacroIdentifier()) 3748 break; 3749 Inner = InnerMQT->getModifiedType(); 3750 } 3751 return Inner; 3752} 3753 3754TypeOfExprType::TypeOfExprType(Expr *E, TypeOfKind Kind, QualType Can) 3755 : Type(TypeOfExpr, 3756 // We have to protect against 'Can' being invalid through its 3757 // default argument. 3758 Kind == TypeOfKind::Unqualified && !Can.isNull() 3759 ? Can.getAtomicUnqualifiedType() 3760 : Can, 3761 toTypeDependence(E->getDependence()) | 3762 (E->getType()->getDependence() & 3763 TypeDependence::VariablyModified)), 3764 TOExpr(E) { 3765 TypeOfBits.IsUnqual = Kind == TypeOfKind::Unqualified; 3766} 3767 3768bool TypeOfExprType::isSugared() const { 3769 return !TOExpr->isTypeDependent(); 3770} 3771 3772QualType TypeOfExprType::desugar() const { 3773 if (isSugared()) { 3774 QualType QT = getUnderlyingExpr()->getType(); 3775 return TypeOfBits.IsUnqual ? QT.getAtomicUnqualifiedType() : QT; 3776 } 3777 return QualType(this, 0); 3778} 3779 3780void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID, 3781 const ASTContext &Context, Expr *E, 3782 bool IsUnqual) { 3783 E->Profile(ID, Context, true); 3784 ID.AddBoolean(IsUnqual); 3785} 3786 3787DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can) 3788 // C++11 [temp.type]p2: "If an expression e involves a template parameter, 3789 // decltype(e) denotes a unique dependent type." Hence a decltype type is 3790 // type-dependent even if its expression is only instantiation-dependent. 3791 : Type(Decltype, can, 3792 toTypeDependence(E->getDependence()) | 3793 (E->isInstantiationDependent() ? TypeDependence::Dependent 3794 : TypeDependence::None) | 3795 (E->getType()->getDependence() & 3796 TypeDependence::VariablyModified)), 3797 E(E), UnderlyingType(underlyingType) {} 3798 3799bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); } 3800 3801QualType DecltypeType::desugar() const { 3802 if (isSugared()) 3803 return getUnderlyingType(); 3804 3805 return QualType(this, 0); 3806} 3807 3808DependentDecltypeType::DependentDecltypeType(Expr *E, QualType UnderlyingType) 3809 : DecltypeType(E, UnderlyingType) {} 3810 3811void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, 3812 const ASTContext &Context, Expr *E) { 3813 E->Profile(ID, Context, true); 3814} 3815 3816UnaryTransformType::UnaryTransformType(QualType BaseType, 3817 QualType UnderlyingType, UTTKind UKind, 3818 QualType CanonicalType) 3819 : Type(UnaryTransform, CanonicalType, BaseType->getDependence()), 3820 BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {} 3821 3822DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C, 3823 QualType BaseType, 3824 UTTKind UKind) 3825 : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {} 3826 3827TagType::TagType(TypeClass TC, const TagDecl *D, QualType can) 3828 : Type(TC, can, 3829 D->isDependentType() ? TypeDependence::DependentInstantiation 3830 : TypeDependence::None), 3831 decl(const_cast<TagDecl *>(D)) {} 3832 3833static TagDecl *getInterestingTagDecl(TagDecl *decl) { 3834 for (auto *I : decl->redecls()) { 3835 if (I->isCompleteDefinition() || I->isBeingDefined()) 3836 return I; 3837 } 3838 // If there's no definition (not even in progress), return what we have. 3839 return decl; 3840} 3841 3842TagDecl *TagType::getDecl() const { 3843 return getInterestingTagDecl(decl); 3844} 3845 3846bool TagType::isBeingDefined() const { 3847 return getDecl()->isBeingDefined(); 3848} 3849 3850bool RecordType::hasConstFields() const { 3851 std::vector<const RecordType*> RecordTypeList; 3852 RecordTypeList.push_back(this); 3853 unsigned NextToCheckIndex = 0; 3854 3855 while (RecordTypeList.size() > NextToCheckIndex) { 3856 for (FieldDecl *FD : 3857 RecordTypeList[NextToCheckIndex]->getDecl()->fields()) { 3858 QualType FieldTy = FD->getType(); 3859 if (FieldTy.isConstQualified()) 3860 return true; 3861 FieldTy = FieldTy.getCanonicalType(); 3862 if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) { 3863 if (!llvm::is_contained(RecordTypeList, FieldRecTy)) 3864 RecordTypeList.push_back(FieldRecTy); 3865 } 3866 } 3867 ++NextToCheckIndex; 3868 } 3869 return false; 3870} 3871 3872bool AttributedType::isQualifier() const { 3873 // FIXME: Generate this with TableGen. 3874 switch (getAttrKind()) { 3875 // These are type qualifiers in the traditional C sense: they annotate 3876 // something about a specific value/variable of a type. (They aren't 3877 // always part of the canonical type, though.) 3878 case attr::ObjCGC: 3879 case attr::ObjCOwnership: 3880 case attr::ObjCInertUnsafeUnretained: 3881 case attr::TypeNonNull: 3882 case attr::TypeNullable: 3883 case attr::TypeNullableResult: 3884 case attr::TypeNullUnspecified: 3885 case attr::LifetimeBound: 3886 case attr::AddressSpace: 3887 return true; 3888 3889 // All other type attributes aren't qualifiers; they rewrite the modified 3890 // type to be a semantically different type. 3891 default: 3892 return false; 3893 } 3894} 3895 3896bool AttributedType::isMSTypeSpec() const { 3897 // FIXME: Generate this with TableGen? 3898 switch (getAttrKind()) { 3899 default: return false; 3900 case attr::Ptr32: 3901 case attr::Ptr64: 3902 case attr::SPtr: 3903 case attr::UPtr: 3904 return true; 3905 } 3906 llvm_unreachable("invalid attr kind"); 3907} 3908 3909bool AttributedType::isWebAssemblyFuncrefSpec() const { 3910 return getAttrKind() == attr::WebAssemblyFuncref; 3911} 3912 3913bool AttributedType::isCallingConv() const { 3914 // FIXME: Generate this with TableGen. 3915 switch (getAttrKind()) { 3916 default: return false; 3917 case attr::Pcs: 3918 case attr::CDecl: 3919 case attr::FastCall: 3920 case attr::StdCall: 3921 case attr::ThisCall: 3922 case attr::RegCall: 3923 case attr::SwiftCall: 3924 case attr::SwiftAsyncCall: 3925 case attr::VectorCall: 3926 case attr::AArch64VectorPcs: 3927 case attr::AArch64SVEPcs: 3928 case attr::AMDGPUKernelCall: 3929 case attr::Pascal: 3930 case attr::MSABI: 3931 case attr::SysVABI: 3932 case attr::IntelOclBicc: 3933 case attr::PreserveMost: 3934 case attr::PreserveAll: 3935 case attr::M68kRTD: 3936 return true; 3937 } 3938 llvm_unreachable("invalid attr kind"); 3939} 3940 3941CXXRecordDecl *InjectedClassNameType::getDecl() const { 3942 return cast<CXXRecordDecl>(getInterestingTagDecl(Decl)); 3943} 3944 3945IdentifierInfo *TemplateTypeParmType::getIdentifier() const { 3946 return isCanonicalUnqualified() ? nullptr : getDecl()->getIdentifier(); 3947} 3948 3949static const TemplateTypeParmDecl *getReplacedParameter(Decl *D, 3950 unsigned Index) { 3951 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) 3952 return TTP; 3953 return cast<TemplateTypeParmDecl>( 3954 getReplacedTemplateParameterList(D)->getParam(Index)); 3955} 3956 3957SubstTemplateTypeParmType::SubstTemplateTypeParmType( 3958 QualType Replacement, Decl *AssociatedDecl, unsigned Index, 3959 std::optional<unsigned> PackIndex) 3960 : Type(SubstTemplateTypeParm, Replacement.getCanonicalType(), 3961 Replacement->getDependence()), 3962 AssociatedDecl(AssociatedDecl) { 3963 SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType = 3964 Replacement != getCanonicalTypeInternal(); 3965 if (SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType) 3966 *getTrailingObjects<QualType>() = Replacement; 3967 3968 SubstTemplateTypeParmTypeBits.Index = Index; 3969 SubstTemplateTypeParmTypeBits.PackIndex = PackIndex ? *PackIndex + 1 : 0; 3970 assert(AssociatedDecl != nullptr); 3971} 3972 3973const TemplateTypeParmDecl * 3974SubstTemplateTypeParmType::getReplacedParameter() const { 3975 return ::getReplacedParameter(getAssociatedDecl(), getIndex()); 3976} 3977 3978SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType( 3979 QualType Canon, Decl *AssociatedDecl, unsigned Index, bool Final, 3980 const TemplateArgument &ArgPack) 3981 : Type(SubstTemplateTypeParmPack, Canon, 3982 TypeDependence::DependentInstantiation | 3983 TypeDependence::UnexpandedPack), 3984 Arguments(ArgPack.pack_begin()), 3985 AssociatedDeclAndFinal(AssociatedDecl, Final) { 3986 SubstTemplateTypeParmPackTypeBits.Index = Index; 3987 SubstTemplateTypeParmPackTypeBits.NumArgs = ArgPack.pack_size(); 3988 assert(AssociatedDecl != nullptr); 3989} 3990 3991Decl *SubstTemplateTypeParmPackType::getAssociatedDecl() const { 3992 return AssociatedDeclAndFinal.getPointer(); 3993} 3994 3995bool SubstTemplateTypeParmPackType::getFinal() const { 3996 return AssociatedDeclAndFinal.getInt(); 3997} 3998 3999const TemplateTypeParmDecl * 4000SubstTemplateTypeParmPackType::getReplacedParameter() const { 4001 return ::getReplacedParameter(getAssociatedDecl(), getIndex()); 4002} 4003 4004IdentifierInfo *SubstTemplateTypeParmPackType::getIdentifier() const { 4005 return getReplacedParameter()->getIdentifier(); 4006} 4007 4008TemplateArgument SubstTemplateTypeParmPackType::getArgumentPack() const { 4009 return TemplateArgument(llvm::ArrayRef(Arguments, getNumArgs())); 4010} 4011 4012void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID) { 4013 Profile(ID, getAssociatedDecl(), getIndex(), getFinal(), getArgumentPack()); 4014} 4015 4016void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID, 4017 const Decl *AssociatedDecl, 4018 unsigned Index, bool Final, 4019 const TemplateArgument &ArgPack) { 4020 ID.AddPointer(AssociatedDecl); 4021 ID.AddInteger(Index); 4022 ID.AddBoolean(Final); 4023 ID.AddInteger(ArgPack.pack_size()); 4024 for (const auto &P : ArgPack.pack_elements()) 4025 ID.AddPointer(P.getAsType().getAsOpaquePtr()); 4026} 4027 4028bool TemplateSpecializationType::anyDependentTemplateArguments( 4029 const TemplateArgumentListInfo &Args, ArrayRef<TemplateArgument> Converted) { 4030 return anyDependentTemplateArguments(Args.arguments(), Converted); 4031} 4032 4033bool TemplateSpecializationType::anyDependentTemplateArguments( 4034 ArrayRef<TemplateArgumentLoc> Args, ArrayRef<TemplateArgument> Converted) { 4035 for (const TemplateArgument &Arg : Converted) 4036 if (Arg.isDependent()) 4037 return true; 4038 return false; 4039} 4040 4041bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments( 4042 ArrayRef<TemplateArgumentLoc> Args) { 4043 for (const TemplateArgumentLoc &ArgLoc : Args) { 4044 if (ArgLoc.getArgument().isInstantiationDependent()) 4045 return true; 4046 } 4047 return false; 4048} 4049 4050TemplateSpecializationType::TemplateSpecializationType( 4051 TemplateName T, ArrayRef<TemplateArgument> Args, QualType Canon, 4052 QualType AliasedType) 4053 : Type(TemplateSpecialization, Canon.isNull() ? QualType(this, 0) : Canon, 4054 (Canon.isNull() 4055 ? TypeDependence::DependentInstantiation 4056 : toSemanticDependence(Canon->getDependence())) | 4057 (toTypeDependence(T.getDependence()) & 4058 TypeDependence::UnexpandedPack)), 4059 Template(T) { 4060 TemplateSpecializationTypeBits.NumArgs = Args.size(); 4061 TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull(); 4062 4063 assert(!T.getAsDependentTemplateName() && 4064 "Use DependentTemplateSpecializationType for dependent template-name"); 4065 assert((T.getKind() == TemplateName::Template || 4066 T.getKind() == TemplateName::SubstTemplateTemplateParm || 4067 T.getKind() == TemplateName::SubstTemplateTemplateParmPack || 4068 T.getKind() == TemplateName::UsingTemplate) && 4069 "Unexpected template name for TemplateSpecializationType"); 4070 4071 auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1); 4072 for (const TemplateArgument &Arg : Args) { 4073 // Update instantiation-dependent, variably-modified, and error bits. 4074 // If the canonical type exists and is non-dependent, the template 4075 // specialization type can be non-dependent even if one of the type 4076 // arguments is. Given: 4077 // template<typename T> using U = int; 4078 // U<T> is always non-dependent, irrespective of the type T. 4079 // However, U<Ts> contains an unexpanded parameter pack, even though 4080 // its expansion (and thus its desugared type) doesn't. 4081 addDependence(toTypeDependence(Arg.getDependence()) & 4082 ~TypeDependence::Dependent); 4083 if (Arg.getKind() == TemplateArgument::Type) 4084 addDependence(Arg.getAsType()->getDependence() & 4085 TypeDependence::VariablyModified); 4086 new (TemplateArgs++) TemplateArgument(Arg); 4087 } 4088 4089 // Store the aliased type if this is a type alias template specialization. 4090 if (isTypeAlias()) { 4091 auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1); 4092 *reinterpret_cast<QualType *>(Begin + Args.size()) = AliasedType; 4093 } 4094} 4095 4096QualType TemplateSpecializationType::getAliasedType() const { 4097 assert(isTypeAlias() && "not a type alias template specialization"); 4098 return *reinterpret_cast<const QualType *>(template_arguments().end()); 4099} 4100 4101void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 4102 const ASTContext &Ctx) { 4103 Profile(ID, Template, template_arguments(), Ctx); 4104 if (isTypeAlias()) 4105 getAliasedType().Profile(ID); 4106} 4107 4108void 4109TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 4110 TemplateName T, 4111 ArrayRef<TemplateArgument> Args, 4112 const ASTContext &Context) { 4113 T.Profile(ID); 4114 for (const TemplateArgument &Arg : Args) 4115 Arg.Profile(ID, Context); 4116} 4117 4118QualType 4119QualifierCollector::apply(const ASTContext &Context, QualType QT) const { 4120 if (!hasNonFastQualifiers()) 4121 return QT.withFastQualifiers(getFastQualifiers()); 4122 4123 return Context.getQualifiedType(QT, *this); 4124} 4125 4126QualType 4127QualifierCollector::apply(const ASTContext &Context, const Type *T) const { 4128 if (!hasNonFastQualifiers()) 4129 return QualType(T, getFastQualifiers()); 4130 4131 return Context.getQualifiedType(T, *this); 4132} 4133 4134void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID, 4135 QualType BaseType, 4136 ArrayRef<QualType> typeArgs, 4137 ArrayRef<ObjCProtocolDecl *> protocols, 4138 bool isKindOf) { 4139 ID.AddPointer(BaseType.getAsOpaquePtr()); 4140 ID.AddInteger(typeArgs.size()); 4141 for (auto typeArg : typeArgs) 4142 ID.AddPointer(typeArg.getAsOpaquePtr()); 4143 ID.AddInteger(protocols.size()); 4144 for (auto *proto : protocols) 4145 ID.AddPointer(proto); 4146 ID.AddBoolean(isKindOf); 4147} 4148 4149void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID) { 4150 Profile(ID, getBaseType(), getTypeArgsAsWritten(), 4151 llvm::ArrayRef(qual_begin(), getNumProtocols()), 4152 isKindOfTypeAsWritten()); 4153} 4154 4155void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID, 4156 const ObjCTypeParamDecl *OTPDecl, 4157 QualType CanonicalType, 4158 ArrayRef<ObjCProtocolDecl *> protocols) { 4159 ID.AddPointer(OTPDecl); 4160 ID.AddPointer(CanonicalType.getAsOpaquePtr()); 4161 ID.AddInteger(protocols.size()); 4162 for (auto *proto : protocols) 4163 ID.AddPointer(proto); 4164} 4165 4166void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID) { 4167 Profile(ID, getDecl(), getCanonicalTypeInternal(), 4168 llvm::ArrayRef(qual_begin(), getNumProtocols())); 4169} 4170 4171namespace { 4172 4173/// The cached properties of a type. 4174class CachedProperties { 4175 Linkage L; 4176 bool local; 4177 4178public: 4179 CachedProperties(Linkage L, bool local) : L(L), local(local) {} 4180 4181 Linkage getLinkage() const { return L; } 4182 bool hasLocalOrUnnamedType() const { return local; } 4183 4184 friend CachedProperties merge(CachedProperties L, CachedProperties R) { 4185 Linkage MergedLinkage = minLinkage(L.L, R.L); 4186 return CachedProperties(MergedLinkage, L.hasLocalOrUnnamedType() || 4187 R.hasLocalOrUnnamedType()); 4188 } 4189}; 4190 4191} // namespace 4192 4193static CachedProperties computeCachedProperties(const Type *T); 4194 4195namespace clang { 4196 4197/// The type-property cache. This is templated so as to be 4198/// instantiated at an internal type to prevent unnecessary symbol 4199/// leakage. 4200template <class Private> class TypePropertyCache { 4201public: 4202 static CachedProperties get(QualType T) { 4203 return get(T.getTypePtr()); 4204 } 4205 4206 static CachedProperties get(const Type *T) { 4207 ensure(T); 4208 return CachedProperties(T->TypeBits.getLinkage(), 4209 T->TypeBits.hasLocalOrUnnamedType()); 4210 } 4211 4212 static void ensure(const Type *T) { 4213 // If the cache is valid, we're okay. 4214 if (T->TypeBits.isCacheValid()) return; 4215 4216 // If this type is non-canonical, ask its canonical type for the 4217 // relevant information. 4218 if (!T->isCanonicalUnqualified()) { 4219 const Type *CT = T->getCanonicalTypeInternal().getTypePtr(); 4220 ensure(CT); 4221 T->TypeBits.CacheValid = true; 4222 T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage; 4223 T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed; 4224 return; 4225 } 4226 4227 // Compute the cached properties and then set the cache. 4228 CachedProperties Result = computeCachedProperties(T); 4229 T->TypeBits.CacheValid = true; 4230 T->TypeBits.CachedLinkage = llvm::to_underlying(Result.getLinkage()); 4231 T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType(); 4232 } 4233}; 4234 4235} // namespace clang 4236 4237// Instantiate the friend template at a private class. In a 4238// reasonable implementation, these symbols will be internal. 4239// It is terrible that this is the best way to accomplish this. 4240namespace { 4241 4242class Private {}; 4243 4244} // namespace 4245 4246using Cache = TypePropertyCache<Private>; 4247 4248static CachedProperties computeCachedProperties(const Type *T) { 4249 switch (T->getTypeClass()) { 4250#define TYPE(Class,Base) 4251#define NON_CANONICAL_TYPE(Class,Base) case Type::Class: 4252#include "clang/AST/TypeNodes.inc" 4253 llvm_unreachable("didn't expect a non-canonical type here"); 4254 4255#define TYPE(Class,Base) 4256#define DEPENDENT_TYPE(Class,Base) case Type::Class: 4257#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class: 4258#include "clang/AST/TypeNodes.inc" 4259 // Treat instantiation-dependent types as external. 4260 if (!T->isInstantiationDependentType()) T->dump(); 4261 assert(T->isInstantiationDependentType()); 4262 return CachedProperties(Linkage::External, false); 4263 4264 case Type::Auto: 4265 case Type::DeducedTemplateSpecialization: 4266 // Give non-deduced 'auto' types external linkage. We should only see them 4267 // here in error recovery. 4268 return CachedProperties(Linkage::External, false); 4269 4270 case Type::BitInt: 4271 case Type::Builtin: 4272 // C++ [basic.link]p8: 4273 // A type is said to have linkage if and only if: 4274 // - it is a fundamental type (3.9.1); or 4275 return CachedProperties(Linkage::External, false); 4276 4277 case Type::Record: 4278 case Type::Enum: { 4279 const TagDecl *Tag = cast<TagType>(T)->getDecl(); 4280 4281 // C++ [basic.link]p8: 4282 // - it is a class or enumeration type that is named (or has a name 4283 // for linkage purposes (7.1.3)) and the name has linkage; or 4284 // - it is a specialization of a class template (14); or 4285 Linkage L = Tag->getLinkageInternal(); 4286 bool IsLocalOrUnnamed = 4287 Tag->getDeclContext()->isFunctionOrMethod() || 4288 !Tag->hasNameForLinkage(); 4289 return CachedProperties(L, IsLocalOrUnnamed); 4290 } 4291 4292 // C++ [basic.link]p8: 4293 // - it is a compound type (3.9.2) other than a class or enumeration, 4294 // compounded exclusively from types that have linkage; or 4295 case Type::Complex: 4296 return Cache::get(cast<ComplexType>(T)->getElementType()); 4297 case Type::Pointer: 4298 return Cache::get(cast<PointerType>(T)->getPointeeType()); 4299 case Type::BlockPointer: 4300 return Cache::get(cast<BlockPointerType>(T)->getPointeeType()); 4301 case Type::LValueReference: 4302 case Type::RValueReference: 4303 return Cache::get(cast<ReferenceType>(T)->getPointeeType()); 4304 case Type::MemberPointer: { 4305 const auto *MPT = cast<MemberPointerType>(T); 4306 return merge(Cache::get(MPT->getClass()), 4307 Cache::get(MPT->getPointeeType())); 4308 } 4309 case Type::ConstantArray: 4310 case Type::IncompleteArray: 4311 case Type::VariableArray: 4312 return Cache::get(cast<ArrayType>(T)->getElementType()); 4313 case Type::Vector: 4314 case Type::ExtVector: 4315 return Cache::get(cast<VectorType>(T)->getElementType()); 4316 case Type::ConstantMatrix: 4317 return Cache::get(cast<ConstantMatrixType>(T)->getElementType()); 4318 case Type::FunctionNoProto: 4319 return Cache::get(cast<FunctionType>(T)->getReturnType()); 4320 case Type::FunctionProto: { 4321 const auto *FPT = cast<FunctionProtoType>(T); 4322 CachedProperties result = Cache::get(FPT->getReturnType()); 4323 for (const auto &ai : FPT->param_types()) 4324 result = merge(result, Cache::get(ai)); 4325 return result; 4326 } 4327 case Type::ObjCInterface: { 4328 Linkage L = cast<ObjCInterfaceType>(T)->getDecl()->getLinkageInternal(); 4329 return CachedProperties(L, false); 4330 } 4331 case Type::ObjCObject: 4332 return Cache::get(cast<ObjCObjectType>(T)->getBaseType()); 4333 case Type::ObjCObjectPointer: 4334 return Cache::get(cast<ObjCObjectPointerType>(T)->getPointeeType()); 4335 case Type::Atomic: 4336 return Cache::get(cast<AtomicType>(T)->getValueType()); 4337 case Type::Pipe: 4338 return Cache::get(cast<PipeType>(T)->getElementType()); 4339 } 4340 4341 llvm_unreachable("unhandled type class"); 4342} 4343 4344/// Determine the linkage of this type. 4345Linkage Type::getLinkage() const { 4346 Cache::ensure(this); 4347 return TypeBits.getLinkage(); 4348} 4349 4350bool Type::hasUnnamedOrLocalType() const { 4351 Cache::ensure(this); 4352 return TypeBits.hasLocalOrUnnamedType(); 4353} 4354 4355LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) { 4356 switch (T->getTypeClass()) { 4357#define TYPE(Class,Base) 4358#define NON_CANONICAL_TYPE(Class,Base) case Type::Class: 4359#include "clang/AST/TypeNodes.inc" 4360 llvm_unreachable("didn't expect a non-canonical type here"); 4361 4362#define TYPE(Class,Base) 4363#define DEPENDENT_TYPE(Class,Base) case Type::Class: 4364#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class: 4365#include "clang/AST/TypeNodes.inc" 4366 // Treat instantiation-dependent types as external. 4367 assert(T->isInstantiationDependentType()); 4368 return LinkageInfo::external(); 4369 4370 case Type::BitInt: 4371 case Type::Builtin: 4372 return LinkageInfo::external(); 4373 4374 case Type::Auto: 4375 case Type::DeducedTemplateSpecialization: 4376 return LinkageInfo::external(); 4377 4378 case Type::Record: 4379 case Type::Enum: 4380 return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl()); 4381 4382 case Type::Complex: 4383 return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType()); 4384 case Type::Pointer: 4385 return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType()); 4386 case Type::BlockPointer: 4387 return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType()); 4388 case Type::LValueReference: 4389 case Type::RValueReference: 4390 return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType()); 4391 case Type::MemberPointer: { 4392 const auto *MPT = cast<MemberPointerType>(T); 4393 LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass()); 4394 LV.merge(computeTypeLinkageInfo(MPT->getPointeeType())); 4395 return LV; 4396 } 4397 case Type::ConstantArray: 4398 case Type::IncompleteArray: 4399 case Type::VariableArray: 4400 return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType()); 4401 case Type::Vector: 4402 case Type::ExtVector: 4403 return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType()); 4404 case Type::ConstantMatrix: 4405 return computeTypeLinkageInfo( 4406 cast<ConstantMatrixType>(T)->getElementType()); 4407 case Type::FunctionNoProto: 4408 return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType()); 4409 case Type::FunctionProto: { 4410 const auto *FPT = cast<FunctionProtoType>(T); 4411 LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType()); 4412 for (const auto &ai : FPT->param_types()) 4413 LV.merge(computeTypeLinkageInfo(ai)); 4414 return LV; 4415 } 4416 case Type::ObjCInterface: 4417 return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl()); 4418 case Type::ObjCObject: 4419 return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType()); 4420 case Type::ObjCObjectPointer: 4421 return computeTypeLinkageInfo( 4422 cast<ObjCObjectPointerType>(T)->getPointeeType()); 4423 case Type::Atomic: 4424 return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType()); 4425 case Type::Pipe: 4426 return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType()); 4427 } 4428 4429 llvm_unreachable("unhandled type class"); 4430} 4431 4432bool Type::isLinkageValid() const { 4433 if (!TypeBits.isCacheValid()) 4434 return true; 4435 4436 Linkage L = LinkageComputer{} 4437 .computeTypeLinkageInfo(getCanonicalTypeInternal()) 4438 .getLinkage(); 4439 return L == TypeBits.getLinkage(); 4440} 4441 4442LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) { 4443 if (!T->isCanonicalUnqualified()) 4444 return computeTypeLinkageInfo(T->getCanonicalTypeInternal()); 4445 4446 LinkageInfo LV = computeTypeLinkageInfo(T); 4447 assert(LV.getLinkage() == T->getLinkage()); 4448 return LV; 4449} 4450 4451LinkageInfo Type::getLinkageAndVisibility() const { 4452 return LinkageComputer{}.getTypeLinkageAndVisibility(this); 4453} 4454 4455std::optional<NullabilityKind> Type::getNullability() const { 4456 QualType Type(this, 0); 4457 while (const auto *AT = Type->getAs<AttributedType>()) { 4458 // Check whether this is an attributed type with nullability 4459 // information. 4460 if (auto Nullability = AT->getImmediateNullability()) 4461 return Nullability; 4462 4463 Type = AT->getEquivalentType(); 4464 } 4465 return std::nullopt; 4466} 4467 4468bool Type::canHaveNullability(bool ResultIfUnknown) const { 4469 QualType type = getCanonicalTypeInternal(); 4470 4471 switch (type->getTypeClass()) { 4472 // We'll only see canonical types here. 4473#define NON_CANONICAL_TYPE(Class, Parent) \ 4474 case Type::Class: \ 4475 llvm_unreachable("non-canonical type"); 4476#define TYPE(Class, Parent) 4477#include "clang/AST/TypeNodes.inc" 4478 4479 // Pointer types. 4480 case Type::Pointer: 4481 case Type::BlockPointer: 4482 case Type::MemberPointer: 4483 case Type::ObjCObjectPointer: 4484 return true; 4485 4486 // Dependent types that could instantiate to pointer types. 4487 case Type::UnresolvedUsing: 4488 case Type::TypeOfExpr: 4489 case Type::TypeOf: 4490 case Type::Decltype: 4491 case Type::UnaryTransform: 4492 case Type::TemplateTypeParm: 4493 case Type::SubstTemplateTypeParmPack: 4494 case Type::DependentName: 4495 case Type::DependentTemplateSpecialization: 4496 case Type::Auto: 4497 return ResultIfUnknown; 4498 4499 // Dependent template specializations can instantiate to pointer 4500 // types unless they're known to be specializations of a class 4501 // template. 4502 case Type::TemplateSpecialization: 4503 if (TemplateDecl *templateDecl 4504 = cast<TemplateSpecializationType>(type.getTypePtr()) 4505 ->getTemplateName().getAsTemplateDecl()) { 4506 if (isa<ClassTemplateDecl>(templateDecl)) 4507 return false; 4508 } 4509 return ResultIfUnknown; 4510 4511 case Type::Builtin: 4512 switch (cast<BuiltinType>(type.getTypePtr())->getKind()) { 4513 // Signed, unsigned, and floating-point types cannot have nullability. 4514#define SIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 4515#define UNSIGNED_TYPE(Id, SingletonId) case BuiltinType::Id: 4516#define FLOATING_TYPE(Id, SingletonId) case BuiltinType::Id: 4517#define BUILTIN_TYPE(Id, SingletonId) 4518#include "clang/AST/BuiltinTypes.def" 4519 return false; 4520 4521 // Dependent types that could instantiate to a pointer type. 4522 case BuiltinType::Dependent: 4523 case BuiltinType::Overload: 4524 case BuiltinType::BoundMember: 4525 case BuiltinType::PseudoObject: 4526 case BuiltinType::UnknownAny: 4527 case BuiltinType::ARCUnbridgedCast: 4528 return ResultIfUnknown; 4529 4530 case BuiltinType::Void: 4531 case BuiltinType::ObjCId: 4532 case BuiltinType::ObjCClass: 4533 case BuiltinType::ObjCSel: 4534#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 4535 case BuiltinType::Id: 4536#include "clang/Basic/OpenCLImageTypes.def" 4537#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 4538 case BuiltinType::Id: 4539#include "clang/Basic/OpenCLExtensionTypes.def" 4540 case BuiltinType::OCLSampler: 4541 case BuiltinType::OCLEvent: 4542 case BuiltinType::OCLClkEvent: 4543 case BuiltinType::OCLQueue: 4544 case BuiltinType::OCLReserveID: 4545#define SVE_TYPE(Name, Id, SingletonId) \ 4546 case BuiltinType::Id: 4547#include "clang/Basic/AArch64SVEACLETypes.def" 4548#define PPC_VECTOR_TYPE(Name, Id, Size) \ 4549 case BuiltinType::Id: 4550#include "clang/Basic/PPCTypes.def" 4551#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 4552#include "clang/Basic/RISCVVTypes.def" 4553#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id: 4554#include "clang/Basic/WebAssemblyReferenceTypes.def" 4555 case BuiltinType::BuiltinFn: 4556 case BuiltinType::NullPtr: 4557 case BuiltinType::IncompleteMatrixIdx: 4558 case BuiltinType::OMPArraySection: 4559 case BuiltinType::OMPArrayShaping: 4560 case BuiltinType::OMPIterator: 4561 return false; 4562 } 4563 llvm_unreachable("unknown builtin type"); 4564 4565 // Non-pointer types. 4566 case Type::Complex: 4567 case Type::LValueReference: 4568 case Type::RValueReference: 4569 case Type::ConstantArray: 4570 case Type::IncompleteArray: 4571 case Type::VariableArray: 4572 case Type::DependentSizedArray: 4573 case Type::DependentVector: 4574 case Type::DependentSizedExtVector: 4575 case Type::Vector: 4576 case Type::ExtVector: 4577 case Type::ConstantMatrix: 4578 case Type::DependentSizedMatrix: 4579 case Type::DependentAddressSpace: 4580 case Type::FunctionProto: 4581 case Type::FunctionNoProto: 4582 case Type::Record: 4583 case Type::DeducedTemplateSpecialization: 4584 case Type::Enum: 4585 case Type::InjectedClassName: 4586 case Type::PackExpansion: 4587 case Type::ObjCObject: 4588 case Type::ObjCInterface: 4589 case Type::Atomic: 4590 case Type::Pipe: 4591 case Type::BitInt: 4592 case Type::DependentBitInt: 4593 return false; 4594 } 4595 llvm_unreachable("bad type kind!"); 4596} 4597 4598std::optional<NullabilityKind> AttributedType::getImmediateNullability() const { 4599 if (getAttrKind() == attr::TypeNonNull) 4600 return NullabilityKind::NonNull; 4601 if (getAttrKind() == attr::TypeNullable) 4602 return NullabilityKind::Nullable; 4603 if (getAttrKind() == attr::TypeNullUnspecified) 4604 return NullabilityKind::Unspecified; 4605 if (getAttrKind() == attr::TypeNullableResult) 4606 return NullabilityKind::NullableResult; 4607 return std::nullopt; 4608} 4609 4610std::optional<NullabilityKind> 4611AttributedType::stripOuterNullability(QualType &T) { 4612 QualType AttrTy = T; 4613 if (auto MacroTy = dyn_cast<MacroQualifiedType>(T)) 4614 AttrTy = MacroTy->getUnderlyingType(); 4615 4616 if (auto attributed = dyn_cast<AttributedType>(AttrTy)) { 4617 if (auto nullability = attributed->getImmediateNullability()) { 4618 T = attributed->getModifiedType(); 4619 return nullability; 4620 } 4621 } 4622 4623 return std::nullopt; 4624} 4625 4626bool Type::isBlockCompatibleObjCPointerType(ASTContext &ctx) const { 4627 const auto *objcPtr = getAs<ObjCObjectPointerType>(); 4628 if (!objcPtr) 4629 return false; 4630 4631 if (objcPtr->isObjCIdType()) { 4632 // id is always okay. 4633 return true; 4634 } 4635 4636 // Blocks are NSObjects. 4637 if (ObjCInterfaceDecl *iface = objcPtr->getInterfaceDecl()) { 4638 if (iface->getIdentifier() != ctx.getNSObjectName()) 4639 return false; 4640 4641 // Continue to check qualifiers, below. 4642 } else if (objcPtr->isObjCQualifiedIdType()) { 4643 // Continue to check qualifiers, below. 4644 } else { 4645 return false; 4646 } 4647 4648 // Check protocol qualifiers. 4649 for (ObjCProtocolDecl *proto : objcPtr->quals()) { 4650 // Blocks conform to NSObject and NSCopying. 4651 if (proto->getIdentifier() != ctx.getNSObjectName() && 4652 proto->getIdentifier() != ctx.getNSCopyingName()) 4653 return false; 4654 } 4655 4656 return true; 4657} 4658 4659Qualifiers::ObjCLifetime Type::getObjCARCImplicitLifetime() const { 4660 if (isObjCARCImplicitlyUnretainedType()) 4661 return Qualifiers::OCL_ExplicitNone; 4662 return Qualifiers::OCL_Strong; 4663} 4664 4665bool Type::isObjCARCImplicitlyUnretainedType() const { 4666 assert(isObjCLifetimeType() && 4667 "cannot query implicit lifetime for non-inferrable type"); 4668 4669 const Type *canon = getCanonicalTypeInternal().getTypePtr(); 4670 4671 // Walk down to the base type. We don't care about qualifiers for this. 4672 while (const auto *array = dyn_cast<ArrayType>(canon)) 4673 canon = array->getElementType().getTypePtr(); 4674 4675 if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) { 4676 // Class and Class<Protocol> don't require retention. 4677 if (opt->getObjectType()->isObjCClass()) 4678 return true; 4679 } 4680 4681 return false; 4682} 4683 4684bool Type::isObjCNSObjectType() const { 4685 if (const auto *typedefType = getAs<TypedefType>()) 4686 return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>(); 4687 return false; 4688} 4689 4690bool Type::isObjCIndependentClassType() const { 4691 if (const auto *typedefType = getAs<TypedefType>()) 4692 return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>(); 4693 return false; 4694} 4695 4696bool Type::isObjCRetainableType() const { 4697 return isObjCObjectPointerType() || 4698 isBlockPointerType() || 4699 isObjCNSObjectType(); 4700} 4701 4702bool Type::isObjCIndirectLifetimeType() const { 4703 if (isObjCLifetimeType()) 4704 return true; 4705 if (const auto *OPT = getAs<PointerType>()) 4706 return OPT->getPointeeType()->isObjCIndirectLifetimeType(); 4707 if (const auto *Ref = getAs<ReferenceType>()) 4708 return Ref->getPointeeType()->isObjCIndirectLifetimeType(); 4709 if (const auto *MemPtr = getAs<MemberPointerType>()) 4710 return MemPtr->getPointeeType()->isObjCIndirectLifetimeType(); 4711 return false; 4712} 4713 4714/// Returns true if objects of this type have lifetime semantics under 4715/// ARC. 4716bool Type::isObjCLifetimeType() const { 4717 const Type *type = this; 4718 while (const ArrayType *array = type->getAsArrayTypeUnsafe()) 4719 type = array->getElementType().getTypePtr(); 4720 return type->isObjCRetainableType(); 4721} 4722 4723/// Determine whether the given type T is a "bridgable" Objective-C type, 4724/// which is either an Objective-C object pointer type or an 4725bool Type::isObjCARCBridgableType() const { 4726 return isObjCObjectPointerType() || isBlockPointerType(); 4727} 4728 4729/// Determine whether the given type T is a "bridgeable" C type. 4730bool Type::isCARCBridgableType() const { 4731 const auto *Pointer = getAs<PointerType>(); 4732 if (!Pointer) 4733 return false; 4734 4735 QualType Pointee = Pointer->getPointeeType(); 4736 return Pointee->isVoidType() || Pointee->isRecordType(); 4737} 4738 4739/// Check if the specified type is the CUDA device builtin surface type. 4740bool Type::isCUDADeviceBuiltinSurfaceType() const { 4741 if (const auto *RT = getAs<RecordType>()) 4742 return RT->getDecl()->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>(); 4743 return false; 4744} 4745 4746/// Check if the specified type is the CUDA device builtin texture type. 4747bool Type::isCUDADeviceBuiltinTextureType() const { 4748 if (const auto *RT = getAs<RecordType>()) 4749 return RT->getDecl()->hasAttr<CUDADeviceBuiltinTextureTypeAttr>(); 4750 return false; 4751} 4752 4753bool Type::hasSizedVLAType() const { 4754 if (!isVariablyModifiedType()) return false; 4755 4756 if (const auto *ptr = getAs<PointerType>()) 4757 return ptr->getPointeeType()->hasSizedVLAType(); 4758 if (const auto *ref = getAs<ReferenceType>()) 4759 return ref->getPointeeType()->hasSizedVLAType(); 4760 if (const ArrayType *arr = getAsArrayTypeUnsafe()) { 4761 if (isa<VariableArrayType>(arr) && 4762 cast<VariableArrayType>(arr)->getSizeExpr()) 4763 return true; 4764 4765 return arr->getElementType()->hasSizedVLAType(); 4766 } 4767 4768 return false; 4769} 4770 4771QualType::DestructionKind QualType::isDestructedTypeImpl(QualType type) { 4772 switch (type.getObjCLifetime()) { 4773 case Qualifiers::OCL_None: 4774 case Qualifiers::OCL_ExplicitNone: 4775 case Qualifiers::OCL_Autoreleasing: 4776 break; 4777 4778 case Qualifiers::OCL_Strong: 4779 return DK_objc_strong_lifetime; 4780 case Qualifiers::OCL_Weak: 4781 return DK_objc_weak_lifetime; 4782 } 4783 4784 if (const auto *RT = 4785 type->getBaseElementTypeUnsafe()->getAs<RecordType>()) { 4786 const RecordDecl *RD = RT->getDecl(); 4787 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) { 4788 /// Check if this is a C++ object with a non-trivial destructor. 4789 if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor()) 4790 return DK_cxx_destructor; 4791 } else { 4792 /// Check if this is a C struct that is non-trivial to destroy or an array 4793 /// that contains such a struct. 4794 if (RD->isNonTrivialToPrimitiveDestroy()) 4795 return DK_nontrivial_c_struct; 4796 } 4797 } 4798 4799 return DK_none; 4800} 4801 4802CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const { 4803 return getClass()->getAsCXXRecordDecl()->getMostRecentNonInjectedDecl(); 4804} 4805 4806void clang::FixedPointValueToString(SmallVectorImpl<char> &Str, 4807 llvm::APSInt Val, unsigned Scale) { 4808 llvm::FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(), 4809 /*IsSaturated=*/false, 4810 /*HasUnsignedPadding=*/false); 4811 llvm::APFixedPoint(Val, FXSema).toString(Str); 4812} 4813 4814AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword, 4815 TypeDependence ExtraDependence, QualType Canon, 4816 ConceptDecl *TypeConstraintConcept, 4817 ArrayRef<TemplateArgument> TypeConstraintArgs) 4818 : DeducedType(Auto, DeducedAsType, ExtraDependence, Canon) { 4819 AutoTypeBits.Keyword = llvm::to_underlying(Keyword); 4820 AutoTypeBits.NumArgs = TypeConstraintArgs.size(); 4821 this->TypeConstraintConcept = TypeConstraintConcept; 4822 assert(TypeConstraintConcept || AutoTypeBits.NumArgs == 0); 4823 if (TypeConstraintConcept) { 4824 auto *ArgBuffer = 4825 const_cast<TemplateArgument *>(getTypeConstraintArguments().data()); 4826 for (const TemplateArgument &Arg : TypeConstraintArgs) { 4827 // We only syntactically depend on the constraint arguments. They don't 4828 // affect the deduced type, only its validity. 4829 addDependence( 4830 toSyntacticDependence(toTypeDependence(Arg.getDependence()))); 4831 4832 new (ArgBuffer++) TemplateArgument(Arg); 4833 } 4834 } 4835} 4836 4837void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, 4838 QualType Deduced, AutoTypeKeyword Keyword, 4839 bool IsDependent, ConceptDecl *CD, 4840 ArrayRef<TemplateArgument> Arguments) { 4841 ID.AddPointer(Deduced.getAsOpaquePtr()); 4842 ID.AddInteger((unsigned)Keyword); 4843 ID.AddBoolean(IsDependent); 4844 ID.AddPointer(CD); 4845 for (const TemplateArgument &Arg : Arguments) 4846 Arg.Profile(ID, Context); 4847} 4848 4849void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) { 4850 Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(), 4851 getTypeConstraintConcept(), getTypeConstraintArguments()); 4852} 4853