68#include "llvm/ADT/APFixedPoint.h"
69#include "llvm/ADT/APInt.h"
70#include "llvm/ADT/APSInt.h"
71#include "llvm/ADT/ArrayRef.h"
72#include "llvm/ADT/DenseMap.h"
73#include "llvm/ADT/DenseSet.h"
74#include "llvm/ADT/FoldingSet.h"
75#include "llvm/ADT/PointerUnion.h"
76#include "llvm/ADT/STLExtras.h"
77#include "llvm/ADT/SmallPtrSet.h"
78#include "llvm/ADT/SmallVector.h"
79#include "llvm/ADT/StringExtras.h"
80#include "llvm/ADT/StringRef.h"
81#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
82#include "llvm/Support/Capacity.h"
83#include "llvm/Support/Casting.h"
84#include "llvm/Support/Compiler.h"
85#include "llvm/Support/ErrorHandling.h"
86#include "llvm/Support/MD5.h"
87#include "llvm/Support/MathExtras.h"
88#include "llvm/Support/SipHash.h"
89#include "llvm/Support/raw_ostream.h"
90#include "llvm/TargetParser/AArch64TargetParser.h"
91#include "llvm/TargetParser/Triple.h"
104using namespace clang;
128 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
133 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
134 if (VD->isStaticDataMember() &&
139 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
144 if (
const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
151 if (
const auto *ED = dyn_cast<EnumDecl>(D)) {
155 if (
const auto *TD = dyn_cast<TagDecl>(D)) {
158 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
190 Locations.emplace_back(BaseLocation);
203 Locations.emplace_back(SourceMgr.getExpansionLoc(BaseLocation));
210 Locations.emplace_back(SourceMgr.getSpellingLoc(D->
getBeginLoc()));
218 const std::map<unsigned, RawComment *> &CommentsInTheFile)
const {
221 if (RepresentativeLocForDecl.
isInvalid() ||
222 !RepresentativeLocForDecl.
isFileID())
226 if (CommentsInTheFile.empty())
232 SourceMgr.getDecomposedLoc(RepresentativeLocForDecl);
235 auto OffsetCommentBehindDecl =
236 CommentsInTheFile.lower_bound(DeclLocDecomp.second);
239 if (OffsetCommentBehindDecl != CommentsInTheFile.end()) {
240 RawComment *CommentBehindDecl = OffsetCommentBehindDecl->second;
242 LangOpts.CommentOpts.ParseAllComments) &&
249 if (SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) ==
250 Comments.getCommentBeginLine(CommentBehindDecl, DeclLocDecomp.first,
251 OffsetCommentBehindDecl->first)) {
252 return CommentBehindDecl;
259 if (OffsetCommentBehindDecl == CommentsInTheFile.begin())
262 auto OffsetCommentBeforeDecl = --OffsetCommentBehindDecl;
263 RawComment *CommentBeforeDecl = OffsetCommentBeforeDecl->second;
267 LangOpts.CommentOpts.ParseAllComments) ||
272 const unsigned CommentEndOffset =
273 Comments.getCommentEndOffset(CommentBeforeDecl);
277 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
283 StringRef
Text(Buffer + CommentEndOffset,
284 DeclLocDecomp.second - CommentEndOffset);
288 if (
Text.find_last_of(
";{}#@") != StringRef::npos)
291 return CommentBeforeDecl;
297 for (
const auto DeclLoc : DeclLocs) {
300 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
311 const FileID File = SourceMgr.getDecomposedLoc(DeclLoc).first;
315 const auto CommentsInThisFile =
Comments.getCommentsInFile(
File);
316 if (!CommentsInThisFile || CommentsInThisFile->empty())
328 assert(LangOpts.RetainCommentsFromSystemHeaders ||
330 Comments.addComment(RC, LangOpts.CommentOpts, BumpAlloc);
335 const Decl **OriginalDecl)
const {
338 OriginalDecl =
nullptr;
350 return DeclComment->second;
363 *OriginalDecl = RedeclComment->second;
366 "This decl is supposed to have comment attached.");
367 return CommentAtRedecl->second;
372 const Decl *LastCheckedRedecl = [&]() {
374 bool CanUseCommentlessCache =
false;
376 for (
auto *Redecl : CanonicalD->
redecls()) {
378 CanUseCommentlessCache =
true;
381 if (Redecl == LastChecked)
388 return CanUseCommentlessCache ? LastChecked :
nullptr;
394 if (LastCheckedRedecl) {
395 if (LastCheckedRedecl == Redecl) {
396 LastCheckedRedecl =
nullptr;
404 *OriginalDecl = Redecl;
405 return RedeclComment;
411 *OriginalDecl =
nullptr;
417 assert(Comment.
isDocumentation() || LangOpts.CommentOpts.ParseAllComments);
427 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
432 for (
const auto *Ext : ID->known_extensions()) {
436 Redeclared.push_back(RedeclaredMethod);
443 if (
Comments.empty() || Decls.empty())
447 for (
const Decl *D : Decls) {
448 if (D->isInvalidDecl())
456 File = SourceMgr.getDecomposedLoc(Loc).first;
461 if (
File.isInvalid())
464 auto CommentsInThisFile =
Comments.getCommentsInFile(
File);
465 if (!CommentsInThisFile || CommentsInThisFile->empty() ||
466 CommentsInThisFile->rbegin()->second->isAttached())
476 for (
const Decl *D : Decls) {
478 if (D->isInvalidDecl())
488 for (
const auto DeclLoc : DeclLocs) {
489 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
493 D, DeclLoc, *CommentsInThisFile)) {
504 const Decl *D)
const {
507 ThisDeclInfo->IsFilled =
false;
508 ThisDeclInfo->fill();
509 ThisDeclInfo->CommentDecl = FC->
getDecl();
510 if (!ThisDeclInfo->TemplateParameters)
520 return RC ? RC->
parse(*
this,
nullptr, D) :
nullptr;
531 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
535 if (Canonical != D) {
543 const Decl *OriginalDecl =
nullptr;
549 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
550 if (OMD && OMD->isPropertyAccessor())
557 for (
unsigned i = 0, e = Overridden.size(); i < e; i++)
561 else if (
const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
564 QualType QT = TD->getUnderlyingType();
565 if (
const auto *TT = QT->
getAs<TagType>())
569 else if (
const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
570 while (IC->getSuperClass()) {
571 IC = IC->getSuperClass();
576 else if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
581 else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
582 if (!(RD = RD->getDefinition()))
585 for (
const auto &I : RD->bases()) {
586 if (I.isVirtual() || (I.getAccessSpecifier() !=
AS_public))
600 for (
const auto &I : RD->vbases()) {
621 if (D != OriginalDecl && OriginalDecl)
629void ASTContext::CanonicalTemplateTemplateParm::Profile(
638 ID.AddInteger(Params->
size());
640 PEnd = Params->
end();
642 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
644 ID.AddBoolean(TTP->isParameterPack());
646 TTP->getNumExpansionParameters().toInternalRepresentation());
650 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
652 ID.AddBoolean(NTTP->isParameterPack());
653 ID.AddPointer(
C.getUnconstrainedType(
C.getCanonicalType(NTTP->getType()))
655 if (NTTP->isExpandedParameterPack()) {
657 ID.AddInteger(NTTP->getNumExpansionTypes());
658 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
660 ID.AddPointer(
T.getCanonicalType().getAsOpaquePtr());
663 ID.AddBoolean(
false);
673TemplateTemplateParmDecl *
677 llvm::FoldingSetNodeID ID;
678 CanonicalTemplateTemplateParm::Profile(ID, *
this, TTP);
679 void *InsertPos =
nullptr;
680 CanonicalTemplateTemplateParm *Canonical
681 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
683 return Canonical->getParam();
688 CanonParams.reserve(Params->
size());
690 PEnd = Params->
end();
694 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
699 TTP->getNumExpansionParameters());
700 CanonParams.push_back(NewTTP);
701 }
else if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
705 if (NTTP->isExpandedParameterPack()) {
708 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
710 ExpandedTInfos.push_back(
718 NTTP->getPosition(),
nullptr,
728 NTTP->getPosition(),
nullptr,
730 NTTP->isParameterPack(),
733 CanonParams.push_back(Param);
749 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
750 assert(!Canonical &&
"Shouldn't be in the map!");
754 Canonical =
new (*this) CanonicalTemplateTemplateParm(CanonTTP);
755 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
762 llvm::FoldingSetNodeID ID;
763 CanonicalTemplateTemplateParm::Profile(ID, *
this, TTP);
764 void *InsertPos =
nullptr;
765 CanonicalTemplateTemplateParm *Canonical =
766 CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
767 return Canonical ? Canonical->getParam() :
nullptr;
773 llvm::FoldingSetNodeID ID;
774 CanonicalTemplateTemplateParm::Profile(ID, *
this, CanonTTP);
775 void *InsertPos =
nullptr;
777 CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos))
778 return Existing->getParam();
779 CanonTemplateTemplateParms.InsertNode(
780 new (*
this) CanonicalTemplateTemplateParm(CanonTTP), InsertPos);
789 return NoSanitizeL->containsType(Mask, TyName);
798 if (!LangOpts.CPlusPlus)
return nullptr;
801 case TargetCXXABI::AppleARM64:
802 case TargetCXXABI::Fuchsia:
803 case TargetCXXABI::GenericARM:
804 case TargetCXXABI::iOS:
805 case TargetCXXABI::WatchOS:
806 case TargetCXXABI::GenericAArch64:
807 case TargetCXXABI::GenericMIPS:
808 case TargetCXXABI::GenericItanium:
809 case TargetCXXABI::WebAssembly:
810 case TargetCXXABI::XL:
812 case TargetCXXABI::Microsoft:
815 llvm_unreachable(
"Invalid CXXABI type!");
819 if (!InterpContext) {
822 return *InterpContext;
828 return *ParentMapCtx;
833 switch (LangOpts.getAddressSpaceMapMangling()) {
841 llvm_unreachable(
"getAddressSpaceMapMangling() doesn't cover anything.");
847 : ConstantArrayTypes(this_(), ConstantArrayTypesLog2InitSize),
848 DependentSizedArrayTypes(this_()), DependentSizedExtVectorTypes(this_()),
849 DependentAddressSpaceTypes(this_()), DependentVectorTypes(this_()),
850 DependentSizedMatrixTypes(this_()),
851 FunctionProtoTypes(this_(), FunctionProtoTypesLog2InitSize),
852 DependentTypeOfExprTypes(this_()), DependentDecltypeTypes(this_()),
853 DependentPackIndexingTypes(this_()), TemplateSpecializationTypes(this_()),
854 DependentBitIntTypes(this_()), SubstTemplateTemplateParmPacks(this_()),
855 DeducedTemplates(this_()), ArrayParameterTypes(this_()),
856 CanonTemplateTemplateParms(this_()), SourceMgr(
SM), LangOpts(LOpts),
859 LangOpts.XRayNeverInstrumentFiles,
860 LangOpts.XRayAttrListFiles,
SM)),
864 Comments(
SM), CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
872 ReleaseDeclContextMaps();
875 for (
auto &Pair : Deallocations)
876 (Pair.first)(Pair.second);
877 Deallocations.clear();
883 I = ObjCLayouts.begin(),
884 E = ObjCLayouts.end();
891 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
892 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
897 ASTRecordLayouts.clear();
899 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
900 AEnd = DeclAttrs.end();
902 A->second->~AttrVec();
905 for (
const auto &
Value : ModuleInitializers)
906 Value.second->~PerModuleInitializers();
907 ModuleInitializers.
clear();
916 TraversalScope = TopLevelDecls;
921 Deallocations.push_back({Callback,
Data});
930 llvm::errs() <<
"\n*** AST Context Stats:\n";
931 llvm::errs() <<
" " << Types.size() <<
" types total.\n";
933 unsigned counts[] = {
934#define TYPE(Name, Parent) 0,
935#define ABSTRACT_TYPE(Name, Parent)
936#include "clang/AST/TypeNodes.inc"
940 for (
unsigned i = 0, e = Types.size(); i != e; ++i) {
946 unsigned TotalBytes = 0;
947#define TYPE(Name, Parent) \
949 llvm::errs() << " " << counts[Idx] << " " << #Name \
950 << " types, " << sizeof(Name##Type) << " each " \
951 << "(" << counts[Idx] * sizeof(Name##Type) \
953 TotalBytes += counts[Idx] * sizeof(Name##Type); \
955#define ABSTRACT_TYPE(Name, Parent)
956#include "clang/AST/TypeNodes.inc"
958 llvm::errs() <<
"Total bytes = " << TotalBytes <<
"\n";
963 <<
" implicit default constructors created\n";
966 <<
" implicit copy constructors created\n";
970 <<
" implicit move constructors created\n";
973 <<
" implicit copy assignment operators created\n";
977 <<
" implicit move assignment operators created\n";
980 <<
" implicit destructors created\n";
983 llvm::errs() <<
"\n";
987 BumpAlloc.PrintStats();
991 bool NotifyListeners) {
995 Listener->RedefinedHiddenDefinition(ND, M);
1002 if (It == MergedDefModules.end())
1005 auto &Merged = It->second;
1006 llvm::DenseSet<Module*>
Found;
1007 for (
Module *&M : Merged)
1008 if (!
Found.insert(M).second)
1010 llvm::erase(Merged,
nullptr);
1017 if (MergedIt == MergedDefModules.end())
1019 return MergedIt->second;
1022void ASTContext::PerModuleInitializers::resolve(
ASTContext &Ctx) {
1023 if (LazyInitializers.empty())
1027 assert(Source &&
"lazy initializers but no external source");
1029 auto LazyInits = std::move(LazyInitializers);
1030 LazyInitializers.clear();
1032 for (
auto ID : LazyInits)
1033 Initializers.push_back(Source->GetExternalDecl(ID));
1035 assert(LazyInitializers.empty() &&
1036 "GetExternalDecl for lazy module initializer added more inits");
1042 if (
const auto *ID = dyn_cast<ImportDecl>(D)) {
1043 auto It = ModuleInitializers.find(ID->getImportedModule());
1046 if (It == ModuleInitializers.end())
1050 auto &Imported = *It->second;
1051 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
1052 Imported.resolve(*
this);
1053 auto *OnlyDecl = Imported.Initializers.front();
1059 auto *&Inits = ModuleInitializers[M];
1061 Inits =
new (*this) PerModuleInitializers;
1062 Inits->Initializers.push_back(D);
1067 auto *&Inits = ModuleInitializers[M];
1069 Inits =
new (*this) PerModuleInitializers;
1070 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
1071 IDs.begin(), IDs.end());
1075 auto It = ModuleInitializers.find(M);
1076 if (It == ModuleInitializers.end())
1079 auto *Inits = It->second;
1080 Inits->resolve(*
this);
1081 return Inits->Initializers;
1086 assert(!CurrentCXXNamedModule &&
1087 "We should set named module for ASTContext for only once");
1088 CurrentCXXNamedModule = M;
1100 auto GetRepresentativeModule = [
this](
const Module *M) {
1101 auto Iter = SameModuleLookupSet.find(M);
1102 if (Iter != SameModuleLookupSet.end())
1103 return Iter->second;
1105 const Module *RepresentativeModule =
1106 PrimaryModuleNameMap.try_emplace(M->getPrimaryModuleInterfaceName(), M)
1108 SameModuleLookupSet[M] = RepresentativeModule;
1109 return RepresentativeModule;
1112 assert(M1 &&
"Shouldn't call `isInSameModule` if both M1 and M2 are none.");
1113 return GetRepresentativeModule(M1) == GetRepresentativeModule(M2);
1117 if (!ExternCContext)
1120 return ExternCContext;
1134#define BuiltinTemplate(BTName) \
1135 BuiltinTemplateDecl *ASTContext::get##BTName##Decl() const { \
1136 if (!Decl##BTName) \
1138 buildBuiltinTemplateDecl(BTK##BTName, get##BTName##Name()); \
1139 return Decl##BTName; \
1141#include "clang/Basic/BuiltinTemplates.inc"
1154 NewDecl->
addAttr(TypeVisibilityAttr::CreateImplicit(
1155 const_cast<ASTContext &
>(*
this), TypeVisibilityAttr::Default));
1160 StringRef Name)
const {
1184 Types.push_back(Ty);
1189 assert((!this->Target || this->Target == &Target) &&
1190 "Incorrect target reinitialization");
1191 assert(
VoidTy.isNull() &&
"Context reinitialized?");
1193 this->Target = &Target;
1194 this->AuxTarget = AuxTarget;
1196 ABI.reset(createCXXABI(Target));
1200 InitBuiltinType(
VoidTy, BuiltinType::Void);
1203 InitBuiltinType(
BoolTy, BuiltinType::Bool);
1205 if (LangOpts.CharIsSigned)
1206 InitBuiltinType(
CharTy, BuiltinType::Char_S);
1208 InitBuiltinType(
CharTy, BuiltinType::Char_U);
1211 InitBuiltinType(
ShortTy, BuiltinType::Short);
1212 InitBuiltinType(
IntTy, BuiltinType::Int);
1213 InitBuiltinType(
LongTy, BuiltinType::Long);
1214 InitBuiltinType(
LongLongTy, BuiltinType::LongLong);
1224 InitBuiltinType(
FloatTy, BuiltinType::Float);
1225 InitBuiltinType(
DoubleTy, BuiltinType::Double);
1226 InitBuiltinType(
LongDoubleTy, BuiltinType::LongDouble);
1229 InitBuiltinType(
Float128Ty, BuiltinType::Float128);
1232 InitBuiltinType(
Ibm128Ty, BuiltinType::Ibm128);
1235 InitBuiltinType(
Float16Ty, BuiltinType::Float16);
1238 InitBuiltinType(
ShortAccumTy, BuiltinType::ShortAccum);
1239 InitBuiltinType(
AccumTy, BuiltinType::Accum);
1240 InitBuiltinType(
LongAccumTy, BuiltinType::LongAccum);
1244 InitBuiltinType(
ShortFractTy, BuiltinType::ShortFract);
1245 InitBuiltinType(
FractTy, BuiltinType::Fract);
1246 InitBuiltinType(
LongFractTy, BuiltinType::LongFract);
1251 InitBuiltinType(
SatAccumTy, BuiltinType::SatAccum);
1257 InitBuiltinType(
SatFractTy, BuiltinType::SatFract);
1264 InitBuiltinType(
Int128Ty, BuiltinType::Int128);
1269 InitBuiltinType(
WCharTy, BuiltinType::WChar_S);
1271 InitBuiltinType(
WCharTy, BuiltinType::WChar_U);
1272 if (LangOpts.CPlusPlus && LangOpts.WChar)
1276 WideCharTy = getFromTargetType(Target.getWCharType());
1279 WIntTy = getFromTargetType(Target.getWIntType());
1282 InitBuiltinType(
Char8Ty, BuiltinType::Char8);
1284 if (LangOpts.CPlusPlus)
1285 InitBuiltinType(
Char16Ty, BuiltinType::Char16);
1287 Char16Ty = getFromTargetType(Target.getChar16Type());
1289 if (LangOpts.CPlusPlus)
1290 InitBuiltinType(
Char32Ty, BuiltinType::Char32);
1292 Char32Ty = getFromTargetType(Target.getChar32Type());
1299 InitBuiltinType(
DependentTy, BuiltinType::Dependent);
1302 InitBuiltinType(
OverloadTy, BuiltinType::Overload);
1314 InitBuiltinType(
UnknownAnyTy, BuiltinType::UnknownAny);
1320 InitBuiltinType(
BuiltinFnTy, BuiltinType::BuiltinFn);
1323 if (LangOpts.OpenMP) {
1330 if (LangOpts.OpenACC && !LangOpts.OpenMP) {
1333 if (LangOpts.MatrixTypes)
1341 if (LangOpts.OpenCL) {
1342#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1343 InitBuiltinType(SingletonId, BuiltinType::Id);
1344#include "clang/Basic/OpenCLImageTypes.def"
1346 InitBuiltinType(
OCLSamplerTy, BuiltinType::OCLSampler);
1347 InitBuiltinType(
OCLEventTy, BuiltinType::OCLEvent);
1349 InitBuiltinType(
OCLQueueTy, BuiltinType::OCLQueue);
1352#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1353 InitBuiltinType(Id##Ty, BuiltinType::Id);
1354#include "clang/Basic/OpenCLExtensionTypes.def"
1357 if (LangOpts.HLSL) {
1358#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1359 InitBuiltinType(SingletonId, BuiltinType::Id);
1360#include "clang/Basic/HLSLIntangibleTypes.def"
1363 if (Target.hasAArch64ACLETypes() ||
1364 (AuxTarget && AuxTarget->hasAArch64ACLETypes())) {
1365#define SVE_TYPE(Name, Id, SingletonId) \
1366 InitBuiltinType(SingletonId, BuiltinType::Id);
1367#include "clang/Basic/AArch64ACLETypes.def"
1370 if (Target.getTriple().isPPC64()) {
1371#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \
1372 InitBuiltinType(Id##Ty, BuiltinType::Id);
1373#include "clang/Basic/PPCTypes.def"
1374#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \
1375 InitBuiltinType(Id##Ty, BuiltinType::Id);
1376#include "clang/Basic/PPCTypes.def"
1379 if (Target.hasRISCVVTypes()) {
1380#define RVV_TYPE(Name, Id, SingletonId) \
1381 InitBuiltinType(SingletonId, BuiltinType::Id);
1382#include "clang/Basic/RISCVVTypes.def"
1385 if (Target.getTriple().isWasm() && Target.hasFeature(
"reference-types")) {
1386#define WASM_TYPE(Name, Id, SingletonId) \
1387 InitBuiltinType(SingletonId, BuiltinType::Id);
1388#include "clang/Basic/WebAssemblyReferenceTypes.def"
1391 if (Target.getTriple().isAMDGPU() ||
1392 (AuxTarget && AuxTarget->getTriple().isAMDGPU())) {
1393#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1394 InitBuiltinType(SingletonId, BuiltinType::Id);
1395#include "clang/Basic/AMDGPUTypes.def"
1402 ObjCConstantStringType =
QualType();
1407 if (LangOpts.OpenCLGenericAddressSpace) {
1408 auto Q =
VoidTy.getQualifiers();
1417 InitBuiltinType(
NullPtrTy, BuiltinType::NullPtr);
1420 InitBuiltinType(
HalfTy, BuiltinType::Half);
1422 InitBuiltinType(
BFloat16Ty, BuiltinType::BFloat16);
1428 if (LangOpts.MicrosoftExt || LangOpts.Borland) {
1435 return SourceMgr.getDiagnostics();
1450 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1451 if (Pos != DeclAttrs.end()) {
1452 Pos->second->~AttrVec();
1453 DeclAttrs.erase(Pos);
1467 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1468 TemplateOrInstantiation.find(Var);
1469 if (Pos == TemplateOrInstantiation.end())
1482 Tmpl, TSK, PointOfInstantiation));
1488 assert(!TemplateOrInstantiation[Inst] &&
1489 "Already noted what the variable was instantiated from");
1490 TemplateOrInstantiation[Inst] = TSI;
1495 return InstantiatedFromUsingDecl.lookup(UUD);
1503 "pattern decl is not a using decl");
1507 "instantiation did not produce a using decl");
1508 assert(!InstantiatedFromUsingDecl[Inst] &&
"pattern already exists");
1509 InstantiatedFromUsingDecl[Inst] = Pattern;
1514 return InstantiatedFromUsingEnumDecl.lookup(UUD);
1519 assert(!InstantiatedFromUsingEnumDecl[Inst] &&
"pattern already exists");
1520 InstantiatedFromUsingEnumDecl[Inst] = Pattern;
1525 return InstantiatedFromUsingShadowDecl.lookup(Inst);
1531 assert(!InstantiatedFromUsingShadowDecl[Inst] &&
"pattern already exists");
1532 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1537 return InstantiatedFromUnnamedFieldDecl.lookup(Field);
1543 "Instantiated field decl is not unnamed");
1545 "Template field decl is not unnamed");
1546 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1547 "Already noted what unnamed field was instantiated from");
1549 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1565 return Range.end() - Range.begin();
1570 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1571 OverriddenMethods.find(
Method->getCanonicalDecl());
1572 if (Pos == OverriddenMethods.end())
1580 OverriddenMethods[
Method].push_back(Overridden);
1588 if (
const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1594 const auto *
Method = dyn_cast<ObjCMethodDecl>(D);
1599 Method->getOverriddenMethods(OverDecls);
1600 Overridden.append(OverDecls.begin(), OverDecls.end());
1603std::optional<ASTContext::CXXRecordDeclRelocationInfo>
1607 auto it = RelocatableClasses.find(D);
1608 if (it != RelocatableClasses.end())
1609 return it->getSecond();
1610 return std::nullopt;
1617 assert(RelocatableClasses.find(D) == RelocatableClasses.end());
1618 RelocatableClasses.insert({D, Info});
1623 if (!Class->isPolymorphic())
1625 const CXXRecordDecl *BaseType = Context.baseForVTableAuthentication(Class);
1626 using AuthAttr = VTablePointerAuthenticationAttr;
1627 const AuthAttr *ExplicitAuth = BaseType->
getAttr<AuthAttr>();
1629 return Context.getLangOpts().PointerAuthVTPtrAddressDiscrimination;
1630 AuthAttr::AddressDiscriminationMode AddressDiscrimination =
1631 ExplicitAuth->getAddressDiscrimination();
1632 if (AddressDiscrimination == AuthAttr::DefaultAddressDiscrimination)
1633 return Context.getLangOpts().PointerAuthVTPtrAddressDiscrimination;
1634 return AddressDiscrimination == AuthAttr::AddressDiscrimination;
1637ASTContext::PointerAuthContent
1638ASTContext::findPointerAuthContent(QualType
T)
const {
1639 assert(isPointerAuthenticationAvailable());
1641 T =
T.getCanonicalType();
1643 return PointerAuthContent::None;
1645 if (
T.hasAddressDiscriminatedPointerAuth())
1646 return PointerAuthContent::AddressDiscriminatedData;
1649 return PointerAuthContent::None;
1651 if (
auto Existing = RecordContainsAddressDiscriminatedPointerAuth.find(RD);
1652 Existing != RecordContainsAddressDiscriminatedPointerAuth.end())
1653 return Existing->second;
1655 PointerAuthContent
Result = PointerAuthContent::None;
1657 auto SaveResultAndReturn = [&]() -> PointerAuthContent {
1658 auto [ResultIter, DidAdd] =
1659 RecordContainsAddressDiscriminatedPointerAuth.try_emplace(RD,
Result);
1665 auto ShouldContinueAfterUpdate = [&](PointerAuthContent NewResult) {
1666 static_assert(PointerAuthContent::None <
1667 PointerAuthContent::AddressDiscriminatedVTable);
1668 static_assert(PointerAuthContent::AddressDiscriminatedVTable <
1669 PointerAuthContent::AddressDiscriminatedData);
1672 return Result != PointerAuthContent::AddressDiscriminatedData;
1674 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1676 !ShouldContinueAfterUpdate(
1677 PointerAuthContent::AddressDiscriminatedVTable))
1678 return SaveResultAndReturn();
1679 for (
auto Base : CXXRD->bases()) {
1680 if (!ShouldContinueAfterUpdate(findPointerAuthContent(
Base.getType())))
1681 return SaveResultAndReturn();
1684 for (
auto *FieldDecl : RD->
fields()) {
1685 if (!ShouldContinueAfterUpdate(
1686 findPointerAuthContent(FieldDecl->getType())))
1687 return SaveResultAndReturn();
1689 return SaveResultAndReturn();
1693 assert(!Import->getNextLocalImport() &&
1694 "Import declaration already in the chain");
1695 assert(!Import->isFromASTFile() &&
"Non-local import declaration");
1696 if (!FirstLocalImport) {
1697 FirstLocalImport = Import;
1698 LastLocalImport = Import;
1702 LastLocalImport->setNextLocalImport(Import);
1703 LastLocalImport = Import;
1715 llvm_unreachable(
"Not a floating point type!");
1716 case BuiltinType::BFloat16:
1717 return Target->getBFloat16Format();
1718 case BuiltinType::Float16:
1719 return Target->getHalfFormat();
1720 case BuiltinType::Half:
1721 return Target->getHalfFormat();
1722 case BuiltinType::Float:
return Target->getFloatFormat();
1723 case BuiltinType::Double:
return Target->getDoubleFormat();
1724 case BuiltinType::Ibm128:
1725 return Target->getIbm128Format();
1726 case BuiltinType::LongDouble:
1728 return AuxTarget->getLongDoubleFormat();
1729 return Target->getLongDoubleFormat();
1730 case BuiltinType::Float128:
1732 return AuxTarget->getFloat128Format();
1733 return Target->getFloat128Format();
1738 unsigned Align = Target->getCharWidth();
1742 Align = AlignFromAttr;
1750 bool UseAlignAttrOnly;
1751 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(D))
1753 FD->hasAttr<PackedAttr>() || FD->getParent()->hasAttr<PackedAttr>();
1755 UseAlignAttrOnly = AlignFromAttr != 0;
1758 if (UseAlignAttrOnly) {
1760 }
else if (
const auto *VD = dyn_cast<ValueDecl>(D)) {
1764 T = RT->getPointeeType();
1769 if (
T->isFunctionType())
1770 Align = getTypeInfoImpl(
T.getTypePtr()).Align;
1775 unsigned MinWidth = Target->getLargeArrayMinWidth();
1776 if (!ForAlignof && MinWidth) {
1778 Align = std::max(Align, Target->getLargeArrayAlign());
1781 Align = std::max(Align, Target->getLargeArrayAlign());
1786 Align = Target->getCharWidth();
1790 if (
const auto *VD = dyn_cast<VarDecl>(D))
1791 if (VD->hasGlobalStorage() && !ForAlignof) {
1802 if (
const auto *Field = dyn_cast<FieldDecl>(VD)) {
1816 uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1817 if (LowBitOfOffset < FieldAlign)
1818 FieldAlign =
static_cast<unsigned>(LowBitOfOffset);
1821 Align = std::min(Align, FieldAlign);
1829 const auto *VD = dyn_cast<VarDecl>(D);
1830 if (MaxAlignedAttr && VD && VD->getStorageClass() ==
SC_Static)
1831 Align = std::min(Align, MaxAlignedAttr);
1851 if (
const auto *RD =
T->getAsCXXRecordDecl(); RD && !RD->
isInvalidDecl()) {
1868 (uint64_t)(-1)/Size) &&
1869 "Overflow in array type char size evaluation");
1872 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1874 Width = llvm::alignTo(Width, Align);
1881 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
1899 switch (BT->getKind()) {
1900 case BuiltinType::Bool:
1901 case BuiltinType::Char_S:
1902 case BuiltinType::Char_U:
1903 case BuiltinType::SChar:
1904 case BuiltinType::UChar:
1905 case BuiltinType::Short:
1906 case BuiltinType::UShort:
1907 case BuiltinType::WChar_S:
1908 case BuiltinType::WChar_U:
1909 case BuiltinType::Char8:
1910 case BuiltinType::Char16:
1911 case BuiltinType::Char32:
1919 if (
const auto *ED =
T->getAsEnumDecl()) {
1920 if (
T->isDependentType() || ED->getPromotionType().isNull() ||
1939 bool NeedsPreferredAlignment)
const {
1942 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1947 if (!
T->isIncompleteType())
1953 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1957 if (
const auto *TD =
T->getAsTagDecl())
1958 return TD->getMaxAlignment();
1964 TypeInfoMap::iterator I = MemoizedTypeInfo.find(
T);
1965 if (I != MemoizedTypeInfo.end())
1970 MemoizedTypeInfo[
T] = TI;
1985 switch (
T->getTypeClass()) {
1986#define TYPE(Class, Base)
1987#define ABSTRACT_TYPE(Class, Base)
1988#define NON_CANONICAL_TYPE(Class, Base)
1989#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1990#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1992 assert(!T->isDependentType() && "should not see dependent types here"); \
1993 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1994#include "clang/AST/TypeNodes.inc"
1995 llvm_unreachable(
"Should not see dependent types");
1997 case Type::FunctionNoProto:
1998 case Type::FunctionProto:
2004 case Type::IncompleteArray:
2005 case Type::VariableArray:
2006 case Type::ConstantArray:
2007 case Type::ArrayParameter: {
2010 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
2011 Size = CAT->getZExtSize();
2014 assert((Size == 0 || EltInfo.
Width <= (uint64_t)(-1) / Size) &&
2015 "Overflow in array type bit size evaluation");
2016 Width = EltInfo.
Width * Size;
2017 Align = EltInfo.
Align;
2021 Width = llvm::alignTo(Width, Align);
2025 case Type::ExtVector:
2026 case Type::Vector: {
2029 Width = VT->isPackedVectorBoolType(*
this)
2030 ? VT->getNumElements()
2031 : EltInfo.
Width * VT->getNumElements();
2033 Width = std::max<unsigned>(8, Width);
2034 Align = std::max<unsigned>(8, Width);
2038 if (Align & (Align-1)) {
2039 Align = llvm::bit_ceil(Align);
2040 Width = llvm::alignTo(Width, Align);
2043 uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
2044 if (TargetVectorAlign && TargetVectorAlign < Align)
2045 Align = TargetVectorAlign;
2059 Align = std::min<unsigned>(64, Width);
2063 case Type::ConstantMatrix: {
2065 TypeInfo ElementInfo =
getTypeInfo(MT->getElementType());
2069 Width = ElementInfo.
Width * MT->getNumRows() * MT->getNumColumns();
2070 Align = ElementInfo.
Align;
2076 default: llvm_unreachable(
"Unknown builtin type!");
2077 case BuiltinType::Void:
2082 case BuiltinType::Bool:
2083 Width = Target->getBoolWidth();
2084 Align = Target->getBoolAlign();
2086 case BuiltinType::Char_S:
2087 case BuiltinType::Char_U:
2088 case BuiltinType::UChar:
2089 case BuiltinType::SChar:
2090 case BuiltinType::Char8:
2091 Width = Target->getCharWidth();
2092 Align = Target->getCharAlign();
2094 case BuiltinType::WChar_S:
2095 case BuiltinType::WChar_U:
2096 Width = Target->getWCharWidth();
2097 Align = Target->getWCharAlign();
2099 case BuiltinType::Char16:
2100 Width = Target->getChar16Width();
2101 Align = Target->getChar16Align();
2103 case BuiltinType::Char32:
2104 Width = Target->getChar32Width();
2105 Align = Target->getChar32Align();
2107 case BuiltinType::UShort:
2108 case BuiltinType::Short:
2109 Width = Target->getShortWidth();
2110 Align = Target->getShortAlign();
2112 case BuiltinType::UInt:
2113 case BuiltinType::Int:
2114 Width = Target->getIntWidth();
2115 Align = Target->getIntAlign();
2117 case BuiltinType::ULong:
2118 case BuiltinType::Long:
2119 Width = Target->getLongWidth();
2120 Align = Target->getLongAlign();
2122 case BuiltinType::ULongLong:
2123 case BuiltinType::LongLong:
2124 Width = Target->getLongLongWidth();
2125 Align = Target->getLongLongAlign();
2127 case BuiltinType::Int128:
2128 case BuiltinType::UInt128:
2130 Align = Target->getInt128Align();
2132 case BuiltinType::ShortAccum:
2133 case BuiltinType::UShortAccum:
2134 case BuiltinType::SatShortAccum:
2135 case BuiltinType::SatUShortAccum:
2136 Width = Target->getShortAccumWidth();
2137 Align = Target->getShortAccumAlign();
2139 case BuiltinType::Accum:
2140 case BuiltinType::UAccum:
2141 case BuiltinType::SatAccum:
2142 case BuiltinType::SatUAccum:
2143 Width = Target->getAccumWidth();
2144 Align = Target->getAccumAlign();
2146 case BuiltinType::LongAccum:
2147 case BuiltinType::ULongAccum:
2148 case BuiltinType::SatLongAccum:
2149 case BuiltinType::SatULongAccum:
2150 Width = Target->getLongAccumWidth();
2151 Align = Target->getLongAccumAlign();
2153 case BuiltinType::ShortFract:
2154 case BuiltinType::UShortFract:
2155 case BuiltinType::SatShortFract:
2156 case BuiltinType::SatUShortFract:
2157 Width = Target->getShortFractWidth();
2158 Align = Target->getShortFractAlign();
2160 case BuiltinType::Fract:
2161 case BuiltinType::UFract:
2162 case BuiltinType::SatFract:
2163 case BuiltinType::SatUFract:
2164 Width = Target->getFractWidth();
2165 Align = Target->getFractAlign();
2167 case BuiltinType::LongFract:
2168 case BuiltinType::ULongFract:
2169 case BuiltinType::SatLongFract:
2170 case BuiltinType::SatULongFract:
2171 Width = Target->getLongFractWidth();
2172 Align = Target->getLongFractAlign();
2174 case BuiltinType::BFloat16:
2175 if (Target->hasBFloat16Type()) {
2176 Width = Target->getBFloat16Width();
2177 Align = Target->getBFloat16Align();
2181 AuxTarget->hasBFloat16Type()) {
2182 Width = AuxTarget->getBFloat16Width();
2183 Align = AuxTarget->getBFloat16Align();
2186 case BuiltinType::Float16:
2187 case BuiltinType::Half:
2188 if (Target->hasFloat16Type() || !
getLangOpts().OpenMP ||
2190 Width = Target->getHalfWidth();
2191 Align = Target->getHalfAlign();
2194 "Expected OpenMP device compilation.");
2195 Width = AuxTarget->getHalfWidth();
2196 Align = AuxTarget->getHalfAlign();
2199 case BuiltinType::Float:
2200 Width = Target->getFloatWidth();
2201 Align = Target->getFloatAlign();
2203 case BuiltinType::Double:
2204 Width = Target->getDoubleWidth();
2205 Align = Target->getDoubleAlign();
2207 case BuiltinType::Ibm128:
2208 Width = Target->getIbm128Width();
2209 Align = Target->getIbm128Align();
2211 case BuiltinType::LongDouble:
2213 (Target->getLongDoubleWidth() != AuxTarget->getLongDoubleWidth() ||
2214 Target->getLongDoubleAlign() != AuxTarget->getLongDoubleAlign())) {
2215 Width = AuxTarget->getLongDoubleWidth();
2216 Align = AuxTarget->getLongDoubleAlign();
2218 Width = Target->getLongDoubleWidth();
2219 Align = Target->getLongDoubleAlign();
2222 case BuiltinType::Float128:
2223 if (Target->hasFloat128Type() || !
getLangOpts().OpenMP ||
2225 Width = Target->getFloat128Width();
2226 Align = Target->getFloat128Align();
2229 "Expected OpenMP device compilation.");
2230 Width = AuxTarget->getFloat128Width();
2231 Align = AuxTarget->getFloat128Align();
2234 case BuiltinType::NullPtr:
2239 case BuiltinType::ObjCId:
2240 case BuiltinType::ObjCClass:
2241 case BuiltinType::ObjCSel:
2245 case BuiltinType::OCLSampler:
2246 case BuiltinType::OCLEvent:
2247 case BuiltinType::OCLClkEvent:
2248 case BuiltinType::OCLQueue:
2249 case BuiltinType::OCLReserveID:
2250#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2251 case BuiltinType::Id:
2252#include "clang/Basic/OpenCLImageTypes.def"
2253#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2254 case BuiltinType::Id:
2255#include "clang/Basic/OpenCLExtensionTypes.def"
2257 Width = Target->getPointerWidth(AS);
2258 Align = Target->getPointerAlign(AS);
2268#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
2269 case BuiltinType::Id: \
2273#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
2274 case BuiltinType::Id: \
2278#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \
2279 case BuiltinType::Id: \
2283#define SVE_SCALAR_TYPE(Name, MangledName, Id, SingletonId, Bits) \
2284 case BuiltinType::Id: \
2288#include "clang/Basic/AArch64ACLETypes.def"
2289#define PPC_VECTOR_TYPE(Name, Id, Size) \
2290 case BuiltinType::Id: \
2294#include "clang/Basic/PPCTypes.def"
2295#define RVV_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, NF, IsSigned, \
2297 case BuiltinType::Id: \
2301#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \
2302 case BuiltinType::Id: \
2306#include "clang/Basic/RISCVVTypes.def"
2307#define WASM_TYPE(Name, Id, SingletonId) \
2308 case BuiltinType::Id: \
2312#include "clang/Basic/WebAssemblyReferenceTypes.def"
2313#define AMDGPU_TYPE(NAME, ID, SINGLETONID, WIDTH, ALIGN) \
2314 case BuiltinType::ID: \
2318#include "clang/Basic/AMDGPUTypes.def"
2319#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2320#include "clang/Basic/HLSLIntangibleTypes.def"
2326 case Type::ObjCObjectPointer:
2330 case Type::BlockPointer:
2332 Width = Target->getPointerWidth(AS);
2333 Align = Target->getPointerAlign(AS);
2335 case Type::LValueReference:
2336 case Type::RValueReference:
2340 Width = Target->getPointerWidth(AS);
2341 Align = Target->getPointerAlign(AS);
2345 Width = Target->getPointerWidth(AS);
2346 Align = Target->getPointerAlign(AS);
2348 case Type::MemberPointer: {
2350 CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
2355 case Type::Complex: {
2359 Width = EltInfo.
Width * 2;
2360 Align = EltInfo.
Align;
2363 case Type::ObjCObject:
2365 case Type::Adjusted:
2368 case Type::ObjCInterface: {
2370 if (ObjCI->getDecl()->isInvalidDecl()) {
2380 case Type::BitInt: {
2382 Align = Target->getBitIntAlign(EIT->getNumBits());
2383 Width = Target->getBitIntWidth(EIT->getNumBits());
2389 const TagDecl *TD = TT->getDecl()->getDefinitionOrSelf();
2402 Info.
Align = AttrAlign;
2412 AlignRequirement = RD->
hasAttr<AlignedAttr>()
2418 case Type::SubstTemplateTypeParm:
2420 getReplacementType().getTypePtr());
2423 case Type::DeducedTemplateSpecialization: {
2425 assert(!A->getDeducedType().isNull() &&
2426 "cannot request the size of an undeduced or dependent auto type");
2427 return getTypeInfo(A->getDeducedType().getTypePtr());
2433 case Type::MacroQualified:
2437 case Type::ObjCTypeParam:
2443 case Type::Typedef: {
2445 TypeInfo Info =
getTypeInfo(TT->desugar().getTypePtr());
2449 if (
unsigned AttrAlign = TT->getDecl()->getMaxAlignment()) {
2460 case Type::Attributed:
2464 case Type::CountAttributed:
2467 case Type::BTFTagAttributed:
2471 case Type::HLSLAttributedResource:
2475 case Type::HLSLInlineSpirv: {
2478 Width = ST->getSize() * 8;
2479 Align = ST->getAlignment();
2480 if (Width == 0 && Align == 0) {
2488 case Type::Atomic: {
2497 Width = Target->getCharWidth();
2499 }
else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2505 Width = llvm::bit_ceil(Width);
2508 Align =
static_cast<unsigned>(Width);
2513 case Type::PredefinedSugar:
2522 assert(llvm::isPowerOf2_32(Align) &&
"Alignment must be power of 2");
2523 return TypeInfo(Width, Align, AlignRequirement);
2527 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(
T);
2528 if (I != MemoizedUnadjustedAlign.end())
2531 unsigned UnadjustedAlign;
2532 if (
const auto *RT =
T->getAsCanonical<RecordType>()) {
2539 UnadjustedAlign =
getTypeAlign(
T->getUnqualifiedDesugaredType());
2542 MemoizedUnadjustedAlign[
T] = UnadjustedAlign;
2543 return UnadjustedAlign;
2547 unsigned SimdAlign = llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(
2597 unsigned ABIAlign = TI.
Align;
2599 T =
T->getBaseElementTypeUnsafe();
2602 if (
T->isMemberPointerType())
2605 if (!Target->allowsLargerPreferedTypeAlignment())
2608 if (
const auto *RD =
T->getAsRecordDecl()) {
2617 unsigned PreferredAlign =
static_cast<unsigned>(
2619 assert(PreferredAlign >= ABIAlign &&
2620 "PreferredAlign should be at least as large as ABIAlign.");
2621 return PreferredAlign;
2628 T = CT->getElementType().getTypePtr();
2629 if (
const auto *ED =
T->getAsEnumDecl())
2630 T = ED->getIntegerType().getTypePtr();
2631 if (
T->isSpecificBuiltinType(BuiltinType::Double) ||
2632 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2633 T->isSpecificBuiltinType(BuiltinType::ULongLong) ||
2634 (
T->isSpecificBuiltinType(BuiltinType::LongDouble) &&
2635 Target->defaultsToAIXPowerAlignment()))
2690 for (
unsigned I = 0, N = Path.size(); I != N; ++I) {
2694 std::swap(
Base, Derived);
2714 llvm::append_range(Ivars, OI->
ivars());
2717 for (
const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2719 Ivars.push_back(Iv);
2727 if (
const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2730 for (
auto *Proto : OI->all_referenced_protocols()) {
2735 for (
const auto *Cat : OI->visible_categories())
2741 SD = SD->getSuperClass();
2743 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2744 for (
auto *Proto : OC->protocols()) {
2747 }
else if (
const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2749 if (!Protocols.insert(
2753 for (
auto *Proto : OP->protocols())
2760 bool CheckIfTriviallyCopyable) {
2761 assert(RD->
isUnion() &&
"Must be union type");
2763 Context.getTypeSizeInChars(Context.getCanonicalTagType(RD));
2765 for (
const auto *Field : RD->
fields()) {
2766 if (!Context.hasUniqueObjectRepresentations(Field->getType(),
2767 CheckIfTriviallyCopyable))
2769 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2770 if (FieldSize != UnionSize)
2779 return Context.getFieldOffset(Field);
2788static std::optional<int64_t>
2790 const RecordDecl *RD,
2791 bool CheckIfTriviallyCopyable);
2793static std::optional<int64_t>
2795 bool CheckIfTriviallyCopyable) {
2796 if (
const auto *RD = Field->getType()->getAsRecordDecl();
2799 CheckIfTriviallyCopyable);
2803 bool IsBitIntType = Field->getType()->isBitIntType();
2804 if (!Field->getType()->isReferenceType() && !IsBitIntType &&
2805 !Context.hasUniqueObjectRepresentations(Field->getType(),
2806 CheckIfTriviallyCopyable))
2807 return std::nullopt;
2809 int64_t FieldSizeInBits =
2810 Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2811 if (Field->isBitField()) {
2814 if (Field->isUnnamedBitField())
2817 int64_t BitfieldSize = Field->getBitWidthValue();
2819 if ((
unsigned)BitfieldSize >
2821 return std::nullopt;
2822 }
else if (BitfieldSize > FieldSizeInBits) {
2823 return std::nullopt;
2825 FieldSizeInBits = BitfieldSize;
2826 }
else if (IsBitIntType && !Context.hasUniqueObjectRepresentations(
2827 Field->getType(), CheckIfTriviallyCopyable)) {
2828 return std::nullopt;
2830 return FieldSizeInBits;
2833static std::optional<int64_t>
2835 bool CheckIfTriviallyCopyable) {
2837 CheckIfTriviallyCopyable);
2840template <
typename RangeT>
2842 const RangeT &Subobjects, int64_t CurOffsetInBits,
2844 bool CheckIfTriviallyCopyable) {
2845 for (
const auto *Subobject : Subobjects) {
2846 std::optional<int64_t> SizeInBits =
2849 return std::nullopt;
2850 if (*SizeInBits != 0) {
2852 if (Offset != CurOffsetInBits)
2853 return std::nullopt;
2854 CurOffsetInBits += *SizeInBits;
2857 return CurOffsetInBits;
2860static std::optional<int64_t>
2863 bool CheckIfTriviallyCopyable) {
2864 assert(!RD->
isUnion() &&
"Must be struct/class type");
2865 const auto &Layout = Context.getASTRecordLayout(RD);
2867 int64_t CurOffsetInBits = 0;
2868 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2869 if (ClassDecl->isDynamicClass())
2870 return std::nullopt;
2873 for (
const auto &
Base : ClassDecl->bases()) {
2876 Bases.emplace_back(
Base.getType()->getAsCXXRecordDecl());
2880 return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
2883 std::optional<int64_t> OffsetAfterBases =
2885 Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);
2886 if (!OffsetAfterBases)
2887 return std::nullopt;
2888 CurOffsetInBits = *OffsetAfterBases;
2891 std::optional<int64_t> OffsetAfterFields =
2893 RD->
fields(), CurOffsetInBits, Context, Layout,
2894 CheckIfTriviallyCopyable);
2895 if (!OffsetAfterFields)
2896 return std::nullopt;
2897 CurOffsetInBits = *OffsetAfterFields;
2899 return CurOffsetInBits;
2903 QualType Ty,
bool CheckIfTriviallyCopyable)
const {
2920 assert(!Ty.
isNull() &&
"Null QualType sent to unique object rep check");
2925 CheckIfTriviallyCopyable);
2928 "hasUniqueObjectRepresentations should not be called with an "
2952 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2955 if (
Record->isInvalidDecl())
2960 CheckIfTriviallyCopyable);
2963 *
this,
Record, CheckIfTriviallyCopyable);
2965 return StructSize && *StructSize ==
static_cast<int64_t
>(
getTypeSize(Ty));
2986 count += Ext->ivar_size();
2991 count += ImplDecl->ivar_size();
3017 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
3018 I = ObjCImpls.find(D);
3019 if (I != ObjCImpls.end())
3027 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
3028 I = ObjCImpls.find(D);
3029 if (I != ObjCImpls.end())
3037 assert(IFaceD && ImplD &&
"Passed null params");
3038 ObjCImpls[IFaceD] = ImplD;
3044 assert(CatD && ImplD &&
"Passed null params");
3045 ObjCImpls[CatD] = ImplD;
3050 return ObjCMethodRedecls.
lookup(MD);
3056 ObjCMethodRedecls[MD] = Redecl;
3061 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->
getDeclContext()))
3063 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->
getDeclContext()))
3064 return CD->getClassInterface();
3065 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(ND->
getDeclContext()))
3066 return IMD->getClassInterface();
3074 assert(VD &&
"Passed null params");
3075 assert(VD->
hasAttr<BlocksAttr>() &&
3076 "getBlockVarCopyInits - not __block var");
3077 auto I = BlockVarCopyInits.find(VD);
3078 if (I != BlockVarCopyInits.end())
3080 return {
nullptr,
false};
3086 assert(VD && CopyExpr &&
"Passed null params");
3087 assert(VD->
hasAttr<BlocksAttr>() &&
3088 "setBlockVarCopyInits - not __block var");
3089 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr,
CanThrow);
3093 unsigned DataSize)
const {
3098 "incorrect data size provided to CreateTypeSourceInfo!");
3115 return getObjCLayout(D);
3120 bool &AnyNonCanonArgs) {
3122 AnyNonCanonArgs |=
C.canonicalizeTemplateArguments(CanonArgs);
3128 bool AnyNonCanonArgs =
false;
3129 for (
auto &Arg : Args) {
3132 AnyNonCanonArgs |= !Arg.structurallyEquals(OrigArg);
3134 return AnyNonCanonArgs;
3142ASTContext::getExtQualType(
const Type *baseType,
Qualifiers quals)
const {
3147 llvm::FoldingSetNodeID ID;
3149 void *insertPos =
nullptr;
3150 if (
ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
3151 assert(eq->getQualifiers() == quals);
3160 canon = getExtQualType(canonSplit.
Ty, canonSplit.
Quals);
3163 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
3166 auto *eq =
new (*
this,
alignof(ExtQuals)) ExtQuals(baseType, canon, quals);
3167 ExtQualNodes.InsertNode(eq, insertPos);
3168 return QualType(eq, fastQuals);
3172 LangAS AddressSpace)
const {
3185 "Type cannot be in multiple addr spaces!");
3188 return getExtQualType(TypeNode, Quals);
3194 if (!
T.hasAddressSpace())
3198 const Type *TypeNode;
3201 if (
T.getTypePtr()->isArrayType()) {
3203 TypeNode =
T.getTypePtr();
3207 while (
T.hasAddressSpace()) {
3208 TypeNode = Quals.
strip(
T);
3212 if (!
QualType(TypeNode, 0).hasAddressSpace())
3216 T =
T.getSingleStepDesugaredType(*
this);
3226 return getExtQualType(TypeNode, Quals);
3234 "Attempted to get vtable pointer discriminator on a monomorphic type");
3237 llvm::raw_svector_ostream Out(Str);
3238 MC->mangleCXXVTable(RD, Out);
3239 return llvm::getPointerAuthStableSipHash(Str);
3265 switch (
T->getTypeClass()) {
3270 case Type::LValueReference:
3275 case Type::RValueReference:
3289 case Type::ObjCObjectPointer:
3290 case Type::BlockPointer:
3299 case Type::VariableArray:
3300 case Type::ConstantArray:
3301 case Type::IncompleteArray:
3302 case Type::ArrayParameter:
3315 case Type::ObjCInterface:
3316 case Type::ObjCObject:
3317 OS <<
"<objc_object>";
3326 QualType UnderlyingType =
T->castAsEnumDecl()->getIntegerType();
3328 Ctx, OS, UnderlyingType.
isNull() ? Ctx.
IntTy : UnderlyingType);
3331 case Type::FunctionNoProto:
3332 case Type::FunctionProto: {
3348 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FuncType)) {
3349 for (
QualType Param : FPT->param_types()) {
3353 if (FPT->isVariadic())
3360 case Type::MemberPointer: {
3364 Ctx, OS,
QualType(MPT->getQualifier().getAsType(), 0));
3368 case Type::ExtVector:
3376 case Type::ConstantMatrix:
3380 case Type::Builtin: {
3382 switch (BTy->getKind()) {
3383#define SIGNED_TYPE(Id, SingletonId) \
3384 case BuiltinType::Id: \
3387#define UNSIGNED_TYPE(Id, SingletonId) \
3388 case BuiltinType::Id: \
3391#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
3392#define BUILTIN_TYPE(Id, SingletonId)
3393#include "clang/AST/BuiltinTypes.def"
3394 llvm_unreachable(
"placeholder types should not appear here.");
3396 case BuiltinType::Half:
3399 case BuiltinType::Float:
3402 case BuiltinType::Double:
3405 case BuiltinType::LongDouble:
3408 case BuiltinType::Float16:
3411 case BuiltinType::Float128:
3415 case BuiltinType::Void:
3419 case BuiltinType::ObjCId:
3420 case BuiltinType::ObjCClass:
3421 case BuiltinType::ObjCSel:
3422 case BuiltinType::NullPtr:
3427 case BuiltinType::OCLSampler:
3428 case BuiltinType::OCLEvent:
3429 case BuiltinType::OCLClkEvent:
3430 case BuiltinType::OCLQueue:
3431 case BuiltinType::OCLReserveID:
3432 case BuiltinType::BFloat16:
3433 case BuiltinType::VectorQuad:
3434 case BuiltinType::VectorPair:
3435 case BuiltinType::DMR1024:
3436 case BuiltinType::DMR2048:
3441 case BuiltinType::Ibm128:
3443#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3444 case BuiltinType::Id: \
3446#include "clang/Basic/OpenCLImageTypes.def"
3447#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3448 case BuiltinType::Id: \
3450#include "clang/Basic/OpenCLExtensionTypes.def"
3451#define SVE_TYPE(Name, Id, SingletonId) \
3452 case BuiltinType::Id: \
3454#include "clang/Basic/AArch64ACLETypes.def"
3455#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3456 case BuiltinType::Id: \
3458#include "clang/Basic/HLSLIntangibleTypes.def"
3459 case BuiltinType::Dependent:
3460 llvm_unreachable(
"should never get here");
3461#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
3462#include "clang/Basic/AMDGPUTypes.def"
3463 case BuiltinType::WasmExternRef:
3464#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
3465#include "clang/Basic/RISCVVTypes.def"
3466 llvm_unreachable(
"not yet implemented");
3468 llvm_unreachable(
"should never get here");
3470 case Type::Record: {
3471 const RecordDecl *RD =
T->castAsCanonical<RecordType>()->getDecl();
3491 II = Typedef->getDeclName().getAsIdentifierInfo();
3494 OS <<
"<anonymous_record>";
3500 case Type::HLSLAttributedResource:
3501 case Type::HLSLInlineSpirv:
3502 llvm_unreachable(
"should never get here");
3504 case Type::DeducedTemplateSpecialization:
3506#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3507#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3508#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3509#define ABSTRACT_TYPE(Class, Base)
3510#define TYPE(Class, Base)
3511#include "clang/AST/TypeNodes.inc"
3512 llvm_unreachable(
"unexpected non-canonical or dependent type!");
3518 assert(!
T->isDependentType() &&
3519 "cannot compute type discriminator of a dependent type");
3522 llvm::raw_svector_ostream Out(Str);
3524 if (
T->isFunctionPointerType() ||
T->isFunctionReferenceType())
3525 T =
T->getPointeeType();
3527 if (
T->isFunctionType()) {
3530 T =
T.getUnqualifiedType();
3551 if (MPT->isMemberFunctionPointer()) {
3557 MPT->getMostRecentCXXRecordDecl());
3561 MC->mangleCanonicalTypeName(
T, Out);
3564 return llvm::getPointerAuthStableSipHash(Str);
3589 "Type cannot have multiple ObjCGCs!");
3592 return getExtQualType(TypeNode, Quals);
3606 QualType WrappedTy,
Expr *CountExpr,
bool CountInBytes,
bool OrNull,
3610 llvm::FoldingSetNodeID ID;
3613 void *InsertPos =
nullptr;
3615 CountAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
3620 size_t Size = CountAttributedType::totalSizeToAlloc<TypeCoupledDeclRefInfo>(
3621 DependentDecls.size());
3624 OrNull, DependentDecls);
3625 Types.push_back(CATy);
3626 CountAttributedTypes.InsertNode(CATy, InsertPos);
3635 case Type::Attributed: {
3643 case Type::BTFTagAttributed: {
3644 const auto *BTFT = dyn_cast<BTFTagAttributedType>(Orig);
3653 case Type::Adjusted: {
3659 case Type::MacroQualified: {
3662 MQT->getMacroIdentifier());
3666 return Adjust(Orig);
3672 if (
T->getExtInfo() == Info)
3676 if (
const auto *FNPT = dyn_cast<FunctionNoProtoType>(
T)) {
3696 FPT->getExtProtoInfo());
3711 L->DeducedReturnType(FD, ResultType);
3722 return getFunctionType(Proto->getReturnType(), Proto->getParamTypes(),
3723 Proto->getExtProtoInfo().withExceptionSpec(ESI));
3739 for (
unsigned i = 0, n = Args.size(); i != n; ++i)
3762 return getFunctionType(Proto->getReturnType(), Proto->param_types(), EPI);
3788 if (TSInfo->getType() != FD->
getType())
3796 "TypeLoc size mismatch from updating exception specification");
3797 TSInfo->overrideType(Updated);
3806 llvm::FoldingSetNodeID ID;
3809 void *InsertPos =
nullptr;
3810 if (
ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
3816 if (!
T.isCanonical()) {
3820 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
3821 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3824 Types.push_back(
New);
3825 ComplexTypes.InsertNode(
New, InsertPos);
3834 llvm::FoldingSetNodeID ID;
3837 void *InsertPos =
nullptr;
3838 if (
PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3844 if (!
T.isCanonical()) {
3848 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3849 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3852 Types.push_back(
New);
3853 PointerTypes.InsertNode(
New, InsertPos);
3858 llvm::FoldingSetNodeID ID;
3860 void *InsertPos =
nullptr;
3861 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3868 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3869 assert(!AT &&
"Shouldn't be in the map!");
3873 Types.push_back(AT);
3874 AdjustedTypes.InsertNode(AT, InsertPos);
3879 llvm::FoldingSetNodeID ID;
3881 void *InsertPos =
nullptr;
3882 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3889 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3890 assert(!AT &&
"Shouldn't be in the map!");
3893 Types.push_back(AT);
3894 AdjustedTypes.InsertNode(AT, InsertPos);
3899 assert((
T->isArrayType() ||
T->isFunctionType()) &&
"T does not decay");
3908 if (
T->isArrayType())
3915 if (
T->isFunctionType())
3927 llvm::FoldingSetNodeID ID;
3928 ATy->Profile(ID, *
this, ATy->getElementType(), ATy->getZExtSize(),
3929 ATy->getSizeExpr(), ATy->getSizeModifier(),
3930 ATy->getIndexTypeQualifiers().getAsOpaqueValue());
3931 void *InsertPos =
nullptr;
3933 ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3942 AT = ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3943 assert(!AT &&
"Shouldn't be in the map!");
3948 Types.push_back(AT);
3949 ArrayParameterTypes.InsertNode(AT, InsertPos);
3956 assert(
T->isFunctionType() &&
"block of function types only");
3959 llvm::FoldingSetNodeID ID;
3962 void *InsertPos =
nullptr;
3964 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3970 if (!
T.isCanonical()) {
3975 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3976 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3980 Types.push_back(
New);
3981 BlockPointerTypes.InsertNode(
New, InsertPos);
3989 assert((!
T->isPlaceholderType() ||
3990 T->isSpecificPlaceholderType(BuiltinType::UnknownAny)) &&
3991 "Unresolved placeholder type");
3995 llvm::FoldingSetNodeID ID;
3998 void *InsertPos =
nullptr;
4000 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
4008 if (!SpelledAsLValue || InnerRef || !
T.isCanonical()) {
4009 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
4014 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
4015 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4020 Types.push_back(
New);
4021 LValueReferenceTypes.InsertNode(
New, InsertPos);
4029 assert((!
T->isPlaceholderType() ||
4030 T->isSpecificPlaceholderType(BuiltinType::UnknownAny)) &&
4031 "Unresolved placeholder type");
4035 llvm::FoldingSetNodeID ID;
4038 void *InsertPos =
nullptr;
4040 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
4048 if (InnerRef || !
T.isCanonical()) {
4049 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
4054 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
4055 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4060 Types.push_back(
New);
4061 RValueReferenceTypes.InsertNode(
New, InsertPos);
4069 assert(Cls &&
"At least one of Qualifier or Cls must be provided");
4072 Cls = Qualifier.getAsRecordDecl();
4076 llvm::FoldingSetNodeID ID;
4079 void *InsertPos =
nullptr;
4081 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4086 return Qualifier.getCanonical();
4094 if (!
T.isCanonical() || Qualifier != CanonicalQualifier) {
4100 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4101 assert(!NewIP &&
"Shouldn't be in the map!");
4105 Types.push_back(
New);
4106 MemberPointerTypes.InsertNode(
New, InsertPos);
4113 const llvm::APInt &ArySizeIn,
4114 const Expr *SizeExpr,
4116 unsigned IndexTypeQuals)
const {
4119 "Constant array of VLAs is illegal!");
4127 llvm::APInt ArySize(ArySizeIn);
4128 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
4130 llvm::FoldingSetNodeID ID;
4132 ASM, IndexTypeQuals);
4134 void *InsertPos =
nullptr;
4136 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
4147 ASM, IndexTypeQuals);
4152 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
4153 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4156 auto *
New = ConstantArrayType::Create(*
this, EltTy, Canon, ArySize, SizeExpr,
4157 ASM, IndexTypeQuals);
4158 ConstantArrayTypes.InsertNode(
New, InsertPos);
4159 Types.push_back(
New);
4168 if (!
type->isVariablyModifiedType())
return type;
4173 const Type *ty = split.
Ty;
4175#define TYPE(Class, Base)
4176#define ABSTRACT_TYPE(Class, Base)
4177#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4178#include "clang/AST/TypeNodes.inc"
4179 llvm_unreachable(
"didn't desugar past all non-canonical types?");
4185 case Type::DependentVector:
4186 case Type::ExtVector:
4187 case Type::DependentSizedExtVector:
4188 case Type::ConstantMatrix:
4189 case Type::DependentSizedMatrix:
4190 case Type::DependentAddressSpace:
4191 case Type::ObjCObject:
4192 case Type::ObjCInterface:
4193 case Type::ObjCObjectPointer:
4196 case Type::UnresolvedUsing:
4197 case Type::TypeOfExpr:
4199 case Type::Decltype:
4200 case Type::UnaryTransform:
4201 case Type::DependentName:
4202 case Type::InjectedClassName:
4203 case Type::TemplateSpecialization:
4204 case Type::TemplateTypeParm:
4205 case Type::SubstTemplateTypeParmPack:
4206 case Type::SubstBuiltinTemplatePack:
4208 case Type::DeducedTemplateSpecialization:
4209 case Type::PackExpansion:
4210 case Type::PackIndexing:
4212 case Type::DependentBitInt:
4213 case Type::ArrayParameter:
4214 case Type::HLSLAttributedResource:
4215 case Type::HLSLInlineSpirv:
4216 llvm_unreachable(
"type should never be variably-modified");
4220 case Type::FunctionNoProto:
4221 case Type::FunctionProto:
4222 case Type::BlockPointer:
4223 case Type::MemberPointer:
4236 case Type::LValueReference: {
4240 lv->isSpelledAsLValue());
4244 case Type::RValueReference: {
4251 case Type::Atomic: {
4257 case Type::ConstantArray: {
4263 cat->getSizeModifier(),
4264 cat->getIndexTypeCVRQualifiers());
4268 case Type::DependentSizedArray: {
4272 dat->getSizeModifier(), dat->getIndexTypeCVRQualifiers());
4277 case Type::IncompleteArray: {
4282 iat->getIndexTypeCVRQualifiers());
4287 case Type::VariableArray: {
4292 vat->getIndexTypeCVRQualifiers());
4305 unsigned IndexTypeQuals)
const {
4322 VariableArrayTypes.push_back(
New);
4323 Types.push_back(
New);
4333 unsigned elementTypeQuals)
const {
4336 "Size must be type- or value-dependent!");
4340 void *insertPos =
nullptr;
4341 llvm::FoldingSetNodeID ID;
4343 ID, *
this, numElements ?
QualType(canonElementType.
Ty, 0) : elementType,
4344 ASM, elementTypeQuals, numElements);
4348 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4360 DependentSizedArrayTypes.InsertNode(newType, insertPos);
4361 Types.push_back(newType);
4369 numElements, ASM, elementTypeQuals);
4370 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
4371 Types.push_back(canonTy);
4376 canonElementType.
Quals);
4380 if (
QualType(canonElementType.
Ty, 0) == elementType &&
4389 Types.push_back(sugaredType);
4395 unsigned elementTypeQuals)
const {
4396 llvm::FoldingSetNodeID ID;
4399 void *insertPos =
nullptr;
4401 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
4413 ASM, elementTypeQuals);
4418 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4419 assert(!existing &&
"Shouldn't be in the map!"); (void) existing;
4425 IncompleteArrayTypes.InsertNode(newType, insertPos);
4426 Types.push_back(newType);
4432#define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS) \
4433 {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \
4436#define SVE_ELTTY(ELTTY, ELTS, NUMVECTORS) \
4437 {ELTTY, llvm::ElementCount::getScalable(ELTS), NUMVECTORS};
4441 llvm_unreachable(
"Unsupported builtin vector type");
4443#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4444 ElBits, NF, IsSigned) \
4445 case BuiltinType::Id: \
4446 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4447 llvm::ElementCount::getScalable(NumEls), NF};
4448#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4450 case BuiltinType::Id: \
4451 return {ElBits == 16 ? HalfTy : (ElBits == 32 ? FloatTy : DoubleTy), \
4452 llvm::ElementCount::getScalable(NumEls), NF};
4453#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4455 case BuiltinType::Id: \
4456 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4457#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4459 case BuiltinType::Id: \
4460 return {MFloat8Ty, llvm::ElementCount::getScalable(NumEls), NF};
4461#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4462 case BuiltinType::Id: \
4463 return {BoolTy, llvm::ElementCount::getScalable(NumEls), NF};
4464#include "clang/Basic/AArch64ACLETypes.def"
4466#define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF, \
4468 case BuiltinType::Id: \
4469 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4470 llvm::ElementCount::getScalable(NumEls), NF};
4471#define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4472 case BuiltinType::Id: \
4473 return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy), \
4474 llvm::ElementCount::getScalable(NumEls), NF};
4475#define RVV_VECTOR_TYPE_BFLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4476 case BuiltinType::Id: \
4477 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4478#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4479 case BuiltinType::Id: \
4480 return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1};
4481#include "clang/Basic/RISCVVTypes.def"
4488 if (Target->getTriple().isWasm() && Target->hasFeature(
"reference-types")) {
4489#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
4490 if (BuiltinType::Id == BuiltinType::WasmExternRef) \
4492#include "clang/Basic/WebAssemblyReferenceTypes.def"
4495 "shouldn't try to generate type externref outside WebAssembly target");
4502 unsigned NumFields)
const {
4504 if (
auto It = ScalableVecTyMap.find(K); It != ScalableVecTyMap.end())
4507 if (Target->hasAArch64ACLETypes()) {
4510#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4511 ElBits, NF, IsSigned) \
4512 if (EltTy->hasIntegerRepresentation() && !EltTy->isBooleanType() && \
4513 EltTy->hasSignedIntegerRepresentation() == IsSigned && \
4514 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4515 return ScalableVecTyMap[K] = SingletonId; \
4517#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4519 if (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4520 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4521 return ScalableVecTyMap[K] = SingletonId; \
4523#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4525 if (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4526 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4527 return ScalableVecTyMap[K] = SingletonId; \
4529#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4531 if (EltTy->isMFloat8Type() && EltTySize == ElBits && \
4532 NumElts == (NumEls * NF) && NumFields == 1) { \
4533 return ScalableVecTyMap[K] = SingletonId; \
4535#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4536 if (EltTy->isBooleanType() && NumElts == (NumEls * NF) && NumFields == 1) \
4537 return ScalableVecTyMap[K] = SingletonId;
4538#include "clang/Basic/AArch64ACLETypes.def"
4539 }
else if (Target->hasRISCVVTypes()) {
4541#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
4543 if (!EltTy->isBooleanType() && \
4544 ((EltTy->hasIntegerRepresentation() && \
4545 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \
4546 (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4548 (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4549 IsBF && !IsFP)) && \
4550 EltTySize == ElBits && NumElts == NumEls && NumFields == NF) \
4551 return ScalableVecTyMap[K] = SingletonId;
4552#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4553 if (EltTy->isBooleanType() && NumElts == NumEls) \
4554 return ScalableVecTyMap[K] = SingletonId;
4555#include "clang/Basic/RISCVVTypes.def"
4570 llvm::FoldingSetNodeID ID;
4573 void *InsertPos =
nullptr;
4574 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4584 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4585 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4588 VectorType(vecType, NumElts, Canonical, VecKind);
4589 VectorTypes.InsertNode(
New, InsertPos);
4590 Types.push_back(
New);
4597 llvm::FoldingSetNodeID ID;
4600 void *InsertPos =
nullptr;
4602 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4607 VecType,
QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
4610 if (CanonVecTy == VecType) {
4615 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4616 assert(!CanonCheck &&
4617 "Dependent-sized vector_size canonical type broken");
4619 DependentVectorTypes.InsertNode(
New, InsertPos);
4628 Types.push_back(
New);
4635 unsigned NumElts)
const {
4642 llvm::FoldingSetNodeID ID;
4645 void *InsertPos =
nullptr;
4646 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4656 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4657 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4661 VectorTypes.InsertNode(
New, InsertPos);
4662 Types.push_back(
New);
4670 llvm::FoldingSetNodeID ID;
4674 void *InsertPos =
nullptr;
4676 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4686 if (CanonVecTy == vecType) {
4691 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4692 assert(!CanonCheck &&
"Dependent-sized ext_vector canonical type broken");
4694 DependentSizedExtVectorTypes.InsertNode(
New, InsertPos);
4703 Types.push_back(
New);
4708 unsigned NumColumns)
const {
4709 llvm::FoldingSetNodeID ID;
4711 Type::ConstantMatrix);
4714 "need a valid element type");
4715 assert(NumRows > 0 && NumRows <= LangOpts.MaxMatrixDimension &&
4716 NumColumns > 0 && NumColumns <= LangOpts.MaxMatrixDimension &&
4717 "need valid matrix dimensions");
4718 void *InsertPos =
nullptr;
4728 assert(!NewIP &&
"Matrix type shouldn't already exist in the map");
4734 MatrixTypes.InsertNode(
New, InsertPos);
4735 Types.push_back(
New);
4744 llvm::FoldingSetNodeID ID;
4748 void *InsertPos =
nullptr;
4750 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4755 ColumnExpr, AttrLoc);
4758 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4759 assert(!CanonCheck &&
"Dependent-sized matrix canonical type broken");
4761 DependentSizedMatrixTypes.InsertNode(Canon, InsertPos);
4762 Types.push_back(Canon);
4775 ColumnExpr, AttrLoc);
4776 Types.push_back(
New);
4781 Expr *AddrSpaceExpr,
4787 void *insertPos =
nullptr;
4788 llvm::FoldingSetNodeID ID;
4793 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
4799 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
4800 Types.push_back(canonTy);
4803 if (canonPointeeType == PointeeType &&
4809 AddrSpaceExpr, AttrLoc);
4810 Types.push_back(sugaredType);
4816 return T.isCanonical() &&
4834 llvm::FoldingSetNodeID ID;
4837 void *InsertPos =
nullptr;
4839 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
4849 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
4850 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4855 Types.push_back(
New);
4856 FunctionNoProtoTypes.InsertNode(
New, InsertPos);
4872 return CanResultType;
4879 if (!NoexceptInType)
4896 bool AnyPackExpansions =
false;
4900 if (ET->
getAs<PackExpansionType>())
4901 AnyPackExpansions =
true;
4903 return AnyPackExpansions;
4909QualType ASTContext::getFunctionTypeInternal(
4910 QualType ResultTy, ArrayRef<QualType> ArgArray,
4911 const FunctionProtoType::ExtProtoInfo &EPI,
bool OnlyWantCanonical)
const {
4912 size_t NumArgs = ArgArray.size();
4916 llvm::FoldingSetNodeID
ID;
4921 bool Unique =
false;
4923 void *InsertPos =
nullptr;
4924 if (FunctionProtoType *FPT =
4925 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
4926 QualType Existing = QualType(FPT, 0);
4945 bool IsCanonicalExceptionSpec =
4949 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
4951 for (
unsigned i = 0; i != NumArgs && isCanonical; ++i)
4952 if (!ArgArray[i].isCanonicalAsParam())
4953 isCanonical =
false;
4955 if (OnlyWantCanonical)
4956 assert(isCanonical &&
4957 "given non-canonical parameters constructing canonical type");
4962 if (!isCanonical && Canonical.
isNull()) {
4963 SmallVector<QualType, 16> CanonicalArgs;
4964 CanonicalArgs.reserve(NumArgs);
4965 for (
unsigned i = 0; i != NumArgs; ++i)
4968 llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
4969 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
4972 if (IsCanonicalExceptionSpec) {
4974 }
else if (NoexceptInType) {
4987 bool AnyPacks =
false;
4989 if (ET->
getAs<PackExpansionType>())
5010 llvm_unreachable(
"dependent noexcept is already canonical");
5013 CanonicalEPI.
ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
5019 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI,
true);
5022 FunctionProtoType *NewIP =
5023 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
5024 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
5029 auto ESH = FunctionProtoType::getExceptionSpecSize(
5031 size_t Size = FunctionProtoType::totalSizeToAlloc<
5032 QualType, SourceLocation, FunctionType::FunctionTypeExtraBitfields,
5033 FunctionType::FunctionTypeExtraAttributeInfo,
5034 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
5035 Expr *, FunctionDecl *, FunctionProtoType::ExtParameterInfo, Qualifiers,
5036 FunctionEffect, EffectConditionExpr>(
5040 ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
5045 auto *FTP = (FunctionProtoType *)
Allocate(Size,
alignof(FunctionProtoType));
5046 FunctionProtoType::ExtProtoInfo newEPI = EPI;
5047 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
5048 Types.push_back(FTP);
5050 FunctionProtoTypes.InsertNode(FTP, InsertPos);
5052 AnyFunctionEffects =
true;
5053 return QualType(FTP, 0);
5056QualType ASTContext::getPipeType(QualType
T,
bool ReadOnly)
const {
5057 llvm::FoldingSetNodeID
ID;
5060 void *InsertPos =
nullptr;
5061 if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
5062 return QualType(PT, 0);
5067 if (!
T.isCanonical()) {
5071 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
5072 assert(!NewIP &&
"Shouldn't be in the map!");
5075 auto *
New =
new (*
this,
alignof(PipeType)) PipeType(
T, Canonical, ReadOnly);
5076 Types.push_back(
New);
5077 PipeTypes.InsertNode(
New, InsertPos);
5078 return QualType(
New, 0);
5088 return getPipeType(
T,
true);
5092 return getPipeType(
T,
false);
5096 llvm::FoldingSetNodeID ID;
5099 void *InsertPos =
nullptr;
5100 if (
BitIntType *EIT = BitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5104 BitIntTypes.InsertNode(
New, InsertPos);
5105 Types.push_back(
New);
5110 Expr *NumBitsExpr)
const {
5112 llvm::FoldingSetNodeID ID;
5115 void *InsertPos =
nullptr;
5117 DependentBitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5122 DependentBitIntTypes.InsertNode(
New, InsertPos);
5124 Types.push_back(
New);
5132 if (
auto *Target = PredefinedSugarTypes[llvm::to_underlying(KD)];
5144 return Ctx.getFromTargetType(Ctx.Target->
getSizeType());
5145 case Kind::SignedSizeT:
5147 case Kind::PtrdiffT:
5150 llvm_unreachable(
"unexpected kind");
5155 Types.push_back(
New);
5156 PredefinedSugarTypes[llvm::to_underlying(KD)] =
New;
5163 if (
auto *Tag = dyn_cast<TagDecl>(
Decl))
5166 if (
auto *
Typedef = dyn_cast<TypedefNameDecl>(
Decl))
5168 if (
auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl))
5177 if (
auto *Tag = dyn_cast<TagDecl>(TD))
5179 if (
auto *TN = dyn_cast<TypedefNameDecl>(TD))
5181 if (
const auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(TD))
5183 assert(TD->TypeForDecl);
5188 if (
const auto *TD = dyn_cast<TagDecl>(
Decl))
5190 if (
const auto *TD = dyn_cast<TypedefNameDecl>(
Decl);
5191 isa_and_nonnull<TypedefDecl, TypeAliasDecl>(TD))
5194 if (
const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl))
5197 assert(
Decl->TypeForDecl);
5207 std::optional<bool> TypeMatchesDeclOrNone)
const {
5208 if (!TypeMatchesDeclOrNone) {
5209 QualType DeclUnderlyingType =
Decl->getUnderlyingType();
5210 assert(!DeclUnderlyingType.
isNull());
5211 if (UnderlyingType.
isNull())
5212 UnderlyingType = DeclUnderlyingType;
5214 assert(
hasSameType(UnderlyingType, DeclUnderlyingType));
5215 TypeMatchesDeclOrNone = UnderlyingType == DeclUnderlyingType;
5219 assert(!UnderlyingType.
isNull());
5223 *TypeMatchesDeclOrNone) {
5224 if (
Decl->TypeForDecl)
5229 !*TypeMatchesDeclOrNone);
5231 Types.push_back(NewType);
5232 Decl->TypeForDecl = NewType;
5236 llvm::FoldingSetNodeID ID;
5238 *TypeMatchesDeclOrNone ?
QualType() : UnderlyingType);
5240 void *InsertPos =
nullptr;
5242 TypedefTypes.FindNodeOrInsertPos(ID, InsertPos))
5243 return QualType(Placeholder->getType(), 0);
5248 1, !!Qualifier, !*TypeMatchesDeclOrNone),
5252 UnderlyingType, !*TypeMatchesDeclOrNone);
5253 auto *Placeholder =
new (NewType->getFoldingSetPlaceholder())
5255 TypedefTypes.InsertNode(Placeholder, InsertPos);
5256 Types.push_back(NewType);
5265 if (UnderlyingType.
isNull()) {
5273 llvm::FoldingSetNodeID ID;
5276 void *InsertPos =
nullptr;
5277 if (
const UsingType *
T = UsingTypes.FindNodeOrInsertPos(ID, InsertPos))
5287 Allocate(UsingType::totalSizeToAlloc<NestedNameSpecifier>(!!Qualifier),
5291 UsingTypes.InsertNode(
T, InsertPos);
5297 const TagDecl *TD,
bool OwnsTag,
5299 const Type *CanonicalType,
5300 bool WithFoldingSetNode)
const {
5301 auto [TC, Size] = [&] {
5304 static_assert(
alignof(EnumType) ==
alignof(TagType));
5305 return std::make_tuple(Type::Enum,
sizeof(EnumType));
5306 case Decl::ClassTemplatePartialSpecialization:
5307 case Decl::ClassTemplateSpecialization:
5308 case Decl::CXXRecord:
5309 static_assert(
alignof(RecordType) ==
alignof(TagType));
5310 static_assert(
alignof(InjectedClassNameType) ==
alignof(TagType));
5312 return std::make_tuple(Type::InjectedClassName,
5313 sizeof(InjectedClassNameType));
5316 return std::make_tuple(Type::Record,
sizeof(RecordType));
5318 llvm_unreachable(
"unexpected decl kind");
5328 if (WithFoldingSetNode) {
5336 sizeof(TagTypeFoldingSetPlaceholder) +
5337 TagTypeFoldingSetPlaceholder::getOffset() + Size,
5338 std::max(
alignof(TagTypeFoldingSetPlaceholder),
alignof(TagType)));
5339 auto *
T =
new (Mem) TagTypeFoldingSetPlaceholder();
5340 Mem =
T->getTagType();
5342 Mem =
Allocate(Size,
alignof(TagType));
5345 auto *
T = [&, TC = TC]() -> TagType * {
5349 auto *
T =
new (Mem) EnumType(TC,
Keyword, Qualifier, TD, OwnsTag,
5350 IsInjected, CanonicalType);
5351 assert(
reinterpret_cast<void *
>(
T) ==
5352 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5353 "TagType must be the first base of EnumType");
5356 case Type::Record: {
5358 auto *
T =
new (Mem) RecordType(TC,
Keyword, Qualifier, TD, OwnsTag,
5359 IsInjected, CanonicalType);
5360 assert(
reinterpret_cast<void *
>(
T) ==
5361 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5362 "TagType must be the first base of RecordType");
5365 case Type::InjectedClassName: {
5366 auto *
T =
new (Mem) InjectedClassNameType(
Keyword, Qualifier, TD,
5367 IsInjected, CanonicalType);
5368 assert(
reinterpret_cast<void *
>(
T) ==
5369 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5370 "TagType must be the first base of InjectedClassNameType");
5374 llvm_unreachable(
"unexpected type class");
5377 assert(
T->getKeyword() ==
Keyword);
5378 assert(
T->getQualifier() == Qualifier);
5379 assert(
T->getDecl() == TD);
5380 assert(
T->isInjected() == IsInjected);
5381 assert(
T->isTagOwned() == OwnsTag);
5390 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD);
5391 RD && RD->isInjectedClassName())
5398 if (TD->TypeForDecl)
5399 return TD->TypeForDecl->getCanonicalTypeUnqualified();
5401 const Type *CanonicalType = getTagTypeInternal(
5404 false,
false,
nullptr,
5406 TD->TypeForDecl = CanonicalType;
5412 const TagDecl *TD,
bool OwnsTag)
const {
5415 bool IsInjected = TD != NonInjectedTD;
5422 if (
Keyword == PreferredKeyword && !Qualifier && !OwnsTag) {
5423 if (
const Type *
T = TD->TypeForDecl;
T && !
T->isCanonicalUnqualified())
5429 std::nullopt, NonInjectedTD,
5430 false, IsInjected, CanonicalType,
5432 TD->TypeForDecl =
T;
5436 llvm::FoldingSetNodeID ID;
5437 TagTypeFoldingSetPlaceholder::Profile(ID,
Keyword, Qualifier, NonInjectedTD,
5438 OwnsTag, IsInjected);
5440 void *InsertPos =
nullptr;
5441 if (TagTypeFoldingSetPlaceholder *
T =
5442 TagTypes.FindNodeOrInsertPos(ID, InsertPos))
5447 getTagTypeInternal(
Keyword, Qualifier, NonInjectedTD, OwnsTag, IsInjected,
5448 CanonicalType,
true);
5449 TagTypes.InsertNode(TagTypeFoldingSetPlaceholder::fromTagType(
T), InsertPos);
5454 unsigned NumPositiveBits,
5457 unsigned IntWidth = Target->getIntWidth();
5458 unsigned CharWidth = Target->getCharWidth();
5459 unsigned ShortWidth = Target->getShortWidth();
5460 bool EnumTooLarge =
false;
5462 if (NumNegativeBits) {
5466 if (IsPacked && NumNegativeBits <= CharWidth &&
5467 NumPositiveBits < CharWidth) {
5469 BestWidth = CharWidth;
5470 }
else if (IsPacked && NumNegativeBits <= ShortWidth &&
5471 NumPositiveBits < ShortWidth) {
5473 BestWidth = ShortWidth;
5474 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
5476 BestWidth = IntWidth;
5478 BestWidth = Target->getLongWidth();
5480 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
5483 BestWidth = Target->getLongLongWidth();
5485 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
5486 EnumTooLarge =
true;
5490 BestPromotionType = (BestWidth <= IntWidth ?
IntTy : BestType);
5495 if (IsPacked && NumPositiveBits <= CharWidth) {
5497 BestPromotionType =
IntTy;
5498 BestWidth = CharWidth;
5499 }
else if (IsPacked && NumPositiveBits <= ShortWidth) {
5501 BestPromotionType =
IntTy;
5502 BestWidth = ShortWidth;
5503 }
else if (NumPositiveBits <= IntWidth) {
5505 BestWidth = IntWidth;
5506 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5509 }
else if (NumPositiveBits <= (BestWidth = Target->getLongWidth())) {
5511 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5515 BestWidth = Target->getLongLongWidth();
5516 if (NumPositiveBits > BestWidth) {
5521 EnumTooLarge =
true;
5524 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5529 return EnumTooLarge;
5533 assert((
T->isIntegralType(*
this) ||
T->isEnumeralType()) &&
5534 "Integral type required!");
5537 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
5538 if (
T->isSignedIntegerOrEnumerationType())
5540 return Value.getActiveBits() <= BitWidth;
5542 return Value.getSignificantBits() <= BitWidth;
5548 const Type *CanonicalType)
const {
5550 UnresolvedUsingType::totalSizeToAlloc<
5552 !!InsertPos, !!Qualifier),
5556 auto *Placeholder =
new (
T->getFoldingSetPlaceholder())
5558 TypedefTypes.InsertNode(Placeholder, InsertPos);
5568 return D->TypeForDecl->getCanonicalTypeUnqualified();
5570 const Type *CanonicalType = getUnresolvedUsingTypeInternal(
5574 D->TypeForDecl = CanonicalType;
5583 if (
const Type *
T = D->TypeForDecl;
T && !
T->isCanonicalUnqualified())
5590 nullptr, CanonicalType);
5595 llvm::FoldingSetNodeID ID;
5598 void *InsertPos =
nullptr;
5600 UnresolvedUsingTypes.FindNodeOrInsertPos(ID, InsertPos))
5601 return QualType(Placeholder->getType(), 0);
5605 const Type *
T = getUnresolvedUsingTypeInternal(
Keyword, Qualifier, D,
5606 InsertPos, CanonicalType);
5614 llvm::FoldingSetNodeID id;
5615 AttributedType::Profile(
id, attrKind, modifiedType, equivalentType,
attr);
5617 void *insertPos =
nullptr;
5618 AttributedType *
type = AttributedTypes.FindNodeOrInsertPos(
id, insertPos);
5621 assert(!
attr ||
attr->getKind() == attrKind);
5624 type =
new (*
this,
alignof(AttributedType))
5625 AttributedType(canon, attrKind,
attr, modifiedType, equivalentType);
5627 Types.push_back(
type);
5628 AttributedTypes.InsertNode(
type, insertPos);
5641 switch (nullability) {
5657 llvm_unreachable(
"Unknown nullability kind");
5662 llvm::FoldingSetNodeID ID;
5663 BTFTagAttributedType::Profile(ID, Wrapped, BTFAttr);
5665 void *InsertPos =
nullptr;
5666 BTFTagAttributedType *Ty =
5667 BTFTagAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
5672 Ty =
new (*
this,
alignof(BTFTagAttributedType))
5673 BTFTagAttributedType(Canon, Wrapped, BTFAttr);
5675 Types.push_back(Ty);
5676 BTFTagAttributedTypes.InsertNode(Ty, InsertPos);
5683 const HLSLAttributedResourceType::Attributes &Attrs) {
5685 llvm::FoldingSetNodeID ID;
5686 HLSLAttributedResourceType::Profile(ID, Wrapped, Contained, Attrs);
5688 void *InsertPos =
nullptr;
5689 HLSLAttributedResourceType *Ty =
5690 HLSLAttributedResourceTypes.FindNodeOrInsertPos(ID, InsertPos);
5694 Ty =
new (*
this,
alignof(HLSLAttributedResourceType))
5695 HLSLAttributedResourceType(Wrapped, Contained, Attrs);
5697 Types.push_back(Ty);
5698 HLSLAttributedResourceTypes.InsertNode(Ty, InsertPos);
5706 llvm::FoldingSetNodeID ID;
5707 HLSLInlineSpirvType::Profile(ID, Opcode, Size, Alignment, Operands);
5709 void *InsertPos =
nullptr;
5710 HLSLInlineSpirvType *Ty =
5711 HLSLInlineSpirvTypes.FindNodeOrInsertPos(ID, InsertPos);
5716 HLSLInlineSpirvType::totalSizeToAlloc<SpirvOperand>(Operands.size()),
5717 alignof(HLSLInlineSpirvType));
5719 Ty =
new (Mem) HLSLInlineSpirvType(Opcode, Size, Alignment, Operands);
5721 Types.push_back(Ty);
5722 HLSLInlineSpirvTypes.InsertNode(Ty, InsertPos);
5729 Decl *AssociatedDecl,
5733 llvm::FoldingSetNodeID ID;
5734 SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index,
5736 void *InsertPos =
nullptr;
5737 SubstTemplateTypeParmType *SubstParm =
5738 SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5741 void *Mem =
Allocate(SubstTemplateTypeParmType::totalSizeToAlloc<QualType>(
5742 !Replacement.isCanonical()),
5743 alignof(SubstTemplateTypeParmType));
5744 SubstParm =
new (Mem) SubstTemplateTypeParmType(Replacement, AssociatedDecl,
5745 Index, PackIndex, Final);
5746 Types.push_back(SubstParm);
5747 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
5755 unsigned Index,
bool Final,
5762 llvm::FoldingSetNodeID ID;
5763 SubstTemplateTypeParmPackType::Profile(ID, AssociatedDecl, Index, Final,
5765 void *InsertPos =
nullptr;
5766 if (SubstTemplateTypeParmPackType *SubstParm =
5767 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
5777 [[maybe_unused]]
const auto *Nothing =
5778 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
5783 auto *SubstParm =
new (*
this,
alignof(SubstTemplateTypeParmPackType))
5784 SubstTemplateTypeParmPackType(Canon, AssociatedDecl, Index, Final,
5786 Types.push_back(SubstParm);
5787 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
5795 return P.getKind() == TemplateArgument::Type;
5797 "Pack contains a non-type");
5799 llvm::FoldingSetNodeID ID;
5800 SubstBuiltinTemplatePackType::Profile(ID, ArgPack);
5802 void *InsertPos =
nullptr;
5804 SubstBuiltinTemplatePackTypes.FindNodeOrInsertPos(ID, InsertPos))
5813 [[maybe_unused]]
const auto *Nothing =
5814 SubstBuiltinTemplatePackTypes.FindNodeOrInsertPos(ID, InsertPos);
5818 auto *PackType =
new (*
this,
alignof(SubstBuiltinTemplatePackType))
5819 SubstBuiltinTemplatePackType(Canon, ArgPack);
5820 Types.push_back(PackType);
5821 SubstBuiltinTemplatePackTypes.InsertNode(PackType, InsertPos);
5831 llvm::FoldingSetNodeID ID;
5832 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
5833 void *InsertPos =
nullptr;
5834 TemplateTypeParmType *TypeParm
5835 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5842 TypeParm =
new (*
this,
alignof(TemplateTypeParmType))
5843 TemplateTypeParmType(Depth, Index, ParameterPack, TTPDecl, Canon);
5845 TemplateTypeParmType *TypeCheck
5846 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5847 assert(!TypeCheck &&
"Template type parameter canonical type broken");
5850 TypeParm =
new (*
this,
alignof(TemplateTypeParmType)) TemplateTypeParmType(
5851 Depth, Index, ParameterPack,
nullptr,
QualType());
5853 Types.push_back(TypeParm);
5854 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
5880 llvm_unreachable(
"unexpected keyword kind");
5894 ElaboratedKeywordLoc, QualifierLoc, TemplateKeywordLoc, NameLoc,
5904 SpecifiedArgVec.reserve(SpecifiedArgs.size());
5906 SpecifiedArgVec.push_back(Arg.getArgument());
5909 CanonicalArgs, Underlying);
5912[[maybe_unused]]
static bool
5915 if (Arg.isPackExpansion())
5926 Template.getAsDependentTemplateName()));
5928 for (
const auto &Arg : Args)
5932 llvm::FoldingSetNodeID ID;
5935 void *InsertPos =
nullptr;
5936 if (
auto *
T = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
5939 void *Mem =
Allocate(
sizeof(TemplateSpecializationType) +
5941 alignof(TemplateSpecializationType));
5945 assert(Spec->isDependentType() &&
5946 "canonical template specialization must be dependent");
5947 Types.push_back(Spec);
5948 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
5956 const auto *TD =
Template.getAsTemplateDecl(
true);
5957 bool IsTypeAlias = TD && TD->isTypeAlias();
5958 if (Underlying.
isNull()) {
5965 bool NonCanonical =
Template != CanonTemplate ||
Keyword != CanonKeyword;
5967 if (CanonicalArgs.empty()) {
5970 CanonicalArgs = CanonArgsVec;
5972 NonCanonical |= !llvm::equal(
5973 SpecifiedArgs, CanonicalArgs,
5982 assert((!isa_and_nonnull<TypeAliasTemplateDecl>(TD) ||
5984 "Caller must compute aliased type");
5985 IsTypeAlias =
false;
5988 CanonKeyword, CanonTemplate, CanonicalArgs);
5992 void *Mem =
Allocate(
sizeof(TemplateSpecializationType) +
5994 (IsTypeAlias ?
sizeof(
QualType) : 0),
5995 alignof(TemplateSpecializationType));
5996 auto *Spec =
new (Mem) TemplateSpecializationType(
5998 Types.push_back(Spec);
6004 llvm::FoldingSetNodeID ID;
6007 void *InsertPos =
nullptr;
6008 ParenType *
T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
6015 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
6016 assert(!CheckT &&
"Paren canonical type broken");
6022 ParenTypes.InsertNode(
T, InsertPos);
6035 Types.push_back(newType);
6042 llvm::FoldingSetNodeID ID;
6043 DependentNameType::Profile(ID,
Keyword, NNS, Name);
6045 void *InsertPos =
nullptr;
6046 if (DependentNameType *
T =
6047 DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos))
6055 if (CanonKeyword !=
Keyword || CanonNNS != NNS) {
6057 [[maybe_unused]] DependentNameType *
T =
6058 DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
6059 assert(!
T &&
"broken canonicalization");
6063 DependentNameType *
T =
new (*
this,
alignof(DependentNameType))
6064 DependentNameType(
Keyword, NNS, Name, Canon);
6066 DependentNameTypes.InsertNode(
T, InsertPos);
6072 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
6074 if (TTP->isParameterPack())
6078 }
else if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
6080 NTTP->getType().getNonPackExpansionType().getNonLValueExprType(*
this);
6086 if (
T->isRecordType()) {
6095 Expr *E =
new (*this)
6097 T,
VK, NTTP->getLocation());
6099 if (NTTP->isParameterPack())
6105 std::nullopt,
false,
6107 if (TTP->isParameterPack())
6113 if (Param->isTemplateParameterPack())
6122 bool ExpectPackInType)
const {
6124 "Pack expansions must expand one or more parameter packs");
6126 llvm::FoldingSetNodeID ID;
6127 PackExpansionType::Profile(ID, Pattern, NumExpansions);
6129 void *InsertPos =
nullptr;
6130 PackExpansionType *
T = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
6141 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
6144 T =
new (*
this,
alignof(PackExpansionType))
6145 PackExpansionType(Pattern, Canon, NumExpansions);
6147 PackExpansionTypes.InsertNode(
T, InsertPos);
6159 if (Protocols.empty())
return true;
6164 for (
unsigned i = 1; i != Protocols.size(); ++i)
6174 llvm::array_pod_sort(Protocols.begin(), Protocols.end(),
CmpProtocolNames);
6178 P = P->getCanonicalDecl();
6181 auto ProtocolsEnd = llvm::unique(Protocols);
6182 Protocols.erase(ProtocolsEnd, Protocols.end());
6187 unsigned NumProtocols)
const {
6196 bool isKindOf)
const {
6199 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
6204 llvm::FoldingSetNodeID ID;
6205 ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
6206 void *InsertPos =
nullptr;
6207 if (
ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
6214 if (effectiveTypeArgs.empty()) {
6216 effectiveTypeArgs = baseObject->getTypeArgs();
6223 bool typeArgsAreCanonical = llvm::all_of(
6226 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.
isCanonical()) {
6230 if (!typeArgsAreCanonical) {
6231 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
6232 for (
auto typeArg : effectiveTypeArgs)
6234 canonTypeArgs = canonTypeArgsVec;
6236 canonTypeArgs = effectiveTypeArgs;
6241 if (!protocolsSorted) {
6242 canonProtocolsVec.append(protocols.begin(), protocols.end());
6244 canonProtocols = canonProtocolsVec;
6246 canonProtocols = protocols;
6250 canonProtocols, isKindOf);
6253 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
6256 unsigned size =
sizeof(ObjCObjectTypeImpl);
6257 size += typeArgs.size() *
sizeof(
QualType);
6259 void *mem =
Allocate(size,
alignof(ObjCObjectTypeImpl));
6261 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
6265 ObjCObjectTypes.InsertNode(
T, InsertPos);
6275 bool allowOnPointerType)
const {
6278 if (
const auto *objT = dyn_cast<ObjCTypeParamType>(
type.getTypePtr())) {
6283 if (allowOnPointerType) {
6284 if (
const auto *objPtr =
6285 dyn_cast<ObjCObjectPointerType>(
type.getTypePtr())) {
6289 protocolsVec.append(objT->qual_begin(),
6291 protocolsVec.append(protocols.begin(), protocols.end());
6294 objT->getBaseType(),
6295 objT->getTypeArgsAsWritten(),
6297 objT->isKindOfTypeAsWritten());
6303 if (
const auto *objT = dyn_cast<ObjCObjectType>(
type.getTypePtr())){
6308 objT->getTypeArgsAsWritten(),
6310 objT->isKindOfTypeAsWritten());
6314 if (
type->isObjCObjectType()) {
6324 if (
type->isObjCIdType()) {
6327 objPtr->isKindOfType());
6332 if (
type->isObjCClassType()) {
6335 objPtr->isKindOfType());
6347 llvm::FoldingSetNodeID ID;
6348 ObjCTypeParamType::Profile(ID,
Decl,
Decl->getUnderlyingType(), protocols);
6349 void *InsertPos =
nullptr;
6350 if (ObjCTypeParamType *TypeParam =
6351 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
6356 if (!protocols.empty()) {
6360 Canonical, protocols, hasError,
true ));
6361 assert(!hasError &&
"Error when apply protocol qualifier to bound type");
6364 unsigned size =
sizeof(ObjCTypeParamType);
6366 void *mem =
Allocate(size,
alignof(ObjCTypeParamType));
6367 auto *newType =
new (mem) ObjCTypeParamType(
Decl, Canonical, protocols);
6369 Types.push_back(newType);
6370 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
6380 protocols.append(NewTypeParamTy->qual_begin(), NewTypeParamTy->qual_end());
6395 for (
auto *Proto : OPT->quals()) {
6418 if (InheritedProtocols.empty())
6422 bool Conforms =
false;
6423 for (
auto *Proto : OPT->quals()) {
6425 for (
auto *PI : InheritedProtocols) {
6437 for (
auto *PI : InheritedProtocols) {
6439 bool Adopts =
false;
6440 for (
auto *Proto : OPT->quals()) {
6454 llvm::FoldingSetNodeID ID;
6457 void *InsertPos =
nullptr;
6459 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
6468 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
6477 Types.push_back(QType);
6478 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
6486 if (
Decl->TypeForDecl)
6490 assert(PrevDecl->TypeForDecl &&
"previous decl has no TypeForDecl");
6491 Decl->TypeForDecl = PrevDecl->TypeForDecl;
6492 return QualType(PrevDecl->TypeForDecl, 0);
6501 Decl->TypeForDecl =
T;
6514 llvm::FoldingSetNodeID ID;
6518 void *InsertPos =
nullptr;
6520 DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
6530 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
6538 Types.push_back(toe);
6549 auto *tot =
new (*
this,
alignof(TypeOfType))
6550 TypeOfType(*
this, tofType, Canonical, Kind);
6551 Types.push_back(tot);
6575 llvm_unreachable(
"Unknown value kind");
6590 }
else if (!UnderlyingType.
isNull()) {
6593 llvm::FoldingSetNodeID ID;
6594 DependentDecltypeType::Profile(ID, *
this, E);
6596 void *InsertPos =
nullptr;
6597 if (DependentDecltypeType *Canon =
6598 DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos))
6603 new (*
this,
alignof(DependentDecltypeType)) DependentDecltypeType(E);
6604 DependentDecltypeTypes.InsertNode(DT, InsertPos);
6605 Types.push_back(DT);
6608 auto *DT =
new (*
this,
alignof(DecltypeType))
6609 DecltypeType(E, UnderlyingType, CanonType);
6610 Types.push_back(DT);
6615 bool FullySubstituted,
6619 if (FullySubstituted && Index) {
6622 llvm::FoldingSetNodeID ID;
6623 PackIndexingType::Profile(ID, *
this, Pattern.
getCanonicalType(), IndexExpr,
6624 FullySubstituted, Expansions);
6625 void *InsertPos =
nullptr;
6626 PackIndexingType *Canon =
6627 DependentPackIndexingTypes.FindNodeOrInsertPos(ID, InsertPos);
6630 PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6634 IndexExpr, FullySubstituted, Expansions);
6635 DependentPackIndexingTypes.InsertNode(Canon, InsertPos);
6641 Allocate(PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6643 auto *
T =
new (Mem) PackIndexingType(Canonical, Pattern, IndexExpr,
6644 FullySubstituted, Expansions);
6653 UnaryTransformType::UTTKind Kind)
const {
6655 llvm::FoldingSetNodeID ID;
6656 UnaryTransformType::Profile(ID, BaseType, UnderlyingType, Kind);
6658 void *InsertPos =
nullptr;
6659 if (UnaryTransformType *UT =
6660 UnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos))
6664 if (!BaseType->isDependentType()) {
6667 assert(UnderlyingType.
isNull() || BaseType == UnderlyingType);
6670 BaseType != CanonBase) {
6675 [[maybe_unused]] UnaryTransformType *UT =
6676 UnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
6677 assert(!UT &&
"broken canonicalization");
6681 auto *UT =
new (*
this,
alignof(UnaryTransformType))
6682 UnaryTransformType(BaseType, UnderlyingType, Kind, CanonType);
6683 UnaryTransformTypes.InsertNode(UT, InsertPos);
6684 Types.push_back(UT);
6688QualType ASTContext::getAutoTypeInternal(
6693 !TypeConstraintConcept && !IsDependent)
6697 llvm::FoldingSetNodeID ID;
6698 bool IsDeducedDependent =
6699 isa_and_nonnull<TemplateTemplateParmDecl>(TypeConstraintConcept) ||
6701 AutoType::Profile(ID, *
this, DeducedType,
Keyword,
6702 IsDependent || IsDeducedDependent, TypeConstraintConcept,
6703 TypeConstraintArgs);
6704 if (
auto const AT_iter = AutoTypes.find(ID); AT_iter != AutoTypes.end())
6705 return QualType(AT_iter->getSecond(), 0);
6709 if (!DeducedType.
isNull()) {
6711 }
else if (TypeConstraintConcept) {
6712 bool AnyNonCanonArgs =
false;
6713 auto *CanonicalConcept =
6716 *
this, TypeConstraintArgs, AnyNonCanonArgs);
6717 if (CanonicalConcept != TypeConstraintConcept || AnyNonCanonArgs) {
6719 CanonicalConcept, CanonicalConceptArgs,
6725 void *Mem =
Allocate(
sizeof(AutoType) +
6726 sizeof(TemplateArgument) * TypeConstraintArgs.size(),
6728 auto *AT =
new (Mem) AutoType(
6730 (IsDependent ? TypeDependence::DependentInstantiation
6731 : TypeDependence::None) |
6732 (IsPack ? TypeDependence::UnexpandedPack : TypeDependence::None),
6733 Canon, TypeConstraintConcept, TypeConstraintArgs);
6735 llvm::FoldingSetNodeID InsertedID;
6736 AT->Profile(InsertedID, *
this);
6737 assert(InsertedID == ID &&
"ID does not match");
6739 Types.push_back(AT);
6740 AutoTypes.try_emplace(ID, AT);
6741 return QualType(AT, 0);
6749 bool IsDependent,
bool IsPack,
6752 assert((!IsPack || IsDependent) &&
"only use IsPack for a dependent pack");
6753 assert((!IsDependent || DeducedType.
isNull()) &&
6754 "A dependent auto should be undeduced");
6755 return getAutoTypeInternal(DeducedType,
Keyword, IsDependent, IsPack,
6756 TypeConstraintConcept, TypeConstraintArgs);
6760 QualType CanonT =
T.getNonPackExpansionType().getCanonicalType();
6763 if (
auto *AT = CanonT->
getAs<AutoType>()) {
6764 if (!AT->isConstrained())
6768 AT->containsUnexpandedParameterPack()),
6780QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
6782 bool IsDependent,
QualType Canon)
const {
6784 void *InsertPos =
nullptr;
6785 llvm::FoldingSetNodeID ID;
6786 DeducedTemplateSpecializationType::Profile(ID,
Keyword,
Template, DeducedType,
6788 if (DeducedTemplateSpecializationType *DTST =
6789 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
6792 auto *DTST =
new (*
this,
alignof(DeducedTemplateSpecializationType))
6794 IsDependent, Canon);
6797 llvm::FoldingSetNodeID TempID;
6798 DTST->Profile(TempID);
6799 assert(ID == TempID &&
"ID does not match");
6801 Types.push_back(DTST);
6802 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
6811 bool IsDependent)
const {
6818 ? getDeducedTemplateSpecializationTypeInternal(
6822 return getDeducedTemplateSpecializationTypeInternal(
6831 llvm::FoldingSetNodeID ID;
6834 void *InsertPos =
nullptr;
6835 if (
AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
6841 if (!
T.isCanonical()) {
6845 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
6846 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
6849 Types.push_back(
New);
6850 AtomicTypes.InsertNode(
New, InsertPos);
6881 return getFromTargetType(Target->getSizeType());
6900 return getFromTargetType(Target->getUnsignedPtrDiffType(
LangAS::Default));
6905 return getFromTargetType(Target->getIntMaxType());
6910 return getFromTargetType(Target->getUIntMaxType());
6928 return getFromTargetType(Target->getIntPtrType());
6938 return getFromTargetType(Target->getProcessIDType());
6950 const Type *Ty =
T.getTypePtr();
6978 quals = splitType.
Quals;
6983 QualType elementType = AT->getElementType();
6988 if (elementType == unqualElementType) {
6989 assert(quals.
empty());
6990 quals = splitType.
Quals;
6998 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
7000 CAT->getSizeExpr(), CAT->getSizeModifier(), 0);
7003 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
7007 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
7009 VAT->getSizeModifier(),
7010 VAT->getIndexTypeCVRQualifiers());
7015 DSAT->getSizeModifier(), 0);
7025 bool AllowPiMismatch)
const {
7040 if (
auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
7041 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
7042 if (!((CAT2 && CAT1->getSize() == CAT2->getSize()) ||
7055 T1 = AT1->getElementType();
7056 T2 = AT2->getElementType();
7076 bool AllowPiMismatch)
const {
7081 if (T1PtrType && T2PtrType) {
7089 T1MPType && T2MPType) {
7090 if (
auto *RD1 = T1MPType->getMostRecentCXXRecordDecl(),
7091 *RD2 = T2MPType->getMostRecentCXXRecordDecl();
7092 RD1 != RD2 && RD1->getCanonicalDecl() != RD2->getCanonicalDecl())
7094 if (T1MPType->getQualifier().getCanonical() !=
7095 T2MPType->getQualifier().getCanonical())
7105 if (T1OPType && T2OPType) {
7137 if (Quals1 != Quals2)
7207 llvm_unreachable(
"bad template name kind!");
7213 if (!TP->hasDefaultArgument())
7215 return &TP->getDefaultArgument().getArgument();
7218 case NamedDecl::TemplateTypeParm:
7220 case NamedDecl::NonTypeTemplateParm:
7222 case NamedDecl::TemplateTemplateParm:
7225 llvm_unreachable(
"Unexpected template parameter kind");
7230 bool IgnoreDeduced)
const {
7231 while (std::optional<TemplateName> UnderlyingOrNone =
7233 Name = *UnderlyingOrNone;
7238 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
Template))
7247 llvm_unreachable(
"cannot canonicalize unresolved template");
7251 assert(DTN &&
"Non-dependent template names must refer to template decls.");
7270 assert(IgnoreDeduced ==
false);
7277 bool NonCanonical = CanonUnderlying != Underlying;
7283 assert(CanonArgs.size() <= Params.size());
7289 for (
int I = CanonArgs.size() - 1; I >= 0; --I) {
7298 if (I ==
int(CanonArgs.size() - 1))
7299 CanonArgs.pop_back();
7300 NonCanonical =
true;
7310 llvm_unreachable(
"always sugar node");
7313 llvm_unreachable(
"bad template name!");
7318 bool IgnoreDeduced)
const {
7339 llvm::FoldingSetNodeID XCEID, YCEID;
7340 XCE->
Profile(XCEID, *
this,
true,
true);
7341 YCE->
Profile(YCEID, *
this,
true,
true);
7342 return XCEID == YCEID;
7391 if (
auto *TX = dyn_cast<TemplateTypeParmDecl>(
X)) {
7393 if (TX->isParameterPack() != TY->isParameterPack())
7395 if (TX->hasTypeConstraint() != TY->hasTypeConstraint())
7398 TY->getTypeConstraint());
7401 if (
auto *TX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7403 return TX->isParameterPack() == TY->isParameterPack() &&
7404 TX->getASTContext().hasSameType(TX->getType(), TY->getType()) &&
7406 TY->getPlaceholderTypeConstraint());
7411 return TX->isParameterPack() == TY->isParameterPack() &&
7413 TY->getTemplateParameters());
7418 if (
X->size() != Y->
size())
7421 for (
unsigned I = 0, N =
X->size(); I != N; ++I)
7435 if (
auto *TTPX = dyn_cast<TemplateTypeParmDecl>(
X)) {
7437 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7440 return hasSameType(TTPX->getDefaultArgument().getArgument().getAsType(),
7441 TTPY->getDefaultArgument().getArgument().getAsType());
7444 if (
auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7446 if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
7449 Expr *DefaultArgumentX =
7450 NTTPX->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7451 Expr *DefaultArgumentY =
7452 NTTPY->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7453 llvm::FoldingSetNodeID XID, YID;
7454 DefaultArgumentX->
Profile(XID, *
this,
true);
7455 DefaultArgumentY->
Profile(YID, *
this,
true);
7462 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7477 auto Kind =
X.getKind();
7485 auto [NamespaceX, PrefixX] =
X.getAsNamespaceAndPrefix();
7488 NamespaceY->getNamespace()))
7493 const auto *TX =
X.getAsType(), *TY = Y.
getAsType();
7494 if (TX->getCanonicalTypeInternal() != TY->getCanonicalTypeInternal())
7503 llvm_unreachable(
"unhandled qualifier kind");
7509 if (A->
hasAttr<CUDADeviceAttr>() != B->
hasAttr<CUDADeviceAttr>())
7511 if (A->
hasAttr<CUDADeviceAttr>() && B->
hasAttr<CUDADeviceAttr>())
7523 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
7527 for (
auto Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {
7528 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
7529 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
7532 if (!Cand1A || !Cand2A)
7538 (*Cand1A)->getCond()->Profile(Cand1ID, A->
getASTContext(),
true);
7539 (*Cand2A)->getCond()->Profile(Cand2ID, B->
getASTContext(),
true);
7543 if (Cand1ID != Cand2ID)
7577 if (
const auto *TypedefX = dyn_cast<TypedefNameDecl>(
X))
7578 if (
const auto *TypedefY = dyn_cast<TypedefNameDecl>(Y))
7580 TypedefY->getUnderlyingType());
7597 if (
const auto *TagX = dyn_cast<TagDecl>(
X)) {
7599 return (TagX->getTagKind() == TagY->getTagKind()) ||
7611 if (
const auto *FuncX = dyn_cast<FunctionDecl>(
X)) {
7613 if (
const auto *CtorX = dyn_cast<CXXConstructorDecl>(
X)) {
7615 if (CtorX->getInheritedConstructor() &&
7616 !
isSameEntity(CtorX->getInheritedConstructor().getConstructor(),
7617 CtorY->getInheritedConstructor().getConstructor()))
7621 if (FuncX->isMultiVersion() != FuncY->isMultiVersion())
7626 if (FuncX->isMultiVersion()) {
7627 const auto *TAX = FuncX->getAttr<TargetAttr>();
7628 const auto *TAY = FuncY->getAttr<TargetAttr>();
7629 assert(TAX && TAY &&
"Multiversion Function without target attribute");
7631 if (TAX->getFeaturesStr() != TAY->getFeaturesStr())
7637 if ((FuncX->isMemberLikeConstrainedFriend() ||
7638 FuncY->isMemberLikeConstrainedFriend()) &&
7639 !FuncX->getLexicalDeclContext()->Equals(
7640 FuncY->getLexicalDeclContext())) {
7645 FuncY->getTrailingRequiresClause()))
7653 FD = FD->getCanonicalDecl();
7654 return FD->getTypeSourceInfo() ? FD->getTypeSourceInfo()->getType()
7657 QualType XT = GetTypeAsWritten(FuncX), YT = GetTypeAsWritten(FuncY);
7672 return FuncX->getLinkageInternal() == FuncY->getLinkageInternal() &&
7677 if (
const auto *VarX = dyn_cast<VarDecl>(
X)) {
7679 if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
7682 if (VarX->getType().isNull() || VarY->getType().isNull())
7685 if (
hasSameType(VarX->getType(), VarY->getType()))
7695 if (!VarXTy || !VarYTy)
7704 if (
const auto *NamespaceX = dyn_cast<NamespaceDecl>(
X)) {
7706 return NamespaceX->isInline() == NamespaceY->isInline();
7711 if (
const auto *TemplateX = dyn_cast<TemplateDecl>(
X)) {
7715 if (
const auto *ConceptX = dyn_cast<ConceptDecl>(
X)) {
7718 ConceptY->getConstraintExpr()))
7723 TemplateY->getTemplatedDecl()) &&
7725 TemplateY->getTemplateParameters());
7729 if (
const auto *FDX = dyn_cast<FieldDecl>(
X)) {
7732 return hasSameType(FDX->getType(), FDY->getType());
7736 if (
const auto *IFDX = dyn_cast<IndirectFieldDecl>(
X)) {
7738 return IFDX->getAnonField()->getCanonicalDecl() ==
7739 IFDY->getAnonField()->getCanonicalDecl();
7748 if (
const auto *USX = dyn_cast<UsingShadowDecl>(
X)) {
7755 if (
const auto *UX = dyn_cast<UsingDecl>(
X)) {
7758 UX->hasTypename() == UY->hasTypename() &&
7759 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7761 if (
const auto *UX = dyn_cast<UnresolvedUsingValueDecl>(
X)) {
7764 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7766 if (
const auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(
X)) {
7774 if (
const auto *UX = dyn_cast<UsingPackDecl>(
X)) {
7776 UX->getInstantiatedFromUsingDecl(),
7781 if (
const auto *NAX = dyn_cast<NamespaceAliasDecl>(
X)) {
7783 return NAX->getNamespace()->Equals(NAY->getNamespace());
7831 bool AnyNonCanonArgs =
false;
7834 if (!AnyNonCanonArgs)
7844 llvm_unreachable(
"Unhandled template argument kind");
7854 llvm_unreachable(
"Comparing NULL template argument");
7879 llvm::FoldingSetNodeID ID1, ID2;
7889 return isSameTemplateArgument(Arg1, Arg2);
7893 llvm_unreachable(
"Unhandled template argument kind");
7898 if (!
T.hasLocalQualifiers()) {
7900 if (
const auto *AT = dyn_cast<ArrayType>(
T))
7920 const auto *ATy = dyn_cast<ArrayType>(split.
Ty);
7921 if (!ATy || qs.
empty())
7928 if (
const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
7931 CAT->getSizeModifier(),
7932 CAT->getIndexTypeCVRQualifiers()));
7933 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
7935 IAT->getSizeModifier(),
7936 IAT->getIndexTypeCVRQualifiers()));
7938 if (
const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
7940 NewEltTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
7941 DSAT->getIndexTypeCVRQualifiers()));
7946 VAT->getIndexTypeCVRQualifiers()));
7952 if (
T->isArrayType() ||
T->isFunctionType())
7960 return T.getUnqualifiedType();
7971 if (
T->isArrayType() ||
T->isFunctionType())
7973 return T.getUnqualifiedType();
7988 assert(PrettyArrayType &&
"Not an array type!");
8025 uint64_t ElementCount = 1;
8028 CA = dyn_cast_or_null<ConstantArrayType>(
8031 return ElementCount;
8039 uint64_t ElementCount = 1;
8043 AILE = dyn_cast<ArrayInitLoopExpr>(AILE->
getSubExpr());
8046 return ElementCount;
8056 default: llvm_unreachable(
"getFloatingRank(): not a floating type");
8058 case BuiltinType::Half:
return HalfRank;
8059 case BuiltinType::Float:
return FloatRank;
8092unsigned ASTContext::getIntegerRank(
const Type *
T)
const {
8093 assert(
T->isCanonicalUnqualified() &&
"T should be canonicalized");
8097 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
8098 return 0 + (EIT->getNumBits() << 3);
8101 default: llvm_unreachable(
"getIntegerRank(): not a built-in integer");
8102 case BuiltinType::Bool:
8104 case BuiltinType::Char_S:
8105 case BuiltinType::Char_U:
8106 case BuiltinType::SChar:
8107 case BuiltinType::UChar:
8109 case BuiltinType::Short:
8110 case BuiltinType::UShort:
8112 case BuiltinType::Int:
8113 case BuiltinType::UInt:
8115 case BuiltinType::Long:
8116 case BuiltinType::ULong:
8118 case BuiltinType::LongLong:
8119 case BuiltinType::ULongLong:
8121 case BuiltinType::Int128:
8122 case BuiltinType::UInt128:
8127 case BuiltinType::Char8:
8129 case BuiltinType::Char16:
8130 return getIntegerRank(
8132 case BuiltinType::Char32:
8133 return getIntegerRank(
8135 case BuiltinType::WChar_S:
8136 case BuiltinType::WChar_U:
8137 return getIntegerRank(
8167 uint64_t BitWidth = Field->getBitWidthValue();
8193 if (BitWidth < IntSize)
8196 if (BitWidth == IntSize)
8211 assert(!Promotable.
isNull());
8214 return ED->getPromotionType();
8223 if (BT->getKind() == BuiltinType::WChar_S ||
8224 BT->getKind() == BuiltinType::WChar_U ||
8225 BT->getKind() == BuiltinType::Char8 ||
8226 BT->getKind() == BuiltinType::Char16 ||
8227 BT->getKind() == BuiltinType::Char32) {
8228 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
8232 for (
const auto &PT : PromoteTypes) {
8234 if (FromSize < ToSize ||
8235 (FromSize == ToSize && FromIsSigned == PT->isSignedIntegerType()))
8238 llvm_unreachable(
"char type should fit into long long");
8245 uint64_t PromotableSize =
getIntWidth(Promotable);
8254 while (!
T.isNull()) {
8256 return T.getObjCLifetime();
8257 if (
T->isArrayType())
8260 T = PT->getPointeeType();
8262 T = RT->getPointeeType();
8287 if (
const auto *ET = dyn_cast<EnumType>(LHSC))
8289 if (
const auto *ET = dyn_cast<EnumType>(RHSC))
8292 if (LHSC == RHSC)
return 0;
8297 unsigned LHSRank = getIntegerRank(LHSC);
8298 unsigned RHSRank = getIntegerRank(RHSC);
8300 if (LHSUnsigned == RHSUnsigned) {
8301 if (LHSRank == RHSRank)
return 0;
8302 return LHSRank > RHSRank ? 1 : -1;
8308 if (LHSRank >= RHSRank)
8318 if (RHSRank >= LHSRank)
8328 if (CFConstantStringTypeDecl)
8329 return CFConstantStringTypeDecl;
8331 assert(!CFConstantStringTagDecl &&
8332 "tag and typedef should be initialized together");
8334 CFConstantStringTagDecl->startDefinition();
8372 if (
static_cast<unsigned>(CFRuntime) <
8375 Fields[Count++] = {
IntTy,
"flags" };
8377 Fields[Count++] = {
LongTy,
"length" };
8381 Fields[Count++] = { getFromTargetType(Target->getUInt64Type()),
"_swift_rc" };
8385 Fields[Count++] = {
IntTy,
"_ptr" };
8391 for (
unsigned i = 0; i < Count; ++i) {
8395 Fields[i].Type,
nullptr,
8398 CFConstantStringTagDecl->addDecl(Field);
8401 CFConstantStringTagDecl->completeDefinition();
8405 CFConstantStringTypeDecl =
8408 return CFConstantStringTypeDecl;
8412 if (!CFConstantStringTagDecl)
8414 return CFConstantStringTagDecl;
8424 if (ObjCSuperType.isNull()) {
8429 return ObjCSuperType;
8435 CFConstantStringTagDecl = TT->castAsRecordDecl();
8439 if (BlockDescriptorType)
8452 static const char *
const FieldNames[] = {
8457 for (
size_t i = 0; i < 2; ++i) {
8460 &
Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
8468 BlockDescriptorType = RD;
8474 if (BlockDescriptorExtendedType)
8489 static const char *
const FieldNames[] = {
8496 for (
size_t i = 0; i < 4; ++i) {
8499 &
Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
8508 BlockDescriptorExtendedType = RD;
8513 const auto *BT = dyn_cast<BuiltinType>(
T);
8522 switch (BT->getKind()) {
8523#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8524 case BuiltinType::Id: \
8526#include "clang/Basic/OpenCLImageTypes.def"
8528 case BuiltinType::OCLClkEvent:
8531 case BuiltinType::OCLEvent:
8534 case BuiltinType::OCLQueue:
8537 case BuiltinType::OCLReserveID:
8540 case BuiltinType::OCLSampler:
8559 if (!copyExpr && record->hasTrivialDestructor())
return false;
8590 llvm_unreachable(
"impossible");
8592 llvm_unreachable(
"fell out of lifetime switch!");
8600 bool &HasByrefExtendedLayout)
const {
8605 HasByrefExtendedLayout =
false;
8607 HasByrefExtendedLayout =
true;
8621 assert(Target &&
"Expected target to be initialized");
8622 const llvm::Triple &
T = Target->getTriple();
8624 if (
T.isOSWindows() &&
T.isArch64Bit())
8630 assert(Target &&
"Expected target to be initialized");
8631 const llvm::Triple &
T = Target->getTriple();
8633 if (
T.isOSWindows() &&
T.isArch64Bit())
8639 if (!ObjCInstanceTypeDecl)
8640 ObjCInstanceTypeDecl =
8642 return ObjCInstanceTypeDecl;
8648 if (
const auto *TT = dyn_cast<TypedefType>(
T))
8650 return II->isStr(
"BOOL");
8658 if (!
type->isIncompleteArrayType() &&
type->isIncompleteType())
8667 else if (
type->isArrayType())
8686 if (
First->isInlineSpecified() || !
First->isStaticDataMember())
8693 !D->isInlineSpecified() && (D->isConstexpr() ||
First->isConstexpr()))
8724 for (
auto *PI :
Decl->parameters()) {
8729 assert(sz.
isPositive() &&
"BlockExpr - Incomplete param type");
8738 ParmOffset = PtrSize;
8739 for (
auto *PVDecl :
Decl->parameters()) {
8740 QualType PType = PVDecl->getOriginalType();
8741 if (
const auto *AT =
8746 PType = PVDecl->getType();
8748 PType = PVDecl->getType();
8768 for (
auto *PI :
Decl->parameters()) {
8775 "getObjCEncodingForFunctionDecl - Incomplete param type");
8782 for (
auto *PVDecl :
Decl->parameters()) {
8783 QualType PType = PVDecl->getOriginalType();
8784 if (
const auto *AT =
8789 PType = PVDecl->getType();
8791 PType = PVDecl->getType();
8805 bool Extended)
const {
8809 ObjCEncOptions Options = ObjCEncOptions()
8810 .setExpandPointedToStructures()
8811 .setExpandStructures()
8812 .setIsOutermostType();
8814 Options.setEncodeBlockParameters().setEncodeClassNames();
8815 getObjCEncodingForTypeImpl(
T, S, Options,
nullptr);
8821 bool Extended)
const {
8826 Decl->getReturnType(), S, Extended);
8835 E =
Decl->sel_param_end(); PI != E; ++PI) {
8842 "getObjCEncodingForMethodDecl - Incomplete param type");
8850 ParmOffset = 2 * PtrSize;
8852 E =
Decl->sel_param_end(); PI != E; ++PI) {
8855 if (
const auto *AT =
8864 PType, S, Extended);
8875 const Decl *Container)
const {
8878 if (
const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
8879 for (
auto *PID : CID->property_impls())
8880 if (PID->getPropertyDecl() == PD)
8884 for (
auto *PID : OID->property_impls())
8885 if (PID->getPropertyDecl() == PD)
8919 const Decl *Container)
const {
8921 bool Dynamic =
false;
8929 SynthesizePID = PropertyImpDecl;
8933 std::string S =
"T";
8978 if (SynthesizePID) {
8995 if (BT->getKind() == BuiltinType::ULong &&
getIntWidth(PointeeTy) == 32)
8998 if (BT->getKind() == BuiltinType::Long &&
getIntWidth(PointeeTy) == 32)
9011 getObjCEncodingForTypeImpl(
T, S,
9013 .setExpandPointedToStructures()
9014 .setExpandStructures()
9015 .setIsOutermostType(),
9016 Field, NotEncodedT);
9020 std::string& S)
const {
9024 getObjCEncodingForTypeImpl(
T, S,
9026 .setExpandPointedToStructures()
9027 .setExpandStructures()
9028 .setIsOutermostType()
9029 .setEncodingProperty(),
9037 case BuiltinType::Void:
return 'v';
9038 case BuiltinType::Bool:
return 'B';
9039 case BuiltinType::Char8:
9040 case BuiltinType::Char_U:
9041 case BuiltinType::UChar:
return 'C';
9042 case BuiltinType::Char16:
9043 case BuiltinType::UShort:
return 'S';
9044 case BuiltinType::Char32:
9045 case BuiltinType::UInt:
return 'I';
9046 case BuiltinType::ULong:
9047 return C->getTargetInfo().getLongWidth() == 32 ?
'L' :
'Q';
9048 case BuiltinType::UInt128:
return 'T';
9049 case BuiltinType::ULongLong:
return 'Q';
9050 case BuiltinType::Char_S:
9051 case BuiltinType::SChar:
return 'c';
9052 case BuiltinType::Short:
return 's';
9053 case BuiltinType::WChar_S:
9054 case BuiltinType::WChar_U:
9055 case BuiltinType::Int:
return 'i';
9056 case BuiltinType::Long:
9057 return C->getTargetInfo().getLongWidth() == 32 ?
'l' :
'q';
9058 case BuiltinType::LongLong:
return 'q';
9059 case BuiltinType::Int128:
return 't';
9060 case BuiltinType::Float:
return 'f';
9061 case BuiltinType::Double:
return 'd';
9062 case BuiltinType::LongDouble:
return 'D';
9063 case BuiltinType::NullPtr:
return '*';
9065 case BuiltinType::BFloat16:
9066 case BuiltinType::Float16:
9067 case BuiltinType::Float128:
9068 case BuiltinType::Ibm128:
9069 case BuiltinType::Half:
9070 case BuiltinType::ShortAccum:
9071 case BuiltinType::Accum:
9072 case BuiltinType::LongAccum:
9073 case BuiltinType::UShortAccum:
9074 case BuiltinType::UAccum:
9075 case BuiltinType::ULongAccum:
9076 case BuiltinType::ShortFract:
9077 case BuiltinType::Fract:
9078 case BuiltinType::LongFract:
9079 case BuiltinType::UShortFract:
9080 case BuiltinType::UFract:
9081 case BuiltinType::ULongFract:
9082 case BuiltinType::SatShortAccum:
9083 case BuiltinType::SatAccum:
9084 case BuiltinType::SatLongAccum:
9085 case BuiltinType::SatUShortAccum:
9086 case BuiltinType::SatUAccum:
9087 case BuiltinType::SatULongAccum:
9088 case BuiltinType::SatShortFract:
9089 case BuiltinType::SatFract:
9090 case BuiltinType::SatLongFract:
9091 case BuiltinType::SatUShortFract:
9092 case BuiltinType::SatUFract:
9093 case BuiltinType::SatULongFract:
9097#define SVE_TYPE(Name, Id, SingletonId) \
9098 case BuiltinType::Id:
9099#include "clang/Basic/AArch64ACLETypes.def"
9100#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9101#include "clang/Basic/RISCVVTypes.def"
9102#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9103#include "clang/Basic/WebAssemblyReferenceTypes.def"
9104#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
9105#include "clang/Basic/AMDGPUTypes.def"
9109 "cannot yet @encode type %0");
9114 case BuiltinType::ObjCId:
9115 case BuiltinType::ObjCClass:
9116 case BuiltinType::ObjCSel:
9117 llvm_unreachable(
"@encoding ObjC primitive type");
9120#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
9121 case BuiltinType::Id:
9122#include "clang/Basic/OpenCLImageTypes.def"
9123#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
9124 case BuiltinType::Id:
9125#include "clang/Basic/OpenCLExtensionTypes.def"
9126 case BuiltinType::OCLEvent:
9127 case BuiltinType::OCLClkEvent:
9128 case BuiltinType::OCLQueue:
9129 case BuiltinType::OCLReserveID:
9130 case BuiltinType::OCLSampler:
9131 case BuiltinType::Dependent:
9132#define PPC_VECTOR_TYPE(Name, Id, Size) \
9133 case BuiltinType::Id:
9134#include "clang/Basic/PPCTypes.def"
9135#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9136#include "clang/Basic/HLSLIntangibleTypes.def"
9137#define BUILTIN_TYPE(KIND, ID)
9138#define PLACEHOLDER_TYPE(KIND, ID) \
9139 case BuiltinType::KIND:
9140#include "clang/AST/BuiltinTypes.def"
9141 llvm_unreachable(
"invalid builtin type for @encode");
9143 llvm_unreachable(
"invalid BuiltinType::Kind value");
9150 if (!
Enum->isFixed())
9160 assert(FD->
isBitField() &&
"not a bitfield - getObjCEncodingForTypeImpl");
9180 if (
const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
9188 S += llvm::utostr(Offset);
9190 if (
const auto *ET =
T->getAsCanonical<EnumType>())
9203 bool VisitBasesAndFields) {
9204 T =
T->getBaseElementTypeUnsafe();
9208 PT->getPointeeType().getTypePtr(),
false);
9210 auto *CXXRD =
T->getAsCXXRecordDecl();
9218 if (!CXXRD->hasDefinition() || !VisitBasesAndFields)
9221 for (
const auto &B : CXXRD->bases())
9226 for (
auto *FD : CXXRD->fields())
9235void ASTContext::getObjCEncodingForTypeImpl(QualType
T, std::string &S,
9236 const ObjCEncOptions Options,
9237 const FieldDecl *FD,
9238 QualType *NotEncodedT)
const {
9240 switch (CT->getTypeClass()) {
9245 if (
const auto *BT = dyn_cast<BuiltinType>(CT))
9253 getObjCEncodingForTypeImpl(
T->
castAs<ComplexType>()->getElementType(), S,
9260 getObjCEncodingForTypeImpl(
T->
castAs<AtomicType>()->getValueType(), S,
9267 case Type::LValueReference:
9268 case Type::RValueReference: {
9271 const auto *PT =
T->
castAs<PointerType>();
9272 if (PT->isObjCSelType()) {
9281 bool isReadOnly =
false;
9286 if (
T->
getAs<TypedefType>()) {
9287 if (Options.IsOutermostType() &&
T.isConstQualified()) {
9291 }
else if (Options.IsOutermostType()) {
9292 QualType P = PointeeTy;
9293 while (
auto PT = P->
getAs<PointerType>())
9304 if (StringRef(S).ends_with(
"nr"))
9305 S.replace(S.end()-2, S.end(),
"rn");
9315 }
else if (
const auto *RTy = PointeeTy->
getAsCanonical<RecordType>()) {
9316 const IdentifierInfo *II = RTy->getDecl()->getIdentifier();
9318 if (II == &
Idents.get(
"objc_class")) {
9323 if (II == &
Idents.get(
"objc_object")) {
9332 RTy, Options.ExpandPointedToStructures()))) {
9341 ObjCEncOptions NewOptions;
9342 if (Options.ExpandPointedToStructures())
9343 NewOptions.setExpandStructures();
9344 getObjCEncodingForTypeImpl(PointeeTy, S, NewOptions,
9345 nullptr, NotEncodedT);
9349 case Type::ConstantArray:
9350 case Type::IncompleteArray:
9351 case Type::VariableArray: {
9358 getObjCEncodingForTypeImpl(
9359 AT->getElementType(), S,
9360 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD);
9364 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
9365 S += llvm::utostr(CAT->getZExtSize());
9369 "Unknown array type!");
9373 getObjCEncodingForTypeImpl(
9374 AT->getElementType(), S,
9375 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD,
9382 case Type::FunctionNoProto:
9383 case Type::FunctionProto:
9387 case Type::Record: {
9389 S += RDecl->
isUnion() ?
'(' :
'{';
9393 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
9394 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
9395 llvm::raw_string_ostream
OS(S);
9396 printTemplateArgumentList(OS, TemplateArgs.
asArray(),
9402 if (Options.ExpandStructures()) {
9405 getObjCEncodingForStructureImpl(RDecl, S, FD,
true, NotEncodedT);
9407 for (
const auto *Field : RDecl->
fields()) {
9410 S +=
Field->getNameAsString();
9415 if (
Field->isBitField()) {
9416 getObjCEncodingForTypeImpl(
Field->getType(), S,
9417 ObjCEncOptions().setExpandStructures(),
9420 QualType qt =
Field->getType();
9422 getObjCEncodingForTypeImpl(
9424 ObjCEncOptions().setExpandStructures().setIsStructField(), FD,
9430 S += RDecl->
isUnion() ?
')' :
'}';
9434 case Type::BlockPointer: {
9435 const auto *BT =
T->
castAs<BlockPointerType>();
9437 if (Options.EncodeBlockParameters()) {
9438 const auto *FT = BT->getPointeeType()->castAs<FunctionType>();
9442 getObjCEncodingForTypeImpl(FT->getReturnType(), S,
9443 Options.forComponentType(), FD, NotEncodedT);
9447 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
9448 for (
const auto &I : FPT->param_types())
9449 getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,
9457 case Type::ObjCObject: {
9461 S +=
"{objc_object=}";
9465 S +=
"{objc_class=}";
9472 case Type::ObjCInterface: {
9475 ObjCInterfaceDecl *OI =
T->
castAs<ObjCObjectType>()->getInterface();
9478 if (Options.ExpandStructures()) {
9480 SmallVector<const ObjCIvarDecl*, 32> Ivars;
9482 for (
unsigned i = 0, e = Ivars.size(); i != e; ++i) {
9483 const FieldDecl *
Field = Ivars[i];
9484 if (
Field->isBitField())
9485 getObjCEncodingForTypeImpl(
Field->getType(), S,
9486 ObjCEncOptions().setExpandStructures(),
9489 getObjCEncodingForTypeImpl(
Field->getType(), S,
9490 ObjCEncOptions().setExpandStructures(), FD,
9498 case Type::ObjCObjectPointer: {
9499 const auto *OPT =
T->
castAs<ObjCObjectPointerType>();
9500 if (OPT->isObjCIdType()) {
9505 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
9513 if (OPT->isObjCQualifiedIdType()) {
9514 getObjCEncodingForTypeImpl(
9516 Options.keepingOnly(ObjCEncOptions()
9517 .setExpandPointedToStructures()
9518 .setExpandStructures()),
9520 if (FD || Options.EncodingProperty() || Options.EncodeClassNames()) {
9524 for (
const auto *I : OPT->quals()) {
9526 S += I->getObjCRuntimeNameAsString();
9535 if (OPT->getInterfaceDecl() &&
9536 (FD || Options.EncodingProperty() || Options.EncodeClassNames())) {
9538 S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
9539 for (
const auto *I : OPT->quals()) {
9541 S += I->getObjCRuntimeNameAsString();
9551 case Type::MemberPointer:
9555 case Type::ExtVector:
9561 case Type::ConstantMatrix:
9574 case Type::DeducedTemplateSpecialization:
9577 case Type::HLSLAttributedResource:
9578 case Type::HLSLInlineSpirv:
9579 llvm_unreachable(
"unexpected type");
9581 case Type::ArrayParameter:
9583#define ABSTRACT_TYPE(KIND, BASE)
9584#define TYPE(KIND, BASE)
9585#define DEPENDENT_TYPE(KIND, BASE) \
9587#define NON_CANONICAL_TYPE(KIND, BASE) \
9589#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
9591#include "clang/AST/TypeNodes.inc"
9592 llvm_unreachable(
"@encode for dependent type!");
9594 llvm_unreachable(
"bad type kind!");
9597void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
9599 const FieldDecl *FD,
9601 QualType *NotEncodedT)
const {
9602 assert(RDecl &&
"Expected non-null RecordDecl");
9603 assert(!RDecl->
isUnion() &&
"Should not be called for unions");
9607 const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
9608 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
9612 for (
const auto &BI : CXXRec->bases()) {
9613 if (!BI.isVirtual()) {
9618 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9619 std::make_pair(offs, base));
9624 for (FieldDecl *Field : RDecl->
fields()) {
9625 if (!
Field->isZeroLengthBitField() &&
Field->isZeroSize(*
this))
9628 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9629 std::make_pair(offs, Field));
9632 if (CXXRec && includeVBases) {
9633 for (
const auto &BI : CXXRec->vbases()) {
9639 FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
9640 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
9641 std::make_pair(offs, base));
9655 std::multimap<uint64_t, NamedDecl *>::iterator
9656 CurLayObj = FieldOrBaseOffsets.begin();
9658 if (CXXRec && CXXRec->isDynamicClass() &&
9659 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
9662 std::string recname = CXXRec->getNameAsString();
9663 if (recname.empty()) recname =
"?";
9676 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9677 std::make_pair(offs,
nullptr));
9680 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
9682 assert(CurOffs <= CurLayObj->first);
9683 if (CurOffs < CurLayObj->first) {
9684 uint64_t padding = CurLayObj->first - CurOffs;
9696 NamedDecl *dcl = CurLayObj->second;
9700 if (
auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
9705 getObjCEncodingForStructureImpl(base, S, FD,
false,
9715 S += field->getNameAsString();
9719 if (field->isBitField()) {
9722 CurOffs += field->getBitWidthValue();
9725 QualType qt = field->getType();
9727 getObjCEncodingForTypeImpl(
9728 qt, S, ObjCEncOptions().setExpandStructures().setIsStructField(),
9739 std::string& S)
const {
9772 if (!ObjCClassDecl) {
9777 return ObjCClassDecl;
9781 if (!ObjCProtocolClassDecl) {
9782 ObjCProtocolClassDecl
9791 return ObjCProtocolClassDecl;
9812 QualType T = Context->getPointerType(Context->CharTy);
9813 return Context->buildImplicitTypedef(
T, Name);
9826 QualType T = Context->getPointerType(Context->VoidTy);
9827 return Context->buildImplicitTypedef(
T,
"__builtin_va_list");
9834 if (Context->getLangOpts().CPlusPlus) {
9839 &Context->Idents.get(
"std"),
9847 const size_t NumFields = 5;
9849 const char *FieldNames[NumFields];
9852 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
9853 FieldNames[0] =
"__stack";
9856 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
9857 FieldNames[1] =
"__gr_top";
9860 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
9861 FieldNames[2] =
"__vr_top";
9864 FieldTypes[3] = Context->IntTy;
9865 FieldNames[3] =
"__gr_offs";
9868 FieldTypes[4] = Context->IntTy;
9869 FieldNames[4] =
"__vr_offs";
9872 for (
unsigned i = 0; i < NumFields; ++i) {
9877 &Context->Idents.get(FieldNames[i]),
9878 FieldTypes[i],
nullptr,
9890 return Context->buildImplicitTypedef(VaListTagType,
"__builtin_va_list");
9897 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
9900 const size_t NumFields = 5;
9902 const char *FieldNames[NumFields];
9905 FieldTypes[0] = Context->UnsignedCharTy;
9906 FieldNames[0] =
"gpr";
9909 FieldTypes[1] = Context->UnsignedCharTy;
9910 FieldNames[1] =
"fpr";
9913 FieldTypes[2] = Context->UnsignedShortTy;
9914 FieldNames[2] =
"reserved";
9917 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
9918 FieldNames[3] =
"overflow_arg_area";
9921 FieldTypes[4] = Context->getPointerType(Context->VoidTy);
9922 FieldNames[4] =
"reg_save_area";
9925 for (
unsigned i = 0; i < NumFields; ++i) {
9929 &Context->Idents.get(FieldNames[i]),
9930 FieldTypes[i],
nullptr,
9943 Context->buildImplicitTypedef(VaListTagType,
"__va_list_tag");
9947 std::nullopt, VaListTagTypedefDecl);
9950 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
9951 QualType VaListTagArrayType = Context->getConstantArrayType(
9953 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
9960 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
9963 const size_t NumFields = 4;
9965 const char *FieldNames[NumFields];
9968 FieldTypes[0] = Context->UnsignedIntTy;
9969 FieldNames[0] =
"gp_offset";
9972 FieldTypes[1] = Context->UnsignedIntTy;
9973 FieldNames[1] =
"fp_offset";
9976 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
9977 FieldNames[2] =
"overflow_arg_area";
9980 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
9981 FieldNames[3] =
"reg_save_area";
9984 for (
unsigned i = 0; i < NumFields; ++i) {
9989 &Context->Idents.get(FieldNames[i]),
9990 FieldTypes[i],
nullptr,
10004 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10005 QualType VaListTagArrayType = Context->getConstantArrayType(
10007 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10010static TypedefDecl *
10013 RecordDecl *VaListDecl = Context->buildImplicitRecord(
"__va_list");
10014 if (Context->getLangOpts().CPlusPlus) {
10033 &Context->Idents.get(
"__ap"),
10034 Context->getPointerType(Context->VoidTy),
10044 Context->VaListTagDecl = VaListDecl;
10047 CanQualType T = Context->getCanonicalTagType(VaListDecl);
10048 return Context->buildImplicitTypedef(
T,
"__builtin_va_list");
10051static TypedefDecl *
10055 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
10058 const size_t NumFields = 4;
10060 const char *FieldNames[NumFields];
10063 FieldTypes[0] = Context->LongTy;
10064 FieldNames[0] =
"__gpr";
10067 FieldTypes[1] = Context->LongTy;
10068 FieldNames[1] =
"__fpr";
10071 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
10072 FieldNames[2] =
"__overflow_arg_area";
10075 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
10076 FieldNames[3] =
"__reg_save_area";
10079 for (
unsigned i = 0; i < NumFields; ++i) {
10084 &Context->Idents.get(FieldNames[i]),
10085 FieldTypes[i],
nullptr,
10099 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10100 QualType VaListTagArrayType = Context->getConstantArrayType(
10103 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10109 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
10112 const size_t NumFields = 3;
10114 const char *FieldNames[NumFields];
10117 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
10118 FieldNames[0] =
"__current_saved_reg_area_pointer";
10121 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
10122 FieldNames[1] =
"__saved_reg_area_end_pointer";
10125 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
10126 FieldNames[2] =
"__overflow_area_pointer";
10129 for (
unsigned i = 0; i < NumFields; ++i) {
10132 SourceLocation(), &Context->Idents.get(FieldNames[i]), FieldTypes[i],
10145 Context->buildImplicitTypedef(VaListTagType,
"__va_list_tag");
10149 std::nullopt, VaListTagTypedefDecl);
10152 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10153 QualType VaListTagArrayType = Context->getConstantArrayType(
10156 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10159static TypedefDecl *
10169 constexpr size_t NumFields = 3;
10170 QualType FieldTypes[NumFields] = {Context->getPointerType(Context->IntTy),
10171 Context->getPointerType(Context->IntTy),
10173 const char *FieldNames[NumFields] = {
"__va_stk",
"__va_reg",
"__va_ndx"};
10176 for (
unsigned i = 0; i < NumFields; ++i) {
10179 &Context->Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
10191 Context->buildImplicitTypedef(VaListTagType,
"__builtin_va_list");
10193 return VaListTagTypedefDecl;
10219 llvm_unreachable(
"Unhandled __builtin_va_list type kind");
10223 if (!BuiltinVaListDecl) {
10224 BuiltinVaListDecl =
CreateVaListDecl(
this, Target->getBuiltinVaListKind());
10225 assert(BuiltinVaListDecl->isImplicit());
10228 return BuiltinVaListDecl;
10241 if (!BuiltinMSVaListDecl)
10244 return BuiltinMSVaListDecl;
10261 assert(ObjCConstantStringType.isNull() &&
10262 "'NSConstantString' type already set!");
10272 unsigned size = End - Begin;
10273 assert(size > 1 &&
"set is not overloaded!");
10279 NamedDecl **Storage = OT->getStorage();
10302 bool TemplateKeyword,
10307 if (
Template.getAsTemplateDecl()->getKind() == Decl::TemplateTemplateParm) {
10308 assert(!Qualifier &&
"unexpected qualified template template parameter");
10309 assert(TemplateKeyword ==
false);
10314 llvm::FoldingSetNodeID ID;
10317 void *InsertPos =
nullptr;
10319 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
10323 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
10333 llvm::FoldingSetNodeID ID;
10336 void *InsertPos =
nullptr;
10338 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos))
10343 DependentTemplateNames.InsertNode(QTN, InsertPos);
10348 Decl *AssociatedDecl,
10351 bool Final)
const {
10352 llvm::FoldingSetNodeID ID;
10354 Index, PackIndex, Final);
10356 void *insertPos =
nullptr;
10358 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
10362 Replacement, AssociatedDecl, Index, PackIndex, Final);
10363 SubstTemplateTemplateParms.InsertNode(subst, insertPos);
10371 Decl *AssociatedDecl,
10372 unsigned Index,
bool Final)
const {
10374 llvm::FoldingSetNodeID ID;
10376 AssociatedDecl, Index, Final);
10378 void *InsertPos =
nullptr;
10380 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
10385 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
10399 llvm::FoldingSetNodeID ID;
10402 void *InsertPos =
nullptr;
10404 DeducedTemplates.FindNodeOrInsertPos(ID, InsertPos);
10410 DeducedTemplates.InsertNode(DTS, InsertPos);
10433 llvm_unreachable(
"Unhandled TargetInfo::IntType value");
10463 while (
const auto *AT = dyn_cast<ArrayType>(CT))
10464 CT = AT->getElementType();
10496 assert(FirstVec->
isVectorType() &&
"FirstVec should be a vector type");
10497 assert(SecondVec->
isVectorType() &&
"SecondVec should be a vector type");
10534 auto VScale = Context.getTargetInfo().getVScaleRange(
10541 uint64_t EltSize = Context.getTypeSize(Info.
ElementType);
10545 uint64_t MinElts = Info.
EC.getKnownMinValue();
10546 return VScale->first * MinElts * EltSize;
10554 "Expected RVV builtin type and vector type!");
10594 return IsValidCast(FirstType, SecondType) ||
10595 IsValidCast(SecondType, FirstType);
10603 "Expected RVV builtin type and vector type!");
10610 if (!BT->isRVVVLSBuiltinType())
10630 return VecTy->getElementType().getCanonicalType()->isIntegerType() &&
10637 return IsLaxCompatible(FirstType, SecondType) ||
10638 IsLaxCompatible(SecondType, FirstType);
10644 if (
const AttributedType *
Attr = dyn_cast<AttributedType>(Ty)) {
10645 if (
Attr->getAttrKind() == attr::ObjCOwnership)
10648 Ty =
Attr->getModifiedType();
10652 Ty =
Paren->getInnerType();
10684 for (
auto *lhsProto : lhs->
quals()) {
10685 bool match =
false;
10686 for (
auto *rhsProto : rhs->
quals()) {
10717 for (
auto *I : lhs->
quals()) {
10721 if (!rhsID->ClassImplementsProtocol(I,
true))
10729 for (
auto *lhsProto : lhs->
quals()) {
10730 bool match =
false;
10735 for (
auto *rhsProto : rhs->
quals()) {
10745 for (
auto *I : lhs->
quals()) {
10749 if (rhsID->ClassImplementsProtocol(I,
true)) {
10766 for (
auto *lhsProto : lhs->
quals()) {
10767 bool match =
false;
10774 for (
auto *rhsProto : rhs->
quals()) {
10793 if (LHSInheritedProtocols.empty() && lhs->
qual_empty())
10795 for (
auto *lhsProto : LHSInheritedProtocols) {
10796 bool match =
false;
10797 for (
auto *rhsProto : rhs->
quals()) {
10822 if (LHS->isObjCUnqualifiedId() || RHS->isObjCUnqualifiedId())
10827 auto finish = [&](
bool succeeded) ->
bool {
10831 if (!RHS->isKindOfType())
10842 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
10847 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
10852 if (LHS->isObjCClass() && RHS->isObjCClass()) {
10857 if (LHS->getInterface() && RHS->getInterface()) {
10872 bool BlockReturnType) {
10876 auto finish = [&](
bool succeeded) ->
bool {
10901 if (
getLangOpts().CompatibilityQualifiedIdBlockParamTypeChecking)
10905 (!BlockReturnType &&
10909 (BlockReturnType ? LHSOPT : RHSOPT),
10910 (BlockReturnType ? RHSOPT : LHSOPT),
false));
10918 return finish(BlockReturnType);
10920 return finish(!BlockReturnType);
10932 return (*lhs)->getName().compare((*rhs)->getName());
10949 assert(LHS->getInterface() &&
"LHS must have an interface base");
10950 assert(RHS->getInterface() &&
"RHS must have an interface base");
10956 for (
auto *proto : LHS->quals()) {
10957 Context.CollectInheritedProtocols(proto, LHSProtocolSet);
10961 Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
10967 for (
auto *proto : RHS->quals()) {
10968 Context.CollectInheritedProtocols(proto, RHSProtocolSet);
10972 Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
10975 for (
auto *proto : LHSProtocolSet) {
10976 if (RHSProtocolSet.count(proto))
10977 IntersectionSet.push_back(proto);
10983 Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
10986 if (!ImpliedProtocols.empty()) {
10988 return ImpliedProtocols.contains(proto);
10993 llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
11003 if (lhsOPT && rhsOPT)
11009 if (lhsBlock && rhsBlock)
11014 if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
11026 bool stripKindOf) {
11027 if (lhsArgs.size() != rhsArgs.size())
11034 for (
unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
11040 if (!stripKindOf ||
11041 !ctx.
hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
11042 rhsArgs[i].stripObjCKindOfType(ctx))) {
11070 if (!LDecl || !RDecl)
11076 bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();
11080 llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
11085 LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
11090 bool anyChanges =
false;
11091 if (LHS->isSpecialized() && RHS->isSpecialized()) {
11094 LHS->getTypeArgs(), RHS->getTypeArgs(),
11097 }
else if (LHS->isSpecialized() != RHS->isSpecialized()) {
11108 if (!Protocols.empty())
11114 if (anyChanges || LHS->isKindOfType() != anyKindOf) {
11117 anyKindOf || LHS->isKindOfType());
11125 QualType LHSSuperType = LHS->getSuperClassType();
11126 if (LHSSuperType.
isNull())
11135 auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
11136 if (KnownLHS != LHSAncestors.end()) {
11137 LHS = KnownLHS->second;
11141 bool anyChanges =
false;
11142 if (LHS->isSpecialized() && RHS->isSpecialized()) {
11145 LHS->getTypeArgs(), RHS->getTypeArgs(),
11148 }
else if (LHS->isSpecialized() != RHS->isSpecialized()) {
11159 if (!Protocols.empty())
11164 if (anyChanges || RHS->isKindOfType() != anyKindOf) {
11167 anyKindOf || RHS->isKindOfType());
11175 QualType RHSSuperType = RHS->getSuperClassType();
11176 if (RHSSuperType.
isNull())
11187 assert(LHS->getInterface() &&
"LHS is not an interface type");
11188 assert(RHS->getInterface() &&
"RHS is not an interface type");
11193 bool IsSuperClass = LHSInterface->
isSuperClassOf(RHS->getInterface());
11200 if (LHS->getNumProtocols() > 0) {
11209 for (
auto *RHSPI : RHS->quals())
11212 if (SuperClassInheritedProtocols.empty())
11215 for (
const auto *LHSProto : LHS->quals()) {
11216 bool SuperImplementsProtocol =
false;
11217 for (
auto *SuperClassProto : SuperClassInheritedProtocols)
11218 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
11219 SuperImplementsProtocol =
true;
11222 if (!SuperImplementsProtocol)
11228 if (LHS->isSpecialized()) {
11233 RHSSuper = RHSSuper->getSuperClassType()->castAs<
ObjCObjectType>();
11236 if (RHSSuper->isSpecialized() &&
11238 LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
11252 if (!LHSOPT || !RHSOPT)
11270 bool CompareUnqualified) {
11289 bool OfBlockPointer,
11291 if (
const RecordType *UT =
T->getAsUnionType()) {
11293 if (UD->
hasAttr<TransparentUnionAttr>()) {
11294 for (
const auto *I : UD->
fields()) {
11295 QualType ET = I->getType().getUnqualifiedType();
11309 bool OfBlockPointer,
11330 bool IsConditionalOperator) {
11333 const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
11334 const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
11335 bool allLTypes =
true;
11336 bool allRTypes =
true;
11340 if (OfBlockPointer) {
11342 QualType LHS = lbase->getReturnType();
11344 if (!UnqualifiedResult)
11346 retType =
mergeTypes(LHS, RHS,
true, UnqualifiedResult,
true);
11411 bool NoReturn = IsConditionalOperator
11421 std::optional<FunctionEffectSet> MergedFX;
11423 if (lproto && rproto) {
11424 assert((AllowCXX ||
11425 (!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec())) &&
11426 "C++ shouldn't be here");
11428 if (lproto->getNumParams() != rproto->getNumParams())
11432 if (lproto->isVariadic() != rproto->isVariadic())
11435 if (lproto->getMethodQuals() != rproto->getMethodQuals())
11439 if (lproto->getExtraAttributeInfo().CFISalt !=
11440 rproto->getExtraAttributeInfo().CFISalt)
11446 if (LHSFX != RHSFX) {
11447 if (IsConditionalOperator)
11456 if (*MergedFX != LHSFX)
11458 if (*MergedFX != RHSFX)
11463 bool canUseLeft, canUseRight;
11475 for (
unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
11476 QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
11477 QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
11479 lParamType, rParamType, OfBlockPointer,
Unqualified);
11486 types.push_back(paramType);
11498 if (allLTypes)
return lhs;
11499 if (allRTypes)
return rhs;
11504 newParamInfos.empty() ?
nullptr : newParamInfos.data();
11510 if (lproto) allRTypes =
false;
11511 if (rproto) allLTypes =
false;
11515 assert((AllowCXX || !proto->
hasExceptionSpec()) &&
"C++ shouldn't be here");
11523 for (
unsigned i = 0, n = proto->
getNumParams(); i < n; ++i) {
11529 paramTy = ED->getIntegerType();
11539 if (allLTypes)
return lhs;
11540 if (allRTypes)
return rhs;
11549 if (allLTypes)
return lhs;
11550 if (allRTypes)
return rhs;
11556 QualType other,
bool isBlockReturnType) {
11562 ET->getDecl()->getDefinitionOrSelf()->getIntegerType();
11563 if (underlyingType.
isNull())
11565 if (Context.hasSameType(underlyingType, other))
11571 Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
11580 if (LangOpts.CPlusPlus || !LangOpts.C23)
11601 bool IsConditionalOperator) {
11612 if (LangOpts.OpenMP && LHSRefTy && RHSRefTy &&
11616 if (LHSRefTy || RHSRefTy)
11628 if (LHSCan == RHSCan)
11633 Qualifiers RQuals = RHSCan.getLocalQualifiers();
11634 if (LQuals != RQuals) {
11651 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
11672 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
11673 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
11676 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
11677 LHSClass = Type::ConstantArray;
11678 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
11679 RHSClass = Type::ConstantArray;
11682 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
11683 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
11686 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
11687 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
11690 if (LHSClass != RHSClass) {
11700 if (OfBlockPointer && !BlockReturnType) {
11708 if (
const auto *AT = LHS->
getAs<AutoType>()) {
11709 if (!AT->isDeduced() && AT->isGNUAutoType())
11712 if (
const auto *AT = RHS->
getAs<AutoType>()) {
11713 if (!AT->isDeduced() && AT->isGNUAutoType())
11720 switch (LHSClass) {
11721#define TYPE(Class, Base)
11722#define ABSTRACT_TYPE(Class, Base)
11723#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
11724#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
11725#define DEPENDENT_TYPE(Class, Base) case Type::Class:
11726#include "clang/AST/TypeNodes.inc"
11727 llvm_unreachable(
"Non-canonical and dependent types shouldn't get here");
11730 case Type::DeducedTemplateSpecialization:
11731 case Type::LValueReference:
11732 case Type::RValueReference:
11733 case Type::MemberPointer:
11734 llvm_unreachable(
"C++ should never be in mergeTypes");
11736 case Type::ObjCInterface:
11737 case Type::IncompleteArray:
11738 case Type::VariableArray:
11739 case Type::FunctionProto:
11740 case Type::ExtVector:
11741 llvm_unreachable(
"Types are eliminated above");
11743 case Type::Pointer:
11754 if (ResultType.
isNull())
11762 case Type::BlockPointer:
11787 if (ResultType.
isNull())
11806 if (ResultType.
isNull())
11814 case Type::ConstantArray:
11829 if (ResultType.
isNull())
11837 if (LVAT || RVAT) {
11840 -> std::pair<bool,llvm::APInt> {
11842 std::optional<llvm::APSInt> TheInt;
11845 return std::make_pair(
true, *TheInt);
11846 return std::make_pair(
false, llvm::APSInt());
11849 return std::make_pair(
true, CAT->getSize());
11850 return std::make_pair(
false, llvm::APInt());
11853 bool HaveLSize, HaveRSize;
11854 llvm::APInt LSize, RSize;
11855 std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
11856 std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
11857 if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
11891 case Type::FunctionNoProto:
11893 false, IsConditionalOperator);
11897 case Type::Builtin:
11900 case Type::Complex:
11909 case Type::ConstantMatrix:
11914 case Type::ObjCObject: {
11923 case Type::ObjCObjectPointer:
11924 if (OfBlockPointer) {
11936 assert(LHS != RHS &&
11937 "Equivalent pipe types should have already been handled!");
11939 case Type::ArrayParameter:
11940 assert(LHS != RHS &&
11941 "Equivalent ArrayParameter types should have already been handled!");
11943 case Type::BitInt: {
11951 if (LHSUnsigned != RHSUnsigned)
11954 if (LHSBits != RHSBits)
11958 case Type::HLSLAttributedResource: {
11959 const HLSLAttributedResourceType *LHSTy =
11960 LHS->
castAs<HLSLAttributedResourceType>();
11961 const HLSLAttributedResourceType *RHSTy =
11962 RHS->
castAs<HLSLAttributedResourceType>();
11963 assert(LHSTy->getWrappedType() == RHSTy->getWrappedType() &&
11964 LHSTy->getWrappedType()->isHLSLResourceType() &&
11965 "HLSLAttributedResourceType should always wrap __hlsl_resource_t");
11967 if (LHSTy->getAttrs() == RHSTy->getAttrs() &&
11968 LHSTy->getContainedType() == RHSTy->getContainedType())
11972 case Type::HLSLInlineSpirv:
11973 const HLSLInlineSpirvType *LHSTy = LHS->
castAs<HLSLInlineSpirvType>();
11974 const HLSLInlineSpirvType *RHSTy = RHS->
castAs<HLSLInlineSpirvType>();
11976 if (LHSTy->getOpcode() == RHSTy->getOpcode() &&
11977 LHSTy->getSize() == RHSTy->getSize() &&
11978 LHSTy->getAlignment() == RHSTy->getAlignment()) {
11979 for (
size_t I = 0; I < LHSTy->getOperands().size(); I++)
11980 if (LHSTy->getOperands()[I] != RHSTy->getOperands()[I])
11988 llvm_unreachable(
"Invalid Type::Class!");
11993 bool &CanUseFirst,
bool &CanUseSecond,
11995 assert(NewParamInfos.empty() &&
"param info list not empty");
11996 CanUseFirst = CanUseSecond =
true;
12002 if (!FirstHasInfo && !SecondHasInfo)
12005 bool NeedParamInfo =
false;
12009 for (
size_t I = 0; I < E; ++I) {
12020 bool FirstNoEscape = FirstParam.
isNoEscape();
12021 bool SecondNoEscape = SecondParam.
isNoEscape();
12022 bool IsNoEscape = FirstNoEscape && SecondNoEscape;
12024 if (NewParamInfos.back().getOpaqueValue())
12025 NeedParamInfo =
true;
12026 if (FirstNoEscape != IsNoEscape)
12027 CanUseFirst =
false;
12028 if (SecondNoEscape != IsNoEscape)
12029 CanUseSecond =
false;
12032 if (!NeedParamInfo)
12033 NewParamInfos.clear();
12039 if (
auto It = ObjCLayouts.find(D); It != ObjCLayouts.end()) {
12040 It->second =
nullptr;
12041 for (
auto *SubClass : ObjCSubClasses[D])
12053 if (LHSCan == RHSCan)
12055 if (RHSCan->isFunctionType()) {
12064 if (ResReturnType.
isNull())
12066 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
12083 Qualifiers RQuals = RHSCan.getLocalQualifiers();
12084 if (LQuals != RQuals) {
12097 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
12113 if (ResQT == LHSBaseQT)
12115 if (ResQT == RHSBaseQT)
12126 if (
const auto *ED =
T->getAsEnumDecl())
12127 T = ED->getIntegerType();
12128 if (
T->isBooleanType())
12131 return EIT->getNumBits();
12137 assert((
T->hasIntegerRepresentation() ||
T->isEnumeralType() ||
12138 T->isFixedPointType()) &&
12139 "Unexpected type");
12144 VTy->getNumElements(), VTy->getVectorKind());
12152 if (
const auto *ED =
T->getAsEnumDecl())
12153 T = ED->getIntegerType();
12156 case BuiltinType::Char_U:
12158 case BuiltinType::Char_S:
12159 case BuiltinType::SChar:
12160 case BuiltinType::Char8:
12162 case BuiltinType::Short:
12164 case BuiltinType::Int:
12166 case BuiltinType::Long:
12168 case BuiltinType::LongLong:
12170 case BuiltinType::Int128:
12175 case BuiltinType::WChar_S:
12178 case BuiltinType::ShortAccum:
12180 case BuiltinType::Accum:
12182 case BuiltinType::LongAccum:
12184 case BuiltinType::SatShortAccum:
12186 case BuiltinType::SatAccum:
12188 case BuiltinType::SatLongAccum:
12190 case BuiltinType::ShortFract:
12192 case BuiltinType::Fract:
12194 case BuiltinType::LongFract:
12196 case BuiltinType::SatShortFract:
12198 case BuiltinType::SatFract:
12200 case BuiltinType::SatLongFract:
12203 assert((
T->hasUnsignedIntegerRepresentation() ||
12204 T->isUnsignedFixedPointType()) &&
12205 "Unexpected signed integer or fixed point type");
12211 assert((
T->hasIntegerRepresentation() ||
T->isEnumeralType() ||
12212 T->isFixedPointType()) &&
12213 "Unexpected type");
12218 VTy->getNumElements(), VTy->getVectorKind());
12226 if (
const auto *ED =
T->getAsEnumDecl())
12227 T = ED->getIntegerType();
12230 case BuiltinType::Char_S:
12232 case BuiltinType::Char_U:
12233 case BuiltinType::UChar:
12234 case BuiltinType::Char8:
12236 case BuiltinType::UShort:
12238 case BuiltinType::UInt:
12240 case BuiltinType::ULong:
12242 case BuiltinType::ULongLong:
12244 case BuiltinType::UInt128:
12249 case BuiltinType::WChar_U:
12252 case BuiltinType::UShortAccum:
12254 case BuiltinType::UAccum:
12256 case BuiltinType::ULongAccum:
12258 case BuiltinType::SatUShortAccum:
12260 case BuiltinType::SatUAccum:
12262 case BuiltinType::SatULongAccum:
12264 case BuiltinType::UShortFract:
12266 case BuiltinType::UFract:
12268 case BuiltinType::ULongFract:
12270 case BuiltinType::SatUShortFract:
12272 case BuiltinType::SatUFract:
12274 case BuiltinType::SatULongFract:
12278 (
T->hasSignedIntegerRepresentation() ||
T->isSignedFixedPointType()) &&
12279 "Unexpected signed integer or fixed point type");
12304 bool AllowTypeModifiers) {
12308 RequiresICE =
false;
12313 bool IsSpecial =
false;
12317 default: Done =
true; --Str;
break;
12319 RequiresICE =
true;
12322 assert(!
Unsigned &&
"Can't use both 'S' and 'U' modifiers!");
12323 assert(!
Signed &&
"Can't use 'S' modifier multiple times!");
12327 assert(!
Signed &&
"Can't use both 'S' and 'U' modifiers!");
12328 assert(!
Unsigned &&
"Can't use 'U' modifier multiple times!");
12332 assert(!IsSpecial &&
"Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers");
12333 assert(HowLong <= 2 &&
"Can't have LLLL modifier");
12338 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12339 assert(HowLong == 0 &&
"Can't use both 'L' and 'N' modifiers!");
12343 if (Context.getTargetInfo().getLongWidth() == 32)
12348 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12349 assert(HowLong == 0 &&
"Can't use both 'L' and 'W' modifiers!");
12353 switch (Context.getTargetInfo().getInt64Type()) {
12355 llvm_unreachable(
"Unexpected integer type");
12366 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12367 assert(HowLong == 0 &&
"Can't use both 'L' and 'Z' modifiers!");
12371 switch (Context.getTargetInfo().getIntTypeByWidth(32,
true)) {
12373 llvm_unreachable(
"Unexpected integer type");
12386 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12387 assert(HowLong == 0 &&
"Can't use both 'L' and 'O' modifiers!");
12391 if (Context.getLangOpts().OpenCL)
12403 default: llvm_unreachable(
"Unknown builtin type letter!");
12406 "Bad modifiers used with 'x'!");
12407 Type = Context.Float16Ty;
12411 "Bad modifiers used with 'y'!");
12412 Type = Context.BFloat16Ty;
12416 "Bad modifiers used with 'v'!");
12417 Type = Context.VoidTy;
12421 "Bad modifiers used with 'h'!");
12422 Type = Context.HalfTy;
12426 "Bad modifiers used with 'f'!");
12427 Type = Context.FloatTy;
12431 "Bad modifiers used with 'd'!");
12433 Type = Context.LongDoubleTy;
12434 else if (HowLong == 2)
12435 Type = Context.Float128Ty;
12437 Type = Context.DoubleTy;
12440 assert(HowLong == 0 &&
"Bad modifiers used with 's'!");
12442 Type = Context.UnsignedShortTy;
12444 Type = Context.ShortTy;
12448 Type =
Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
12449 else if (HowLong == 2)
12450 Type =
Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
12451 else if (HowLong == 1)
12452 Type =
Unsigned ? Context.UnsignedLongTy : Context.LongTy;
12454 Type =
Unsigned ? Context.UnsignedIntTy : Context.IntTy;
12457 assert(HowLong == 0 &&
"Bad modifiers used with 'c'!");
12459 Type = Context.SignedCharTy;
12461 Type = Context.UnsignedCharTy;
12463 Type = Context.CharTy;
12466 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'b'!");
12467 Type = Context.BoolTy;
12470 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'z'!");
12471 Type = Context.getSizeType();
12474 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'w'!");
12475 Type = Context.getWideCharType();
12478 Type = Context.getCFConstantStringType();
12481 Type = Context.getObjCIdType();
12484 Type = Context.getObjCSelType();
12487 Type = Context.getObjCSuperType();
12490 Type = Context.getBuiltinVaListType();
12491 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12502 Type = Context.getBuiltinVaListType();
12503 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12505 Type = Context.getArrayDecayedType(
Type);
12507 Type = Context.getLValueReferenceType(
Type);
12511 unsigned NumElements = strtoul(Str, &End, 10);
12512 assert(End != Str &&
"Missing vector size");
12516 RequiresICE,
false);
12517 assert(!RequiresICE &&
"Can't require vector ICE");
12519 Type = Context.getScalableVectorType(ElementType, NumElements);
12525 Type = Context.SveCountTy;
12529 Type = Context.AMDGPUBufferRsrcTy;
12533 Type = Context.AMDGPUTextureTy;
12537 llvm_unreachable(
"Unexpected target builtin type");
12543 unsigned NumElements = strtoul(Str, &End, 10);
12544 assert(End != Str &&
"Missing vector size");
12548 RequiresICE,
false);
12549 assert(!RequiresICE &&
"Can't require vector ICE");
12558 unsigned NumElements = strtoul(Str, &End, 10);
12559 assert(End != Str &&
"Missing vector size");
12565 Type = Context.getExtVectorType(ElementType, NumElements);
12571 assert(!RequiresICE &&
"Can't require complex ICE");
12572 Type = Context.getComplexType(ElementType);
12576 Type = Context.getPointerDiffType();
12579 Type = Context.getFILEType();
12580 if (
Type.isNull()) {
12587 Type = Context.getsigjmp_bufType();
12589 Type = Context.getjmp_bufType();
12591 if (
Type.isNull()) {
12597 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'K'!");
12598 Type = Context.getucontext_tType();
12600 if (
Type.isNull()) {
12606 Type = Context.getProcessIDType();
12609 Type = Context.MFloat8Ty;
12614 Done = !AllowTypeModifiers;
12616 switch (
char c = *Str++) {
12617 default: Done =
true; --Str;
break;
12623 unsigned AddrSpace = strtoul(Str, &End, 10);
12626 Type = Context.getAddrSpaceQualType(
12628 Context.getLangASForBuiltinAddressSpace(AddrSpace));
12632 Type = Context.getPointerType(
Type);
12634 Type = Context.getLValueReferenceType(
Type);
12642 Type = Context.getVolatileType(
Type);
12651 "Integer constant 'I' type must be an integer");
12664 bool AllowTypeModifiers)
const {
12671 unsigned *IntegerConstantArgs)
const {
12672 const char *TypeStr =
BuiltinInfo.getTypeString(Id);
12673 if (TypeStr[0] ==
'\0') {
12680 bool RequiresICE =
false;
12683 RequiresICE,
true);
12687 assert(!RequiresICE &&
"Result of intrinsic cannot be required to be an ICE");
12689 while (TypeStr[0] && TypeStr[0] !=
'.') {
12696 if (RequiresICE && IntegerConstantArgs)
12697 *IntegerConstantArgs |= 1 << ArgTypes.size();
12703 ArgTypes.push_back(Ty);
12706 if (Id == Builtin::BI__GetExceptionInfo)
12709 assert((TypeStr[0] !=
'.' || TypeStr[1] == 0) &&
12710 "'.' should only occur at end of builtin type list!");
12712 bool Variadic = (TypeStr[0] ==
'.');
12719 if (ArgTypes.empty() && Variadic && !
getLangOpts().requiresStrictPrototypes())
12769 if ((!Context.getLangOpts().CPlusPlus &&
12770 !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12771 !FD->
hasAttr<DLLExportAttr>()) ||
12772 FD->
hasAttr<GNUInlineAttr>()) {
12790 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12805 if (D->
hasAttr<DLLImportAttr>()) {
12808 }
else if (D->
hasAttr<DLLExportAttr>()) {
12811 }
else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice) {
12814 if (D->
hasAttr<CUDAGlobalAttr>() &&
12823 if (Context.shouldExternalize(D))
12838 switch (Source->hasExternalDefinitions(D)) {
12865 if (Context.getLangOpts().CPlusPlus &&
12866 Context.getLangOpts().IncrementalExtensions &&
12882 if (!LexicalContext)
12887 auto StaticLocalLinkage =
12899 return StaticLocalLinkage;
12905 if (Context.isMSStaticDataMemberInlineDefinition(VD))
12911 switch (Context.getInlineVariableDefinitionKind(VD)) {
12926 return StrongLinkage;
12929 return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12944 llvm_unreachable(
"Invalid Linkage!");
12954 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
12955 if (!VD->isFileVarDecl())
12960 if (VD->getDescribedVarTemplate() ||
12963 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
12989 if (D->
hasAttr<WeakRefAttr>())
12996 if (LangOpts.SYCLIsDevice)
12998 D->
hasAttr<SYCLExternalAttr>());
13004 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
13006 if (!FD->doesThisDeclarationHaveABody())
13007 return FD->doesDeclarationForceExternallyVisibleDefinition();
13010 if (FD->
hasAttr<ConstructorAttr>() || FD->
hasAttr<DestructorAttr>())
13015 if (
getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
13016 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
13035 assert(VD->isFileVarDecl() &&
"Expected file scoped var");
13039 if (LangOpts.OpenMP &&
13040 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
13047 if (VD->shouldEmitInExternalSource())
13060 if (VD->needsDestruction(*
this))
13064 if (VD->hasInitWithSideEffects())
13069 if (
const auto *DD = dyn_cast<DecompositionDecl>(VD)) {
13070 for (
const auto *BD : DD->flat_bindings())
13071 if (
const auto *BindingVD = BD->getHoldingVar())
13081 llvm::function_ref<
void(
FunctionDecl *)> Pred)
const {
13082 assert(FD->
isMultiVersion() &&
"Only valid for multiversioned functions");
13083 llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
13088 for (
auto *CurDecl :
13092 SeenDecls.insert(CurFD).second) {
13099 bool IsCXXMethod)
const {
13102 return ABI->getDefaultMethodCallConv(IsVariadic);
13104 switch (LangOpts.getDefaultCallingConv()) {
13132 return Target->getDefaultCallingConv();
13137 return ABI->isNearlyEmpty(RD);
13142 auto ABI = Target->getCXXABI();
13143 if (ABI.isMicrosoft())
13146 auto ComponentLayout =
getLangOpts().RelativeCXXABIVTables
13152 return VTContext.get();
13158 switch (
T->getCXXABI().getKind()) {
13159 case TargetCXXABI::AppleARM64:
13160 case TargetCXXABI::Fuchsia:
13161 case TargetCXXABI::GenericAArch64:
13162 case TargetCXXABI::GenericItanium:
13163 case TargetCXXABI::GenericARM:
13164 case TargetCXXABI::GenericMIPS:
13165 case TargetCXXABI::iOS:
13166 case TargetCXXABI::WebAssembly:
13167 case TargetCXXABI::WatchOS:
13168 case TargetCXXABI::XL:
13170 case TargetCXXABI::Microsoft:
13173 llvm_unreachable(
"Unsupported ABI");
13177 assert(
T.getCXXABI().getKind() != TargetCXXABI::Microsoft &&
13178 "Device mangle context does not support Microsoft mangling.");
13179 switch (
T.getCXXABI().getKind()) {
13180 case TargetCXXABI::AppleARM64:
13181 case TargetCXXABI::Fuchsia:
13182 case TargetCXXABI::GenericAArch64:
13183 case TargetCXXABI::GenericItanium:
13184 case TargetCXXABI::GenericARM:
13185 case TargetCXXABI::GenericMIPS:
13186 case TargetCXXABI::iOS:
13187 case TargetCXXABI::WebAssembly:
13188 case TargetCXXABI::WatchOS:
13189 case TargetCXXABI::XL:
13193 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
13194 return RD->getDeviceLambdaManglingNumber();
13195 return std::nullopt;
13198 case TargetCXXABI::Microsoft:
13202 llvm_unreachable(
"Unsupported ABI");
13208 return ASTRecordLayouts.getMemorySize() +
13209 llvm::capacity_in_bytes(ObjCLayouts) +
13210 llvm::capacity_in_bytes(KeyFunctions) +
13211 llvm::capacity_in_bytes(ObjCImpls) +
13212 llvm::capacity_in_bytes(BlockVarCopyInits) +
13213 llvm::capacity_in_bytes(DeclAttrs) +
13214 llvm::capacity_in_bytes(TemplateOrInstantiation) +
13215 llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
13216 llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
13217 llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
13218 llvm::capacity_in_bytes(OverriddenMethods) +
13219 llvm::capacity_in_bytes(Types) +
13220 llvm::capacity_in_bytes(VariableArrayTypes);
13228 unsigned Signed)
const {
13231 if (!QualTy && DestWidth == 128)
13260 llvm_unreachable(
"Unhandled TargetInfo::RealType value");
13267 MangleNumbers[ND] = Number;
13270 Listener->AddedManglingNumber(ND, Number);
13274 bool ForAuxTarget)
const {
13275 auto I = MangleNumbers.find(ND);
13276 unsigned Res = I != MangleNumbers.end() ? I->second : 1;
13279 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice) {
13280 Res = ForAuxTarget ? Res >> 16 : Res & 0xFFFF;
13282 assert(!ForAuxTarget &&
"Only CUDA/HIP host compilation supports mangling "
13283 "number for aux target");
13285 return Res > 1 ? Res : 1;
13292 StaticLocalNumbers[VD] = Number;
13295 Listener->AddedStaticLocalNumbers(VD, Number);
13299 auto I = StaticLocalNumbers.find(VD);
13300 return I != StaticLocalNumbers.end() ? I->second : 1;
13304 bool IsDestroying) {
13305 if (!IsDestroying) {
13317 bool IsTypeAware) {
13318 if (!IsTypeAware) {
13331 assert(LangOpts.CPlusPlus);
13332 std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
13340 assert(LangOpts.CPlusPlus);
13341 std::unique_ptr<MangleNumberingContext> &MCtx =
13342 ExtraMangleNumberingContexts[D];
13348std::unique_ptr<MangleNumberingContext>
13350 return ABI->createMangleNumberingContext();
13355 return ABI->getCopyConstructorForExceptionObject(
13361 return ABI->addCopyConstructorForExceptionObject(
13368 return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
13373 return ABI->getTypedefNameForUnnamedTagDecl(TD);
13378 return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
13382 return ABI->getDeclaratorForUnnamedTagDecl(TD);
13386 ParamIndices[D] =
index;
13390 ParameterIndexTable::const_iterator I = ParamIndices.find(D);
13391 assert(I != ParamIndices.end() &&
13392 "ParmIndices lacks entry set by ParmVarDecl");
13397 unsigned Length)
const {
13423 assert(
MSGuidTagDecl &&
"building MS GUID without MS extensions?");
13425 llvm::FoldingSetNodeID ID;
13429 if (
MSGuidDecl *Existing = MSGuidDecls.FindNodeOrInsertPos(ID, InsertPos))
13433 MSGuidDecl *
New = MSGuidDecl::Create(*
this, GUIDType, Parts);
13434 MSGuidDecls.InsertNode(
New, InsertPos);
13440 const APValue &APVal)
const {
13441 llvm::FoldingSetNodeID ID;
13446 UnnamedGlobalConstantDecls.FindNodeOrInsertPos(ID, InsertPos))
13450 UnnamedGlobalConstantDecl::Create(*
this, Ty, APVal);
13451 UnnamedGlobalConstantDecls.InsertNode(
New, InsertPos);
13457 assert(
T->isRecordType() &&
"template param object of unexpected type");
13463 llvm::FoldingSetNodeID ID;
13468 TemplateParamObjectDecls.FindNodeOrInsertPos(ID, InsertPos))
13472 TemplateParamObjectDecls.InsertNode(
New, InsertPos);
13478 if (!
T.isOSDarwin())
13481 if (!(
T.isiOS() &&
T.isOSVersionLT(7)) &&
13482 !(
T.isMacOSX() &&
T.isOSVersionLT(10, 9)))
13491 return (Size != Align ||
toBits(sizeChars) > MaxInlineWidthInBits);
13498 if (MethodDecl->
hasAttr<UnavailableAttr>()
13499 || MethodDecl->
hasAttr<DeprecatedAttr>())
13513 IM != EM && IF != EF; ++IM, ++IF) {
13544 llvm::FoldingSetNodeID IDX, IDY;
13545 X->Profile(IDX, *
this,
true);
13546 Y->
Profile(IDY, *
this,
true);
13560 for (
const Decl *DX :
X->redecls()) {
13565 if (DX->isFirstDecl())
13568 llvm_unreachable(
"Corrupt redecls chain");
13571template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13573 return cast_or_null<T>(
13575 const_cast<Decl *
>(cast_or_null<Decl>(Y))));
13578template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13586 bool IgnoreDeduced =
false) {
13601 bool IgnoreDeduced) {
13609 assert(Xs.size() == Ys.size());
13611 for (
size_t I = 0; I < Rs.size(); ++I)
13618 return X->getAttributeLoc() == Y->getAttributeLoc() ?
X->getAttributeLoc()
13628 switch (
X.getKind()) {
13658 auto NExpX =
X.getNumTemplateExpansions();
13672 if (Xs.size() != Ys.size())
13674 R.resize(Xs.size());
13675 for (
size_t I = 0; I < R.size(); ++I) {
13688 assert(!Different);
13716 assert(!IsSame &&
"Should be the same NestedNameSpecifier");
13718 return std::nullopt;
13723 assert(Kind == NNS2.
getKind());
13728 auto Kind = Namespace1->getKind();
13729 if (Kind != Namespace2->getKind() ||
13730 (Kind == Decl::NamespaceAlias &&
13735 Namespace2->getNamespace()),
13769 llvm_unreachable(
"singletons did not compare equal");
13777 const T *Y,
bool IsSame) {
13778 return ::getCommonNNS(Ctx,
X->getQualifier(), Y->getQualifier(), IsSame);
13791 QualType EX =
X->getElementType(), EY = Y->getElementType();
13800 QY += EY.getQualifiers() - RQ;
13812 assert(Ctx.
hasSameExpr(
X->getSizeExpr(), Y->getSizeExpr()));
13813 return X->getSizeExpr();
13818 return X->getSizeModifier();
13824 return X->getIndexTypeCVRQualifiers();
13834 llvm::DenseMap<QualType, unsigned>
Found;
13835 for (
auto Ts : {
X, Y}) {
13842 Out.emplace_back(
T);
13848FunctionProtoType::ExceptionSpecInfo
13852 bool AcceptDependent)
const {
13878 assert(AcceptDependent &&
13879 "computing composite pointer type of dependent types");
13894 llvm_unreachable(
"These ESTs should be handled above");
13899 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
13903 Result.Exceptions = ExceptionTypeStorage;
13910 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
13913 llvm_unreachable(
"invalid ExceptionSpecificationType");
13922#define UNEXPECTED_TYPE(Class, Kind) \
13923 case Type::Class: \
13924 llvm_unreachable("Unexpected " Kind ": " #Class);
13926#define NON_CANONICAL_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "non-canonical")
13927#define TYPE(Class, Base)
13928#include "clang/AST/TypeNodes.inc"
13930#define SUGAR_FREE_TYPE(Class) UNEXPECTED_TYPE(Class, "sugar-free")
13941#undef SUGAR_FREE_TYPE
13942#define NON_UNIQUE_TYPE(Class) UNEXPECTED_TYPE(Class, "non-unique")
13945#undef NON_UNIQUE_TYPE
13949#undef UNEXPECTED_TYPE
13953 assert(AX->getDeducedType().isNull());
13954 assert(AY->getDeducedType().isNull());
13955 assert(AX->getKeyword() == AY->getKeyword());
13956 assert(AX->isInstantiationDependentType() ==
13957 AY->isInstantiationDependentType());
13959 AY->getTypeConstraintArguments());
13962 AX->containsUnexpandedParameterPack(),
13964 AY->getTypeConstraintConcept()),
13967 case Type::IncompleteArray: {
13974 case Type::DependentSizedArray: {
13982 case Type::ConstantArray: {
13985 assert(AX->getSize() == AY->getSize());
13986 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13987 ? AX->getSizeExpr()
13993 case Type::ArrayParameter: {
13996 assert(AX->getSize() == AY->getSize());
13997 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13998 ? AX->getSizeExpr()
14005 case Type::Atomic: {
14010 case Type::Complex: {
14014 case Type::Pointer: {
14018 case Type::BlockPointer: {
14022 case Type::ObjCObjectPointer: {
14027 case Type::MemberPointer: {
14031 PY->getMostRecentCXXRecordDecl()));
14035 PX->getMostRecentCXXRecordDecl());
14037 case Type::LValueReference: {
14042 PX->isSpelledAsLValue() ||
14043 PY->isSpelledAsLValue());
14045 case Type::RValueReference: {
14051 case Type::DependentAddressSpace: {
14054 assert(Ctx.
hasSameExpr(PX->getAddrSpaceExpr(), PY->getAddrSpaceExpr()));
14056 PX->getAddrSpaceExpr(),
14059 case Type::FunctionNoProto: {
14062 assert(FX->getExtInfo() == FY->getExtInfo());
14067 case Type::FunctionProto: {
14071 EPIY = FY->getExtProtoInfo();
14072 assert(EPIX.
ExtInfo == EPIY.ExtInfo);
14079 assert(EPIX.
TypeQuals == EPIY.TypeQuals);
14080 assert(EPIX.
Variadic == EPIY.Variadic);
14089 auto P =
getCommonTypes(Ctx, FX->param_types(), FY->param_types(),
14097 case Type::ObjCObject: {
14100 std::equal(OX->getProtocols().begin(), OX->getProtocols().end(),
14101 OY->getProtocols().begin(), OY->getProtocols().end(),
14103 return P0->getCanonicalDecl() == P1->getCanonicalDecl();
14105 "protocol lists must be the same");
14107 OY->getTypeArgsAsWritten());
14110 OX->getProtocols(),
14111 OX->isKindOfTypeAsWritten() && OY->isKindOfTypeAsWritten());
14113 case Type::ConstantMatrix: {
14116 assert(MX->getNumRows() == MY->getNumRows());
14117 assert(MX->getNumColumns() == MY->getNumColumns());
14119 MX->getNumRows(), MX->getNumColumns());
14121 case Type::DependentSizedMatrix: {
14124 assert(Ctx.
hasSameExpr(MX->getRowExpr(), MY->getRowExpr()));
14125 assert(Ctx.
hasSameExpr(MX->getColumnExpr(), MY->getColumnExpr()));
14130 case Type::Vector: {
14132 assert(VX->getNumElements() == VY->getNumElements());
14133 assert(VX->getVectorKind() == VY->getVectorKind());
14135 VX->getNumElements(), VX->getVectorKind());
14137 case Type::ExtVector: {
14139 assert(VX->getNumElements() == VY->getNumElements());
14141 VX->getNumElements());
14143 case Type::DependentSizedExtVector: {
14150 case Type::DependentVector: {
14153 assert(VX->getVectorKind() == VY->getVectorKind());
14160 case Type::InjectedClassName: {
14167 case Type::TemplateSpecialization: {
14171 TY->template_arguments());
14175 TY->getTemplateName(),
14177 As, {},
X->getCanonicalTypeInternal());
14179 case Type::Decltype: {
14182 assert(DX->isDependentType());
14183 assert(DY->isDependentType());
14184 assert(Ctx.
hasSameExpr(DX->getUnderlyingExpr(), DY->getUnderlyingExpr()));
14188 case Type::PackIndexing: {
14191 assert(DX->isDependentType());
14192 assert(DY->isDependentType());
14193 assert(Ctx.
hasSameExpr(DX->getIndexExpr(), DY->getIndexExpr()));
14196 case Type::DependentName: {
14199 assert(NX->getIdentifier() == NY->getIdentifier());
14204 case Type::UnaryTransform: {
14207 assert(TX->getUTTKind() == TY->getUTTKind());
14211 TY->getUnderlyingType()),
14214 case Type::PackExpansion: {
14217 assert(PX->getNumExpansions() == PY->getNumExpansions());
14220 PX->getNumExpansions(),
false);
14224 assert(PX->isReadOnly() == PY->isReadOnly());
14229 case Type::TemplateTypeParm: {
14232 assert(TX->getDepth() == TY->getDepth());
14233 assert(TX->getIndex() == TY->getIndex());
14234 assert(TX->isParameterPack() == TY->isParameterPack());
14236 TX->getDepth(), TX->getIndex(), TX->isParameterPack(),
14240 llvm_unreachable(
"Unknown Type Class");
14250#define UNEXPECTED_TYPE(Class, Kind) \
14251 case Type::Class: \
14252 llvm_unreachable("Unexpected " Kind ": " #Class);
14253#define TYPE(Class, Base)
14254#define DEPENDENT_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "dependent")
14255#include "clang/AST/TypeNodes.inc"
14257#define CANONICAL_TYPE(Class) UNEXPECTED_TYPE(Class, "canonical")
14283#undef CANONICAL_TYPE
14285#undef UNEXPECTED_TYPE
14287 case Type::Adjusted: {
14289 QualType OX = AX->getOriginalType(), OY = AY->getOriginalType();
14296 case Type::Decayed: {
14298 QualType OX = DX->getOriginalType(), OY = DY->getOriginalType();
14305 case Type::Attributed: {
14307 AttributedType::Kind Kind = AX->getAttrKind();
14308 if (Kind != AY->getAttrKind())
14310 QualType MX = AX->getModifiedType(), MY = AY->getModifiedType();
14318 case Type::BTFTagAttributed: {
14320 const BTFTypeTagAttr *AX = BX->getAttr();
14322 if (AX->getBTFTypeTag() !=
14331 if (KW != AY->getKeyword())
14335 AY->getTypeConstraintConcept());
14339 AY->getTypeConstraintArguments())) {
14347 false,
false, CD, As);
14349 case Type::PackIndexing:
14350 case Type::Decltype:
14352 case Type::DeducedTemplateSpecialization:
14355 case Type::MacroQualified: {
14359 if (IX != MY->getMacroIdentifier())
14363 case Type::SubstTemplateTypeParm: {
14370 unsigned Index = SX->getIndex();
14371 if (Index != SY->getIndex())
14373 auto PackIndex = SX->getPackIndex();
14374 if (PackIndex != SY->getPackIndex())
14377 CD, Index, PackIndex,
14378 SX->getFinal() && SY->getFinal());
14380 case Type::ObjCTypeParam:
14386 case Type::TemplateSpecialization: {
14391 TY->getTemplateName(),
true);
14396 TY->template_arguments()))
14402 case Type::Typedef: {
14412 case Type::TypeOf: {
14423 case Type::TypeOfExpr:
14426 case Type::UnaryTransform: {
14429 UnaryTransformType::UTTKind KX = UX->getUTTKind();
14430 if (KX != UY->getUTTKind())
14432 QualType BX = UX->getBaseType(), BY = UY->getBaseType();
14439 case Type::Using: {
14448 case Type::MemberPointer: {
14452 assert(Cls == PY->getMostRecentCXXRecordDecl());
14457 case Type::CountAttributed: {
14460 if (DX->isCountInBytes() != DY->isCountInBytes())
14462 if (DX->isOrNull() != DY->isOrNull())
14464 Expr *CEX = DX->getCountExpr();
14465 Expr *CEY = DY->getCountExpr();
14469 DX->isCountInBytes(), DX->isOrNull(),
14480 DX->isCountInBytes(), DX->isOrNull(),
14483 case Type::PredefinedSugar:
14488 llvm_unreachable(
"Unhandled Type Class");
14495 QualType NT =
T.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
14510 if (
X.isCanonical())
14539 if (SX.
Ty != SY.Ty) {
14547 while (!Xs.empty() && !Ys.empty() && Xs.back().Ty == Ys.back().Ty) {
14550 SX = Xs.pop_back_val();
14551 SY = Ys.pop_back_val();
14554 if (KeepCommonQualifiers)
14561 while (!Xs.empty() && !Ys.empty()) {
14564 SX = Xs.pop_back_val();
14565 SY = Ys.pop_back_val();
14570 SX.
Ty = Underlying.Ty;
14573 QX -= Underlying.Quals;
14591 llvm_unreachable(
"Not a saturated fixed point type!");
14592 case BuiltinType::SatShortAccum:
14594 case BuiltinType::SatAccum:
14596 case BuiltinType::SatLongAccum:
14598 case BuiltinType::SatUShortAccum:
14600 case BuiltinType::SatUAccum:
14602 case BuiltinType::SatULongAccum:
14604 case BuiltinType::SatShortFract:
14606 case BuiltinType::SatFract:
14608 case BuiltinType::SatLongFract:
14610 case BuiltinType::SatUShortFract:
14612 case BuiltinType::SatUFract:
14614 case BuiltinType::SatULongFract:
14626 llvm_unreachable(
"Not a fixed point type!");
14627 case BuiltinType::ShortAccum:
14629 case BuiltinType::Accum:
14631 case BuiltinType::LongAccum:
14633 case BuiltinType::UShortAccum:
14635 case BuiltinType::UAccum:
14637 case BuiltinType::ULongAccum:
14639 case BuiltinType::ShortFract:
14641 case BuiltinType::Fract:
14643 case BuiltinType::LongFract:
14645 case BuiltinType::UShortFract:
14647 case BuiltinType::UFract:
14649 case BuiltinType::ULongFract:
14655 if (LangOpts.OpenCL)
14679 llvm_unreachable(
"Not a fixed point type!");
14680 case BuiltinType::ShortAccum:
14681 case BuiltinType::SatShortAccum:
14682 return Target.getShortAccumScale();
14683 case BuiltinType::Accum:
14684 case BuiltinType::SatAccum:
14685 return Target.getAccumScale();
14686 case BuiltinType::LongAccum:
14687 case BuiltinType::SatLongAccum:
14688 return Target.getLongAccumScale();
14689 case BuiltinType::UShortAccum:
14690 case BuiltinType::SatUShortAccum:
14691 return Target.getUnsignedShortAccumScale();
14692 case BuiltinType::UAccum:
14693 case BuiltinType::SatUAccum:
14694 return Target.getUnsignedAccumScale();
14695 case BuiltinType::ULongAccum:
14696 case BuiltinType::SatULongAccum:
14697 return Target.getUnsignedLongAccumScale();
14698 case BuiltinType::ShortFract:
14699 case BuiltinType::SatShortFract:
14700 return Target.getShortFractScale();
14701 case BuiltinType::Fract:
14702 case BuiltinType::SatFract:
14703 return Target.getFractScale();
14704 case BuiltinType::LongFract:
14705 case BuiltinType::SatLongFract:
14706 return Target.getLongFractScale();
14707 case BuiltinType::UShortFract:
14708 case BuiltinType::SatUShortFract:
14709 return Target.getUnsignedShortFractScale();
14710 case BuiltinType::UFract:
14711 case BuiltinType::SatUFract:
14712 return Target.getUnsignedFractScale();
14713 case BuiltinType::ULongFract:
14714 case BuiltinType::SatULongFract:
14715 return Target.getUnsignedLongFractScale();
14725 llvm_unreachable(
"Not a fixed point type!");
14726 case BuiltinType::ShortAccum:
14727 case BuiltinType::SatShortAccum:
14728 return Target.getShortAccumIBits();
14729 case BuiltinType::Accum:
14730 case BuiltinType::SatAccum:
14731 return Target.getAccumIBits();
14732 case BuiltinType::LongAccum:
14733 case BuiltinType::SatLongAccum:
14734 return Target.getLongAccumIBits();
14735 case BuiltinType::UShortAccum:
14736 case BuiltinType::SatUShortAccum:
14737 return Target.getUnsignedShortAccumIBits();
14738 case BuiltinType::UAccum:
14739 case BuiltinType::SatUAccum:
14740 return Target.getUnsignedAccumIBits();
14741 case BuiltinType::ULongAccum:
14742 case BuiltinType::SatULongAccum:
14743 return Target.getUnsignedLongAccumIBits();
14744 case BuiltinType::ShortFract:
14745 case BuiltinType::SatShortFract:
14746 case BuiltinType::Fract:
14747 case BuiltinType::SatFract:
14748 case BuiltinType::LongFract:
14749 case BuiltinType::SatLongFract:
14750 case BuiltinType::UShortFract:
14751 case BuiltinType::SatUShortFract:
14752 case BuiltinType::UFract:
14753 case BuiltinType::SatUFract:
14754 case BuiltinType::ULongFract:
14755 case BuiltinType::SatULongFract:
14760llvm::FixedPointSemantics
14763 "Can only get the fixed point semantics for a "
14764 "fixed point or integer type.");
14766 return llvm::FixedPointSemantics::GetIntegerSemantics(
14770 return llvm::FixedPointSemantics(
14773 !isSigned &&
getTargetInfo().doUnsignedFixedPointTypesHavePadding());
14788 "Expected unsigned fixed point type");
14791 case BuiltinType::UShortAccum:
14793 case BuiltinType::UAccum:
14795 case BuiltinType::ULongAccum:
14797 case BuiltinType::SatUShortAccum:
14799 case BuiltinType::SatUAccum:
14801 case BuiltinType::SatULongAccum:
14803 case BuiltinType::UShortFract:
14805 case BuiltinType::UFract:
14807 case BuiltinType::ULongFract:
14809 case BuiltinType::SatUShortFract:
14811 case BuiltinType::SatUFract:
14813 case BuiltinType::SatULongFract:
14816 llvm_unreachable(
"Unexpected unsigned fixed point type");
14824 std::vector<std::string> BackendFeats;
14825 llvm::AArch64::ExtensionSet FeatureBits;
14826 for (StringRef F : FMVFeatStrings)
14827 if (
auto FMVExt = llvm::AArch64::parseFMVExtension(F))
14829 FeatureBits.enable(*FMVExt->ID);
14830 FeatureBits.toLLVMFeatureList(BackendFeats);
14831 return BackendFeats;
14836 assert(TD !=
nullptr);
14839 llvm::erase_if(
ParsedAttr.Features, [&](
const std::string &Feat) {
14840 return !Target->isValidFeatureName(StringRef{Feat}.substr(1));
14851 Target->getTargetOpts().CPU,
14852 Target->getTargetOpts().Features);
14859 StringRef TargetCPU = Target->getTargetOpts().CPU;
14861 if (
const auto *TD = FD->
getAttr<TargetAttr>()) {
14867 if (!Target->getTriple().isAArch64())
14870 Target->getTargetOpts().FeaturesAsWritten.begin(),
14871 Target->getTargetOpts().FeaturesAsWritten.end());
14882 }
else if (
const auto *SD = FD->
getAttr<CPUSpecificAttr>()) {
14884 Target->getCPUSpecificCPUDispatchFeatures(
14886 std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
14887 Features.insert(Features.begin(),
14888 Target->getTargetOpts().FeaturesAsWritten.begin(),
14889 Target->getTargetOpts().FeaturesAsWritten.end());
14890 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14891 }
else if (
const auto *TC = FD->
getAttr<TargetClonesAttr>()) {
14892 if (Target->getTriple().isAArch64()) {
14896 Features.insert(Features.begin(),
14897 Target->getTargetOpts().FeaturesAsWritten.begin(),
14898 Target->getTargetOpts().FeaturesAsWritten.end());
14899 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14900 }
else if (Target->getTriple().isRISCV()) {
14902 std::vector<std::string> Features;
14903 if (VersionStr !=
"default") {
14905 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14908 Features.insert(Features.begin(),
14909 Target->getTargetOpts().FeaturesAsWritten.begin(),
14910 Target->getTargetOpts().FeaturesAsWritten.end());
14911 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14913 std::vector<std::string> Features;
14915 if (VersionStr.starts_with(
"arch="))
14916 TargetCPU = VersionStr.drop_front(
sizeof(
"arch=") - 1);
14917 else if (VersionStr !=
"default")
14918 Features.push_back((StringRef{
"+"} + VersionStr).str());
14919 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14921 }
else if (
const auto *TV = FD->
getAttr<TargetVersionAttr>()) {
14922 std::vector<std::string> Features;
14923 if (Target->getTriple().isRISCV()) {
14925 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14928 assert(Target->getTriple().isAArch64());
14930 TV->getFeatures(Feats);
14933 Features.insert(Features.begin(),
14934 Target->getTargetOpts().FeaturesAsWritten.begin(),
14935 Target->getTargetOpts().FeaturesAsWritten.end());
14936 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14938 FeatureMap = Target->getTargetOpts().FeatureMap;
14949 auto DeviceDiscriminatorOverrider =
14951 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
14953 return RD->getDeviceLambdaManglingNumber();
14954 return std::nullopt;
14957 Context, Context.getDiagnostics(), DeviceDiscriminatorOverrider)};
14965 std::string Buffer;
14966 Buffer.reserve(128);
14967 llvm::raw_string_ostream Out(Buffer);
14968 MC->mangleCanonicalTypeName(KernelNameType, Out);
14969 std::string KernelName = Out.str();
14971 return {KernelNameType, FD, KernelName};
14980 const auto *SKEPAttr = FD->
getAttr<SYCLKernelEntryPointAttr>();
14981 assert(SKEPAttr &&
"Missing sycl_kernel_entry_point attribute");
14990 "SYCL kernel name conflict");
15005 return &IT->second;
15011 return *OMPTraitInfoVector.back();
15018 return DB << Section.
Decl;
15019 return DB <<
"a prior #pragma section";
15023 bool IsInternalVar =
15026 bool IsExplicitDeviceVar = (D->
hasAttr<CUDADeviceAttr>() &&
15027 !D->
getAttr<CUDADeviceAttr>()->isImplicit()) ||
15028 (D->
hasAttr<CUDAConstantAttr>() &&
15029 !D->
getAttr<CUDAConstantAttr>()->isImplicit());
15033 return (IsInternalVar &&
15034 (D->
hasAttr<HIPManagedAttr>() || IsExplicitDeviceVar)) ||
15035 (D->
hasAttr<CUDAGlobalAttr>() &&
15042 (D->
hasAttr<HIPManagedAttr>() || D->
hasAttr<CUDAGlobalAttr>() ||
15047 if (!CUIDHash.empty())
15049 if (LangOpts.CUID.empty())
15050 return StringRef();
15051 CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.CUID),
true);
15061 assert(PrimaryBase);
15064 auto Base = Layout.getPrimaryBase();
15065 if (!
Base ||
Base == PrimaryBase || !
Base->isPolymorphic())
15067 PrimaryBase =
Base;
15069 return PrimaryBase;
15073 StringRef MangledName) {
15075 assert(
Method->isVirtual());
15076 bool DefaultIncludesPointerAuth =
15077 LangOpts.PointerAuthCalls || LangOpts.PointerAuthIntrinsics;
15079 if (!DefaultIncludesPointerAuth)
15082 auto Existing = ThunksToBeAbbreviated.find(VirtualMethodDecl);
15083 if (Existing != ThunksToBeAbbreviated.end())
15084 return Existing->second.contains(MangledName.str());
15087 llvm::StringMap<llvm::SmallVector<std::string, 2>> Thunks;
15089 if (
const auto *ThunkInfos = VtableContext->getThunkInfo(VirtualMethodDecl)) {
15091 for (
const auto &Thunk : *ThunkInfos) {
15093 llvm::raw_svector_ostream ElidedNameStream(ElidedName);
15099 Mangler->mangleThunk(
Method, Thunk,
true,
15102 llvm::raw_svector_ostream mangledNameStream(MangledName);
15106 mangledNameStream);
15108 Mangler->mangleThunk(
Method, Thunk,
false,
15109 mangledNameStream);
15111 Thunks[ElidedName].push_back(std::string(MangledName));
15114 llvm::StringSet<> SimplifiedThunkNames;
15115 for (
auto &ThunkList : Thunks) {
15116 llvm::sort(ThunkList.second);
15117 SimplifiedThunkNames.insert(ThunkList.second[0]);
15119 bool Result = SimplifiedThunkNames.contains(MangledName);
15120 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 getCanonicalTemplateArguments(const ASTContext &C, ArrayRef< TemplateArgument > Args, bool &AnyNonCanonArgs)
static char getObjCEncodingForPrimitiveType(const ASTContext *C, const BuiltinType *BT)
static bool isSameQualifier(const NestedNameSpecifier X, const NestedNameSpecifier Y)
static bool unionHasUniqueObjectRepresentations(const ASTContext &Context, const RecordDecl *RD, bool CheckIfTriviallyCopyable)
static TypedefDecl * CreateHexagonBuiltinVaListDecl(const ASTContext *Context)
#define CANONICAL_TYPE(Class)
static ElaboratedTypeKeyword getCommonTypeKeyword(const T *X, const T *Y, bool IsSame)
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 QualType getCommonArrayElementType(const ASTContext &Ctx, const T *X, Qualifiers &QX, const T *Y, Qualifiers &QY)
#define SUGAR_FREE_TYPE(Class)
static SYCLKernelInfo BuildSYCLKernelInfo(ASTContext &Context, CanQualType KernelNameType, const FunctionDecl *FD)
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 bool hasSameCudaAttrs(const FunctionDecl *A, const FunctionDecl *B)
static TemplateName getCommonTemplateName(const ASTContext &Ctx, TemplateName X, TemplateName Y, bool IgnoreDeduced=false)
static int CmpProtocolNames(ObjCProtocolDecl *const *LHS, ObjCProtocolDecl *const *RHS)
CmpProtocolNames - Comparison predicate for sorting protocols alphabetically.
static auto * getCommonSizeExpr(const ASTContext &Ctx, T *X, T *Y)
static TypedefDecl * CreatePowerABIBuiltinVaListDecl(const ASTContext *Context)
static auto getCommonSizeModifier(const ArrayType *X, const ArrayType *Y)
static TemplateArgument getCommonTemplateArgument(const ASTContext &Ctx, const TemplateArgument &X, const TemplateArgument &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 NestedNameSpecifier getCommonNNS(const ASTContext &Ctx, NestedNameSpecifier NNS1, NestedNameSpecifier NNS2, bool IsSame)
Returns a NestedNameSpecifier which has only the common sugar present in both NNS1 and NNS2.
static TypedefDecl * CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context)
static int64_t getSubobjectOffset(const FieldDecl *Field, const ASTContext &Context, const clang::ASTRecordLayout &)
static QualType getCommonSugarTypeNode(const ASTContext &Ctx, const Type *X, const Type *Y, SplitQualType Underlying)
static TypedefDecl * CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context)
static QualType getCommonNonSugarTypeNode(const ASTContext &Ctx, const Type *X, Qualifiers &QX, const Type *Y, Qualifiers &QY)
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 ElaboratedTypeKeyword getCanonicalElaboratedTypeKeyword(ElaboratedTypeKeyword Keyword)
static QualType getCommonPointeeType(const ASTContext &Ctx, const T *X, const T *Y)
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 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 bool getCommonTemplateArguments(const ASTContext &Ctx, SmallVectorImpl< TemplateArgument > &R, ArrayRef< TemplateArgument > Xs, ArrayRef< TemplateArgument > Ys)
static TypedefDecl * CreateXtensaABIBuiltinVaListDecl(const ASTContext *Context)
static QualType getCommonElementType(const ASTContext &Ctx, const T *X, const T *Y)
static void mergeTypeLists(const ASTContext &Ctx, SmallVectorImpl< QualType > &Out, ArrayRef< QualType > X, ArrayRef< QualType > 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 uint64_t getRVVTypeSize(ASTContext &Context, const BuiltinType *Ty)
getRVVTypeSize - Return RVV vector register size.
static auto unwrapSugar(SplitQualType &T, Qualifiers &QTotal)
static TemplateName getCommonTemplateNameChecked(const ASTContext &Ctx, TemplateName X, TemplateName Y, bool IgnoreDeduced)
static int compareObjCProtocolsByName(ObjCProtocolDecl *const *lhs, ObjCProtocolDecl *const *rhs)
Comparison routine for Objective-C protocols to be used with llvm::array_pod_sort.
static std::string charUnitsToString(const CharUnits &CU)
static const TagDecl * getNonInjectedClassName(const TagDecl *TD)
static bool hasAnyPackExpansions(ArrayRef< TemplateArgument > Args)
static char ObjCEncodingForEnumDecl(const ASTContext *C, const EnumDecl *ED)
static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, SmallVectorImpl< const NamedDecl * > &Redeclared)
static SmallVector< SourceLocation, 2 > getDeclLocsForCommentSearch(const Decl *D, SourceManager &SourceMgr)
static auto getCommonTypes(const ASTContext &Ctx, ArrayRef< QualType > Xs, ArrayRef< QualType > Ys, bool Unqualified=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)
static NestedNameSpecifier getCommonQualifier(const ASTContext &Ctx, const T *X, const T *Y, bool IsSame)
#define UNEXPECTED_TYPE(Class, Kind)
static TypedefDecl * CreateVaListDecl(const ASTContext *Context, TargetInfo::BuiltinVaListKind Kind)
static bool primaryBaseHaseAddressDiscriminatedVTableAuthentication(const ASTContext &Context, const CXXRecordDecl *Class)
static std::vector< std::string > getFMVBackendFeaturesFor(const llvm::SmallVectorImpl< StringRef > &FMVFeatStrings)
Defines the clang::ASTContext interface.
#define BuiltinTemplate(BTName)
Provides definitions for the various language-specific address spaces.
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
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::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.
C Language Family Type Representation.
__device__ __2f16 float c
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
@ GE_Missing_stdio
Missing a type from <stdio.h>
@ GE_Missing_ucontext
Missing a type from <ucontext.h>
@ GE_Missing_setjmp
Missing a type from <setjmp.h>
RawComment * getRawCommentForDeclNoCacheImpl(const Decl *D, const SourceLocation RepresentativeLocForDecl, const std::map< unsigned, RawComment * > &CommentsInFile) const
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.
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.
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.
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
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 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.
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 isTypeAwareOperatorNewOrDelete(const FunctionDecl *FD) const
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 getCanonicalTemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T, ArrayRef< TemplateArgument > CanonicalArgs) const
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.
static CanQualType getCanonicalType(QualType T)
Return the canonical (structural) type corresponding to the specified potentially non-canonical 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
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.
std::unique_ptr< MangleNumberingContext > createMangleNumberingContext() const
QualType getUnsignedPointerDiffType() const
Return the unique unsigned counterpart of "ptrdiff_t" integer type.
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 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.
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 getSubstBuiltinTemplatePack(const TemplateArgument &ArgPack)
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
IntrusiveRefCntPtr< ExternalASTSource > ExternalSource
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,...
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 propertyTypesAreCompatible(QualType, QualType)
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
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.
TemplateName getDependentTemplateName(const DependentTemplateStorage &Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template operat...
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...
void setRelocationInfoForCXXRecord(const CXXRecordDecl *, CXXRecordDeclRelocationInfo)
QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, bool Final) const
Retrieve a substitution-result type.
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=RecordDecl::TagKind::Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified 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...
CanQualType UnsignedLongFractTy
QualType mergeTagDefinitions(QualType, QualType)
overridden_method_range overridden_methods(const CXXMethodDecl *Method) const
void setIsTypeAwareOperatorNewOrDelete(const FunctionDecl *FD, bool IsTypeAware)
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.
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT, ObjCInterfaceDecl *IDecl)
QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in QT's qualified-id protocol list adopt...
FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage, bool AcceptDependent) const
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...
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
QualType getUsingType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UsingShadowDecl *D, QualType UnderlyingType=QualType()) const
CanQualType OMPIteratorTy
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...
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCIvarDecl *Ivar) const
Get the offset of an ObjCIvarDecl in bits.
SelectorTable & Selectors
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 alignment 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.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current context.
bool canBindObjCObjectType(QualType To, QualType From)
TemplateTemplateParmDecl * insertCanonicalTemplateTemplateParmDeclInternal(TemplateTemplateParmDecl *CanonTTP) const
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...
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier NNS, const IdentifierInfo *Name) const
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....
CanQualType getCanonicalSizeType() const
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
CanQualType ObjCBuiltinIdTy
overridden_cxx_method_iterator overridden_methods_end(const CXXMethodDecl *Method) const
VTableContextBase * getVTableContext()
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
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
PointerAuthQualifier getObjCMemberSelTypePtrAuth()
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
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const
Emit the encoded type for the function Decl into S.
TypeSourceInfo * getTemplateSpecializationTypeInfo(ElaboratedTypeKeyword Keyword, SourceLocation ElaboratedKeywordLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKeywordLoc, TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &SpecifiedArgs, ArrayRef< TemplateArgument > CanonicalArgs, QualType Canon=QualType()) const
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
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
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
TemplateTemplateParmDecl * findCanonicalTemplateTemplateParmDeclInternal(TemplateTemplateParmDecl *TTP) const
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.
friend class CXXRecordDecl
CanQualType UnsignedLongTy
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl * > &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized,...
bool computeBestEnumTypes(bool IsPacked, unsigned NumNegativeBits, unsigned NumPositiveBits, QualType &BestType, QualType &BestPromotionType)
Compute BestType and BestPromotionType for an enum based on the highest number of negative and positi...
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...
const TranslationUnitKind TUKind
CanQualType UnsignedLongAccumTy
QualType AutoRRefDeductTy
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.
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl, unsigned Index, bool Final, const TemplateArgument &ArgPack)
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.
QualType getHLSLInlineSpirvType(uint32_t Opcode, uint32_t Size, uint32_t Alignment, ArrayRef< SpirvOperand > Operands)
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
bool isInSameModule(const Module *M1, const Module *M2) const
If the two module M1 and M2 are in the same module.
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.
friend class NestedNameSpecifier
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.
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
CanQualType ObjCBuiltinBoolTy
TypeInfoChars getTypeInfoInChars(const Type *T) const
QualType getPredefinedSugarType(PredefinedSugarType::Kind KD) 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.
TemplateTemplateParmDecl * getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const
Canonicalize the given TemplateTemplateParmDecl.
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
void ResetObjCLayout(const ObjCInterfaceDecl *D)
ArrayRef< Module * > getModulesWithMergedDefinition(const NamedDecl *Def)
Get the additional modules in which the definition Def has been merged.
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
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.
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, UnsignedOrNone Index=std::nullopt) const
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
llvm::PointerUnion< VarTemplateDecl *, MemberSpecializationInfo * > TemplateOrSpecializationInfo
A type synonym for the TemplateOrInstantiation mapping.
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a non-unique reference to the type for a variable array of the specified element type.
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...
QualType getCorrespondingUnsaturatedType(QualType Ty) const
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
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.
QualType getTypeDeclType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypeDecl *Decl) const
bool isDestroyingOperatorDelete(const FunctionDecl *FD) const
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.
llvm::iterator_range< overridden_cxx_method_iterator > overridden_method_range
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.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, TemplateDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
CanQualType getCanonicalTypeDeclType(const TypeDecl *TD) const
QualType getPackExpansionType(QualType Pattern, UnsignedOrNone NumExpansions, bool ExpectPackInType=true) const
Form a pack expansion type with the given pattern.
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
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
QualType getTypedefType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType UnderlyingType=QualType(), std::optional< bool > TypeMatchesDeclOrNone=std::nullopt) const
Return the unique reference to the type for the specified typedef-name decl.
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl * > protocols) const
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.
QualType getTemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T, ArrayRef< TemplateArgument > SpecifiedArgs, ArrayRef< TemplateArgument > CanonicalArgs, QualType Underlying=QualType()) const
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
TemplateName getQualifiedTemplateName(NestedNameSpecifier Qualifier, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
bool isSameAssociatedConstraint(const AssociatedConstraint &ACX, const AssociatedConstraint &ACY) const
Determine whether two 'requires' expressions are similar enough that they may be used in re-declarati...
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.
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 isRepresentableIntegerValue(llvm::APSInt &Value, QualType T)
Determine whether the given integral value is representable within the given type T.
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.
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
QualType getMemberPointerType(QualType T, NestedNameSpecifier Qualifier, const CXXRecordDecl *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
static bool hasSameType(QualType T1, QualType T2)
Determine whether the given types T1 and T2 are equivalent.
const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
RawComment * getRawCommentForDeclNoCache(const Decl *D) const
Return the documentation comment attached to a given declaration, without looking into cache.
QualType getTagType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TagDecl *TD, bool OwnsTag) const
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
CanQualType getMSGuidType() const
Retrieve the implicitly-predeclared 'struct _GUID' type.
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...
CanQualType getCanonicalUnresolvedUsingType(const UnresolvedUsingTypenameDecl *D) const
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 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)
void deduplicateMergedDefinitionsFor(NamedDecl *ND)
Clean up the merged definition list.
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
interp::Context & getInterpContext()
Returns the clang bytecode interpreter context.
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
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.
QualType getUnresolvedUsingType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UnresolvedUsingTypenameDecl *D) const
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
QualType getDeducedTemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
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 ...
QualType getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t.
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.
CanQualType SatUnsignedLongAccumTy
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
CanQualType getCanonicalTagType(const TagDecl *TD) const
bool isSameTemplateArgument(const TemplateArgument &Arg1, const TemplateArgument &Arg2) const
Determine whether the given template arguments Arg1 and Arg2 are equivalent.
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.
unsigned getTargetAddressSpace(LangAS AS) const
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...
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
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.
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.
std::optional< CXXRecordDeclRelocationInfo > getRelocationInfoForCXXRecord(const CXXRecordDecl *) const
static bool hasSameUnqualifiedType(QualType T1, QualType T2)
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
InlineVariableDefinitionKind getInlineVariableDefinitionKind(const VarDecl *VD) const
Determine whether a definition of this inline variable should be treated as a weak or strong definiti...
TemplateName getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl, unsigned Index, UnsignedOrNone PackIndex, bool Final) const
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_type
Missing a type.
QualType adjustStringLiteralBaseType(QualType StrLTy) const
uint16_t getPointerAuthTypeDiscriminator(QualType T)
Return the "other" type-specific discriminator for the given type.
bool canonicalizeTemplateArguments(MutableArrayRef< TemplateArgument > Args) const
Canonicalize the given template argument list.
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.
const CXXRecordDecl * baseForVTableAuthentication(const CXXRecordDecl *ThisClass) const
Resolve the root record to be used to derive the vtable pointer authentication policy for the specifi...
QualType getVariableArrayDecayedType(QualType Ty) const
Returns a vla type where known sizes are replaced with [*].
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...
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false) const
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
void setIsDestroyingOperatorDelete(const FunctionDecl *FD, bool IsDestroying)
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 ~ASTMutationListener()
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 adjustment.
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,...
void Profile(llvm::FoldingSetNodeID &ID)
Attr - This represents one attribute.
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...
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.
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr)
CXXRecordDecl * getDefinition() const
bool isPolymorphic() const
Whether this class is polymorphic (C++ [class.virtual]), which means that the class contains or inher...
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)
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.
Complex values, per C99 6.2.5p11.
void Profile(llvm::FoldingSetNodeID &ID)
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.
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.
Decl::Kind getDeclKind() const
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
const DeclContext * getParentFunctionOrMethod(bool LexicalParent=false) const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext,...
bool isModuleLocal() const
Whether this declaration was a local declaration to a C++20 named module.
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,...
bool isUnconditionallyVisible() const
Determine whether this declaration is definitely visible to name lookup, independent of whether the o...
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.
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
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
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
TemplateName getUnderlying() const
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const
DefaultArguments getDefaultArguments() const
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)
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.
void Profile(llvm::FoldingSetNodeID &ID) const
IdentifierOrOverloadedOperator getName() const
NestedNameSpecifier getQualifier() const
Return the nested name specifier that qualifies this name.
bool hasTemplateKeyword() const
Was this template name was preceeded by the template keyword?
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.
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.
EnumDecl * getDefinitionOrSelf() const
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
This represents one expression.
bool isIntegerConstantExpr(const ASTContext &Ctx) const
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.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
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.
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.
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 void CompleteRedeclChain(const Decl *D)
Gives the external AST source an opportunity to complete the redeclaration chain for a declaration.
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.
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
FunctionDecl * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
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.
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
SmallVector< Conflict > Conflicts
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
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
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.
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)
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
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)
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.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
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
Represent a C++ namespace.
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested)
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
NestedNameSpecifier getCanonical() const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
CXXRecordDecl * getAsMicrosoftSuper() const
NamespaceAndPrefix getAsNamespaceAndPrefix() const
bool isCanonical() const
Whether this nested name specifier is canonical.
const Type * getAsType() const
Kind
The kind of specifier that completes this nested name specifier.
@ MicrosoftSuper
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
@ Global
The global specifier '::'. There is no stored value.
@ Type
A type, stored as a Type*.
@ Namespace
A namespace-like entity, stored as a NamespaceBaseDecl*.
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.
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 * 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
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
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.
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
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...
A structure for storing the information associated with an overloaded template name.
Represents a C++11 pack expansion that produces a sequence of expressions.
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)
Pointer-authentication qualifiers.
static PointerAuthQualifier Create(unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, PointerAuthenticationMode AuthenticationMode, bool IsIsaPointer, bool AuthenticatesNullValues)
bool isEquivalent(PointerAuthQualifier Other) const
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 hasAddressDiscriminatedPointerAuth() const
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 getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
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()
PointerAuthQualifier getPointerAuth() const
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 isLambda() const
Determine whether this record is a class describing a lambda function object.
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)
RecordDecl * getMostRecentDecl()
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.
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
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.
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, ArrayRef< SourceLocation > Locs)
This is the "fully general" constructor that allows representation of strings formed from one or more...
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 declaration of a struct/union/class/enum.
TypedefNameDecl * getTypedefNameForAnonDecl() const
void startDefinition()
Starts the definition of this tag declaration.
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
TagKind getTagKind() 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.
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...
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....
@ 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.
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
IntType getPtrDiffType(LangAS AddrSpace) const
IntType getSizeType() 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 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
IntType getSignedSizeType() const
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
bool useAddressSpaceMapMangling() const
Specify if mangling based on address space map should be used or not for language specific address sp...
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.
ArrayRef< TemplateArgumentLoc > arguments() const
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Location wrapper for a TemplateArgument.
Represents a template argument.
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
UnsignedOrNone 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.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
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.
DeducedTemplateStorage * getAsDeducedTemplateName() const
Retrieve the deduced template info, if any.
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
std::optional< TemplateName > desugar(bool IgnoreDeduced) const
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template declarations that this template name refers to,...
AssumedTemplateStorage * getAsAssumedTemplateName() const
Retrieve information on a name that has been assumed to be a template-name in order to permit a call ...
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.
UsingShadowDecl * getAsUsingShadowDecl() const
Retrieve the using shadow declaration through which the underlying template declaration is introduced...
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
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()
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TemplateNameKind templateParameterKind() const
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateNameKind ParameterKind, bool Typename, TemplateParameterList *Params)
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.
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, UnsignedOrNone NumExpanded=std::nullopt)
Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string...
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
TemplateDecl * getNamedConcept() const
ConceptReference * getConceptReference() const
Represents a declaration of a type.
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...
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.
bool isBlockPointerType() const
bool isObjCBuiltinType() const
QualType getRVVEltType(const ASTContext &Ctx) const
Returns the representative type for the element of an RVV builtin type.
bool isIncompleteArrayType() const
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6....
bool isPointerType() const
TagDecl * castAsTagDecl() const
bool isArrayParameterType() const
CanQualType getCanonicalTypeUnqualified() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific 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 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.
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 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...
QualType getCanonicalTypeInternal() const
@ PtrdiffT
The "ptrdiff_t" type.
@ SizeT
The "size_t" type.
@ SignedSizeT
The signed integer type corresponding to "size_t".
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.
EnumDecl * getAsEnumDecl() const
Retrieves the EnumDecl this type refers to.
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.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
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
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType Underlying)
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,...
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UnresolvedUsingTypenameDecl *D)
Represents a dependent using declaration which was marked with typename.
UnresolvedUsingTypenameDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this declaration.
Represents a C++ using-enum-declaration.
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UsingShadowDecl *D, QualType UnderlyingType)
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.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
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.
mlir::Type getBaseType(mlir::Value varPtr)
const AstTypeMatcher< TagType > tagType
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
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isa(CodeGen::Address addr)
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.
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
std::pair< FileID, unsigned > FileIDAndOffset
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.
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
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.
const FunctionProtoType * T
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
@ Interface
The "__interface" keyword.
@ Struct
The "struct" keyword.
@ Class
The "class" keyword.
constexpr uint16_t SelPointerConstantDiscriminator
Constant discriminator to be used with objective-c sel pointers.
bool isDiscardableGVALinkage(GVALinkage L)
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
@ Keyword
The name has been typo-corrected to a keyword.
LangAS
Defines the address space values used by the address space qualifier of QualType.
TranslationUnitKind
Describes the kind of translation unit being processed.
const Decl & adjustDeclToTemplate(const Decl &D)
If we have a 'templated' declaration for a template, adjust 'D' to refer to the actual template.
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.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ConceptReference *C)
Insertion operator for diagnostics.
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
U cast(CodeGen::Address addr)
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...
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ None
No keyword precedes the qualified type name.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
@ Class
The "class" keyword introduces the elaborated-type-specifier.
@ Union
The "union" keyword introduces the elaborated-type-specifier.
@ 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)
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
const Expr * ConstraintExpr
UnsignedOrNone ArgPackSubstIndex
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
bool requiresFunctionProtoTypeExtraAttributeInfo() const
unsigned HasTrailingReturn
bool requiresFunctionProtoTypeExtraBitfields() const
FunctionType::ExtInfo ExtInfo
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
A lazy value (of type T) that is within an AST node of type Owner, where the value might change in la...
Contains information gathered from parsing the contents of TargetAttr.
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.
llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet
Store declaration pairs already found to be non-equivalent.
bool IsEquivalent(Decl *D1, Decl *D2)
Determine whether the two declarations are structurally equivalent.
A this pointer adjustment.
IntType
===-— Target Data Type Query Methods ----------------------------—===//
AlignRequirementKind AlignRequirement
AlignRequirementKind AlignRequirement