67#include "llvm/ADT/APFixedPoint.h"
68#include "llvm/ADT/APInt.h"
69#include "llvm/ADT/APSInt.h"
70#include "llvm/ADT/ArrayRef.h"
71#include "llvm/ADT/DenseMap.h"
72#include "llvm/ADT/DenseSet.h"
73#include "llvm/ADT/FoldingSet.h"
74#include "llvm/ADT/PointerUnion.h"
75#include "llvm/ADT/STLExtras.h"
76#include "llvm/ADT/SmallPtrSet.h"
77#include "llvm/ADT/SmallVector.h"
78#include "llvm/ADT/StringExtras.h"
79#include "llvm/ADT/StringRef.h"
80#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
81#include "llvm/Support/Capacity.h"
82#include "llvm/Support/Compiler.h"
83#include "llvm/Support/ErrorHandling.h"
84#include "llvm/Support/MD5.h"
85#include "llvm/Support/MathExtras.h"
86#include "llvm/Support/SipHash.h"
87#include "llvm/Support/raw_ostream.h"
88#include "llvm/TargetParser/AArch64TargetParser.h"
89#include "llvm/TargetParser/Triple.h"
102using namespace clang;
115template <>
struct llvm::DenseMapInfo<
llvm::FoldingSetNodeID> {
116 static FoldingSetNodeID
getEmptyKey() {
return FoldingSetNodeID{}; }
120 for (
size_t i = 0; i <
sizeof(id) /
sizeof(
unsigned); ++i) {
121 id.AddInteger(std::numeric_limits<unsigned>::max());
127 return Val.ComputeHash();
130 static bool isEqual(
const FoldingSetNodeID &LHS,
131 const FoldingSetNodeID &RHS) {
147 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
152 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
153 if (VD->isStaticDataMember() &&
158 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(
D)) {
163 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(
D)) {
170 if (
const auto *ED = dyn_cast<EnumDecl>(
D)) {
174 if (
const auto *TD = dyn_cast<TagDecl>(
D)) {
177 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
181 if (isa<ParmVarDecl>(
D))
186 if (isa<TemplateTypeParmDecl>(
D) ||
187 isa<NonTypeTemplateParmDecl>(
D) ||
188 isa<TemplateTemplateParmDecl>(
D))
199 if (isa<ObjCMethodDecl>(
D) || isa<ObjCContainerDecl>(
D) ||
200 isa<ObjCPropertyDecl>(
D) || isa<RedeclarableTemplateDecl>(
D) ||
201 isa<ClassTemplateSpecializationDecl>(
D) ||
209 Locations.emplace_back(BaseLocation);
237 const std::map<unsigned, RawComment *> &CommentsInTheFile)
const {
240 if (RepresentativeLocForDecl.
isInvalid() ||
241 !RepresentativeLocForDecl.
isFileID())
245 if (CommentsInTheFile.empty())
250 const std::pair<FileID, unsigned> DeclLocDecomp =
254 auto OffsetCommentBehindDecl =
255 CommentsInTheFile.lower_bound(DeclLocDecomp.second);
258 if (OffsetCommentBehindDecl != CommentsInTheFile.end()) {
259 RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second;
263 (isa<FieldDecl>(
D) || isa<EnumConstantDecl>(
D) || isa<VarDecl>(
D) ||
264 isa<ObjCMethodDecl>(
D) || isa<ObjCPropertyDecl>(
D))) {
268 if (SourceMgr.
getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) ==
270 OffsetCommentBehindDecl->first)) {
271 return CommentBehindDecl;
278 if (OffsetCommentBehindDecl == CommentsInTheFile.begin())
281 auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl;
282 RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second;
291 const unsigned CommentEndOffset =
296 const char *Buffer = SourceMgr.
getBufferData(DeclLocDecomp.first,
302 StringRef
Text(Buffer + CommentEndOffset,
303 DeclLocDecomp.second - CommentEndOffset);
307 if (
Text.find_last_of(
";{}#@") != StringRef::npos)
310 return CommentBeforeDecl;
316 for (
const auto DeclLoc : DeclLocs) {
319 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
335 if (!CommentsInThisFile || CommentsInThisFile->empty())
347 assert(LangOpts.RetainCommentsFromSystemHeaders ||
356 if (
const auto *FD = dyn_cast<FunctionDecl>(&
D)) {
376 if (
const auto *VD = dyn_cast<VarDecl>(&
D)) {
379 if (VD->isStaticDataMember())
385 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(&
D)) {
392 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
398 return isa<ClassTemplateDecl *>(PU)
399 ? *
static_cast<const Decl *
>(cast<ClassTemplateDecl *>(PU))
400 : *
static_cast<const Decl *
>(
401 cast<ClassTemplatePartialSpecializationDecl *>(PU));
406 CRD->getMemberSpecializationInfo())
407 return *Info->getInstantiatedFrom();
411 if (
const auto *ED = dyn_cast<EnumDecl>(&
D)) {
424 const Decl **OriginalDecl)
const {
427 OriginalDecl =
nullptr;
439 return DeclComment->second;
452 *OriginalDecl = RedeclComment->second;
455 "This decl is supposed to have comment attached.");
456 return CommentAtRedecl->second;
461 const Decl *LastCheckedRedecl = [&]() {
463 bool CanUseCommentlessCache =
false;
465 for (
auto *Redecl : CanonicalD->
redecls()) {
467 CanUseCommentlessCache =
true;
470 if (Redecl == LastChecked)
477 return CanUseCommentlessCache ? LastChecked :
nullptr;
483 if (LastCheckedRedecl) {
484 if (LastCheckedRedecl == Redecl) {
485 LastCheckedRedecl =
nullptr;
493 *OriginalDecl = Redecl;
494 return RedeclComment;
500 *OriginalDecl =
nullptr;
516 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
521 for (
const auto *Ext : ID->known_extensions()) {
525 Redeclared.push_back(RedeclaredMethod);
536 for (
const Decl *
D : Decls) {
550 if (
File.isInvalid())
554 if (!CommentsInThisFile || CommentsInThisFile->empty() ||
555 CommentsInThisFile->rbegin()->second->isAttached())
565 for (
const Decl *
D : Decls) {
577 for (
const auto DeclLoc : DeclLocs) {
578 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
582 D, DeclLoc, *CommentsInThisFile)) {
593 const Decl *
D)
const {
596 ThisDeclInfo->IsFilled =
false;
597 ThisDeclInfo->fill();
598 ThisDeclInfo->CommentDecl = FC->
getDecl();
599 if (!ThisDeclInfo->TemplateParameters)
609 return RC ? RC->
parse(*
this,
nullptr,
D) :
nullptr;
620 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
624 if (Canonical !=
D) {
632 const Decl *OriginalDecl =
nullptr;
636 if (isa<ObjCMethodDecl>(
D) || isa<FunctionDecl>(
D)) {
638 const auto *OMD = dyn_cast<ObjCMethodDecl>(
D);
639 if (OMD && OMD->isPropertyAccessor())
646 for (
unsigned i = 0, e = Overridden.size(); i < e; i++)
650 else if (
const auto *TD = dyn_cast<TypedefNameDecl>(
D)) {
653 QualType QT = TD->getUnderlyingType();
655 if (
const Decl *TD = TT->getDecl())
659 else if (
const auto *IC = dyn_cast<ObjCInterfaceDecl>(
D)) {
660 while (IC->getSuperClass()) {
661 IC = IC->getSuperClass();
666 else if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(
D)) {
671 else if (
const auto *RD = dyn_cast<CXXRecordDecl>(
D)) {
672 if (!(RD = RD->getDefinition()))
675 for (
const auto &I : RD->bases()) {
676 if (I.isVirtual() || (I.getAccessSpecifier() !=
AS_public))
690 for (
const auto &I : RD->vbases()) {
711 if (
D != OriginalDecl && OriginalDecl)
720ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
728 ID.AddInteger(Params->
size());
730 PEnd = Params->
end();
732 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*
P)) {
734 ID.AddBoolean(TTP->isParameterPack());
735 if (TTP->isExpandedParameterPack()) {
737 ID.AddInteger(TTP->getNumExpansionParameters());
739 ID.AddBoolean(
false);
743 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
745 ID.AddBoolean(NTTP->isParameterPack());
746 ID.AddPointer(
C.getUnconstrainedType(
C.getCanonicalType(NTTP->getType()))
748 if (NTTP->isExpandedParameterPack()) {
750 ID.AddInteger(NTTP->getNumExpansionTypes());
751 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
753 ID.AddPointer(
T.getCanonicalType().getAsOpaquePtr());
756 ID.AddBoolean(
false);
760 auto *TTP = cast<TemplateTemplateParmDecl>(*
P);
767ASTContext::getCanonicalTemplateTemplateParmDecl(
770 llvm::FoldingSetNodeID
ID;
771 CanonicalTemplateTemplateParm::Profile(ID, *
this, TTP);
772 void *InsertPos =
nullptr;
773 CanonicalTemplateTemplateParm *Canonical
774 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
776 return Canonical->getParam();
781 CanonParams.reserve(Params->
size());
783 PEnd = Params->
end();
787 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*
P)) {
793 ? std::optional<unsigned>(TTP->getNumExpansionParameters())
795 CanonParams.push_back(NewTTP);
796 }
else if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
800 if (NTTP->isExpandedParameterPack()) {
803 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
805 ExpandedTInfos.push_back(
813 NTTP->getPosition(),
nullptr,
823 NTTP->getPosition(),
nullptr,
825 NTTP->isParameterPack(),
828 CanonParams.push_back(Param);
830 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
831 cast<TemplateTemplateParmDecl>(*
P)));
842 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
843 assert(!Canonical &&
"Shouldn't be in the map!");
847 Canonical =
new (*this) CanonicalTemplateTemplateParm(CanonTTP);
848 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
857 return NoSanitizeL->containsType(Mask, TyName) &&
858 !NoSanitizeL->containsType(Mask, TyName,
"sanitize");
867 if (!LangOpts.CPlusPlus)
return nullptr;
870 case TargetCXXABI::AppleARM64:
871 case TargetCXXABI::Fuchsia:
872 case TargetCXXABI::GenericARM:
873 case TargetCXXABI::iOS:
874 case TargetCXXABI::WatchOS:
875 case TargetCXXABI::GenericAArch64:
876 case TargetCXXABI::GenericMIPS:
877 case TargetCXXABI::GenericItanium:
878 case TargetCXXABI::WebAssembly:
879 case TargetCXXABI::XL:
881 case TargetCXXABI::Microsoft:
884 llvm_unreachable(
"Invalid CXXABI type!");
888 if (!InterpContext) {
891 return *InterpContext.get();
897 return *ParentMapCtx.get();
902 switch (LangOpts.getAddressSpaceMapMangling()) {
910 llvm_unreachable(
"getAddressSpaceMapMangling() doesn't cover anything.");
916 : ConstantArrayTypes(this_(), ConstantArrayTypesLog2InitSize),
917 DependentSizedArrayTypes(this_()), DependentSizedExtVectorTypes(this_()),
918 DependentAddressSpaceTypes(this_()), DependentVectorTypes(this_()),
919 DependentSizedMatrixTypes(this_()),
920 FunctionProtoTypes(this_(), FunctionProtoTypesLog2InitSize),
921 DependentTypeOfExprTypes(this_()), DependentDecltypeTypes(this_()),
922 TemplateSpecializationTypes(this_()),
923 DependentTemplateSpecializationTypes(this_()),
924 DependentBitIntTypes(this_()), SubstTemplateTemplateParmPacks(this_()),
925 DeducedTemplates(this_()), ArrayParameterTypes(this_()),
926 CanonTemplateTemplateParms(this_()), SourceMgr(
SM), LangOpts(LOpts),
929 LangOpts.XRayNeverInstrumentFiles,
930 LangOpts.XRayAttrListFiles,
SM)),
933 BuiltinInfo(builtins), TUKind(TUKind), DeclarationNames(*this),
934 Comments(
SM), CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
935 CompCategories(this_()), LastSDM(nullptr, 0) {
942 ReleaseDeclContextMaps();
945 for (
auto &Pair : Deallocations)
946 (Pair.first)(Pair.second);
947 Deallocations.clear();
953 I = ObjCLayouts.begin(),
E = ObjCLayouts.end(); I !=
E; )
959 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
960 I = ASTRecordLayouts.begin(),
E = ASTRecordLayouts.end(); I !=
E; ) {
965 ASTRecordLayouts.clear();
967 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
968 AEnd = DeclAttrs.end();
970 A->second->~AttrVec();
973 for (
const auto &
Value : ModuleInitializers)
974 Value.second->~PerModuleInitializers();
975 ModuleInitializers.
clear();
981 TraversalScope = TopLevelDecls;
986 Deallocations.push_back({Callback,
Data});
995 llvm::errs() <<
"\n*** AST Context Stats:\n";
996 llvm::errs() <<
" " << Types.size() <<
" types total.\n";
998 unsigned counts[] = {
999#define TYPE(Name, Parent) 0,
1000#define ABSTRACT_TYPE(Name, Parent)
1001#include "clang/AST/TypeNodes.inc"
1005 for (
unsigned i = 0, e = Types.size(); i != e; ++i) {
1011 unsigned TotalBytes = 0;
1012#define TYPE(Name, Parent) \
1014 llvm::errs() << " " << counts[Idx] << " " << #Name \
1015 << " types, " << sizeof(Name##Type) << " each " \
1016 << "(" << counts[Idx] * sizeof(Name##Type) \
1018 TotalBytes += counts[Idx] * sizeof(Name##Type); \
1020#define ABSTRACT_TYPE(Name, Parent)
1021#include "clang/AST/TypeNodes.inc"
1023 llvm::errs() <<
"Total bytes = " << TotalBytes <<
"\n";
1028 <<
" implicit default constructors created\n";
1031 <<
" implicit copy constructors created\n";
1035 <<
" implicit move constructors created\n";
1038 <<
" implicit copy assignment operators created\n";
1042 <<
" implicit move assignment operators created\n";
1045 <<
" implicit destructors created\n";
1048 llvm::errs() <<
"\n";
1052 BumpAlloc.PrintStats();
1056 bool NotifyListeners) {
1057 if (NotifyListeners)
1066 if (It == MergedDefModules.end())
1069 auto &Merged = It->second;
1070 llvm::DenseSet<Module*>
Found;
1071 for (
Module *&M : Merged)
1072 if (!
Found.insert(M).second)
1074 llvm::erase(Merged,
nullptr);
1081 if (MergedIt == MergedDefModules.end())
1083 return MergedIt->second;
1086void ASTContext::PerModuleInitializers::resolve(
ASTContext &Ctx) {
1087 if (LazyInitializers.empty())
1091 assert(Source &&
"lazy initializers but no external source");
1093 auto LazyInits = std::move(LazyInitializers);
1094 LazyInitializers.clear();
1096 for (
auto ID : LazyInits)
1097 Initializers.push_back(Source->GetExternalDecl(ID));
1099 assert(LazyInitializers.empty() &&
1100 "GetExternalDecl for lazy module initializer added more inits");
1106 if (
const auto *ID = dyn_cast<ImportDecl>(
D)) {
1107 auto It = ModuleInitializers.find(ID->getImportedModule());
1110 if (It == ModuleInitializers.end())
1114 auto &Imported = *It->second;
1115 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
1116 Imported.resolve(*
this);
1117 auto *OnlyDecl = Imported.Initializers.front();
1118 if (isa<ImportDecl>(OnlyDecl))
1123 auto *&Inits = ModuleInitializers[M];
1125 Inits =
new (*this) PerModuleInitializers;
1126 Inits->Initializers.push_back(
D);
1131 auto *&Inits = ModuleInitializers[M];
1133 Inits =
new (*this) PerModuleInitializers;
1134 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
1135 IDs.begin(), IDs.end());
1139 auto It = ModuleInitializers.find(M);
1140 if (It == ModuleInitializers.end())
1143 auto *Inits = It->second;
1144 Inits->resolve(*
this);
1145 return Inits->Initializers;
1150 assert(!CurrentCXXNamedModule &&
1151 "We should set named module for ASTContext for only once");
1152 CurrentCXXNamedModule = M;
1164 auto GetRepresentativeModule = [
this](
const Module *M) {
1165 auto Iter = SameModuleLookupSet.find(M);
1166 if (
Iter != SameModuleLookupSet.end())
1167 return Iter->second;
1169 const Module *RepresentativeModule =
1170 PrimaryModuleNameMap.try_emplace(M->getPrimaryModuleInterfaceName(), M)
1172 SameModuleLookupSet[M] = RepresentativeModule;
1173 return RepresentativeModule;
1176 assert(M1 &&
"Shouldn't call `isInSameModule` if both M1 and M2 are none.");
1177 return GetRepresentativeModule(M1) == GetRepresentativeModule(M2);
1181 if (!ExternCContext)
1184 return ExternCContext;
1190 auto *BuiltinTemplate =
1192 BuiltinTemplate->setImplicit();
1195 return BuiltinTemplate;
1200 if (!MakeIntegerSeqDecl)
1203 return MakeIntegerSeqDecl;
1208 if (!TypePackElementDecl)
1211 return TypePackElementDecl;
1215 if (!BuiltinCommonTypeDecl)
1218 return BuiltinCommonTypeDecl;
1232 NewDecl->
addAttr(TypeVisibilityAttr::CreateImplicit(
1233 const_cast<ASTContext &
>(*
this), TypeVisibilityAttr::Default));
1238 StringRef Name)
const {
1262 Types.push_back(Ty);
1267 assert((!this->Target || this->Target == &
Target) &&
1268 "Incorrect target reinitialization");
1272 this->AuxTarget = AuxTarget;
1274 ABI.reset(createCXXABI(
Target));
1278 InitBuiltinType(
VoidTy, BuiltinType::Void);
1281 InitBuiltinType(
BoolTy, BuiltinType::Bool);
1283 if (LangOpts.CharIsSigned)
1284 InitBuiltinType(
CharTy, BuiltinType::Char_S);
1286 InitBuiltinType(
CharTy, BuiltinType::Char_U);
1289 InitBuiltinType(
ShortTy, BuiltinType::Short);
1290 InitBuiltinType(
IntTy, BuiltinType::Int);
1291 InitBuiltinType(
LongTy, BuiltinType::Long);
1292 InitBuiltinType(
LongLongTy, BuiltinType::LongLong);
1302 InitBuiltinType(
FloatTy, BuiltinType::Float);
1303 InitBuiltinType(
DoubleTy, BuiltinType::Double);
1304 InitBuiltinType(
LongDoubleTy, BuiltinType::LongDouble);
1307 InitBuiltinType(
Float128Ty, BuiltinType::Float128);
1310 InitBuiltinType(
Ibm128Ty, BuiltinType::Ibm128);
1313 InitBuiltinType(
Float16Ty, BuiltinType::Float16);
1316 InitBuiltinType(
ShortAccumTy, BuiltinType::ShortAccum);
1317 InitBuiltinType(
AccumTy, BuiltinType::Accum);
1318 InitBuiltinType(
LongAccumTy, BuiltinType::LongAccum);
1322 InitBuiltinType(
ShortFractTy, BuiltinType::ShortFract);
1323 InitBuiltinType(
FractTy, BuiltinType::Fract);
1324 InitBuiltinType(
LongFractTy, BuiltinType::LongFract);
1329 InitBuiltinType(
SatAccumTy, BuiltinType::SatAccum);
1335 InitBuiltinType(
SatFractTy, BuiltinType::SatFract);
1342 InitBuiltinType(
Int128Ty, BuiltinType::Int128);
1347 InitBuiltinType(
WCharTy, BuiltinType::WChar_S);
1349 InitBuiltinType(
WCharTy, BuiltinType::WChar_U);
1350 if (LangOpts.CPlusPlus && LangOpts.WChar)
1360 InitBuiltinType(
Char8Ty, BuiltinType::Char8);
1362 if (LangOpts.CPlusPlus)
1363 InitBuiltinType(
Char16Ty, BuiltinType::Char16);
1367 if (LangOpts.CPlusPlus)
1368 InitBuiltinType(
Char32Ty, BuiltinType::Char32);
1377 InitBuiltinType(
DependentTy, BuiltinType::Dependent);
1380 InitBuiltinType(
OverloadTy, BuiltinType::Overload);
1392 InitBuiltinType(
UnknownAnyTy, BuiltinType::UnknownAny);
1398 InitBuiltinType(
BuiltinFnTy, BuiltinType::BuiltinFn);
1401 if (LangOpts.OpenMP) {
1408 if (LangOpts.OpenACC && !LangOpts.OpenMP) {
1411 if (LangOpts.MatrixTypes)
1419 if (LangOpts.OpenCL) {
1420#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1421 InitBuiltinType(SingletonId, BuiltinType::Id);
1422#include "clang/Basic/OpenCLImageTypes.def"
1424 InitBuiltinType(
OCLSamplerTy, BuiltinType::OCLSampler);
1425 InitBuiltinType(
OCLEventTy, BuiltinType::OCLEvent);
1427 InitBuiltinType(
OCLQueueTy, BuiltinType::OCLQueue);
1430#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1431 InitBuiltinType(Id##Ty, BuiltinType::Id);
1432#include "clang/Basic/OpenCLExtensionTypes.def"
1435 if (LangOpts.HLSL) {
1436#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1437 InitBuiltinType(SingletonId, BuiltinType::Id);
1438#include "clang/Basic/HLSLIntangibleTypes.def"
1441 if (
Target.hasAArch64SVETypes() ||
1443#define SVE_TYPE(Name, Id, SingletonId) \
1444 InitBuiltinType(SingletonId, BuiltinType::Id);
1445#include "clang/Basic/AArch64SVEACLETypes.def"
1448 if (
Target.getTriple().isPPC64()) {
1449#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \
1450 InitBuiltinType(Id##Ty, BuiltinType::Id);
1451#include "clang/Basic/PPCTypes.def"
1452#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \
1453 InitBuiltinType(Id##Ty, BuiltinType::Id);
1454#include "clang/Basic/PPCTypes.def"
1457 if (
Target.hasRISCVVTypes()) {
1458#define RVV_TYPE(Name, Id, SingletonId) \
1459 InitBuiltinType(SingletonId, BuiltinType::Id);
1460#include "clang/Basic/RISCVVTypes.def"
1463 if (
Target.getTriple().isWasm() &&
Target.hasFeature(
"reference-types")) {
1464#define WASM_TYPE(Name, Id, SingletonId) \
1465 InitBuiltinType(SingletonId, BuiltinType::Id);
1466#include "clang/Basic/WebAssemblyReferenceTypes.def"
1469 if (
Target.getTriple().isAMDGPU() ||
1470 (AuxTarget && AuxTarget->
getTriple().isAMDGPU())) {
1471#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1472 InitBuiltinType(SingletonId, BuiltinType::Id);
1473#include "clang/Basic/AMDGPUTypes.def"
1480 ObjCConstantStringType =
QualType();
1485 if (LangOpts.OpenCLGenericAddressSpace) {
1495 InitBuiltinType(
NullPtrTy, BuiltinType::NullPtr);
1498 InitBuiltinType(
HalfTy, BuiltinType::Half);
1500 InitBuiltinType(
BFloat16Ty, BuiltinType::BFloat16);
1506 if (LangOpts.MicrosoftExt || LangOpts.Borland) {
1528 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(
D);
1529 if (Pos != DeclAttrs.end()) {
1530 Pos->second->~AttrVec();
1531 DeclAttrs.erase(Pos);
1545 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1546 TemplateOrInstantiation.find(Var);
1547 if (Pos == TemplateOrInstantiation.end())
1560 Tmpl, TSK, PointOfInstantiation));
1566 assert(!TemplateOrInstantiation[Inst] &&
1567 "Already noted what the variable was instantiated from");
1568 TemplateOrInstantiation[Inst] = TSI;
1573 return InstantiatedFromUsingDecl.lookup(UUD);
1578 assert((isa<UsingDecl>(Pattern) ||
1579 isa<UnresolvedUsingValueDecl>(Pattern) ||
1580 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
1581 "pattern decl is not a using decl");
1582 assert((isa<UsingDecl>(Inst) ||
1583 isa<UnresolvedUsingValueDecl>(Inst) ||
1584 isa<UnresolvedUsingTypenameDecl>(Inst)) &&
1585 "instantiation did not produce a using decl");
1586 assert(!InstantiatedFromUsingDecl[Inst] &&
"pattern already exists");
1587 InstantiatedFromUsingDecl[Inst] = Pattern;
1592 return InstantiatedFromUsingEnumDecl.lookup(UUD);
1597 assert(!InstantiatedFromUsingEnumDecl[Inst] &&
"pattern already exists");
1598 InstantiatedFromUsingEnumDecl[Inst] = Pattern;
1603 return InstantiatedFromUsingShadowDecl.lookup(Inst);
1609 assert(!InstantiatedFromUsingShadowDecl[Inst] &&
"pattern already exists");
1610 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1615 return InstantiatedFromUnnamedFieldDecl.lookup(Field);
1621 "Instantiated field decl is not unnamed");
1623 "Template field decl is not unnamed");
1624 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1625 "Already noted what unnamed field was instantiated from");
1627 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1648 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1650 if (Pos == OverriddenMethods.end())
1658 OverriddenMethods[Method].push_back(Overridden);
1666 if (
const auto *CXXMethod = dyn_cast<CXXMethodDecl>(
D)) {
1672 const auto *Method = dyn_cast<ObjCMethodDecl>(
D);
1677 Method->getOverriddenMethods(OverDecls);
1678 Overridden.append(OverDecls.begin(), OverDecls.end());
1682 assert(!Import->getNextLocalImport() &&
1683 "Import declaration already in the chain");
1684 assert(!Import->isFromASTFile() &&
"Non-local import declaration");
1685 if (!FirstLocalImport) {
1686 FirstLocalImport = Import;
1687 LastLocalImport = Import;
1691 LastLocalImport->setNextLocalImport(Import);
1692 LastLocalImport = Import;
1704 llvm_unreachable(
"Not a floating point type!");
1705 case BuiltinType::BFloat16:
1706 return Target->getBFloat16Format();
1707 case BuiltinType::Float16:
1708 return Target->getHalfFormat();
1709 case BuiltinType::Half:
1710 return Target->getHalfFormat();
1711 case BuiltinType::Float:
return Target->getFloatFormat();
1712 case BuiltinType::Double:
return Target->getDoubleFormat();
1713 case BuiltinType::Ibm128:
1714 return Target->getIbm128Format();
1715 case BuiltinType::LongDouble:
1718 return Target->getLongDoubleFormat();
1719 case BuiltinType::Float128:
1722 return Target->getFloat128Format();
1727 unsigned Align =
Target->getCharWidth();
1731 Align = AlignFromAttr;
1739 bool UseAlignAttrOnly;
1740 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(
D))
1742 FD->hasAttr<PackedAttr>() || FD->getParent()->hasAttr<PackedAttr>();
1744 UseAlignAttrOnly = AlignFromAttr != 0;
1747 if (UseAlignAttrOnly) {
1749 }
else if (
const auto *VD = dyn_cast<ValueDecl>(
D)) {
1759 Align = getTypeInfoImpl(
T.getTypePtr()).
Align;
1764 unsigned MinWidth =
Target->getLargeArrayMinWidth();
1765 if (!ForAlignof && MinWidth) {
1767 Align = std::max(Align,
Target->getLargeArrayAlign());
1768 else if (isa<ConstantArrayType>(
arrayType) &&
1770 Align = std::max(Align,
Target->getLargeArrayAlign());
1775 Align =
Target->getCharWidth();
1779 if (
const auto *VD = dyn_cast<VarDecl>(
D))
1780 if (VD->hasGlobalStorage() && !ForAlignof) {
1791 if (
const auto *Field = dyn_cast<FieldDecl>(VD)) {
1794 if (!
Parent->isInvalidDecl()) {
1805 uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1806 if (LowBitOfOffset < FieldAlign)
1807 FieldAlign =
static_cast<unsigned>(LowBitOfOffset);
1810 Align = std::min(Align, FieldAlign);
1818 const auto *VD = dyn_cast<VarDecl>(
D);
1819 if (MaxAlignedAttr && VD && VD->getStorageClass() ==
SC_Static)
1820 Align = std::min(Align, MaxAlignedAttr);
1858 (uint64_t)(-1)/Size) &&
1859 "Overflow in array type char size evaluation");
1864 Width = llvm::alignTo(Width, Align);
1871 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
1889 switch (BT->getKind()) {
1890 case BuiltinType::Bool:
1891 case BuiltinType::Char_S:
1892 case BuiltinType::Char_U:
1893 case BuiltinType::SChar:
1894 case BuiltinType::UChar:
1895 case BuiltinType::Short:
1896 case BuiltinType::UShort:
1897 case BuiltinType::WChar_S:
1898 case BuiltinType::WChar_U:
1899 case BuiltinType::Char8:
1900 case BuiltinType::Char16:
1901 case BuiltinType::Char32:
1911 ET->getDecl()->isScoped())
1929 bool NeedsPreferredAlignment)
const {
1932 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1943 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1948 return TT->getDecl()->getMaxAlignment();
1954 TypeInfoMap::iterator I = MemoizedTypeInfo.find(
T);
1955 if (I != MemoizedTypeInfo.end())
1960 MemoizedTypeInfo[
T] = TI;
1976#define TYPE(Class, Base)
1977#define ABSTRACT_TYPE(Class, Base)
1978#define NON_CANONICAL_TYPE(Class, Base)
1979#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1980#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1982 assert(!T->isDependentType() && "should not see dependent types here"); \
1983 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1984#include "clang/AST/TypeNodes.inc"
1985 llvm_unreachable(
"Should not see dependent types");
1987 case Type::FunctionNoProto:
1988 case Type::FunctionProto:
1994 case Type::IncompleteArray:
1995 case Type::VariableArray:
1996 case Type::ConstantArray:
1997 case Type::ArrayParameter: {
2000 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
2001 Size = CAT->getZExtSize();
2004 assert((Size == 0 || EltInfo.
Width <= (uint64_t)(-1) / Size) &&
2005 "Overflow in array type bit size evaluation");
2006 Width = EltInfo.
Width * Size;
2007 Align = EltInfo.
Align;
2011 Width = llvm::alignTo(Width, Align);
2015 case Type::ExtVector:
2016 case Type::Vector: {
2017 const auto *VT = cast<VectorType>(
T);
2019 Width = VT->isExtVectorBoolType() ? VT->getNumElements()
2020 : EltInfo.
Width * VT->getNumElements();
2022 Width = std::max<unsigned>(8, Width);
2023 Align = std::max<unsigned>(8, Width);
2027 if (Align & (Align-1)) {
2028 Align = llvm::bit_ceil(Align);
2029 Width = llvm::alignTo(Width, Align);
2033 if (TargetVectorAlign && TargetVectorAlign < Align)
2034 Align = TargetVectorAlign;
2048 Align = std::min<unsigned>(64, Width);
2052 case Type::ConstantMatrix: {
2053 const auto *MT = cast<ConstantMatrixType>(
T);
2058 Width = ElementInfo.
Width * MT->getNumRows() * MT->getNumColumns();
2059 Align = ElementInfo.
Align;
2064 switch (cast<BuiltinType>(
T)->
getKind()) {
2065 default: llvm_unreachable(
"Unknown builtin type!");
2066 case BuiltinType::Void:
2071 case BuiltinType::Bool:
2072 Width =
Target->getBoolWidth();
2073 Align =
Target->getBoolAlign();
2075 case BuiltinType::Char_S:
2076 case BuiltinType::Char_U:
2077 case BuiltinType::UChar:
2078 case BuiltinType::SChar:
2079 case BuiltinType::Char8:
2080 Width =
Target->getCharWidth();
2081 Align =
Target->getCharAlign();
2083 case BuiltinType::WChar_S:
2084 case BuiltinType::WChar_U:
2085 Width =
Target->getWCharWidth();
2086 Align =
Target->getWCharAlign();
2088 case BuiltinType::Char16:
2089 Width =
Target->getChar16Width();
2090 Align =
Target->getChar16Align();
2092 case BuiltinType::Char32:
2093 Width =
Target->getChar32Width();
2094 Align =
Target->getChar32Align();
2096 case BuiltinType::UShort:
2097 case BuiltinType::Short:
2098 Width =
Target->getShortWidth();
2099 Align =
Target->getShortAlign();
2101 case BuiltinType::UInt:
2102 case BuiltinType::Int:
2103 Width =
Target->getIntWidth();
2104 Align =
Target->getIntAlign();
2106 case BuiltinType::ULong:
2107 case BuiltinType::Long:
2108 Width =
Target->getLongWidth();
2109 Align =
Target->getLongAlign();
2111 case BuiltinType::ULongLong:
2112 case BuiltinType::LongLong:
2113 Width =
Target->getLongLongWidth();
2114 Align =
Target->getLongLongAlign();
2116 case BuiltinType::Int128:
2117 case BuiltinType::UInt128:
2119 Align =
Target->getInt128Align();
2121 case BuiltinType::ShortAccum:
2122 case BuiltinType::UShortAccum:
2123 case BuiltinType::SatShortAccum:
2124 case BuiltinType::SatUShortAccum:
2125 Width =
Target->getShortAccumWidth();
2126 Align =
Target->getShortAccumAlign();
2128 case BuiltinType::Accum:
2129 case BuiltinType::UAccum:
2130 case BuiltinType::SatAccum:
2131 case BuiltinType::SatUAccum:
2132 Width =
Target->getAccumWidth();
2133 Align =
Target->getAccumAlign();
2135 case BuiltinType::LongAccum:
2136 case BuiltinType::ULongAccum:
2137 case BuiltinType::SatLongAccum:
2138 case BuiltinType::SatULongAccum:
2139 Width =
Target->getLongAccumWidth();
2140 Align =
Target->getLongAccumAlign();
2142 case BuiltinType::ShortFract:
2143 case BuiltinType::UShortFract:
2144 case BuiltinType::SatShortFract:
2145 case BuiltinType::SatUShortFract:
2146 Width =
Target->getShortFractWidth();
2147 Align =
Target->getShortFractAlign();
2149 case BuiltinType::Fract:
2150 case BuiltinType::UFract:
2151 case BuiltinType::SatFract:
2152 case BuiltinType::SatUFract:
2153 Width =
Target->getFractWidth();
2154 Align =
Target->getFractAlign();
2156 case BuiltinType::LongFract:
2157 case BuiltinType::ULongFract:
2158 case BuiltinType::SatLongFract:
2159 case BuiltinType::SatULongFract:
2160 Width =
Target->getLongFractWidth();
2161 Align =
Target->getLongFractAlign();
2163 case BuiltinType::BFloat16:
2164 if (
Target->hasBFloat16Type()) {
2165 Width =
Target->getBFloat16Width();
2166 Align =
Target->getBFloat16Align();
2175 case BuiltinType::Float16:
2176 case BuiltinType::Half:
2179 Width =
Target->getHalfWidth();
2180 Align =
Target->getHalfAlign();
2183 "Expected OpenMP device compilation.");
2188 case BuiltinType::Float:
2189 Width =
Target->getFloatWidth();
2190 Align =
Target->getFloatAlign();
2192 case BuiltinType::Double:
2193 Width =
Target->getDoubleWidth();
2194 Align =
Target->getDoubleAlign();
2196 case BuiltinType::Ibm128:
2197 Width =
Target->getIbm128Width();
2198 Align =
Target->getIbm128Align();
2200 case BuiltinType::LongDouble:
2207 Width =
Target->getLongDoubleWidth();
2208 Align =
Target->getLongDoubleAlign();
2211 case BuiltinType::Float128:
2214 Width =
Target->getFloat128Width();
2215 Align =
Target->getFloat128Align();
2218 "Expected OpenMP device compilation.");
2223 case BuiltinType::NullPtr:
2228 case BuiltinType::ObjCId:
2229 case BuiltinType::ObjCClass:
2230 case BuiltinType::ObjCSel:
2234 case BuiltinType::OCLSampler:
2235 case BuiltinType::OCLEvent:
2236 case BuiltinType::OCLClkEvent:
2237 case BuiltinType::OCLQueue:
2238 case BuiltinType::OCLReserveID:
2239#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2240 case BuiltinType::Id:
2241#include "clang/Basic/OpenCLImageTypes.def"
2242#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2243 case BuiltinType::Id:
2244#include "clang/Basic/OpenCLExtensionTypes.def"
2246 Width =
Target->getPointerWidth(AS);
2247 Align =
Target->getPointerAlign(AS);
2257#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
2258 case BuiltinType::Id: \
2262#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
2263 case BuiltinType::Id: \
2267#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \
2268 case BuiltinType::Id: \
2272#define AARCH64_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
2274 case BuiltinType::Id: \
2275 Width = NumEls * ElBits * NF; \
2276 Align = NumEls * ElBits; \
2278#include "clang/Basic/AArch64SVEACLETypes.def"
2279#define PPC_VECTOR_TYPE(Name, Id, Size) \
2280 case BuiltinType::Id: \
2284#include "clang/Basic/PPCTypes.def"
2285#define RVV_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, NF, IsSigned, \
2287 case BuiltinType::Id: \
2291#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \
2292 case BuiltinType::Id: \
2296#include "clang/Basic/RISCVVTypes.def"
2297#define WASM_TYPE(Name, Id, SingletonId) \
2298 case BuiltinType::Id: \
2302#include "clang/Basic/WebAssemblyReferenceTypes.def"
2303#define AMDGPU_TYPE(NAME, ID, SINGLETONID, WIDTH, ALIGN) \
2304 case BuiltinType::ID: \
2308#include "clang/Basic/AMDGPUTypes.def"
2309#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2310#include "clang/Basic/HLSLIntangibleTypes.def"
2316 case Type::ObjCObjectPointer:
2320 case Type::BlockPointer:
2321 AS = cast<BlockPointerType>(
T)->getPointeeType().getAddressSpace();
2322 Width =
Target->getPointerWidth(AS);
2323 Align =
Target->getPointerAlign(AS);
2325 case Type::LValueReference:
2326 case Type::RValueReference:
2329 AS = cast<ReferenceType>(
T)->getPointeeType().getAddressSpace();
2330 Width =
Target->getPointerWidth(AS);
2331 Align =
Target->getPointerAlign(AS);
2334 AS = cast<PointerType>(
T)->getPointeeType().getAddressSpace();
2335 Width =
Target->getPointerWidth(AS);
2336 Align =
Target->getPointerAlign(AS);
2338 case Type::MemberPointer: {
2339 const auto *MPT = cast<MemberPointerType>(
T);
2345 case Type::Complex: {
2349 Width = EltInfo.
Width * 2;
2350 Align = EltInfo.
Align;
2353 case Type::ObjCObject:
2354 return getTypeInfo(cast<ObjCObjectType>(
T)->getBaseType().getTypePtr());
2355 case Type::Adjusted:
2358 case Type::ObjCInterface: {
2359 const auto *ObjCI = cast<ObjCInterfaceType>(
T);
2360 if (ObjCI->getDecl()->isInvalidDecl()) {
2370 case Type::BitInt: {
2371 const auto *EIT = cast<BitIntType>(
T);
2372 Align =
Target->getBitIntAlign(EIT->getNumBits());
2373 Width =
Target->getBitIntWidth(EIT->getNumBits());
2378 const auto *TT = cast<TagType>(
T);
2380 if (TT->getDecl()->isInvalidDecl()) {
2386 if (
const auto *ET = dyn_cast<EnumType>(TT)) {
2387 const EnumDecl *ED = ET->getDecl();
2391 Info.
Align = AttrAlign;
2397 const auto *RT = cast<RecordType>(TT);
2402 AlignRequirement = RD->
hasAttr<AlignedAttr>()
2408 case Type::SubstTemplateTypeParm:
2409 return getTypeInfo(cast<SubstTemplateTypeParmType>(
T)->
2410 getReplacementType().getTypePtr());
2413 case Type::DeducedTemplateSpecialization: {
2414 const auto *A = cast<DeducedType>(
T);
2415 assert(!A->getDeducedType().isNull() &&
2416 "cannot request the size of an undeduced or dependent auto type");
2417 return getTypeInfo(A->getDeducedType().getTypePtr());
2421 return getTypeInfo(cast<ParenType>(
T)->getInnerType().getTypePtr());
2423 case Type::MacroQualified:
2427 case Type::ObjCTypeParam:
2428 return getTypeInfo(cast<ObjCTypeParamType>(
T)->desugar().getTypePtr());
2431 return getTypeInfo(cast<UsingType>(
T)->desugar().getTypePtr());
2433 case Type::Typedef: {
2434 const auto *TT = cast<TypedefType>(
T);
2439 if (
unsigned AttrAlign = TT->getDecl()->getMaxAlignment()) {
2450 case Type::Elaborated:
2451 return getTypeInfo(cast<ElaboratedType>(
T)->getNamedType().getTypePtr());
2453 case Type::Attributed:
2455 cast<AttributedType>(
T)->getEquivalentType().getTypePtr());
2457 case Type::CountAttributed:
2458 return getTypeInfo(cast<CountAttributedType>(
T)->desugar().getTypePtr());
2460 case Type::BTFTagAttributed:
2462 cast<BTFTagAttributedType>(
T)->getWrappedType().getTypePtr());
2464 case Type::HLSLAttributedResource:
2466 cast<HLSLAttributedResourceType>(
T)->getWrappedType().getTypePtr());
2468 case Type::Atomic: {
2477 Width =
Target->getCharWidth();
2479 }
else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2485 Width = llvm::bit_ceil(Width);
2488 Align =
static_cast<unsigned>(Width);
2499 assert(llvm::isPowerOf2_32(Align) &&
"Alignment must be power of 2");
2500 return TypeInfo(Width, Align, AlignRequirement);
2504 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(
T);
2505 if (I != MemoizedUnadjustedAlign.end())
2508 unsigned UnadjustedAlign;
2520 MemoizedUnadjustedAlign[
T] = UnadjustedAlign;
2521 return UnadjustedAlign;
2525 unsigned SimdAlign = llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(
2575 unsigned ABIAlign = TI.
Align;
2583 if (!
Target->allowsLargerPreferedTypeAlignment())
2597 unsigned PreferredAlign =
static_cast<unsigned>(
2599 assert(PreferredAlign >= ABIAlign &&
2600 "PreferredAlign should be at least as large as ABIAlign.");
2601 return PreferredAlign;
2608 T = CT->getElementType().getTypePtr();
2610 T = ET->getDecl()->getIntegerType().getTypePtr();
2615 Target->defaultsToAIXPowerAlignment()))
2670 for (
unsigned I = 0, N =
Path.size(); I != N; ++I) {
2674 std::swap(
Base, Derived);
2694 llvm::append_range(Ivars, OI->
ivars());
2697 for (
const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2699 Ivars.push_back(Iv);
2707 if (
const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2710 for (
auto *Proto : OI->all_referenced_protocols()) {
2715 for (
const auto *Cat : OI->visible_categories())
2721 SD = SD->getSuperClass();
2723 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2724 for (
auto *Proto : OC->protocols()) {
2727 }
else if (
const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2729 if (!Protocols.insert(
2733 for (
auto *Proto : OP->protocols())
2740 bool CheckIfTriviallyCopyable) {
2741 assert(RD->
isUnion() &&
"Must be union type");
2744 for (
const auto *Field : RD->
fields()) {
2746 CheckIfTriviallyCopyable))
2749 if (FieldSize != UnionSize)
2767static std::optional<int64_t>
2770 bool CheckIfTriviallyCopyable);
2772static std::optional<int64_t>
2774 bool CheckIfTriviallyCopyable) {
2775 if (Field->getType()->isRecordType()) {
2776 const RecordDecl *RD = Field->getType()->getAsRecordDecl();
2779 CheckIfTriviallyCopyable);
2784 bool IsBitIntType = Field->getType()->isBitIntType();
2785 if (!Field->getType()->isReferenceType() && !IsBitIntType &&
2787 CheckIfTriviallyCopyable))
2788 return std::nullopt;
2790 int64_t FieldSizeInBits =
2792 if (Field->isBitField()) {
2795 if (Field->isUnnamedBitField())
2798 int64_t BitfieldSize = Field->getBitWidthValue();
2800 if ((
unsigned)BitfieldSize >
2801 cast<BitIntType>(Field->getType())->getNumBits())
2802 return std::nullopt;
2803 }
else if (BitfieldSize > FieldSizeInBits) {
2804 return std::nullopt;
2806 FieldSizeInBits = BitfieldSize;
2808 Field->getType(), CheckIfTriviallyCopyable)) {
2809 return std::nullopt;
2811 return FieldSizeInBits;
2814static std::optional<int64_t>
2816 bool CheckIfTriviallyCopyable) {
2818 CheckIfTriviallyCopyable);
2821template <
typename RangeT>
2823 const RangeT &Subobjects, int64_t CurOffsetInBits,
2825 bool CheckIfTriviallyCopyable) {
2826 for (
const auto *Subobject : Subobjects) {
2827 std::optional<int64_t> SizeInBits =
2830 return std::nullopt;
2831 if (*SizeInBits != 0) {
2833 if (Offset != CurOffsetInBits)
2834 return std::nullopt;
2835 CurOffsetInBits += *SizeInBits;
2838 return CurOffsetInBits;
2841static std::optional<int64_t>
2844 bool CheckIfTriviallyCopyable) {
2845 assert(!RD->
isUnion() &&
"Must be struct/class type");
2848 int64_t CurOffsetInBits = 0;
2849 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2850 if (ClassDecl->isDynamicClass())
2851 return std::nullopt;
2854 for (
const auto &
Base : ClassDecl->bases()) {
2857 Bases.emplace_back(
Base.getType()->getAsCXXRecordDecl());
2861 return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
2864 std::optional<int64_t> OffsetAfterBases =
2866 Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);
2867 if (!OffsetAfterBases)
2868 return std::nullopt;
2869 CurOffsetInBits = *OffsetAfterBases;
2872 std::optional<int64_t> OffsetAfterFields =
2874 RD->
fields(), CurOffsetInBits, Context, Layout,
2875 CheckIfTriviallyCopyable);
2876 if (!OffsetAfterFields)
2877 return std::nullopt;
2878 CurOffsetInBits = *OffsetAfterFields;
2880 return CurOffsetInBits;
2884 QualType Ty,
bool CheckIfTriviallyCopyable)
const {
2901 assert(!Ty.
isNull() &&
"Null QualType sent to unique object rep check");
2906 CheckIfTriviallyCopyable);
2909 "hasUniqueObjectRepresentations should not be called with an "
2930 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2935 if (
Record->isInvalidDecl())
2940 CheckIfTriviallyCopyable);
2943 *
this,
Record, CheckIfTriviallyCopyable);
2945 return StructSize && *StructSize ==
static_cast<int64_t
>(
getTypeSize(Ty));
2966 count += Ext->ivar_size();
2971 count += ImplDecl->ivar_size();
2989 if (isa<GNUNullExpr>(
E))
return true;
2997 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2998 I = ObjCImpls.find(
D);
2999 if (I != ObjCImpls.end())
3000 return cast<ObjCImplementationDecl>(I->second);
3007 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
3008 I = ObjCImpls.find(
D);
3009 if (I != ObjCImpls.end())
3010 return cast<ObjCCategoryImplDecl>(I->second);
3017 assert(IFaceD && ImplD &&
"Passed null params");
3018 ObjCImpls[IFaceD] = ImplD;
3024 assert(CatD && ImplD &&
"Passed null params");
3025 ObjCImpls[CatD] = ImplD;
3030 return ObjCMethodRedecls.lookup(MD);
3036 ObjCMethodRedecls[MD] = Redecl;
3041 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->
getDeclContext()))
3043 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->
getDeclContext()))
3044 return CD->getClassInterface();
3045 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(ND->
getDeclContext()))
3046 return IMD->getClassInterface();
3054 assert(VD &&
"Passed null params");
3055 assert(VD->
hasAttr<BlocksAttr>() &&
3056 "getBlockVarCopyInits - not __block var");
3057 auto I = BlockVarCopyInits.find(VD);
3058 if (I != BlockVarCopyInits.end())
3060 return {
nullptr,
false};
3066 assert(VD && CopyExpr &&
"Passed null params");
3067 assert(VD->
hasAttr<BlocksAttr>() &&
3068 "setBlockVarCopyInits - not __block var");
3069 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr,
CanThrow);
3073 unsigned DataSize)
const {
3078 "incorrect data size provided to CreateTypeSourceInfo!");
3095 return getObjCLayout(
D,
nullptr);
3101 return getObjCLayout(
D->getClassInterface(),
D);
3106 bool &AnyNonCanonArgs) {
3108 for (
auto &Arg : CanonArgs) {
3110 Arg =
C.getCanonicalTemplateArgument(Arg);
3111 AnyNonCanonArgs |= !Arg.structurallyEquals(OrigArg);
3121ASTContext::getExtQualType(
const Type *baseType,
Qualifiers quals)
const {
3126 llvm::FoldingSetNodeID
ID;
3128 void *insertPos =
nullptr;
3129 if (
ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
3130 assert(eq->getQualifiers() == quals);
3139 canon = getExtQualType(canonSplit.
Ty, canonSplit.
Quals);
3142 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
3145 auto *eq =
new (*
this,
alignof(
ExtQuals))
ExtQuals(baseType, canon, quals);
3146 ExtQualNodes.InsertNode(eq, insertPos);
3151 LangAS AddressSpace)
const {
3164 "Type cannot be in multiple addr spaces!");
3167 return getExtQualType(TypeNode, Quals);
3173 if (!
T.hasAddressSpace())
3177 const Type *TypeNode;
3182 TypeNode =
T.getTypePtr();
3186 while (
T.hasAddressSpace()) {
3187 TypeNode = Quals.
strip(
T);
3191 if (!
QualType(TypeNode, 0).hasAddressSpace())
3195 T =
T.getSingleStepDesugaredType(*
this);
3205 return getExtQualType(TypeNode, Quals);
3213 "Attempted to get vtable pointer discriminator on a monomorphic type");
3216 llvm::raw_svector_ostream Out(Str);
3217 MC->mangleCXXVTable(RD, Out);
3218 return llvm::getPointerAuthStableSipHash(Str);
3247 Ctx, OS, cast<AtomicType>(
T)->getValueType());
3249 case Type::LValueReference:
3254 case Type::RValueReference:
3268 case Type::ObjCObjectPointer:
3269 case Type::BlockPointer:
3276 Ctx, OS, cast<ComplexType>(
T)->getElementType());
3278 case Type::VariableArray:
3279 case Type::ConstantArray:
3280 case Type::IncompleteArray:
3281 case Type::ArrayParameter:
3292 Ctx, OS, cast<ArrayType>(
T)->getElementType());
3294 case Type::ObjCInterface:
3295 case Type::ObjCObject:
3296 OS <<
"<objc_object>";
3305 QualType UnderlyingType = cast<EnumType>(
T)->getDecl()->getIntegerType();
3307 Ctx, OS, UnderlyingType.
isNull() ? Ctx.
IntTy : UnderlyingType);
3310 case Type::FunctionNoProto:
3311 case Type::FunctionProto: {
3325 const auto *FuncType = cast<FunctionType>(
T);
3327 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FuncType)) {
3328 for (
QualType Param : FPT->param_types()) {
3332 if (FPT->isVariadic())
3339 case Type::MemberPointer: {
3346 case Type::ExtVector:
3354 case Type::ConstantMatrix:
3358 case Type::Builtin: {
3360 switch (BTy->getKind()) {
3361#define SIGNED_TYPE(Id, SingletonId) \
3362 case BuiltinType::Id: \
3365#define UNSIGNED_TYPE(Id, SingletonId) \
3366 case BuiltinType::Id: \
3369#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
3370#define BUILTIN_TYPE(Id, SingletonId)
3371#include "clang/AST/BuiltinTypes.def"
3372 llvm_unreachable(
"placeholder types should not appear here.");
3374 case BuiltinType::Half:
3377 case BuiltinType::Float:
3380 case BuiltinType::Double:
3383 case BuiltinType::LongDouble:
3386 case BuiltinType::Float16:
3389 case BuiltinType::Float128:
3393 case BuiltinType::Void:
3397 case BuiltinType::ObjCId:
3398 case BuiltinType::ObjCClass:
3399 case BuiltinType::ObjCSel:
3400 case BuiltinType::NullPtr:
3405 case BuiltinType::OCLSampler:
3406 case BuiltinType::OCLEvent:
3407 case BuiltinType::OCLClkEvent:
3408 case BuiltinType::OCLQueue:
3409 case BuiltinType::OCLReserveID:
3410 case BuiltinType::BFloat16:
3411 case BuiltinType::VectorQuad:
3412 case BuiltinType::VectorPair:
3417 case BuiltinType::Ibm128:
3419#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3420 case BuiltinType::Id: \
3422#include "clang/Basic/OpenCLImageTypes.def"
3423#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3424 case BuiltinType::Id: \
3426#include "clang/Basic/OpenCLExtensionTypes.def"
3427#define SVE_TYPE(Name, Id, SingletonId) \
3428 case BuiltinType::Id: \
3430#include "clang/Basic/AArch64SVEACLETypes.def"
3431#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3432 case BuiltinType::Id: \
3434#include "clang/Basic/HLSLIntangibleTypes.def"
3435 case BuiltinType::Dependent:
3436 llvm_unreachable(
"should never get here");
3437#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
3438#include "clang/Basic/AMDGPUTypes.def"
3439 case BuiltinType::WasmExternRef:
3440#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
3441#include "clang/Basic/RISCVVTypes.def"
3442 llvm_unreachable(
"not yet implemented");
3444 llvm_unreachable(
"should never get here");
3446 case Type::Record: {
3467 II = Typedef->getDeclName().getAsIdentifierInfo();
3470 OS <<
"<anonymous_record>";
3476 case Type::HLSLAttributedResource:
3477 llvm_unreachable(
"should never get here");
3479 case Type::DeducedTemplateSpecialization:
3481#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3482#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3483#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3484#define ABSTRACT_TYPE(Class, Base)
3485#define TYPE(Class, Base)
3486#include "clang/AST/TypeNodes.inc"
3487 llvm_unreachable(
"unexpected non-canonical or dependent type!");
3494 "cannot compute type discriminator of a dependent type");
3497 llvm::raw_svector_ostream Out(Str);
3505 T =
T.getUnqualifiedType();
3507 MC->mangleCanonicalTypeName(
T, Out);
3510 return llvm::getPointerAuthStableSipHash(Str);
3535 "Type cannot have multiple ObjCGCs!");
3538 return getExtQualType(TypeNode, Quals);
3552 QualType WrappedTy,
Expr *CountExpr,
bool CountInBytes,
bool OrNull,
3556 llvm::FoldingSetNodeID ID;
3559 void *InsertPos =
nullptr;
3561 CountAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
3566 size_t Size = CountAttributedType::totalSizeToAlloc<TypeCoupledDeclRefInfo>(
3567 DependentDecls.size());
3570 OrNull, DependentDecls);
3571 Types.push_back(CATy);
3572 CountAttributedTypes.InsertNode(CATy, InsertPos);
3581 case Type::Attributed: {
3582 const auto *AT = cast<AttributedType>(Orig);
3589 case Type::BTFTagAttributed: {
3590 const auto *BTFT = dyn_cast<BTFTagAttributedType>(Orig);
3595 case Type::Elaborated: {
3596 const auto *ET = cast<ElaboratedType>(Orig);
3603 adjustType(cast<ParenType>(Orig)->getInnerType(), Adjust));
3605 case Type::Adjusted: {
3606 const auto *AT = cast<AdjustedType>(Orig);
3611 case Type::MacroQualified: {
3612 const auto *MQT = cast<MacroQualifiedType>(Orig);
3614 MQT->getMacroIdentifier());
3618 return Adjust(Orig);
3628 if (
const auto *FNPT = dyn_cast<FunctionNoProtoType>(
T)) {
3631 const auto *FPT = cast<FunctionProtoType>(
T);
3637 return cast<FunctionType>(
Result.getTypePtr());
3648 FPT->getExtProtoInfo());
3663 L->DeducedReturnType(FD, ResultType);
3674 return getFunctionType(Proto->getReturnType(), Proto->getParamTypes(),
3675 Proto->getExtProtoInfo().withExceptionSpec(ESI));
3691 for (
unsigned i = 0, n = Args.size(); i != n; ++i)
3714 return getFunctionType(Proto->getReturnType(), Proto->param_types(), EPI);
3740 if (TSInfo->getType() != FD->
getType())
3748 "TypeLoc size mismatch from updating exception specification");
3749 TSInfo->overrideType(Updated);
3758 llvm::FoldingSetNodeID ID;
3761 void *InsertPos =
nullptr;
3762 if (
ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
3768 if (!
T.isCanonical()) {
3772 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
3773 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3776 Types.push_back(New);
3777 ComplexTypes.InsertNode(New, InsertPos);
3786 llvm::FoldingSetNodeID ID;
3789 void *InsertPos =
nullptr;
3790 if (
PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3796 if (!
T.isCanonical()) {
3800 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3801 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3804 Types.push_back(New);
3805 PointerTypes.InsertNode(New, InsertPos);
3810 llvm::FoldingSetNodeID ID;
3812 void *InsertPos =
nullptr;
3813 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3820 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3821 assert(!AT &&
"Shouldn't be in the map!");
3825 Types.push_back(AT);
3826 AdjustedTypes.InsertNode(AT, InsertPos);
3831 llvm::FoldingSetNodeID ID;
3833 void *InsertPos =
nullptr;
3834 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3841 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3842 assert(!AT &&
"Shouldn't be in the map!");
3845 Types.push_back(AT);
3846 AdjustedTypes.InsertNode(AT, InsertPos);
3877 const auto *ATy = cast<ConstantArrayType>(Ty);
3878 llvm::FoldingSetNodeID ID;
3879 ATy->Profile(ID, *
this, ATy->getElementType(), ATy->getZExtSize(),
3880 ATy->getSizeExpr(), ATy->getSizeModifier(),
3881 ATy->getIndexTypeQualifiers().getAsOpaqueValue());
3882 void *InsertPos =
nullptr;
3884 ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3893 AT = ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3894 assert(!AT &&
"Shouldn't be in the map!");
3899 Types.push_back(AT);
3900 ArrayParameterTypes.InsertNode(AT, InsertPos);
3910 llvm::FoldingSetNodeID ID;
3913 void *InsertPos =
nullptr;
3915 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3921 if (!
T.isCanonical()) {
3926 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3927 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3931 Types.push_back(New);
3932 BlockPointerTypes.InsertNode(New, InsertPos);
3942 "Unresolved placeholder type");
3946 llvm::FoldingSetNodeID ID;
3949 void *InsertPos =
nullptr;
3951 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
3959 if (!SpelledAsLValue || InnerRef || !
T.isCanonical()) {
3960 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
3965 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
3966 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3971 Types.push_back(New);
3972 LValueReferenceTypes.InsertNode(New, InsertPos);
3982 "Unresolved placeholder type");
3986 llvm::FoldingSetNodeID ID;
3989 void *InsertPos =
nullptr;
3991 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
3999 if (InnerRef || !
T.isCanonical()) {
4000 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
4005 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
4006 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4011 Types.push_back(New);
4012 RValueReferenceTypes.InsertNode(New, InsertPos);
4021 llvm::FoldingSetNodeID ID;
4024 void *InsertPos =
nullptr;
4026 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4037 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4038 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4042 Types.push_back(New);
4043 MemberPointerTypes.InsertNode(New, InsertPos);
4050 const llvm::APInt &ArySizeIn,
4051 const Expr *SizeExpr,
4053 unsigned IndexTypeQuals)
const {
4056 "Constant array of VLAs is illegal!");
4064 llvm::APInt ArySize(ArySizeIn);
4065 ArySize = ArySize.zextOrTrunc(
Target->getMaxPointerWidth());
4067 llvm::FoldingSetNodeID ID;
4069 ASM, IndexTypeQuals);
4071 void *InsertPos =
nullptr;
4073 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
4084 ASM, IndexTypeQuals);
4089 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
4090 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4093 auto *New = ConstantArrayType::Create(*
this, EltTy, Canon, ArySize, SizeExpr,
4094 ASM, IndexTypeQuals);
4095 ConstantArrayTypes.InsertNode(New, InsertPos);
4096 Types.push_back(New);
4105 if (!
type->isVariablyModifiedType())
return type;
4110 const Type *ty = split.
Ty;
4112#define TYPE(Class, Base)
4113#define ABSTRACT_TYPE(Class, Base)
4114#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4115#include "clang/AST/TypeNodes.inc"
4116 llvm_unreachable(
"didn't desugar past all non-canonical types?");
4122 case Type::DependentVector:
4123 case Type::ExtVector:
4124 case Type::DependentSizedExtVector:
4125 case Type::ConstantMatrix:
4126 case Type::DependentSizedMatrix:
4127 case Type::DependentAddressSpace:
4128 case Type::ObjCObject:
4129 case Type::ObjCInterface:
4130 case Type::ObjCObjectPointer:
4133 case Type::UnresolvedUsing:
4134 case Type::TypeOfExpr:
4136 case Type::Decltype:
4137 case Type::UnaryTransform:
4138 case Type::DependentName:
4139 case Type::InjectedClassName:
4140 case Type::TemplateSpecialization:
4141 case Type::DependentTemplateSpecialization:
4142 case Type::TemplateTypeParm:
4143 case Type::SubstTemplateTypeParmPack:
4145 case Type::DeducedTemplateSpecialization:
4146 case Type::PackExpansion:
4147 case Type::PackIndexing:
4149 case Type::DependentBitInt:
4150 case Type::ArrayParameter:
4151 case Type::HLSLAttributedResource:
4152 llvm_unreachable(
"type should never be variably-modified");
4156 case Type::FunctionNoProto:
4157 case Type::FunctionProto:
4158 case Type::BlockPointer:
4159 case Type::MemberPointer:
4172 case Type::LValueReference: {
4173 const auto *lv = cast<LValueReferenceType>(ty);
4176 lv->isSpelledAsLValue());
4180 case Type::RValueReference: {
4181 const auto *lv = cast<RValueReferenceType>(ty);
4187 case Type::Atomic: {
4188 const auto *at = cast<AtomicType>(ty);
4193 case Type::ConstantArray: {
4194 const auto *cat = cast<ConstantArrayType>(ty);
4199 cat->getSizeModifier(),
4200 cat->getIndexTypeCVRQualifiers());
4204 case Type::DependentSizedArray: {
4205 const auto *dat = cast<DependentSizedArrayType>(ty);
4209 dat->getSizeModifier(),
4210 dat->getIndexTypeCVRQualifiers(),
4211 dat->getBracketsRange());
4216 case Type::IncompleteArray: {
4217 const auto *iat = cast<IncompleteArrayType>(ty);
4226 case Type::VariableArray: {
4227 const auto *vat = cast<VariableArrayType>(ty);
4231 vat->getIndexTypeCVRQualifiers(), vat->getBracketsRange());
4244 unsigned IndexTypeQuals,
4255 IndexTypeQuals, Brackets);
4262 VariableArrayTypes.push_back(New);
4263 Types.push_back(New);
4273 unsigned elementTypeQuals,
4277 "Size must be type- or value-dependent!");
4281 void *insertPos =
nullptr;
4282 llvm::FoldingSetNodeID ID;
4284 ID, *
this, numElements ?
QualType(canonElementType.
Ty, 0) : elementType,
4285 ASM, elementTypeQuals, numElements);
4289 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4300 elementTypeQuals, brackets);
4301 DependentSizedArrayTypes.InsertNode(newType, insertPos);
4302 Types.push_back(newType);
4310 numElements, ASM, elementTypeQuals, brackets);
4311 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
4312 Types.push_back(canonTy);
4317 canonElementType.
Quals);
4321 if (
QualType(canonElementType.
Ty, 0) == elementType &&
4329 elementTypeQuals, brackets);
4330 Types.push_back(sugaredType);
4336 unsigned elementTypeQuals)
const {
4337 llvm::FoldingSetNodeID ID;
4340 void *insertPos =
nullptr;
4342 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
4354 ASM, elementTypeQuals);
4359 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4360 assert(!existing &&
"Shouldn't be in the map!"); (void) existing;
4366 IncompleteArrayTypes.InsertNode(newType, insertPos);
4367 Types.push_back(newType);
4373#define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS) \
4374 {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \
4377#define SVE_ELTTY(ELTTY, ELTS, NUMVECTORS) \
4378 {ELTTY, llvm::ElementCount::getScalable(ELTS), NUMVECTORS};
4382 llvm_unreachable(
"Unsupported builtin vector type");
4384#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4385 ElBits, NF, IsSigned) \
4386 case BuiltinType::Id: \
4387 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4388 llvm::ElementCount::getScalable(NumEls), NF};
4389#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4391 case BuiltinType::Id: \
4392 return {ElBits == 16 ? HalfTy : (ElBits == 32 ? FloatTy : DoubleTy), \
4393 llvm::ElementCount::getScalable(NumEls), NF};
4394#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4396 case BuiltinType::Id: \
4397 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4398#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4399 case BuiltinType::Id: \
4400 return {BoolTy, llvm::ElementCount::getScalable(NumEls), NF};
4401#define AARCH64_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4403 case BuiltinType::Id: \
4404 return {getIntTypeForBitwidth(ElBits, false), \
4405 llvm::ElementCount::getFixed(NumEls), NF};
4406#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId)
4407#include "clang/Basic/AArch64SVEACLETypes.def"
4409#define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF, \
4411 case BuiltinType::Id: \
4412 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4413 llvm::ElementCount::getScalable(NumEls), NF};
4414#define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4415 case BuiltinType::Id: \
4416 return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy), \
4417 llvm::ElementCount::getScalable(NumEls), NF};
4418#define RVV_VECTOR_TYPE_BFLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4419 case BuiltinType::Id: \
4420 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4421#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4422 case BuiltinType::Id: \
4423 return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1};
4424#include "clang/Basic/RISCVVTypes.def"
4431 if (
Target->getTriple().isWasm() &&
Target->hasFeature(
"reference-types")) {
4432#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
4433 if (BuiltinType::Id == BuiltinType::WasmExternRef) \
4435#include "clang/Basic/WebAssemblyReferenceTypes.def"
4438 "shouldn't try to generate type externref outside WebAssembly target");
4445 unsigned NumFields)
const {
4446 if (
Target->hasAArch64SVETypes()) {
4449#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4450 ElBits, NF, IsSigned) \
4451 if (EltTy->hasIntegerRepresentation() && !EltTy->isBooleanType() && \
4452 EltTy->hasSignedIntegerRepresentation() == IsSigned && \
4453 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4454 return SingletonId; \
4456#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4458 if (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4459 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4460 return SingletonId; \
4462#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4464 if (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4465 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4466 return SingletonId; \
4468#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4469 if (EltTy->isBooleanType() && NumElts == (NumEls * NF) && NumFields == 1) \
4471#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId)
4472#define AARCH64_VECTOR_TYPE(Name, MangledName, Id, SingletonId)
4473#include "clang/Basic/AArch64SVEACLETypes.def"
4474 }
else if (
Target->hasRISCVVTypes()) {
4476#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
4478 if (!EltTy->isBooleanType() && \
4479 ((EltTy->hasIntegerRepresentation() && \
4480 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \
4481 (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4483 (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4484 IsBF && !IsFP)) && \
4485 EltTySize == ElBits && NumElts == NumEls && NumFields == NF) \
4487#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4488 if (EltTy->isBooleanType() && NumElts == NumEls) \
4490#include "clang/Basic/RISCVVTypes.def"
4506 llvm::FoldingSetNodeID ID;
4509 void *InsertPos =
nullptr;
4510 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4520 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4521 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4524 VectorType(vecType, NumElts, Canonical, VecKind);
4525 VectorTypes.InsertNode(New, InsertPos);
4526 Types.push_back(New);
4533 llvm::FoldingSetNodeID ID;
4536 void *InsertPos =
nullptr;
4538 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4543 VecType,
QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
4546 if (CanonVecTy == VecType) {
4551 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4552 assert(!CanonCheck &&
4553 "Dependent-sized vector_size canonical type broken");
4555 DependentVectorTypes.InsertNode(New, InsertPos);
4564 Types.push_back(New);
4571 unsigned NumElts)
const {
4579 llvm::FoldingSetNodeID ID;
4582 void *InsertPos =
nullptr;
4583 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4593 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4594 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4598 VectorTypes.InsertNode(New, InsertPos);
4599 Types.push_back(New);
4607 llvm::FoldingSetNodeID ID;
4611 void *InsertPos =
nullptr;
4613 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4623 if (CanonVecTy == vecType) {
4628 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4629 assert(!CanonCheck &&
"Dependent-sized ext_vector canonical type broken");
4631 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
4640 Types.push_back(New);
4645 unsigned NumColumns)
const {
4646 llvm::FoldingSetNodeID ID;
4648 Type::ConstantMatrix);
4651 "need a valid element type");
4654 "need valid matrix dimensions");
4655 void *InsertPos =
nullptr;
4665 assert(!NewIP &&
"Matrix type shouldn't already exist in the map");
4671 MatrixTypes.InsertNode(New, InsertPos);
4672 Types.push_back(New);
4681 llvm::FoldingSetNodeID ID;
4685 void *InsertPos =
nullptr;
4687 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4692 ColumnExpr, AttrLoc);
4695 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4696 assert(!CanonCheck &&
"Dependent-sized matrix canonical type broken");
4698 DependentSizedMatrixTypes.InsertNode(Canon, InsertPos);
4699 Types.push_back(Canon);
4712 ColumnExpr, AttrLoc);
4713 Types.push_back(New);
4718 Expr *AddrSpaceExpr,
4724 void *insertPos =
nullptr;
4725 llvm::FoldingSetNodeID ID;
4730 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
4736 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
4737 Types.push_back(canonTy);
4740 if (canonPointeeType == PointeeType &&
4746 AddrSpaceExpr, AttrLoc);
4747 Types.push_back(sugaredType);
4753 return T.isCanonical() &&
4771 llvm::FoldingSetNodeID ID;
4774 void *InsertPos =
nullptr;
4776 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
4786 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
4787 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4792 Types.push_back(New);
4793 FunctionNoProtoTypes.InsertNode(New, InsertPos);
4809 return CanResultType;
4816 if (!NoexceptInType)
4833 bool AnyPackExpansions =
false;
4838 AnyPackExpansions =
true;
4840 return AnyPackExpansions;
4846QualType ASTContext::getFunctionTypeInternal(
4849 size_t NumArgs = ArgArray.size();
4853 llvm::FoldingSetNodeID
ID;
4858 bool Unique =
false;
4860 void *InsertPos =
nullptr;
4862 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
4882 bool IsCanonicalExceptionSpec =
4886 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
4888 for (
unsigned i = 0; i != NumArgs && isCanonical; ++i)
4889 if (!ArgArray[i].isCanonicalAsParam())
4890 isCanonical =
false;
4892 if (OnlyWantCanonical)
4893 assert(isCanonical &&
4894 "given non-canonical parameters constructing canonical type");
4899 if (!isCanonical && Canonical.
isNull()) {
4901 CanonicalArgs.reserve(NumArgs);
4902 for (
unsigned i = 0; i != NumArgs; ++i)
4909 if (IsCanonicalExceptionSpec) {
4911 }
else if (NoexceptInType) {
4924 bool AnyPacks =
false;
4947 llvm_unreachable(
"dependent noexcept is already canonical");
4956 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI,
true);
4960 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
4961 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4966 auto ESH = FunctionProtoType::getExceptionSpecSize(
4968 size_t Size = FunctionProtoType::totalSizeToAlloc<
4975 ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
4983 Types.push_back(FTP);
4985 FunctionProtoTypes.InsertNode(FTP, InsertPos);
4987 AnyFunctionEffects =
true;
4992 llvm::FoldingSetNodeID
ID;
4995 void *InsertPos =
nullptr;
4996 if (
PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
5002 if (!
T.isCanonical()) {
5006 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
5007 assert(!NewIP &&
"Shouldn't be in the map!");
5011 Types.push_back(New);
5012 PipeTypes.InsertNode(New, InsertPos);
5023 return getPipeType(
T,
true);
5027 return getPipeType(
T,
false);
5031 llvm::FoldingSetNodeID ID;
5034 void *InsertPos =
nullptr;
5035 if (
BitIntType *EIT = BitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5039 BitIntTypes.InsertNode(New, InsertPos);
5040 Types.push_back(New);
5045 Expr *NumBitsExpr)
const {
5047 llvm::FoldingSetNodeID ID;
5050 void *InsertPos =
nullptr;
5052 DependentBitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5057 DependentBitIntTypes.InsertNode(New, InsertPos);
5059 Types.push_back(New);
5065 if (!isa<CXXRecordDecl>(
D))
return false;
5066 const auto *RD = cast<CXXRecordDecl>(
D);
5067 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
5069 if (RD->getDescribedClassTemplate() &&
5070 !isa<ClassTemplateSpecializationDecl>(RD))
5081 if (
Decl->TypeForDecl) {
5082 assert(isa<InjectedClassNameType>(
Decl->TypeForDecl));
5084 assert(PrevDecl->TypeForDecl &&
"previous declaration has no type");
5085 Decl->TypeForDecl = PrevDecl->TypeForDecl;
5086 assert(isa<InjectedClassNameType>(
Decl->TypeForDecl));
5090 Decl->TypeForDecl = newType;
5091 Types.push_back(newType);
5099 assert(
Decl &&
"Passed null for Decl param");
5100 assert(!
Decl->TypeForDecl &&
"TypeForDecl present in slow case");
5102 if (
const auto *Typedef = dyn_cast<TypedefNameDecl>(
Decl))
5105 assert(!isa<TemplateTypeParmDecl>(
Decl) &&
5106 "Template type parameter types are always available.");
5108 if (
const auto *
Record = dyn_cast<RecordDecl>(
Decl)) {
5109 assert(
Record->isFirstDecl() &&
"struct/union has previous declaration");
5112 }
else if (
const auto *
Enum = dyn_cast<EnumDecl>(
Decl)) {
5113 assert(
Enum->isFirstDecl() &&
"enum has previous declaration");
5115 }
else if (
const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl)) {
5118 llvm_unreachable(
"TypeDecl without a type?");
5127 if (!
Decl->TypeForDecl) {
5129 Underlying =
Decl->getUnderlyingType();
5132 Decl->TypeForDecl = NewType;
5133 Types.push_back(NewType);
5136 if (Underlying.
isNull() ||
Decl->getUnderlyingType() == Underlying)
5140 llvm::FoldingSetNodeID ID;
5143 void *InsertPos =
nullptr;
5144 if (
TypedefType *
T = TypedefTypes.FindNodeOrInsertPos(ID, InsertPos)) {
5145 assert(!
T->typeMatchesDecl() &&
5146 "non-divergent case should be handled with TypeDecl");
5150 void *Mem =
Allocate(TypedefType::totalSizeToAlloc<QualType>(
true),
5152 auto *NewType =
new (Mem)
TypedefType(Type::Typedef,
Decl, Underlying,
5154 TypedefTypes.InsertNode(NewType, InsertPos);
5155 Types.push_back(NewType);
5161 llvm::FoldingSetNodeID ID;
5164 void *InsertPos =
nullptr;
5165 if (
UsingType *
T = UsingTypes.FindNodeOrInsertPos(ID, InsertPos))
5168 const Type *TypeForDecl =
5169 cast<TypeDecl>(
Found->getTargetDecl())->getTypeForDecl();
5178 Allocate(UsingType::totalSizeToAlloc<QualType>(!Underlying.
isNull()),
5181 Types.push_back(NewType);
5182 UsingTypes.InsertNode(NewType, InsertPos);
5190 if (PrevDecl->TypeForDecl)
5191 return QualType(
Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
5194 Decl->TypeForDecl = newType;
5195 Types.push_back(newType);
5203 if (PrevDecl->TypeForDecl)
5204 return QualType(
Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
5207 Decl->TypeForDecl = newType;
5208 Types.push_back(newType);
5214 if (
Decl->TypeForDecl)
5219 if (CanonicalDecl->TypeForDecl)
5220 return QualType(
Decl->TypeForDecl = CanonicalDecl->TypeForDecl, 0);
5224 Decl->TypeForDecl = newType;
5225 Types.push_back(newType);
5232 const Attr *attr)
const {
5233 llvm::FoldingSetNodeID id;
5236 void *insertPos =
nullptr;
5240 assert(!
attr ||
attr->getKind() == attrKind);
5246 Types.push_back(
type);
5247 AttributedTypes.InsertNode(
type, insertPos);
5260 switch (nullability) {
5276 llvm_unreachable(
"Unknown nullability kind");
5281 llvm::FoldingSetNodeID ID;
5284 void *InsertPos =
nullptr;
5286 BTFTagAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
5294 Types.push_back(Ty);
5295 BTFTagAttributedTypes.InsertNode(Ty, InsertPos);
5304 llvm::FoldingSetNodeID ID;
5307 void *InsertPos =
nullptr;
5309 HLSLAttributedResourceTypes.FindNodeOrInsertPos(ID, InsertPos);
5316 Types.push_back(Ty);
5317 HLSLAttributedResourceTypes.InsertNode(Ty, InsertPos);
5323 QualType Replacement,
Decl *AssociatedDecl,
unsigned Index,
5324 std::optional<unsigned> PackIndex,
5326 llvm::FoldingSetNodeID ID;
5329 void *InsertPos =
nullptr;
5331 SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5334 void *Mem =
Allocate(SubstTemplateTypeParmType::totalSizeToAlloc<QualType>(
5335 !Replacement.isCanonical()),
5338 Index, PackIndex, Flag);
5339 Types.push_back(SubstParm);
5340 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
5349 unsigned Index,
bool Final,
5356 llvm::FoldingSetNodeID ID;
5359 void *InsertPos =
nullptr;
5361 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
5371 [[maybe_unused]]
const auto *Nothing =
5372 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
5380 Types.push_back(SubstParm);
5381 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
5391 llvm::FoldingSetNodeID ID;
5393 void *InsertPos =
nullptr;
5395 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5406 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5407 assert(!TypeCheck &&
"Template type parameter canonical type broken");
5411 Depth, Index, ParameterPack,
nullptr,
QualType());
5413 Types.push_back(TypeParm);
5414 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
5424 assert(!Name.getAsDependentTemplateName() &&
5425 "No dependent template names here!");
5436 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
5446 "No dependent template names here!");
5449 ArgVec.reserve(Args.size());
5451 ArgVec.push_back(Arg.getArgument());
5459 if (Arg.isPackExpansion())
5471 "No dependent template names here!");
5476 if (!Underlying.
isNull())
5482 "Caller must compute aliased type");
5483 IsTypeAlias =
false;
5492 (IsTypeAlias ?
sizeof(
QualType) : 0),
5496 IsTypeAlias ? Underlying :
QualType());
5498 Types.push_back(Spec);
5505 "No dependent template names here!");
5514 bool AnyNonCanonArgs =
false;
5520 llvm::FoldingSetNodeID ID;
5524 void *InsertPos =
nullptr;
5526 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
5536 Types.push_back(Spec);
5537 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
5541 "Non-dependent template-id type must have a canonical type");
5548 TagDecl *OwnedTagDecl)
const {
5549 llvm::FoldingSetNodeID ID;
5552 void *InsertPos =
nullptr;
5553 ElaboratedType *
T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
5560 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
5561 assert(!CheckT &&
"Elaborated canonical type broken");
5566 Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
5568 T =
new (Mem)
ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
5571 ElaboratedTypes.InsertNode(
T, InsertPos);
5577 llvm::FoldingSetNodeID ID;
5580 void *InsertPos =
nullptr;
5581 ParenType *
T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
5588 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
5589 assert(!CheckT &&
"Paren canonical type broken");
5595 ParenTypes.InsertNode(
T, InsertPos);
5608 Types.push_back(newType);
5618 if (CanonNNS != NNS)
5622 llvm::FoldingSetNodeID ID;
5625 void *InsertPos =
nullptr;
5627 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
5634 DependentNameTypes.InsertNode(
T, InsertPos);
5643 for (
unsigned I = 0,
E = Args.size(); I !=
E; ++I)
5655 "nested-name-specifier must be dependent");
5657 llvm::FoldingSetNodeID ID;
5661 void *InsertPos =
nullptr;
5663 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
5673 bool AnyNonCanonArgs =
false;
5678 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
5684 [[maybe_unused]]
auto *Nothing =
5685 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
5686 assert(!Nothing &&
"canonical type broken");
5695 DependentTemplateSpecializationTypes.InsertNode(
T, InsertPos);
5701 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
5707 }
else if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5709 NTTP->getType().getNonPackExpansionType().getNonLValueExprType(*
this);
5724 Expr *
E =
new (*this)
5726 T, VK, NTTP->getLocation());
5728 if (NTTP->isParameterPack())
5733 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
5750 std::optional<unsigned> NumExpansions,
5751 bool ExpectPackInType)
const {
5753 "Pack expansions must expand one or more parameter packs");
5755 llvm::FoldingSetNodeID ID;
5758 void *InsertPos =
nullptr;
5770 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
5776 PackExpansionTypes.InsertNode(
T, InsertPos);
5788 if (Protocols.empty())
return true;
5793 for (
unsigned i = 1; i != Protocols.size(); ++i)
5803 llvm::array_pod_sort(Protocols.begin(), Protocols.end(),
CmpProtocolNames);
5807 P =
P->getCanonicalDecl();
5810 auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
5811 Protocols.erase(ProtocolsEnd, Protocols.end());
5816 unsigned NumProtocols)
const {
5826 bool isKindOf)
const {
5829 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
5830 isa<ObjCInterfaceType>(baseType))
5834 llvm::FoldingSetNodeID ID;
5836 void *InsertPos =
nullptr;
5837 if (
ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
5844 if (effectiveTypeArgs.empty()) {
5846 effectiveTypeArgs = baseObject->getTypeArgs();
5853 bool typeArgsAreCanonical = llvm::all_of(
5856 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.
isCanonical()) {
5860 if (!typeArgsAreCanonical) {
5861 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
5862 for (
auto typeArg : effectiveTypeArgs)
5864 canonTypeArgs = canonTypeArgsVec;
5866 canonTypeArgs = effectiveTypeArgs;
5871 if (!protocolsSorted) {
5872 canonProtocolsVec.append(protocols.begin(), protocols.end());
5874 canonProtocols = canonProtocolsVec;
5876 canonProtocols = protocols;
5880 canonProtocols, isKindOf);
5883 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
5887 size += typeArgs.size() *
sizeof(
QualType);
5895 ObjCObjectTypes.InsertNode(
T, InsertPos);
5905 bool allowOnPointerType)
const {
5908 if (
const auto *objT = dyn_cast<ObjCTypeParamType>(
type.getTypePtr())) {
5913 if (allowOnPointerType) {
5914 if (
const auto *objPtr =
5915 dyn_cast<ObjCObjectPointerType>(
type.getTypePtr())) {
5921 protocolsVec.append(protocols.begin(), protocols.end());
5933 if (
const auto *objT = dyn_cast<ObjCObjectType>(
type.getTypePtr())){
5938 objT->getTypeArgsAsWritten(),
5940 objT->isKindOfTypeAsWritten());
5944 if (
type->isObjCObjectType()) {
5954 if (
type->isObjCIdType()) {
5957 objPtr->isKindOfType());
5962 if (
type->isObjCClassType()) {
5965 objPtr->isKindOfType());
5977 llvm::FoldingSetNodeID ID;
5979 void *InsertPos =
nullptr;
5981 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
5986 if (!protocols.empty()) {
5990 Canonical, protocols, hasError,
true ));
5991 assert(!hasError &&
"Error when apply protocol qualifier to bound type");
5999 Types.push_back(newType);
6000 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
6008 auto NewTypeParamTy = cast<ObjCTypeParamType>(New->
getTypeForDecl());
6010 protocols.append(NewTypeParamTy->qual_begin(), NewTypeParamTy->qual_end());
6025 for (
auto *Proto : OPT->quals()) {
6048 if (InheritedProtocols.empty())
6052 bool Conforms =
false;
6053 for (
auto *Proto : OPT->quals()) {
6055 for (
auto *PI : InheritedProtocols) {
6067 for (
auto *PI : InheritedProtocols) {
6069 bool Adopts =
false;
6070 for (
auto *Proto : OPT->quals()) {
6084 llvm::FoldingSetNodeID ID;
6087 void *InsertPos =
nullptr;
6089 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
6098 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
6107 Types.push_back(QType);
6108 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
6116 if (
Decl->TypeForDecl)
6120 assert(PrevDecl->TypeForDecl &&
"previous decl has no TypeForDecl");
6121 Decl->TypeForDecl = PrevDecl->TypeForDecl;
6122 return QualType(PrevDecl->TypeForDecl, 0);
6131 Decl->TypeForDecl =
T;
6144 llvm::FoldingSetNodeID ID;
6148 void *InsertPos =
nullptr;
6150 DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
6160 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
6168 Types.push_back(toe);
6181 Types.push_back(tot);
6205 llvm_unreachable(
"Unknown value kind");
6220 llvm::FoldingSetNodeID ID;
6223 void *InsertPos =
nullptr;
6225 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
6230 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
6238 Types.push_back(dt);
6243 bool FullySubstituted,
6247 if (FullySubstituted && Index != -1) {
6250 llvm::FoldingSetNodeID ID;
6253 void *InsertPos =
nullptr;
6255 DependentPackIndexingTypes.FindNodeOrInsertPos(ID, InsertPos);
6258 PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6262 IndexExpr, FullySubstituted, Expansions);
6263 DependentPackIndexingTypes.InsertNode(Canon, InsertPos);
6269 Allocate(PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6272 FullySubstituted, Expansions);
6287 llvm::FoldingSetNodeID ID;
6290 void *InsertPos =
nullptr;
6292 = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
6298 DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
6307 Types.push_back(ut);
6311QualType ASTContext::getAutoTypeInternal(
6316 !TypeConstraintConcept && !IsDependent)
6320 llvm::FoldingSetNodeID ID;
6321 bool IsDeducedDependent =
6324 IsDependent || IsDeducedDependent, TypeConstraintConcept,
6325 TypeConstraintArgs);
6326 if (
auto const AT_iter = AutoTypes.find(ID); AT_iter != AutoTypes.end())
6327 return QualType(AT_iter->getSecond(), 0);
6333 }
else if (TypeConstraintConcept) {
6334 bool AnyNonCanonArgs =
false;
6337 *
this, TypeConstraintArgs, AnyNonCanonArgs);
6338 if (CanonicalConcept != TypeConstraintConcept || AnyNonCanonArgs) {
6340 getAutoTypeInternal(
QualType(), Keyword, IsDependent, IsPack,
6341 CanonicalConcept, CanonicalConceptArgs,
true);
6351 (IsDependent ? TypeDependence::DependentInstantiation
6352 : TypeDependence::None) |
6353 (IsPack ? TypeDependence::UnexpandedPack : TypeDependence::None),
6354 Canon, TypeConstraintConcept, TypeConstraintArgs);
6356 llvm::FoldingSetNodeID InsertedID;
6357 AT->
Profile(InsertedID, *
this);
6358 assert(InsertedID == ID &&
"ID does not match");
6360 Types.push_back(AT);
6361 AutoTypes.try_emplace(ID, AT);
6370 bool IsDependent,
bool IsPack,
6373 assert((!IsPack || IsDependent) &&
"only use IsPack for a dependent pack");
6375 "A dependent auto should be undeduced");
6376 return getAutoTypeInternal(
DeducedType, Keyword, IsDependent, IsPack,
6377 TypeConstraintConcept, TypeConstraintArgs);
6381 QualType CanonT =
T.getNonPackExpansionType().getCanonicalType();
6385 if (!AT->isConstrained())
6389 AT->containsUnexpandedParameterPack()),
6401QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
6405 void *InsertPos =
nullptr;
6406 llvm::FoldingSetNodeID ID;
6410 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
6416 llvm::FoldingSetNodeID TempID;
6417 DTST->Profile(TempID);
6418 assert(ID == TempID &&
"ID does not match");
6419 Types.push_back(DTST);
6420 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
6430 ? getDeducedTemplateSpecializationTypeInternal(
6434 return getDeducedTemplateSpecializationTypeInternal(Template,
DeducedType,
6435 IsDependent, Canon);
6443 llvm::FoldingSetNodeID ID;
6446 void *InsertPos =
nullptr;
6447 if (
AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
6453 if (!
T.isCanonical()) {
6457 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
6458 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
6461 Types.push_back(New);
6462 AtomicTypes.InsertNode(New, InsertPos);
6498 return getFromTargetType(
Target->getSizeType());
6504 return getFromTargetType(
Target->getSignedSizeType());
6509 return getFromTargetType(
Target->getIntMaxType());
6514 return getFromTargetType(
Target->getUIntMaxType());
6532 return getFromTargetType(
Target->getIntPtrType());
6555 return getFromTargetType(
Target->getProcessIDType());
6567 const Type *Ty =
T.getTypePtr();
6571 }
else if (isa<ArrayType>(Ty)) {
6573 }
else if (isa<FunctionType>(Ty)) {
6595 quals = splitType.
Quals;
6600 QualType elementType = AT->getElementType();
6605 if (elementType == unqualElementType) {
6606 assert(quals.
empty());
6607 quals = splitType.
Quals;
6615 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
6617 CAT->getSizeExpr(), CAT->getSizeModifier(), 0);
6620 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
6624 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
6627 VAT->getSizeModifier(),
6628 VAT->getIndexTypeCVRQualifiers(),
6629 VAT->getBracketsRange());
6632 const auto *DSAT = cast<DependentSizedArrayType>(AT);
6634 DSAT->getSizeModifier(), 0,
6645 bool AllowPiMismatch)
const {
6660 if (
auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
6661 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
6662 if (!((CAT2 && CAT1->getSize() == CAT2->getSize()) ||
6664 isa<IncompleteArrayType>(AT2))))
6666 }
else if (isa<IncompleteArrayType>(AT1)) {
6667 if (!(isa<IncompleteArrayType>(AT2) ||
6669 isa<ConstantArrayType>(AT2))))
6675 T1 = AT1->getElementType();
6676 T2 = AT2->getElementType();
6696 bool AllowPiMismatch)
const {
6701 if (T1PtrType && T2PtrType) {
6709 if (T1MPType && T2MPType &&
6720 if (T1OPType && T2OPType) {
6752 if (Quals1 != Quals2)
6766 switch (Name.getKind()) {
6801 = Name.getAsSubstTemplateTemplateParm();
6808 = Name.getAsSubstTemplateTemplateParmPack();
6821 llvm_unreachable(
"bad template name kind!");
6827 if (!TP->hasDefaultArgument())
6829 return &TP->getDefaultArgument().getArgument();
6831 switch (
P->getKind()) {
6832 case NamedDecl::TemplateTypeParm:
6833 return handleParam(cast<TemplateTypeParmDecl>(
P));
6834 case NamedDecl::NonTypeTemplateParm:
6835 return handleParam(cast<NonTypeTemplateParmDecl>(
P));
6836 case NamedDecl::TemplateTemplateParm:
6837 return handleParam(cast<TemplateTemplateParmDecl>(
P));
6839 llvm_unreachable(
"Unexpected template parameter kind");
6844 bool IgnoreDeduced)
const {
6845 while (std::optional<TemplateName> UnderlyingOrNone =
6846 Name.desugar(IgnoreDeduced))
6847 Name = *UnderlyingOrNone;
6849 switch (Name.getKind()) {
6852 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
6853 Template = getCanonicalTemplateTemplateParmDecl(TTP);
6861 llvm_unreachable(
"cannot canonicalize unresolved template");
6865 assert(DTN &&
"Non-dependent template names must refer to template decls.");
6866 return DTN->CanonicalTemplateName;
6871 Name.getAsSubstTemplateTemplateParmPack();
6879 assert(IgnoreDeduced ==
false);
6886 bool NonCanonical = CanonUnderlying != Underlying;
6892 assert(CanonArgs.size() <= Params.size());
6898 for (
int I = CanonArgs.size() - 1; I >= 0; --I) {
6907 if (I ==
int(CanonArgs.size() - 1))
6908 CanonArgs.pop_back();
6909 NonCanonical =
true;
6919 llvm_unreachable(
"always sugar node");
6922 llvm_unreachable(
"bad template name!");
6927 bool IgnoreDeduced)
const {
6939 llvm::FoldingSetNodeID XCEID, YCEID;
6940 XCE->
Profile(XCEID, *
this,
true,
true);
6941 YCE->
Profile(YCEID, *
this,
true,
true);
6942 return XCEID == YCEID;
6991 if (
auto *TX = dyn_cast<TemplateTypeParmDecl>(
X)) {
6992 auto *TY = cast<TemplateTypeParmDecl>(Y);
6993 if (TX->isParameterPack() != TY->isParameterPack())
6995 if (TX->hasTypeConstraint() != TY->hasTypeConstraint())
6998 TY->getTypeConstraint());
7001 if (
auto *TX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7002 auto *TY = cast<NonTypeTemplateParmDecl>(Y);
7003 return TX->isParameterPack() == TY->isParameterPack() &&
7004 TX->getASTContext().hasSameType(TX->getType(), TY->getType()) &&
7006 TY->getPlaceholderTypeConstraint());
7009 auto *TX = cast<TemplateTemplateParmDecl>(
X);
7010 auto *TY = cast<TemplateTemplateParmDecl>(Y);
7011 return TX->isParameterPack() == TY->isParameterPack() &&
7013 TY->getTemplateParameters());
7018 if (
X->size() != Y->
size())
7021 for (
unsigned I = 0, N =
X->size(); I != N; ++I)
7035 if (
auto *TTPX = dyn_cast<TemplateTypeParmDecl>(
X)) {
7036 auto *TTPY = cast<TemplateTypeParmDecl>(Y);
7037 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7040 return hasSameType(TTPX->getDefaultArgument().getArgument().getAsType(),
7041 TTPY->getDefaultArgument().getArgument().getAsType());
7044 if (
auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7045 auto *NTTPY = cast<NonTypeTemplateParmDecl>(Y);
7046 if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
7049 Expr *DefaultArgumentX =
7050 NTTPX->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7051 Expr *DefaultArgumentY =
7052 NTTPY->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7053 llvm::FoldingSetNodeID XID, YID;
7054 DefaultArgumentX->
Profile(XID, *
this,
true);
7055 DefaultArgumentY->
Profile(YID, *
this,
true);
7059 auto *TTPX = cast<TemplateTemplateParmDecl>(
X);
7060 auto *TTPY = cast<TemplateTemplateParmDecl>(Y);
7062 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7071 if (
auto *NS =
X->getAsNamespace())
7073 if (
auto *NAS =
X->getAsNamespaceAlias())
7074 return NAS->getNamespace();
7082 if (!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())
7084 }
else if (
X->getKind() != Y->
getKind())
7089 switch (
X->getKind()) {
7100 if (
X->getAsType()->getCanonicalTypeInternal() !=
7110 auto *PX =
X->getPrefix();
7124 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
7128 for (
auto Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {
7129 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
7130 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
7133 if (!Cand1A || !Cand2A)
7139 (*Cand1A)->getCond()->Profile(Cand1ID, A->
getASTContext(),
true);
7140 (*Cand2A)->getCond()->Profile(Cand2ID, B->
getASTContext(),
true);
7144 if (Cand1ID != Cand2ID)
7172 if (
const auto *TypedefX = dyn_cast<TypedefNameDecl>(
X))
7173 if (
const auto *TypedefY = dyn_cast<TypedefNameDecl>(Y))
7175 TypedefY->getUnderlyingType());
7182 if (isa<ObjCInterfaceDecl>(
X) || isa<ObjCProtocolDecl>(
X))
7185 if (isa<ClassTemplateSpecializationDecl>(
X)) {
7192 if (
const auto *TagX = dyn_cast<TagDecl>(
X)) {
7193 const auto *TagY = cast<TagDecl>(Y);
7194 return (TagX->getTagKind() == TagY->getTagKind()) ||
7206 if (
const auto *FuncX = dyn_cast<FunctionDecl>(
X)) {
7207 const auto *FuncY = cast<FunctionDecl>(Y);
7208 if (
const auto *CtorX = dyn_cast<CXXConstructorDecl>(
X)) {
7209 const auto *CtorY = cast<CXXConstructorDecl>(Y);
7210 if (CtorX->getInheritedConstructor() &&
7211 !
isSameEntity(CtorX->getInheritedConstructor().getConstructor(),
7212 CtorY->getInheritedConstructor().getConstructor()))
7216 if (FuncX->isMultiVersion() != FuncY->isMultiVersion())
7221 if (FuncX->isMultiVersion()) {
7222 const auto *TAX = FuncX->getAttr<TargetAttr>();
7223 const auto *TAY = FuncY->getAttr<TargetAttr>();
7224 assert(TAX && TAY &&
"Multiversion Function without target attribute");
7226 if (TAX->getFeaturesStr() != TAY->getFeaturesStr())
7232 if ((FuncX->isMemberLikeConstrainedFriend() ||
7233 FuncY->isMemberLikeConstrainedFriend()) &&
7234 !FuncX->getLexicalDeclContext()->Equals(
7235 FuncY->getLexicalDeclContext())) {
7240 FuncY->getTrailingRequiresClause()))
7248 FD = FD->getCanonicalDecl();
7249 return FD->getTypeSourceInfo() ? FD->getTypeSourceInfo()->getType()
7252 QualType XT = GetTypeAsWritten(FuncX), YT = GetTypeAsWritten(FuncY);
7267 return FuncX->getLinkageInternal() == FuncY->getLinkageInternal() &&
7272 if (
const auto *VarX = dyn_cast<VarDecl>(
X)) {
7273 const auto *VarY = cast<VarDecl>(Y);
7274 if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
7277 if (VarX->getType().isNull() || VarY->getType().isNull())
7280 if (
hasSameType(VarX->getType(), VarY->getType()))
7290 if (!VarXTy || !VarYTy)
7299 if (
const auto *NamespaceX = dyn_cast<NamespaceDecl>(
X)) {
7300 const auto *NamespaceY = cast<NamespaceDecl>(Y);
7301 return NamespaceX->isInline() == NamespaceY->isInline();
7306 if (
const auto *TemplateX = dyn_cast<TemplateDecl>(
X)) {
7307 const auto *TemplateY = cast<TemplateDecl>(Y);
7310 if (
const auto *ConceptX = dyn_cast<ConceptDecl>(
X)) {
7311 const auto *ConceptY = cast<ConceptDecl>(Y);
7313 ConceptY->getConstraintExpr()))
7318 TemplateY->getTemplatedDecl()) &&
7320 TemplateY->getTemplateParameters());
7324 if (
const auto *FDX = dyn_cast<FieldDecl>(
X)) {
7325 const auto *FDY = cast<FieldDecl>(Y);
7327 return hasSameType(FDX->getType(), FDY->getType());
7331 if (
const auto *IFDX = dyn_cast<IndirectFieldDecl>(
X)) {
7332 const auto *IFDY = cast<IndirectFieldDecl>(Y);
7333 return IFDX->getAnonField()->getCanonicalDecl() ==
7334 IFDY->getAnonField()->getCanonicalDecl();
7338 if (isa<EnumConstantDecl>(
X))
7343 if (
const auto *USX = dyn_cast<UsingShadowDecl>(
X)) {
7344 const auto *USY = cast<UsingShadowDecl>(Y);
7350 if (
const auto *UX = dyn_cast<UsingDecl>(
X)) {
7351 const auto *UY = cast<UsingDecl>(Y);
7353 UX->hasTypename() == UY->hasTypename() &&
7354 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7356 if (
const auto *UX = dyn_cast<UnresolvedUsingValueDecl>(
X)) {
7357 const auto *UY = cast<UnresolvedUsingValueDecl>(Y);
7359 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7361 if (
const auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(
X)) {
7364 cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
7369 if (
const auto *UX = dyn_cast<UsingPackDecl>(
X)) {
7371 UX->getInstantiatedFromUsingDecl(),
7372 cast<UsingPackDecl>(Y)->getInstantiatedFromUsingDecl());
7376 if (
const auto *NAX = dyn_cast<NamespaceAliasDecl>(
X)) {
7377 const auto *NAY = cast<NamespaceAliasDecl>(Y);
7378 return NAX->getNamespace()->Equals(NAY->getNamespace());
7425 bool AnyNonCanonArgs =
false;
7428 if (!AnyNonCanonArgs)
7438 llvm_unreachable(
"Unhandled template argument kind");
7481 DNT->getIdentifier());
7495 llvm_unreachable(
"Invalid NestedNameSpecifier::Kind!");
7500 if (!
T.hasLocalQualifiers()) {
7502 if (
const auto *AT = dyn_cast<ArrayType>(
T))
7507 if (!isa<ArrayType>(
T.getCanonicalType()))
7522 const auto *ATy = dyn_cast<ArrayType>(split.
Ty);
7523 if (!ATy || qs.
empty())
7530 if (
const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
7533 CAT->getSizeModifier(),
7534 CAT->getIndexTypeCVRQualifiers()));
7535 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
7537 IAT->getSizeModifier(),
7538 IAT->getIndexTypeCVRQualifiers()));
7540 if (
const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
7541 return cast<ArrayType>(
7543 DSAT->getSizeExpr(),
7544 DSAT->getSizeModifier(),
7545 DSAT->getIndexTypeCVRQualifiers(),
7546 DSAT->getBracketsRange()));
7548 const auto *VAT = cast<VariableArrayType>(ATy);
7551 VAT->getSizeModifier(),
7552 VAT->getIndexTypeCVRQualifiers(),
7553 VAT->getBracketsRange()));
7567 return T.getUnqualifiedType();
7580 return T.getUnqualifiedType();
7595 assert(PrettyArrayType &&
"Not an array type!");
7632 uint64_t ElementCount = 1;
7635 CA = dyn_cast_or_null<ConstantArrayType>(
7638 return ElementCount;
7646 uint64_t ElementCount = 1;
7650 AILE = dyn_cast<ArrayInitLoopExpr>(AILE->
getSubExpr());
7653 return ElementCount;
7663 default: llvm_unreachable(
"getFloatingRank(): not a floating type");
7665 case BuiltinType::Half:
return HalfRank;
7666 case BuiltinType::Float:
return FloatRank;
7699unsigned ASTContext::getIntegerRank(
const Type *
T)
const {
7704 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
7705 return 0 + (EIT->getNumBits() << 3);
7707 switch (cast<BuiltinType>(
T)->getKind()) {
7708 default: llvm_unreachable(
"getIntegerRank(): not a built-in integer");
7709 case BuiltinType::Bool:
7711 case BuiltinType::Char_S:
7712 case BuiltinType::Char_U:
7713 case BuiltinType::SChar:
7714 case BuiltinType::UChar:
7716 case BuiltinType::Short:
7717 case BuiltinType::UShort:
7719 case BuiltinType::Int:
7720 case BuiltinType::UInt:
7722 case BuiltinType::Long:
7723 case BuiltinType::ULong:
7725 case BuiltinType::LongLong:
7726 case BuiltinType::ULongLong:
7728 case BuiltinType::Int128:
7729 case BuiltinType::UInt128:
7734 case BuiltinType::Char8:
7736 case BuiltinType::Char16:
7737 return getIntegerRank(
7739 case BuiltinType::Char32:
7740 return getIntegerRank(
7742 case BuiltinType::WChar_S:
7743 case BuiltinType::WChar_U:
7744 return getIntegerRank(
7774 uint64_t BitWidth = Field->getBitWidthValue();
7797 if (
QualType QT = Field->getType(); QT->isBitIntType())
7800 if (BitWidth < IntSize)
7803 if (BitWidth == IntSize)
7818 assert(!Promotable.
isNull());
7821 return ET->getDecl()->getPromotionType();
7830 if (BT->getKind() == BuiltinType::WChar_S ||
7831 BT->getKind() == BuiltinType::WChar_U ||
7832 BT->getKind() == BuiltinType::Char8 ||
7833 BT->getKind() == BuiltinType::Char16 ||
7834 BT->getKind() == BuiltinType::Char32) {
7835 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
7839 for (
const auto &PT : PromoteTypes) {
7841 if (FromSize < ToSize ||
7842 (FromSize == ToSize && FromIsSigned == PT->isSignedIntegerType()))
7845 llvm_unreachable(
"char type should fit into long long");
7852 uint64_t PromotableSize =
getIntWidth(Promotable);
7861 while (!
T.isNull()) {
7863 return T.getObjCLifetime();
7893 if (
const auto *ET = dyn_cast<EnumType>(LHSC))
7895 if (
const auto *ET = dyn_cast<EnumType>(RHSC))
7898 if (LHSC == RHSC)
return 0;
7903 unsigned LHSRank = getIntegerRank(LHSC);
7904 unsigned RHSRank = getIntegerRank(RHSC);
7906 if (LHSUnsigned == RHSUnsigned) {
7907 if (LHSRank == RHSRank)
return 0;
7908 return LHSRank > RHSRank ? 1 : -1;
7914 if (LHSRank >= RHSRank)
7924 if (RHSRank >= LHSRank)
7934 if (CFConstantStringTypeDecl)
7935 return CFConstantStringTypeDecl;
7937 assert(!CFConstantStringTagDecl &&
7938 "tag and typedef should be initialized together");
7978 if (
static_cast<unsigned>(CFRuntime) <
7981 Fields[Count++] = {
IntTy,
"flags" };
7983 Fields[Count++] = {
LongTy,
"length" };
7987 Fields[Count++] = { getFromTargetType(
Target->getUInt64Type()),
"_swift_rc" };
7991 Fields[Count++] = {
IntTy,
"_ptr" };
7997 for (
unsigned i = 0; i < Count; ++i) {
8001 Fields[i].Type,
nullptr,
8004 CFConstantStringTagDecl->
addDecl(Field);
8011 CFConstantStringTypeDecl =
8014 return CFConstantStringTypeDecl;
8018 if (!CFConstantStringTagDecl)
8020 return CFConstantStringTagDecl;
8029 if (ObjCSuperType.
isNull()) {
8034 return ObjCSuperType;
8039 CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
8046 if (BlockDescriptorType)
8059 static const char *
const FieldNames[] = {
8064 for (
size_t i = 0; i < 2; ++i) {
8067 &
Idents.
get(FieldNames[i]), FieldTypes[i],
nullptr,
8075 BlockDescriptorType = RD;
8081 if (BlockDescriptorExtendedType)
8096 static const char *
const FieldNames[] = {
8103 for (
size_t i = 0; i < 4; ++i) {
8106 &
Idents.
get(FieldNames[i]), FieldTypes[i],
nullptr,
8115 BlockDescriptorExtendedType = RD;
8120 const auto *BT = dyn_cast<BuiltinType>(
T);
8123 if (isa<PipeType>(
T))
8129 switch (BT->getKind()) {
8130#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8131 case BuiltinType::Id: \
8133#include "clang/Basic/OpenCLImageTypes.def"
8135 case BuiltinType::OCLClkEvent:
8138 case BuiltinType::OCLEvent:
8141 case BuiltinType::OCLQueue:
8144 case BuiltinType::OCLReserveID:
8147 case BuiltinType::OCLSampler:
8166 if (!copyExpr && record->hasTrivialDestructor())
return false;
8194 llvm_unreachable(
"impossible");
8196 llvm_unreachable(
"fell out of lifetime switch!");
8204 bool &HasByrefExtendedLayout)
const {
8209 HasByrefExtendedLayout =
false;
8211 HasByrefExtendedLayout =
true;
8225 assert(
Target &&
"Expected target to be initialized");
8226 const llvm::Triple &
T =
Target->getTriple();
8228 if (
T.isOSWindows() &&
T.isArch64Bit())
8234 assert(
Target &&
"Expected target to be initialized");
8235 const llvm::Triple &
T =
Target->getTriple();
8237 if (
T.isOSWindows() &&
T.isArch64Bit())
8243 if (!ObjCInstanceTypeDecl)
8244 ObjCInstanceTypeDecl =
8246 return ObjCInstanceTypeDecl;
8252 if (
const auto *TT = dyn_cast<TypedefType>(
T))
8254 return II->isStr(
"BOOL");
8262 if (!
type->isIncompleteArrayType() &&
type->isIncompleteType())
8271 else if (
type->isArrayType())
8290 if (
First->isInlineSpecified() || !
First->isStaticDataMember())
8297 !
D->isInlineSpecified() && (
D->isConstexpr() ||
First->isConstexpr()))
8328 for (
auto *PI :
Decl->parameters()) {
8333 assert(sz.
isPositive() &&
"BlockExpr - Incomplete param type");
8342 ParmOffset = PtrSize;
8343 for (
auto *PVDecl :
Decl->parameters()) {
8344 QualType PType = PVDecl->getOriginalType();
8345 if (
const auto *AT =
8349 if (!isa<ConstantArrayType>(AT))
8350 PType = PVDecl->getType();
8352 PType = PVDecl->getType();
8372 for (
auto *PI :
Decl->parameters()) {
8379 "getObjCEncodingForFunctionDecl - Incomplete param type");
8386 for (
auto *PVDecl :
Decl->parameters()) {
8387 QualType PType = PVDecl->getOriginalType();
8388 if (
const auto *AT =
8392 if (!isa<ConstantArrayType>(AT))
8393 PType = PVDecl->getType();
8395 PType = PVDecl->getType();
8409 bool Extended)
const {
8413 ObjCEncOptions Options = ObjCEncOptions()
8414 .setExpandPointedToStructures()
8415 .setExpandStructures()
8416 .setIsOutermostType();
8418 Options.setEncodeBlockParameters().setEncodeClassNames();
8419 getObjCEncodingForTypeImpl(
T, S, Options,
nullptr);
8425 bool Extended)
const {
8430 Decl->getReturnType(), S, Extended);
8439 E =
Decl->sel_param_end(); PI !=
E; ++PI) {
8446 "getObjCEncodingForMethodDecl - Incomplete param type");
8454 ParmOffset = 2 * PtrSize;
8456 E =
Decl->sel_param_end(); PI !=
E; ++PI) {
8459 if (
const auto *AT =
8463 if (!isa<ConstantArrayType>(AT))
8468 PType, S, Extended);
8479 const Decl *Container)
const {
8482 if (
const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
8483 for (
auto *PID : CID->property_impls())
8484 if (PID->getPropertyDecl() == PD)
8487 const auto *OID = cast<ObjCImplementationDecl>(Container);
8488 for (
auto *PID : OID->property_impls())
8489 if (PID->getPropertyDecl() == PD)
8523 const Decl *Container)
const {
8525 bool Dynamic =
false;
8533 SynthesizePID = PropertyImpDecl;
8537 std::string S =
"T";
8582 if (SynthesizePID) {
8599 if (BT->getKind() == BuiltinType::ULong &&
getIntWidth(PointeeTy) == 32)
8602 if (BT->getKind() == BuiltinType::Long &&
getIntWidth(PointeeTy) == 32)
8615 getObjCEncodingForTypeImpl(
T, S,
8617 .setExpandPointedToStructures()
8618 .setExpandStructures()
8619 .setIsOutermostType(),
8620 Field, NotEncodedT);
8624 std::string& S)
const {
8628 getObjCEncodingForTypeImpl(
T, S,
8630 .setExpandPointedToStructures()
8631 .setExpandStructures()
8632 .setIsOutermostType()
8633 .setEncodingProperty(),
8641 case BuiltinType::Void:
return 'v';
8642 case BuiltinType::Bool:
return 'B';
8643 case BuiltinType::Char8:
8644 case BuiltinType::Char_U:
8645 case BuiltinType::UChar:
return 'C';
8646 case BuiltinType::Char16:
8647 case BuiltinType::UShort:
return 'S';
8648 case BuiltinType::Char32:
8649 case BuiltinType::UInt:
return 'I';
8650 case BuiltinType::ULong:
8651 return C->getTargetInfo().getLongWidth() == 32 ?
'L' :
'Q';
8652 case BuiltinType::UInt128:
return 'T';
8653 case BuiltinType::ULongLong:
return 'Q';
8654 case BuiltinType::Char_S:
8655 case BuiltinType::SChar:
return 'c';
8656 case BuiltinType::Short:
return 's';
8657 case BuiltinType::WChar_S:
8658 case BuiltinType::WChar_U:
8659 case BuiltinType::Int:
return 'i';
8660 case BuiltinType::Long:
8661 return C->getTargetInfo().getLongWidth() == 32 ?
'l' :
'q';
8662 case BuiltinType::LongLong:
return 'q';
8663 case BuiltinType::Int128:
return 't';
8664 case BuiltinType::Float:
return 'f';
8665 case BuiltinType::Double:
return 'd';
8666 case BuiltinType::LongDouble:
return 'D';
8667 case BuiltinType::NullPtr:
return '*';
8669 case BuiltinType::BFloat16:
8670 case BuiltinType::Float16:
8671 case BuiltinType::Float128:
8672 case BuiltinType::Ibm128:
8673 case BuiltinType::Half:
8674 case BuiltinType::ShortAccum:
8675 case BuiltinType::Accum:
8676 case BuiltinType::LongAccum:
8677 case BuiltinType::UShortAccum:
8678 case BuiltinType::UAccum:
8679 case BuiltinType::ULongAccum:
8680 case BuiltinType::ShortFract:
8681 case BuiltinType::Fract:
8682 case BuiltinType::LongFract:
8683 case BuiltinType::UShortFract:
8684 case BuiltinType::UFract:
8685 case BuiltinType::ULongFract:
8686 case BuiltinType::SatShortAccum:
8687 case BuiltinType::SatAccum:
8688 case BuiltinType::SatLongAccum:
8689 case BuiltinType::SatUShortAccum:
8690 case BuiltinType::SatUAccum:
8691 case BuiltinType::SatULongAccum:
8692 case BuiltinType::SatShortFract:
8693 case BuiltinType::SatFract:
8694 case BuiltinType::SatLongFract:
8695 case BuiltinType::SatUShortFract:
8696 case BuiltinType::SatUFract:
8697 case BuiltinType::SatULongFract:
8701#define SVE_TYPE(Name, Id, SingletonId) \
8702 case BuiltinType::Id:
8703#include "clang/Basic/AArch64SVEACLETypes.def"
8704#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
8705#include "clang/Basic/RISCVVTypes.def"
8706#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
8707#include "clang/Basic/WebAssemblyReferenceTypes.def"
8708#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
8709#include "clang/Basic/AMDGPUTypes.def"
8713 "cannot yet @encode type %0");
8718 case BuiltinType::ObjCId:
8719 case BuiltinType::ObjCClass:
8720 case BuiltinType::ObjCSel:
8721 llvm_unreachable(
"@encoding ObjC primitive type");
8724#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8725 case BuiltinType::Id:
8726#include "clang/Basic/OpenCLImageTypes.def"
8727#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8728 case BuiltinType::Id:
8729#include "clang/Basic/OpenCLExtensionTypes.def"
8730 case BuiltinType::OCLEvent:
8731 case BuiltinType::OCLClkEvent:
8732 case BuiltinType::OCLQueue:
8733 case BuiltinType::OCLReserveID:
8734 case BuiltinType::OCLSampler:
8735 case BuiltinType::Dependent:
8736#define PPC_VECTOR_TYPE(Name, Id, Size) \
8737 case BuiltinType::Id:
8738#include "clang/Basic/PPCTypes.def"
8739#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
8740#include "clang/Basic/HLSLIntangibleTypes.def"
8741#define BUILTIN_TYPE(KIND, ID)
8742#define PLACEHOLDER_TYPE(KIND, ID) \
8743 case BuiltinType::KIND:
8744#include "clang/AST/BuiltinTypes.def"
8745 llvm_unreachable(
"invalid builtin type for @encode");
8747 llvm_unreachable(
"invalid BuiltinType::Kind value");
8754 if (!
Enum->isFixed())
8764 assert(FD->
isBitField() &&
"not a bitfield - getObjCEncodingForTypeImpl");
8784 if (
const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
8793 S += llvm::utostr(Offset);
8808 bool VisitBasesAndFields) {
8813 PT->getPointeeType().getTypePtr(),
false);
8820 if (isa<ClassTemplateSpecializationDecl>(CXXRD))
8823 if (!CXXRD->hasDefinition() || !VisitBasesAndFields)
8826 for (
const auto &B : CXXRD->bases())
8831 for (
auto *FD : CXXRD->fields())
8840void ASTContext::getObjCEncodingForTypeImpl(
QualType T, std::string &S,
8841 const ObjCEncOptions Options,
8845 switch (CT->getTypeClass()) {
8850 if (
const auto *BT = dyn_cast<BuiltinType>(CT))
8872 case Type::LValueReference:
8873 case Type::RValueReference: {
8875 if (isa<PointerType>(CT)) {
8877 if (PT->isObjCSelType()) {
8886 bool isReadOnly =
false;
8892 if (Options.IsOutermostType() &&
T.isConstQualified()) {
8896 }
else if (Options.IsOutermostType()) {
8899 P = PT->getPointeeType();
8900 if (
P.isConstQualified()) {
8909 if (StringRef(S).ends_with(
"nr"))
8910 S.replace(S.end()-2, S.end(),
"rn");
8922 if (RTy->getDecl()->getIdentifier() == &
Idents.
get(
"objc_class")) {
8927 if (RTy->getDecl()->getIdentifier() == &
Idents.
get(
"objc_object")) {
8936 RTy, Options.ExpandPointedToStructures()))) {
8945 ObjCEncOptions NewOptions;
8946 if (Options.ExpandPointedToStructures())
8947 NewOptions.setExpandStructures();
8948 getObjCEncodingForTypeImpl(PointeeTy, S, NewOptions,
8949 nullptr, NotEncodedT);
8953 case Type::ConstantArray:
8954 case Type::IncompleteArray:
8955 case Type::VariableArray: {
8956 const auto *AT = cast<ArrayType>(CT);
8958 if (isa<IncompleteArrayType>(AT) && !Options.IsStructField()) {
8962 getObjCEncodingForTypeImpl(
8963 AT->getElementType(), S,
8964 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD);
8968 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
8969 S += llvm::utostr(CAT->getZExtSize());
8972 assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&
8973 "Unknown array type!");
8977 getObjCEncodingForTypeImpl(
8978 AT->getElementType(), S,
8979 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD,
8986 case Type::FunctionNoProto:
8987 case Type::FunctionProto:
8991 case Type::Record: {
8992 RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
8993 S += RDecl->
isUnion() ?
'(' :
'{';
8997 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
8999 llvm::raw_string_ostream OS(S);
9006 if (Options.ExpandStructures()) {
9009 getObjCEncodingForStructureImpl(RDecl, S, FD,
true, NotEncodedT);
9011 for (
const auto *Field : RDecl->
fields()) {
9014 S +=
Field->getNameAsString();
9019 if (
Field->isBitField()) {
9020 getObjCEncodingForTypeImpl(
Field->getType(), S,
9021 ObjCEncOptions().setExpandStructures(),
9026 getObjCEncodingForTypeImpl(
9028 ObjCEncOptions().setExpandStructures().setIsStructField(), FD,
9034 S += RDecl->
isUnion() ?
')' :
'}';
9038 case Type::BlockPointer: {
9041 if (Options.EncodeBlockParameters()) {
9042 const auto *FT = BT->getPointeeType()->castAs<
FunctionType>();
9046 getObjCEncodingForTypeImpl(FT->getReturnType(), S,
9047 Options.forComponentType(), FD, NotEncodedT);
9051 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
9052 for (
const auto &I : FPT->param_types())
9053 getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,
9061 case Type::ObjCObject: {
9065 S +=
"{objc_object=}";
9069 S +=
"{objc_class=}";
9076 case Type::ObjCInterface: {
9082 if (Options.ExpandStructures()) {
9086 for (
unsigned i = 0, e = Ivars.size(); i != e; ++i) {
9088 if (
Field->isBitField())
9089 getObjCEncodingForTypeImpl(
Field->getType(), S,
9090 ObjCEncOptions().setExpandStructures(),
9093 getObjCEncodingForTypeImpl(
Field->getType(), S,
9094 ObjCEncOptions().setExpandStructures(), FD,
9102 case Type::ObjCObjectPointer: {
9104 if (OPT->isObjCIdType()) {
9109 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
9117 if (OPT->isObjCQualifiedIdType()) {
9118 getObjCEncodingForTypeImpl(
9120 Options.keepingOnly(ObjCEncOptions()
9121 .setExpandPointedToStructures()
9122 .setExpandStructures()),
9124 if (FD || Options.EncodingProperty() || Options.EncodeClassNames()) {
9128 for (
const auto *I : OPT->quals()) {
9130 S += I->getObjCRuntimeNameAsString();
9139 if (OPT->getInterfaceDecl() &&
9140 (FD || Options.EncodingProperty() || Options.EncodeClassNames())) {
9142 S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
9143 for (
const auto *I : OPT->quals()) {
9145 S += I->getObjCRuntimeNameAsString();
9155 case Type::MemberPointer:
9159 case Type::ExtVector:
9165 case Type::ConstantMatrix:
9178 case Type::DeducedTemplateSpecialization:
9181 case Type::HLSLAttributedResource:
9182 llvm_unreachable(
"unexpected type");
9184 case Type::ArrayParameter:
9186#define ABSTRACT_TYPE(KIND, BASE)
9187#define TYPE(KIND, BASE)
9188#define DEPENDENT_TYPE(KIND, BASE) \
9190#define NON_CANONICAL_TYPE(KIND, BASE) \
9192#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
9194#include "clang/AST/TypeNodes.inc"
9195 llvm_unreachable(
"@encode for dependent type!");
9197 llvm_unreachable(
"bad type kind!");
9200void ASTContext::getObjCEncodingForStructureImpl(
RecordDecl *RDecl,
9205 assert(RDecl &&
"Expected non-null RecordDecl");
9206 assert(!RDecl->
isUnion() &&
"Should not be called for unions");
9210 const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
9211 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
9215 for (
const auto &BI : CXXRec->bases()) {
9216 if (!BI.isVirtual()) {
9221 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9222 std::make_pair(offs, base));
9228 if (!
Field->isZeroLengthBitField() &&
Field->isZeroSize(*
this))
9231 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9232 std::make_pair(offs, Field));
9235 if (CXXRec && includeVBases) {
9236 for (
const auto &BI : CXXRec->vbases()) {
9242 FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
9243 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
9244 std::make_pair(offs, base));
9258 std::multimap<uint64_t, NamedDecl *>::iterator
9259 CurLayObj = FieldOrBaseOffsets.begin();
9261 if (CXXRec && CXXRec->isDynamicClass() &&
9262 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
9265 std::string recname = CXXRec->getNameAsString();
9266 if (recname.empty()) recname =
"?";
9279 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9280 std::make_pair(offs,
nullptr));
9283 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
9285 assert(CurOffs <= CurLayObj->first);
9286 if (CurOffs < CurLayObj->first) {
9287 uint64_t padding = CurLayObj->first - CurOffs;
9303 if (
auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
9308 getObjCEncodingForStructureImpl(base, S, FD,
false,
9315 const auto *field = cast<FieldDecl>(dcl);
9318 S += field->getNameAsString();
9322 if (field->isBitField()) {
9325 CurOffs += field->getBitWidthValue();
9330 getObjCEncodingForTypeImpl(
9331 qt, S, ObjCEncOptions().setExpandStructures().setIsStructField(),
9342 std::string& S)
const {
9375 if (!ObjCClassDecl) {
9380 return ObjCClassDecl;
9384 if (!ObjCProtocolClassDecl) {
9385 ObjCProtocolClassDecl
9394 return ObjCProtocolClassDecl;
9439 const size_t NumFields = 5;
9441 const char *FieldNames[NumFields];
9445 FieldNames[0] =
"__stack";
9449 FieldNames[1] =
"__gr_top";
9453 FieldNames[2] =
"__vr_top";
9456 FieldTypes[3] = Context->
IntTy;
9457 FieldNames[3] =
"__gr_offs";
9460 FieldTypes[4] = Context->
IntTy;
9461 FieldNames[4] =
"__vr_offs";
9464 for (
unsigned i = 0; i < NumFields; ++i) {
9470 FieldTypes[i],
nullptr,
9475 VaListTagDecl->
addDecl(Field);
9492 const size_t NumFields = 5;
9494 const char *FieldNames[NumFields];
9498 FieldNames[0] =
"gpr";
9502 FieldNames[1] =
"fpr";
9506 FieldNames[2] =
"reserved";
9510 FieldNames[3] =
"overflow_arg_area";
9514 FieldNames[4] =
"reg_save_area";
9517 for (
unsigned i = 0; i < NumFields; ++i) {
9522 FieldTypes[i],
nullptr,
9527 VaListTagDecl->
addDecl(Field);
9554 const size_t NumFields = 4;
9556 const char *FieldNames[NumFields];
9560 FieldNames[0] =
"gp_offset";
9564 FieldNames[1] =
"fp_offset";
9568 FieldNames[2] =
"overflow_arg_area";
9572 FieldNames[3] =
"reg_save_area";
9575 for (
unsigned i = 0; i < NumFields; ++i) {
9581 FieldTypes[i],
nullptr,
9586 VaListTagDecl->
addDecl(Field);
9657 const size_t NumFields = 4;
9659 const char *FieldNames[NumFields];
9662 FieldTypes[0] = Context->
LongTy;
9663 FieldNames[0] =
"__gpr";
9666 FieldTypes[1] = Context->
LongTy;
9667 FieldNames[1] =
"__fpr";
9671 FieldNames[2] =
"__overflow_arg_area";
9675 FieldNames[3] =
"__reg_save_area";
9678 for (
unsigned i = 0; i < NumFields; ++i) {
9684 FieldTypes[i],
nullptr,
9689 VaListTagDecl->
addDecl(Field);
9711 const size_t NumFields = 3;
9713 const char *FieldNames[NumFields];
9717 FieldNames[0] =
"__current_saved_reg_area_pointer";
9721 FieldNames[1] =
"__saved_reg_area_end_pointer";
9725 FieldNames[2] =
"__overflow_area_pointer";
9728 for (
unsigned i = 0; i < NumFields; ++i) {
9736 VaListTagDecl->
addDecl(Field);
9766 constexpr size_t NumFields = 3;
9770 const char *FieldNames[NumFields] = {
"__va_stk",
"__va_reg",
"__va_ndx"};
9773 for (
unsigned i = 0; i < NumFields; ++i) {
9776 &Context->
Idents.
get(FieldNames[i]), FieldTypes[i],
nullptr,
9780 VaListTagDecl->
addDecl(Field);
9790 return VaListTagTypedefDecl;
9818 llvm_unreachable(
"Unhandled __builtin_va_list type kind");
9822 if (!BuiltinVaListDecl) {
9827 return BuiltinVaListDecl;
9840 if (!BuiltinMSVaListDecl)
9843 return BuiltinMSVaListDecl;
9855 assert(ObjCConstantStringType.
isNull() &&
9856 "'NSConstantString' type already set!");
9866 unsigned size = End -
Begin;
9867 assert(size > 1 &&
"set is not overloaded!");
9876 assert(isa<FunctionTemplateDecl>(
D) ||
9877 isa<UnresolvedUsingValueDecl>(
D) ||
9878 (isa<UsingShadowDecl>(
D) &&
9879 isa<FunctionTemplateDecl>(
D->getUnderlyingDecl())));
9896 bool TemplateKeyword,
9902 llvm::FoldingSetNodeID ID;
9905 void *InsertPos =
nullptr;
9907 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
9911 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
9923 "Nested name specifier must be dependent");
9925 llvm::FoldingSetNodeID ID;
9928 void *InsertPos =
nullptr;
9930 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
9936 if (CanonNNS == NNS) {
9944 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
9945 assert(!CheckQTN &&
"Dependent type name canonicalization broken");
9949 DependentTemplateNames.InsertNode(QTN, InsertPos);
9959 "Nested name specifier must be dependent");
9961 llvm::FoldingSetNodeID ID;
9964 void *InsertPos =
nullptr;
9966 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
9972 if (CanonNNS == NNS) {
9981 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
9982 assert(!CheckQTN &&
"Dependent template name canonicalization broken");
9986 DependentTemplateNames.InsertNode(QTN, InsertPos);
9992 std::optional<unsigned> PackIndex)
const {
9993 llvm::FoldingSetNodeID ID;
9997 void *insertPos =
nullptr;
9999 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
10003 Replacement, AssociatedDecl, Index, PackIndex);
10004 SubstTemplateTemplateParms.InsertNode(subst, insertPos);
10012 Decl *AssociatedDecl,
10013 unsigned Index,
bool Final)
const {
10015 llvm::FoldingSetNodeID ID;
10017 AssociatedDecl, Index, Final);
10019 void *InsertPos =
nullptr;
10021 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
10026 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
10040 llvm::FoldingSetNodeID ID;
10043 void *InsertPos =
nullptr;
10045 DeducedTemplates.FindNodeOrInsertPos(ID, InsertPos);
10051 DeducedTemplates.InsertNode(DTS, InsertPos);
10074 llvm_unreachable(
"Unhandled TargetInfo::IntType value");
10104 while (
const auto *AT = dyn_cast<ArrayType>(CT))
10105 CT = AT->getElementType();
10137 assert(FirstVec->
isVectorType() &&
"FirstVec should be a vector type");
10138 assert(SecondVec->
isVectorType() &&
"SecondVec should be a vector type");
10175 if (Ty->
getKind() == BuiltinType::SveBool ||
10176 Ty->
getKind() == BuiltinType::SveCount)
10189 return BT->getKind() == BuiltinType::SveBool;
10191 return VT->getElementType().getCanonicalType() ==
10202 return IsValidCast(FirstType, SecondType) ||
10203 IsValidCast(SecondType, FirstType);
10221 if (BT->getKind() == BuiltinType::SveBool &&
10242 return VecTy->getElementType().getCanonicalType()->isIntegerType() &&
10249 return IsLaxCompatible(FirstType, SecondType) ||
10250 IsLaxCompatible(SecondType, FirstType);
10266 uint64_t MinElts = Info.
EC.getKnownMinValue();
10267 return VScale->first * MinElts * EltSize;
10275 "Expected RVV builtin type and vector type!");
10315 return IsValidCast(FirstType, SecondType) ||
10316 IsValidCast(SecondType, FirstType);
10324 "Expected RVV builtin type and vector type!");
10331 if (!BT->isRVVVLSBuiltinType())
10351 return VecTy->getElementType().getCanonicalType()->isIntegerType() &&
10358 return IsLaxCompatible(FirstType, SecondType) ||
10359 IsLaxCompatible(SecondType, FirstType);
10366 if (
Attr->getAttrKind() == attr::ObjCOwnership)
10369 Ty =
Attr->getModifiedType();
10373 Ty =
Paren->getInnerType();
10405 for (
auto *lhsProto : lhs->
quals()) {
10406 bool match =
false;
10407 for (
auto *rhsProto : rhs->
quals()) {
10438 for (
auto *I : lhs->
quals()) {
10442 if (!rhsID->ClassImplementsProtocol(I,
true))
10450 for (
auto *lhsProto : lhs->
quals()) {
10451 bool match =
false;
10456 for (
auto *rhsProto : rhs->
quals()) {
10466 for (
auto *I : lhs->
quals()) {
10470 if (rhsID->ClassImplementsProtocol(I,
true)) {
10487 for (
auto *lhsProto : lhs->
quals()) {
10488 bool match =
false;
10495 for (
auto *rhsProto : rhs->
quals()) {
10514 if (LHSInheritedProtocols.empty() && lhs->
qual_empty())
10516 for (
auto *lhsProto : LHSInheritedProtocols) {
10517 bool match =
false;
10518 for (
auto *rhsProto : rhs->
quals()) {
10548 auto finish = [&](
bool succeeded) ->
bool {
10593 bool BlockReturnType) {
10597 auto finish = [&](
bool succeeded) ->
bool {
10622 if (
getLangOpts().CompatibilityQualifiedIdBlockParamTypeChecking)
10626 (!BlockReturnType &&
10630 (BlockReturnType ? LHSOPT : RHSOPT),
10631 (BlockReturnType ? RHSOPT : LHSOPT),
false));
10639 return finish(BlockReturnType);
10641 return finish(!BlockReturnType);
10653 return (*lhs)->getName().compare((*rhs)->getName());
10670 assert(LHS->
getInterface() &&
"LHS must have an interface base");
10671 assert(RHS->
getInterface() &&
"RHS must have an interface base");
10677 for (
auto *proto : LHS->
quals()) {
10688 for (
auto *proto : RHS->
quals()) {
10696 for (
auto *proto : LHSProtocolSet) {
10697 if (RHSProtocolSet.count(proto))
10698 IntersectionSet.push_back(proto);
10707 if (!ImpliedProtocols.empty()) {
10709 return ImpliedProtocols.contains(proto);
10714 llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
10724 if (lhsOPT && rhsOPT)
10730 if (lhsBlock && rhsBlock)
10735 if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
10747 bool stripKindOf) {
10748 if (lhsArgs.size() != rhsArgs.size())
10755 for (
unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
10761 if (!stripKindOf ||
10762 !ctx.
hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
10763 rhsArgs[i].stripObjCKindOfType(ctx))) {
10791 if (!LDecl || !RDecl)
10801 llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
10811 bool anyChanges =
false;
10829 if (!Protocols.empty())
10847 if (LHSSuperType.
isNull())
10857 if (KnownLHS != LHSAncestors.end()) {
10858 LHS = KnownLHS->second;
10862 bool anyChanges =
false;
10880 if (!Protocols.empty())
10897 if (RHSSuperType.
isNull())
10908 assert(LHS->
getInterface() &&
"LHS is not an interface type");
10909 assert(RHS->
getInterface() &&
"RHS is not an interface type");
10930 for (
auto *RHSPI : RHS->
quals())
10933 if (SuperClassInheritedProtocols.empty())
10936 for (
const auto *LHSProto : LHS->
quals()) {
10937 bool SuperImplementsProtocol =
false;
10938 for (
auto *SuperClassProto : SuperClassInheritedProtocols)
10939 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
10940 SuperImplementsProtocol =
true;
10943 if (!SuperImplementsProtocol)
10973 if (!LHSOPT || !RHSOPT)
10991 bool CompareUnqualified) {
11010 bool OfBlockPointer,
11014 if (UD->
hasAttr<TransparentUnionAttr>()) {
11015 for (
const auto *I : UD->
fields()) {
11016 QualType ET = I->getType().getUnqualifiedType();
11030 bool OfBlockPointer,
11051 bool IsConditionalOperator) {
11054 const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
11055 const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
11056 bool allLTypes =
true;
11057 bool allRTypes =
true;
11061 if (OfBlockPointer) {
11063 QualType LHS = lbase->getReturnType();
11065 if (!UnqualifiedResult)
11067 retType =
mergeTypes(LHS, RHS,
true, UnqualifiedResult,
true);
11132 bool NoReturn = IsConditionalOperator
11142 std::optional<FunctionEffectSet> MergedFX;
11144 if (lproto && rproto) {
11145 assert((AllowCXX ||
11146 (!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec())) &&
11147 "C++ shouldn't be here");
11149 if (lproto->getNumParams() != rproto->getNumParams())
11153 if (lproto->isVariadic() != rproto->isVariadic())
11156 if (lproto->getMethodQuals() != rproto->getMethodQuals())
11162 if (LHSFX != RHSFX) {
11163 if (IsConditionalOperator)
11172 if (*MergedFX != LHSFX)
11174 if (*MergedFX != RHSFX)
11179 bool canUseLeft, canUseRight;
11191 for (
unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
11192 QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
11193 QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
11195 lParamType, rParamType, OfBlockPointer,
Unqualified);
11202 types.push_back(paramType);
11214 if (allLTypes)
return lhs;
11215 if (allRTypes)
return rhs;
11220 newParamInfos.empty() ? nullptr : newParamInfos.data();
11226 if (lproto) allRTypes =
false;
11227 if (rproto) allLTypes =
false;
11231 assert((AllowCXX || !proto->
hasExceptionSpec()) &&
"C++ shouldn't be here");
11239 for (
unsigned i = 0, n = proto->
getNumParams(); i < n; ++i) {
11245 paramTy =
Enum->getDecl()->getIntegerType();
11255 if (allLTypes)
return lhs;
11256 if (allRTypes)
return rhs;
11265 if (allLTypes)
return lhs;
11266 if (allRTypes)
return rhs;
11272 QualType other,
bool isBlockReturnType) {
11278 if (underlyingType.
isNull())
11294 bool IsConditionalOperator) {
11305 if (LangOpts.OpenMP && LHSRefTy && RHSRefTy &&
11309 if (LHSRefTy || RHSRefTy)
11321 if (LHSCan == RHSCan)
11326 Qualifiers RQuals = RHSCan.getLocalQualifiers();
11327 if (LQuals != RQuals) {
11343 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
11364 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
11365 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
11368 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
11369 LHSClass = Type::ConstantArray;
11370 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
11371 RHSClass = Type::ConstantArray;
11374 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
11375 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
11378 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
11379 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
11382 if (LHSClass != RHSClass) {
11392 if (OfBlockPointer && !BlockReturnType) {
11401 if (!AT->isDeduced() && AT->isGNUAutoType())
11405 if (!AT->isDeduced() && AT->isGNUAutoType())
11412 switch (LHSClass) {
11413#define TYPE(Class, Base)
11414#define ABSTRACT_TYPE(Class, Base)
11415#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
11416#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
11417#define DEPENDENT_TYPE(Class, Base) case Type::Class:
11418#include "clang/AST/TypeNodes.inc"
11419 llvm_unreachable(
"Non-canonical and dependent types shouldn't get here");
11422 case Type::DeducedTemplateSpecialization:
11423 case Type::LValueReference:
11424 case Type::RValueReference:
11425 case Type::MemberPointer:
11426 llvm_unreachable(
"C++ should never be in mergeTypes");
11428 case Type::ObjCInterface:
11429 case Type::IncompleteArray:
11430 case Type::VariableArray:
11431 case Type::FunctionProto:
11432 case Type::ExtVector:
11433 llvm_unreachable(
"Types are eliminated above");
11435 case Type::Pointer:
11446 if (ResultType.
isNull())
11454 case Type::BlockPointer:
11479 if (ResultType.
isNull())
11498 if (ResultType.
isNull())
11506 case Type::ConstantArray:
11521 if (ResultType.
isNull())
11529 if (LVAT || RVAT) {
11532 -> std::pair<bool,llvm::APInt> {
11534 std::optional<llvm::APSInt> TheInt;
11537 return std::make_pair(
true, *TheInt);
11538 return std::make_pair(
false, llvm::APSInt());
11541 return std::make_pair(
true, CAT->getSize());
11542 return std::make_pair(
false, llvm::APInt());
11545 bool HaveLSize, HaveRSize;
11546 llvm::APInt LSize, RSize;
11547 std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
11548 std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
11549 if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
11583 case Type::FunctionNoProto:
11585 false, IsConditionalOperator);
11589 case Type::Builtin:
11592 case Type::Complex:
11601 case Type::ConstantMatrix:
11606 case Type::ObjCObject: {
11615 case Type::ObjCObjectPointer:
11616 if (OfBlockPointer) {
11628 assert(LHS != RHS &&
11629 "Equivalent pipe types should have already been handled!");
11631 case Type::ArrayParameter:
11632 assert(LHS != RHS &&
11633 "Equivalent ArrayParameter types should have already been handled!");
11635 case Type::BitInt: {
11643 if (LHSUnsigned != RHSUnsigned)
11646 if (LHSBits != RHSBits)
11650 case Type::HLSLAttributedResource: {
11657 "HLSLAttributedResourceType should always wrap __hlsl_resource_t");
11659 if (LHSTy->
getAttrs() == RHSTy->getAttrs() &&
11666 llvm_unreachable(
"Invalid Type::Class!");
11671 bool &CanUseFirst,
bool &CanUseSecond,
11673 assert(NewParamInfos.empty() &&
"param info list not empty");
11674 CanUseFirst = CanUseSecond =
true;
11680 if (!FirstHasInfo && !SecondHasInfo)
11683 bool NeedParamInfo =
false;
11687 for (
size_t I = 0; I <
E; ++I) {
11698 bool FirstNoEscape = FirstParam.
isNoEscape();
11699 bool SecondNoEscape = SecondParam.
isNoEscape();
11700 bool IsNoEscape = FirstNoEscape && SecondNoEscape;
11702 if (NewParamInfos.back().getOpaqueValue())
11703 NeedParamInfo =
true;
11704 if (FirstNoEscape != IsNoEscape)
11705 CanUseFirst =
false;
11706 if (SecondNoEscape != IsNoEscape)
11707 CanUseSecond =
false;
11710 if (!NeedParamInfo)
11711 NewParamInfos.clear();
11717 ObjCLayouts[CD] =
nullptr;
11727 if (LHSCan == RHSCan)
11729 if (RHSCan->isFunctionType()) {
11733 cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();
11735 cast<FunctionType>(LHSCan.
getTypePtr())->getReturnType();
11738 if (ResReturnType.
isNull())
11740 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
11744 if (
const auto *FPT = cast<FunctionProtoType>(F)) {
11757 Qualifiers RQuals = RHSCan.getLocalQualifiers();
11758 if (LQuals != RQuals) {
11771 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
11787 if (ResQT == LHSBaseQT)
11789 if (ResQT == RHSBaseQT)
11801 T = ET->getDecl()->getIntegerType();
11805 return EIT->getNumBits();
11813 "Unexpected type");
11818 VTy->getNumElements(), VTy->getVectorKind());
11827 T = ETy->getDecl()->getIntegerType();
11830 case BuiltinType::Char_U:
11832 case BuiltinType::Char_S:
11833 case BuiltinType::SChar:
11834 case BuiltinType::Char8:
11836 case BuiltinType::Short:
11838 case BuiltinType::Int:
11840 case BuiltinType::Long:
11842 case BuiltinType::LongLong:
11844 case BuiltinType::Int128:
11849 case BuiltinType::WChar_S:
11852 case BuiltinType::ShortAccum:
11854 case BuiltinType::Accum:
11856 case BuiltinType::LongAccum:
11858 case BuiltinType::SatShortAccum:
11860 case BuiltinType::SatAccum:
11862 case BuiltinType::SatLongAccum:
11864 case BuiltinType::ShortFract:
11866 case BuiltinType::Fract:
11868 case BuiltinType::LongFract:
11870 case BuiltinType::SatShortFract:
11872 case BuiltinType::SatFract:
11874 case BuiltinType::SatLongFract:
11879 "Unexpected signed integer or fixed point type");
11887 "Unexpected type");
11892 VTy->getNumElements(), VTy->getVectorKind());
11901 T = ETy->getDecl()->getIntegerType();
11904 case BuiltinType::Char_S:
11906 case BuiltinType::Char_U:
11907 case BuiltinType::UChar:
11908 case BuiltinType::Char8:
11910 case BuiltinType::UShort:
11912 case BuiltinType::UInt:
11914 case BuiltinType::ULong:
11916 case BuiltinType::ULongLong:
11918 case BuiltinType::UInt128:
11923 case BuiltinType::WChar_U:
11926 case BuiltinType::UShortAccum:
11928 case BuiltinType::UAccum:
11930 case BuiltinType::ULongAccum:
11932 case BuiltinType::SatUShortAccum:
11934 case BuiltinType::SatUAccum:
11936 case BuiltinType::SatULongAccum:
11938 case BuiltinType::UShortFract:
11940 case BuiltinType::UFract:
11942 case BuiltinType::ULongFract:
11944 case BuiltinType::SatUShortFract:
11946 case BuiltinType::SatUFract:
11948 case BuiltinType::SatULongFract:
11953 "Unexpected signed integer or fixed point type");
11978 bool AllowTypeModifiers) {
11982 RequiresICE =
false;
11987 bool IsSpecial =
false;
11991 default: Done =
true; --Str;
break;
11993 RequiresICE =
true;
11996 assert(!
Unsigned &&
"Can't use both 'S' and 'U' modifiers!");
11997 assert(!
Signed &&
"Can't use 'S' modifier multiple times!");
12001 assert(!
Signed &&
"Can't use both 'S' and 'U' modifiers!");
12002 assert(!
Unsigned &&
"Can't use 'U' modifier multiple times!");
12006 assert(!IsSpecial &&
"Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers");
12007 assert(HowLong <= 2 &&
"Can't have LLLL modifier");
12012 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12013 assert(HowLong == 0 &&
"Can't use both 'L' and 'N' modifiers!");
12022 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12023 assert(HowLong == 0 &&
"Can't use both 'L' and 'W' modifiers!");
12029 llvm_unreachable(
"Unexpected integer type");
12040 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12041 assert(HowLong == 0 &&
"Can't use both 'L' and 'Z' modifiers!");
12047 llvm_unreachable(
"Unexpected integer type");
12060 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12061 assert(HowLong == 0 &&
"Can't use both 'L' and 'O' modifiers!");
12077 default: llvm_unreachable(
"Unknown builtin type letter!");
12080 "Bad modifiers used with 'x'!");
12085 "Bad modifiers used with 'y'!");
12090 "Bad modifiers used with 'v'!");
12095 "Bad modifiers used with 'h'!");
12100 "Bad modifiers used with 'f'!");
12105 "Bad modifiers used with 'd'!");
12108 else if (HowLong == 2)
12114 assert(HowLong == 0 &&
"Bad modifiers used with 's'!");
12123 else if (HowLong == 2)
12125 else if (HowLong == 1)
12131 assert(HowLong == 0 &&
"Bad modifiers used with 'c'!");
12140 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'b'!");
12144 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'z'!");
12148 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'w'!");
12165 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12177 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12185 unsigned NumElements = strtoul(Str, &End, 10);
12186 assert(End != Str &&
"Missing vector size");
12190 RequiresICE,
false);
12191 assert(!RequiresICE &&
"Can't require vector ICE");
12199 Type = Context.SveCountTy;
12203 Type = Context.AMDGPUBufferRsrcTy;
12207 llvm_unreachable(
"Unexpected target builtin type");
12213 unsigned NumElements = strtoul(Str, &End, 10);
12214 assert(End != Str &&
"Missing vector size");
12218 RequiresICE,
false);
12219 assert(!RequiresICE &&
"Can't require vector ICE");
12228 unsigned NumElements = strtoul(Str, &End, 10);
12229 assert(End != Str &&
"Missing vector size");
12241 assert(!RequiresICE &&
"Can't require complex ICE");
12250 if (
Type.isNull()) {
12261 if (
Type.isNull()) {
12267 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'K'!");
12270 if (
Type.isNull()) {
12281 Done = !AllowTypeModifiers;
12283 switch (
char c = *Str++) {
12284 default: Done =
true; --Str;
break;
12290 unsigned AddrSpace = strtoul(Str, &End, 10);
12318 "Integer constant 'I' type must be an integer");
12331 bool AllowTypeModifiers)
const {
12338 unsigned *IntegerConstantArgs)
const {
12340 if (TypeStr[0] ==
'\0') {
12347 bool RequiresICE =
false;
12350 RequiresICE,
true);
12354 assert(!RequiresICE &&
"Result of intrinsic cannot be required to be an ICE");
12356 while (TypeStr[0] && TypeStr[0] !=
'.') {
12363 if (RequiresICE && IntegerConstantArgs)
12364 *IntegerConstantArgs |= 1 << ArgTypes.size();
12370 ArgTypes.push_back(Ty);
12373 if (
Id == Builtin::BI__GetExceptionInfo)
12376 assert((TypeStr[0] !=
'.' || TypeStr[1] == 0) &&
12377 "'.' should only occur at end of builtin type list!");
12379 bool Variadic = (TypeStr[0] ==
'.');
12382 Variadic,
false,
true));
12387 if (ArgTypes.empty() && Variadic && !
getLangOpts().requiresStrictPrototypes())
12439 !FD->
hasAttr<DLLExportAttr>()) ||
12440 FD->
hasAttr<GNUInlineAttr>()) {
12459 isa<CXXConstructorDecl>(FD) &&
12460 cast<CXXConstructorDecl>(FD)->isInheritingConstructor())
12473 if (
D->
hasAttr<DLLImportAttr>()) {
12476 }
else if (
D->
hasAttr<DLLExportAttr>()) {
12482 if (
D->
hasAttr<CUDAGlobalAttr>() &&
12545 while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
12550 if (!LexicalContext)
12555 auto StaticLocalLinkage =
12567 return StaticLocalLinkage;
12594 return StrongLinkage;
12612 llvm_unreachable(
"Invalid Linkage!");
12622 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
12623 if (!VD->isFileVarDecl())
12628 if (VD->getDescribedVarTemplate() ||
12629 isa<VarTemplatePartialSpecializationDecl>(VD))
12631 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
12635 }
else if (isa<PragmaCommentDecl>(
D))
12637 else if (isa<PragmaDetectMismatchDecl>(
D))
12639 else if (isa<OMPRequiresDecl>(
D))
12641 else if (isa<OMPThreadPrivateDecl>(
D))
12643 else if (isa<OMPAllocateDecl>(
D))
12645 else if (isa<OMPDeclareReductionDecl>(
D) || isa<OMPDeclareMapperDecl>(
D))
12647 else if (isa<ImportDecl>(
D))
12664 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
12666 if (!FD->doesThisDeclarationHaveABody())
12667 return FD->doesDeclarationForceExternallyVisibleDefinition();
12670 if (FD->
hasAttr<ConstructorAttr>() || FD->
hasAttr<DestructorAttr>())
12675 if (
getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
12676 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
12694 const auto *VD = cast<VarDecl>(
D);
12695 assert(VD->isFileVarDecl() &&
"Expected file scoped var");
12699 if (LangOpts.OpenMP &&
12700 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
12707 if (VD->shouldEmitInExternalSource())
12720 if (VD->needsDestruction(*
this))
12724 if (VD->getInit() && VD->getInit()->HasSideEffects(*
this) &&
12726 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
12731 if (
const auto *DD = dyn_cast<DecompositionDecl>(VD))
12732 for (
const auto *BD : DD->bindings())
12733 if (
const auto *BindingVD = BD->getHoldingVar())
12742 llvm::function_ref<
void(
FunctionDecl *)> Pred)
const {
12743 assert(FD->
isMultiVersion() &&
"Only valid for multiversioned functions");
12744 llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
12749 for (
auto *CurDecl :
12753 SeenDecls.insert(CurFD).second) {
12761 bool IsBuiltin)
const {
12764 return ABI->getDefaultMethodCallConv(IsVariadic);
12769 switch (LangOpts.getDefaultCallingConv()) {
12798 return Target->getDefaultCallingConv();
12803 return ABI->isNearlyEmpty(RD);
12807 if (!VTContext.get()) {
12808 auto ABI =
Target->getCXXABI();
12809 if (ABI.isMicrosoft())
12812 auto ComponentLayout =
getLangOpts().RelativeCXXABIVTables
12818 return VTContext.get();
12824 switch (
T->getCXXABI().getKind()) {
12825 case TargetCXXABI::AppleARM64:
12826 case TargetCXXABI::Fuchsia:
12827 case TargetCXXABI::GenericAArch64:
12828 case TargetCXXABI::GenericItanium:
12829 case TargetCXXABI::GenericARM:
12830 case TargetCXXABI::GenericMIPS:
12831 case TargetCXXABI::iOS:
12832 case TargetCXXABI::WebAssembly:
12833 case TargetCXXABI::WatchOS:
12834 case TargetCXXABI::XL:
12836 case TargetCXXABI::Microsoft:
12839 llvm_unreachable(
"Unsupported ABI");
12843 assert(
T.getCXXABI().getKind() != TargetCXXABI::Microsoft &&
12844 "Device mangle context does not support Microsoft mangling.");
12845 switch (
T.getCXXABI().getKind()) {
12846 case TargetCXXABI::AppleARM64:
12847 case TargetCXXABI::Fuchsia:
12848 case TargetCXXABI::GenericAArch64:
12849 case TargetCXXABI::GenericItanium:
12850 case TargetCXXABI::GenericARM:
12851 case TargetCXXABI::GenericMIPS:
12852 case TargetCXXABI::iOS:
12853 case TargetCXXABI::WebAssembly:
12854 case TargetCXXABI::WatchOS:
12855 case TargetCXXABI::XL:
12859 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
12860 return RD->getDeviceLambdaManglingNumber();
12861 return std::nullopt;
12864 case TargetCXXABI::Microsoft:
12868 llvm_unreachable(
"Unsupported ABI");
12874 return ASTRecordLayouts.getMemorySize() +
12875 llvm::capacity_in_bytes(ObjCLayouts) +
12876 llvm::capacity_in_bytes(KeyFunctions) +
12877 llvm::capacity_in_bytes(ObjCImpls) +
12878 llvm::capacity_in_bytes(BlockVarCopyInits) +
12879 llvm::capacity_in_bytes(DeclAttrs) +
12880 llvm::capacity_in_bytes(TemplateOrInstantiation) +
12881 llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
12882 llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
12883 llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
12884 llvm::capacity_in_bytes(OverriddenMethods) +
12885 llvm::capacity_in_bytes(Types) +
12886 llvm::capacity_in_bytes(VariableArrayTypes);
12894 unsigned Signed)
const {
12897 if (!QualTy && DestWidth == 128)
12926 llvm_unreachable(
"Unhandled TargetInfo::RealType value");
12933 MangleNumbers[ND] = Number;
12940 bool ForAuxTarget)
const {
12941 auto I = MangleNumbers.find(ND);
12942 unsigned Res = I != MangleNumbers.end() ? I->second : 1;
12945 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice) {
12946 Res = ForAuxTarget ? Res >> 16 : Res & 0xFFFF;
12948 assert(!ForAuxTarget &&
"Only CUDA/HIP host compilation supports mangling "
12949 "number for aux target");
12951 return Res > 1 ? Res : 1;
12958 StaticLocalNumbers[VD] = Number;
12965 auto I = StaticLocalNumbers.find(VD);
12966 return I != StaticLocalNumbers.end() ? I->second : 1;
12971 assert(LangOpts.CPlusPlus);
12972 std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
12980 assert(LangOpts.CPlusPlus);
12981 std::unique_ptr<MangleNumberingContext> &MCtx =
12982 ExtraMangleNumberingContexts[
D];
12988std::unique_ptr<MangleNumberingContext>
12990 return ABI->createMangleNumberingContext();
12995 return ABI->getCopyConstructorForExceptionObject(
13001 return ABI->addCopyConstructorForExceptionObject(
13008 return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
13013 return ABI->getTypedefNameForUnnamedTagDecl(TD);
13018 return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
13022 return ABI->getDeclaratorForUnnamedTagDecl(TD);
13026 ParamIndices[
D] = index;
13030 ParameterIndexTable::const_iterator I = ParamIndices.find(
D);
13031 assert(I != ParamIndices.end() &&
13032 "ParmIndices lacks entry set by ParmVarDecl");
13037 unsigned Length)
const {
13063 assert(
MSGuidTagDecl &&
"building MS GUID without MS extensions?");
13065 llvm::FoldingSetNodeID ID;
13069 if (
MSGuidDecl *Existing = MSGuidDecls.FindNodeOrInsertPos(ID, InsertPos))
13073 MSGuidDecl *New = MSGuidDecl::Create(*
this, GUIDType, Parts);
13074 MSGuidDecls.InsertNode(New, InsertPos);
13080 const APValue &APVal)
const {
13081 llvm::FoldingSetNodeID ID;
13086 UnnamedGlobalConstantDecls.FindNodeOrInsertPos(ID, InsertPos))
13090 UnnamedGlobalConstantDecl::Create(*
this, Ty, APVal);
13091 UnnamedGlobalConstantDecls.InsertNode(New, InsertPos);
13097 assert(
T->
isRecordType() &&
"template param object of unexpected type");
13103 llvm::FoldingSetNodeID ID;
13108 TemplateParamObjectDecls.FindNodeOrInsertPos(ID, InsertPos))
13112 TemplateParamObjectDecls.InsertNode(New, InsertPos);
13118 if (!
T.isOSDarwin())
13121 if (!(
T.isiOS() &&
T.isOSVersionLT(7)) &&
13122 !(
T.isMacOSX() &&
T.isOSVersionLT(10, 9)))
13131 return (Size != Align ||
toBits(sizeChars) > MaxInlineWidthInBits);
13138 if (MethodDecl->
hasAttr<UnavailableAttr>()
13139 || MethodDecl->
hasAttr<DeprecatedAttr>())
13153 IM != EM && IF != EF; ++IM, ++IF) {
13184 llvm::FoldingSetNodeID IDX, IDY;
13185 X->Profile(IDX, *
this,
true);
13186 Y->
Profile(IDY, *
this,
true);
13200 for (
const Decl *DX :
X->redecls()) {
13205 if (DX->isFirstDecl())
13208 llvm_unreachable(
"Corrupt redecls chain");
13211template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13213 return cast_or_null<T>(
13215 const_cast<Decl *
>(cast_or_null<Decl>(Y))));
13218template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13221 const_cast<Decl *
>(cast<Decl>(Y))));
13226 bool IgnoreDeduced =
false) {
13241 bool IgnoreDeduced) {
13249 assert(Xs.size() == Ys.size());
13251 for (
size_t I = 0; I < Rs.size(); ++I)
13258 return X->getAttributeLoc() == Y->getAttributeLoc() ?
X->getAttributeLoc()
13268 switch (
X.getKind()) {
13298 auto NExpX =
X.getNumTemplateExpansions();
13312 if (Xs.size() != Ys.size())
13314 R.resize(Xs.size());
13315 for (
size_t I = 0; I < R.size(); ++I) {
13328 assert(!Different);
13335 return X->getKeyword() == Y->getKeyword() ?
X->getKeyword()
13343 return X->getQualifier() == Y->getQualifier()
13344 ?
X->getQualifier()
13357 QualType EX =
X->getElementType(), EY = Y->getElementType();
13362 QY += EY.getQualifiers() - RQ;
13372 assert(Ctx.
hasSameExpr(
X->getSizeExpr(), Y->getSizeExpr()));
13373 return X->getSizeExpr();
13378 return X->getSizeModifier();
13384 return X->getIndexTypeCVRQualifiers();
13393 llvm::DenseMap<QualType, unsigned>
Found;
13394 for (
auto Ts : {
X, Y}) {
13401 Out.emplace_back(
T);
13411 bool AcceptDependent) {
13437 assert(AcceptDependent &&
13438 "computing composite pointer type of dependent types");
13453 llvm_unreachable(
"These ESTs should be handled above");
13458 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
13462 Result.Exceptions = ExceptionTypeStorage;
13469 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
13472 llvm_unreachable(
"invalid ExceptionSpecificationType");
13481#define UNEXPECTED_TYPE(Class, Kind) \
13482 case Type::Class: \
13483 llvm_unreachable("Unexpected " Kind ": " #Class);
13485#define NON_CANONICAL_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "non-canonical")
13486#define TYPE(Class, Base)
13487#include "clang/AST/TypeNodes.inc"
13489#define SUGAR_FREE_TYPE(Class) UNEXPECTED_TYPE(Class, "sugar-free")
13500#undef SUGAR_FREE_TYPE
13501#define NON_UNIQUE_TYPE(Class) UNEXPECTED_TYPE(Class, "non-unique")
13504#undef NON_UNIQUE_TYPE
13508#undef UNEXPECTED_TYPE
13511 const auto *AX = cast<AutoType>(
X), *AY = cast<AutoType>(Y);
13512 assert(AX->getDeducedType().isNull());
13513 assert(AY->getDeducedType().isNull());
13514 assert(AX->getKeyword() == AY->getKeyword());
13515 assert(AX->isInstantiationDependentType() ==
13516 AY->isInstantiationDependentType());
13518 AY->getTypeConstraintArguments());
13521 AX->containsUnexpandedParameterPack(),
13523 AY->getTypeConstraintConcept()),
13526 case Type::IncompleteArray: {
13527 const auto *AX = cast<IncompleteArrayType>(
X),
13528 *AY = cast<IncompleteArrayType>(Y);
13533 case Type::DependentSizedArray: {
13534 const auto *AX = cast<DependentSizedArrayType>(
X),
13535 *AY = cast<DependentSizedArrayType>(Y);
13540 AX->getBracketsRange() == AY->getBracketsRange()
13541 ? AX->getBracketsRange()
13544 case Type::ConstantArray: {
13545 const auto *AX = cast<ConstantArrayType>(
X),
13546 *AY = cast<ConstantArrayType>(Y);
13547 assert(AX->getSize() == AY->getSize());
13548 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13549 ? AX->getSizeExpr()
13555 case Type::ArrayParameter: {
13556 const auto *AX = cast<ArrayParameterType>(
X),
13557 *AY = cast<ArrayParameterType>(Y);
13558 assert(AX->getSize() == AY->getSize());
13559 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13560 ? AX->getSizeExpr()
13567 case Type::Atomic: {
13568 const auto *AX = cast<AtomicType>(
X), *AY = cast<AtomicType>(Y);
13572 case Type::Complex: {
13573 const auto *CX = cast<ComplexType>(
X), *CY = cast<ComplexType>(Y);
13576 case Type::Pointer: {
13577 const auto *PX = cast<PointerType>(
X), *PY = cast<PointerType>(Y);
13580 case Type::BlockPointer: {
13581 const auto *PX = cast<BlockPointerType>(
X), *PY = cast<BlockPointerType>(Y);
13584 case Type::ObjCObjectPointer: {
13585 const auto *PX = cast<ObjCObjectPointerType>(
X),
13586 *PY = cast<ObjCObjectPointerType>(Y);
13589 case Type::MemberPointer: {
13590 const auto *PX = cast<MemberPointerType>(
X),
13591 *PY = cast<MemberPointerType>(Y);
13598 case Type::LValueReference: {
13599 const auto *PX = cast<LValueReferenceType>(
X),
13600 *PY = cast<LValueReferenceType>(Y);
13603 PX->isSpelledAsLValue() ||
13604 PY->isSpelledAsLValue());
13606 case Type::RValueReference: {
13607 const auto *PX = cast<RValueReferenceType>(
X),
13608 *PY = cast<RValueReferenceType>(Y);
13612 case Type::DependentAddressSpace: {
13613 const auto *PX = cast<DependentAddressSpaceType>(
X),
13614 *PY = cast<DependentAddressSpaceType>(Y);
13615 assert(Ctx.
hasSameExpr(PX->getAddrSpaceExpr(), PY->getAddrSpaceExpr()));
13617 PX->getAddrSpaceExpr(),
13620 case Type::FunctionNoProto: {
13621 const auto *FX = cast<FunctionNoProtoType>(
X),
13622 *FY = cast<FunctionNoProtoType>(Y);
13623 assert(FX->getExtInfo() == FY->getExtInfo());
13628 case Type::FunctionProto: {
13629 const auto *FX = cast<FunctionProtoType>(
X),
13630 *FY = cast<FunctionProtoType>(Y);
13632 EPIY = FY->getExtProtoInfo();
13633 assert(EPIX.
ExtInfo == EPIY.ExtInfo);
13636 assert(EPIX.
TypeQuals == EPIY.TypeQuals);
13637 assert(EPIX.
Variadic == EPIY.Variadic);
13654 case Type::ObjCObject: {
13655 const auto *OX = cast<ObjCObjectType>(
X), *OY = cast<ObjCObjectType>(Y);
13657 std::equal(OX->getProtocols().begin(), OX->getProtocols().end(),
13658 OY->getProtocols().begin(), OY->getProtocols().end(),
13660 return P0->getCanonicalDecl() == P1->getCanonicalDecl();
13662 "protocol lists must be the same");
13664 OY->getTypeArgsAsWritten());
13667 OX->getProtocols(),
13668 OX->isKindOfTypeAsWritten() && OY->isKindOfTypeAsWritten());
13670 case Type::ConstantMatrix: {
13671 const auto *MX = cast<ConstantMatrixType>(
X),
13672 *MY = cast<ConstantMatrixType>(Y);
13673 assert(MX->getNumRows() == MY->getNumRows());
13674 assert(MX->getNumColumns() == MY->getNumColumns());
13676 MX->getNumRows(), MX->getNumColumns());
13678 case Type::DependentSizedMatrix: {
13679 const auto *MX = cast<DependentSizedMatrixType>(
X),
13680 *MY = cast<DependentSizedMatrixType>(Y);
13681 assert(Ctx.
hasSameExpr(MX->getRowExpr(), MY->getRowExpr()));
13682 assert(Ctx.
hasSameExpr(MX->getColumnExpr(), MY->getColumnExpr()));
13687 case Type::Vector: {
13688 const auto *VX = cast<VectorType>(
X), *VY = cast<VectorType>(Y);
13689 assert(VX->getNumElements() == VY->getNumElements());
13690 assert(VX->getVectorKind() == VY->getVectorKind());
13692 VX->getNumElements(), VX->getVectorKind());
13694 case Type::ExtVector: {
13695 const auto *VX = cast<ExtVectorType>(
X), *VY = cast<ExtVectorType>(Y);
13696 assert(VX->getNumElements() == VY->getNumElements());
13698 VX->getNumElements());
13700 case Type::DependentSizedExtVector: {
13701 const auto *VX = cast<DependentSizedExtVectorType>(
X),
13702 *VY = cast<DependentSizedExtVectorType>(Y);
13707 case Type::DependentVector: {
13708 const auto *VX = cast<DependentVectorType>(
X),
13709 *VY = cast<DependentVectorType>(Y);
13710 assert(VX->getVectorKind() == VY->getVectorKind());
13715 case Type::InjectedClassName: {
13716 const auto *IX = cast<InjectedClassNameType>(
X),
13717 *IY = cast<InjectedClassNameType>(Y);
13721 IY->getInjectedSpecializationType()));
13723 case Type::TemplateSpecialization: {
13724 const auto *TX = cast<TemplateSpecializationType>(
X),
13725 *TY = cast<TemplateSpecializationType>(Y);
13727 TY->template_arguments());
13730 TY->getTemplateName(),
13732 As,
X->getCanonicalTypeInternal());
13734 case Type::Decltype: {
13735 const auto *DX = cast<DecltypeType>(
X);
13736 [[maybe_unused]]
const auto *DY = cast<DecltypeType>(Y);
13737 assert(DX->isDependentType());
13738 assert(DY->isDependentType());
13739 assert(Ctx.
hasSameExpr(DX->getUnderlyingExpr(), DY->getUnderlyingExpr()));
13743 case Type::PackIndexing: {
13744 const auto *DX = cast<PackIndexingType>(
X);
13745 [[maybe_unused]]
const auto *DY = cast<PackIndexingType>(Y);
13746 assert(DX->isDependentType());
13747 assert(DY->isDependentType());
13748 assert(Ctx.
hasSameExpr(DX->getIndexExpr(), DY->getIndexExpr()));
13751 case Type::DependentName: {
13752 const auto *NX = cast<DependentNameType>(
X),
13753 *NY = cast<DependentNameType>(Y);
13754 assert(NX->getIdentifier() == NY->getIdentifier());
13757 NX->getIdentifier(), NX->getCanonicalTypeInternal());
13759 case Type::DependentTemplateSpecialization: {
13760 const auto *TX = cast<DependentTemplateSpecializationType>(
X),
13761 *TY = cast<DependentTemplateSpecializationType>(Y);
13762 assert(TX->getIdentifier() == TY->getIdentifier());
13764 TY->template_arguments());
13767 TX->getIdentifier(), As);
13769 case Type::UnaryTransform: {
13770 const auto *TX = cast<UnaryTransformType>(
X),
13771 *TY = cast<UnaryTransformType>(Y);
13772 assert(TX->getUTTKind() == TY->getUTTKind());
13776 TY->getUnderlyingType()),
13779 case Type::PackExpansion: {
13780 const auto *PX = cast<PackExpansionType>(
X),
13781 *PY = cast<PackExpansionType>(Y);
13782 assert(PX->getNumExpansions() == PY->getNumExpansions());
13785 PX->getNumExpansions(),
false);
13788 const auto *PX = cast<PipeType>(
X), *PY = cast<PipeType>(Y);
13789 assert(PX->isReadOnly() == PY->isReadOnly());
13794 case Type::TemplateTypeParm: {
13795 const auto *TX = cast<TemplateTypeParmType>(
X),
13796 *TY = cast<TemplateTypeParmType>(Y);
13797 assert(TX->getDepth() == TY->getDepth());
13798 assert(TX->getIndex() == TY->getIndex());
13799 assert(TX->isParameterPack() == TY->isParameterPack());
13801 TX->getDepth(), TX->getIndex(), TX->isParameterPack(),
13805 llvm_unreachable(
"Unknown Type Class");
13815#define UNEXPECTED_TYPE(Class, Kind) \
13816 case Type::Class: \
13817 llvm_unreachable("Unexpected " Kind ": " #Class);
13818#define TYPE(Class, Base)
13819#define DEPENDENT_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "dependent")
13820#include "clang/AST/TypeNodes.inc"
13822#define CANONICAL_TYPE(Class) UNEXPECTED_TYPE(Class, "canonical")
13848#undef CANONICAL_TYPE
13850#undef UNEXPECTED_TYPE
13852 case Type::Adjusted: {
13853 const auto *AX = cast<AdjustedType>(
X), *AY = cast<AdjustedType>(Y);
13854 QualType OX = AX->getOriginalType(), OY = AY->getOriginalType();
13861 case Type::Decayed: {
13862 const auto *DX = cast<DecayedType>(
X), *DY = cast<DecayedType>(Y);
13863 QualType OX = DX->getOriginalType(), OY = DY->getOriginalType();
13870 case Type::Attributed: {
13871 const auto *AX = cast<AttributedType>(
X), *AY = cast<AttributedType>(Y);
13873 if (Kind != AY->getAttrKind())
13875 QualType MX = AX->getModifiedType(), MY = AY->getModifiedType();
13883 case Type::BTFTagAttributed: {
13884 const auto *BX = cast<BTFTagAttributedType>(
X);
13885 const BTFTypeTagAttr *AX = BX->getAttr();
13887 if (AX->getBTFTypeTag() !=
13888 cast<BTFTagAttributedType>(Y)->getAttr()->getBTFTypeTag())
13893 const auto *AX = cast<AutoType>(
X), *AY = cast<AutoType>(Y);
13896 if (KW != AY->getKeyword())
13900 AY->getTypeConstraintConcept());
13904 AY->getTypeConstraintArguments())) {
13912 false,
false, CD, As);
13914 case Type::PackIndexing:
13915 case Type::Decltype:
13917 case Type::DeducedTemplateSpecialization:
13921 case Type::Elaborated: {
13922 const auto *EX = cast<ElaboratedType>(
X), *EY = cast<ElaboratedType>(Y);
13928 case Type::MacroQualified: {
13929 const auto *MX = cast<MacroQualifiedType>(
X),
13930 *MY = cast<MacroQualifiedType>(Y);
13932 if (IX != MY->getMacroIdentifier())
13936 case Type::SubstTemplateTypeParm: {
13937 const auto *SX = cast<SubstTemplateTypeParmType>(
X),
13938 *SY = cast<SubstTemplateTypeParmType>(Y);
13943 unsigned Index = SX->getIndex();
13944 if (Index != SY->getIndex())
13946 auto PackIndex = SX->getPackIndex();
13947 if (PackIndex != SY->getPackIndex())
13950 CD, Index, PackIndex);
13952 case Type::ObjCTypeParam:
13958 case Type::TemplateSpecialization: {
13959 const auto *TX = cast<TemplateSpecializationType>(
X),
13960 *TY = cast<TemplateSpecializationType>(Y);
13963 TY->getTemplateName(),
true);
13968 TY->template_arguments()))
13973 case Type::Typedef: {
13974 const auto *TX = cast<TypedefType>(
X), *TY = cast<TypedefType>(Y);
13980 case Type::TypeOf: {
13986 if (cast<TypeOfType>(
X)->
getKind() == cast<TypeOfType>(Y)->
getKind() &&
13991 case Type::TypeOfExpr:
13994 case Type::UnaryTransform: {
13995 const auto *UX = cast<UnaryTransformType>(
X),
13996 *UY = cast<UnaryTransformType>(Y);
13998 if (KX != UY->getUTTKind())
14000 QualType BX = UX->getBaseType(), BY = UY->getBaseType();
14007 case Type::Using: {
14008 const auto *UX = cast<UsingType>(
X), *UY = cast<UsingType>(Y);
14015 case Type::CountAttributed: {
14016 const auto *DX = cast<CountAttributedType>(
X),
14017 *DY = cast<CountAttributedType>(Y);
14018 if (DX->isCountInBytes() != DY->isCountInBytes())
14020 if (DX->isOrNull() != DY->isOrNull())
14022 Expr *CEX = DX->getCountExpr();
14023 Expr *CEY = DY->getCountExpr();
14027 DX->isCountInBytes(), DX->isOrNull(),
14038 DX->isCountInBytes(), DX->isOrNull(),
14042 llvm_unreachable(
"Unhandled Type Class");
14064 if (
X.isCanonical())
14077 if (SX.
Ty != SY.Ty) {
14085 while (!Xs.empty() && !Ys.empty() && Xs.back().Ty == Ys.back().Ty) {
14088 SX = Xs.pop_back_val();
14089 SY = Ys.pop_back_val();
14099 while (!Xs.empty() && !Ys.empty()) {
14102 SX = Xs.pop_back_val();
14103 SY = Ys.pop_back_val();
14108 SX.
Ty = Underlying.Ty;
14111 QX -= Underlying.Quals;
14129 llvm_unreachable(
"Not a saturated fixed point type!");
14130 case BuiltinType::SatShortAccum:
14132 case BuiltinType::SatAccum:
14134 case BuiltinType::SatLongAccum:
14136 case BuiltinType::SatUShortAccum:
14138 case BuiltinType::SatUAccum:
14140 case BuiltinType::SatULongAccum:
14142 case BuiltinType::SatShortFract:
14144 case BuiltinType::SatFract:
14146 case BuiltinType::SatLongFract:
14148 case BuiltinType::SatUShortFract:
14150 case BuiltinType::SatUFract:
14152 case BuiltinType::SatULongFract:
14164 llvm_unreachable(
"Not a fixed point type!");
14165 case BuiltinType::ShortAccum:
14167 case BuiltinType::Accum:
14169 case BuiltinType::LongAccum:
14171 case BuiltinType::UShortAccum:
14173 case BuiltinType::UAccum:
14175 case BuiltinType::ULongAccum:
14177 case BuiltinType::ShortFract:
14179 case BuiltinType::Fract:
14181 case BuiltinType::LongFract:
14183 case BuiltinType::UShortFract:
14185 case BuiltinType::UFract:
14187 case BuiltinType::ULongFract:
14193 if (LangOpts.OpenCL)
14217 llvm_unreachable(
"Not a fixed point type!");
14218 case BuiltinType::ShortAccum:
14219 case BuiltinType::SatShortAccum:
14220 return Target.getShortAccumScale();
14221 case BuiltinType::Accum:
14222 case BuiltinType::SatAccum:
14223 return Target.getAccumScale();
14224 case BuiltinType::LongAccum:
14225 case BuiltinType::SatLongAccum:
14226 return Target.getLongAccumScale();
14227 case BuiltinType::UShortAccum:
14228 case BuiltinType::SatUShortAccum:
14229 return Target.getUnsignedShortAccumScale();
14230 case BuiltinType::UAccum:
14231 case BuiltinType::SatUAccum:
14232 return Target.getUnsignedAccumScale();
14233 case BuiltinType::ULongAccum:
14234 case BuiltinType::SatULongAccum:
14235 return Target.getUnsignedLongAccumScale();
14236 case BuiltinType::ShortFract:
14237 case BuiltinType::SatShortFract:
14238 return Target.getShortFractScale();
14239 case BuiltinType::Fract:
14240 case BuiltinType::SatFract:
14241 return Target.getFractScale();
14242 case BuiltinType::LongFract:
14243 case BuiltinType::SatLongFract:
14244 return Target.getLongFractScale();
14245 case BuiltinType::UShortFract:
14246 case BuiltinType::SatUShortFract:
14247 return Target.getUnsignedShortFractScale();
14248 case BuiltinType::UFract:
14249 case BuiltinType::SatUFract:
14250 return Target.getUnsignedFractScale();
14251 case BuiltinType::ULongFract:
14252 case BuiltinType::SatULongFract:
14253 return Target.getUnsignedLongFractScale();
14263 llvm_unreachable(
"Not a fixed point type!");
14264 case BuiltinType::ShortAccum:
14265 case BuiltinType::SatShortAccum:
14266 return Target.getShortAccumIBits();
14267 case BuiltinType::Accum:
14268 case BuiltinType::SatAccum:
14269 return Target.getAccumIBits();
14270 case BuiltinType::LongAccum:
14271 case BuiltinType::SatLongAccum:
14272 return Target.getLongAccumIBits();
14273 case BuiltinType::UShortAccum:
14274 case BuiltinType::SatUShortAccum:
14275 return Target.getUnsignedShortAccumIBits();
14276 case BuiltinType::UAccum:
14277 case BuiltinType::SatUAccum:
14278 return Target.getUnsignedAccumIBits();
14279 case BuiltinType::ULongAccum:
14280 case BuiltinType::SatULongAccum:
14281 return Target.getUnsignedLongAccumIBits();
14282 case BuiltinType::ShortFract:
14283 case BuiltinType::SatShortFract:
14284 case BuiltinType::Fract:
14285 case BuiltinType::SatFract:
14286 case BuiltinType::LongFract:
14287 case BuiltinType::SatLongFract:
14288 case BuiltinType::UShortFract:
14289 case BuiltinType::SatUShortFract:
14290 case BuiltinType::UFract:
14291 case BuiltinType::SatUFract:
14292 case BuiltinType::ULongFract:
14293 case BuiltinType::SatULongFract:
14298llvm::FixedPointSemantics
14301 "Can only get the fixed point semantics for a "
14302 "fixed point or integer type.");
14304 return llvm::FixedPointSemantics::GetIntegerSemantics(
14308 return llvm::FixedPointSemantics(
14311 !isSigned &&
getTargetInfo().doUnsignedFixedPointTypesHavePadding());
14326 "Expected unsigned fixed point type");
14329 case BuiltinType::UShortAccum:
14331 case BuiltinType::UAccum:
14333 case BuiltinType::ULongAccum:
14335 case BuiltinType::SatUShortAccum:
14337 case BuiltinType::SatUAccum:
14339 case BuiltinType::SatULongAccum:
14341 case BuiltinType::UShortFract:
14343 case BuiltinType::UFract:
14345 case BuiltinType::ULongFract:
14347 case BuiltinType::SatUShortFract:
14349 case BuiltinType::SatUFract:
14351 case BuiltinType::SatULongFract:
14354 llvm_unreachable(
"Unexpected unsigned fixed point type");
14362 std::vector<std::string> BackendFeats;
14363 llvm::AArch64::ExtensionSet FeatureBits;
14364 for (StringRef F : FMVFeatStrings)
14365 if (
auto FMVExt = llvm::AArch64::parseFMVExtension(F))
14367 FeatureBits.enable(*FMVExt->ID);
14368 FeatureBits.toLLVMFeatureList(BackendFeats);
14369 return BackendFeats;
14374 assert(TD !=
nullptr);
14377 llvm::erase_if(
ParsedAttr.Features, [&](
const std::string &Feat) {
14378 return !Target->isValidFeatureName(StringRef{Feat}.substr(1));
14389 Target->getTargetOpts().CPU,
14390 Target->getTargetOpts().Features);
14397 StringRef TargetCPU =
Target->getTargetOpts().CPU;
14399 if (
const auto *TD = FD->
getAttr<TargetAttr>()) {
14405 if (!
Target->getTriple().isAArch64())
14408 Target->getTargetOpts().FeaturesAsWritten.begin(),
14409 Target->getTargetOpts().FeaturesAsWritten.end());
14420 }
else if (
const auto *SD = FD->
getAttr<CPUSpecificAttr>()) {
14422 Target->getCPUSpecificCPUDispatchFeatures(
14424 std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
14425 Features.insert(Features.begin(),
14426 Target->getTargetOpts().FeaturesAsWritten.begin(),
14427 Target->getTargetOpts().FeaturesAsWritten.end());
14429 }
else if (
const auto *TC = FD->
getAttr<TargetClonesAttr>()) {
14430 if (
Target->getTriple().isAArch64()) {
14434 Features.insert(Features.begin(),
14435 Target->getTargetOpts().FeaturesAsWritten.begin(),
14436 Target->getTargetOpts().FeaturesAsWritten.end());
14438 }
else if (
Target->getTriple().isRISCV()) {
14440 std::vector<std::string> Features;
14441 if (VersionStr !=
"default") {
14443 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14446 Features.insert(Features.begin(),
14447 Target->getTargetOpts().FeaturesAsWritten.begin(),
14448 Target->getTargetOpts().FeaturesAsWritten.end());
14451 std::vector<std::string> Features;
14453 if (VersionStr.starts_with(
"arch="))
14454 TargetCPU = VersionStr.drop_front(
sizeof(
"arch=") - 1);
14455 else if (VersionStr !=
"default")
14456 Features.push_back((StringRef{
"+"} + VersionStr).str());
14459 }
else if (
const auto *TV = FD->
getAttr<TargetVersionAttr>()) {
14460 std::vector<std::string> Features;
14461 if (
Target->getTriple().isRISCV()) {
14463 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14466 assert(
Target->getTriple().isAArch64());
14468 TV->getFeatures(Feats);
14471 Features.insert(Features.begin(),
14472 Target->getTargetOpts().FeaturesAsWritten.begin(),
14473 Target->getTargetOpts().FeaturesAsWritten.end());
14476 FeatureMap =
Target->getTargetOpts().FeatureMap;
14482 return {KernelNameType, FD};
14491 const auto *SKEPAttr = FD->
getAttr<SYCLKernelEntryPointAttr>();
14492 assert(SKEPAttr &&
"Missing sycl_kernel_entry_point attribute");
14501 "SYCL kernel name conflict");
14516 return &IT->second;
14522 return *OMPTraitInfoVector.back();
14529 return DB << Section.
Decl;
14530 return DB <<
"a prior #pragma section";
14534 bool IsInternalVar =
14537 bool IsExplicitDeviceVar = (
D->
hasAttr<CUDADeviceAttr>() &&
14538 !
D->
getAttr<CUDADeviceAttr>()->isImplicit()) ||
14539 (
D->
hasAttr<CUDAConstantAttr>() &&
14540 !
D->
getAttr<CUDAConstantAttr>()->isImplicit());
14544 return (IsInternalVar &&
14545 (
D->
hasAttr<HIPManagedAttr>() || IsExplicitDeviceVar)) ||
14558 if (!CUIDHash.empty())
14560 if (LangOpts.
CUID.empty())
14561 return StringRef();
14562 CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.
CUID),
true);
14572 assert(PrimaryBase);
14575 auto Base = Layout.getPrimaryBase();
14576 if (!
Base ||
Base == PrimaryBase || !
Base->isPolymorphic())
14578 PrimaryBase =
Base;
14580 return PrimaryBase;
14584 StringRef MangledName) {
14585 auto *Method = cast<CXXMethodDecl>(VirtualMethodDecl.
getDecl());
14586 assert(Method->isVirtual());
14587 bool DefaultIncludesPointerAuth =
14588 LangOpts.PointerAuthCalls || LangOpts.PointerAuthIntrinsics;
14590 if (!DefaultIncludesPointerAuth)
14593 auto Existing = ThunksToBeAbbreviated.find(VirtualMethodDecl);
14594 if (Existing != ThunksToBeAbbreviated.end())
14595 return Existing->second.contains(MangledName.str());
14598 llvm::StringMap<llvm::SmallVector<std::string, 2>> Thunks;
14600 if (
const auto *ThunkInfos = VtableContext->getThunkInfo(VirtualMethodDecl)) {
14601 auto *
Destructor = dyn_cast<CXXDestructorDecl>(Method);
14602 for (
const auto &Thunk : *ThunkInfos) {
14604 llvm::raw_svector_ostream ElidedNameStream(ElidedName);
14610 Mangler->mangleThunk(Method, Thunk,
true,
14613 llvm::raw_svector_ostream mangledNameStream(MangledName);
14617 mangledNameStream);
14619 Mangler->mangleThunk(Method, Thunk,
false,
14620 mangledNameStream);
14622 Thunks[ElidedName].push_back(std::string(MangledName));
14625 llvm::StringSet<> SimplifiedThunkNames;
14626 for (
auto &ThunkList : Thunks) {
14627 llvm::sort(ThunkList.second);
14628 SimplifiedThunkNames.insert(ThunkList.second[0]);
14630 bool Result = SimplifiedThunkNames.contains(MangledName);
14631 ThunksToBeAbbreviated[VirtualMethodDecl] = std::move(SimplifiedThunkNames);
This file provides AST data structures related to concepts.
static void SortAndUniqueProtocols(SmallVectorImpl< ObjCProtocolDecl * > &Protocols)
static bool isCanonicalExceptionSpecification(const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType)
static SourceLocation getCommonAttrLoc(const T *X, const T *Y)
static auto getCommonTypes(ASTContext &Ctx, ArrayRef< QualType > Xs, ArrayRef< QualType > Ys, bool Unqualified=false)
static auto getCanonicalTemplateArguments(const ASTContext &C, ArrayRef< TemplateArgument > Args, bool &AnyNonCanonArgs)
static char getObjCEncodingForPrimitiveType(const ASTContext *C, const BuiltinType *BT)
static bool NeedsInjectedClassNameType(const RecordDecl *D)
static bool unionHasUniqueObjectRepresentations(const ASTContext &Context, const RecordDecl *RD, bool CheckIfTriviallyCopyable)
static NamespaceDecl * getNamespace(const NestedNameSpecifier *X)
static TypedefDecl * CreateHexagonBuiltinVaListDecl(const ASTContext *Context)
#define CANONICAL_TYPE(Class)
static NestedNameSpecifier * getCommonNNS(ASTContext &Ctx, const T *X, const T *Y)
static Decl * getCommonDecl(Decl *X, Decl *Y)
static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context, const Decl *D, GVALinkage L)
static bool isTypeTypedefedAsBOOL(QualType T)
static void EncodeBitField(const ASTContext *Ctx, std::string &S, QualType T, const FieldDecl *FD)
static GVALinkage basicGVALinkageForVariable(const ASTContext &Context, const VarDecl *VD)
static const TemplateArgument * getDefaultTemplateArgumentOrNone(const NamedDecl *P)
static uint64_t getSVETypeSize(ASTContext &Context, const BuiltinType *Ty)
getSVETypeSize - Return SVE vector or predicate register size.
#define SUGAR_FREE_TYPE(Class)
static bool getCommonTemplateArguments(ASTContext &Ctx, SmallVectorImpl< TemplateArgument > &R, ArrayRef< TemplateArgument > Xs, ArrayRef< TemplateArgument > Ys)
static bool hasTemplateSpecializationInEncodedString(const Type *T, bool VisitBasesAndFields)
static void getIntersectionOfProtocols(ASTContext &Context, const ObjCInterfaceDecl *CommonBase, const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT, SmallVectorImpl< ObjCProtocolDecl * > &IntersectionSet)
getIntersectionOfProtocols - This routine finds the intersection of set of protocols inherited from t...
static bool areCompatMatrixTypes(const ConstantMatrixType *LHS, const ConstantMatrixType *RHS)
areCompatMatrixTypes - Return true if the two specified matrix types are compatible.
static TypedefDecl * CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context)
static bool sameObjCTypeArgs(ASTContext &ctx, const ObjCInterfaceDecl *iface, ArrayRef< QualType > lhsArgs, ArrayRef< QualType > rhsArgs, bool stripKindOf)
static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs, QualType rhs)
Determine whether the first type is a subtype of the second.
static const Type * getIntegerTypeForEnum(const EnumType *ET)
static const Decl & adjustDeclToTemplate(const Decl &D)
If we have a 'templated' declaration for a template, adjust 'D' to refer to the actual template.
static int CmpProtocolNames(ObjCProtocolDecl *const *LHS, ObjCProtocolDecl *const *RHS)
CmpProtocolNames - Comparison predicate for sorting protocols alphabetically.
static QualType getCommonElementType(ASTContext &Ctx, const T *X, const T *Y)
static TypedefDecl * CreatePowerABIBuiltinVaListDecl(const ASTContext *Context)
static auto getCommonSizeModifier(const ArrayType *X, const ArrayType *Y)
static std::optional< int64_t > structHasUniqueObjectRepresentations(const ASTContext &Context, const RecordDecl *RD, bool CheckIfTriviallyCopyable)
static bool hasSameOverloadableAttrs(const FunctionDecl *A, const FunctionDecl *B)
Determine whether the attributes we can overload on are identical for A and B.
static T * getCommonDeclChecked(T *X, T *Y)
static TypedefDecl * CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context)
static int64_t getSubobjectOffset(const FieldDecl *Field, const ASTContext &Context, const clang::ASTRecordLayout &)
static TypedefDecl * CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context)
static TypedefDecl * CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context)
static TemplateName getCommonTemplateNameChecked(ASTContext &Ctx, TemplateName X, TemplateName Y, bool IgnoreDeduced)
static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET, QualType other, bool isBlockReturnType)
Given that we have an enum type and a non-enum type, try to merge them.
static GVALinkage adjustGVALinkageForExternalDefinitionKind(const ASTContext &Ctx, const Decl *D, GVALinkage L)
Adjust the GVALinkage for a declaration based on what an external AST source knows about whether ther...
static TypedefDecl * CreateSystemZBuiltinVaListDecl(const ASTContext *Context)
static std::optional< int64_t > getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context, bool CheckIfTriviallyCopyable)
static GVALinkage basicGVALinkageForFunction(const ASTContext &Context, const FunctionDecl *FD)
#define NON_UNIQUE_TYPE(Class)
static TypedefDecl * CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context)
static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI, const LangOptions &LangOpts)
static auto getCommonIndexTypeCVRQualifiers(const ArrayType *X, const ArrayType *Y)
static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequiresICE, bool AllowTypeModifiers)
DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the pointer over the consume...
static TypedefDecl * CreateCharPtrBuiltinVaListDecl(const ASTContext *Context)
static void mergeTypeLists(ASTContext &Ctx, SmallVectorImpl< QualType > &Out, ArrayRef< QualType > X, ArrayRef< QualType > Y)
static bool areSortedAndUniqued(ArrayRef< ObjCProtocolDecl * > Protocols)
static TypeInfoChars getConstantArrayInfoInChars(const ASTContext &Context, const ConstantArrayType *CAT)
getConstantArrayInfoInChars - Performing the computation in CharUnits instead of in bits prevents ove...
static FloatingRank getFloatingRank(QualType T)
getFloatingRank - Return a relative rank for floating point types.
static TypedefDecl * CreateXtensaABIBuiltinVaListDecl(const ASTContext *Context)
static TemplateArgument getCommonTemplateArgument(ASTContext &Ctx, const TemplateArgument &X, const TemplateArgument &Y)
static auto * getCommonSizeExpr(ASTContext &Ctx, T *X, T *Y)
static void encodeTypeForFunctionPointerAuth(const ASTContext &Ctx, raw_ostream &OS, QualType QT)
Encode a function type for use in the discriminator of a function pointer type.
static std::optional< int64_t > structSubobjectsHaveUniqueObjectRepresentations(const RangeT &Subobjects, int64_t CurOffsetInBits, const ASTContext &Context, const clang::ASTRecordLayout &Layout, bool CheckIfTriviallyCopyable)
static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET)
static QualType getCommonArrayElementType(ASTContext &Ctx, const T *X, Qualifiers &QX, const T *Y, Qualifiers &QY)
static QualType getCommonPointeeType(ASTContext &Ctx, const T *X, const T *Y)
static uint64_t getRVVTypeSize(ASTContext &Context, const BuiltinType *Ty)
getRVVTypeSize - Return RVV vector register size.
static auto unwrapSugar(SplitQualType &T, Qualifiers &QTotal)
static SYCLKernelInfo BuildSYCLKernelInfo(CanQualType KernelNameType, const FunctionDecl *FD)
static int compareObjCProtocolsByName(ObjCProtocolDecl *const *lhs, ObjCProtocolDecl *const *rhs)
Comparison routine for Objective-C protocols to be used with llvm::array_pod_sort.
static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X, Qualifiers &QX, const Type *Y, Qualifiers &QY)
static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X, const Type *Y, SplitQualType Underlying)
static bool isSameQualifier(const NestedNameSpecifier *X, const NestedNameSpecifier *Y)
static std::string charUnitsToString(const CharUnits &CU)
static bool hasAnyPackExpansions(ArrayRef< TemplateArgument > Args)
static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, SmallVectorImpl< const NamedDecl * > &Redeclared)
static SmallVector< SourceLocation, 2 > getDeclLocsForCommentSearch(const Decl *D, SourceManager &SourceMgr)
static TemplateName getCommonTemplateName(ASTContext &Ctx, TemplateName X, TemplateName Y, bool IgnoreDeduced=false)
static bool isCanonicalResultType(QualType T)
Determine whether T is canonical as the result type of a function.
static TypedefDecl * CreateMSVaListDecl(const ASTContext *Context)
static bool areCompatVectorTypes(const VectorType *LHS, const VectorType *RHS)
areCompatVectorTypes - Return true if the two specified vector types are compatible.
static TypedefDecl * CreateCharPtrNamedVaListDecl(const ASTContext *Context, StringRef Name)
#define UNEXPECTED_TYPE(Class, Kind)
static TypedefDecl * CreateVaListDecl(const ASTContext *Context, TargetInfo::BuiltinVaListKind Kind)
static std::vector< std::string > getFMVBackendFeaturesFor(const llvm::SmallVectorImpl< StringRef > &FMVFeatStrings)
static ElaboratedTypeKeyword getCommonTypeKeyword(const T *X, const T *Y)
Defines the clang::ASTContext interface.
Provides definitions for the various language-specific address spaces.
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
static constexpr Builtin::Info BuiltinInfo[]
Defines enum values for all the target-independent builtin functions.
static bool CanThrow(Expr *E, ASTContext &Ctx)
static Decl::Kind getKind(const Decl *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
This file defines OpenMP nodes for declarative directives.
Defines the C++ template declaration subclasses.
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
static const Decl * getCanonicalDecl(const Decl *D)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Target Target
llvm::MachO::Record Record
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature.
Defines the clang::Module class, which describes a module in the source code.
Defines types useful for describing an Objective-C runtime.
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
static QualType getUnderlyingType(const SubRegion *R)
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
static QualType getPointeeType(const MemRegion *R)
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
static const TemplateArgument & getArgument(const TemplateArgument &A)
C Language Family Type Representation.
__device__ __2f16 float c
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
bool isMemberPointerToDerivedMember() const
const ValueDecl * getMemberPointerDecl() const
ArrayRef< const CXXRecordDecl * > getMemberPointerPath() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
bool getByrefLifetime(QualType Ty, Qualifiers::ObjCLifetime &Lifetime, bool &HasByrefExtendedLayout) const
Returns true, if given type has a known lifetime.
MSGuidDecl * getMSGuidDecl(MSGuidDeclParts Parts) const
Return a declaration for the global GUID object representing the given GUID value.
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl, const ObjCMethodDecl *MethodImp)
CanQualType ObjCBuiltinSelTy
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
CanQualType getCanonicalFunctionResultType(QualType ResultType) const
Adjust the given function result type.
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
llvm::PointerUnion< VarTemplateDecl *, MemberSpecializationInfo * > TemplateOrSpecializationInfo
A type synonym for the TemplateOrInstantiation mapping.
LangAS getOpenCLTypeAddrSpace(const Type *T) const
Get address space for OpenCL type.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
void InitBuiltinTypes(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)
Initialize built-in types.
ParentMapContext & getParentMapContext()
Returns the dynamic AST node parent map context.
QualType getParenType(QualType NamedType) const
size_t getSideTableAllocatedMemory() const
Return the total memory used for various side tables.
MemberSpecializationInfo * getInstantiatedFromStaticDataMember(const VarDecl *Var)
If this variable is an instantiated static data member of a class template specialization,...
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
CanQualType ARCUnbridgedCastTy
QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr, Expr *ColumnExpr, SourceLocation AttrLoc) const
Return the unique reference to the matrix type of the specified element type and size.
QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped) const
llvm::DenseMap< const Decl *, comments::FullComment * > ParsedComments
Mapping from declarations to parsed comments attached to any redeclaration.
BuiltinTemplateDecl * getBuiltinCommonTypeDecl() const
unsigned getManglingNumber(const NamedDecl *ND, bool ForAuxTarget=false) const
unsigned getIntWidth(QualType T) const
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one.
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
TemplateOrSpecializationInfo getTemplateOrSpecializationInfo(const VarDecl *Var)
InlineVariableDefinitionKind
@ None
Not an inline variable.
@ Weak
Weak definition of inline variable.
@ Strong
Strong definition.
@ WeakUnknown
Weak for now, might become strong later in this TU.
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl)
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type.
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
TypedefDecl * getCFConstantStringDecl() const
CanQualType SatUnsignedFractTy
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
ExternCContextDecl * getExternCContextDecl() const
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const
Parses the target attributes passed in, and returns only the ones that are valid feature names.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
CanQualType UnsignedShortAccumTy
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
QualType adjustFunctionResultType(QualType FunctionType, QualType NewResultType)
Change the result type of a function type, preserving sugar such as attributed types.
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, ObjCProtocolDecl *rProto) const
ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the inheritance hierarchy of 'rProto...
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
void adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig, ObjCTypeParamDecl *New) const
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type.
bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool AllowCXX=false, bool IsConditionalOperator=false)
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
DeclarationNameTable DeclarationNames
comments::FullComment * cloneFullComment(comments::FullComment *FC, const Decl *D) const
QualType getUnresolvedUsingType(const UnresolvedUsingTypenameDecl *Decl) const
CharUnits getObjCEncodingTypeSize(QualType T) const
Return the size of type T for Objective-C encoding purpose, in characters.
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType, const Attr *attr=nullptr) const
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
void setCurrentNamedModule(Module *M)
Set the (C++20) module we are building.
QualType getProcessIDType() const
Return the unique type for "pid_t" defined in <sys/types.h>.
CharUnits getMemberPointerPathAdjustment(const APValue &MP) const
Find the 'this' offset for the member path in a pointer-to-member APValue.
bool mayExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel may be externalized.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
std::unique_ptr< MangleNumberingContext > createMangleNumberingContext() const
QualType getUnsignedPointerDiffType() const
Return the unique unsigned counterpart of "ptrdiff_t" integer type.
QualType getucontext_tType() const
Retrieve the C ucontext_t type.
QualType getRecordType(const RecordDecl *Decl) const
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
bool hasSameExpr(const Expr *X, const Expr *Y) const
Determine whether the given expressions X and Y are equivalent.
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
MangleContext * createMangleContext(const TargetInfo *T=nullptr)
If T is null pointer, assume the target in ASTContext.
QualType getRealTypeForBitwidth(unsigned DestWidth, FloatModeKind ExplicitType) const
getRealTypeForBitwidth - sets floating point QualTy according to specified bitwidth.
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
IdentifierInfo * getBuiltinCommonTypeName() const
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
unsigned getTypeUnadjustedAlign(QualType T) const
Return the ABI-specified natural alignment of a (complete) type T, before alignment adjustments,...
unsigned char getFixedPointIBits(QualType Ty) const
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
bool ObjCQualifiedClassTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS)
ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and Class<pr1, ...>.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
bool propertyTypesAreCompatible(QualType, QualType)
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type.
CanQualType SatLongAccumTy
CanQualType getIntMaxType() const
Return the unique type for "intmax_t" (C99 7.18.1.5), defined in <stdint.h>.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
OpenCLTypeKind getOpenCLTypeKind(const Type *T) const
Map an AST Type to an OpenCLTypeKind enum value.
QualType getFILEType() const
Retrieve the C FILE type.
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, std::string &S) const
Put the string version of the type qualifiers QT into S.
unsigned getPreferredTypeAlign(QualType T) const
Return the "preferred" alignment of the specified type T for the current target, in bits.
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
CanQualType OMPArrayShapingTy
ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents, SelectorTable &sels, Builtin::Context &builtins, TranslationUnitKind TUKind)
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
getObjCEncodingForPropertyDecl - Return the encoded type for this method declaration.
TemplateName getCanonicalTemplateName(TemplateName Name, bool IgnoreDeduced=false) const
Retrieves the "canonical" template name that refers to a given template.
unsigned getStaticLocalNumber(const VarDecl *VD) const
void addComment(const RawComment &RC)
void getLegacyIntegralTypeEncoding(QualType &t) const
getLegacyIntegralTypeEncoding - Another legacy compatibility encoding: 32-bit longs are encoded as 'l...
bool isSameTypeConstraint(const TypeConstraint *XTC, const TypeConstraint *YTC) const
Determine whether two type contraint are similar enough that they could used in declarations of the s...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=RecordDecl::TagKind::Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex, SubstTemplateTypeParmTypeFlag Flag=SubstTemplateTypeParmTypeFlag::None) const
Retrieve a substitution-result type.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getMSGuidType() const
Retrieve the implicitly-predeclared 'struct _GUID' type.
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
CanQualType UnsignedLongFractTy
QualType getEnumType(const EnumDecl *Decl) const
overridden_method_range overridden_methods(const CXXMethodDecl *Method) const
QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const
Return a dependent bit-precise integer type with the specified signedness and bit count.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD, ObjCImplementationDecl *ImplD)
Set the implementation of ObjCInterfaceDecl.
StringRef getCUIDHash() const
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
IdentifierInfo * getMakeIntegerSeqName() const
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT, ObjCInterfaceDecl *IDecl)
QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in QT's qualified-id protocol list adopt...
void addLazyModuleInitializers(Module *M, ArrayRef< GlobalDeclID > IDs)
bool isSameConstraintExpr(const Expr *XCE, const Expr *YCE) const
Determine whether two 'requires' expressions are similar enough that they may be used in re-declarati...
IdentifierInfo * getTypePackElementName() const
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
CanQualType OMPIteratorTy
TemplateName getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex) const
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
QualType getFunctionTypeWithoutPtrSizes(QualType T)
Get a function type and produce the equivalent function type where pointer size address spaces in the...
llvm::iterator_range< overridden_cxx_method_iterator > overridden_method_range
bool isTypeIgnoredBySanitizer(const SanitizerMask &Mask, const QualType &Ty) const
Check if a type can have its sanitizer instrumentation elided based on its presence within an ignorel...
unsigned getMinGlobalAlignOfVar(uint64_t Size, const VarDecl *VD) const
Return the minimum alignement as specified by the target.
RawCommentList Comments
All comments in this translation unit.
bool isSameDefaultTemplateArgument(const NamedDecl *X, const NamedDecl *Y) const
Determine whether two default template arguments are similar enough that they may be used in declarat...
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
QualType getMacroQualifiedType(QualType UnderlyingTy, const IdentifierInfo *MacroII) const
QualType removePtrSizeAddrSpace(QualType T) const
Remove the existing address space on the type if it is a pointer size address space and return the ty...
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
CanQualType SatShortFractTy
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
bool canBindObjCObjectType(QualType To, QualType From)
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
bool hasUniqueObjectRepresentations(QualType Ty, bool CheckIfTriviallyCopyable=true) const
Return true if the specified type has unique object representations according to (C++17 [meta....
bool typesAreBlockPointerCompatible(QualType, QualType)
CanQualType SatUnsignedAccumTy
bool useAbbreviatedThunkName(GlobalDecl VirtualMethodDecl, StringRef MangledName)
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
QualType getSignatureParameterType(QualType T) const
Retrieve the parameter type as adjusted for use in the signature of a function, decaying array and fu...
CanQualType ArraySectionTy
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
CanQualType ObjCBuiltinIdTy
overridden_cxx_method_iterator overridden_methods_end(const CXXMethodDecl *Method) const
VTableContextBase * getVTableContext()
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const
ObjCPropertyImplDecl * getObjCPropertyImplDeclForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
bool isNearlyEmpty(const CXXRecordDecl *RD) const
void cacheRawCommentForDecl(const Decl &OriginalD, const RawComment &Comment) const
Attaches Comment to OriginalD and to its redeclaration chain and removes the redeclaration chain from...
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
void eraseDeclAttrs(const Decl *D)
Erase the attributes corresponding to the given declaration.
UsingEnumDecl * getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst)
If the given using-enum decl Inst is an instantiation of another using-enum decl, return it.
RecordDecl * getCFConstantStringTagDecl() const
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const
Emit the encoded type for the function Decl into S.
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
CanQualType UnsignedFractTy
QualType getjmp_bufType() const
Retrieve the C jmp_buf type.
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
QualType mergeFunctionParameterTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeFunctionParameterTypes - merge two types which appear as function parameter types
QualType getsigjmp_bufType() const
Retrieve the C sigjmp_buf type.
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
CanQualType ObjCBuiltinClassTy
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
CanQualType UnresolvedTemplateTy
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
CanQualType UnsignedLongTy
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl * > &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized,...
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
QualType adjustType(QualType OldType, llvm::function_ref< QualType(QualType)> Adjust) const
Rebuild a type, preserving any existing type sugar.
void addedLocalImportDecl(ImportDecl *Import)
Notify the AST context that a new import declaration has been parsed or implicitly created within thi...
CanQualType UnsignedLongAccumTy
QualType AutoRRefDeductTy
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length.
QualType getCorrespondingSaturatedType(QualType Ty) const
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const
Determine whether the two declarations refer to the same entity.
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl, unsigned Index, bool Final, const TemplateArgument &ArgPack)
Retrieve a.
CanQualType BoundMemberTy
CanQualType SatUnsignedShortFractTy
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
bool hasSameFunctionTypeIgnoringParamABI(QualType T, QualType U) const
Determine if two function types are the same, ignoring parameter ABI annotations.
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
unsigned getOpenMPDefaultSimdAlign(QualType T) const
Get default simd alignment of the specified complete type in bits.
QualType getObjCSuperType() const
Returns the C struct type for objc_super.
QualType getBlockDescriptorType() const
Gets the struct used to keep track of the descriptor for pointer to blocks.
bool CommentsLoaded
True if comments are already loaded from ExternalASTSource.
BlockVarCopyInit getBlockVarCopyInit(const VarDecl *VD) const
Get the copy initialization expression of the VarDecl VD, or nullptr if none exists.
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost
Keep track of CUDA/HIP device-side variables ODR-used by host code.
CanQualType PseudoObjectTy
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
void setTraversalScope(const std::vector< Decl * > &)
CharUnits getTypeUnadjustedAlignInChars(QualType T) const
getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a type, in characters,...
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
unsigned getAlignOfGlobalVar(QualType T, const VarDecl *VD) const
Return the alignment in bits that should be given to a global variable with type T.
TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
MangleContext * createDeviceMangleContext(const TargetInfo &T)
Creates a device mangle context to correctly mangle lambdas in a mixed architecture compile by settin...
CharUnits getExnObjectAlignment() const
Return the alignment (in bytes) of the thrown exception object.
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
ASTMutationListener * Listener
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
CanQualType ObjCBuiltinBoolTy
TypeInfoChars getTypeInfoInChars(const Type *T) const
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
TemplateParamObjectDecl * getTemplateParamObjectDecl(QualType T, const APValue &V) const
Return the template parameter object of the given type with the given value.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
CanQualType OCLClkEventTy
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
const clang::PrintingPolicy & getPrintingPolicy() const
ArrayRef< Module * > getModulesWithMergedDefinition(const NamedDecl *Def)
Get the additional modules in which the definition Def has been merged.
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCImplementationDecl *ID, const ObjCIvarDecl *Ivar) const
Get the offset of an ObjCIvarDecl in bits.
CanQualType SatUnsignedShortAccumTy
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl=nullptr) const
Return the documentation comment attached to a given declaration.
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
const ObjCMethodDecl * getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const
Get the duplicate declaration of a ObjCMethod in the same interface, or null if none exists.
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
QualType getObjCIdType() const
Represents the Objective-CC id type.
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
QualType getFunctionTypeWithoutParamABIs(QualType T) const
Get or construct a function type that is equivalent to the input type except that the parameter ABI a...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
QualType getCorrespondingUnsaturatedType(QualType Ty) const
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage, bool AcceptDependent)
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl) const
unsigned getTargetDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
llvm::DenseMap< CanQualType, SYCLKernelInfo > SYCLKernels
Map of SYCL kernels indexed by the unique type used to name the kernel.
bool isSameTemplateParameterList(const TemplateParameterList *X, const TemplateParameterList *Y) const
Determine whether two template parameter lists are similar enough that they may be used in declaratio...
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
const CXXRecordDecl * baseForVTableAuthentication(const CXXRecordDecl *ThisClass)
Resolve the root record to be used to derive the vtable pointer authentication policy for the specifi...
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CanQualType UnsignedInt128Ty
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class.
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built.
void setManglingNumber(const NamedDecl *ND, unsigned Number)
llvm::DenseMap< const Decl *, const RawComment * > DeclRawComments
Mapping from declaration to directly attached comment.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType UnsignedCharTy
CanQualType UnsignedShortFractTy
BuiltinTemplateDecl * buildBuiltinTemplateDecl(BuiltinTemplateKind BTK, const IdentifierInfo *II) const
void * Allocate(size_t Size, unsigned Align=8) const
bool canBuiltinBeRedeclared(const FunctionDecl *) const
Return whether a declaration to a builtin is allowed to be overloaded/redeclared.
CanQualType UnsignedIntTy
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl * > protocols) const
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, QualType T, std::string &S, bool Extended) const
getObjCEncodingForMethodParameter - Return the encoded type for a single method parameter or return t...
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
unsigned overridden_methods_size(const CXXMethodDecl *Method) const
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const
Return the encoded type for this block declaration.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getExceptionObjectType(QualType T) const
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) const
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl)
ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's protocol list adopt all protocols in Q...
CanQualType UnsignedLongLongTy
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
CanQualType OCLReserveIDTy
bool isSameTemplateParameter(const NamedDecl *X, const NamedDecl *Y) const
Determine whether two template parameters are similar enough that they may be used in declarations of...
void registerSYCLEntryPointFunction(FunctionDecl *FD)
Generates and stores SYCL kernel metadata for the provided SYCL kernel entry point function.
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const
CanQualType UnsignedShortTy
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
void UnwrapSimilarArrayTypes(QualType &T1, QualType &T2, bool AllowPiMismatch=true) const
Attempt to unwrap two types that may both be array types with the same bound (or both be array types ...
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
const SYCLKernelInfo & getSYCLKernelInfo(QualType T) const
Given a type used as a SYCL kernel name, returns a reference to the metadata generated from the corre...
bool canAssignObjCInterfacesInBlockPointer(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT, bool BlockReturnType)
canAssignObjCInterfacesInBlockPointer - This routine is specifically written for providing type-safet...
CanQualType SatUnsignedLongFractTy
const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
RawComment * getRawCommentForDeclNoCache(const Decl *D) const
Return the documentation comment attached to a given declaration, without looking into cache.
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
const VariableArrayType * getAsVariableArrayType(QualType T) const
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
const ObjCInterfaceDecl * getObjContainingInterface(const NamedDecl *ND) const
Returns the Objective-C interface that ND belongs to if it is an Objective-C method/property/ivar etc...
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
bool hasSimilarType(QualType T1, QualType T2) const
Determine if two types are similar, according to the C++ rules.
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
void ResetObjCLayout(const ObjCContainerDecl *CD)
interp::Context & getInterpContext()
Returns the clang bytecode interpreter context.
UnnamedGlobalConstantDecl * getUnnamedGlobalConstantDecl(QualType Ty, const APValue &Value) const
Return a declaration for a uniquified anonymous global constant corresponding to a given APValue.
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
void getOverriddenMethods(const NamedDecl *Method, SmallVectorImpl< const NamedDecl * > &Overridden) const
Return C++ or ObjC overridden methods for the given Method.
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y, bool IgnoreDeduced=false) const
Determine whether the given template names refer to the same template.
CanQualType SatLongFractTy
const TargetInfo & getTargetInfo() const
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
CanQualType SatShortAccumTy
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
CanQualType IncompleteMatrixIdxTy
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
CanQualType getNSIntegerType() const
QualType getCorrespondingUnsignedType(QualType T) const
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index, bool Final) const
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
QualType getHLSLAttributedResourceType(QualType Wrapped, QualType Contained, const HLSLAttributedResourceType::Attributes &Attrs)
bool UnwrapSimilarTypes(QualType &T1, QualType &T2, bool AllowPiMismatch=true) const
Attempt to unwrap two types that may be similar (C++ [conv.qual]).
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
BuiltinTemplateDecl * getTypePackElementDecl() const
CanQualType SatUnsignedLongAccumTy
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
QualType getTypeOfType(QualType QT, TypeOfKind Kind) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes.
QualType getCorrespondingSignedType(QualType T) const
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 'RHS' attributes and ret...
llvm::DenseMap< const Decl *, const Decl * > CommentlessRedeclChains
Keeps track of redeclaration chains that don't have any comment attached.
uint64_t getArrayInitLoopExprElementCount(const ArrayInitLoopExpr *AILE) const
Return number of elements initialized in an ArrayInitLoopExpr.
void deduplicateMergedDefinitonsFor(NamedDecl *ND)
Clean up the merged definition list.
unsigned getTargetAddressSpace(LangAS AS) const
QualType getWideCharType() const
Return the type of wide characters.
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners=true)
Note that the definition ND has been merged into module M, and should be visible whenever M is visibl...
void addTranslationUnitDecl()
void getObjCEncodingForPropertyType(QualType T, std::string &S) const
Emit the Objective-C property type encoding for the given type T into S.
unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet< ObjCProtocolDecl *, 8 > &Protocols)
CollectInheritedProtocols - Collect all protocols in current class and those inherited by it.
bool isPromotableIntegerType(QualType T) const
More type predicates useful for type checking/promotion.
llvm::DenseMap< const Decl *, const Decl * > RedeclChainComments
Mapping from canonical declaration to the first redeclaration in chain that has a comment attached.
CanQualType getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Underlying=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
InlineVariableDefinitionKind getInlineVariableDefinitionKind(const VarDecl *VD) const
Determine whether a definition of this inline variable should be treated as a weak or strong definiti...
CanQualType getUIntMaxType() const
Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in <stdint.h>.
uint16_t getPointerAuthVTablePointerDiscriminator(const CXXRecordDecl *RD)
Return the "other" discriminator used for the pointer auth schema used for vtable pointers in instanc...
CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const
Loading virtual member pointers using the virtual inheritance model always results in an adjustment u...
LangAS getLangASForBuiltinAddressSpace(unsigned AS) const
bool hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U)
Determine whether two function types are the same, ignoring pointer sizes in the return type and para...
unsigned char getFixedPointScale(QualType Ty) const
QualType getIncompleteArrayType(QualType EltTy, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type.
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
QualType DecodeTypeStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequireICE, bool AllowTypeModifiers) const
TemplateName getAssumedTemplateName(DeclarationName Name) const
Retrieve a template name representing an unqualified-id that has been assumed to name a template for ...
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_type
Missing a type.
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
QualType adjustStringLiteralBaseType(QualType StrLTy) const
uint16_t getPointerAuthTypeDiscriminator(QualType T)
Return the "other" type-specific discriminator for the given type.
QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const
C23 feature and GCC extension.
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals) const
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
bool hasCvrSimilarType(QualType T1, QualType T2)
Determine if two types are similar, ignoring only CVR qualifiers.
TemplateName getDeducedTemplateName(TemplateName Underlying, DefaultArguments DefaultArgs) const
Represents a TemplateName which had some of its default arguments deduced.
ObjCImplementationDecl * getObjCImplementation(ObjCInterfaceDecl *D)
Get the implementation of the ObjCInterfaceDecl D, or nullptr if none exists.
CanQualType UnsignedAccumTy
void setObjCMethodRedeclaration(const ObjCMethodDecl *MD, const ObjCMethodDecl *Redecl)
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
QualType getConstantMatrixType(QualType ElementType, unsigned NumRows, unsigned NumColumns) const
Return the unique reference to the matrix type of the specified element type and size.
QualType getVariableArrayDecayedType(QualType Ty) const
Returns a vla type where known sizes are replaced with [*].
bool isInSameModule(const Module *M1, const Module *M2)
If the two module M1 and M2 are in the same module.
void setCFConstantStringType(QualType T)
const SYCLKernelInfo * findSYCLKernelInfo(QualType T) const
Returns a pointer to the metadata generated from the corresponding SYCLkernel entry point if the prov...
unsigned getParameterIndex(const ParmVarDecl *D) const
Used by ParmVarDecl to retrieve on the side the index of the parameter when it exceeds the size of th...
void AddDeallocation(void(*Callback)(void *), void *Data) const
Add a deallocation callback that will be invoked when the ASTContext is destroyed.
AttrVec & getDeclAttrs(const Decl *D)
Retrieve the attributes for the given declaration.
CXXMethodVector::const_iterator overridden_cxx_method_iterator
RawComment * getRawCommentForDeclNoCacheImpl(const Decl *D, const SourceLocation RepresentativeLocForDecl, const std::map< unsigned, RawComment * > &CommentsInFile) const
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
QualType mergeTransparentUnionType(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeTransparentUnionType - if T is a transparent union type and a member of T is compatible with Sub...
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
bool isSentinelNullExpr(const Expr *E)
CanQualType getNSUIntegerType() const
uint64_t getCharWidth() const
Return the size of the character type, in bits.
QualType getBitIntType(bool Unsigned, unsigned NumBits) const
Return a bit-precise integer type with the specified signedness and bit count.
unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
virtual void AddedStaticLocalNumbers(const Decl *D, unsigned Number)
An static local number was added to a Decl.
virtual ~ASTMutationListener()
virtual void RedefinedHiddenDefinition(const NamedDecl *D, Module *M)
A definition has been made visible by being redefined locally.
virtual void AddedManglingNumber(const Decl *D, unsigned Number)
An mangling number was added to a Decl.
virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType)
A function's return type has been deduced.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
CharUnits getAlignment() const
getAlignment - Get the record alignment in characters.
const CXXRecordDecl * getBaseSharingVBPtr() const
CharUnits getSize() const
getSize - Get the record size in characters.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getDataSize() const
getDataSize() - Get the record data size, which is the record size without tail padding,...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
CharUnits getUnadjustedAlignment() const
getUnadjustedAlignment - Get the record alignment in characters, before alignment adjustement.
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
void Profile(llvm::FoldingSetNodeID &ID)
Represents a loop initializing the elements of an array.
llvm::APInt getArraySize() const
Expr * getSubExpr() const
Get the initializer to use for each array element.
Represents a constant array type that does not decay to a pointer when used as a function parameter.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
ArraySizeModifier getSizeModifier() const
Qualifiers getIndexTypeQualifiers() const
QualType getElementType() const
unsigned getIndexTypeCVRQualifiers() const
A structure for storing the information associated with a name that has been assumed to be a template...
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
void Profile(llvm::FoldingSetNodeID &ID)
Attr - This represents one attribute.
An attributed type is a type to which a type attribute has been applied.
void Profile(llvm::FoldingSetNodeID &ID)
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
bool isConstrained() const
void Profile(llvm::FoldingSetNodeID &ID)
A fixed int type of a specified bitwidth.
void Profile(llvm::FoldingSetNodeID &ID) const
unsigned getNumBits() const
Represents a block literal declaration, which is like an unnamed FunctionDecl.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
void Profile(llvm::FoldingSetNodeID &ID)
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
static BuiltinTemplateDecl * Create(const ASTContext &C, DeclContext *DC, DeclarationName Name, BuiltinTemplateKind BTK)
This class is used for builtin types like 'int'.
StringRef getName(const PrintingPolicy &Policy) const
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
const char * getTypeString(unsigned ID) const
Get the type descriptor string for the specified builtin.
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
bool canBeRedeclared(unsigned ID) const
Returns true if this is a builtin that can be redeclared.
bool isNoReturn(unsigned ID) const
Return true if we know this builtin never returns.
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
Implements C++ ABI-specific semantic analysis functions.
Represents a C++ constructor within a class.
Represents a static or instance method of a struct/union/class.
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Represents a C++ struct/union/class.
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
bool isDynamicClass() const
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
SplitQualType split() const
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
QualType withConst() const
Retrieves a version of this type with const applied.
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Qualifiers getQualifiers() const
Retrieve all qualifiers.
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
CharUnits - This is an opaque type for sizes expressed in character units.
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
bool isZero() const
isZero - Test whether the quantity equals zero.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Declaration of a class template.
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this.
Complex values, per C99 6.2.5p11.
QualType getElementType() const
void Profile(llvm::FoldingSetNodeID &ID)
Declaration of a C++20 concept.
ConceptDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool hasExplicitTemplateArgs() const
Whether or not template arguments were explicitly specified in the concept reference (they might not ...
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Represents the canonical version of C arrays with a specified constant size.
const Expr * getSizeExpr() const
Return a pointer to the size expression.
llvm::APInt getSize() const
Return the constant array size as an APInt.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Represents a concrete matrix type with constant number of rows and columns.
unsigned getNumColumns() const
Returns the number of columns in the matrix.
void Profile(llvm::FoldingSetNodeID &ID)
unsigned getNumRows() const
Returns the number of rows in the matrix.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
void Profile(llvm::FoldingSetNodeID &ID)
Represents a pointer type decayed from an array or function type.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
static Decl * castFromDeclContext(const DeclContext *)
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
void setImplicit(bool I=true)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
DeclContext * getDeclContext()
SourceLocation getBeginLoc() const LLVM_READONLY
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
DeclarationNameLoc - Additional source/type location info for a declaration name.
static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc, SourceLocation EndLoc)
Construct location information for a non-literal C++ operator.
The name of a declaration.
static int compare(DeclarationName LHS, DeclarationName RHS)
Represents a ValueDecl that came out of a declarator.
TypeSourceInfo * getTypeSourceInfo() const
Represents the type decltype(expr) (C++11).
Represents a C++17 deduced template specialization type.
void Profile(llvm::FoldingSetNodeID &ID) const
TemplateName getUnderlying() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const
DefaultArguments getDefaultArguments() const
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Represents an extended address space qualifier where the input address space value is dependent.
Expr * getAddrSpaceExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Internal representation of canonical, dependent decltype(expr) types.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Represents a qualified type name for which the type name is dependent.
void Profile(llvm::FoldingSetNodeID &ID)
Represents an array type in C++ whose size is a value-dependent expression.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Expr * getSizeExpr() const
Represents an extended vector type where either the type or size is dependent.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Represents a matrix type where the type and the number of rows and columns is dependent on a template...
Expr * getRowExpr() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Represents a dependent template name that cannot be resolved prior to template instantiation.
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
void Profile(llvm::FoldingSetNodeID &ID)
Represents a template specialization type whose template cannot be resolved, e.g.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Internal representation of canonical, dependent typeof(expr) types.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Represents a vector type where either the type or size is dependent.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
Represents a type that was referred to using an elaborated type keyword, e.g., struct S,...
void Profile(llvm::FoldingSetNodeID &ID)
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
bool isComplete() const
Returns true if this can be considered a complete type.
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
EnumDecl * getDecl() const
This represents one expression.
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifi...
void Profile(llvm::FoldingSetNodeID &ID) const
ExtVectorType - Extended vector type.
Declaration context for names declared as extern "C" in C++.
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
Abstract interface for external sources of AST nodes.
virtual ExtKind hasExternalDefinitions(const Decl *D)
virtual void ReadComments()
Loads comment ranges.
virtual void CompleteRedeclChain(const Decl *D)
Gives the external AST source an opportunity to complete the redeclaration chain for a declaration.
virtual void PrintStats()
Print any statistics that have been gathered regarding the external AST source.
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getBitWidthValue() const
Computes the bit width of this field, if this is a bit field.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a function declaration or definition.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool isMSExternInline() const
The combination of the extern and inline keywords under MSVC forces the function to be required.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Represents an abstract function effect, using just an enumeration describing its kind.
An immutable set of FunctionEffects and possibly conditions attached to them.
ArrayRef< EffectConditionExpr > conditions() const
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
void Profile(llvm::FoldingSetNodeID &ID)
Represents a prototype with parameter type info, e.g.
ExtParameterInfo getExtParameterInfo(unsigned I) const
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
unsigned getNumParams() const
QualType getParamType(unsigned i) const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
bool isVariadic() const
Whether this function prototype is variadic.
ExtProtoInfo getExtProtoInfo() const
ArrayRef< QualType > getParamTypes() const
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Declaration of a template function.
A class which abstracts out some details necessary for making a call.
CallingConv getCC() const
bool getNoCfCheck() const
unsigned getRegParm() const
bool getNoCallerSavedRegs() const
ExtInfo withNoReturn(bool noReturn) const
bool getHasRegParm() const
bool getProducesResult() const
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
ExtParameterInfo withIsNoEscape(bool NoEscape) const
FunctionType - C99 6.7.5.3 - Function Declarators.
ExtInfo getExtInfo() const
QualType getReturnType() const
GlobalDecl - represents a global declaration.
unsigned getMultiVersionIndex() const
CXXDtorType getDtorType() const
const Decl * getDecl() const
QualType getWrappedType() const
const Attributes & getAttrs() const
QualType getContainedType() const
void Profile(llvm::FoldingSetNodeID &ID)
One of these records is kept for each identifier that is lexed.
unsigned getLength() const
Efficiently return the length of this identifier info.
StringRef getName() const
Return the actual identifier string.
Implements an efficient mapping from strings to IdentifierInfo nodes.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Represents a C array with an unspecified size.
void Profile(llvm::FoldingSetNodeID &ID)
The injected class name of a C++ class template or class template partial specialization.
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)
@ Relative
Components in the vtable are relative offsets between the vtable and the other structs/functions.
@ Pointer
Components in the vtable are pointers to other structs/functions.
An lvalue reference type, per C++11 [dcl.ref].
@ Swift
Interoperability with the latest known version of the Swift runtime.
@ Swift4_2
Interoperability with the Swift 4.2 runtime.
@ Swift4_1
Interoperability with the Swift 4.1 runtime.
@ Integer
Permit vector bitcasts between integer vectors with different numbers of elements but the same total ...
@ All
Permit vector bitcasts between all vectors with the same total bit-width.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
std::optional< TargetCXXABI::Kind > CXXABI
C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
CommentOptions CommentOpts
Options for parsing comments.
std::string CUID
The user provided compilation unit ID, if non-empty.
static void Profile(llvm::FoldingSetNodeID &ID, Parts P)
Sugar type that represents a type that was qualified by a qualifier written as a macro invocation.
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
QualType getElementType() const
Returns type of the elements being stored in the matrix.
static bool isValidElementType(QualType T)
Valid elements types are the following:
A pointer to member type per C++ 8.3.3 - Pointers to members.
void Profile(llvm::FoldingSetNodeID &ID)
QualType getPointeeType() const
const Type * getClass() const
Provides information a specialization of a member of a class template, which may be a member function...
static MicrosoftMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)
Describes a module or submodule.
bool isNamedModule() const
Does this Module is a named module of a standard named module?
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isPlaceholderVar(const LangOptions &LangOpts) const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
bool isExternallyVisible() const
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Represent a C++ namespace.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, const IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
@ TypeSpec
A type, stored as a Type*.
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Identifier
An identifier, stored as an IdentifierInfo*.
@ Global
The global specifier '::'. There is no stored value.
@ Namespace
A namespace, stored as a NamespaceDecl*.
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, const IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
ObjCCategoryDecl - Represents a category declaration.
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
ObjCContainerDecl - Represents a container for method declarations.
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
static ObjCInterfaceDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation atLoc, const IdentifierInfo *Id, ObjCTypeParamList *typeParamList, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc=SourceLocation(), bool isInternal=false)
bool hasDefinition() const
Determine whether this class has been defined.
bool ClassImplementsProtocol(ObjCProtocolDecl *lProto, bool lookupCategory, bool RHSIsQualifiedID=false)
ClassImplementsProtocol - Checks that 'lProto' protocol has been implemented in IDecl class,...
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class's metadata.
ObjCImplementationDecl * getImplementation() const
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
ObjCInterfaceDecl * getSuperClass() const
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
known_extensions_range known_extensions() const
Interfaces are the core concept in Objective-C for object oriented design.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarDecl * getNextIvar()
ObjCMethodDecl - Represents an instance or class method declaration.
ObjCDeclQualifier getObjCDeclQualifier() const
unsigned param_size() const
param_const_iterator param_end() const
param_const_iterator param_begin() const
const ParmVarDecl *const * param_const_iterator
Selector getSelector() const
bool isInstanceMethod() const
QualType getReturnType() const
Represents a pointer to an Objective C object.
bool isObjCQualifiedClassType() const
True if this is equivalent to 'Class.
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
void Profile(llvm::FoldingSetNodeID &ID)
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of...
void Profile(llvm::FoldingSetNodeID &ID)
Represents a class type in Objective C.
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
bool isObjCQualifiedClass() const
QualType getBaseType() const
Gets the base type of this object type.
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
bool isObjCQualifiedId() const
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
bool isObjCUnqualifiedId() const
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface.
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Represents one property declaration in an Objective-C interface.
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
SetterKind getSetterKind() const
getSetterKind - Return the method used for doing assignment in the property setter.
Selector getSetterName() const
Selector getGetterName() const
ObjCPropertyAttribute::Kind getPropertyAttributes() const
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
ObjCIvarDecl * getPropertyIvarDecl() const
Represents an Objective-C protocol declaration.
protocol_range protocols() const
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
qual_iterator qual_end() const
qual_iterator qual_begin() const
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
Represents the declaration of an Objective-C type parameter.
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Represents a type parameter type in Objective C.
void Profile(llvm::FoldingSetNodeID &ID)
A structure for storing the information associated with an overloaded template name.
Represents a C++11 pack expansion that produces a sequence of expressions.
Represents a pack expansion of types.
void Profile(llvm::FoldingSetNodeID &ID)
void Profile(llvm::FoldingSetNodeID &ID)
Sugar for parentheses used when specifying types.
void Profile(llvm::FoldingSetNodeID &ID)
void clear()
Clear parent maps.
Represents a parameter to a function.
ObjCDeclQualifier getObjCDeclQualifier() const
QualType getOriginalType() const
ParsedAttr - Represents a syntactic attribute.
void Profile(llvm::FoldingSetNodeID &ID)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
void Profile(llvm::FoldingSetNodeID &ID)
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
bool hasQualifiers() const
Determine whether this type has any qualifiers.
QualType withConst() const
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
bool isConstQualified() const
Determine whether this type is const-qualified.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
const Type * getTypePtrOrNull() const
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Represents a template name as written in source code.
void Profile(llvm::FoldingSetNodeID &ID)
A qualifier set is used to build a set of qualifiers.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
The collection of all-type qualifiers we support.
unsigned getCVRQualifiers() const
void removeCVRQualifiers(unsigned mask)
void addAddressSpace(LangAS space)
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
@ OCL_Weak
Reading or writing from this object requires a barrier call.
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
void removeObjCLifetime()
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated.
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
void removeFastQualifiers(unsigned mask)
bool hasUnaligned() const
bool hasAddressSpace() const
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
unsigned getFastQualifiers() const
void removeAddressSpace()
void setAddressSpace(LangAS space)
bool hasObjCGCAttr() const
uint64_t getAsOpaqueValue() const
bool hasObjCLifetime() const
ObjCLifetime getObjCLifetime() const
void addObjCGCAttr(GC type)
LangAS getAddressSpace() const
An rvalue reference type, per C++11 [dcl.ref].
Represents a struct/union/class.
bool hasFlexibleArrayMember() const
field_range fields() const
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
virtual void completeDefinition()
Note that the definition of this type is now complete.
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Base for LValueReferenceType and RValueReferenceType.
QualType getPointeeType() const
void Profile(llvm::FoldingSetNodeID &ID)
This table allows us to fully hide how we implement multi-keyword caching.
std::string getAsString() const
Derive the full selector name (e.g.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
DiagnosticsEngine & getDiagnostics() const
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID.
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
StringLiteral - This represents a string literal expression, e.g.
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
A structure for storing an already-substituted template template parameter pack.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
void Profile(llvm::FoldingSetNodeID &ID, ASTContext &Context)
TemplateTemplateParmDecl * getParameterPack() const
Retrieve the template template parameter pack being substituted.
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
A structure for storing the information associated with a substituted template template parameter.
void Profile(llvm::FoldingSetNodeID &ID)
TemplateTemplateParmDecl * getParameter() const
Represents the result of substituting a set of types for a template type parameter pack.
void Profile(llvm::FoldingSetNodeID &ID)
Represents the result of substituting a type for a template type parameter.
void Profile(llvm::FoldingSetNodeID &ID)
Represents the declaration of a struct/union/class/enum.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
TagDecl * getDecl() const
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Kind
The basic C++ ABI kind.
static Kind getKind(StringRef Name)
Exposes information about the current target.
TargetOptions & getTargetOpts() const
Retrieve the target options.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
IntType getInt64Type() const
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
virtual LangAS getCUDABuiltinAddressSpace(unsigned AS) const
Map from the address space field in builtin description strings to the language address space.
virtual LangAS getOpenCLBuiltinAddressSpace(unsigned AS) const
Map from the address space field in builtin description strings to the language address space.
unsigned getDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
unsigned getBFloat16Width() const
getBFloat16Width/Align/Format - Return the size/align/format of '__bf16'.
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
@ AArch64ABIBuiltinVaList
__builtin_va_list as defined by the AArch64 ABI http://infocenter.arm.com/help/topic/com....
@ PNaClABIBuiltinVaList
__builtin_va_list as defined by the PNaCl ABI: http://www.chromium.org/nativeclient/pnacl/bitcode-abi...
@ PowerABIBuiltinVaList
__builtin_va_list as defined by the Power ABI: https://www.power.org /resources/downloads/Power-Arch-...
@ AAPCSABIBuiltinVaList
__builtin_va_list as defined by ARM AAPCS ABI http://infocenter.arm.com
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
@ VoidPtrBuiltinVaList
typedef void* __builtin_va_list;
@ X86_64ABIBuiltinVaList
__builtin_va_list as defined by the x86-64 ABI: http://refspecs.linuxbase.org/elf/x86_64-abi-0....
virtual uint64_t getNullPointerValue(LangAS AddrSpace) const
Get integer value for null pointer.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
unsigned getHalfAlign() const
unsigned getBFloat16Align() const
FloatModeKind getRealTypeByWidth(unsigned BitWidth, FloatModeKind ExplicitType) const
Return floating point type with specified width.
virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return integer type with specified width.
unsigned getHalfWidth() const
getHalfWidth/Align/Format - Return the size/align/format of 'half'.
unsigned getMaxAlignedAttribute() const
Get the maximum alignment in bits for a static variable with aligned attribute.
virtual unsigned getMinGlobalAlign(uint64_t Size, bool HasNonWeakDef) const
getMinGlobalAlign - Return the minimum alignment of a global variable, unless its alignment is explic...
unsigned getTargetAddressSpace(LangAS AS) const
unsigned getFloat128Width() const
getFloat128Width/Align/Format - Return the size/align/format of '__float128'.
const llvm::fltSemantics & getLongDoubleFormat() const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool hasAArch64SVETypes() const
Returns whether or not the AArch64 SVE built-in types are available on this target.
bool useAddressSpaceMapMangling() const
Specify if mangling based on address space map should be used or not for language specific address sp...
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
unsigned getFloat128Align() const
virtual bool hasBFloat16Type() const
Determine whether the _BFloat16 type is supported on this target.
const llvm::fltSemantics & getFloat128Format() const
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of 'long double'.
unsigned getLongDoubleAlign() const
virtual std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const
Returns target-specific min and max values VScale_Range.
llvm::StringMap< bool > FeatureMap
The map of which features have been enabled disabled based on the command line.
A convenient class for passing around template argument information.
SourceLocation getRAngleLoc() const
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
SourceLocation getLAngleLoc() const
A template argument list.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
std::optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce,...
QualType getAsType() const
Retrieve the type for a type template argument.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
bool structurallyEquals(const TemplateArgument &Other) const
Determines whether two template arguments are superficially the same.
QualType getIntegralType() const
Retrieve the type of the integral value.
bool getIsDefaulted() const
If returns 'true', this TemplateArgument corresponds to a default template parameter.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
The base class of all kinds of template declarations (e.g., class, function, etc.).
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Represents a C++ template name within the type system.
TemplateDecl * getAsTemplateDecl(bool IgnoreDeduced=false) const
Retrieve the underlying template declaration that this template name refers to, if known.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
@ UsingTemplate
A template name that refers to a template declaration found through a specific using shadow declarati...
@ OverloadedTemplate
A set of overloaded template declarations.
@ Template
A single template declaration.
@ DependentTemplate
A dependent template name that has not been resolved to a template (or set of templates).
@ SubstTemplateTemplateParm
A template template parameter that has been substituted for some other template name.
@ SubstTemplateTemplateParmPack
A template template parameter pack that has been substituted for a template template argument pack,...
@ DeducedTemplate
A template name that refers to another TemplateName with deduced default arguments.
@ QualifiedTemplate
A qualified template name, where the qualification is kept to describe the source code as written.
@ AssumedTemplate
An unqualified-id that has been assumed to name a function template that will be found by ADL.
A template parameter object.
static void Profile(llvm::FoldingSetNodeID &ID, QualType T, const APValue &V)
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Expr * getRequiresClause()
The constraint-expression of the associated requires-clause.
ArrayRef< NamedDecl * > asArray()
unsigned getNumArgs() const
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
void setTemplateKeywordLoc(SourceLocation Loc)
void setTemplateNameLoc(SourceLocation Loc)
void setLAngleLoc(SourceLocation Loc)
void setRAngleLoc(SourceLocation Loc)
Represents a type template specialization; the template must be a class template, a type alias templa...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
unsigned getDepth() const
Get the nesting depth of the template parameter.
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, bool Typename, TemplateParameterList *Params)
Declaration of a template type parameter.
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, std::optional< unsigned > NumExpanded=std::nullopt)
void Profile(llvm::FoldingSetNodeID &ID)
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
ConceptDecl * getNamedConcept() const
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
ConceptReference * getConceptReference() const
Represents a declaration of a type.
void setTypeForDecl(const Type *TD)
const Type * getTypeForDecl() const
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
static unsigned getFullDataSizeForType(QualType Ty)
Returns the size of type source info data block for the given type.
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location.
Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expre...
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
bool isFunctionReferenceType() const
bool isObjCBuiltinType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isIncompleteArrayType() const
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isConstantArrayType() const
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
bool isFunctionPointerType() const
bool isPointerType() const
bool isArrayParameterType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isEnumeralType() const
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
bool isObjCQualifiedIdType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e....
QualType getSveEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an SVE builtin type.
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
bool isBuiltinType() const
Helper methods to distinguish type categories.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
QualType getCanonicalTypeInternal() const
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isMemberPointerType() const
bool isObjCIdType() const
bool isUnsaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isFunctionType() const
bool isObjCObjectPointerType() const
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
bool isVectorType() const
bool isObjCClassType() const
bool isRVVVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'riscv_rvv_vector_bits' type attribute,...
bool isRVVSizelessBuiltinType() const
Returns true for RVV scalable vector types.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
bool isAnyPointerType() const
TypeClass getTypeClass() const
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
const T * getAs() const
Member-template getAs<specific type>'.
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
bool isNullPtrType() const
bool isRecordType() const
bool isObjCRetainableType() const
std::optional< NullabilityKind > getNullability() const
Determine the nullability of the given type.
Represents the declaration of a typedef-name via the 'typedef' type specifier.
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Base class for declarations which introduce a typedef-name.
QualType getUnderlyingType() const
void setTypeSourceInfo(TypeSourceInfo *newType)
void Profile(llvm::FoldingSetNodeID &ID)
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
static void Profile(llvm::FoldingSetNodeID &ID, QualType Ty, const APValue &APVal)
The iterator over UnresolvedSets.
Represents the dependent type named by a dependently-scoped typename using declaration,...
Represents a dependent using declaration which was marked with typename.
Represents a C++ using-enum-declaration.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
void Profile(llvm::FoldingSetNodeID &ID)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Represents a variable declaration or definition.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
bool isStaticDataMember() const
Determines whether this is a static data member.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
bool isInline() const
Whether this variable is (C++1z) inline.
@ DeclarationOnly
This declaration is only a declaration.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Represents a C array with a specified size that is not an integer-constant-expression.
Expr * getSizeExpr() const
Represents a GCC generic vector type.
unsigned getNumElements() const
void Profile(llvm::FoldingSetNodeID &ID)
VectorKind getVectorKind() const
QualType getElementType() const
Holds all information required to evaluate constexpr code in a module.
Defines the Linkage enumeration and various utility functions.
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
const AstTypeMatcher< TagType > tagType
Matches tag types (record and enum types).
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
GVALinkage
A more specific kind of linkage than enum Linkage.
@ GVA_AvailableExternally
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
OpenCLTypeKind
OpenCL type kinds.
FunctionType::ExtInfo getFunctionExtInfo(const Type &t)
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
NullabilityKind
Describes the nullability of a particular type.
@ Nullable
Values of this type can be null.
@ Unspecified
Whether values of this type can be null is (explicitly) unspecified.
@ NonNull
Values of this type can never be null.
@ ICIS_NoInit
No in-class initializer.
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
TypeOfKind
The kind of 'typeof' expression we're after.
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
@ Result
The result type of a method or function.
ArraySizeModifier
Capture whether this is a normal array (e.g.
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
SubstTemplateTypeParmTypeFlag
TagTypeKind
The kind of a tag type.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
bool isDiscardableGVALinkage(GVALinkage L)
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
@ BTK__type_pack_element
This names the __type_pack_element BuiltinTemplateDecl.
@ BTK__builtin_common_type
This names the __builtin_common_type BuiltinTemplateDecl.
@ BTK__make_integer_seq
This names the __make_integer_seq BuiltinTemplateDecl.
LangAS
Defines the address space values used by the address space qualifier of QualType.
TranslationUnitKind
Describes the kind of translation unit being processed.
bool isPtrSizeAddressSpace(LangAS AS)
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ Invariant
The parameter is invariant: must match exactly.
@ Contravariant
The parameter is contravariant, e.g., X<T> is a subtype of X when the type parameter is covariant and...
@ Covariant
The parameter is covariant, e.g., X<T> is a subtype of X when the type parameter is covariant and T i...
@ AltiVecBool
is AltiVec 'vector bool ...'
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
@ AltiVecPixel
is AltiVec 'vector Pixel'
@ Generic
not a target-specific vector type
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
LangAS getLangASFromTargetAS(unsigned TargetAS)
@ None
The alignment was not explicit in code.
@ RequiredByEnum
The alignment comes from an alignment attribute on a enum type.
@ RequiredByTypedef
The alignment comes from an alignment attribute on a typedef.
@ RequiredByRecord
The alignment comes from an alignment attribute on a record type.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
@ None
No keyword precedes the qualified type name.
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
Diagnostic wrappers for TextAPI types for error reporting.
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Copy initialization expr of a __block variable and a boolean flag that indicates whether the expressi...
Expr * getCopyExpr() const
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
ArrayRef< TemplateArgument > Args
Holds information about the various types of exception specification.
ExceptionSpecificationType Type
The kind of exception specification this is.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Extra information about a function prototype.
ExceptionSpecInfo ExceptionSpec
bool requiresFunctionProtoTypeArmAttributes() const
FunctionEffectsRef FunctionEffects
const ExtParameterInfo * ExtParameterInfos
RefQualifierKind RefQualifier
unsigned HasTrailingReturn
bool requiresFunctionProtoTypeExtraBitfields() const
FunctionType::ExtInfo ExtInfo
A simple holder for a QualType representing a type in an exception specification.
A holder for Arm type attributes as described in the Arm C/C++ Language extensions which are not part...
A lazy value (of type T) that is within an AST node of type Owner, where the value might change in la...
Parts of a decomposed MSGuidDecl.
Contains information gathered from parsing the contents of TargetAttr.
Describes how types, statements, expressions, and declarations should be printed.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
const Type * Ty
The locally-unqualified type.
Qualifiers Quals
The local qualifiers.
A this pointer adjustment.
IntType
===-— Target Data Type Query Methods ----------------------------—===//
AlignRequirementKind AlignRequirement
AlignRequirementKind AlignRequirement
static bool isEqual(const FoldingSetNodeID &LHS, const FoldingSetNodeID &RHS)
static FoldingSetNodeID getTombstoneKey()
static FoldingSetNodeID getEmptyKey()
static unsigned getHashValue(const FoldingSetNodeID &Val)