17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/PointerIntPair.h"
38#include "llvm/ADT/PointerUnion.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/ADT/Twine.h"
41#include "llvm/ADT/iterator_range.h"
42#include "llvm/Support/Casting.h"
43#include "llvm/Support/Compiler.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/PointerLikeTypeTraits.h"
46#include "llvm/Support/TrailingObjects.h"
47#include "llvm/Support/type_traits.h"
64class TemplateParameterList;
72namespace serialization {
73 template <
class T>
class AbstractTypeReader;
110template <
typename>
class CanQual;
115class ExtQualsTypeCommonBase;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;
132class UsingShadowDecl;
137#define TYPE(Class, Base) class Class##Type;
138#include "clang/AST/TypeNodes.inc"
201 Q.Mask = L.Mask & R.Mask;
298 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
299 Mask = (Mask & ~CVRMask) | mask;
302 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
309 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
313 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
319 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
327 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
352 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
355 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
361 Mask |= (
type << LifetimeShift);
378 return static_cast<LangAS>(Mask >> AddressSpaceShift);
399 Mask = (Mask & ~AddressSpaceMask)
400 | (((uint32_t) space) << AddressSpaceShift);
413 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
414 Mask = (Mask & ~FastMask) | mask;
417 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
424 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
439 bool empty()
const {
return !Mask; }
604 bool appendSpaceIfNonEmpty =
false)
const;
606 void Profile(llvm::FoldingSetNodeID &ID)
const {
615 static const uint32_t UMask = 0x8;
616 static const uint32_t UShift = 3;
617 static const uint32_t GCAttrMask = 0x30;
618 static const uint32_t GCAttrShift = 4;
619 static const uint32_t LifetimeMask = 0x1C0;
620 static const uint32_t LifetimeShift = 6;
621 static const uint32_t AddressSpaceMask =
622 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask);
623 static const uint32_t AddressSpaceShift = 9;
633 : Quals(Quals), HasAtomic(HasAtomic) {}
682 std::pair<const Type *,Qualifiers>
asPair()
const {
683 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
687 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
690 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
740 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
743 const ExtQuals *getExtQualsUnsafe()
const {
747 const Type *getTypePtrUnsafe()
const {
748 return Value.getPointer().get<
const Type*>();
751 const ExtQualsTypeCommonBase *getCommonPtr()
const {
752 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
753 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
755 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
787 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
804 return Value.getPointer().isNull();
944 &&
"non-fast qualifier bits set in mask!");
1069 return getSingleStepDesugaredTypeImpl(*
this, Context);
1075 if (isa<ParenType>(*
this))
1082 return LHS.Value == RHS.Value;
1085 return LHS.Value != RHS.Value;
1088 return LHS.Value < RHS.Value;
1102 const Twine &PlaceHolder = Twine(),
1103 unsigned Indentation = 0)
const;
1107 unsigned Indentation = 0) {
1113 const Twine &PlaceHolder,
1114 unsigned Indentation = 0);
1131 const Twine &PlaceHolder;
1132 unsigned Indentation;
1136 const Twine &PlaceHolder,
unsigned Indentation)
1137 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1138 Indentation(Indentation) {}
1142 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1148 const Twine &PlaceHolder = Twine(),
1149 unsigned Indentation = 0)
const {
1153 void dump(
const char *
s)
const;
1155 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1291 return isDestructedTypeImpl(*
this);
1389raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1409 return P.getAsOpaquePtr();
1417 static constexpr int NumLowBitsAvailable = 0;
1437 const Type *
const BaseType;
1443 : BaseType(baseType), CanonicalType(canon) {}
1479 canon.isNull() ?
QualType(this_(), 0) : canon),
1482 &&
"ExtQuals created with no fast qualifiers");
1484 &&
"ExtQuals created with fast qualifiers");
1508 const Type *BaseType,
1511 ID.AddPointer(BaseType);
1571#define TYPE(Class, Base) Class,
1572#define LAST_TYPE(Class) TypeLast = Class
1573#define ABSTRACT_TYPE(Class, Base)
1574#include "clang/AST/TypeNodes.inc"
1579 class TypeBitfields {
1581 template <
class T>
friend class TypePropertyCache;
1587 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1591 mutable unsigned CacheValid : 1;
1594 mutable unsigned CachedLinkage : 3;
1597 mutable unsigned CachedLocalOrUnnamed : 1;
1600 mutable unsigned FromAST : 1;
1602 bool isCacheValid()
const {
1607 assert(isCacheValid() &&
"getting linkage from invalid cache");
1608 return static_cast<Linkage>(CachedLinkage);
1611 bool hasLocalOrUnnamedType()
const {
1612 assert(isCacheValid() &&
"getting linkage from invalid cache");
1613 return CachedLocalOrUnnamed;
1616 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1629 unsigned IndexTypeQuals : 3;
1634 unsigned SizeModifier : 3;
1643 unsigned HasStoredSizeExpr : 1;
1666 unsigned ExtInfo : 13;
1671 unsigned RefQualifier : 2;
1681 unsigned HasExtQuals : 1;
1687 unsigned NumParams : 16;
1690 unsigned ExceptionSpecType : 4;
1693 unsigned HasExtParameterInfos : 1;
1696 unsigned HasExtraBitfields : 1;
1699 unsigned Variadic : 1;
1702 unsigned HasTrailingReturn : 1;
1711 unsigned NumTypeArgs : 7;
1714 unsigned NumProtocols : 6;
1717 unsigned IsKindOf : 1;
1736 unsigned SpelledAsLValue : 1;
1740 unsigned InnerRef : 1;
1749 unsigned Keyword : 8;
1761 unsigned HasOwnedTagDecl : 1;
1772 unsigned VecKind : 4;
1774 uint32_t NumElements;
1783 unsigned AttrKind : 32 - NumTypeBits;
1793 unsigned Keyword : 2;
1810 unsigned IsUnqual : 1;
1819 unsigned hasTypeDifferentFromDecl : 1;
1828 unsigned hasTypeDifferentFromDecl : 1;
1836 unsigned HasNonCanonicalUnderlyingType : 1;
1839 unsigned Index : 15;
1846 unsigned PackIndex : 16;
1855 unsigned Index : 16;
1861 unsigned NumArgs : 16;
1870 unsigned TypeAlias : 1;
1914 unsigned NumExpansions;
1945 void setFromAST(
bool V =
true)
const {
1956 "changing bitfields changed sizeof(Type)!");
1957 static_assert(
alignof(
decltype(*this)) %
sizeof(
void *) == 0,
1958 "Insufficient alignment!");
1962 TypeBits.CachedLocalOrUnnamed =
false;
1971 TypeBits.Dependence =
static_cast<unsigned>(D);
2014 return CanonicalType ==
QualType(
this, 0);
2223 return hasAttr(attr::ObjCInertUnsafeUnretained);
2262#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2263 bool is##Id##Type() const;
2264#include "clang/Basic/OpenCLImageTypes.def"
2274#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2275 bool is##Id##Type() const;
2276#include "clang/Basic/OpenCLExtensionTypes.def"
2297 bool isRVVType(
unsigned Bitwidth,
bool IsFloat)
const;
2449 template <
typename T>
const T *
getAs()
const;
2468 template <
typename T>
const T *
castAs()
const;
2600 std::optional<ArrayRef<QualType>>
2610 return CanonicalType;
2615 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
2620template <>
const TypedefType *
Type::getAs()
const;
2626template <>
const TemplateSpecializationType *
Type::getAs()
const;
2630template <>
const AttributedType *
Type::getAs()
const;
2634#define TYPE(Class, Base)
2635#define LEAF_TYPE(Class) \
2636template <> inline const Class##Type *Type::getAs() const { \
2637 return dyn_cast<Class##Type>(CanonicalType); \
2639template <> inline const Class##Type *Type::castAs() const { \
2640 return cast<Class##Type>(CanonicalType); \
2642#include "clang/AST/TypeNodes.inc"
2650#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2651#include "clang/Basic/OpenCLImageTypes.def"
2653#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2654#include "clang/Basic/OpenCLExtensionTypes.def"
2656#define SVE_TYPE(Name, Id, SingletonId) Id,
2657#include "clang/Basic/AArch64SVEACLETypes.def"
2659#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2660#include "clang/Basic/PPCTypes.def"
2662#define RVV_TYPE(Name, Id, SingletonId) Id,
2663#include "clang/Basic/RISCVVTypes.def"
2665#define WASM_TYPE(Name, Id, SingletonId) Id,
2666#include "clang/Basic/WebAssemblyReferenceTypes.def"
2668#define BUILTIN_TYPE(Id, SingletonId) Id,
2669#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2670#include "clang/AST/BuiltinTypes.def"
2689 StringRef str =
getName(Policy);
2690 assert(!str.empty() && str.data()[str.size()] ==
'\0');
2719 return K >= Overload;
2754 ElementType(Element) {}
2807 PointeeType(Pointee) {}
2839 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2849 Profile(ID, OriginalTy, AdjustedTy);
2888 PointeeType(Pointee) {}
2916 bool SpelledAsLValue)
2918 PointeeType(Referencee) {
2934 return T->PointeeType;
2943 bool SpelledAsLValue) {
2945 ID.AddBoolean(SpelledAsLValue);
2959 bool SpelledAsLValue)
3001 :
Type(MemberPointer, CanonicalPtr,
3004 PointeeType(Pointee), Class(Cls) {}
3032 const Type *Class) {
3034 ID.AddPointer(Class);
3061 unsigned tq,
const Expr *sz =
nullptr);
3091 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
3093 friend TrailingObjects;
3099 :
ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
3102 assert(!can.
isNull() &&
"canonical constant array should not have size");
3103 *getTrailingObjects<const Expr*>() = sz;
3107 unsigned numTrailingObjects(OverloadToken<const Expr*>)
const {
3112 const llvm::APInt &
getSize()
const {
return Size; }
3115 ? *getTrailingObjects<const Expr *>()
3125 const llvm::APInt &NumElements);
3137 QualType ET,
const llvm::APInt &ArraySize,
3139 unsigned TypeQuals);
3154 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3174 ID.AddInteger(SizeMod);
3175 ID.AddInteger(TypeQuals);
3206 :
ArrayType(VariableArray, et, can, sm, tq, e),
3207 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3215 return (
Expr*) SizeExpr;
3230 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3272 return (
Expr*) SizeExpr;
3293 unsigned TypeQuals,
Expr *E);
3311 Expr *AddrSpaceExpr;
3452 ID.AddInteger(NumElements);
3454 ID.AddInteger(VecKind);
3523 case 'x':
case 'r':
return 0;
3524 case 'y':
case 'g':
return 1;
3525 case 'z':
case 'b':
return 2;
3526 case 'w':
case 'a':
return 3;
3544 case 'a':
return 10;
3546 case 'b':
return 11;
3548 case 'c':
return 12;
3550 case 'd':
return 13;
3552 case 'e':
return 14;
3554 case 'f':
return 15;
3559 if (isNumericAccessor)
3592 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
3629 unsigned NColumns,
QualType CanonElementType);
3632 unsigned NColumns,
QualType CanonElementType);
3739 HasPassObjSize = 0x20,
3742 unsigned char Data = 0;
3751 copy.Data = (copy.Data & ~ABIMask) |
unsigned(kind);
3761 copy.Data |= IsConsumed;
3763 copy.Data &= ~IsConsumed;
3770 Copy.Data |= HasPassObjSize;
3778 Copy.Data |= IsNoEscape;
3780 Copy.Data &= ~IsNoEscape;
3792 return lhs.Data == rhs.Data;
3796 return lhs.Data != rhs.Data;
3831 enum { CallConvMask = 0x1F };
3832 enum { NoReturnMask = 0x20 };
3833 enum { ProducesResultMask = 0x40 };
3834 enum { NoCallerSavedRegsMask = 0x80 };
3836 RegParmMask = 0x700,
3839 enum { NoCfCheckMask = 0x800 };
3840 enum { CmseNSCallMask = 0x1000 };
3841 uint16_t Bits =
CC_C;
3843 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3849 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
3851 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
3852 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3853 (producesResult ? ProducesResultMask : 0) |
3854 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3855 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3856 (NoCfCheck ? NoCfCheckMask : 0) |
3857 (cmseNSCall ? CmseNSCallMask : 0);
3873 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3876 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3885 return Bits == Other.Bits;
3888 return Bits != Other.Bits;
3896 return ExtInfo(Bits | NoReturnMask);
3898 return ExtInfo(Bits & ~NoReturnMask);
3903 return ExtInfo(Bits | ProducesResultMask);
3905 return ExtInfo(Bits & ~ProducesResultMask);
3910 return ExtInfo(Bits | CmseNSCallMask);
3912 return ExtInfo(Bits & ~CmseNSCallMask);
3916 if (noCallerSavedRegs)
3917 return ExtInfo(Bits | NoCallerSavedRegsMask);
3919 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3924 return ExtInfo(Bits | NoCfCheckMask);
3926 return ExtInfo(Bits & ~NoCfCheckMask);
3930 assert(RegParm < 7 &&
"Invalid regparm value");
3931 return ExtInfo((Bits & ~RegParmMask) |
3932 ((RegParm + 1) << RegParmOffset));
3936 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
3940 ID.AddInteger(Bits);
3989 "Const, volatile and restrict are assumed to be a subset of "
3990 "the fast qualifiers.");
4052 public llvm::FoldingSetNode,
4053 private llvm::TrailingObjects<
4054 FunctionProtoType, QualType, SourceLocation,
4055 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
4056 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
4058 friend TrailingObjects;
4150 Result.ExceptionSpec = ESI;
4160 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
4164 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
4168 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
4169 return hasExtraBitfields();
4172 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
4173 return getExceptionSpecSize().NumExceptionType;
4176 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4177 return getExceptionSpecSize().NumExprPtr;
4180 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
4181 return getExceptionSpecSize().NumFunctionDeclPtr;
4184 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
4190 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
4192 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
4199 FunctionProtoType(QualType result, ArrayRef<QualType> params,
4200 QualType canonical,
const ExtProtoInfo &epi);
4205 struct ExceptionSpecSizeHolder {
4206 unsigned NumExceptionType;
4207 unsigned NumExprPtr;
4208 unsigned NumFunctionDeclPtr;
4213 static ExceptionSpecSizeHolder
4225 return {NumExceptions, 0, 0};
4238 llvm_unreachable(
"bad exception specification kind");
4243 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
4248 bool hasExtraBitfields()
const {
4251 "ExtraBitfields are required for given ExceptionSpecType");
4256 bool hasExtQualifiers()
const {
4264 assert(i <
getNumParams() &&
"invalid parameter index");
4331 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4347 return *getTrailingObjects<Expr *>();
4358 return getTrailingObjects<FunctionDecl *>()[0];
4368 return getTrailingObjects<FunctionDecl *>()[1];
4386 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4402 if (hasExtQualifiers())
4403 return *getTrailingObjects<Qualifiers>();
4420 return getTrailingObjects<QualType>();
4435 getTrailingObjects<ExceptionType>());
4460 return getTrailingObjects<ExtParameterInfo>();
4464 assert(I <
getNumParams() &&
"parameter index out of range");
4466 return getTrailingObjects<ExtParameterInfo>()[I];
4471 assert(I <
getNumParams() &&
"parameter index out of range");
4473 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4478 assert(I <
getNumParams() &&
"parameter index out of range");
4480 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4537 public llvm::FoldingSetNode,
4538 private llvm::TrailingObjects<UsingType, QualType> {
4541 friend TrailingObjects;
4562 ID.AddPointer(Found);
4563 if (!Underlying.
isNull())
4570 public llvm::FoldingSetNode,
4571 private llvm::TrailingObjects<TypedefType, QualType> {
4574 friend TrailingObjects;