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/None.h"
75 #include "llvm/ADT/Optional.h"
76 #include "llvm/ADT/PointerUnion.h"
77 #include "llvm/ADT/STLExtras.h"
78 #include "llvm/ADT/SmallPtrSet.h"
79 #include "llvm/ADT/SmallVector.h"
80 #include "llvm/ADT/StringExtras.h"
81 #include "llvm/ADT/StringRef.h"
82 #include "llvm/ADT/Triple.h"
83 #include "llvm/Support/Capacity.h"
84 #include "llvm/Support/Casting.h"
85 #include "llvm/Support/Compiler.h"
86 #include "llvm/Support/ErrorHandling.h"
87 #include "llvm/Support/MD5.h"
88 #include "llvm/Support/MathExtras.h"
89 #include "llvm/Support/raw_ostream.h"
101 using namespace clang;
125 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
130 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
131 if (VD->isStaticDataMember() &&
136 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
141 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
148 if (
const auto *ED = dyn_cast<EnumDecl>(D)) {
152 if (
const auto *TD = dyn_cast<TagDecl>(D)) {
155 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
159 if (isa<ParmVarDecl>(D))
164 if (isa<TemplateTypeParmDecl>(D) ||
165 isa<NonTypeTemplateParmDecl>(D) ||
166 isa<TemplateTemplateParmDecl>(D))
175 if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
176 isa<ObjCPropertyDecl>(D) ||
177 isa<RedeclarableTemplateDecl>(D) ||
178 isa<ClassTemplateSpecializationDecl>(D) ||
185 if (isa<TypedefDecl>(D)) {
192 if (
const auto *TD = dyn_cast<TagDecl>(D)) {
208 const std::map<unsigned, RawComment *> &CommentsInTheFile)
const {
211 if (RepresentativeLocForDecl.
isInvalid() ||
212 !RepresentativeLocForDecl.
isFileID())
216 if (CommentsInTheFile.empty())
221 const std::pair<FileID, unsigned> DeclLocDecomp =
225 auto OffsetCommentBehindDecl =
226 CommentsInTheFile.lower_bound(DeclLocDecomp.second);
229 if (OffsetCommentBehindDecl != CommentsInTheFile.end()) {
230 RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second;
234 (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
235 isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
239 if (SourceMgr.
getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) ==
241 OffsetCommentBehindDecl->first)) {
242 return CommentBehindDecl;
249 if (OffsetCommentBehindDecl == CommentsInTheFile.begin())
252 auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl;
253 RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second;
262 const unsigned CommentEndOffset =
266 bool Invalid =
false;
267 const char *Buffer = SourceMgr.
getBufferData(DeclLocDecomp.first,
273 StringRef
Text(Buffer + CommentEndOffset,
274 DeclLocDecomp.second - CommentEndOffset);
278 if (
Text.find_first_of(
";{}#@") != StringRef::npos)
281 return CommentBeforeDecl;
302 if (!CommentsInThisFile || CommentsInThisFile->empty())
309 assert(LangOpts.RetainCommentsFromSystemHeaders ||
318 if (
const auto *FD = dyn_cast<FunctionDecl>(&D)) {
338 if (
const auto *VD = dyn_cast<VarDecl>(&D)) {
341 if (VD->isStaticDataMember())
347 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(&D)) {
354 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
362 : *
static_cast<const Decl *
>(
368 CRD->getMemberSpecializationInfo())
369 return *Info->getInstantiatedFrom();
373 if (
const auto *ED = dyn_cast<EnumDecl>(&D)) {
386 const Decl **OriginalDecl)
const {
389 OriginalDecl =
nullptr;
401 return DeclComment->second;
414 *OriginalDecl = RedeclComment->second;
417 "This decl is supposed to have comment attached.");
418 return CommentAtRedecl->second;
424 auto LastCheckedRedecl = [
this, CanonicalD]() ->
const Decl * {
427 return LookupRes->second;
431 for (
const auto Redecl : D->
redecls()) {
434 if (LastCheckedRedecl) {
435 if (LastCheckedRedecl == Redecl) {
436 LastCheckedRedecl =
nullptr;
444 *OriginalDecl = Redecl;
445 return RedeclComment;
451 *OriginalDecl =
nullptr;
467 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
472 for (
const auto *Ext :
ID->known_extensions()) {
476 Redeclared.push_back(RedeclaredMethod);
487 for (
Decl *D : Decls) {
497 if (
File.isInvalid())
501 if (!CommentsInThisFile || CommentsInThisFile->empty() ||
502 CommentsInThisFile->rbegin()->second->isAttached())
513 for (
const Decl *D : Decls) {
515 if (D->isInvalidDecl())
538 const Decl *D)
const {
541 ThisDeclInfo->IsFilled =
false;
542 ThisDeclInfo->fill();
543 ThisDeclInfo->CommentDecl = FC->
getDecl();
544 if (!ThisDeclInfo->TemplateParameters)
554 return RC ? RC->
parse(*
this,
nullptr, D) :
nullptr;
565 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
569 if (Canonical != D) {
577 const Decl *OriginalDecl =
nullptr;
581 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
583 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
584 if (OMD && OMD->isPropertyAccessor())
591 for (
unsigned i = 0, e = Overridden.size(); i < e; i++)
595 else if (
const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
598 QualType QT = TD->getUnderlyingType();
600 if (
const Decl *TD = TT->getDecl())
604 else if (
const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
605 while (IC->getSuperClass()) {
606 IC = IC->getSuperClass();
611 else if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
616 else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
617 if (!(RD = RD->getDefinition()))
620 for (
const auto &I : RD->bases()) {
621 if (I.isVirtual() || (I.getAccessSpecifier() !=
AS_public))
627 if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
635 for (
const auto &I : RD->vbases()) {
642 if (!(VirtualBase= VirtualBase->getDefinition()))
656 if (D != OriginalDecl && OriginalDecl)
665 ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &
ID,
673 ID.AddInteger(Params->
size());
675 PEnd = Params->
end();
677 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*
P)) {
679 ID.AddBoolean(TTP->isParameterPack());
681 ID.AddBoolean(TC !=
nullptr);
685 if (TTP->isExpandedParameterPack()) {
687 ID.AddInteger(TTP->getNumExpansionParameters());
689 ID.AddBoolean(
false);
693 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
695 ID.AddBoolean(NTTP->isParameterPack());
696 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
697 if (NTTP->isExpandedParameterPack()) {
699 ID.AddInteger(NTTP->getNumExpansionTypes());
700 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
701 QualType T = NTTP->getExpansionType(I);
705 ID.AddBoolean(
false);
709 auto *TTP = cast<TemplateTemplateParmDecl>(*
P);
714 ID.AddBoolean(RequiresClause !=
nullptr);
730 if (
const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))
731 CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());
733 CSE = cast<ConceptSpecializationExpr>(IDC);
736 NewConverted.reserve(OldConverted.size());
741 NewConverted.push_back(ConstrainedType);
742 llvm::append_range(NewConverted,
743 OldConverted.front().pack_elements().drop_front(1));
746 NewConverted.clear();
747 NewConverted.push_back(NewPack);
748 assert(OldConverted.size() == 1 &&
749 "Template parameter pack should be the last parameter");
752 "Unexpected first argument kind for immediately-declared "
754 NewConverted.push_back(ConstrainedType);
755 llvm::append_range(NewConverted, OldConverted.drop_front(1));
761 if (
auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))
770 ASTContext::getCanonicalTemplateTemplateParmDecl(
773 llvm::FoldingSetNodeID
ID;
774 CanonicalTemplateTemplateParm::Profile(
ID, *
this, TTP);
775 void *InsertPos =
nullptr;
776 CanonicalTemplateTemplateParm *Canonical
777 = CanonTemplateTemplateParms.FindNodeOrInsertPos(
ID, InsertPos);
779 return Canonical->getParam();
784 CanonParams.reserve(Params->
size());
786 PEnd = Params->
end();
788 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*
P)) {
795 if (
const auto *TC = TTP->getTypeConstraint()) {
802 for (
const auto &ArgLoc : Args->arguments())
814 CanonParams.push_back(NewTTP);
815 }
else if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
819 if (NTTP->isExpandedParameterPack()) {
822 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
824 ExpandedTInfos.push_back(
832 NTTP->getPosition(),
nullptr,
842 NTTP->getPosition(),
nullptr,
844 NTTP->isParameterPack(),
848 if (AT->isConstrained()) {
851 *
this, NTTP->getPlaceholderTypeConstraint(), T));
854 CanonParams.push_back(Param);
857 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
858 cast<TemplateTemplateParmDecl>(*
P)));
861 Expr *CanonRequiresClause =
nullptr;
863 CanonRequiresClause = RequiresClause;
875 CanonRequiresClause));
878 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(
ID, InsertPos);
879 assert(!Canonical &&
"Shouldn't be in the map!");
883 Canonical =
new (*this) CanonicalTemplateTemplateParm(CanonTTP);
884 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
894 if (!LangOpts.CPlusPlus)
return nullptr;
897 case TargetCXXABI::AppleARM64:
898 case TargetCXXABI::Fuchsia:
899 case TargetCXXABI::GenericARM:
900 case TargetCXXABI::iOS:
901 case TargetCXXABI::WatchOS:
902 case TargetCXXABI::GenericAArch64:
903 case TargetCXXABI::GenericMIPS:
904 case TargetCXXABI::GenericItanium:
905 case TargetCXXABI::WebAssembly:
906 case TargetCXXABI::XL:
908 case TargetCXXABI::Microsoft:
911 llvm_unreachable(
"Invalid CXXABI type!");
915 if (!InterpContext) {
918 return *InterpContext.get();
924 return *ParentMapCtx.get();
929 if (LOpts.FakeAddressSpaceMap) {
932 static const unsigned FakeAddrSpaceMap[] = {
953 return &FakeAddrSpaceMap;
961 switch (LangOpts.getAddressSpaceMapMangling()) {
969 llvm_unreachable(
"getAddressSpaceMapMangling() doesn't cover anything.");
975 : ConstantArrayTypes(this_(), ConstantArrayTypesLog2InitSize),
976 FunctionProtoTypes(this_(), FunctionProtoTypesLog2InitSize),
977 TemplateSpecializationTypes(this_()),
978 DependentTemplateSpecializationTypes(this_()), AutoTypes(this_()),
979 SubstTemplateTemplateParmPacks(this_()),
980 CanonTemplateTemplateParms(this_()), SourceMgr(
SM), LangOpts(LOpts),
983 LangOpts.XRayNeverInstrumentFiles,
984 LangOpts.XRayAttrListFiles,
SM)),
987 BuiltinInfo(builtins), TUKind(TUKind), DeclarationNames(*this),
988 Comments(
SM), CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
989 CompCategories(this_()), LastSDM(nullptr, 0) {
996 ReleaseDeclContextMaps();
999 for (
auto &Pair : Deallocations)
1000 (Pair.first)(Pair.second);
1001 Deallocations.clear();
1007 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
1011 ObjCLayouts.clear();
1013 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
1014 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
1019 ASTRecordLayouts.clear();
1021 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
1022 AEnd = DeclAttrs.end();
1024 A->second->~AttrVec();
1027 for (
const auto &
Value : ModuleInitializers)
1028 Value.second->~PerModuleInitializers();
1029 ModuleInitializers.clear();
1035 TraversalScope = TopLevelDecls;
1040 Deallocations.push_back({Callback, Data});
1049 llvm::errs() <<
"\n*** AST Context Stats:\n";
1050 llvm::errs() <<
" " << Types.size() <<
" types total.\n";
1052 unsigned counts[] = {
1053 #define TYPE(Name, Parent) 0,
1054 #define ABSTRACT_TYPE(Name, Parent)
1055 #include "clang/AST/TypeNodes.inc"
1059 for (
unsigned i = 0, e = Types.size(); i != e; ++i) {
1065 unsigned TotalBytes = 0;
1066 #define TYPE(Name, Parent) \
1068 llvm::errs() << " " << counts[Idx] << " " << #Name \
1069 << " types, " << sizeof(Name##Type) << " each " \
1070 << "(" << counts[Idx] * sizeof(Name##Type) \
1072 TotalBytes += counts[Idx] * sizeof(Name##Type); \
1074 #define ABSTRACT_TYPE(Name, Parent)
1075 #include "clang/AST/TypeNodes.inc"
1077 llvm::errs() <<
"Total bytes = " << TotalBytes <<
"\n";
1082 <<
" implicit default constructors created\n";
1085 <<
" implicit copy constructors created\n";
1089 <<
" implicit move constructors created\n";
1092 <<
" implicit copy assignment operators created\n";
1096 <<
" implicit move assignment operators created\n";
1099 <<
" implicit destructors created\n";
1102 llvm::errs() <<
"\n";
1106 BumpAlloc.PrintStats();
1110 bool NotifyListeners) {
1111 if (NotifyListeners)
1120 if (It == MergedDefModules.end())
1123 auto &Merged = It->second;
1125 for (
Module *&M : Merged)
1126 if (!Found.insert(M).second)
1128 llvm::erase_value(Merged,
nullptr);
1135 if (MergedIt == MergedDefModules.end())
1137 return MergedIt->second;
1140 void ASTContext::PerModuleInitializers::resolve(
ASTContext &Ctx) {
1141 if (LazyInitializers.empty())
1145 assert(Source &&
"lazy initializers but no external source");
1147 auto LazyInits = std::move(LazyInitializers);
1148 LazyInitializers.clear();
1150 for (
auto ID : LazyInits)
1151 Initializers.push_back(Source->GetExternalDecl(
ID));
1153 assert(LazyInitializers.empty() &&
1154 "GetExternalDecl for lazy module initializer added more inits");
1160 if (
const auto *
ID = dyn_cast<ImportDecl>(D)) {
1161 auto It = ModuleInitializers.find(
ID->getImportedModule());
1164 if (It == ModuleInitializers.end())
1168 auto &Imported = *It->second;
1169 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
1170 Imported.resolve(*
this);
1171 auto *OnlyDecl = Imported.Initializers.front();
1172 if (isa<ImportDecl>(OnlyDecl))
1177 auto *&Inits = ModuleInitializers[M];
1179 Inits =
new (*this) PerModuleInitializers;
1180 Inits->Initializers.push_back(D);
1184 auto *&Inits = ModuleInitializers[M];
1186 Inits =
new (*this) PerModuleInitializers;
1187 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
1188 IDs.begin(), IDs.end());
1192 auto It = ModuleInitializers.find(M);
1193 if (It == ModuleInitializers.end())
1196 auto *Inits = It->second;
1197 Inits->resolve(*
this);
1198 return Inits->Initializers;
1202 if (!ExternCContext)
1205 return ExternCContext;
1211 auto *BuiltinTemplate =
1213 BuiltinTemplate->setImplicit();
1216 return BuiltinTemplate;
1221 if (!MakeIntegerSeqDecl)
1224 return MakeIntegerSeqDecl;
1229 if (!TypePackElementDecl)
1232 return TypePackElementDecl;
1246 NewDecl->
addAttr(TypeVisibilityAttr::CreateImplicit(
1247 const_cast<ASTContext &
>(*
this), TypeVisibilityAttr::Default));
1252 StringRef Name)
const {
1276 Types.push_back(Ty);
1281 assert((!this->Target || this->Target == &
Target) &&
1282 "Incorrect target reinitialization");
1286 this->AuxTarget = AuxTarget;
1288 ABI.reset(createCXXABI(
Target));
1293 InitBuiltinType(
VoidTy, BuiltinType::Void);
1296 InitBuiltinType(
BoolTy, BuiltinType::Bool);
1298 if (LangOpts.CharIsSigned)
1299 InitBuiltinType(
CharTy, BuiltinType::Char_S);
1301 InitBuiltinType(
CharTy, BuiltinType::Char_U);
1304 InitBuiltinType(
ShortTy, BuiltinType::Short);
1305 InitBuiltinType(
IntTy, BuiltinType::Int);
1306 InitBuiltinType(
LongTy, BuiltinType::Long);
1307 InitBuiltinType(
LongLongTy, BuiltinType::LongLong);
1318 InitBuiltinType(
DoubleTy, BuiltinType::Double);
1319 InitBuiltinType(
LongDoubleTy, BuiltinType::LongDouble);
1322 InitBuiltinType(
Float128Ty, BuiltinType::Float128);
1325 InitBuiltinType(
Ibm128Ty, BuiltinType::Ibm128);
1328 InitBuiltinType(
Float16Ty, BuiltinType::Float16);
1331 InitBuiltinType(
ShortAccumTy, BuiltinType::ShortAccum);
1332 InitBuiltinType(
AccumTy, BuiltinType::Accum);
1333 InitBuiltinType(
LongAccumTy, BuiltinType::LongAccum);
1337 InitBuiltinType(
ShortFractTy, BuiltinType::ShortFract);
1338 InitBuiltinType(
FractTy, BuiltinType::Fract);
1339 InitBuiltinType(
LongFractTy, BuiltinType::LongFract);
1344 InitBuiltinType(
SatAccumTy, BuiltinType::SatAccum);
1350 InitBuiltinType(
SatFractTy, BuiltinType::SatFract);
1357 InitBuiltinType(
Int128Ty, BuiltinType::Int128);
1362 InitBuiltinType(
WCharTy, BuiltinType::WChar_S);
1364 InitBuiltinType(
WCharTy, BuiltinType::WChar_U);
1365 if (LangOpts.CPlusPlus && LangOpts.WChar)
1375 InitBuiltinType(
Char8Ty, BuiltinType::Char8);
1377 if (LangOpts.CPlusPlus)
1378 InitBuiltinType(
Char16Ty, BuiltinType::Char16);
1382 if (LangOpts.CPlusPlus)
1383 InitBuiltinType(
Char32Ty, BuiltinType::Char32);
1392 InitBuiltinType(
DependentTy, BuiltinType::Dependent);
1395 InitBuiltinType(
OverloadTy, BuiltinType::Overload);
1404 InitBuiltinType(
UnknownAnyTy, BuiltinType::UnknownAny);
1410 InitBuiltinType(
BuiltinFnTy, BuiltinType::BuiltinFn);
1413 if (LangOpts.OpenMP) {
1418 if (LangOpts.MatrixTypes)
1426 if (LangOpts.OpenCL) {
1427 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1428 InitBuiltinType(SingletonId, BuiltinType::Id);
1429 #include "clang/Basic/OpenCLImageTypes.def"
1431 InitBuiltinType(
OCLSamplerTy, BuiltinType::OCLSampler);
1432 InitBuiltinType(
OCLEventTy, BuiltinType::OCLEvent);
1434 InitBuiltinType(
OCLQueueTy, BuiltinType::OCLQueue);
1437 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1438 InitBuiltinType(Id##Ty, BuiltinType::Id);
1439 #include "clang/Basic/OpenCLExtensionTypes.def"
1442 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"
1467 ObjCConstantStringType =
QualType();
1472 if (LangOpts.OpenCLGenericAddressSpace) {
1482 InitBuiltinType(
NullPtrTy, BuiltinType::NullPtr);
1485 InitBuiltinType(
HalfTy, BuiltinType::Half);
1487 InitBuiltinType(
BFloat16Ty, BuiltinType::BFloat16);
1493 if (LangOpts.MicrosoftExt || LangOpts.Borland) {
1504 AttrVec *&Result = DeclAttrs[D];
1515 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1516 if (Pos != DeclAttrs.end()) {
1517 Pos->second->~AttrVec();
1518 DeclAttrs.erase(Pos);
1532 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1533 TemplateOrInstantiation.find(Var);
1534 if (Pos == TemplateOrInstantiation.end())
1547 Tmpl, TSK, PointOfInstantiation));
1553 assert(!TemplateOrInstantiation[Inst] &&
1554 "Already noted what the variable was instantiated from");
1555 TemplateOrInstantiation[Inst] = TSI;
1560 auto Pos = InstantiatedFromUsingDecl.find(UUD);
1561 if (Pos == InstantiatedFromUsingDecl.end())
1569 assert((isa<UsingDecl>(Pattern) ||
1570 isa<UnresolvedUsingValueDecl>(Pattern) ||
1571 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
1572 "pattern decl is not a using decl");
1573 assert((isa<UsingDecl>(Inst) ||
1574 isa<UnresolvedUsingValueDecl>(Inst) ||
1575 isa<UnresolvedUsingTypenameDecl>(Inst)) &&
1576 "instantiation did not produce a using decl");
1577 assert(!InstantiatedFromUsingDecl[Inst] &&
"pattern already exists");
1578 InstantiatedFromUsingDecl[Inst] = Pattern;
1583 auto Pos = InstantiatedFromUsingEnumDecl.find(UUD);
1584 if (Pos == InstantiatedFromUsingEnumDecl.end())
1592 assert(!InstantiatedFromUsingEnumDecl[Inst] &&
"pattern already exists");
1593 InstantiatedFromUsingEnumDecl[Inst] = Pattern;
1598 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1599 = InstantiatedFromUsingShadowDecl.find(Inst);
1600 if (Pos == InstantiatedFromUsingShadowDecl.end())
1609 assert(!InstantiatedFromUsingShadowDecl[Inst] &&
"pattern already exists");
1610 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1614 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1615 = InstantiatedFromUnnamedFieldDecl.find(Field);
1616 if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1624 assert(!Inst->
getDeclName() &&
"Instantiated field decl is not unnamed");
1625 assert(!Tmpl->
getDeclName() &&
"Template field decl is not unnamed");
1626 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1627 "Already noted what unnamed field was instantiated from");
1629 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1645 return Range.end() - Range.begin();
1650 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1652 if (Pos == OverriddenMethods.end())
1660 OverriddenMethods[Method].push_back(Overridden);
1668 if (
const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1674 const auto *Method = dyn_cast<ObjCMethodDecl>(D);
1679 Method->getOverriddenMethods(OverDecls);
1680 Overridden.append(OverDecls.begin(), OverDecls.end());
1684 assert(!Import->getNextLocalImport() &&
1685 "Import declaration already in the chain");
1686 assert(!Import->
isFromASTFile() &&
"Non-local import declaration");
1687 if (!FirstLocalImport) {
1688 FirstLocalImport = Import;
1689 LastLocalImport = Import;
1693 LastLocalImport->setNextLocalImport(Import);
1694 LastLocalImport = Import;
1706 llvm_unreachable(
"Not a floating point type!");
1707 case BuiltinType::BFloat16:
1709 case BuiltinType::Float16:
1711 case BuiltinType::Half:
1723 case BuiltinType::Ibm128:
1725 case BuiltinType::LongDouble:
1729 case BuiltinType::Float128:
1739 bool UseAlignAttrOnly =
false;
1741 Align = AlignFromAttr;
1749 if (isa<FieldDecl>(D)) {
1750 UseAlignAttrOnly = D->
hasAttr<PackedAttr>() ||
1751 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1753 UseAlignAttrOnly =
true;
1756 else if (isa<FieldDecl>(D))
1759 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1763 if (UseAlignAttrOnly) {
1765 }
else if (
const auto *VD = dyn_cast<ValueDecl>(D)) {
1781 if (!ForAlignof && MinWidth) {
1784 else if (isa<ConstantArrayType>(
arrayType) &&
1792 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
1793 if (VD->hasGlobalStorage() && !ForAlignof) {
1805 if (
const auto *Field = dyn_cast<FieldDecl>(VD)) {
1808 if (!
Parent->isInvalidDecl()) {
1820 if (LowBitOfOffset < FieldAlign)
1821 FieldAlign =
static_cast<unsigned>(LowBitOfOffset);
1824 Align =
std::min(Align, FieldAlign);
1832 const auto *VD = dyn_cast<VarDecl>(D);
1833 if (MaxAlignedAttr && VD && VD->getStorageClass() ==
SC_Static)
1834 Align =
std::min(Align, MaxAlignedAttr);
1872 "Overflow in array type char size evaluation");
1877 Width = llvm::alignTo(Width, Align);
1884 if (
const auto *CAT = dyn_cast<ConstantArrayType>(T))
1904 bool NeedsPreferredAlignment)
const {
1907 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1918 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1923 return TT->getDecl()->getMaxAlignment();
1929 TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
1930 if (I != MemoizedTypeInfo.end())
1935 MemoizedTypeInfo[T] = TI;
1945 TypeInfo ASTContext::getTypeInfoImpl(
const Type *T)
const {
1951 #define TYPE(Class, Base)
1952 #define ABSTRACT_TYPE(Class, Base)
1953 #define NON_CANONICAL_TYPE(Class, Base)
1954 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1955 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1957 assert(!T->isDependentType() && "should not see dependent types here"); \
1958 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1959 #include "clang/AST/TypeNodes.inc"
1960 llvm_unreachable(
"Should not see dependent types");
1962 case Type::FunctionNoProto:
1963 case Type::FunctionProto:
1969 case Type::IncompleteArray:
1970 case Type::VariableArray:
1971 case Type::ConstantArray: {
1974 if (
const auto *CAT = dyn_cast<ConstantArrayType>(T))
1975 Size = CAT->getSize().getZExtValue();
1978 assert((Size == 0 || EltInfo.
Width <= (
uint64_t)(-1) / Size) &&
1979 "Overflow in array type bit size evaluation");
1980 Width = EltInfo.
Width * Size;
1981 Align = EltInfo.
Align;
1985 Width = llvm::alignTo(Width, Align);
1989 case Type::ExtVector:
1990 case Type::Vector: {
1991 const auto *VT = cast<VectorType>(T);
1993 Width = VT->isExtVectorBoolType() ? VT->getNumElements()
1994 : EltInfo.
Width * VT->getNumElements();
1996 Align = std::max<unsigned>(8, Width);
2000 if (Align & (Align-1)) {
2001 Align = llvm::NextPowerOf2(Align);
2002 Width = llvm::alignTo(Width, Align);
2006 if (TargetVectorAlign && TargetVectorAlign < Align)
2007 Align = TargetVectorAlign;
2018 case Type::ConstantMatrix: {
2019 const auto *MT = cast<ConstantMatrixType>(T);
2024 Width = ElementInfo.
Width * MT->getNumRows() * MT->getNumColumns();
2025 Align = ElementInfo.
Align;
2030 switch (cast<BuiltinType>(T)->
getKind()) {
2031 default: llvm_unreachable(
"Unknown builtin type!");
2032 case BuiltinType::Void:
2037 case BuiltinType::Bool:
2041 case BuiltinType::Char_S:
2042 case BuiltinType::Char_U:
2043 case BuiltinType::UChar:
2044 case BuiltinType::SChar:
2045 case BuiltinType::Char8:
2049 case BuiltinType::WChar_S:
2050 case BuiltinType::WChar_U:
2054 case BuiltinType::Char16:
2058 case BuiltinType::Char32:
2062 case BuiltinType::UShort:
2063 case BuiltinType::Short:
2067 case BuiltinType::UInt:
2068 case BuiltinType::Int:
2072 case BuiltinType::ULong:
2073 case BuiltinType::Long:
2077 case BuiltinType::ULongLong:
2078 case BuiltinType::LongLong:
2082 case BuiltinType::Int128:
2083 case BuiltinType::UInt128:
2087 case BuiltinType::ShortAccum:
2088 case BuiltinType::UShortAccum:
2089 case BuiltinType::SatShortAccum:
2090 case BuiltinType::SatUShortAccum:
2094 case BuiltinType::Accum:
2095 case BuiltinType::UAccum:
2096 case BuiltinType::SatAccum:
2097 case BuiltinType::SatUAccum:
2101 case BuiltinType::LongAccum:
2102 case BuiltinType::ULongAccum:
2103 case BuiltinType::SatLongAccum:
2104 case BuiltinType::SatULongAccum:
2108 case BuiltinType::ShortFract:
2109 case BuiltinType::UShortFract:
2110 case BuiltinType::SatShortFract:
2111 case BuiltinType::SatUShortFract:
2115 case BuiltinType::Fract:
2116 case BuiltinType::UFract:
2117 case BuiltinType::SatFract:
2118 case BuiltinType::SatUFract:
2122 case BuiltinType::LongFract:
2123 case BuiltinType::ULongFract:
2124 case BuiltinType::SatLongFract:
2125 case BuiltinType::SatULongFract:
2129 case BuiltinType::BFloat16:
2135 case BuiltinType::Float16:
2136 case BuiltinType::Half:
2143 "Expected OpenMP device compilation.");
2152 case BuiltinType::Double:
2156 case BuiltinType::Ibm128:
2160 case BuiltinType::LongDouble:
2171 case BuiltinType::Float128:
2178 "Expected OpenMP device compilation.");
2183 case BuiltinType::NullPtr:
2187 case BuiltinType::ObjCId:
2188 case BuiltinType::ObjCClass:
2189 case BuiltinType::ObjCSel:
2193 case BuiltinType::OCLSampler:
2194 case BuiltinType::OCLEvent:
2195 case BuiltinType::OCLClkEvent:
2196 case BuiltinType::OCLQueue:
2197 case BuiltinType::OCLReserveID:
2198 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2199 case BuiltinType::Id:
2200 #include "clang/Basic/OpenCLImageTypes.def"
2201 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2202 case BuiltinType::Id:
2203 #include "clang/Basic/OpenCLExtensionTypes.def"
2217 #define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId, NumEls, ElBits, \
2218 IsSigned, IsFP, IsBF) \
2219 case BuiltinType::Id: \
2223 #define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId, NumEls) \
2224 case BuiltinType::Id: \
2228 #include "clang/Basic/AArch64SVEACLETypes.def"
2229 #define PPC_VECTOR_TYPE(Name, Id, Size) \
2230 case BuiltinType::Id: \
2234 #include "clang/Basic/PPCTypes.def"
2235 #define RVV_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, NF, IsSigned, \
2237 case BuiltinType::Id: \
2241 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \
2242 case BuiltinType::Id: \
2246 #include "clang/Basic/RISCVVTypes.def"
2249 case Type::ObjCObjectPointer:
2253 case Type::BlockPointer:
2258 case Type::LValueReference:
2259 case Type::RValueReference:
2271 case Type::MemberPointer: {
2272 const auto *MPT = cast<MemberPointerType>(T);
2278 case Type::Complex: {
2282 Width = EltInfo.
Width * 2;
2283 Align = EltInfo.
Align;
2286 case Type::ObjCObject:
2287 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
2288 case Type::Adjusted:
2291 case Type::ObjCInterface: {
2292 const auto *ObjCI = cast<ObjCInterfaceType>(T);
2293 if (ObjCI->getDecl()->isInvalidDecl()) {
2303 case Type::BitInt: {
2304 const auto *EIT = cast<BitIntType>(T);
2307 getCharWidth(), llvm::PowerOf2Ceil(EIT->getNumBits()))),
2309 Width = llvm::alignTo(EIT->getNumBits(), Align);
2314 const auto *TT = cast<TagType>(T);
2316 if (TT->getDecl()->isInvalidDecl()) {
2322 if (
const auto *ET = dyn_cast<EnumType>(TT)) {
2323 const EnumDecl *ED = ET->getDecl();
2327 Info.
Align = AttrAlign;
2333 const auto *RT = cast<RecordType>(TT);
2338 AlignRequirement = RD->
hasAttr<AlignedAttr>()
2344 case Type::SubstTemplateTypeParm:
2345 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
2346 getReplacementType().getTypePtr());
2349 case Type::DeducedTemplateSpecialization: {
2350 const auto *A = cast<DeducedType>(T);
2351 assert(!A->getDeducedType().isNull() &&
2352 "cannot request the size of an undeduced or dependent auto type");
2353 return getTypeInfo(A->getDeducedType().getTypePtr());
2357 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
2359 case Type::MacroQualified:
2363 case Type::ObjCTypeParam:
2364 return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
2367 return getTypeInfo(cast<UsingType>(T)->desugar().getTypePtr());
2369 case Type::Typedef: {
2386 case Type::Elaborated:
2387 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
2389 case Type::Attributed:
2391 cast<AttributedType>(T)->getEquivalentType().getTypePtr());
2393 case Type::BTFTagAttributed:
2395 cast<BTFTagAttributedType>(T)->getWrappedType().getTypePtr());
2397 case Type::Atomic: {
2408 }
else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2414 if (!llvm::isPowerOf2_64(Width))
2415 Width = llvm::NextPowerOf2(Width);
2418 Align =
static_cast<unsigned>(Width);
2429 assert(llvm::isPowerOf2_32(Align) &&
"Alignment must be power of 2");
2430 return TypeInfo(Width, Align, AlignRequirement);
2434 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
2435 if (I != MemoizedUnadjustedAlign.end())
2438 unsigned UnadjustedAlign;
2450 MemoizedUnadjustedAlign[T] = UnadjustedAlign;
2451 return UnadjustedAlign;
2504 unsigned ABIAlign = TI.
Align;
2526 unsigned PreferredAlign =
static_cast<unsigned>(
2528 assert(PreferredAlign >= ABIAlign &&
2529 "PreferredAlign should be at least as large as ABIAlign.");
2530 return PreferredAlign;
2537 T = CT->getElementType().getTypePtr();
2539 T = ET->getDecl()->getIntegerType().getTypePtr();
2590 for (
unsigned I = 0, N = Path.size(); I != N; ++I) {
2594 std::swap(
Base, Derived);
2614 llvm::append_range(Ivars, OI->
ivars());
2617 for (
const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2619 Ivars.push_back(Iv);
2627 if (
const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2630 for (
auto *Proto : OI->all_referenced_protocols()) {
2635 for (
const auto *Cat : OI->visible_categories())
2641 SD = SD->getSuperClass();
2643 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2644 for (
auto *Proto : OC->protocols()) {
2647 }
else if (
const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2649 if (!Protocols.insert(
2653 for (
auto *Proto : OP->protocols())
2660 assert(RD->
isUnion() &&
"Must be union type");
2663 for (
const auto *Field : RD->
fields()) {
2667 if (FieldSize != UnionSize)
2691 if (Field->getType()->isRecordType()) {
2692 const RecordDecl *RD = Field->getType()->getAsRecordDecl();
2699 bool IsBitIntType = Field->getType()->isBitIntType();
2700 if (!Field->getType()->isReferenceType() && !IsBitIntType &&
2706 if (Field->isBitField()) {
2707 int64_t BitfieldSize = Field->getBitWidthValue(Context);
2709 if ((
unsigned)BitfieldSize >
2710 cast<BitIntType>(Field->getType())->getNumBits())
2712 }
else if (BitfieldSize > FieldSizeInBits) {
2715 FieldSizeInBits = BitfieldSize;
2716 }
else if (IsBitIntType &&
2720 return FieldSizeInBits;
2728 template <
typename RangeT>
2730 const RangeT &Subobjects,
int64_t CurOffsetInBits,
2732 for (
const auto *Subobject : Subobjects) {
2737 if (*SizeInBits != 0) {
2739 if (
Offset != CurOffsetInBits)
2741 CurOffsetInBits += *SizeInBits;
2744 return CurOffsetInBits;
2750 assert(!RD->
isUnion() &&
"Must be struct/class type");
2754 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2755 if (ClassDecl->isDynamicClass())
2759 for (
const auto &
Base : ClassDecl->bases()) {
2762 Bases.emplace_back(
Base.getType()->getAsCXXRecordDecl());
2766 return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
2772 if (!OffsetAfterBases)
2774 CurOffsetInBits = *OffsetAfterBases;
2779 RD->
fields(), CurOffsetInBits, Context, Layout);
2780 if (!OffsetAfterFields)
2782 CurOffsetInBits = *OffsetAfterFields;
2784 return CurOffsetInBits;
2805 assert(!Ty.
isNull() &&
"Null QualType sent to unique object rep check");
2818 if (
const auto *BIT = dyn_cast<BitIntType>(Ty))
2830 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2866 count += Ext->ivar_size();
2871 count += ImplDecl->ivar_size();
2889 if (isa<GNUNullExpr>(E))
return true;
2897 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2898 I = ObjCImpls.find(D);
2899 if (I != ObjCImpls.end())
2900 return cast<ObjCImplementationDecl>(I->second);
2907 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2908 I = ObjCImpls.find(D);
2909 if (I != ObjCImpls.end())
2910 return cast<ObjCCategoryImplDecl>(I->second);
2917 assert(IFaceD && ImplD &&
"Passed null params");
2918 ObjCImpls[IFaceD] = ImplD;
2924 assert(CatD && ImplD &&
"Passed null params");
2925 ObjCImpls[CatD] = ImplD;
2930 return ObjCMethodRedecls.lookup(MD);
2936 ObjCMethodRedecls[MD] = Redecl;
2943 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->
getDeclContext()))
2944 return CD->getClassInterface();
2945 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(ND->
getDeclContext()))
2946 return IMD->getClassInterface();
2954 assert(VD &&
"Passed null params");
2955 assert(VD->
hasAttr<BlocksAttr>() &&
2956 "getBlockVarCopyInits - not __block var");
2957 auto I = BlockVarCopyInits.find(VD);
2958 if (I != BlockVarCopyInits.end())
2960 return {
nullptr,
false};
2966 assert(VD && CopyExpr &&
"Passed null params");
2967 assert(VD->
hasAttr<BlocksAttr>() &&
2968 "setBlockVarCopyInits - not __block var");
2969 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr,
CanThrow);
2973 unsigned DataSize)
const {
2978 "incorrect data size provided to CreateTypeSourceInfo!");
2995 return getObjCLayout(D,
nullptr);
3009 ASTContext::getExtQualType(
const Type *baseType,
Qualifiers quals)
const {
3014 llvm::FoldingSetNodeID
ID;
3016 void *insertPos =
nullptr;
3017 if (
ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(
ID, insertPos)) {
3018 assert(eq->getQualifiers() == quals);
3027 canon = getExtQualType(canonSplit.
Ty, canonSplit.
Quals);
3030 (void) ExtQualNodes.FindNodeOrInsertPos(
ID, insertPos);
3034 ExtQualNodes.InsertNode(eq, insertPos);
3039 LangAS AddressSpace)
const {
3052 "Type cannot be in multiple addr spaces!");
3055 return getExtQualType(TypeNode, Quals);
3067 const Type *TypeNode;
3070 TypeNode = Quals.
strip(T);
3074 if (!
QualType(TypeNode, 0).hasAddressSpace())
3087 return getExtQualType(TypeNode, Quals);
3114 "Type cannot have multiple ObjCGCs!");
3117 return getExtQualType(TypeNode, Quals);
3136 if (
const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
3139 const auto *FPT = cast<FunctionProtoType>(T);
3142 Result =
getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
3145 return cast<FunctionType>(Result.getTypePtr());
3161 L->DeducedReturnType(FD, ResultType);
3171 if (
const auto *PT = dyn_cast<ParenType>(Orig))
3176 if (
const auto *MQT = dyn_cast<MacroQualifiedType>(Orig))
3179 MQT->getMacroIdentifier());
3182 if (
const auto *AT = dyn_cast<AttributedType>(Orig))
3192 Proto->getReturnType(), Proto->getParamTypes(),
3193 Proto->getExtProtoInfo().withExceptionSpec(ESI));
3208 for (
unsigned i = 0, n = Args.size(); i != n; ++i)
3242 if (TSInfo->getType() != FD->
getType())
3250 "TypeLoc size mismatch from updating exception specification");
3251 TSInfo->overrideType(Updated);
3260 llvm::FoldingSetNodeID
ID;
3263 void *InsertPos =
nullptr;
3264 if (
ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(
ID, InsertPos))
3274 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(
ID, InsertPos);
3275 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3278 Types.push_back(New);
3279 ComplexTypes.InsertNode(New, InsertPos);
3288 llvm::FoldingSetNodeID
ID;
3291 void *InsertPos =
nullptr;
3292 if (
PointerType *PT = PointerTypes.FindNodeOrInsertPos(
ID, InsertPos))
3302 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(
ID, InsertPos);
3303 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3306 Types.push_back(New);
3307 PointerTypes.InsertNode(New, InsertPos);
3312 llvm::FoldingSetNodeID
ID;
3314 void *InsertPos =
nullptr;
3315 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(
ID, InsertPos);
3322 AT = AdjustedTypes.FindNodeOrInsertPos(
ID, InsertPos);
3323 assert(!AT &&
"Shouldn't be in the map!");
3327 Types.push_back(AT);
3328 AdjustedTypes.InsertNode(AT, InsertPos);
3352 llvm::FoldingSetNodeID
ID;
3354 void *InsertPos =
nullptr;
3355 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(
ID, InsertPos);
3362 AT = AdjustedTypes.FindNodeOrInsertPos(
ID, InsertPos);
3363 assert(!AT &&
"Shouldn't be in the map!");
3366 Types.push_back(AT);
3367 AdjustedTypes.InsertNode(AT, InsertPos);
3377 llvm::FoldingSetNodeID
ID;
3380 void *InsertPos =
nullptr;
3382 BlockPointerTypes.FindNodeOrInsertPos(
ID, InsertPos))
3393 BlockPointerTypes.FindNodeOrInsertPos(
ID, InsertPos);
3394 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3397 Types.push_back(New);
3398 BlockPointerTypes.InsertNode(New, InsertPos);
3408 "Unresolved placeholder type");
3412 llvm::FoldingSetNodeID
ID;
3415 void *InsertPos =
nullptr;
3417 LValueReferenceTypes.FindNodeOrInsertPos(
ID, InsertPos))
3425 if (!SpelledAsLValue || InnerRef || !T.
isCanonical()) {
3426 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
3431 LValueReferenceTypes.FindNodeOrInsertPos(
ID, InsertPos);
3432 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3437 Types.push_back(New);
3438 LValueReferenceTypes.InsertNode(New, InsertPos);
3448 "Unresolved placeholder type");
3452 llvm::FoldingSetNodeID
ID;
3455 void *InsertPos =
nullptr;
3457 RValueReferenceTypes.FindNodeOrInsertPos(
ID, InsertPos))
3466 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
3471 RValueReferenceTypes.FindNodeOrInsertPos(
ID, InsertPos);
3472 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3476 Types.push_back(New);
3477 RValueReferenceTypes.InsertNode(New, InsertPos);
3486 llvm::FoldingSetNodeID
ID;
3489 void *InsertPos =
nullptr;
3491 MemberPointerTypes.FindNodeOrInsertPos(
ID, InsertPos))
3502 MemberPointerTypes.FindNodeOrInsertPos(
ID, InsertPos);
3503 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3506 Types.push_back(New);
3507 MemberPointerTypes.InsertNode(New, InsertPos);
3515 const Expr *SizeExpr,
3517 unsigned IndexTypeQuals)
const {
3520 "Constant array of VLAs is illegal!");
3531 llvm::FoldingSetNodeID
ID;
3535 void *InsertPos =
nullptr;
3537 ConstantArrayTypes.FindNodeOrInsertPos(
ID, InsertPos))
3547 ASM, IndexTypeQuals);
3552 ConstantArrayTypes.FindNodeOrInsertPos(
ID, InsertPos);
3553 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3557 ConstantArrayType::totalSizeToAlloc<const Expr *>(SizeExpr ? 1 : 0),
3559 auto *New =
new (Mem)
3561 ConstantArrayTypes.InsertNode(New, InsertPos);
3562 Types.push_back(New);
3571 if (!
type->isVariablyModifiedType())
return type;
3576 const Type *ty = split.
Ty;
3578 #define TYPE(Class, Base)
3579 #define ABSTRACT_TYPE(Class, Base)
3580 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3581 #include "clang/AST/TypeNodes.inc"
3582 llvm_unreachable(
"didn't desugar past all non-canonical types?");
3588 case Type::DependentVector:
3589 case Type::ExtVector:
3590 case Type::DependentSizedExtVector:
3591 case Type::ConstantMatrix:
3592 case Type::DependentSizedMatrix:
3593 case Type::DependentAddressSpace:
3594 case Type::ObjCObject:
3595 case Type::ObjCInterface:
3596 case Type::ObjCObjectPointer:
3599 case Type::UnresolvedUsing:
3600 case Type::TypeOfExpr:
3602 case Type::Decltype:
3603 case Type::UnaryTransform:
3604 case Type::DependentName:
3605 case Type::InjectedClassName:
3606 case Type::TemplateSpecialization:
3607 case Type::DependentTemplateSpecialization:
3608 case Type::TemplateTypeParm:
3609 case Type::SubstTemplateTypeParmPack:
3611 case Type::DeducedTemplateSpecialization:
3612 case Type::PackExpansion:
3614 case Type::DependentBitInt:
3615 llvm_unreachable(
"type should never be variably-modified");
3619 case Type::FunctionNoProto:
3620 case Type::FunctionProto:
3621 case Type::BlockPointer:
3622 case Type::MemberPointer:
3632 cast<PointerType>(ty)->getPointeeType()));
3635 case Type::LValueReference: {
3636 const auto *lv = cast<LValueReferenceType>(ty);
3639 lv->isSpelledAsLValue());
3643 case Type::RValueReference: {
3644 const auto *lv = cast<RValueReferenceType>(ty);
3650 case Type::Atomic: {
3651 const auto *at = cast<AtomicType>(ty);
3656 case Type::ConstantArray: {
3657 const auto *
cat = cast<ConstantArrayType>(ty);
3662 cat->getSizeModifier(),
3663 cat->getIndexTypeCVRQualifiers());
3667 case Type::DependentSizedArray: {
3668 const auto *dat = cast<DependentSizedArrayType>(ty);
3672 dat->getSizeModifier(),
3673 dat->getIndexTypeCVRQualifiers(),
3674 dat->getBracketsRange());
3679 case Type::IncompleteArray: {
3680 const auto *iat = cast<IncompleteArrayType>(ty);
3685 iat->getIndexTypeCVRQualifiers(),
3691 case Type::VariableArray: {
3692 const auto *vat = cast<VariableArrayType>(ty);
3697 vat->getIndexTypeCVRQualifiers(),
3698 vat->getBracketsRange());
3712 unsigned IndexTypeQuals,
3722 IndexTypeQuals, Brackets);
3729 VariableArrayTypes.push_back(New);
3730 Types.push_back(New);
3740 unsigned elementTypeQuals,
3744 "Size must be type- or value-dependent!");
3754 numElements, ASM, elementTypeQuals,
3756 Types.push_back(newType);
3765 void *insertPos =
nullptr;
3766 llvm::FoldingSetNodeID
ID;
3769 ASM, elementTypeQuals, numElements);
3773 DependentSizedArrayTypes.FindNodeOrInsertPos(
ID, insertPos);
3779 QualType(), numElements, ASM, elementTypeQuals,
3781 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3782 Types.push_back(canonTy);
3787 canonElementType.
Quals);
3791 if (
QualType(canonElementType.
Ty, 0) == elementType &&
3800 ASM, elementTypeQuals, brackets);
3801 Types.push_back(sugaredType);
3807 unsigned elementTypeQuals)
const {
3808 llvm::FoldingSetNodeID
ID;
3811 void *insertPos =
nullptr;
3813 IncompleteArrayTypes.FindNodeOrInsertPos(
ID, insertPos))
3824 ASM, elementTypeQuals);
3829 IncompleteArrayTypes.FindNodeOrInsertPos(
ID, insertPos);
3830 assert(!existing &&
"Shouldn't be in the map!"); (void) existing;
3836 IncompleteArrayTypes.InsertNode(newType, insertPos);
3837 Types.push_back(newType);
3843 #define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS) \
3844 {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \
3847 #define SVE_ELTTY(ELTTY, ELTS, NUMVECTORS) \
3848 {ELTTY, llvm::ElementCount::getScalable(ELTS), NUMVECTORS};
3852 llvm_unreachable(
"Unsupported builtin vector type");
3853 case BuiltinType::SveInt8:
3855 case BuiltinType::SveUint8:
3857 case BuiltinType::SveInt8x2:
3859 case BuiltinType::SveUint8x2:
3861 case BuiltinType::SveInt8x3:
3863 case BuiltinType::SveUint8x3:
3865 case BuiltinType::SveInt8x4:
3867 case BuiltinType::SveUint8x4:
3869 case BuiltinType::SveInt16:
3871 case BuiltinType::SveUint16:
3873 case BuiltinType::SveInt16x2:
3875 case BuiltinType::SveUint16x2:
3877 case BuiltinType::SveInt16x3:
3879 case BuiltinType::SveUint16x3:
3881 case BuiltinType::SveInt16x4:
3883 case BuiltinType::SveUint16x4:
3885 case BuiltinType::SveInt32:
3887 case BuiltinType::SveUint32:
3889 case BuiltinType::SveInt32x2:
3891 case BuiltinType::SveUint32x2:
3893 case BuiltinType::SveInt32x3:
3895 case BuiltinType::SveUint32x3:
3897 case BuiltinType::SveInt32x4:
3899 case BuiltinType::SveUint32x4:
3901 case BuiltinType::SveInt64:
3903 case BuiltinType::SveUint64:
3905 case BuiltinType::SveInt64x2:
3907 case BuiltinType::SveUint64x2:
3909 case BuiltinType::SveInt64x3:
3911 case BuiltinType::SveUint64x3:
3913 case BuiltinType::SveInt64x4:
3915 case BuiltinType::SveUint64x4:
3917 case BuiltinType::SveBool:
3919 case BuiltinType::SveFloat16:
3921 case BuiltinType::SveFloat16x2:
3923 case BuiltinType::SveFloat16x3:
3925 case BuiltinType::SveFloat16x4:
3927 case BuiltinType::SveFloat32:
3929 case BuiltinType::SveFloat32x2:
3931 case BuiltinType::SveFloat32x3:
3933 case BuiltinType::SveFloat32x4:
3935 case BuiltinType::SveFloat64:
3937 case BuiltinType::SveFloat64x2:
3939 case BuiltinType::SveFloat64x3:
3941 case BuiltinType::SveFloat64x4:
3943 case BuiltinType::SveBFloat16:
3945 case BuiltinType::SveBFloat16x2:
3947 case BuiltinType::SveBFloat16x3:
3949 case BuiltinType::SveBFloat16x4:
3951 #define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF, \
3953 case BuiltinType::Id: \
3954 return {getIntTypeForBitwidth(ElBits, IsSigned), \
3955 llvm::ElementCount::getScalable(NumEls), NF};
3956 #define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
3957 case BuiltinType::Id: \
3958 return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy), \
3959 llvm::ElementCount::getScalable(NumEls), NF};
3960 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
3961 case BuiltinType::Id: \
3962 return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1};
3963 #include "clang/Basic/RISCVVTypes.def"
3971 unsigned NumElts)
const {
3974 #define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId, NumEls, ElBits, \
3975 IsSigned, IsFP, IsBF) \
3976 if (!EltTy->isBooleanType() && \
3977 ((EltTy->hasIntegerRepresentation() && \
3978 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \
3979 (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
3981 (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
3982 IsBF && !IsFP)) && \
3983 EltTySize == ElBits && NumElts == NumEls) { \
3984 return SingletonId; \
3986 #define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId, NumEls) \
3987 if (EltTy->isBooleanType() && NumElts == NumEls) \
3989 #include "clang/Basic/AArch64SVEACLETypes.def"
3992 #define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
3994 if (!EltTy->isBooleanType() && \
3995 ((EltTy->hasIntegerRepresentation() && \
3996 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \
3997 (EltTy->hasFloatingRepresentation() && IsFP)) && \
3998 EltTySize == ElBits && NumElts == NumEls) \
4000 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4001 if (EltTy->isBooleanType() && NumElts == NumEls) \
4003 #include "clang/Basic/RISCVVTypes.def"
4015 llvm::FoldingSetNodeID
ID;
4018 void *InsertPos =
nullptr;
4019 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(
ID, InsertPos))
4029 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4030 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4033 VectorType(vecType, NumElts, Canonical, VecKind);
4034 VectorTypes.InsertNode(New, InsertPos);
4035 Types.push_back(New);
4043 llvm::FoldingSetNodeID
ID;
4046 void *InsertPos =
nullptr;
4048 DependentVectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4053 *
this, VecType,
QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
4056 if (CanonVecTy == VecType) {
4058 *
this, VecType,
QualType(), SizeExpr, AttrLoc, VecKind);
4061 DependentVectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4062 assert(!CanonCheck &&
4063 "Dependent-sized vector_size canonical type broken");
4065 DependentVectorTypes.InsertNode(New, InsertPos);
4070 *
this, VecType, CanonTy, SizeExpr, AttrLoc, VecKind);
4074 Types.push_back(New);
4085 llvm::FoldingSetNodeID
ID;
4088 void *InsertPos =
nullptr;
4089 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(
ID, InsertPos))
4099 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4100 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4104 VectorTypes.InsertNode(New, InsertPos);
4105 Types.push_back(New);
4113 llvm::FoldingSetNodeID
ID;
4117 void *InsertPos =
nullptr;
4119 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4129 if (CanonVecTy == vecType) {
4135 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(
ID, InsertPos);
4136 assert(!CanonCheck &&
"Dependent-sized ext_vector canonical type broken");
4138 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
4143 *
this, vecType, CanonExtTy, SizeExpr, AttrLoc);
4147 Types.push_back(New);
4152 unsigned NumColumns)
const {
4153 llvm::FoldingSetNodeID
ID;
4155 Type::ConstantMatrix);
4158 "need a valid element type");
4161 "need valid matrix dimensions");
4162 void *InsertPos =
nullptr;
4172 assert(!NewIP &&
"Matrix type shouldn't already exist in the map");
4178 MatrixTypes.InsertNode(New, InsertPos);
4179 Types.push_back(New);
4188 llvm::FoldingSetNodeID
ID;
4192 void *InsertPos =
nullptr;
4194 DependentSizedMatrixTypes.FindNodeOrInsertPos(
ID, InsertPos);
4198 *
this, CanonElementTy,
QualType(), RowExpr, ColumnExpr, AttrLoc);
4201 DependentSizedMatrixTypes.FindNodeOrInsertPos(
ID, InsertPos);
4202 assert(!CanonCheck &&
"Dependent-sized matrix canonical type broken");
4204 DependentSizedMatrixTypes.InsertNode(Canon, InsertPos);
4205 Types.push_back(Canon);
4218 ColumnExpr, AttrLoc);
4219 Types.push_back(New);
4224 Expr *AddrSpaceExpr,
4230 void *insertPos =
nullptr;
4231 llvm::FoldingSetNodeID
ID;
4236 DependentAddressSpaceTypes.FindNodeOrInsertPos(
ID, insertPos);
4241 QualType(), AddrSpaceExpr, AttrLoc);
4242 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
4243 Types.push_back(canonTy);
4246 if (canonPointeeType == PointeeType &&
4253 AddrSpaceExpr, AttrLoc);
4254 Types.push_back(sugaredType);
4278 llvm::FoldingSetNodeID
ID;
4281 void *InsertPos =
nullptr;
4283 FunctionNoProtoTypes.FindNodeOrInsertPos(
ID, InsertPos))
4293 FunctionNoProtoTypes.FindNodeOrInsertPos(
ID, InsertPos);
4294 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4299 Types.push_back(New);
4300 FunctionNoProtoTypes.InsertNode(New, InsertPos);
4316 return CanResultType;
4323 if (!NoexceptInType)
4340 bool AnyPackExpansions =
false;
4345 AnyPackExpansions =
true;
4347 return AnyPackExpansions;
4353 QualType ASTContext::getFunctionTypeInternal(
4356 size_t NumArgs = ArgArray.size();
4360 llvm::FoldingSetNodeID
ID;
4365 bool Unique =
false;
4367 void *InsertPos =
nullptr;
4369 FunctionProtoTypes.FindNodeOrInsertPos(
ID, InsertPos)) {
4389 bool IsCanonicalExceptionSpec =
4393 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
4395 for (
unsigned i = 0; i != NumArgs && isCanonical; ++i)
4396 if (!ArgArray[i].isCanonicalAsParam())
4397 isCanonical =
false;
4399 if (OnlyWantCanonical)
4400 assert(isCanonical &&
4401 "given non-canonical parameters constructing canonical type");
4406 if (!isCanonical && Canonical.
isNull()) {
4408 CanonicalArgs.reserve(NumArgs);
4409 for (
unsigned i = 0; i != NumArgs; ++i)
4416 if (IsCanonicalExceptionSpec) {
4418 }
else if (NoexceptInType) {
4431 bool AnyPacks =
false;
4454 llvm_unreachable(
"dependent noexcept is already canonical");
4463 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI,
true);
4467 FunctionProtoTypes.FindNodeOrInsertPos(
ID, InsertPos);
4468 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4473 auto ESH = FunctionProtoType::getExceptionSpecSize(
4475 size_t Size = FunctionProtoType::totalSizeToAlloc<
4478 FunctionProtoType::ExtParameterInfo,
Qualifiers>(
4480 ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
4487 Types.push_back(FTP);
4489 FunctionProtoTypes.InsertNode(FTP, InsertPos);
4494 llvm::FoldingSetNodeID
ID;
4497 void *InsertPos =
nullptr;
4498 if (
PipeType *PT = PipeTypes.FindNodeOrInsertPos(
ID, InsertPos))
4508 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(
ID, InsertPos);
4509 assert(!NewIP &&
"Shouldn't be in the map!");
4513 Types.push_back(New);
4514 PipeTypes.InsertNode(New, InsertPos);
4525 return getPipeType(T,
true);
4529 return getPipeType(T,
false);
4533 llvm::FoldingSetNodeID
ID;
4536 void *InsertPos =
nullptr;
4537 if (
BitIntType *EIT = BitIntTypes.FindNodeOrInsertPos(
ID, InsertPos))
4541 BitIntTypes.InsertNode(New, InsertPos);
4542 Types.push_back(New);
4547 Expr *NumBitsExpr)
const {
4549 llvm::FoldingSetNodeID
ID;
4552 void *InsertPos =
nullptr;
4554 DependentBitIntTypes.FindNodeOrInsertPos(
ID, InsertPos))
4559 DependentBitIntTypes.InsertNode(New, InsertPos);
4561 Types.push_back(New);
4567 if (!isa<CXXRecordDecl>(D))
return false;
4568 const auto *RD = cast<CXXRecordDecl>(D);
4569 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
4571 if (RD->getDescribedClassTemplate() &&
4572 !isa<ClassTemplateSpecializationDecl>(RD))
4583 if (
Decl->TypeForDecl) {
4584 assert(isa<InjectedClassNameType>(
Decl->TypeForDecl));
4586 assert(PrevDecl->TypeForDecl &&
"previous declaration has no type");
4587 Decl->TypeForDecl = PrevDecl->TypeForDecl;
4588 assert(isa<InjectedClassNameType>(
Decl->TypeForDecl));
4592 Decl->TypeForDecl = newType;
4593 Types.push_back(newType);
4601 assert(
Decl &&
"Passed null for Decl param");
4602 assert(!
Decl->TypeForDecl &&
"TypeForDecl present in slow case");
4604 if (
const auto *Typedef = dyn_cast<TypedefNameDecl>(
Decl))
4607 assert(!isa<TemplateTypeParmDecl>(
Decl) &&
4608 "Template type parameter types are always available.");
4610 if (
const auto *Record = dyn_cast<RecordDecl>(
Decl)) {
4611 assert(Record->isFirstDecl() &&
"struct/union has previous declaration");
4614 }
else if (
const auto *Enum = dyn_cast<EnumDecl>(
Decl)) {
4615 assert(Enum->isFirstDecl() &&
"enum has previous declaration");
4617 }
else if (
const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl)) {
4620 llvm_unreachable(
"TypeDecl without a type?");
4632 Underlying =
Decl->getUnderlyingType();
4636 Decl->TypeForDecl = newType;
4637 Types.push_back(newType);
4643 llvm::FoldingSetNodeID
ID;
4646 void *InsertPos =
nullptr;
4647 UsingType *T = UsingTypes.FindNodeOrInsertPos(
ID, InsertPos);
4657 Types.push_back(NewType);
4658 UsingTypes.InsertNode(NewType, InsertPos);
4666 if (PrevDecl->TypeForDecl)
4667 return QualType(
Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
4670 Decl->TypeForDecl = newType;
4671 Types.push_back(newType);
4679 if (PrevDecl->TypeForDecl)
4680 return QualType(
Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
4683 Decl->TypeForDecl = newType;
4684 Types.push_back(newType);
4690 if (
Decl->TypeForDecl)
4695 if (CanonicalDecl->TypeForDecl)
4696 return QualType(
Decl->TypeForDecl = CanonicalDecl->TypeForDecl, 0);
4699 Decl->TypeForDecl = newType;
4700 Types.push_back(newType);
4707 llvm::FoldingSetNodeID id;
4710 void *insertPos =
nullptr;
4718 Types.push_back(
type);
4719 AttributedTypes.InsertNode(
type, insertPos);
4726 llvm::FoldingSetNodeID
ID;
4729 void *InsertPos =
nullptr;
4731 BTFTagAttributedTypes.FindNodeOrInsertPos(
ID, InsertPos);
4738 Types.push_back(Ty);
4739 BTFTagAttributedTypes.InsertNode(Ty, InsertPos);
4749 &&
"replacement types must always be canonical");
4751 llvm::FoldingSetNodeID
ID;
4753 void *InsertPos =
nullptr;
4755 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(
ID, InsertPos);
4760 Types.push_back(SubstParm);
4761 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
4774 assert(
P.getAsType().isCanonical() &&
"Pack contains non-canonical type");
4778 llvm::FoldingSetNodeID
ID;
4780 void *InsertPos =
nullptr;
4782 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(
ID, InsertPos))
4790 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(
ID, InsertPos);
4796 Types.push_back(SubstParm);
4797 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
4807 llvm::FoldingSetNodeID
ID;
4809 void *InsertPos =
nullptr;
4811 = TemplateTypeParmTypes.FindNodeOrInsertPos(
ID, InsertPos);
4821 = TemplateTypeParmTypes.FindNodeOrInsertPos(
ID, InsertPos);
4822 assert(!TypeCheck &&
"Template type parameter canonical type broken");
4828 Types.push_back(TypeParm);
4829 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
4839 assert(!Name.getAsDependentTemplateName() &&
4840 "No dependent template names here!");
4850 for (
unsigned i = 0, e = TL.
getNumArgs(); i != e; ++i)
4860 "No dependent template names here!");
4863 ArgVec.reserve(Args.
size());
4865 ArgVec.push_back(Arg.getArgument());
4873 if (Arg.isPackExpansion())
4885 "No dependent template names here!");
4888 Template = QTN->getUnderlyingTemplate();
4893 if (!Underlying.
isNull())
4899 "Caller must compute aliased type");
4900 IsTypeAlias =
false;
4909 (IsTypeAlias?
sizeof(
QualType) : 0),
4913 IsTypeAlias ? Underlying :
QualType());
4915 Types.push_back(Spec);
4923 bool AnyNonCanonArgs =
false;
4924 unsigned NumArgs = OrigArgs.size();
4925 CanonArgs.resize(NumArgs);
4926 for (
unsigned I = 0; I != NumArgs; ++I) {
4929 CanonArg = C.getCanonicalTemplateArgument(OrigArg);
4931 AnyNonCanonArgs =
true;
4933 return AnyNonCanonArgs;
4939 "No dependent template names here!");
4952 llvm::FoldingSetNodeID
ID;
4956 void *InsertPos =
nullptr;
4958 = TemplateSpecializationTypes.FindNodeOrInsertPos(
ID, InsertPos);
4968 Types.push_back(Spec);
4969 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
4973 "Non-dependent template-id type must have a canonical type");
4980 TagDecl *OwnedTagDecl)
const {
4981 llvm::FoldingSetNodeID
ID;
4984 void *InsertPos =
nullptr;
4992 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(
ID, InsertPos);
4993 assert(!CheckT &&
"Elaborated canonical type broken");
4997 void *Mem =
Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
4999 T =
new (Mem)
ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
5002 ElaboratedTypes.InsertNode(T, InsertPos);
5008 llvm::FoldingSetNodeID
ID;
5011 void *InsertPos =
nullptr;
5012 ParenType *T = ParenTypes.FindNodeOrInsertPos(
ID, InsertPos);
5019 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(
ID, InsertPos);
5020 assert(!CheckT &&
"Paren canonical type broken");
5026 ParenTypes.InsertNode(T, InsertPos);
5039 Types.push_back(newType);
5049 if (CanonNNS != NNS)
5053 llvm::FoldingSetNodeID
ID;
5056 void *InsertPos =
nullptr;
5058 = DependentNameTypes.FindNodeOrInsertPos(
ID, InsertPos);
5064 DependentNameTypes.InsertNode(T, InsertPos);
5076 for (
unsigned I = 0, E = Args.
size(); I != E; ++I)
5088 "nested-name-specifier must be dependent");
5090 llvm::FoldingSetNodeID
ID;
5094 void *InsertPos =
nullptr;
5096 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(
ID, InsertPos);
5106 bool AnyNonCanonArgs =
5110 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
5116 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(
ID, InsertPos);
5125 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
5131 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
5137 }
else if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
5139 NTTP->getType().getNonPackExpansionType().getNonLValueExprType(*
this);
5147 *
this, NTTP,
false, T,
5150 if (NTTP->isParameterPack())
5155 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
5171 Args.reserve(Args.size() + Params->
size());
5179 bool ExpectPackInType) {
5181 "Pack expansions must expand one or more parameter packs");
5183 llvm::FoldingSetNodeID
ID;
5186 void *InsertPos =
nullptr;
5198 PackExpansionTypes.FindNodeOrInsertPos(
ID, InsertPos);
5204 PackExpansionTypes.InsertNode(T, InsertPos);
5216 if (Protocols.empty())
return true;
5221 for (
unsigned i = 1; i != Protocols.size(); ++i)
5231 llvm::array_pod_sort(Protocols.begin(), Protocols.end(),
CmpProtocolNames);
5235 P =
P->getCanonicalDecl();
5238 auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
5239 Protocols.erase(ProtocolsEnd, Protocols.end());
5244 unsigned NumProtocols)
const {
5246 llvm::makeArrayRef(Protocols, NumProtocols),
5254 bool isKindOf)
const {
5257 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
5258 isa<ObjCInterfaceType>(baseType))
5262 llvm::FoldingSetNodeID
ID;
5264 void *InsertPos =
nullptr;
5265 if (
ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(
ID, InsertPos))
5272 if (effectiveTypeArgs.empty()) {
5274 effectiveTypeArgs = baseObject->getTypeArgs();
5281 bool typeArgsAreCanonical = llvm::all_of(
5284 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.
isCanonical()) {
5288 if (!typeArgsAreCanonical) {
5289 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
5290 for (
auto typeArg : effectiveTypeArgs)
5292 canonTypeArgs = canonTypeArgsVec;
5294 canonTypeArgs = effectiveTypeArgs;
5299 if (!protocolsSorted) {
5300 canonProtocolsVec.append(protocols.begin(), protocols.end());
5302 canonProtocols = canonProtocolsVec;
5304 canonProtocols = protocols;
5308 canonProtocols, isKindOf);
5311 ObjCObjectTypes.FindNodeOrInsertPos(
ID, InsertPos);
5315 size += typeArgs.size() *
sizeof(
QualType);
5323 ObjCObjectTypes.InsertNode(T, InsertPos);
5333 bool allowOnPointerType)
const {
5336 if (
const auto *objT = dyn_cast<ObjCTypeParamType>(
type.getTypePtr())) {
5341 if (allowOnPointerType) {
5342 if (
const auto *objPtr =
5343 dyn_cast<ObjCObjectPointerType>(
type.getTypePtr())) {
5349 protocolsVec.append(protocols.begin(), protocols.end());
5361 if (
const auto *objT = dyn_cast<ObjCObjectType>(
type.getTypePtr())){
5366 objT->getTypeArgsAsWritten(),
5368 objT->isKindOfTypeAsWritten());
5372 if (
type->isObjCObjectType()) {
5382 if (
type->isObjCIdType()) {
5385 objPtr->isKindOfType());
5390 if (
type->isObjCClassType()) {
5393 objPtr->isKindOfType());