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/None.h"
38 #include "llvm/ADT/Optional.h"
39 #include "llvm/ADT/PointerIntPair.h"
40 #include "llvm/ADT/PointerUnion.h"
41 #include "llvm/ADT/StringRef.h"
42 #include "llvm/ADT/Twine.h"
43 #include "llvm/ADT/iterator_range.h"
44 #include "llvm/Support/Casting.h"
45 #include "llvm/Support/Compiler.h"
46 #include "llvm/Support/ErrorHandling.h"
47 #include "llvm/Support/PointerLikeTypeTraits.h"
48 #include "llvm/Support/TrailingObjects.h"
49 #include "llvm/Support/type_traits.h"
55 #include <type_traits>
65 class TemplateParameterList;
73 namespace serialization {
74 template <
class T>
class AbstractTypeReader;
111 template <
typename>
class CanQual;
116 class ExtQualsTypeCommonBase;
118 class IdentifierInfo;
120 class ObjCInterfaceDecl;
121 class ObjCProtocolDecl;
122 class ObjCTypeParamDecl;
123 struct PrintingPolicy;
127 class TemplateArgument;
128 class TemplateArgumentListInfo;
129 class TemplateArgumentLoc;
130 class TemplateTypeParmDecl;
131 class TypedefNameDecl;
132 class UnresolvedUsingTypenameDecl;
133 class UsingShadowDecl;
138 #define TYPE(Class, Base) class Class##Type;
139 #include "clang/AST/TypeNodes.inc"
202 Q.Mask = L.Mask & R.Mask;
299 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
300 Mask = (Mask & ~
CVRMask) | mask;
303 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
310 assert(!(mask & ~
CVRMask) &&
"bitmask contains non-CVR bits");
314 assert(!(mask & ~
CVRMask & ~UMask) &&
"bitmask contains non-CVRU bits");
320 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
328 Mask = (Mask & ~GCAttrMask) | (
type << GCAttrShift);
353 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
356 Mask = (Mask & ~LifetimeMask) | (
type << LifetimeShift);
362 Mask |= (
type << LifetimeShift);
379 return static_cast<LangAS>(Mask >> AddressSpaceShift);
400 Mask = (Mask & ~AddressSpaceMask)
401 | (((uint32_t) space) << AddressSpaceShift);
414 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
418 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
425 assert(!(mask & ~
FastMask) &&
"bitmask contains non-fast qualifier bits");
440 bool empty()
const {
return !Mask; }
605 bool appendSpaceIfNonEmpty =
false)
const;
616 static const uint32_t UMask = 0x8;
617 static const uint32_t UShift = 3;
618 static const uint32_t GCAttrMask = 0x30;
619 static const uint32_t GCAttrShift = 4;
620 static const uint32_t LifetimeMask = 0x1C0;
621 static const uint32_t LifetimeShift = 6;
622 static const uint32_t AddressSpaceMask =
623 ~(
CVRMask | UMask | GCAttrMask | LifetimeMask);
624 static const uint32_t AddressSpaceShift = 9;
634 : Quals(Quals), HasAtomic(HasAtomic) {}
683 std::pair<const Type *,Qualifiers>
asPair()
const {
684 return std::pair<const Type *, Qualifiers>(
Ty,
Quals);
688 return a.
Ty ==
b.Ty && a.
Quals ==
b.Quals;
691 return a.
Ty !=
b.Ty || a.
Quals !=
b.Quals;
735 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
738 const ExtQuals *getExtQualsUnsafe()
const {
742 const Type *getTypePtrUnsafe()
const {
743 return Value.getPointer().get<
const Type*>();
746 const ExtQualsTypeCommonBase *getCommonPtr()
const {
747 assert(!
isNull() &&
"Cannot retrieve a NULL type pointer");
748 auto CommonPtrVal =
reinterpret_cast<uintptr_t>(
Value.getOpaqueValue());
750 return reinterpret_cast<ExtQualsTypeCommonBase*
>(CommonPtrVal);
780 T.Value.setFromOpaqueValue(
const_cast<void*
>(Ptr));
797 return Value.getPointer().isNull();
931 &&
"non-fast qualifier bits set in mask!");
1057 return getSingleStepDesugaredTypeImpl(*
this, Context);
1063 if (isa<ParenType>(*
this))
1070 return LHS.Value == RHS.Value;
1073 return LHS.Value != RHS.Value;
1076 return LHS.Value < RHS.Value;
1090 const Twine &PlaceHolder = Twine(),
1091 unsigned Indentation = 0)
const;
1095 unsigned Indentation = 0) {
1101 const Twine &PlaceHolder,
1102 unsigned Indentation = 0);
1119 const Twine &PlaceHolder;
1120 unsigned Indentation;
1124 const Twine &PlaceHolder,
unsigned Indentation)
1125 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1126 Indentation(Indentation) {}
1130 SQT.T.
print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1136 const Twine &PlaceHolder = Twine(),
1137 unsigned Indentation = 0)
const {
1141 void dump(
const char *
s)
const;
1143 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
1279 return isDestructedTypeImpl(*
this);
1377 raw_ostream &
operator<<(raw_ostream &OS, QualType QT);
1397 return P.getAsOpaquePtr();
1405 static constexpr
int NumLowBitsAvailable = 0;
1425 const Type *
const BaseType;
1431 : BaseType(baseType), CanonicalType(canon) {}
1467 canon.isNull() ?
QualType(this_(), 0) : canon),
1470 &&
"ExtQuals created with no fast qualifiers");
1472 &&
"ExtQuals created with fast qualifiers");
1496 const Type *BaseType,
1499 ID.AddPointer(BaseType);
1559 #define TYPE(Class, Base) Class,
1560 #define LAST_TYPE(Class) TypeLast = Class
1561 #define ABSTRACT_TYPE(Class, Base)
1562 #include "clang/AST/TypeNodes.inc"
1567 class TypeBitfields {
1575 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1579 mutable unsigned CacheValid : 1;
1582 mutable unsigned CachedLinkage : 3;
1585 mutable unsigned CachedLocalOrUnnamed : 1;
1588 mutable unsigned FromAST : 1;
1590 bool isCacheValid()
const {
1595 assert(isCacheValid() &&
"getting linkage from invalid cache");
1596 return static_cast<Linkage>(CachedLinkage);
1599 bool hasLocalOrUnnamedType()
const {
1600 assert(isCacheValid() &&
"getting linkage from invalid cache");
1601 return CachedLocalOrUnnamed;
1604 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1617 unsigned IndexTypeQuals : 3;
1622 unsigned SizeModifier : 3;
1631 unsigned HasStoredSizeExpr : 1;
1654 unsigned ExtInfo : 13;
1659 unsigned RefQualifier : 2;
1669 unsigned HasExtQuals : 1;
1675 unsigned NumParams : 16;
1678 unsigned ExceptionSpecType : 4;
1681 unsigned HasExtParameterInfos : 1;
1684 unsigned HasExtraBitfields : 1;
1687 unsigned Variadic : 1;
1690 unsigned HasTrailingReturn : 1;
1699 unsigned NumTypeArgs : 7;
1702 unsigned NumProtocols : 6;
1705 unsigned IsKindOf : 1;
1724 unsigned SpelledAsLValue : 1;
1728 unsigned InnerRef : 1;
1737 unsigned Keyword : 8;
1749 unsigned HasOwnedTagDecl : 1;
1760 unsigned VecKind : 3;
1762 uint32_t NumElements;
1771 unsigned AttrKind : 32 - NumTypeBits;
1781 unsigned Keyword : 2;
1814 unsigned TypeAlias : 1;
1858 unsigned NumExpansions;
1885 void setFromAST(
bool V =
true)
const {
1896 "changing bitfields changed sizeof(Type)!");
1897 static_assert(
alignof(decltype(*
this)) %
sizeof(
void *) == 0,
1898 "Insufficient alignment!");
1902 TypeBits.CachedLocalOrUnnamed =
false;
1911 TypeBits.Dependence =
static_cast<unsigned>(D);
1954 return CanonicalType ==
QualType(
this, 0);
2143 return hasAttr(attr::ObjCInertUnsafeUnretained);
2181 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2182 bool is##Id##Type() const;
2183 #include "clang/Basic/OpenCLImageTypes.def"
2193 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2194 bool is##Id##Type() const;
2195 #include "clang/Basic/OpenCLExtensionTypes.def"
2364 template <
typename T>
const T *
getAs()
const;
2383 template <
typename T>
const T *
castAs()
const;
2528 return CanonicalType;
2533 void dump(llvm::raw_ostream &OS,
const ASTContext &Context)
const;
2538 template <>
const TypedefType *
Type::getAs()
const;
2543 template <>
const TemplateSpecializationType *
Type::getAs()
const;
2547 template <>
const AttributedType *
Type::getAs()
const;
2551 #define TYPE(Class, Base)
2552 #define LEAF_TYPE(Class) \
2553 template <> inline const Class##Type *Type::getAs() const { \
2554 return dyn_cast<Class##Type>(CanonicalType); \
2556 template <> inline const Class##Type *Type::castAs() const { \
2557 return cast<Class##Type>(CanonicalType); \
2559 #include "clang/AST/TypeNodes.inc"
2567 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2568 #include "clang/Basic/OpenCLImageTypes.def"
2570 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2571 #include "clang/Basic/OpenCLExtensionTypes.def"
2573 #define SVE_TYPE(Name, Id, SingletonId) Id,
2574 #include "clang/Basic/AArch64SVEACLETypes.def"
2576 #define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2577 #include "clang/Basic/PPCTypes.def"
2579 #define RVV_TYPE(Name, Id, SingletonId) Id,
2580 #include "clang/Basic/RISCVVTypes.def"
2582 #define BUILTIN_TYPE(Id, SingletonId) Id,
2583 #define LAST_BUILTIN_TYPE(Id) LastKind = Id
2584 #include "clang/AST/BuiltinTypes.def"
2603 StringRef str =
getName(Policy);
2604 assert(!str.empty() && str.data()[str.size()] ==
'\0');
2631 return K >= Overload;
2666 ElementType(Element) {}
2719 PointeeType(Pointee) {}
2751 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2800 PointeeType(Pointee) {}
2828 bool SpelledAsLValue)
2830 PointeeType(Referencee) {
2846 return T->PointeeType;
2855 bool SpelledAsLValue) {
2857 ID.AddBoolean(SpelledAsLValue);
2871 bool SpelledAsLValue)
2913 :
Type(MemberPointer, CanonicalPtr,
2916 PointeeType(Pointee), Class(Cls) {}
2944 const Type *Class) {
2946 ID.AddPointer(Class);
2973 unsigned tq,
const Expr *sz =
nullptr);
3003 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
3005 friend TrailingObjects;
3011 :
ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
3014 assert(!can.
isNull() &&
"canonical constant array should not have size");
3015 *getTrailingObjects<const Expr*>() = sz;
3019 unsigned numTrailingObjects(OverloadToken<const Expr*>)
const {
3027 ? *getTrailingObjects<const Expr *>()
3051 unsigned TypeQuals);
3066 :
ArrayType(IncompleteArray, et, can, sm, tq) {}
3086 ID.AddInteger(SizeMod);
3087 ID.AddInteger(TypeQuals);
3118 :
ArrayType(VariableArray, et, can, sm, tq, e),
3119 SizeExpr((
Stmt*) e), Brackets(brackets) {}
3127 return (
Expr*) SizeExpr;
3142 llvm_unreachable(
"Cannot unique VariableArrayTypes.");
3184 return (
Expr*) SizeExpr;
3205 unsigned TypeQuals,
Expr *E);
3223 Expr *AddrSpaceExpr;
3361 ID.AddInteger(NumElements);
3363 ID.AddInteger(VecKind);
3432 case 'x':
case 'r':
return 0;
3433 case 'y':
case 'g':
return 1;
3434 case 'z':
case 'b':
return 2;
3435 case 'w':
case 'a':
return 3;
3453 case 'a':
return 10;
3455 case 'b':
return 11;
3457 case 'c':
return 12;
3459 case 'd':
return 13;
3461 case 'e':
return 14;
3463 case 'f':
return 15;
3468 if (isNumericAccessor)
3501 const Expr *RowExpr =
nullptr,
const Expr *ColumnExpr =
nullptr);
3538 unsigned NColumns,
QualType CanonElementType);
3541 unsigned NColumns,
QualType CanonElementType);
3648 HasPassObjSize = 0x20,
3651 unsigned char Data = 0;
3660 copy.Data = (copy.Data & ~ABIMask) |
unsigned(
kind);
3670 copy.Data |= IsConsumed;
3672 copy.Data &= ~IsConsumed;
3679 Copy.Data |= HasPassObjSize;
3687 Copy.Data |= IsNoEscape;
3689 Copy.Data &= ~IsNoEscape;
3701 return lhs.Data == rhs.Data;
3705 return lhs.Data != rhs.Data;
3740 enum { CallConvMask = 0x1F };
3741 enum { NoReturnMask = 0x20 };
3742 enum { ProducesResultMask = 0x40 };
3743 enum { NoCallerSavedRegsMask = 0x80 };
3745 RegParmMask = 0x700,
3748 enum { NoCfCheckMask = 0x800 };
3749 enum { CmseNSCallMask = 0x1000 };
3750 uint16_t Bits =
CC_C;
3752 ExtInfo(
unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3758 bool producesResult,
bool noCallerSavedRegs,
bool NoCfCheck,
3760 assert((!hasRegParm || regParm < 7) &&
"Invalid regparm value");
3761 Bits = ((
unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3762 (producesResult ? ProducesResultMask : 0) |
3763 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3764 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3765 (NoCfCheck ? NoCfCheckMask : 0) |
3766 (cmseNSCall ? CmseNSCallMask : 0);
3782 bool getHasRegParm()
const {
return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3785 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3794 return Bits == Other.Bits;
3797 return Bits != Other.Bits;
3805 return ExtInfo(Bits | NoReturnMask);
3807 return ExtInfo(Bits & ~NoReturnMask);
3812 return ExtInfo(Bits | ProducesResultMask);
3814 return ExtInfo(Bits & ~ProducesResultMask);
3819 return ExtInfo(Bits | CmseNSCallMask);
3821 return ExtInfo(Bits & ~CmseNSCallMask);
3825 if (noCallerSavedRegs)
3826 return ExtInfo(Bits | NoCallerSavedRegsMask);
3828 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3833 return ExtInfo(Bits | NoCfCheckMask);
3835 return ExtInfo(Bits & ~NoCfCheckMask);
3839 assert(RegParm < 7 &&
"Invalid regparm value");
3840 return ExtInfo((Bits & ~RegParmMask) |
3841 ((RegParm + 1) << RegParmOffset));
3845 return ExtInfo((Bits & ~CallConvMask) | (
unsigned) cc);
3849 ID.AddInteger(Bits);
3895 "Const, volatile and restrict are assumed to be a subset of "
3896 "the fast qualifiers.");
3958 public llvm::FoldingSetNode,
3959 private llvm::TrailingObjects<
3960 FunctionProtoType, QualType, SourceLocation,
3961 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3962 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3964 friend TrailingObjects;
4056 Result.ExceptionSpec = ESI;
4066 unsigned numTrailingObjects(OverloadToken<QualType>)
const {
4070 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
4074 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>)
const {
4075 return hasExtraBitfields();
4078 unsigned numTrailingObjects(OverloadToken<ExceptionType>)
const {
4079 return getExceptionSpecSize().NumExceptionType;
4082 unsigned numTrailingObjects(OverloadToken<Expr *>)
const {
4083 return getExceptionSpecSize().NumExprPtr;
4086 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>)
const {
4087 return getExceptionSpecSize().NumFunctionDeclPtr;
4090 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>)
const {
4096 static bool containsAnyUnexpandedParameterPack(
const QualType *ArgArray,
4098 for (
unsigned Idx = 0; Idx < numArgs; ++Idx)
4105 FunctionProtoType(
QualType result, ArrayRef<QualType> params,
4106 QualType canonical,
const ExtProtoInfo &epi);
4111 struct ExceptionSpecSizeHolder {
4112 unsigned NumExceptionType;
4113 unsigned NumExprPtr;
4114 unsigned NumFunctionDeclPtr;
4119 static ExceptionSpecSizeHolder
4131 return {NumExceptions, 0, 0};
4144 llvm_unreachable(
"bad exception specification kind");
4149 ExceptionSpecSizeHolder getExceptionSpecSize()
const {
4154 bool hasExtraBitfields()
const {
4157 "ExtraBitfields are required for given ExceptionSpecType");
4162 bool hasExtQualifiers()
const {
4170 assert(i <
getNumParams() &&
"invalid parameter index");
4237 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4253 return *getTrailingObjects<Expr *>();
4264 return getTrailingObjects<FunctionDecl *>()[0];
4274 return getTrailingObjects<FunctionDecl *>()[1];
4292 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4308 if (hasExtQualifiers())
4309 return *getTrailingObjects<Qualifiers>();
4327 return getTrailingObjects<QualType>();
4342 getTrailingObjects<ExceptionType>());
4367 return getTrailingObjects<ExtParameterInfo>();
4371 assert(I <
getNumParams() &&
"parameter index out of range");
4373 return getTrailingObjects<ExtParameterInfo>()[I];
4378 assert(I <
getNumParams() &&
"parameter index out of range");
4380 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4385 assert(I <
getNumParams() &&
"parameter index out of range");
4387 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4404 const ExtProtoInfo &EPI,
const ASTContext &Context,
4459 ID.AddPointer(Found);
4493 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4494 assert(isa<AttributedType>(UnderlyingTy) &&
4495 "Expected a macro qualified type to only wrap attributed types.");
4565 assert(!isa<TypedefType>(can) &&
"Invalid canonical type");
4666 public llvm::FoldingSetNode {
4678 ID.AddInteger((
unsigned)UKind);
4774 ModifiedType(modified), EquivalentType(equivalent) {