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>())
570 else if (
const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
571 while (IC->getSuperClass()) {
572 IC = IC->getSuperClass();
577 else if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
582 else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
583 if (!(RD = RD->getDefinition()))
586 for (
const auto &I : RD->bases()) {
587 if (I.isVirtual() || (I.getAccessSpecifier() !=
AS_public))
601 for (
const auto &I : RD->vbases()) {
622 if (D != OriginalDecl && OriginalDecl)
630void ASTContext::CanonicalTemplateTemplateParm::Profile(
639 ID.AddInteger(Params->
size());
641 PEnd = Params->
end();
643 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
645 ID.AddBoolean(TTP->isParameterPack());
647 TTP->getNumExpansionParameters().toInternalRepresentation());
651 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
653 ID.AddBoolean(NTTP->isParameterPack());
654 ID.AddPointer(
C.getUnconstrainedType(
C.getCanonicalType(NTTP->getType()))
656 if (NTTP->isExpandedParameterPack()) {
658 ID.AddInteger(NTTP->getNumExpansionTypes());
659 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
661 ID.AddPointer(
T.getCanonicalType().getAsOpaquePtr());
664 ID.AddBoolean(
false);
674TemplateTemplateParmDecl *
678 llvm::FoldingSetNodeID ID;
679 CanonicalTemplateTemplateParm::Profile(ID, *
this, TTP);
680 void *InsertPos =
nullptr;
681 CanonicalTemplateTemplateParm *Canonical
682 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
684 return Canonical->getParam();
689 CanonParams.reserve(Params->
size());
691 PEnd = Params->
end();
695 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
700 TTP->getNumExpansionParameters());
701 CanonParams.push_back(NewTTP);
702 }
else if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
706 if (NTTP->isExpandedParameterPack()) {
709 for (
unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
711 ExpandedTInfos.push_back(
719 NTTP->getPosition(),
nullptr,
729 NTTP->getPosition(),
nullptr,
731 NTTP->isParameterPack(),
734 CanonParams.push_back(Param);
750 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
751 assert(!Canonical &&
"Shouldn't be in the map!");
755 Canonical =
new (*this) CanonicalTemplateTemplateParm(CanonTTP);
756 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
763 llvm::FoldingSetNodeID ID;
764 CanonicalTemplateTemplateParm::Profile(ID, *
this, TTP);
765 void *InsertPos =
nullptr;
766 CanonicalTemplateTemplateParm *Canonical =
767 CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
768 return Canonical ? Canonical->getParam() :
nullptr;
774 llvm::FoldingSetNodeID ID;
775 CanonicalTemplateTemplateParm::Profile(ID, *
this, CanonTTP);
776 void *InsertPos =
nullptr;
778 CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos))
779 return Existing->getParam();
780 CanonTemplateTemplateParms.InsertNode(
781 new (*
this) CanonicalTemplateTemplateParm(CanonTTP), InsertPos);
790 return NoSanitizeL->containsType(Mask, TyName);
799 if (!LangOpts.CPlusPlus)
return nullptr;
802 case TargetCXXABI::AppleARM64:
803 case TargetCXXABI::Fuchsia:
804 case TargetCXXABI::GenericARM:
805 case TargetCXXABI::iOS:
806 case TargetCXXABI::WatchOS:
807 case TargetCXXABI::GenericAArch64:
808 case TargetCXXABI::GenericMIPS:
809 case TargetCXXABI::GenericItanium:
810 case TargetCXXABI::WebAssembly:
811 case TargetCXXABI::XL:
813 case TargetCXXABI::Microsoft:
816 llvm_unreachable(
"Invalid CXXABI type!");
820 if (!InterpContext) {
823 return *InterpContext;
829 return *ParentMapCtx;
834 switch (LangOpts.getAddressSpaceMapMangling()) {
842 llvm_unreachable(
"getAddressSpaceMapMangling() doesn't cover anything.");
848 : ConstantArrayTypes(this_(), ConstantArrayTypesLog2InitSize),
849 DependentSizedArrayTypes(this_()), DependentSizedExtVectorTypes(this_()),
850 DependentAddressSpaceTypes(this_()), DependentVectorTypes(this_()),
851 DependentSizedMatrixTypes(this_()),
852 FunctionProtoTypes(this_(), FunctionProtoTypesLog2InitSize),
853 DependentTypeOfExprTypes(this_()), DependentDecltypeTypes(this_()),
854 DependentPackIndexingTypes(this_()), TemplateSpecializationTypes(this_()),
855 DependentBitIntTypes(this_()), SubstTemplateTemplateParmPacks(this_()),
856 DeducedTemplates(this_()), ArrayParameterTypes(this_()),
857 CanonTemplateTemplateParms(this_()), SourceMgr(
SM), LangOpts(LOpts),
860 LangOpts.XRayNeverInstrumentFiles,
861 LangOpts.XRayAttrListFiles,
SM)),
865 Comments(
SM), CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
873 ReleaseDeclContextMaps();
876 for (
auto &Pair : Deallocations)
877 (Pair.first)(Pair.second);
878 Deallocations.clear();
884 I = ObjCLayouts.begin(),
885 E = ObjCLayouts.end();
892 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
893 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
898 ASTRecordLayouts.clear();
900 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
901 AEnd = DeclAttrs.end();
903 A->second->~AttrVec();
906 for (
const auto &
Value : ModuleInitializers)
907 Value.second->~PerModuleInitializers();
908 ModuleInitializers.
clear();
917 TraversalScope = TopLevelDecls;
922 Deallocations.push_back({Callback,
Data});
931 llvm::errs() <<
"\n*** AST Context Stats:\n";
932 llvm::errs() <<
" " << Types.size() <<
" types total.\n";
934 unsigned counts[] = {
935#define TYPE(Name, Parent) 0,
936#define ABSTRACT_TYPE(Name, Parent)
937#include "clang/AST/TypeNodes.inc"
941 for (
unsigned i = 0, e = Types.size(); i != e; ++i) {
947 unsigned TotalBytes = 0;
948#define TYPE(Name, Parent) \
950 llvm::errs() << " " << counts[Idx] << " " << #Name \
951 << " types, " << sizeof(Name##Type) << " each " \
952 << "(" << counts[Idx] * sizeof(Name##Type) \
954 TotalBytes += counts[Idx] * sizeof(Name##Type); \
956#define ABSTRACT_TYPE(Name, Parent)
957#include "clang/AST/TypeNodes.inc"
959 llvm::errs() <<
"Total bytes = " << TotalBytes <<
"\n";
964 <<
" implicit default constructors created\n";
967 <<
" implicit copy constructors created\n";
971 <<
" implicit move constructors created\n";
974 <<
" implicit copy assignment operators created\n";
978 <<
" implicit move assignment operators created\n";
981 <<
" implicit destructors created\n";
984 llvm::errs() <<
"\n";
988 BumpAlloc.PrintStats();
992 bool NotifyListeners) {
996 Listener->RedefinedHiddenDefinition(ND, M);
1003 if (It == MergedDefModules.end())
1006 auto &Merged = It->second;
1007 llvm::DenseSet<Module*>
Found;
1008 for (
Module *&M : Merged)
1009 if (!
Found.insert(M).second)
1011 llvm::erase(Merged,
nullptr);
1018 if (MergedIt == MergedDefModules.end())
1020 return MergedIt->second;
1023void ASTContext::PerModuleInitializers::resolve(
ASTContext &Ctx) {
1024 if (LazyInitializers.empty())
1028 assert(Source &&
"lazy initializers but no external source");
1030 auto LazyInits = std::move(LazyInitializers);
1031 LazyInitializers.clear();
1033 for (
auto ID : LazyInits)
1034 Initializers.push_back(Source->GetExternalDecl(ID));
1036 assert(LazyInitializers.empty() &&
1037 "GetExternalDecl for lazy module initializer added more inits");
1043 if (
const auto *ID = dyn_cast<ImportDecl>(D)) {
1044 auto It = ModuleInitializers.find(ID->getImportedModule());
1047 if (It == ModuleInitializers.end())
1051 auto &Imported = *It->second;
1052 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
1053 Imported.resolve(*
this);
1054 auto *OnlyDecl = Imported.Initializers.front();
1060 auto *&Inits = ModuleInitializers[M];
1062 Inits =
new (*this) PerModuleInitializers;
1063 Inits->Initializers.push_back(D);
1068 auto *&Inits = ModuleInitializers[M];
1070 Inits =
new (*this) PerModuleInitializers;
1071 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
1072 IDs.begin(), IDs.end());
1076 auto It = ModuleInitializers.find(M);
1077 if (It == ModuleInitializers.end())
1080 auto *Inits = It->second;
1081 Inits->resolve(*
this);
1082 return Inits->Initializers;
1087 assert(!CurrentCXXNamedModule &&
1088 "We should set named module for ASTContext for only once");
1089 CurrentCXXNamedModule = M;
1101 auto GetRepresentativeModule = [
this](
const Module *M) {
1102 auto Iter = SameModuleLookupSet.find(M);
1103 if (Iter != SameModuleLookupSet.end())
1104 return Iter->second;
1106 const Module *RepresentativeModule =
1107 PrimaryModuleNameMap.try_emplace(M->getPrimaryModuleInterfaceName(), M)
1109 SameModuleLookupSet[M] = RepresentativeModule;
1110 return RepresentativeModule;
1113 assert(M1 &&
"Shouldn't call `isInSameModule` if both M1 and M2 are none.");
1114 return GetRepresentativeModule(M1) == GetRepresentativeModule(M2);
1118 if (!ExternCContext)
1121 return ExternCContext;
1135#define BuiltinTemplate(BTName) \
1136 BuiltinTemplateDecl *ASTContext::get##BTName##Decl() const { \
1137 if (!Decl##BTName) \
1139 buildBuiltinTemplateDecl(BTK##BTName, get##BTName##Name()); \
1140 return Decl##BTName; \
1142#include "clang/Basic/BuiltinTemplates.inc"
1155 NewDecl->
addAttr(TypeVisibilityAttr::CreateImplicit(
1156 const_cast<ASTContext &
>(*
this), TypeVisibilityAttr::Default));
1161 StringRef Name)
const {
1185 Types.push_back(Ty);
1190 assert((!this->Target || this->Target == &Target) &&
1191 "Incorrect target reinitialization");
1192 assert(
VoidTy.isNull() &&
"Context reinitialized?");
1194 this->Target = &Target;
1195 this->AuxTarget = AuxTarget;
1197 ABI.reset(createCXXABI(Target));
1201 InitBuiltinType(
VoidTy, BuiltinType::Void);
1204 InitBuiltinType(
BoolTy, BuiltinType::Bool);
1206 if (LangOpts.CharIsSigned)
1207 InitBuiltinType(
CharTy, BuiltinType::Char_S);
1209 InitBuiltinType(
CharTy, BuiltinType::Char_U);
1212 InitBuiltinType(
ShortTy, BuiltinType::Short);
1213 InitBuiltinType(
IntTy, BuiltinType::Int);
1214 InitBuiltinType(
LongTy, BuiltinType::Long);
1215 InitBuiltinType(
LongLongTy, BuiltinType::LongLong);
1225 InitBuiltinType(
FloatTy, BuiltinType::Float);
1226 InitBuiltinType(
DoubleTy, BuiltinType::Double);
1227 InitBuiltinType(
LongDoubleTy, BuiltinType::LongDouble);
1230 InitBuiltinType(
Float128Ty, BuiltinType::Float128);
1233 InitBuiltinType(
Ibm128Ty, BuiltinType::Ibm128);
1236 InitBuiltinType(
Float16Ty, BuiltinType::Float16);
1239 InitBuiltinType(
ShortAccumTy, BuiltinType::ShortAccum);
1240 InitBuiltinType(
AccumTy, BuiltinType::Accum);
1241 InitBuiltinType(
LongAccumTy, BuiltinType::LongAccum);
1245 InitBuiltinType(
ShortFractTy, BuiltinType::ShortFract);
1246 InitBuiltinType(
FractTy, BuiltinType::Fract);
1247 InitBuiltinType(
LongFractTy, BuiltinType::LongFract);
1252 InitBuiltinType(
SatAccumTy, BuiltinType::SatAccum);
1258 InitBuiltinType(
SatFractTy, BuiltinType::SatFract);
1265 InitBuiltinType(
Int128Ty, BuiltinType::Int128);
1270 InitBuiltinType(
WCharTy, BuiltinType::WChar_S);
1272 InitBuiltinType(
WCharTy, BuiltinType::WChar_U);
1273 if (LangOpts.CPlusPlus && LangOpts.WChar)
1277 WideCharTy = getFromTargetType(Target.getWCharType());
1280 WIntTy = getFromTargetType(Target.getWIntType());
1283 InitBuiltinType(
Char8Ty, BuiltinType::Char8);
1285 if (LangOpts.CPlusPlus)
1286 InitBuiltinType(
Char16Ty, BuiltinType::Char16);
1288 Char16Ty = getFromTargetType(Target.getChar16Type());
1290 if (LangOpts.CPlusPlus)
1291 InitBuiltinType(
Char32Ty, BuiltinType::Char32);
1293 Char32Ty = getFromTargetType(Target.getChar32Type());
1300 InitBuiltinType(
DependentTy, BuiltinType::Dependent);
1303 InitBuiltinType(
OverloadTy, BuiltinType::Overload);
1315 InitBuiltinType(
UnknownAnyTy, BuiltinType::UnknownAny);
1321 InitBuiltinType(
BuiltinFnTy, BuiltinType::BuiltinFn);
1324 if (LangOpts.OpenMP) {
1331 if (LangOpts.OpenACC && !LangOpts.OpenMP) {
1334 if (LangOpts.MatrixTypes)
1342 if (LangOpts.OpenCL) {
1343#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1344 InitBuiltinType(SingletonId, BuiltinType::Id);
1345#include "clang/Basic/OpenCLImageTypes.def"
1347 InitBuiltinType(
OCLSamplerTy, BuiltinType::OCLSampler);
1348 InitBuiltinType(
OCLEventTy, BuiltinType::OCLEvent);
1350 InitBuiltinType(
OCLQueueTy, BuiltinType::OCLQueue);
1353#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1354 InitBuiltinType(Id##Ty, BuiltinType::Id);
1355#include "clang/Basic/OpenCLExtensionTypes.def"
1358 if (LangOpts.HLSL) {
1359#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1360 InitBuiltinType(SingletonId, BuiltinType::Id);
1361#include "clang/Basic/HLSLIntangibleTypes.def"
1364 if (Target.hasAArch64ACLETypes() ||
1365 (AuxTarget && AuxTarget->hasAArch64ACLETypes())) {
1366#define SVE_TYPE(Name, Id, SingletonId) \
1367 InitBuiltinType(SingletonId, BuiltinType::Id);
1368#include "clang/Basic/AArch64ACLETypes.def"
1371 if (Target.getTriple().isPPC64()) {
1372#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \
1373 InitBuiltinType(Id##Ty, BuiltinType::Id);
1374#include "clang/Basic/PPCTypes.def"
1375#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \
1376 InitBuiltinType(Id##Ty, BuiltinType::Id);
1377#include "clang/Basic/PPCTypes.def"
1380 if (Target.hasRISCVVTypes()) {
1381#define RVV_TYPE(Name, Id, SingletonId) \
1382 InitBuiltinType(SingletonId, BuiltinType::Id);
1383#include "clang/Basic/RISCVVTypes.def"
1386 if (Target.getTriple().isWasm() && Target.hasFeature(
"reference-types")) {
1387#define WASM_TYPE(Name, Id, SingletonId) \
1388 InitBuiltinType(SingletonId, BuiltinType::Id);
1389#include "clang/Basic/WebAssemblyReferenceTypes.def"
1392 if (Target.getTriple().isAMDGPU() ||
1393 (AuxTarget && AuxTarget->getTriple().isAMDGPU())) {
1394#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1395 InitBuiltinType(SingletonId, BuiltinType::Id);
1396#include "clang/Basic/AMDGPUTypes.def"
1403 ObjCConstantStringType =
QualType();
1408 if (LangOpts.OpenCLGenericAddressSpace) {
1409 auto Q =
VoidTy.getQualifiers();
1418 InitBuiltinType(
NullPtrTy, BuiltinType::NullPtr);
1421 InitBuiltinType(
HalfTy, BuiltinType::Half);
1423 InitBuiltinType(
BFloat16Ty, BuiltinType::BFloat16);
1429 if (LangOpts.MicrosoftExt || LangOpts.Borland) {
1436 return SourceMgr.getDiagnostics();
1451 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1452 if (Pos != DeclAttrs.end()) {
1453 Pos->second->~AttrVec();
1454 DeclAttrs.erase(Pos);
1468 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1469 TemplateOrInstantiation.find(Var);
1470 if (Pos == TemplateOrInstantiation.end())
1483 Tmpl, TSK, PointOfInstantiation));
1489 assert(!TemplateOrInstantiation[Inst] &&
1490 "Already noted what the variable was instantiated from");
1491 TemplateOrInstantiation[Inst] = TSI;
1496 return InstantiatedFromUsingDecl.lookup(UUD);
1504 "pattern decl is not a using decl");
1508 "instantiation did not produce a using decl");
1509 assert(!InstantiatedFromUsingDecl[Inst] &&
"pattern already exists");
1510 InstantiatedFromUsingDecl[Inst] = Pattern;
1515 return InstantiatedFromUsingEnumDecl.lookup(UUD);
1520 assert(!InstantiatedFromUsingEnumDecl[Inst] &&
"pattern already exists");
1521 InstantiatedFromUsingEnumDecl[Inst] = Pattern;
1526 return InstantiatedFromUsingShadowDecl.lookup(Inst);
1532 assert(!InstantiatedFromUsingShadowDecl[Inst] &&
"pattern already exists");
1533 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1538 return InstantiatedFromUnnamedFieldDecl.lookup(Field);
1544 "Instantiated field decl is not unnamed");
1546 "Template field decl is not unnamed");
1547 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1548 "Already noted what unnamed field was instantiated from");
1550 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1566 return Range.end() - Range.begin();
1571 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1572 OverriddenMethods.find(
Method->getCanonicalDecl());
1573 if (Pos == OverriddenMethods.end())
1581 OverriddenMethods[
Method].push_back(Overridden);
1589 if (
const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1595 const auto *
Method = dyn_cast<ObjCMethodDecl>(D);
1600 Method->getOverriddenMethods(OverDecls);
1601 Overridden.append(OverDecls.begin(), OverDecls.end());
1604std::optional<ASTContext::CXXRecordDeclRelocationInfo>
1608 auto it = RelocatableClasses.find(D);
1609 if (it != RelocatableClasses.end())
1610 return it->getSecond();
1611 return std::nullopt;
1618 assert(RelocatableClasses.find(D) == RelocatableClasses.end());
1619 RelocatableClasses.insert({D, Info});
1624 if (!Class->isPolymorphic())
1626 const CXXRecordDecl *BaseType = Context.baseForVTableAuthentication(Class);
1627 using AuthAttr = VTablePointerAuthenticationAttr;
1628 const AuthAttr *ExplicitAuth = BaseType->
getAttr<AuthAttr>();
1630 return Context.getLangOpts().PointerAuthVTPtrAddressDiscrimination;
1631 AuthAttr::AddressDiscriminationMode AddressDiscrimination =
1632 ExplicitAuth->getAddressDiscrimination();
1633 if (AddressDiscrimination == AuthAttr::DefaultAddressDiscrimination)
1634 return Context.getLangOpts().PointerAuthVTPtrAddressDiscrimination;
1635 return AddressDiscrimination == AuthAttr::AddressDiscrimination;
1638ASTContext::PointerAuthContent
1639ASTContext::findPointerAuthContent(QualType
T)
const {
1640 assert(isPointerAuthenticationAvailable());
1642 T =
T.getCanonicalType();
1644 return PointerAuthContent::None;
1646 if (
T.hasAddressDiscriminatedPointerAuth())
1647 return PointerAuthContent::AddressDiscriminatedData;
1650 return PointerAuthContent::None;
1652 if (
auto Existing = RecordContainsAddressDiscriminatedPointerAuth.find(RD);
1653 Existing != RecordContainsAddressDiscriminatedPointerAuth.end())
1654 return Existing->second;
1656 PointerAuthContent
Result = PointerAuthContent::None;
1658 auto SaveResultAndReturn = [&]() -> PointerAuthContent {
1659 auto [ResultIter, DidAdd] =
1660 RecordContainsAddressDiscriminatedPointerAuth.try_emplace(RD,
Result);
1666 auto ShouldContinueAfterUpdate = [&](PointerAuthContent NewResult) {
1667 static_assert(PointerAuthContent::None <
1668 PointerAuthContent::AddressDiscriminatedVTable);
1669 static_assert(PointerAuthContent::AddressDiscriminatedVTable <
1670 PointerAuthContent::AddressDiscriminatedData);
1673 return Result != PointerAuthContent::AddressDiscriminatedData;
1675 if (
const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
1677 !ShouldContinueAfterUpdate(
1678 PointerAuthContent::AddressDiscriminatedVTable))
1679 return SaveResultAndReturn();
1680 for (
auto Base : CXXRD->bases()) {
1681 if (!ShouldContinueAfterUpdate(findPointerAuthContent(
Base.getType())))
1682 return SaveResultAndReturn();
1685 for (
auto *FieldDecl : RD->
fields()) {
1686 if (!ShouldContinueAfterUpdate(
1687 findPointerAuthContent(FieldDecl->getType())))
1688 return SaveResultAndReturn();
1690 return SaveResultAndReturn();
1694 assert(!Import->getNextLocalImport() &&
1695 "Import declaration already in the chain");
1696 assert(!Import->isFromASTFile() &&
"Non-local import declaration");
1697 if (!FirstLocalImport) {
1698 FirstLocalImport = Import;
1699 LastLocalImport = Import;
1703 LastLocalImport->setNextLocalImport(Import);
1704 LastLocalImport = Import;
1716 llvm_unreachable(
"Not a floating point type!");
1717 case BuiltinType::BFloat16:
1718 return Target->getBFloat16Format();
1719 case BuiltinType::Float16:
1720 return Target->getHalfFormat();
1721 case BuiltinType::Half:
1722 return Target->getHalfFormat();
1723 case BuiltinType::Float:
return Target->getFloatFormat();
1724 case BuiltinType::Double:
return Target->getDoubleFormat();
1725 case BuiltinType::Ibm128:
1726 return Target->getIbm128Format();
1727 case BuiltinType::LongDouble:
1729 return AuxTarget->getLongDoubleFormat();
1730 return Target->getLongDoubleFormat();
1731 case BuiltinType::Float128:
1733 return AuxTarget->getFloat128Format();
1734 return Target->getFloat128Format();
1739 unsigned Align = Target->getCharWidth();
1743 Align = AlignFromAttr;
1751 bool UseAlignAttrOnly;
1752 if (
const FieldDecl *FD = dyn_cast<FieldDecl>(D))
1754 FD->hasAttr<PackedAttr>() || FD->getParent()->hasAttr<PackedAttr>();
1756 UseAlignAttrOnly = AlignFromAttr != 0;
1759 if (UseAlignAttrOnly) {
1761 }
else if (
const auto *VD = dyn_cast<ValueDecl>(D)) {
1765 T = RT->getPointeeType();
1770 if (
T->isFunctionType())
1771 Align = getTypeInfoImpl(
T.getTypePtr()).Align;
1776 unsigned MinWidth = Target->getLargeArrayMinWidth();
1777 if (!ForAlignof && MinWidth) {
1779 Align = std::max(Align, Target->getLargeArrayAlign());
1782 Align = std::max(Align, Target->getLargeArrayAlign());
1787 Align = Target->getCharWidth();
1791 if (
const auto *VD = dyn_cast<VarDecl>(D))
1792 if (VD->hasGlobalStorage() && !ForAlignof) {
1803 if (
const auto *Field = dyn_cast<FieldDecl>(VD)) {
1817 uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1818 if (LowBitOfOffset < FieldAlign)
1819 FieldAlign =
static_cast<unsigned>(LowBitOfOffset);
1822 Align = std::min(Align, FieldAlign);
1830 const auto *VD = dyn_cast<VarDecl>(D);
1831 if (MaxAlignedAttr && VD && VD->getStorageClass() ==
SC_Static)
1832 Align = std::min(Align, MaxAlignedAttr);
1852 if (
const auto *RD =
T->getAsCXXRecordDecl(); RD && !RD->
isInvalidDecl()) {
1869 (uint64_t)(-1)/Size) &&
1870 "Overflow in array type char size evaluation");
1873 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1875 Width = llvm::alignTo(Width, Align);
1882 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
1900 switch (BT->getKind()) {
1901 case BuiltinType::Bool:
1902 case BuiltinType::Char_S:
1903 case BuiltinType::Char_U:
1904 case BuiltinType::SChar:
1905 case BuiltinType::UChar:
1906 case BuiltinType::Short:
1907 case BuiltinType::UShort:
1908 case BuiltinType::WChar_S:
1909 case BuiltinType::WChar_U:
1910 case BuiltinType::Char8:
1911 case BuiltinType::Char16:
1912 case BuiltinType::Char32:
1920 if (
const auto *ED =
T->getAsEnumDecl()) {
1921 if (
T->isDependentType() || ED->getPromotionType().isNull() ||
1940 bool NeedsPreferredAlignment)
const {
1943 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1948 if (!
T->isIncompleteType())
1954 if (
unsigned Align = TT->getDecl()->getMaxAlignment())
1958 if (
const auto *TD =
T->getAsTagDecl())
1959 return TD->getMaxAlignment();
1965 TypeInfoMap::iterator I = MemoizedTypeInfo.find(
T);
1966 if (I != MemoizedTypeInfo.end())
1971 MemoizedTypeInfo[
T] = TI;
1986 switch (
T->getTypeClass()) {
1987#define TYPE(Class, Base)
1988#define ABSTRACT_TYPE(Class, Base)
1989#define NON_CANONICAL_TYPE(Class, Base)
1990#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1991#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1993 assert(!T->isDependentType() && "should not see dependent types here"); \
1994 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1995#include "clang/AST/TypeNodes.inc"
1996 llvm_unreachable(
"Should not see dependent types");
1998 case Type::FunctionNoProto:
1999 case Type::FunctionProto:
2005 case Type::IncompleteArray:
2006 case Type::VariableArray:
2007 case Type::ConstantArray:
2008 case Type::ArrayParameter: {
2011 if (
const auto *CAT = dyn_cast<ConstantArrayType>(
T))
2012 Size = CAT->getZExtSize();
2015 assert((Size == 0 || EltInfo.
Width <= (uint64_t)(-1) / Size) &&
2016 "Overflow in array type bit size evaluation");
2017 Width = EltInfo.
Width * Size;
2018 Align = EltInfo.
Align;
2022 Width = llvm::alignTo(Width, Align);
2026 case Type::ExtVector:
2027 case Type::Vector: {
2030 Width = VT->isPackedVectorBoolType(*
this)
2031 ? VT->getNumElements()
2032 : EltInfo.
Width * VT->getNumElements();
2034 Width = std::max<unsigned>(8, Width);
2035 Align = std::max<unsigned>(8, Width);
2039 if (Align & (Align-1)) {
2040 Align = llvm::bit_ceil(Align);
2041 Width = llvm::alignTo(Width, Align);
2044 uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
2045 if (TargetVectorAlign && TargetVectorAlign < Align)
2046 Align = TargetVectorAlign;
2060 Align = std::min<unsigned>(64, Width);
2064 case Type::ConstantMatrix: {
2066 TypeInfo ElementInfo =
getTypeInfo(MT->getElementType());
2070 Width = ElementInfo.
Width * MT->getNumRows() * MT->getNumColumns();
2071 Align = ElementInfo.
Align;
2077 default: llvm_unreachable(
"Unknown builtin type!");
2078 case BuiltinType::Void:
2083 case BuiltinType::Bool:
2084 Width = Target->getBoolWidth();
2085 Align = Target->getBoolAlign();
2087 case BuiltinType::Char_S:
2088 case BuiltinType::Char_U:
2089 case BuiltinType::UChar:
2090 case BuiltinType::SChar:
2091 case BuiltinType::Char8:
2092 Width = Target->getCharWidth();
2093 Align = Target->getCharAlign();
2095 case BuiltinType::WChar_S:
2096 case BuiltinType::WChar_U:
2097 Width = Target->getWCharWidth();
2098 Align = Target->getWCharAlign();
2100 case BuiltinType::Char16:
2101 Width = Target->getChar16Width();
2102 Align = Target->getChar16Align();
2104 case BuiltinType::Char32:
2105 Width = Target->getChar32Width();
2106 Align = Target->getChar32Align();
2108 case BuiltinType::UShort:
2109 case BuiltinType::Short:
2110 Width = Target->getShortWidth();
2111 Align = Target->getShortAlign();
2113 case BuiltinType::UInt:
2114 case BuiltinType::Int:
2115 Width = Target->getIntWidth();
2116 Align = Target->getIntAlign();
2118 case BuiltinType::ULong:
2119 case BuiltinType::Long:
2120 Width = Target->getLongWidth();
2121 Align = Target->getLongAlign();
2123 case BuiltinType::ULongLong:
2124 case BuiltinType::LongLong:
2125 Width = Target->getLongLongWidth();
2126 Align = Target->getLongLongAlign();
2128 case BuiltinType::Int128:
2129 case BuiltinType::UInt128:
2131 Align = Target->getInt128Align();
2133 case BuiltinType::ShortAccum:
2134 case BuiltinType::UShortAccum:
2135 case BuiltinType::SatShortAccum:
2136 case BuiltinType::SatUShortAccum:
2137 Width = Target->getShortAccumWidth();
2138 Align = Target->getShortAccumAlign();
2140 case BuiltinType::Accum:
2141 case BuiltinType::UAccum:
2142 case BuiltinType::SatAccum:
2143 case BuiltinType::SatUAccum:
2144 Width = Target->getAccumWidth();
2145 Align = Target->getAccumAlign();
2147 case BuiltinType::LongAccum:
2148 case BuiltinType::ULongAccum:
2149 case BuiltinType::SatLongAccum:
2150 case BuiltinType::SatULongAccum:
2151 Width = Target->getLongAccumWidth();
2152 Align = Target->getLongAccumAlign();
2154 case BuiltinType::ShortFract:
2155 case BuiltinType::UShortFract:
2156 case BuiltinType::SatShortFract:
2157 case BuiltinType::SatUShortFract:
2158 Width = Target->getShortFractWidth();
2159 Align = Target->getShortFractAlign();
2161 case BuiltinType::Fract:
2162 case BuiltinType::UFract:
2163 case BuiltinType::SatFract:
2164 case BuiltinType::SatUFract:
2165 Width = Target->getFractWidth();
2166 Align = Target->getFractAlign();
2168 case BuiltinType::LongFract:
2169 case BuiltinType::ULongFract:
2170 case BuiltinType::SatLongFract:
2171 case BuiltinType::SatULongFract:
2172 Width = Target->getLongFractWidth();
2173 Align = Target->getLongFractAlign();
2175 case BuiltinType::BFloat16:
2176 if (Target->hasBFloat16Type()) {
2177 Width = Target->getBFloat16Width();
2178 Align = Target->getBFloat16Align();
2182 AuxTarget->hasBFloat16Type()) {
2183 Width = AuxTarget->getBFloat16Width();
2184 Align = AuxTarget->getBFloat16Align();
2187 case BuiltinType::Float16:
2188 case BuiltinType::Half:
2189 if (Target->hasFloat16Type() || !
getLangOpts().OpenMP ||
2191 Width = Target->getHalfWidth();
2192 Align = Target->getHalfAlign();
2195 "Expected OpenMP device compilation.");
2196 Width = AuxTarget->getHalfWidth();
2197 Align = AuxTarget->getHalfAlign();
2200 case BuiltinType::Float:
2201 Width = Target->getFloatWidth();
2202 Align = Target->getFloatAlign();
2204 case BuiltinType::Double:
2205 Width = Target->getDoubleWidth();
2206 Align = Target->getDoubleAlign();
2208 case BuiltinType::Ibm128:
2209 Width = Target->getIbm128Width();
2210 Align = Target->getIbm128Align();
2212 case BuiltinType::LongDouble:
2214 (Target->getLongDoubleWidth() != AuxTarget->getLongDoubleWidth() ||
2215 Target->getLongDoubleAlign() != AuxTarget->getLongDoubleAlign())) {
2216 Width = AuxTarget->getLongDoubleWidth();
2217 Align = AuxTarget->getLongDoubleAlign();
2219 Width = Target->getLongDoubleWidth();
2220 Align = Target->getLongDoubleAlign();
2223 case BuiltinType::Float128:
2224 if (Target->hasFloat128Type() || !
getLangOpts().OpenMP ||
2226 Width = Target->getFloat128Width();
2227 Align = Target->getFloat128Align();
2230 "Expected OpenMP device compilation.");
2231 Width = AuxTarget->getFloat128Width();
2232 Align = AuxTarget->getFloat128Align();
2235 case BuiltinType::NullPtr:
2240 case BuiltinType::ObjCId:
2241 case BuiltinType::ObjCClass:
2242 case BuiltinType::ObjCSel:
2246 case BuiltinType::OCLSampler:
2247 case BuiltinType::OCLEvent:
2248 case BuiltinType::OCLClkEvent:
2249 case BuiltinType::OCLQueue:
2250 case BuiltinType::OCLReserveID:
2251#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2252 case BuiltinType::Id:
2253#include "clang/Basic/OpenCLImageTypes.def"
2254#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2255 case BuiltinType::Id:
2256#include "clang/Basic/OpenCLExtensionTypes.def"
2258 Width = Target->getPointerWidth(AS);
2259 Align = Target->getPointerAlign(AS);
2269#define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId) \
2270 case BuiltinType::Id: \
2274#define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId) \
2275 case BuiltinType::Id: \
2279#define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId) \
2280 case BuiltinType::Id: \
2284#define SVE_SCALAR_TYPE(Name, MangledName, Id, SingletonId, Bits) \
2285 case BuiltinType::Id: \
2289#include "clang/Basic/AArch64ACLETypes.def"
2290#define PPC_VECTOR_TYPE(Name, Id, Size) \
2291 case BuiltinType::Id: \
2295#include "clang/Basic/PPCTypes.def"
2296#define RVV_VECTOR_TYPE(Name, Id, SingletonId, ElKind, ElBits, NF, IsSigned, \
2298 case BuiltinType::Id: \
2302#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, ElKind) \
2303 case BuiltinType::Id: \
2307#include "clang/Basic/RISCVVTypes.def"
2308#define WASM_TYPE(Name, Id, SingletonId) \
2309 case BuiltinType::Id: \
2313#include "clang/Basic/WebAssemblyReferenceTypes.def"
2314#define AMDGPU_TYPE(NAME, ID, SINGLETONID, WIDTH, ALIGN) \
2315 case BuiltinType::ID: \
2319#include "clang/Basic/AMDGPUTypes.def"
2320#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
2321#include "clang/Basic/HLSLIntangibleTypes.def"
2327 case Type::ObjCObjectPointer:
2331 case Type::BlockPointer:
2333 Width = Target->getPointerWidth(AS);
2334 Align = Target->getPointerAlign(AS);
2336 case Type::LValueReference:
2337 case Type::RValueReference:
2341 Width = Target->getPointerWidth(AS);
2342 Align = Target->getPointerAlign(AS);
2346 Width = Target->getPointerWidth(AS);
2347 Align = Target->getPointerAlign(AS);
2349 case Type::MemberPointer: {
2351 CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
2356 case Type::Complex: {
2360 Width = EltInfo.
Width * 2;
2361 Align = EltInfo.
Align;
2364 case Type::ObjCObject:
2366 case Type::Adjusted:
2369 case Type::ObjCInterface: {
2371 if (ObjCI->getDecl()->isInvalidDecl()) {
2381 case Type::BitInt: {
2383 Align = Target->getBitIntAlign(EIT->getNumBits());
2384 Width = Target->getBitIntWidth(EIT->getNumBits());
2390 const TagDecl *TD = TT->getOriginalDecl()->getDefinitionOrSelf();
2403 Info.
Align = AttrAlign;
2413 AlignRequirement = RD->
hasAttr<AlignedAttr>()
2419 case Type::SubstTemplateTypeParm:
2421 getReplacementType().getTypePtr());
2424 case Type::DeducedTemplateSpecialization: {
2426 assert(!A->getDeducedType().isNull() &&
2427 "cannot request the size of an undeduced or dependent auto type");
2428 return getTypeInfo(A->getDeducedType().getTypePtr());
2434 case Type::MacroQualified:
2438 case Type::ObjCTypeParam:
2444 case Type::Typedef: {
2446 TypeInfo Info =
getTypeInfo(TT->desugar().getTypePtr());
2450 if (
unsigned AttrAlign = TT->getDecl()->getMaxAlignment()) {
2461 case Type::Attributed:
2465 case Type::CountAttributed:
2468 case Type::BTFTagAttributed:
2472 case Type::HLSLAttributedResource:
2476 case Type::HLSLInlineSpirv: {
2479 Width = ST->getSize() * 8;
2480 Align = ST->getAlignment();
2481 if (Width == 0 && Align == 0) {
2489 case Type::Atomic: {
2498 Width = Target->getCharWidth();
2500 }
else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2506 Width = llvm::bit_ceil(Width);
2509 Align =
static_cast<unsigned>(Width);
2514 case Type::PredefinedSugar:
2523 assert(llvm::isPowerOf2_32(Align) &&
"Alignment must be power of 2");
2524 return TypeInfo(Width, Align, AlignRequirement);
2528 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(
T);
2529 if (I != MemoizedUnadjustedAlign.end())
2532 unsigned UnadjustedAlign;
2533 if (
const auto *RT =
T->getAsCanonical<RecordType>()) {
2540 UnadjustedAlign =
getTypeAlign(
T->getUnqualifiedDesugaredType());
2543 MemoizedUnadjustedAlign[
T] = UnadjustedAlign;
2544 return UnadjustedAlign;
2548 unsigned SimdAlign = llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(
2598 unsigned ABIAlign = TI.
Align;
2600 T =
T->getBaseElementTypeUnsafe();
2603 if (
T->isMemberPointerType())
2606 if (!Target->allowsLargerPreferedTypeAlignment())
2609 if (
const auto *RD =
T->getAsRecordDecl()) {
2618 unsigned PreferredAlign =
static_cast<unsigned>(
2620 assert(PreferredAlign >= ABIAlign &&
2621 "PreferredAlign should be at least as large as ABIAlign.");
2622 return PreferredAlign;
2629 T = CT->getElementType().getTypePtr();
2630 if (
const auto *ED =
T->getAsEnumDecl())
2631 T = ED->getIntegerType().getTypePtr();
2632 if (
T->isSpecificBuiltinType(BuiltinType::Double) ||
2633 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2634 T->isSpecificBuiltinType(BuiltinType::ULongLong) ||
2635 (
T->isSpecificBuiltinType(BuiltinType::LongDouble) &&
2636 Target->defaultsToAIXPowerAlignment()))
2691 for (
unsigned I = 0, N = Path.size(); I != N; ++I) {
2695 std::swap(
Base, Derived);
2715 llvm::append_range(Ivars, OI->
ivars());
2718 for (
const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2720 Ivars.push_back(Iv);
2728 if (
const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2731 for (
auto *Proto : OI->all_referenced_protocols()) {
2736 for (
const auto *Cat : OI->visible_categories())
2742 SD = SD->getSuperClass();
2744 }
else if (
const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2745 for (
auto *Proto : OC->protocols()) {
2748 }
else if (
const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2750 if (!Protocols.insert(
2754 for (
auto *Proto : OP->protocols())
2761 bool CheckIfTriviallyCopyable) {
2762 assert(RD->
isUnion() &&
"Must be union type");
2764 Context.getTypeSizeInChars(Context.getCanonicalTagType(RD));
2766 for (
const auto *Field : RD->
fields()) {
2767 if (!Context.hasUniqueObjectRepresentations(Field->getType(),
2768 CheckIfTriviallyCopyable))
2770 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2771 if (FieldSize != UnionSize)
2780 return Context.getFieldOffset(Field);
2789static std::optional<int64_t>
2791 const RecordDecl *RD,
2792 bool CheckIfTriviallyCopyable);
2794static std::optional<int64_t>
2796 bool CheckIfTriviallyCopyable) {
2797 if (
const auto *RD = Field->getType()->getAsRecordDecl();
2800 CheckIfTriviallyCopyable);
2804 bool IsBitIntType = Field->getType()->isBitIntType();
2805 if (!Field->getType()->isReferenceType() && !IsBitIntType &&
2806 !Context.hasUniqueObjectRepresentations(Field->getType(),
2807 CheckIfTriviallyCopyable))
2808 return std::nullopt;
2810 int64_t FieldSizeInBits =
2811 Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2812 if (Field->isBitField()) {
2815 if (Field->isUnnamedBitField())
2818 int64_t BitfieldSize = Field->getBitWidthValue();
2820 if ((
unsigned)BitfieldSize >
2822 return std::nullopt;
2823 }
else if (BitfieldSize > FieldSizeInBits) {
2824 return std::nullopt;
2826 FieldSizeInBits = BitfieldSize;
2827 }
else if (IsBitIntType && !Context.hasUniqueObjectRepresentations(
2828 Field->getType(), CheckIfTriviallyCopyable)) {
2829 return std::nullopt;
2831 return FieldSizeInBits;
2834static std::optional<int64_t>
2836 bool CheckIfTriviallyCopyable) {
2838 CheckIfTriviallyCopyable);
2841template <
typename RangeT>
2843 const RangeT &Subobjects, int64_t CurOffsetInBits,
2845 bool CheckIfTriviallyCopyable) {
2846 for (
const auto *Subobject : Subobjects) {
2847 std::optional<int64_t> SizeInBits =
2850 return std::nullopt;
2851 if (*SizeInBits != 0) {
2853 if (Offset != CurOffsetInBits)
2854 return std::nullopt;
2855 CurOffsetInBits += *SizeInBits;
2858 return CurOffsetInBits;
2861static std::optional<int64_t>
2864 bool CheckIfTriviallyCopyable) {
2865 assert(!RD->
isUnion() &&
"Must be struct/class type");
2866 const auto &Layout = Context.getASTRecordLayout(RD);
2868 int64_t CurOffsetInBits = 0;
2869 if (
const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2870 if (ClassDecl->isDynamicClass())
2871 return std::nullopt;
2874 for (
const auto &
Base : ClassDecl->bases()) {
2877 Bases.emplace_back(
Base.getType()->getAsCXXRecordDecl());
2881 return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
2884 std::optional<int64_t> OffsetAfterBases =
2886 Bases, CurOffsetInBits, Context, Layout, CheckIfTriviallyCopyable);
2887 if (!OffsetAfterBases)
2888 return std::nullopt;
2889 CurOffsetInBits = *OffsetAfterBases;
2892 std::optional<int64_t> OffsetAfterFields =
2894 RD->
fields(), CurOffsetInBits, Context, Layout,
2895 CheckIfTriviallyCopyable);
2896 if (!OffsetAfterFields)
2897 return std::nullopt;
2898 CurOffsetInBits = *OffsetAfterFields;
2900 return CurOffsetInBits;
2904 QualType Ty,
bool CheckIfTriviallyCopyable)
const {
2921 assert(!Ty.
isNull() &&
"Null QualType sent to unique object rep check");
2926 CheckIfTriviallyCopyable);
2929 "hasUniqueObjectRepresentations should not be called with an "
2953 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2956 if (
Record->isInvalidDecl())
2961 CheckIfTriviallyCopyable);
2964 *
this,
Record, CheckIfTriviallyCopyable);
2966 return StructSize && *StructSize ==
static_cast<int64_t
>(
getTypeSize(Ty));
2987 count += Ext->ivar_size();
2992 count += ImplDecl->ivar_size();
3018 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
3019 I = ObjCImpls.find(D);
3020 if (I != ObjCImpls.end())
3028 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
3029 I = ObjCImpls.find(D);
3030 if (I != ObjCImpls.end())
3038 assert(IFaceD && ImplD &&
"Passed null params");
3039 ObjCImpls[IFaceD] = ImplD;
3045 assert(CatD && ImplD &&
"Passed null params");
3046 ObjCImpls[CatD] = ImplD;
3051 return ObjCMethodRedecls.
lookup(MD);
3057 ObjCMethodRedecls[MD] = Redecl;
3062 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->
getDeclContext()))
3064 if (
const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->
getDeclContext()))
3065 return CD->getClassInterface();
3066 if (
const auto *IMD = dyn_cast<ObjCImplDecl>(ND->
getDeclContext()))
3067 return IMD->getClassInterface();
3075 assert(VD &&
"Passed null params");
3076 assert(VD->
hasAttr<BlocksAttr>() &&
3077 "getBlockVarCopyInits - not __block var");
3078 auto I = BlockVarCopyInits.find(VD);
3079 if (I != BlockVarCopyInits.end())
3081 return {
nullptr,
false};
3087 assert(VD && CopyExpr &&
"Passed null params");
3088 assert(VD->
hasAttr<BlocksAttr>() &&
3089 "setBlockVarCopyInits - not __block var");
3090 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr,
CanThrow);
3094 unsigned DataSize)
const {
3099 "incorrect data size provided to CreateTypeSourceInfo!");
3116 return getObjCLayout(D);
3121 bool &AnyNonCanonArgs) {
3123 AnyNonCanonArgs |=
C.canonicalizeTemplateArguments(CanonArgs);
3129 bool AnyNonCanonArgs =
false;
3130 for (
auto &Arg : Args) {
3133 AnyNonCanonArgs |= !Arg.structurallyEquals(OrigArg);
3135 return AnyNonCanonArgs;
3143ASTContext::getExtQualType(
const Type *baseType,
Qualifiers quals)
const {
3148 llvm::FoldingSetNodeID ID;
3150 void *insertPos =
nullptr;
3151 if (
ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
3152 assert(eq->getQualifiers() == quals);
3161 canon = getExtQualType(canonSplit.
Ty, canonSplit.
Quals);
3164 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
3167 auto *eq =
new (*
this,
alignof(ExtQuals)) ExtQuals(baseType, canon, quals);
3168 ExtQualNodes.InsertNode(eq, insertPos);
3169 return QualType(eq, fastQuals);
3173 LangAS AddressSpace)
const {
3186 "Type cannot be in multiple addr spaces!");
3189 return getExtQualType(TypeNode, Quals);
3195 if (!
T.hasAddressSpace())
3199 const Type *TypeNode;
3202 if (
T.getTypePtr()->isArrayType()) {
3204 TypeNode =
T.getTypePtr();
3208 while (
T.hasAddressSpace()) {
3209 TypeNode = Quals.
strip(
T);
3213 if (!
QualType(TypeNode, 0).hasAddressSpace())
3217 T =
T.getSingleStepDesugaredType(*
this);
3227 return getExtQualType(TypeNode, Quals);
3235 "Attempted to get vtable pointer discriminator on a monomorphic type");
3238 llvm::raw_svector_ostream Out(Str);
3239 MC->mangleCXXVTable(RD, Out);
3240 return llvm::getPointerAuthStableSipHash(Str);
3266 switch (
T->getTypeClass()) {
3271 case Type::LValueReference:
3276 case Type::RValueReference:
3290 case Type::ObjCObjectPointer:
3291 case Type::BlockPointer:
3300 case Type::VariableArray:
3301 case Type::ConstantArray:
3302 case Type::IncompleteArray:
3303 case Type::ArrayParameter:
3316 case Type::ObjCInterface:
3317 case Type::ObjCObject:
3318 OS <<
"<objc_object>";
3327 QualType UnderlyingType =
T->castAsEnumDecl()->getIntegerType();
3329 Ctx, OS, UnderlyingType.
isNull() ? Ctx.
IntTy : UnderlyingType);
3332 case Type::FunctionNoProto:
3333 case Type::FunctionProto: {
3349 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FuncType)) {
3350 for (
QualType Param : FPT->param_types()) {
3354 if (FPT->isVariadic())
3361 case Type::MemberPointer: {
3365 Ctx, OS,
QualType(MPT->getQualifier().getAsType(), 0));
3369 case Type::ExtVector:
3377 case Type::ConstantMatrix:
3381 case Type::Builtin: {
3383 switch (BTy->getKind()) {
3384#define SIGNED_TYPE(Id, SingletonId) \
3385 case BuiltinType::Id: \
3388#define UNSIGNED_TYPE(Id, SingletonId) \
3389 case BuiltinType::Id: \
3392#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
3393#define BUILTIN_TYPE(Id, SingletonId)
3394#include "clang/AST/BuiltinTypes.def"
3395 llvm_unreachable(
"placeholder types should not appear here.");
3397 case BuiltinType::Half:
3400 case BuiltinType::Float:
3403 case BuiltinType::Double:
3406 case BuiltinType::LongDouble:
3409 case BuiltinType::Float16:
3412 case BuiltinType::Float128:
3416 case BuiltinType::Void:
3420 case BuiltinType::ObjCId:
3421 case BuiltinType::ObjCClass:
3422 case BuiltinType::ObjCSel:
3423 case BuiltinType::NullPtr:
3428 case BuiltinType::OCLSampler:
3429 case BuiltinType::OCLEvent:
3430 case BuiltinType::OCLClkEvent:
3431 case BuiltinType::OCLQueue:
3432 case BuiltinType::OCLReserveID:
3433 case BuiltinType::BFloat16:
3434 case BuiltinType::VectorQuad:
3435 case BuiltinType::VectorPair:
3436 case BuiltinType::DMR1024:
3437 case BuiltinType::DMR2048:
3442 case BuiltinType::Ibm128:
3444#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
3445 case BuiltinType::Id: \
3447#include "clang/Basic/OpenCLImageTypes.def"
3448#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
3449 case BuiltinType::Id: \
3451#include "clang/Basic/OpenCLExtensionTypes.def"
3452#define SVE_TYPE(Name, Id, SingletonId) \
3453 case BuiltinType::Id: \
3455#include "clang/Basic/AArch64ACLETypes.def"
3456#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
3457 case BuiltinType::Id: \
3459#include "clang/Basic/HLSLIntangibleTypes.def"
3460 case BuiltinType::Dependent:
3461 llvm_unreachable(
"should never get here");
3462#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
3463#include "clang/Basic/AMDGPUTypes.def"
3464 case BuiltinType::WasmExternRef:
3465#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
3466#include "clang/Basic/RISCVVTypes.def"
3467 llvm_unreachable(
"not yet implemented");
3469 llvm_unreachable(
"should never get here");
3471 case Type::Record: {
3472 const RecordDecl *RD =
T->castAsCanonical<RecordType>()->getOriginalDecl();
3492 II = Typedef->getDeclName().getAsIdentifierInfo();
3495 OS <<
"<anonymous_record>";
3501 case Type::HLSLAttributedResource:
3502 case Type::HLSLInlineSpirv:
3503 llvm_unreachable(
"should never get here");
3505 case Type::DeducedTemplateSpecialization:
3507#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3508#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3509#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
3510#define ABSTRACT_TYPE(Class, Base)
3511#define TYPE(Class, Base)
3512#include "clang/AST/TypeNodes.inc"
3513 llvm_unreachable(
"unexpected non-canonical or dependent type!");
3519 assert(!
T->isDependentType() &&
3520 "cannot compute type discriminator of a dependent type");
3523 llvm::raw_svector_ostream Out(Str);
3525 if (
T->isFunctionPointerType() ||
T->isFunctionReferenceType())
3526 T =
T->getPointeeType();
3528 if (
T->isFunctionType()) {
3531 T =
T.getUnqualifiedType();
3552 if (MPT->isMemberFunctionPointer()) {
3558 MPT->getMostRecentCXXRecordDecl());
3562 MC->mangleCanonicalTypeName(
T, Out);
3565 return llvm::getPointerAuthStableSipHash(Str);
3590 "Type cannot have multiple ObjCGCs!");
3593 return getExtQualType(TypeNode, Quals);
3607 QualType WrappedTy,
Expr *CountExpr,
bool CountInBytes,
bool OrNull,
3611 llvm::FoldingSetNodeID ID;
3614 void *InsertPos =
nullptr;
3616 CountAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
3621 size_t Size = CountAttributedType::totalSizeToAlloc<TypeCoupledDeclRefInfo>(
3622 DependentDecls.size());
3625 OrNull, DependentDecls);
3626 Types.push_back(CATy);
3627 CountAttributedTypes.InsertNode(CATy, InsertPos);
3636 case Type::Attributed: {
3644 case Type::BTFTagAttributed: {
3645 const auto *BTFT = dyn_cast<BTFTagAttributedType>(Orig);
3654 case Type::Adjusted: {
3660 case Type::MacroQualified: {
3663 MQT->getMacroIdentifier());
3667 return Adjust(Orig);
3673 if (
T->getExtInfo() == Info)
3677 if (
const auto *FNPT = dyn_cast<FunctionNoProtoType>(
T)) {
3697 FPT->getExtProtoInfo());
3712 L->DeducedReturnType(FD, ResultType);
3723 return getFunctionType(Proto->getReturnType(), Proto->getParamTypes(),
3724 Proto->getExtProtoInfo().withExceptionSpec(ESI));
3740 for (
unsigned i = 0, n = Args.size(); i != n; ++i)
3763 return getFunctionType(Proto->getReturnType(), Proto->param_types(), EPI);
3789 if (TSInfo->getType() != FD->
getType())
3797 "TypeLoc size mismatch from updating exception specification");
3798 TSInfo->overrideType(Updated);
3807 llvm::FoldingSetNodeID ID;
3810 void *InsertPos =
nullptr;
3811 if (
ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
3817 if (!
T.isCanonical()) {
3821 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
3822 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3825 Types.push_back(
New);
3826 ComplexTypes.InsertNode(
New, InsertPos);
3835 llvm::FoldingSetNodeID ID;
3838 void *InsertPos =
nullptr;
3839 if (
PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3845 if (!
T.isCanonical()) {
3849 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3850 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3853 Types.push_back(
New);
3854 PointerTypes.InsertNode(
New, InsertPos);
3859 llvm::FoldingSetNodeID ID;
3861 void *InsertPos =
nullptr;
3862 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3869 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3870 assert(!AT &&
"Shouldn't be in the map!");
3874 Types.push_back(AT);
3875 AdjustedTypes.InsertNode(AT, InsertPos);
3880 llvm::FoldingSetNodeID ID;
3882 void *InsertPos =
nullptr;
3883 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3890 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
3891 assert(!AT &&
"Shouldn't be in the map!");
3894 Types.push_back(AT);
3895 AdjustedTypes.InsertNode(AT, InsertPos);
3900 assert((
T->isArrayType() ||
T->isFunctionType()) &&
"T does not decay");
3909 if (
T->isArrayType())
3916 if (
T->isFunctionType())
3928 llvm::FoldingSetNodeID ID;
3929 ATy->Profile(ID, *
this, ATy->getElementType(), ATy->getZExtSize(),
3930 ATy->getSizeExpr(), ATy->getSizeModifier(),
3931 ATy->getIndexTypeQualifiers().getAsOpaqueValue());
3932 void *InsertPos =
nullptr;
3934 ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3943 AT = ArrayParameterTypes.FindNodeOrInsertPos(ID, InsertPos);
3944 assert(!AT &&
"Shouldn't be in the map!");
3949 Types.push_back(AT);
3950 ArrayParameterTypes.InsertNode(AT, InsertPos);
3957 assert(
T->isFunctionType() &&
"block of function types only");
3960 llvm::FoldingSetNodeID ID;
3963 void *InsertPos =
nullptr;
3965 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3971 if (!
T.isCanonical()) {
3976 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3977 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
3981 Types.push_back(
New);
3982 BlockPointerTypes.InsertNode(
New, InsertPos);
3990 assert((!
T->isPlaceholderType() ||
3991 T->isSpecificPlaceholderType(BuiltinType::UnknownAny)) &&
3992 "Unresolved placeholder type");
3996 llvm::FoldingSetNodeID ID;
3999 void *InsertPos =
nullptr;
4001 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
4009 if (!SpelledAsLValue || InnerRef || !
T.isCanonical()) {
4010 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
4015 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
4016 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4021 Types.push_back(
New);
4022 LValueReferenceTypes.InsertNode(
New, InsertPos);
4030 assert((!
T->isPlaceholderType() ||
4031 T->isSpecificPlaceholderType(BuiltinType::UnknownAny)) &&
4032 "Unresolved placeholder type");
4036 llvm::FoldingSetNodeID ID;
4039 void *InsertPos =
nullptr;
4041 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
4049 if (InnerRef || !
T.isCanonical()) {
4050 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() :
T);
4055 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
4056 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4061 Types.push_back(
New);
4062 RValueReferenceTypes.InsertNode(
New, InsertPos);
4070 assert(Cls &&
"At least one of Qualifier or Cls must be provided");
4073 Cls = Qualifier.getAsRecordDecl();
4077 llvm::FoldingSetNodeID ID;
4080 void *InsertPos =
nullptr;
4082 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4087 return Qualifier.getCanonical();
4095 if (!
T.isCanonical() || Qualifier != CanonicalQualifier) {
4101 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4102 assert(!NewIP &&
"Shouldn't be in the map!");
4106 Types.push_back(
New);
4107 MemberPointerTypes.InsertNode(
New, InsertPos);
4114 const llvm::APInt &ArySizeIn,
4115 const Expr *SizeExpr,
4117 unsigned IndexTypeQuals)
const {
4120 "Constant array of VLAs is illegal!");
4128 llvm::APInt ArySize(ArySizeIn);
4129 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
4131 llvm::FoldingSetNodeID ID;
4133 ASM, IndexTypeQuals);
4135 void *InsertPos =
nullptr;
4137 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
4148 ASM, IndexTypeQuals);
4153 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
4154 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4157 auto *
New = ConstantArrayType::Create(*
this, EltTy, Canon, ArySize, SizeExpr,
4158 ASM, IndexTypeQuals);
4159 ConstantArrayTypes.InsertNode(
New, InsertPos);
4160 Types.push_back(
New);
4169 if (!
type->isVariablyModifiedType())
return type;
4174 const Type *ty = split.
Ty;
4176#define TYPE(Class, Base)
4177#define ABSTRACT_TYPE(Class, Base)
4178#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4179#include "clang/AST/TypeNodes.inc"
4180 llvm_unreachable(
"didn't desugar past all non-canonical types?");
4186 case Type::DependentVector:
4187 case Type::ExtVector:
4188 case Type::DependentSizedExtVector:
4189 case Type::ConstantMatrix:
4190 case Type::DependentSizedMatrix:
4191 case Type::DependentAddressSpace:
4192 case Type::ObjCObject:
4193 case Type::ObjCInterface:
4194 case Type::ObjCObjectPointer:
4197 case Type::UnresolvedUsing:
4198 case Type::TypeOfExpr:
4200 case Type::Decltype:
4201 case Type::UnaryTransform:
4202 case Type::DependentName:
4203 case Type::InjectedClassName:
4204 case Type::TemplateSpecialization:
4205 case Type::TemplateTypeParm:
4206 case Type::SubstTemplateTypeParmPack:
4207 case Type::SubstBuiltinTemplatePack:
4209 case Type::DeducedTemplateSpecialization:
4210 case Type::PackExpansion:
4211 case Type::PackIndexing:
4213 case Type::DependentBitInt:
4214 case Type::ArrayParameter:
4215 case Type::HLSLAttributedResource:
4216 case Type::HLSLInlineSpirv:
4217 llvm_unreachable(
"type should never be variably-modified");
4221 case Type::FunctionNoProto:
4222 case Type::FunctionProto:
4223 case Type::BlockPointer:
4224 case Type::MemberPointer:
4237 case Type::LValueReference: {
4241 lv->isSpelledAsLValue());
4245 case Type::RValueReference: {
4252 case Type::Atomic: {
4258 case Type::ConstantArray: {
4264 cat->getSizeModifier(),
4265 cat->getIndexTypeCVRQualifiers());
4269 case Type::DependentSizedArray: {
4273 dat->getSizeModifier(), dat->getIndexTypeCVRQualifiers());
4278 case Type::IncompleteArray: {
4283 iat->getIndexTypeCVRQualifiers());
4288 case Type::VariableArray: {
4293 vat->getIndexTypeCVRQualifiers());
4306 unsigned IndexTypeQuals)
const {
4323 VariableArrayTypes.push_back(
New);
4324 Types.push_back(
New);
4334 unsigned elementTypeQuals)
const {
4337 "Size must be type- or value-dependent!");
4341 void *insertPos =
nullptr;
4342 llvm::FoldingSetNodeID ID;
4344 ID, *
this, numElements ?
QualType(canonElementType.
Ty, 0) : elementType,
4345 ASM, elementTypeQuals, numElements);
4349 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4361 DependentSizedArrayTypes.InsertNode(newType, insertPos);
4362 Types.push_back(newType);
4370 numElements, ASM, elementTypeQuals);
4371 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
4372 Types.push_back(canonTy);
4377 canonElementType.
Quals);
4381 if (
QualType(canonElementType.
Ty, 0) == elementType &&
4390 Types.push_back(sugaredType);
4396 unsigned elementTypeQuals)
const {
4397 llvm::FoldingSetNodeID ID;
4400 void *insertPos =
nullptr;
4402 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
4414 ASM, elementTypeQuals);
4419 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
4420 assert(!existing &&
"Shouldn't be in the map!"); (void) existing;
4426 IncompleteArrayTypes.InsertNode(newType, insertPos);
4427 Types.push_back(newType);
4433#define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS) \
4434 {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \
4437#define SVE_ELTTY(ELTTY, ELTS, NUMVECTORS) \
4438 {ELTTY, llvm::ElementCount::getScalable(ELTS), NUMVECTORS};
4442 llvm_unreachable(
"Unsupported builtin vector type");
4444#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4445 ElBits, NF, IsSigned) \
4446 case BuiltinType::Id: \
4447 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4448 llvm::ElementCount::getScalable(NumEls), NF};
4449#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4451 case BuiltinType::Id: \
4452 return {ElBits == 16 ? HalfTy : (ElBits == 32 ? FloatTy : DoubleTy), \
4453 llvm::ElementCount::getScalable(NumEls), NF};
4454#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4456 case BuiltinType::Id: \
4457 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4458#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4460 case BuiltinType::Id: \
4461 return {MFloat8Ty, llvm::ElementCount::getScalable(NumEls), NF};
4462#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4463 case BuiltinType::Id: \
4464 return {BoolTy, llvm::ElementCount::getScalable(NumEls), NF};
4465#include "clang/Basic/AArch64ACLETypes.def"
4467#define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF, \
4469 case BuiltinType::Id: \
4470 return {getIntTypeForBitwidth(ElBits, IsSigned), \
4471 llvm::ElementCount::getScalable(NumEls), NF};
4472#define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4473 case BuiltinType::Id: \
4474 return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy), \
4475 llvm::ElementCount::getScalable(NumEls), NF};
4476#define RVV_VECTOR_TYPE_BFLOAT(Name, Id, SingletonId, NumEls, ElBits, NF) \
4477 case BuiltinType::Id: \
4478 return {BFloat16Ty, llvm::ElementCount::getScalable(NumEls), NF};
4479#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4480 case BuiltinType::Id: \
4481 return {BoolTy, llvm::ElementCount::getScalable(NumEls), 1};
4482#include "clang/Basic/RISCVVTypes.def"
4489 if (Target->getTriple().isWasm() && Target->hasFeature(
"reference-types")) {
4490#define WASM_REF_TYPE(Name, MangledName, Id, SingletonId, AS) \
4491 if (BuiltinType::Id == BuiltinType::WasmExternRef) \
4493#include "clang/Basic/WebAssemblyReferenceTypes.def"
4496 "shouldn't try to generate type externref outside WebAssembly target");
4503 unsigned NumFields)
const {
4505 if (
auto It = ScalableVecTyMap.find(K); It != ScalableVecTyMap.end())
4508 if (Target->hasAArch64ACLETypes()) {
4511#define SVE_VECTOR_TYPE_INT(Name, MangledName, Id, SingletonId, NumEls, \
4512 ElBits, NF, IsSigned) \
4513 if (EltTy->hasIntegerRepresentation() && !EltTy->isBooleanType() && \
4514 EltTy->hasSignedIntegerRepresentation() == IsSigned && \
4515 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4516 return ScalableVecTyMap[K] = SingletonId; \
4518#define SVE_VECTOR_TYPE_FLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4520 if (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4521 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4522 return ScalableVecTyMap[K] = SingletonId; \
4524#define SVE_VECTOR_TYPE_BFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4526 if (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4527 EltTySize == ElBits && NumElts == (NumEls * NF) && NumFields == 1) { \
4528 return ScalableVecTyMap[K] = SingletonId; \
4530#define SVE_VECTOR_TYPE_MFLOAT(Name, MangledName, Id, SingletonId, NumEls, \
4532 if (EltTy->isMFloat8Type() && EltTySize == ElBits && \
4533 NumElts == (NumEls * NF) && NumFields == 1) { \
4534 return ScalableVecTyMap[K] = SingletonId; \
4536#define SVE_PREDICATE_TYPE_ALL(Name, MangledName, Id, SingletonId, NumEls, NF) \
4537 if (EltTy->isBooleanType() && NumElts == (NumEls * NF) && NumFields == 1) \
4538 return ScalableVecTyMap[K] = SingletonId;
4539#include "clang/Basic/AArch64ACLETypes.def"
4540 }
else if (Target->hasRISCVVTypes()) {
4542#define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, \
4544 if (!EltTy->isBooleanType() && \
4545 ((EltTy->hasIntegerRepresentation() && \
4546 EltTy->hasSignedIntegerRepresentation() == IsSigned) || \
4547 (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() && \
4549 (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() && \
4550 IsBF && !IsFP)) && \
4551 EltTySize == ElBits && NumElts == NumEls && NumFields == NF) \
4552 return ScalableVecTyMap[K] = SingletonId;
4553#define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls) \
4554 if (EltTy->isBooleanType() && NumElts == NumEls) \
4555 return ScalableVecTyMap[K] = SingletonId;
4556#include "clang/Basic/RISCVVTypes.def"
4571 llvm::FoldingSetNodeID ID;
4574 void *InsertPos =
nullptr;
4575 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4585 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4586 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4589 VectorType(vecType, NumElts, Canonical, VecKind);
4590 VectorTypes.InsertNode(
New, InsertPos);
4591 Types.push_back(
New);
4598 llvm::FoldingSetNodeID ID;
4601 void *InsertPos =
nullptr;
4603 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4608 VecType,
QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
4611 if (CanonVecTy == VecType) {
4616 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4617 assert(!CanonCheck &&
4618 "Dependent-sized vector_size canonical type broken");
4620 DependentVectorTypes.InsertNode(
New, InsertPos);
4629 Types.push_back(
New);
4636 unsigned NumElts)
const {
4643 llvm::FoldingSetNodeID ID;
4646 void *InsertPos =
nullptr;
4647 if (
VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
4657 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4658 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4662 VectorTypes.InsertNode(
New, InsertPos);
4663 Types.push_back(
New);
4671 llvm::FoldingSetNodeID ID;
4675 void *InsertPos =
nullptr;
4677 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4687 if (CanonVecTy == vecType) {
4692 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
4693 assert(!CanonCheck &&
"Dependent-sized ext_vector canonical type broken");
4695 DependentSizedExtVectorTypes.InsertNode(
New, InsertPos);
4704 Types.push_back(
New);
4709 unsigned NumColumns)
const {
4710 llvm::FoldingSetNodeID ID;
4712 Type::ConstantMatrix);
4715 "need a valid element type");
4718 "need valid matrix dimensions");
4719 void *InsertPos =
nullptr;
4729 assert(!NewIP &&
"Matrix type shouldn't already exist in the map");
4735 MatrixTypes.InsertNode(
New, InsertPos);
4736 Types.push_back(
New);
4745 llvm::FoldingSetNodeID ID;
4749 void *InsertPos =
nullptr;
4751 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4756 ColumnExpr, AttrLoc);
4759 DependentSizedMatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
4760 assert(!CanonCheck &&
"Dependent-sized matrix canonical type broken");
4762 DependentSizedMatrixTypes.InsertNode(Canon, InsertPos);
4763 Types.push_back(Canon);
4776 ColumnExpr, AttrLoc);
4777 Types.push_back(
New);
4782 Expr *AddrSpaceExpr,
4788 void *insertPos =
nullptr;
4789 llvm::FoldingSetNodeID ID;
4794 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
4800 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
4801 Types.push_back(canonTy);
4804 if (canonPointeeType == PointeeType &&
4810 AddrSpaceExpr, AttrLoc);
4811 Types.push_back(sugaredType);
4817 return T.isCanonical() &&
4835 llvm::FoldingSetNodeID ID;
4838 void *InsertPos =
nullptr;
4840 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
4850 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
4851 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
4856 Types.push_back(
New);
4857 FunctionNoProtoTypes.InsertNode(
New, InsertPos);
4873 return CanResultType;
4880 if (!NoexceptInType)
4897 bool AnyPackExpansions =
false;
4901 if (ET->
getAs<PackExpansionType>())
4902 AnyPackExpansions =
true;
4904 return AnyPackExpansions;
4910QualType ASTContext::getFunctionTypeInternal(
4911 QualType ResultTy, ArrayRef<QualType> ArgArray,
4912 const FunctionProtoType::ExtProtoInfo &EPI,
bool OnlyWantCanonical)
const {
4913 size_t NumArgs = ArgArray.size();
4917 llvm::FoldingSetNodeID
ID;
4922 bool Unique =
false;
4924 void *InsertPos =
nullptr;
4925 if (FunctionProtoType *FPT =
4926 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
4927 QualType Existing = QualType(FPT, 0);
4946 bool IsCanonicalExceptionSpec =
4950 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
4952 for (
unsigned i = 0; i != NumArgs && isCanonical; ++i)
4953 if (!ArgArray[i].isCanonicalAsParam())
4954 isCanonical =
false;
4956 if (OnlyWantCanonical)
4957 assert(isCanonical &&
4958 "given non-canonical parameters constructing canonical type");
4963 if (!isCanonical && Canonical.
isNull()) {
4964 SmallVector<QualType, 16> CanonicalArgs;
4965 CanonicalArgs.reserve(NumArgs);
4966 for (
unsigned i = 0; i != NumArgs; ++i)
4969 llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
4970 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
4973 if (IsCanonicalExceptionSpec) {
4975 }
else if (NoexceptInType) {
4988 bool AnyPacks =
false;
4990 if (ET->
getAs<PackExpansionType>())
5011 llvm_unreachable(
"dependent noexcept is already canonical");
5014 CanonicalEPI.
ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
5020 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI,
true);
5023 FunctionProtoType *NewIP =
5024 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
5025 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
5030 auto ESH = FunctionProtoType::getExceptionSpecSize(
5032 size_t Size = FunctionProtoType::totalSizeToAlloc<
5033 QualType, SourceLocation, FunctionType::FunctionTypeExtraBitfields,
5034 FunctionType::FunctionTypeExtraAttributeInfo,
5035 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
5036 Expr *, FunctionDecl *, FunctionProtoType::ExtParameterInfo, Qualifiers,
5037 FunctionEffect, EffectConditionExpr>(
5041 ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
5046 auto *FTP = (FunctionProtoType *)
Allocate(Size,
alignof(FunctionProtoType));
5047 FunctionProtoType::ExtProtoInfo newEPI = EPI;
5048 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
5049 Types.push_back(FTP);
5051 FunctionProtoTypes.InsertNode(FTP, InsertPos);
5053 AnyFunctionEffects =
true;
5054 return QualType(FTP, 0);
5057QualType ASTContext::getPipeType(QualType
T,
bool ReadOnly)
const {
5058 llvm::FoldingSetNodeID
ID;
5061 void *InsertPos =
nullptr;
5062 if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
5063 return QualType(PT, 0);
5068 if (!
T.isCanonical()) {
5072 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
5073 assert(!NewIP &&
"Shouldn't be in the map!");
5076 auto *
New =
new (*
this,
alignof(PipeType)) PipeType(
T, Canonical, ReadOnly);
5077 Types.push_back(
New);
5078 PipeTypes.InsertNode(
New, InsertPos);
5079 return QualType(
New, 0);
5089 return getPipeType(
T,
true);
5093 return getPipeType(
T,
false);
5097 llvm::FoldingSetNodeID ID;
5100 void *InsertPos =
nullptr;
5101 if (
BitIntType *EIT = BitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5105 BitIntTypes.InsertNode(
New, InsertPos);
5106 Types.push_back(
New);
5111 Expr *NumBitsExpr)
const {
5113 llvm::FoldingSetNodeID ID;
5116 void *InsertPos =
nullptr;
5118 DependentBitIntTypes.FindNodeOrInsertPos(ID, InsertPos))
5123 DependentBitIntTypes.InsertNode(
New, InsertPos);
5125 Types.push_back(
New);
5133 if (
auto *Target = PredefinedSugarTypes[llvm::to_underlying(KD)];
5145 return Ctx.getFromTargetType(Ctx.Target->
getSizeType());
5146 case Kind::SignedSizeT:
5148 case Kind::PtrdiffT:
5151 llvm_unreachable(
"unexpected kind");
5156 Types.push_back(
New);
5157 PredefinedSugarTypes[llvm::to_underlying(KD)] =
New;
5164 if (
auto *Tag = dyn_cast<TagDecl>(
Decl))
5167 if (
auto *
Typedef = dyn_cast<TypedefNameDecl>(
Decl))
5169 if (
auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl))
5178 if (
auto *Tag = dyn_cast<TagDecl>(TD))
5180 if (
auto *TN = dyn_cast<TypedefNameDecl>(TD))
5182 if (
const auto *UD = dyn_cast<UnresolvedUsingTypenameDecl>(TD))
5184 assert(TD->TypeForDecl);
5189 if (
const auto *TD = dyn_cast<TagDecl>(
Decl))
5191 if (
const auto *TD = dyn_cast<TypedefNameDecl>(
Decl);
5192 isa_and_nonnull<TypedefDecl, TypeAliasDecl>(TD))
5195 if (
const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(
Decl))
5198 assert(
Decl->TypeForDecl);
5208 std::optional<bool> TypeMatchesDeclOrNone)
const {
5209 if (!TypeMatchesDeclOrNone) {
5210 QualType DeclUnderlyingType =
Decl->getUnderlyingType();
5211 assert(!DeclUnderlyingType.
isNull());
5212 if (UnderlyingType.
isNull())
5213 UnderlyingType = DeclUnderlyingType;
5215 assert(
hasSameType(UnderlyingType, DeclUnderlyingType));
5216 TypeMatchesDeclOrNone = UnderlyingType == DeclUnderlyingType;
5220 assert(!UnderlyingType.
isNull());
5224 *TypeMatchesDeclOrNone) {
5225 if (
Decl->TypeForDecl)
5230 !*TypeMatchesDeclOrNone);
5232 Types.push_back(NewType);
5233 Decl->TypeForDecl = NewType;
5237 llvm::FoldingSetNodeID ID;
5239 *TypeMatchesDeclOrNone ?
QualType() : UnderlyingType);
5241 void *InsertPos =
nullptr;
5243 TypedefTypes.FindNodeOrInsertPos(ID, InsertPos))
5244 return QualType(Placeholder->getType(), 0);
5249 1, !!Qualifier, !*TypeMatchesDeclOrNone),
5253 UnderlyingType, !*TypeMatchesDeclOrNone);
5254 auto *Placeholder =
new (NewType->getFoldingSetPlaceholder())
5256 TypedefTypes.InsertNode(Placeholder, InsertPos);
5257 Types.push_back(NewType);
5266 if (UnderlyingType.
isNull()) {
5274 llvm::FoldingSetNodeID ID;
5277 void *InsertPos =
nullptr;
5278 if (
const UsingType *
T = UsingTypes.FindNodeOrInsertPos(ID, InsertPos))
5288 Allocate(UsingType::totalSizeToAlloc<NestedNameSpecifier>(!!Qualifier),
5292 UsingTypes.InsertNode(
T, InsertPos);
5298 const TagDecl *TD,
bool OwnsTag,
5300 const Type *CanonicalType,
5301 bool WithFoldingSetNode)
const {
5302 auto [TC, Size] = [&] {
5305 static_assert(
alignof(EnumType) ==
alignof(TagType));
5306 return std::make_tuple(Type::Enum,
sizeof(EnumType));
5307 case Decl::ClassTemplatePartialSpecialization:
5308 case Decl::ClassTemplateSpecialization:
5309 case Decl::CXXRecord:
5310 static_assert(
alignof(RecordType) ==
alignof(TagType));
5311 static_assert(
alignof(InjectedClassNameType) ==
alignof(TagType));
5313 return std::make_tuple(Type::InjectedClassName,
5314 sizeof(InjectedClassNameType));
5317 return std::make_tuple(Type::Record,
sizeof(RecordType));
5319 llvm_unreachable(
"unexpected decl kind");
5329 if (WithFoldingSetNode) {
5337 sizeof(TagTypeFoldingSetPlaceholder) +
5338 TagTypeFoldingSetPlaceholder::getOffset() + Size,
5339 std::max(
alignof(TagTypeFoldingSetPlaceholder),
alignof(TagType)));
5340 auto *
T =
new (Mem) TagTypeFoldingSetPlaceholder();
5341 Mem =
T->getTagType();
5343 Mem =
Allocate(Size,
alignof(TagType));
5346 auto *
T = [&, TC = TC]() -> TagType * {
5350 auto *
T =
new (Mem) EnumType(TC,
Keyword, Qualifier, TD, OwnsTag,
5351 IsInjected, CanonicalType);
5352 assert(
reinterpret_cast<void *
>(
T) ==
5353 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5354 "TagType must be the first base of EnumType");
5357 case Type::Record: {
5359 auto *
T =
new (Mem) RecordType(TC,
Keyword, Qualifier, TD, OwnsTag,
5360 IsInjected, CanonicalType);
5361 assert(
reinterpret_cast<void *
>(
T) ==
5362 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5363 "TagType must be the first base of RecordType");
5366 case Type::InjectedClassName: {
5367 auto *
T =
new (Mem) InjectedClassNameType(
Keyword, Qualifier, TD,
5368 IsInjected, CanonicalType);
5369 assert(
reinterpret_cast<void *
>(
T) ==
5370 reinterpret_cast<void *
>(
static_cast<TagType *
>(
T)) &&
5371 "TagType must be the first base of InjectedClassNameType");
5375 llvm_unreachable(
"unexpected type class");
5378 assert(
T->getKeyword() ==
Keyword);
5379 assert(
T->getQualifier() == Qualifier);
5380 assert(
T->getOriginalDecl() == TD);
5381 assert(
T->isInjected() == IsInjected);
5382 assert(
T->isTagOwned() == OwnsTag);
5391 if (
const auto *RD = dyn_cast<CXXRecordDecl>(TD);
5392 RD && RD->isInjectedClassName())
5399 if (TD->TypeForDecl)
5400 return TD->TypeForDecl->getCanonicalTypeUnqualified();
5402 const Type *CanonicalType = getTagTypeInternal(
5405 false,
false,
nullptr,
5407 TD->TypeForDecl = CanonicalType;
5413 const TagDecl *TD,
bool OwnsTag)
const {
5416 bool IsInjected = TD != NonInjectedTD;
5423 if (
Keyword == PreferredKeyword && !Qualifier && !OwnsTag) {
5424 if (
const Type *
T = TD->TypeForDecl;
T && !
T->isCanonicalUnqualified())
5430 std::nullopt, NonInjectedTD,
5431 false, IsInjected, CanonicalType,
5433 TD->TypeForDecl =
T;
5437 llvm::FoldingSetNodeID ID;
5438 TagTypeFoldingSetPlaceholder::Profile(ID,
Keyword, Qualifier, NonInjectedTD,
5439 OwnsTag, IsInjected);
5441 void *InsertPos =
nullptr;
5442 if (TagTypeFoldingSetPlaceholder *
T =
5443 TagTypes.FindNodeOrInsertPos(ID, InsertPos))
5448 getTagTypeInternal(
Keyword, Qualifier, NonInjectedTD, OwnsTag, IsInjected,
5449 CanonicalType,
true);
5450 TagTypes.InsertNode(TagTypeFoldingSetPlaceholder::fromTagType(
T), InsertPos);
5455 unsigned NumPositiveBits,
5458 unsigned IntWidth = Target->getIntWidth();
5459 unsigned CharWidth = Target->getCharWidth();
5460 unsigned ShortWidth = Target->getShortWidth();
5461 bool EnumTooLarge =
false;
5463 if (NumNegativeBits) {
5467 if (IsPacked && NumNegativeBits <= CharWidth &&
5468 NumPositiveBits < CharWidth) {
5470 BestWidth = CharWidth;
5471 }
else if (IsPacked && NumNegativeBits <= ShortWidth &&
5472 NumPositiveBits < ShortWidth) {
5474 BestWidth = ShortWidth;
5475 }
else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
5477 BestWidth = IntWidth;
5479 BestWidth = Target->getLongWidth();
5481 if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
5484 BestWidth = Target->getLongLongWidth();
5486 if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
5487 EnumTooLarge =
true;
5491 BestPromotionType = (BestWidth <= IntWidth ?
IntTy : BestType);
5496 if (IsPacked && NumPositiveBits <= CharWidth) {
5498 BestPromotionType =
IntTy;
5499 BestWidth = CharWidth;
5500 }
else if (IsPacked && NumPositiveBits <= ShortWidth) {
5502 BestPromotionType =
IntTy;
5503 BestWidth = ShortWidth;
5504 }
else if (NumPositiveBits <= IntWidth) {
5506 BestWidth = IntWidth;
5507 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5510 }
else if (NumPositiveBits <= (BestWidth = Target->getLongWidth())) {
5512 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5516 BestWidth = Target->getLongLongWidth();
5517 if (NumPositiveBits > BestWidth) {
5522 EnumTooLarge =
true;
5525 BestPromotionType = (NumPositiveBits == BestWidth || !LangOpts.CPlusPlus)
5530 return EnumTooLarge;
5534 assert((
T->isIntegralType(*
this) ||
T->isEnumeralType()) &&
5535 "Integral type required!");
5538 if (
Value.isUnsigned() ||
Value.isNonNegative()) {
5539 if (
T->isSignedIntegerOrEnumerationType())
5541 return Value.getActiveBits() <= BitWidth;
5543 return Value.getSignificantBits() <= BitWidth;
5549 const Type *CanonicalType)
const {
5551 UnresolvedUsingType::totalSizeToAlloc<
5553 !!InsertPos, !!Qualifier),
5557 auto *Placeholder =
new (
T->getFoldingSetPlaceholder())
5559 TypedefTypes.InsertNode(Placeholder, InsertPos);
5569 return D->TypeForDecl->getCanonicalTypeUnqualified();
5571 const Type *CanonicalType = getUnresolvedUsingTypeInternal(
5575 D->TypeForDecl = CanonicalType;
5584 if (
const Type *
T = D->TypeForDecl;
T && !
T->isCanonicalUnqualified())
5591 nullptr, CanonicalType);
5596 llvm::FoldingSetNodeID ID;
5599 void *InsertPos =
nullptr;
5601 UnresolvedUsingTypes.FindNodeOrInsertPos(ID, InsertPos))
5602 return QualType(Placeholder->getType(), 0);
5606 const Type *
T = getUnresolvedUsingTypeInternal(
Keyword, Qualifier, D,
5607 InsertPos, CanonicalType);
5615 llvm::FoldingSetNodeID id;
5616 AttributedType::Profile(
id, attrKind, modifiedType, equivalentType,
attr);
5618 void *insertPos =
nullptr;
5619 AttributedType *
type = AttributedTypes.FindNodeOrInsertPos(
id, insertPos);
5622 assert(!
attr ||
attr->getKind() == attrKind);
5625 type =
new (*
this,
alignof(AttributedType))
5626 AttributedType(canon, attrKind,
attr, modifiedType, equivalentType);
5628 Types.push_back(
type);
5629 AttributedTypes.InsertNode(
type, insertPos);
5642 switch (nullability) {
5658 llvm_unreachable(
"Unknown nullability kind");
5663 llvm::FoldingSetNodeID ID;
5664 BTFTagAttributedType::Profile(ID, Wrapped, BTFAttr);
5666 void *InsertPos =
nullptr;
5667 BTFTagAttributedType *Ty =
5668 BTFTagAttributedTypes.FindNodeOrInsertPos(ID, InsertPos);
5673 Ty =
new (*
this,
alignof(BTFTagAttributedType))
5674 BTFTagAttributedType(Canon, Wrapped, BTFAttr);
5676 Types.push_back(Ty);
5677 BTFTagAttributedTypes.InsertNode(Ty, InsertPos);
5684 const HLSLAttributedResourceType::Attributes &Attrs) {
5686 llvm::FoldingSetNodeID ID;
5687 HLSLAttributedResourceType::Profile(ID, Wrapped, Contained, Attrs);
5689 void *InsertPos =
nullptr;
5690 HLSLAttributedResourceType *Ty =
5691 HLSLAttributedResourceTypes.FindNodeOrInsertPos(ID, InsertPos);
5695 Ty =
new (*
this,
alignof(HLSLAttributedResourceType))
5696 HLSLAttributedResourceType(Wrapped, Contained, Attrs);
5698 Types.push_back(Ty);
5699 HLSLAttributedResourceTypes.InsertNode(Ty, InsertPos);
5707 llvm::FoldingSetNodeID ID;
5708 HLSLInlineSpirvType::Profile(ID, Opcode, Size, Alignment, Operands);
5710 void *InsertPos =
nullptr;
5711 HLSLInlineSpirvType *Ty =
5712 HLSLInlineSpirvTypes.FindNodeOrInsertPos(ID, InsertPos);
5717 HLSLInlineSpirvType::totalSizeToAlloc<SpirvOperand>(Operands.size()),
5718 alignof(HLSLInlineSpirvType));
5720 Ty =
new (Mem) HLSLInlineSpirvType(Opcode, Size, Alignment, Operands);
5722 Types.push_back(Ty);
5723 HLSLInlineSpirvTypes.InsertNode(Ty, InsertPos);
5730 Decl *AssociatedDecl,
5734 llvm::FoldingSetNodeID ID;
5735 SubstTemplateTypeParmType::Profile(ID, Replacement, AssociatedDecl, Index,
5737 void *InsertPos =
nullptr;
5738 SubstTemplateTypeParmType *SubstParm =
5739 SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5742 void *Mem =
Allocate(SubstTemplateTypeParmType::totalSizeToAlloc<QualType>(
5743 !Replacement.isCanonical()),
5744 alignof(SubstTemplateTypeParmType));
5745 SubstParm =
new (Mem) SubstTemplateTypeParmType(Replacement, AssociatedDecl,
5746 Index, PackIndex, Final);
5747 Types.push_back(SubstParm);
5748 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
5756 unsigned Index,
bool Final,
5763 llvm::FoldingSetNodeID ID;
5764 SubstTemplateTypeParmPackType::Profile(ID, AssociatedDecl, Index, Final,
5766 void *InsertPos =
nullptr;
5767 if (SubstTemplateTypeParmPackType *SubstParm =
5768 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
5778 [[maybe_unused]]
const auto *Nothing =
5779 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
5784 auto *SubstParm =
new (*
this,
alignof(SubstTemplateTypeParmPackType))
5785 SubstTemplateTypeParmPackType(Canon, AssociatedDecl, Index, Final,
5787 Types.push_back(SubstParm);
5788 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
5796 return P.getKind() == TemplateArgument::Type;
5798 "Pack contains a non-type");
5800 llvm::FoldingSetNodeID ID;
5801 SubstBuiltinTemplatePackType::Profile(ID, ArgPack);
5803 void *InsertPos =
nullptr;
5805 SubstBuiltinTemplatePackTypes.FindNodeOrInsertPos(ID, InsertPos))
5814 [[maybe_unused]]
const auto *Nothing =
5815 SubstBuiltinTemplatePackTypes.FindNodeOrInsertPos(ID, InsertPos);
5819 auto *PackType =
new (*
this,
alignof(SubstBuiltinTemplatePackType))
5820 SubstBuiltinTemplatePackType(Canon, ArgPack);
5821 Types.push_back(PackType);
5822 SubstBuiltinTemplatePackTypes.InsertNode(PackType, InsertPos);
5832 llvm::FoldingSetNodeID ID;
5833 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
5834 void *InsertPos =
nullptr;
5835 TemplateTypeParmType *TypeParm
5836 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5843 TypeParm =
new (*
this,
alignof(TemplateTypeParmType))
5844 TemplateTypeParmType(Depth, Index, ParameterPack, TTPDecl, Canon);
5846 TemplateTypeParmType *TypeCheck
5847 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
5848 assert(!TypeCheck &&
"Template type parameter canonical type broken");
5851 TypeParm =
new (*
this,
alignof(TemplateTypeParmType)) TemplateTypeParmType(
5852 Depth, Index, ParameterPack,
nullptr,
QualType());
5854 Types.push_back(TypeParm);
5855 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
5881 llvm_unreachable(
"unexpected keyword kind");
5895 ElaboratedKeywordLoc, QualifierLoc, TemplateKeywordLoc, NameLoc,
5905 SpecifiedArgVec.reserve(SpecifiedArgs.size());
5907 SpecifiedArgVec.push_back(Arg.getArgument());
5910 CanonicalArgs, Underlying);
5913[[maybe_unused]]
static bool
5916 if (Arg.isPackExpansion())
5927 Template.getAsDependentTemplateName()));
5929 for (
const auto &Arg : Args)
5933 llvm::FoldingSetNodeID ID;
5936 void *InsertPos =
nullptr;
5937 if (
auto *
T = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
5940 void *Mem =
Allocate(
sizeof(TemplateSpecializationType) +
5942 alignof(TemplateSpecializationType));
5946 assert(Spec->isDependentType() &&
5947 "canonical template specialization must be dependent");
5948 Types.push_back(Spec);
5949 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
5957 const auto *TD =
Template.getAsTemplateDecl(
true);
5958 bool IsTypeAlias = TD && TD->isTypeAlias();
5959 if (Underlying.
isNull()) {
5966 bool NonCanonical =
Template != CanonTemplate ||
Keyword != CanonKeyword;
5968 if (CanonicalArgs.empty()) {
5971 CanonicalArgs = CanonArgsVec;
5973 NonCanonical |= !llvm::equal(
5974 SpecifiedArgs, CanonicalArgs,
5983 assert((!isa_and_nonnull<TypeAliasTemplateDecl>(TD) ||
5985 "Caller must compute aliased type");
5986 IsTypeAlias =
false;
5989 CanonKeyword, CanonTemplate, CanonicalArgs);
5993 void *Mem =
Allocate(
sizeof(TemplateSpecializationType) +
5995 (IsTypeAlias ?
sizeof(
QualType) : 0),
5996 alignof(TemplateSpecializationType));
5997 auto *Spec =
new (Mem) TemplateSpecializationType(
5999 Types.push_back(Spec);
6005 llvm::FoldingSetNodeID ID;
6008 void *InsertPos =
nullptr;
6009 ParenType *
T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
6016 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
6017 assert(!CheckT &&
"Paren canonical type broken");
6023 ParenTypes.InsertNode(
T, InsertPos);
6036 Types.push_back(newType);
6043 llvm::FoldingSetNodeID ID;
6044 DependentNameType::Profile(ID,
Keyword, NNS, Name);
6046 void *InsertPos =
nullptr;
6047 if (DependentNameType *
T =
6048 DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos))
6056 if (CanonKeyword !=
Keyword || CanonNNS != NNS) {
6058 [[maybe_unused]] DependentNameType *
T =
6059 DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
6060 assert(!
T &&
"broken canonicalization");
6064 DependentNameType *
T =
new (*
this,
alignof(DependentNameType))
6065 DependentNameType(
Keyword, NNS, Name, Canon);
6067 DependentNameTypes.InsertNode(
T, InsertPos);
6073 if (
const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
6075 if (TTP->isParameterPack())
6079 }
else if (
auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
6081 NTTP->getType().getNonPackExpansionType().getNonLValueExprType(*
this);
6087 if (
T->isRecordType()) {
6096 Expr *E =
new (*this)
6098 T,
VK, NTTP->getLocation());
6100 if (NTTP->isParameterPack())
6106 std::nullopt,
false,
6108 if (TTP->isParameterPack())
6114 if (Param->isTemplateParameterPack())
6123 bool ExpectPackInType)
const {
6125 "Pack expansions must expand one or more parameter packs");
6127 llvm::FoldingSetNodeID ID;
6128 PackExpansionType::Profile(ID, Pattern, NumExpansions);
6130 void *InsertPos =
nullptr;
6131 PackExpansionType *
T = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
6142 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
6145 T =
new (*
this,
alignof(PackExpansionType))
6146 PackExpansionType(Pattern, Canon, NumExpansions);
6148 PackExpansionTypes.InsertNode(
T, InsertPos);
6160 if (Protocols.empty())
return true;
6165 for (
unsigned i = 1; i != Protocols.size(); ++i)
6175 llvm::array_pod_sort(Protocols.begin(), Protocols.end(),
CmpProtocolNames);
6179 P = P->getCanonicalDecl();
6182 auto ProtocolsEnd = llvm::unique(Protocols);
6183 Protocols.erase(ProtocolsEnd, Protocols.end());
6188 unsigned NumProtocols)
const {
6197 bool isKindOf)
const {
6200 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
6205 llvm::FoldingSetNodeID ID;
6206 ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
6207 void *InsertPos =
nullptr;
6208 if (
ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
6215 if (effectiveTypeArgs.empty()) {
6217 effectiveTypeArgs = baseObject->getTypeArgs();
6224 bool typeArgsAreCanonical = llvm::all_of(
6227 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.
isCanonical()) {
6231 if (!typeArgsAreCanonical) {
6232 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
6233 for (
auto typeArg : effectiveTypeArgs)
6235 canonTypeArgs = canonTypeArgsVec;
6237 canonTypeArgs = effectiveTypeArgs;
6242 if (!protocolsSorted) {
6243 canonProtocolsVec.append(protocols.begin(), protocols.end());
6245 canonProtocols = canonProtocolsVec;
6247 canonProtocols = protocols;
6251 canonProtocols, isKindOf);
6254 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
6257 unsigned size =
sizeof(ObjCObjectTypeImpl);
6258 size += typeArgs.size() *
sizeof(
QualType);
6260 void *mem =
Allocate(size,
alignof(ObjCObjectTypeImpl));
6262 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
6266 ObjCObjectTypes.InsertNode(
T, InsertPos);
6276 bool allowOnPointerType)
const {
6279 if (
const auto *objT = dyn_cast<ObjCTypeParamType>(
type.getTypePtr())) {
6284 if (allowOnPointerType) {
6285 if (
const auto *objPtr =
6286 dyn_cast<ObjCObjectPointerType>(
type.getTypePtr())) {
6290 protocolsVec.append(objT->qual_begin(),
6292 protocolsVec.append(protocols.begin(), protocols.end());
6295 objT->getBaseType(),
6296 objT->getTypeArgsAsWritten(),
6298 objT->isKindOfTypeAsWritten());
6304 if (
const auto *objT = dyn_cast<ObjCObjectType>(
type.getTypePtr())){
6309 objT->getTypeArgsAsWritten(),
6311 objT->isKindOfTypeAsWritten());
6315 if (
type->isObjCObjectType()) {
6325 if (
type->isObjCIdType()) {
6328 objPtr->isKindOfType());
6333 if (
type->isObjCClassType()) {
6336 objPtr->isKindOfType());
6348 llvm::FoldingSetNodeID ID;
6349 ObjCTypeParamType::Profile(ID,
Decl,
Decl->getUnderlyingType(), protocols);
6350 void *InsertPos =
nullptr;
6351 if (ObjCTypeParamType *TypeParam =
6352 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
6357 if (!protocols.empty()) {
6361 Canonical, protocols, hasError,
true ));
6362 assert(!hasError &&
"Error when apply protocol qualifier to bound type");
6365 unsigned size =
sizeof(ObjCTypeParamType);
6367 void *mem =
Allocate(size,
alignof(ObjCTypeParamType));
6368 auto *newType =
new (mem) ObjCTypeParamType(
Decl, Canonical, protocols);
6370 Types.push_back(newType);
6371 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
6381 protocols.append(NewTypeParamTy->qual_begin(), NewTypeParamTy->qual_end());
6396 for (
auto *Proto : OPT->quals()) {
6419 if (InheritedProtocols.empty())
6423 bool Conforms =
false;
6424 for (
auto *Proto : OPT->quals()) {
6426 for (
auto *PI : InheritedProtocols) {
6438 for (
auto *PI : InheritedProtocols) {
6440 bool Adopts =
false;
6441 for (
auto *Proto : OPT->quals()) {
6455 llvm::FoldingSetNodeID ID;
6458 void *InsertPos =
nullptr;
6460 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
6469 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
6478 Types.push_back(QType);
6479 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
6487 if (
Decl->TypeForDecl)
6491 assert(PrevDecl->TypeForDecl &&
"previous decl has no TypeForDecl");
6492 Decl->TypeForDecl = PrevDecl->TypeForDecl;
6493 return QualType(PrevDecl->TypeForDecl, 0);
6502 Decl->TypeForDecl =
T;
6515 llvm::FoldingSetNodeID ID;
6519 void *InsertPos =
nullptr;
6521 DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
6531 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
6539 Types.push_back(toe);
6550 auto *tot =
new (*
this,
alignof(TypeOfType))
6551 TypeOfType(*
this, tofType, Canonical, Kind);
6552 Types.push_back(tot);
6576 llvm_unreachable(
"Unknown value kind");
6591 }
else if (!UnderlyingType.
isNull()) {
6594 llvm::FoldingSetNodeID ID;
6595 DependentDecltypeType::Profile(ID, *
this, E);
6597 void *InsertPos =
nullptr;
6598 if (DependentDecltypeType *Canon =
6599 DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos))
6604 new (*
this,
alignof(DependentDecltypeType)) DependentDecltypeType(E);
6605 DependentDecltypeTypes.InsertNode(DT, InsertPos);
6606 Types.push_back(DT);
6609 auto *DT =
new (*
this,
alignof(DecltypeType))
6610 DecltypeType(E, UnderlyingType, CanonType);
6611 Types.push_back(DT);
6616 bool FullySubstituted,
6620 if (FullySubstituted && Index) {
6623 llvm::FoldingSetNodeID ID;
6624 PackIndexingType::Profile(ID, *
this, Pattern.
getCanonicalType(), IndexExpr,
6625 FullySubstituted, Expansions);
6626 void *InsertPos =
nullptr;
6627 PackIndexingType *Canon =
6628 DependentPackIndexingTypes.FindNodeOrInsertPos(ID, InsertPos);
6631 PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6635 IndexExpr, FullySubstituted, Expansions);
6636 DependentPackIndexingTypes.InsertNode(Canon, InsertPos);
6642 Allocate(PackIndexingType::totalSizeToAlloc<QualType>(Expansions.size()),
6644 auto *
T =
new (Mem) PackIndexingType(Canonical, Pattern, IndexExpr,
6645 FullySubstituted, Expansions);
6654 UnaryTransformType::UTTKind Kind)
const {
6656 llvm::FoldingSetNodeID ID;
6657 UnaryTransformType::Profile(ID, BaseType, UnderlyingType, Kind);
6659 void *InsertPos =
nullptr;
6660 if (UnaryTransformType *UT =
6661 UnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos))
6665 if (!BaseType->isDependentType()) {
6668 assert(UnderlyingType.
isNull() || BaseType == UnderlyingType);
6671 BaseType != CanonBase) {
6676 [[maybe_unused]] UnaryTransformType *UT =
6677 UnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
6678 assert(!UT &&
"broken canonicalization");
6682 auto *UT =
new (*
this,
alignof(UnaryTransformType))
6683 UnaryTransformType(BaseType, UnderlyingType, Kind, CanonType);
6684 UnaryTransformTypes.InsertNode(UT, InsertPos);
6685 Types.push_back(UT);
6689QualType ASTContext::getAutoTypeInternal(
6694 !TypeConstraintConcept && !IsDependent)
6698 llvm::FoldingSetNodeID ID;
6699 bool IsDeducedDependent =
6700 isa_and_nonnull<TemplateTemplateParmDecl>(TypeConstraintConcept) ||
6702 AutoType::Profile(ID, *
this, DeducedType,
Keyword,
6703 IsDependent || IsDeducedDependent, TypeConstraintConcept,
6704 TypeConstraintArgs);
6705 if (
auto const AT_iter = AutoTypes.find(ID); AT_iter != AutoTypes.end())
6706 return QualType(AT_iter->getSecond(), 0);
6710 if (!DeducedType.
isNull()) {
6712 }
else if (TypeConstraintConcept) {
6713 bool AnyNonCanonArgs =
false;
6714 auto *CanonicalConcept =
6717 *
this, TypeConstraintArgs, AnyNonCanonArgs);
6718 if (CanonicalConcept != TypeConstraintConcept || AnyNonCanonArgs) {
6720 CanonicalConcept, CanonicalConceptArgs,
6726 void *Mem =
Allocate(
sizeof(AutoType) +
6727 sizeof(TemplateArgument) * TypeConstraintArgs.size(),
6729 auto *AT =
new (Mem) AutoType(
6731 (IsDependent ? TypeDependence::DependentInstantiation
6732 : TypeDependence::None) |
6733 (IsPack ? TypeDependence::UnexpandedPack : TypeDependence::None),
6734 Canon, TypeConstraintConcept, TypeConstraintArgs);
6736 llvm::FoldingSetNodeID InsertedID;
6737 AT->Profile(InsertedID, *
this);
6738 assert(InsertedID == ID &&
"ID does not match");
6740 Types.push_back(AT);
6741 AutoTypes.try_emplace(ID, AT);
6742 return QualType(AT, 0);
6750 bool IsDependent,
bool IsPack,
6753 assert((!IsPack || IsDependent) &&
"only use IsPack for a dependent pack");
6754 assert((!IsDependent || DeducedType.
isNull()) &&
6755 "A dependent auto should be undeduced");
6756 return getAutoTypeInternal(DeducedType,
Keyword, IsDependent, IsPack,
6757 TypeConstraintConcept, TypeConstraintArgs);
6761 QualType CanonT =
T.getNonPackExpansionType().getCanonicalType();
6764 if (
auto *AT = CanonT->
getAs<AutoType>()) {
6765 if (!AT->isConstrained())
6769 AT->containsUnexpandedParameterPack()),
6781QualType ASTContext::getDeducedTemplateSpecializationTypeInternal(
6783 bool IsDependent,
QualType Canon)
const {
6785 void *InsertPos =
nullptr;
6786 llvm::FoldingSetNodeID ID;
6787 DeducedTemplateSpecializationType::Profile(ID,
Keyword,
Template, DeducedType,
6789 if (DeducedTemplateSpecializationType *DTST =
6790 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
6793 auto *DTST =
new (*
this,
alignof(DeducedTemplateSpecializationType))
6795 IsDependent, Canon);
6798 llvm::FoldingSetNodeID TempID;
6799 DTST->Profile(TempID);
6800 assert(ID == TempID &&
"ID does not match");
6802 Types.push_back(DTST);
6803 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
6812 bool IsDependent)
const {
6819 ? getDeducedTemplateSpecializationTypeInternal(
6823 return getDeducedTemplateSpecializationTypeInternal(
6832 llvm::FoldingSetNodeID ID;
6835 void *InsertPos =
nullptr;
6836 if (
AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
6842 if (!
T.isCanonical()) {
6846 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
6847 assert(!NewIP &&
"Shouldn't be in the map!"); (void)NewIP;
6850 Types.push_back(
New);
6851 AtomicTypes.InsertNode(
New, InsertPos);
6882 return getFromTargetType(Target->getSizeType());
6901 return getFromTargetType(Target->getUnsignedPtrDiffType(
LangAS::Default));
6906 return getFromTargetType(Target->getIntMaxType());
6911 return getFromTargetType(Target->getUIntMaxType());
6929 return getFromTargetType(Target->getIntPtrType());
6939 return getFromTargetType(Target->getProcessIDType());
6951 const Type *Ty =
T.getTypePtr();
6979 quals = splitType.
Quals;
6984 QualType elementType = AT->getElementType();
6989 if (elementType == unqualElementType) {
6990 assert(quals.
empty());
6991 quals = splitType.
Quals;
6999 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
7001 CAT->getSizeExpr(), CAT->getSizeModifier(), 0);
7004 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
7008 if (
const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
7010 VAT->getSizeModifier(),
7011 VAT->getIndexTypeCVRQualifiers());
7016 DSAT->getSizeModifier(), 0);
7026 bool AllowPiMismatch)
const {
7041 if (
auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
7042 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
7043 if (!((CAT2 && CAT1->getSize() == CAT2->getSize()) ||
7056 T1 = AT1->getElementType();
7057 T2 = AT2->getElementType();
7077 bool AllowPiMismatch)
const {
7082 if (T1PtrType && T2PtrType) {
7090 T1MPType && T2MPType) {
7091 if (
auto *RD1 = T1MPType->getMostRecentCXXRecordDecl(),
7092 *RD2 = T2MPType->getMostRecentCXXRecordDecl();
7093 RD1 != RD2 && RD1->getCanonicalDecl() != RD2->getCanonicalDecl())
7095 if (T1MPType->getQualifier().getCanonical() !=
7096 T2MPType->getQualifier().getCanonical())
7106 if (T1OPType && T2OPType) {
7138 if (Quals1 != Quals2)
7208 llvm_unreachable(
"bad template name kind!");
7214 if (!TP->hasDefaultArgument())
7216 return &TP->getDefaultArgument().getArgument();
7219 case NamedDecl::TemplateTypeParm:
7221 case NamedDecl::NonTypeTemplateParm:
7223 case NamedDecl::TemplateTemplateParm:
7226 llvm_unreachable(
"Unexpected template parameter kind");
7231 bool IgnoreDeduced)
const {
7232 while (std::optional<TemplateName> UnderlyingOrNone =
7234 Name = *UnderlyingOrNone;
7239 if (
auto *TTP = dyn_cast<TemplateTemplateParmDecl>(
Template))
7248 llvm_unreachable(
"cannot canonicalize unresolved template");
7252 assert(DTN &&
"Non-dependent template names must refer to template decls.");
7271 assert(IgnoreDeduced ==
false);
7278 bool NonCanonical = CanonUnderlying != Underlying;
7284 assert(CanonArgs.size() <= Params.size());
7290 for (
int I = CanonArgs.size() - 1; I >= 0; --I) {
7299 if (I ==
int(CanonArgs.size() - 1))
7300 CanonArgs.pop_back();
7301 NonCanonical =
true;
7311 llvm_unreachable(
"always sugar node");
7314 llvm_unreachable(
"bad template name!");
7319 bool IgnoreDeduced)
const {
7340 llvm::FoldingSetNodeID XCEID, YCEID;
7341 XCE->
Profile(XCEID, *
this,
true,
true);
7342 YCE->
Profile(YCEID, *
this,
true,
true);
7343 return XCEID == YCEID;
7392 if (
auto *TX = dyn_cast<TemplateTypeParmDecl>(
X)) {
7394 if (TX->isParameterPack() != TY->isParameterPack())
7396 if (TX->hasTypeConstraint() != TY->hasTypeConstraint())
7399 TY->getTypeConstraint());
7402 if (
auto *TX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7404 return TX->isParameterPack() == TY->isParameterPack() &&
7405 TX->getASTContext().hasSameType(TX->getType(), TY->getType()) &&
7407 TY->getPlaceholderTypeConstraint());
7412 return TX->isParameterPack() == TY->isParameterPack() &&
7414 TY->getTemplateParameters());
7419 if (
X->size() != Y->
size())
7422 for (
unsigned I = 0, N =
X->size(); I != N; ++I)
7436 if (
auto *TTPX = dyn_cast<TemplateTypeParmDecl>(
X)) {
7438 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7441 return hasSameType(TTPX->getDefaultArgument().getArgument().getAsType(),
7442 TTPY->getDefaultArgument().getArgument().getAsType());
7445 if (
auto *NTTPX = dyn_cast<NonTypeTemplateParmDecl>(
X)) {
7447 if (!NTTPX->hasDefaultArgument() || !NTTPY->hasDefaultArgument())
7450 Expr *DefaultArgumentX =
7451 NTTPX->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7452 Expr *DefaultArgumentY =
7453 NTTPY->getDefaultArgument().getArgument().getAsExpr()->
IgnoreImpCasts();
7454 llvm::FoldingSetNodeID XID, YID;
7455 DefaultArgumentX->
Profile(XID, *
this,
true);
7456 DefaultArgumentY->
Profile(YID, *
this,
true);
7463 if (!TTPX->hasDefaultArgument() || !TTPY->hasDefaultArgument())
7478 auto Kind =
X.getKind();
7486 auto [NamespaceX, PrefixX] =
X.getAsNamespaceAndPrefix();
7489 NamespaceY->getNamespace()))
7494 const auto *TX =
X.getAsType(), *TY = Y.
getAsType();
7495 if (TX->getCanonicalTypeInternal() != TY->getCanonicalTypeInternal())
7504 llvm_unreachable(
"unhandled qualifier kind");
7510 if (A->
hasAttr<CUDADeviceAttr>() != B->
hasAttr<CUDADeviceAttr>())
7512 if (A->
hasAttr<CUDADeviceAttr>() && B->
hasAttr<CUDADeviceAttr>())
7524 llvm::FoldingSetNodeID Cand1ID, Cand2ID;
7528 for (
auto Pair : zip_longest(AEnableIfAttrs, BEnableIfAttrs)) {
7529 std::optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
7530 std::optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
7533 if (!Cand1A || !Cand2A)
7539 (*Cand1A)->getCond()->Profile(Cand1ID, A->
getASTContext(),
true);
7540 (*Cand2A)->getCond()->Profile(Cand2ID, B->
getASTContext(),
true);
7544 if (Cand1ID != Cand2ID)
7578 if (
const auto *TypedefX = dyn_cast<TypedefNameDecl>(
X))
7579 if (
const auto *TypedefY = dyn_cast<TypedefNameDecl>(Y))
7581 TypedefY->getUnderlyingType());
7598 if (
const auto *TagX = dyn_cast<TagDecl>(
X)) {
7600 return (TagX->getTagKind() == TagY->getTagKind()) ||
7612 if (
const auto *FuncX = dyn_cast<FunctionDecl>(
X)) {
7614 if (
const auto *CtorX = dyn_cast<CXXConstructorDecl>(
X)) {
7616 if (CtorX->getInheritedConstructor() &&
7617 !
isSameEntity(CtorX->getInheritedConstructor().getConstructor(),
7618 CtorY->getInheritedConstructor().getConstructor()))
7622 if (FuncX->isMultiVersion() != FuncY->isMultiVersion())
7627 if (FuncX->isMultiVersion()) {
7628 const auto *TAX = FuncX->getAttr<TargetAttr>();
7629 const auto *TAY = FuncY->getAttr<TargetAttr>();
7630 assert(TAX && TAY &&
"Multiversion Function without target attribute");
7632 if (TAX->getFeaturesStr() != TAY->getFeaturesStr())
7638 if ((FuncX->isMemberLikeConstrainedFriend() ||
7639 FuncY->isMemberLikeConstrainedFriend()) &&
7640 !FuncX->getLexicalDeclContext()->Equals(
7641 FuncY->getLexicalDeclContext())) {
7646 FuncY->getTrailingRequiresClause()))
7654 FD = FD->getCanonicalDecl();
7655 return FD->getTypeSourceInfo() ? FD->getTypeSourceInfo()->getType()
7658 QualType XT = GetTypeAsWritten(FuncX), YT = GetTypeAsWritten(FuncY);
7673 return FuncX->getLinkageInternal() == FuncY->getLinkageInternal() &&
7678 if (
const auto *VarX = dyn_cast<VarDecl>(
X)) {
7680 if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
7683 if (VarX->getType().isNull() || VarY->getType().isNull())
7686 if (
hasSameType(VarX->getType(), VarY->getType()))
7696 if (!VarXTy || !VarYTy)
7705 if (
const auto *NamespaceX = dyn_cast<NamespaceDecl>(
X)) {
7707 return NamespaceX->isInline() == NamespaceY->isInline();
7712 if (
const auto *TemplateX = dyn_cast<TemplateDecl>(
X)) {
7716 if (
const auto *ConceptX = dyn_cast<ConceptDecl>(
X)) {
7719 ConceptY->getConstraintExpr()))
7724 TemplateY->getTemplatedDecl()) &&
7726 TemplateY->getTemplateParameters());
7730 if (
const auto *FDX = dyn_cast<FieldDecl>(
X)) {
7733 return hasSameType(FDX->getType(), FDY->getType());
7737 if (
const auto *IFDX = dyn_cast<IndirectFieldDecl>(
X)) {
7739 return IFDX->getAnonField()->getCanonicalDecl() ==
7740 IFDY->getAnonField()->getCanonicalDecl();
7749 if (
const auto *USX = dyn_cast<UsingShadowDecl>(
X)) {
7756 if (
const auto *UX = dyn_cast<UsingDecl>(
X)) {
7759 UX->hasTypename() == UY->hasTypename() &&
7760 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7762 if (
const auto *UX = dyn_cast<UnresolvedUsingValueDecl>(
X)) {
7765 UX->isAccessDeclaration() == UY->isAccessDeclaration();
7767 if (
const auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(
X)) {
7775 if (
const auto *UX = dyn_cast<UsingPackDecl>(
X)) {
7777 UX->getInstantiatedFromUsingDecl(),
7782 if (
const auto *NAX = dyn_cast<NamespaceAliasDecl>(
X)) {
7784 return NAX->getNamespace()->Equals(NAY->getNamespace());
7832 bool AnyNonCanonArgs =
false;
7835 if (!AnyNonCanonArgs)
7845 llvm_unreachable(
"Unhandled template argument kind");
7855 llvm_unreachable(
"Comparing NULL template argument");
7880 llvm::FoldingSetNodeID ID1, ID2;
7890 return isSameTemplateArgument(Arg1, Arg2);
7894 llvm_unreachable(
"Unhandled template argument kind");
7899 if (!
T.hasLocalQualifiers()) {
7901 if (
const auto *AT = dyn_cast<ArrayType>(
T))
7921 const auto *ATy = dyn_cast<ArrayType>(split.
Ty);
7922 if (!ATy || qs.
empty())
7929 if (
const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
7932 CAT->getSizeModifier(),
7933 CAT->getIndexTypeCVRQualifiers()));
7934 if (
const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
7936 IAT->getSizeModifier(),
7937 IAT->getIndexTypeCVRQualifiers()));
7939 if (
const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
7941 NewEltTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
7942 DSAT->getIndexTypeCVRQualifiers()));
7947 VAT->getIndexTypeCVRQualifiers()));
7953 if (
T->isArrayType() ||
T->isFunctionType())
7961 return T.getUnqualifiedType();
7972 if (
T->isArrayType() ||
T->isFunctionType())
7974 return T.getUnqualifiedType();
7989 assert(PrettyArrayType &&
"Not an array type!");
8026 uint64_t ElementCount = 1;
8029 CA = dyn_cast_or_null<ConstantArrayType>(
8032 return ElementCount;
8040 uint64_t ElementCount = 1;
8044 AILE = dyn_cast<ArrayInitLoopExpr>(AILE->
getSubExpr());
8047 return ElementCount;
8057 default: llvm_unreachable(
"getFloatingRank(): not a floating type");
8059 case BuiltinType::Half:
return HalfRank;
8060 case BuiltinType::Float:
return FloatRank;
8093unsigned ASTContext::getIntegerRank(
const Type *
T)
const {
8094 assert(
T->isCanonicalUnqualified() &&
"T should be canonicalized");
8098 if (
const auto *EIT = dyn_cast<BitIntType>(
T))
8099 return 0 + (EIT->getNumBits() << 3);
8102 default: llvm_unreachable(
"getIntegerRank(): not a built-in integer");
8103 case BuiltinType::Bool:
8105 case BuiltinType::Char_S:
8106 case BuiltinType::Char_U:
8107 case BuiltinType::SChar:
8108 case BuiltinType::UChar:
8110 case BuiltinType::Short:
8111 case BuiltinType::UShort:
8113 case BuiltinType::Int:
8114 case BuiltinType::UInt:
8116 case BuiltinType::Long:
8117 case BuiltinType::ULong:
8119 case BuiltinType::LongLong:
8120 case BuiltinType::ULongLong:
8122 case BuiltinType::Int128:
8123 case BuiltinType::UInt128:
8128 case BuiltinType::Char8:
8130 case BuiltinType::Char16:
8131 return getIntegerRank(
8133 case BuiltinType::Char32:
8134 return getIntegerRank(
8136 case BuiltinType::WChar_S:
8137 case BuiltinType::WChar_U:
8138 return getIntegerRank(
8168 uint64_t BitWidth = Field->getBitWidthValue();
8194 if (BitWidth < IntSize)
8197 if (BitWidth == IntSize)
8212 assert(!Promotable.
isNull());
8215 return ED->getPromotionType();
8224 if (BT->getKind() == BuiltinType::WChar_S ||
8225 BT->getKind() == BuiltinType::WChar_U ||
8226 BT->getKind() == BuiltinType::Char8 ||
8227 BT->getKind() == BuiltinType::Char16 ||
8228 BT->getKind() == BuiltinType::Char32) {
8229 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
8233 for (
const auto &PT : PromoteTypes) {
8235 if (FromSize < ToSize ||
8236 (FromSize == ToSize && FromIsSigned == PT->isSignedIntegerType()))
8239 llvm_unreachable(
"char type should fit into long long");
8246 uint64_t PromotableSize =
getIntWidth(Promotable);
8255 while (!
T.isNull()) {
8257 return T.getObjCLifetime();
8258 if (
T->isArrayType())
8261 T = PT->getPointeeType();
8263 T = RT->getPointeeType();
8288 if (
const auto *ET = dyn_cast<EnumType>(LHSC))
8290 if (
const auto *ET = dyn_cast<EnumType>(RHSC))
8293 if (LHSC == RHSC)
return 0;
8298 unsigned LHSRank = getIntegerRank(LHSC);
8299 unsigned RHSRank = getIntegerRank(RHSC);
8301 if (LHSUnsigned == RHSUnsigned) {
8302 if (LHSRank == RHSRank)
return 0;
8303 return LHSRank > RHSRank ? 1 : -1;
8309 if (LHSRank >= RHSRank)
8319 if (RHSRank >= LHSRank)
8329 if (CFConstantStringTypeDecl)
8330 return CFConstantStringTypeDecl;
8332 assert(!CFConstantStringTagDecl &&
8333 "tag and typedef should be initialized together");
8335 CFConstantStringTagDecl->startDefinition();
8373 if (
static_cast<unsigned>(CFRuntime) <
8376 Fields[Count++] = {
IntTy,
"flags" };
8378 Fields[Count++] = {
LongTy,
"length" };
8382 Fields[Count++] = { getFromTargetType(Target->getUInt64Type()),
"_swift_rc" };
8386 Fields[Count++] = {
IntTy,
"_ptr" };
8392 for (
unsigned i = 0; i < Count; ++i) {
8396 Fields[i].Type,
nullptr,
8399 CFConstantStringTagDecl->addDecl(Field);
8402 CFConstantStringTagDecl->completeDefinition();
8406 CFConstantStringTypeDecl =
8409 return CFConstantStringTypeDecl;
8413 if (!CFConstantStringTagDecl)
8415 return CFConstantStringTagDecl;
8425 if (ObjCSuperType.isNull()) {
8430 return ObjCSuperType;
8436 CFConstantStringTagDecl = TT->castAsRecordDecl();
8440 if (BlockDescriptorType)
8453 static const char *
const FieldNames[] = {
8458 for (
size_t i = 0; i < 2; ++i) {
8461 &
Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
8469 BlockDescriptorType = RD;
8475 if (BlockDescriptorExtendedType)
8490 static const char *
const FieldNames[] = {
8497 for (
size_t i = 0; i < 4; ++i) {
8500 &
Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
8509 BlockDescriptorExtendedType = RD;
8514 const auto *BT = dyn_cast<BuiltinType>(
T);
8523 switch (BT->getKind()) {
8524#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8525 case BuiltinType::Id: \
8527#include "clang/Basic/OpenCLImageTypes.def"
8529 case BuiltinType::OCLClkEvent:
8532 case BuiltinType::OCLEvent:
8535 case BuiltinType::OCLQueue:
8538 case BuiltinType::OCLReserveID:
8541 case BuiltinType::OCLSampler:
8560 if (!copyExpr && record->hasTrivialDestructor())
return false;
8591 llvm_unreachable(
"impossible");
8593 llvm_unreachable(
"fell out of lifetime switch!");
8601 bool &HasByrefExtendedLayout)
const {
8606 HasByrefExtendedLayout =
false;
8608 HasByrefExtendedLayout =
true;
8622 assert(Target &&
"Expected target to be initialized");
8623 const llvm::Triple &
T = Target->getTriple();
8625 if (
T.isOSWindows() &&
T.isArch64Bit())
8631 assert(Target &&
"Expected target to be initialized");
8632 const llvm::Triple &
T = Target->getTriple();
8634 if (
T.isOSWindows() &&
T.isArch64Bit())
8640 if (!ObjCInstanceTypeDecl)
8641 ObjCInstanceTypeDecl =
8643 return ObjCInstanceTypeDecl;
8649 if (
const auto *TT = dyn_cast<TypedefType>(
T))
8651 return II->isStr(
"BOOL");
8659 if (!
type->isIncompleteArrayType() &&
type->isIncompleteType())
8668 else if (
type->isArrayType())
8687 if (
First->isInlineSpecified() || !
First->isStaticDataMember())
8694 !D->isInlineSpecified() && (D->isConstexpr() ||
First->isConstexpr()))
8725 for (
auto *PI :
Decl->parameters()) {
8730 assert(sz.
isPositive() &&
"BlockExpr - Incomplete param type");
8739 ParmOffset = PtrSize;
8740 for (
auto *PVDecl :
Decl->parameters()) {
8741 QualType PType = PVDecl->getOriginalType();
8742 if (
const auto *AT =
8747 PType = PVDecl->getType();
8749 PType = PVDecl->getType();
8769 for (
auto *PI :
Decl->parameters()) {
8776 "getObjCEncodingForFunctionDecl - Incomplete param type");
8783 for (
auto *PVDecl :
Decl->parameters()) {
8784 QualType PType = PVDecl->getOriginalType();
8785 if (
const auto *AT =
8790 PType = PVDecl->getType();
8792 PType = PVDecl->getType();
8806 bool Extended)
const {
8810 ObjCEncOptions Options = ObjCEncOptions()
8811 .setExpandPointedToStructures()
8812 .setExpandStructures()
8813 .setIsOutermostType();
8815 Options.setEncodeBlockParameters().setEncodeClassNames();
8816 getObjCEncodingForTypeImpl(
T, S, Options,
nullptr);
8822 bool Extended)
const {
8827 Decl->getReturnType(), S, Extended);
8836 E =
Decl->sel_param_end(); PI != E; ++PI) {
8843 "getObjCEncodingForMethodDecl - Incomplete param type");
8851 ParmOffset = 2 * PtrSize;
8853 E =
Decl->sel_param_end(); PI != E; ++PI) {
8856 if (
const auto *AT =
8865 PType, S, Extended);
8876 const Decl *Container)
const {
8879 if (
const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
8880 for (
auto *PID : CID->property_impls())
8881 if (PID->getPropertyDecl() == PD)
8885 for (
auto *PID : OID->property_impls())
8886 if (PID->getPropertyDecl() == PD)
8920 const Decl *Container)
const {
8922 bool Dynamic =
false;
8930 SynthesizePID = PropertyImpDecl;
8934 std::string S =
"T";
8979 if (SynthesizePID) {
8996 if (BT->getKind() == BuiltinType::ULong &&
getIntWidth(PointeeTy) == 32)
8999 if (BT->getKind() == BuiltinType::Long &&
getIntWidth(PointeeTy) == 32)
9012 getObjCEncodingForTypeImpl(
T, S,
9014 .setExpandPointedToStructures()
9015 .setExpandStructures()
9016 .setIsOutermostType(),
9017 Field, NotEncodedT);
9021 std::string& S)
const {
9025 getObjCEncodingForTypeImpl(
T, S,
9027 .setExpandPointedToStructures()
9028 .setExpandStructures()
9029 .setIsOutermostType()
9030 .setEncodingProperty(),
9038 case BuiltinType::Void:
return 'v';
9039 case BuiltinType::Bool:
return 'B';
9040 case BuiltinType::Char8:
9041 case BuiltinType::Char_U:
9042 case BuiltinType::UChar:
return 'C';
9043 case BuiltinType::Char16:
9044 case BuiltinType::UShort:
return 'S';
9045 case BuiltinType::Char32:
9046 case BuiltinType::UInt:
return 'I';
9047 case BuiltinType::ULong:
9048 return C->getTargetInfo().getLongWidth() == 32 ?
'L' :
'Q';
9049 case BuiltinType::UInt128:
return 'T';
9050 case BuiltinType::ULongLong:
return 'Q';
9051 case BuiltinType::Char_S:
9052 case BuiltinType::SChar:
return 'c';
9053 case BuiltinType::Short:
return 's';
9054 case BuiltinType::WChar_S:
9055 case BuiltinType::WChar_U:
9056 case BuiltinType::Int:
return 'i';
9057 case BuiltinType::Long:
9058 return C->getTargetInfo().getLongWidth() == 32 ?
'l' :
'q';
9059 case BuiltinType::LongLong:
return 'q';
9060 case BuiltinType::Int128:
return 't';
9061 case BuiltinType::Float:
return 'f';
9062 case BuiltinType::Double:
return 'd';
9063 case BuiltinType::LongDouble:
return 'D';
9064 case BuiltinType::NullPtr:
return '*';
9066 case BuiltinType::BFloat16:
9067 case BuiltinType::Float16:
9068 case BuiltinType::Float128:
9069 case BuiltinType::Ibm128:
9070 case BuiltinType::Half:
9071 case BuiltinType::ShortAccum:
9072 case BuiltinType::Accum:
9073 case BuiltinType::LongAccum:
9074 case BuiltinType::UShortAccum:
9075 case BuiltinType::UAccum:
9076 case BuiltinType::ULongAccum:
9077 case BuiltinType::ShortFract:
9078 case BuiltinType::Fract:
9079 case BuiltinType::LongFract:
9080 case BuiltinType::UShortFract:
9081 case BuiltinType::UFract:
9082 case BuiltinType::ULongFract:
9083 case BuiltinType::SatShortAccum:
9084 case BuiltinType::SatAccum:
9085 case BuiltinType::SatLongAccum:
9086 case BuiltinType::SatUShortAccum:
9087 case BuiltinType::SatUAccum:
9088 case BuiltinType::SatULongAccum:
9089 case BuiltinType::SatShortFract:
9090 case BuiltinType::SatFract:
9091 case BuiltinType::SatLongFract:
9092 case BuiltinType::SatUShortFract:
9093 case BuiltinType::SatUFract:
9094 case BuiltinType::SatULongFract:
9098#define SVE_TYPE(Name, Id, SingletonId) \
9099 case BuiltinType::Id:
9100#include "clang/Basic/AArch64ACLETypes.def"
9101#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9102#include "clang/Basic/RISCVVTypes.def"
9103#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9104#include "clang/Basic/WebAssemblyReferenceTypes.def"
9105#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
9106#include "clang/Basic/AMDGPUTypes.def"
9110 "cannot yet @encode type %0");
9115 case BuiltinType::ObjCId:
9116 case BuiltinType::ObjCClass:
9117 case BuiltinType::ObjCSel:
9118 llvm_unreachable(
"@encoding ObjC primitive type");
9121#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
9122 case BuiltinType::Id:
9123#include "clang/Basic/OpenCLImageTypes.def"
9124#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
9125 case BuiltinType::Id:
9126#include "clang/Basic/OpenCLExtensionTypes.def"
9127 case BuiltinType::OCLEvent:
9128 case BuiltinType::OCLClkEvent:
9129 case BuiltinType::OCLQueue:
9130 case BuiltinType::OCLReserveID:
9131 case BuiltinType::OCLSampler:
9132 case BuiltinType::Dependent:
9133#define PPC_VECTOR_TYPE(Name, Id, Size) \
9134 case BuiltinType::Id:
9135#include "clang/Basic/PPCTypes.def"
9136#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
9137#include "clang/Basic/HLSLIntangibleTypes.def"
9138#define BUILTIN_TYPE(KIND, ID)
9139#define PLACEHOLDER_TYPE(KIND, ID) \
9140 case BuiltinType::KIND:
9141#include "clang/AST/BuiltinTypes.def"
9142 llvm_unreachable(
"invalid builtin type for @encode");
9144 llvm_unreachable(
"invalid BuiltinType::Kind value");
9151 if (!
Enum->isFixed())
9161 assert(FD->
isBitField() &&
"not a bitfield - getObjCEncodingForTypeImpl");
9181 if (
const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
9189 S += llvm::utostr(Offset);
9191 if (
const auto *ET =
T->getAsCanonical<EnumType>())
9204 bool VisitBasesAndFields) {
9205 T =
T->getBaseElementTypeUnsafe();
9209 PT->getPointeeType().getTypePtr(),
false);
9211 auto *CXXRD =
T->getAsCXXRecordDecl();
9219 if (!CXXRD->hasDefinition() || !VisitBasesAndFields)
9222 for (
const auto &B : CXXRD->bases())
9227 for (
auto *FD : CXXRD->fields())
9236void ASTContext::getObjCEncodingForTypeImpl(QualType
T, std::string &S,
9237 const ObjCEncOptions Options,
9238 const FieldDecl *FD,
9239 QualType *NotEncodedT)
const {
9241 switch (CT->getTypeClass()) {
9246 if (
const auto *BT = dyn_cast<BuiltinType>(CT))
9254 getObjCEncodingForTypeImpl(
T->
castAs<ComplexType>()->getElementType(), S,
9261 getObjCEncodingForTypeImpl(
T->
castAs<AtomicType>()->getValueType(), S,
9268 case Type::LValueReference:
9269 case Type::RValueReference: {
9272 const auto *PT =
T->
castAs<PointerType>();
9273 if (PT->isObjCSelType()) {
9282 bool isReadOnly =
false;
9287 if (
T->
getAs<TypedefType>()) {
9288 if (Options.IsOutermostType() &&
T.isConstQualified()) {
9292 }
else if (Options.IsOutermostType()) {
9293 QualType P = PointeeTy;
9294 while (
auto PT = P->
getAs<PointerType>())
9305 if (StringRef(S).ends_with(
"nr"))
9306 S.replace(S.end()-2, S.end(),
"rn");
9316 }
else if (
const auto *RTy = PointeeTy->
getAsCanonical<RecordType>()) {
9317 const IdentifierInfo *II = RTy->getOriginalDecl()->getIdentifier();
9319 if (II == &
Idents.get(
"objc_class")) {
9324 if (II == &
Idents.get(
"objc_object")) {
9333 RTy, Options.ExpandPointedToStructures()))) {
9342 ObjCEncOptions NewOptions;
9343 if (Options.ExpandPointedToStructures())
9344 NewOptions.setExpandStructures();
9345 getObjCEncodingForTypeImpl(PointeeTy, S, NewOptions,
9346 nullptr, NotEncodedT);
9350 case Type::ConstantArray:
9351 case Type::IncompleteArray:
9352 case Type::VariableArray: {
9359 getObjCEncodingForTypeImpl(
9360 AT->getElementType(), S,
9361 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD);
9365 if (
const auto *CAT = dyn_cast<ConstantArrayType>(AT))
9366 S += llvm::utostr(CAT->getZExtSize());
9370 "Unknown array type!");
9374 getObjCEncodingForTypeImpl(
9375 AT->getElementType(), S,
9376 Options.keepingOnly(ObjCEncOptions().setExpandStructures()), FD,
9383 case Type::FunctionNoProto:
9384 case Type::FunctionProto:
9388 case Type::Record: {
9390 S += RDecl->
isUnion() ?
'(' :
'{';
9394 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
9395 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
9396 llvm::raw_string_ostream
OS(S);
9397 printTemplateArgumentList(OS, TemplateArgs.
asArray(),
9403 if (Options.ExpandStructures()) {
9406 getObjCEncodingForStructureImpl(RDecl, S, FD,
true, NotEncodedT);
9408 for (
const auto *Field : RDecl->
fields()) {
9411 S +=
Field->getNameAsString();
9416 if (
Field->isBitField()) {
9417 getObjCEncodingForTypeImpl(
Field->getType(), S,
9418 ObjCEncOptions().setExpandStructures(),
9421 QualType qt =
Field->getType();
9423 getObjCEncodingForTypeImpl(
9425 ObjCEncOptions().setExpandStructures().setIsStructField(), FD,
9431 S += RDecl->
isUnion() ?
')' :
'}';
9435 case Type::BlockPointer: {
9436 const auto *BT =
T->
castAs<BlockPointerType>();
9438 if (Options.EncodeBlockParameters()) {
9439 const auto *FT = BT->getPointeeType()->castAs<FunctionType>();
9443 getObjCEncodingForTypeImpl(FT->getReturnType(), S,
9444 Options.forComponentType(), FD, NotEncodedT);
9448 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
9449 for (
const auto &I : FPT->param_types())
9450 getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,
9458 case Type::ObjCObject: {
9462 S +=
"{objc_object=}";
9466 S +=
"{objc_class=}";
9473 case Type::ObjCInterface: {
9476 ObjCInterfaceDecl *OI =
T->
castAs<ObjCObjectType>()->getInterface();
9479 if (Options.ExpandStructures()) {
9481 SmallVector<const ObjCIvarDecl*, 32> Ivars;
9483 for (
unsigned i = 0, e = Ivars.size(); i != e; ++i) {
9484 const FieldDecl *
Field = Ivars[i];
9485 if (
Field->isBitField())
9486 getObjCEncodingForTypeImpl(
Field->getType(), S,
9487 ObjCEncOptions().setExpandStructures(),
9490 getObjCEncodingForTypeImpl(
Field->getType(), S,
9491 ObjCEncOptions().setExpandStructures(), FD,
9499 case Type::ObjCObjectPointer: {
9500 const auto *OPT =
T->
castAs<ObjCObjectPointerType>();
9501 if (OPT->isObjCIdType()) {
9506 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
9514 if (OPT->isObjCQualifiedIdType()) {
9515 getObjCEncodingForTypeImpl(
9517 Options.keepingOnly(ObjCEncOptions()
9518 .setExpandPointedToStructures()
9519 .setExpandStructures()),
9521 if (FD || Options.EncodingProperty() || Options.EncodeClassNames()) {
9525 for (
const auto *I : OPT->quals()) {
9527 S += I->getObjCRuntimeNameAsString();
9536 if (OPT->getInterfaceDecl() &&
9537 (FD || Options.EncodingProperty() || Options.EncodeClassNames())) {
9539 S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
9540 for (
const auto *I : OPT->quals()) {
9542 S += I->getObjCRuntimeNameAsString();
9552 case Type::MemberPointer:
9556 case Type::ExtVector:
9562 case Type::ConstantMatrix:
9575 case Type::DeducedTemplateSpecialization:
9578 case Type::HLSLAttributedResource:
9579 case Type::HLSLInlineSpirv:
9580 llvm_unreachable(
"unexpected type");
9582 case Type::ArrayParameter:
9584#define ABSTRACT_TYPE(KIND, BASE)
9585#define TYPE(KIND, BASE)
9586#define DEPENDENT_TYPE(KIND, BASE) \
9588#define NON_CANONICAL_TYPE(KIND, BASE) \
9590#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
9592#include "clang/AST/TypeNodes.inc"
9593 llvm_unreachable(
"@encode for dependent type!");
9595 llvm_unreachable(
"bad type kind!");
9598void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
9600 const FieldDecl *FD,
9602 QualType *NotEncodedT)
const {
9603 assert(RDecl &&
"Expected non-null RecordDecl");
9604 assert(!RDecl->
isUnion() &&
"Should not be called for unions");
9608 const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
9609 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
9613 for (
const auto &BI : CXXRec->bases()) {
9614 if (!BI.isVirtual()) {
9619 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9620 std::make_pair(offs, base));
9625 for (FieldDecl *Field : RDecl->
fields()) {
9626 if (!
Field->isZeroLengthBitField() &&
Field->isZeroSize(*
this))
9629 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9630 std::make_pair(offs, Field));
9633 if (CXXRec && includeVBases) {
9634 for (
const auto &BI : CXXRec->vbases()) {
9640 FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
9641 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
9642 std::make_pair(offs, base));
9656 std::multimap<uint64_t, NamedDecl *>::iterator
9657 CurLayObj = FieldOrBaseOffsets.begin();
9659 if (CXXRec && CXXRec->isDynamicClass() &&
9660 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
9663 std::string recname = CXXRec->getNameAsString();
9664 if (recname.empty()) recname =
"?";
9677 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
9678 std::make_pair(offs,
nullptr));
9681 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
9683 assert(CurOffs <= CurLayObj->first);
9684 if (CurOffs < CurLayObj->first) {
9685 uint64_t padding = CurLayObj->first - CurOffs;
9697 NamedDecl *dcl = CurLayObj->second;
9701 if (
auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
9706 getObjCEncodingForStructureImpl(base, S, FD,
false,
9716 S += field->getNameAsString();
9720 if (field->isBitField()) {
9723 CurOffs += field->getBitWidthValue();
9726 QualType qt = field->getType();
9728 getObjCEncodingForTypeImpl(
9729 qt, S, ObjCEncOptions().setExpandStructures().setIsStructField(),
9740 std::string& S)
const {
9773 if (!ObjCClassDecl) {
9778 return ObjCClassDecl;
9782 if (!ObjCProtocolClassDecl) {
9783 ObjCProtocolClassDecl
9792 return ObjCProtocolClassDecl;
9813 QualType T = Context->getPointerType(Context->CharTy);
9814 return Context->buildImplicitTypedef(
T, Name);
9827 QualType T = Context->getPointerType(Context->VoidTy);
9828 return Context->buildImplicitTypedef(
T,
"__builtin_va_list");
9835 if (Context->getLangOpts().CPlusPlus) {
9840 &Context->Idents.get(
"std"),
9848 const size_t NumFields = 5;
9850 const char *FieldNames[NumFields];
9853 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
9854 FieldNames[0] =
"__stack";
9857 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
9858 FieldNames[1] =
"__gr_top";
9861 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
9862 FieldNames[2] =
"__vr_top";
9865 FieldTypes[3] = Context->IntTy;
9866 FieldNames[3] =
"__gr_offs";
9869 FieldTypes[4] = Context->IntTy;
9870 FieldNames[4] =
"__vr_offs";
9873 for (
unsigned i = 0; i < NumFields; ++i) {
9878 &Context->Idents.get(FieldNames[i]),
9879 FieldTypes[i],
nullptr,
9891 return Context->buildImplicitTypedef(VaListTagType,
"__builtin_va_list");
9898 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
9901 const size_t NumFields = 5;
9903 const char *FieldNames[NumFields];
9906 FieldTypes[0] = Context->UnsignedCharTy;
9907 FieldNames[0] =
"gpr";
9910 FieldTypes[1] = Context->UnsignedCharTy;
9911 FieldNames[1] =
"fpr";
9914 FieldTypes[2] = Context->UnsignedShortTy;
9915 FieldNames[2] =
"reserved";
9918 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
9919 FieldNames[3] =
"overflow_arg_area";
9922 FieldTypes[4] = Context->getPointerType(Context->VoidTy);
9923 FieldNames[4] =
"reg_save_area";
9926 for (
unsigned i = 0; i < NumFields; ++i) {
9930 &Context->Idents.get(FieldNames[i]),
9931 FieldTypes[i],
nullptr,
9944 Context->buildImplicitTypedef(VaListTagType,
"__va_list_tag");
9948 std::nullopt, VaListTagTypedefDecl);
9951 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
9952 QualType VaListTagArrayType = Context->getConstantArrayType(
9954 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
9961 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
9964 const size_t NumFields = 4;
9966 const char *FieldNames[NumFields];
9969 FieldTypes[0] = Context->UnsignedIntTy;
9970 FieldNames[0] =
"gp_offset";
9973 FieldTypes[1] = Context->UnsignedIntTy;
9974 FieldNames[1] =
"fp_offset";
9977 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
9978 FieldNames[2] =
"overflow_arg_area";
9981 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
9982 FieldNames[3] =
"reg_save_area";
9985 for (
unsigned i = 0; i < NumFields; ++i) {
9990 &Context->Idents.get(FieldNames[i]),
9991 FieldTypes[i],
nullptr,
10005 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10006 QualType VaListTagArrayType = Context->getConstantArrayType(
10008 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10011static TypedefDecl *
10014 RecordDecl *VaListDecl = Context->buildImplicitRecord(
"__va_list");
10015 if (Context->getLangOpts().CPlusPlus) {
10034 &Context->Idents.get(
"__ap"),
10035 Context->getPointerType(Context->VoidTy),
10045 Context->VaListTagDecl = VaListDecl;
10048 CanQualType T = Context->getCanonicalTagType(VaListDecl);
10049 return Context->buildImplicitTypedef(
T,
"__builtin_va_list");
10052static TypedefDecl *
10056 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
10059 const size_t NumFields = 4;
10061 const char *FieldNames[NumFields];
10064 FieldTypes[0] = Context->LongTy;
10065 FieldNames[0] =
"__gpr";
10068 FieldTypes[1] = Context->LongTy;
10069 FieldNames[1] =
"__fpr";
10072 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
10073 FieldNames[2] =
"__overflow_arg_area";
10076 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
10077 FieldNames[3] =
"__reg_save_area";
10080 for (
unsigned i = 0; i < NumFields; ++i) {
10085 &Context->Idents.get(FieldNames[i]),
10086 FieldTypes[i],
nullptr,
10100 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10101 QualType VaListTagArrayType = Context->getConstantArrayType(
10104 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10110 VaListTagDecl = Context->buildImplicitRecord(
"__va_list_tag");
10113 const size_t NumFields = 3;
10115 const char *FieldNames[NumFields];
10118 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
10119 FieldNames[0] =
"__current_saved_reg_area_pointer";
10122 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
10123 FieldNames[1] =
"__saved_reg_area_end_pointer";
10126 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
10127 FieldNames[2] =
"__overflow_area_pointer";
10130 for (
unsigned i = 0; i < NumFields; ++i) {
10133 SourceLocation(), &Context->Idents.get(FieldNames[i]), FieldTypes[i],
10146 Context->buildImplicitTypedef(VaListTagType,
"__va_list_tag");
10150 std::nullopt, VaListTagTypedefDecl);
10153 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
10154 QualType VaListTagArrayType = Context->getConstantArrayType(
10157 return Context->buildImplicitTypedef(VaListTagArrayType,
"__builtin_va_list");
10160static TypedefDecl *
10170 constexpr size_t NumFields = 3;
10171 QualType FieldTypes[NumFields] = {Context->getPointerType(Context->IntTy),
10172 Context->getPointerType(Context->IntTy),
10174 const char *FieldNames[NumFields] = {
"__va_stk",
"__va_reg",
"__va_ndx"};
10177 for (
unsigned i = 0; i < NumFields; ++i) {
10180 &Context->Idents.get(FieldNames[i]), FieldTypes[i],
nullptr,
10192 Context->buildImplicitTypedef(VaListTagType,
"__builtin_va_list");
10194 return VaListTagTypedefDecl;
10220 llvm_unreachable(
"Unhandled __builtin_va_list type kind");
10224 if (!BuiltinVaListDecl) {
10225 BuiltinVaListDecl =
CreateVaListDecl(
this, Target->getBuiltinVaListKind());
10226 assert(BuiltinVaListDecl->isImplicit());
10229 return BuiltinVaListDecl;
10242 if (!BuiltinMSVaListDecl)
10245 return BuiltinMSVaListDecl;
10262 assert(ObjCConstantStringType.isNull() &&
10263 "'NSConstantString' type already set!");
10273 unsigned size = End - Begin;
10274 assert(size > 1 &&
"set is not overloaded!");
10280 NamedDecl **Storage = OT->getStorage();
10303 bool TemplateKeyword,
10308 if (
Template.getAsTemplateDecl()->getKind() == Decl::TemplateTemplateParm) {
10309 assert(!Qualifier &&
"unexpected qualified template template parameter");
10310 assert(TemplateKeyword ==
false);
10315 llvm::FoldingSetNodeID ID;
10318 void *InsertPos =
nullptr;
10320 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
10324 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
10334 llvm::FoldingSetNodeID ID;
10337 void *InsertPos =
nullptr;
10339 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos))
10344 DependentTemplateNames.InsertNode(QTN, InsertPos);
10349 Decl *AssociatedDecl,
10352 bool Final)
const {
10353 llvm::FoldingSetNodeID ID;
10355 Index, PackIndex, Final);
10357 void *insertPos =
nullptr;
10359 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
10363 Replacement, AssociatedDecl, Index, PackIndex, Final);
10364 SubstTemplateTemplateParms.InsertNode(subst, insertPos);
10372 Decl *AssociatedDecl,
10373 unsigned Index,
bool Final)
const {
10375 llvm::FoldingSetNodeID ID;
10377 AssociatedDecl, Index, Final);
10379 void *InsertPos =
nullptr;
10381 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
10386 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
10400 llvm::FoldingSetNodeID ID;
10403 void *InsertPos =
nullptr;
10405 DeducedTemplates.FindNodeOrInsertPos(ID, InsertPos);
10411 DeducedTemplates.InsertNode(DTS, InsertPos);
10434 llvm_unreachable(
"Unhandled TargetInfo::IntType value");
10464 while (
const auto *AT = dyn_cast<ArrayType>(CT))
10465 CT = AT->getElementType();
10497 assert(FirstVec->
isVectorType() &&
"FirstVec should be a vector type");
10498 assert(SecondVec->
isVectorType() &&
"SecondVec should be a vector type");
10535 auto VScale = Context.getTargetInfo().getVScaleRange(
10542 uint64_t EltSize = Context.getTypeSize(Info.
ElementType);
10546 uint64_t MinElts = Info.
EC.getKnownMinValue();
10547 return VScale->first * MinElts * EltSize;
10555 "Expected RVV builtin type and vector type!");
10595 return IsValidCast(FirstType, SecondType) ||
10596 IsValidCast(SecondType, FirstType);
10604 "Expected RVV builtin type and vector type!");
10611 if (!BT->isRVVVLSBuiltinType())
10631 return VecTy->getElementType().getCanonicalType()->isIntegerType() &&
10638 return IsLaxCompatible(FirstType, SecondType) ||
10639 IsLaxCompatible(SecondType, FirstType);
10645 if (
const AttributedType *
Attr = dyn_cast<AttributedType>(Ty)) {
10646 if (
Attr->getAttrKind() == attr::ObjCOwnership)
10649 Ty =
Attr->getModifiedType();
10653 Ty =
Paren->getInnerType();
10685 for (
auto *lhsProto : lhs->
quals()) {
10686 bool match =
false;
10687 for (
auto *rhsProto : rhs->
quals()) {
10718 for (
auto *I : lhs->
quals()) {
10722 if (!rhsID->ClassImplementsProtocol(I,
true))
10730 for (
auto *lhsProto : lhs->
quals()) {
10731 bool match =
false;
10736 for (
auto *rhsProto : rhs->
quals()) {
10746 for (
auto *I : lhs->
quals()) {
10750 if (rhsID->ClassImplementsProtocol(I,
true)) {
10767 for (
auto *lhsProto : lhs->
quals()) {
10768 bool match =
false;
10775 for (
auto *rhsProto : rhs->
quals()) {
10794 if (LHSInheritedProtocols.empty() && lhs->
qual_empty())
10796 for (
auto *lhsProto : LHSInheritedProtocols) {
10797 bool match =
false;
10798 for (
auto *rhsProto : rhs->
quals()) {
10823 if (LHS->isObjCUnqualifiedId() || RHS->isObjCUnqualifiedId())
10828 auto finish = [&](
bool succeeded) ->
bool {
10832 if (!RHS->isKindOfType())
10843 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
10848 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
10853 if (LHS->isObjCClass() && RHS->isObjCClass()) {
10858 if (LHS->getInterface() && RHS->getInterface()) {
10873 bool BlockReturnType) {
10877 auto finish = [&](
bool succeeded) ->
bool {
10902 if (
getLangOpts().CompatibilityQualifiedIdBlockParamTypeChecking)
10906 (!BlockReturnType &&
10910 (BlockReturnType ? LHSOPT : RHSOPT),
10911 (BlockReturnType ? RHSOPT : LHSOPT),
false));
10919 return finish(BlockReturnType);
10921 return finish(!BlockReturnType);
10933 return (*lhs)->getName().compare((*rhs)->getName());
10950 assert(LHS->getInterface() &&
"LHS must have an interface base");
10951 assert(RHS->getInterface() &&
"RHS must have an interface base");
10957 for (
auto *proto : LHS->quals()) {
10958 Context.CollectInheritedProtocols(proto, LHSProtocolSet);
10962 Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
10968 for (
auto *proto : RHS->quals()) {
10969 Context.CollectInheritedProtocols(proto, RHSProtocolSet);
10973 Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
10976 for (
auto *proto : LHSProtocolSet) {
10977 if (RHSProtocolSet.count(proto))
10978 IntersectionSet.push_back(proto);
10984 Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
10987 if (!ImpliedProtocols.empty()) {
10989 return ImpliedProtocols.contains(proto);
10994 llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
11004 if (lhsOPT && rhsOPT)
11010 if (lhsBlock && rhsBlock)
11015 if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
11027 bool stripKindOf) {
11028 if (lhsArgs.size() != rhsArgs.size())
11035 for (
unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
11041 if (!stripKindOf ||
11042 !ctx.
hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
11043 rhsArgs[i].stripObjCKindOfType(ctx))) {
11071 if (!LDecl || !RDecl)
11077 bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();
11081 llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
11086 LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
11091 bool anyChanges =
false;
11092 if (LHS->isSpecialized() && RHS->isSpecialized()) {
11095 LHS->getTypeArgs(), RHS->getTypeArgs(),
11098 }
else if (LHS->isSpecialized() != RHS->isSpecialized()) {
11109 if (!Protocols.empty())
11115 if (anyChanges || LHS->isKindOfType() != anyKindOf) {
11118 anyKindOf || LHS->isKindOfType());
11126 QualType LHSSuperType = LHS->getSuperClassType();
11127 if (LHSSuperType.
isNull())
11136 auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
11137 if (KnownLHS != LHSAncestors.end()) {
11138 LHS = KnownLHS->second;
11142 bool anyChanges =
false;
11143 if (LHS->isSpecialized() && RHS->isSpecialized()) {
11146 LHS->getTypeArgs(), RHS->getTypeArgs(),
11149 }
else if (LHS->isSpecialized() != RHS->isSpecialized()) {
11160 if (!Protocols.empty())
11165 if (anyChanges || RHS->isKindOfType() != anyKindOf) {
11168 anyKindOf || RHS->isKindOfType());
11176 QualType RHSSuperType = RHS->getSuperClassType();
11177 if (RHSSuperType.
isNull())
11188 assert(LHS->getInterface() &&
"LHS is not an interface type");
11189 assert(RHS->getInterface() &&
"RHS is not an interface type");
11194 bool IsSuperClass = LHSInterface->
isSuperClassOf(RHS->getInterface());
11201 if (LHS->getNumProtocols() > 0) {
11210 for (
auto *RHSPI : RHS->quals())
11213 if (SuperClassInheritedProtocols.empty())
11216 for (
const auto *LHSProto : LHS->quals()) {
11217 bool SuperImplementsProtocol =
false;
11218 for (
auto *SuperClassProto : SuperClassInheritedProtocols)
11219 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
11220 SuperImplementsProtocol =
true;
11223 if (!SuperImplementsProtocol)
11229 if (LHS->isSpecialized()) {
11234 RHSSuper = RHSSuper->getSuperClassType()->castAs<
ObjCObjectType>();
11237 if (RHSSuper->isSpecialized() &&
11239 LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
11253 if (!LHSOPT || !RHSOPT)
11271 bool CompareUnqualified) {
11290 bool OfBlockPointer,
11292 if (
const RecordType *UT =
T->getAsUnionType()) {
11294 if (UD->
hasAttr<TransparentUnionAttr>()) {
11295 for (
const auto *I : UD->
fields()) {
11296 QualType ET = I->getType().getUnqualifiedType();
11310 bool OfBlockPointer,
11331 bool IsConditionalOperator) {
11334 const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
11335 const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
11336 bool allLTypes =
true;
11337 bool allRTypes =
true;
11341 if (OfBlockPointer) {
11343 QualType LHS = lbase->getReturnType();
11345 if (!UnqualifiedResult)
11347 retType =
mergeTypes(LHS, RHS,
true, UnqualifiedResult,
true);
11412 bool NoReturn = IsConditionalOperator
11422 std::optional<FunctionEffectSet> MergedFX;
11424 if (lproto && rproto) {
11425 assert((AllowCXX ||
11426 (!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec())) &&
11427 "C++ shouldn't be here");
11429 if (lproto->getNumParams() != rproto->getNumParams())
11433 if (lproto->isVariadic() != rproto->isVariadic())
11436 if (lproto->getMethodQuals() != rproto->getMethodQuals())
11440 if (lproto->getExtraAttributeInfo().CFISalt !=
11441 rproto->getExtraAttributeInfo().CFISalt)
11447 if (LHSFX != RHSFX) {
11448 if (IsConditionalOperator)
11457 if (*MergedFX != LHSFX)
11459 if (*MergedFX != RHSFX)
11464 bool canUseLeft, canUseRight;
11476 for (
unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
11477 QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
11478 QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
11480 lParamType, rParamType, OfBlockPointer,
Unqualified);
11487 types.push_back(paramType);
11499 if (allLTypes)
return lhs;
11500 if (allRTypes)
return rhs;
11505 newParamInfos.empty() ?
nullptr : newParamInfos.data();
11511 if (lproto) allRTypes =
false;
11512 if (rproto) allLTypes =
false;
11516 assert((AllowCXX || !proto->
hasExceptionSpec()) &&
"C++ shouldn't be here");
11524 for (
unsigned i = 0, n = proto->
getNumParams(); i < n; ++i) {
11530 paramTy = ED->getIntegerType();
11540 if (allLTypes)
return lhs;
11541 if (allRTypes)
return rhs;
11550 if (allLTypes)
return lhs;
11551 if (allRTypes)
return rhs;
11557 QualType other,
bool isBlockReturnType) {
11563 ET->getOriginalDecl()->getDefinitionOrSelf()->getIntegerType();
11564 if (underlyingType.
isNull())
11566 if (Context.hasSameType(underlyingType, other))
11572 Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
11581 if (LangOpts.CPlusPlus || !LangOpts.C23)
11596 bool IsConditionalOperator) {
11607 if (LangOpts.OpenMP && LHSRefTy && RHSRefTy &&
11611 if (LHSRefTy || RHSRefTy)
11623 if (LHSCan == RHSCan)
11628 Qualifiers RQuals = RHSCan.getLocalQualifiers();
11629 if (LQuals != RQuals) {
11646 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
11667 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
11668 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
11671 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
11672 LHSClass = Type::ConstantArray;
11673 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
11674 RHSClass = Type::ConstantArray;
11677 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
11678 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
11681 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
11682 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
11685 if (LHSClass != RHSClass) {
11695 if (OfBlockPointer && !BlockReturnType) {
11703 if (
const auto *AT = LHS->
getAs<AutoType>()) {
11704 if (!AT->isDeduced() && AT->isGNUAutoType())
11707 if (
const auto *AT = RHS->
getAs<AutoType>()) {
11708 if (!AT->isDeduced() && AT->isGNUAutoType())
11715 switch (LHSClass) {
11716#define TYPE(Class, Base)
11717#define ABSTRACT_TYPE(Class, Base)
11718#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
11719#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
11720#define DEPENDENT_TYPE(Class, Base) case Type::Class:
11721#include "clang/AST/TypeNodes.inc"
11722 llvm_unreachable(
"Non-canonical and dependent types shouldn't get here");
11725 case Type::DeducedTemplateSpecialization:
11726 case Type::LValueReference:
11727 case Type::RValueReference:
11728 case Type::MemberPointer:
11729 llvm_unreachable(
"C++ should never be in mergeTypes");
11731 case Type::ObjCInterface:
11732 case Type::IncompleteArray:
11733 case Type::VariableArray:
11734 case Type::FunctionProto:
11735 case Type::ExtVector:
11736 llvm_unreachable(
"Types are eliminated above");
11738 case Type::Pointer:
11749 if (ResultType.
isNull())
11757 case Type::BlockPointer:
11782 if (ResultType.
isNull())
11801 if (ResultType.
isNull())
11809 case Type::ConstantArray:
11824 if (ResultType.
isNull())
11832 if (LVAT || RVAT) {
11835 -> std::pair<bool,llvm::APInt> {
11837 std::optional<llvm::APSInt> TheInt;
11840 return std::make_pair(
true, *TheInt);
11841 return std::make_pair(
false, llvm::APSInt());
11844 return std::make_pair(
true, CAT->getSize());
11845 return std::make_pair(
false, llvm::APInt());
11848 bool HaveLSize, HaveRSize;
11849 llvm::APInt LSize, RSize;
11850 std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
11851 std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
11852 if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
11886 case Type::FunctionNoProto:
11888 false, IsConditionalOperator);
11892 case Type::Builtin:
11895 case Type::Complex:
11904 case Type::ConstantMatrix:
11909 case Type::ObjCObject: {
11918 case Type::ObjCObjectPointer:
11919 if (OfBlockPointer) {
11931 assert(LHS != RHS &&
11932 "Equivalent pipe types should have already been handled!");
11934 case Type::ArrayParameter:
11935 assert(LHS != RHS &&
11936 "Equivalent ArrayParameter types should have already been handled!");
11938 case Type::BitInt: {
11946 if (LHSUnsigned != RHSUnsigned)
11949 if (LHSBits != RHSBits)
11953 case Type::HLSLAttributedResource: {
11954 const HLSLAttributedResourceType *LHSTy =
11955 LHS->
castAs<HLSLAttributedResourceType>();
11956 const HLSLAttributedResourceType *RHSTy =
11957 RHS->
castAs<HLSLAttributedResourceType>();
11958 assert(LHSTy->getWrappedType() == RHSTy->getWrappedType() &&
11959 LHSTy->getWrappedType()->isHLSLResourceType() &&
11960 "HLSLAttributedResourceType should always wrap __hlsl_resource_t");
11962 if (LHSTy->getAttrs() == RHSTy->getAttrs() &&
11963 LHSTy->getContainedType() == RHSTy->getContainedType())
11967 case Type::HLSLInlineSpirv:
11968 const HLSLInlineSpirvType *LHSTy = LHS->
castAs<HLSLInlineSpirvType>();
11969 const HLSLInlineSpirvType *RHSTy = RHS->
castAs<HLSLInlineSpirvType>();
11971 if (LHSTy->getOpcode() == RHSTy->getOpcode() &&
11972 LHSTy->getSize() == RHSTy->getSize() &&
11973 LHSTy->getAlignment() == RHSTy->getAlignment()) {
11974 for (
size_t I = 0; I < LHSTy->getOperands().size(); I++)
11975 if (LHSTy->getOperands()[I] != RHSTy->getOperands()[I])
11983 llvm_unreachable(
"Invalid Type::Class!");
11988 bool &CanUseFirst,
bool &CanUseSecond,
11990 assert(NewParamInfos.empty() &&
"param info list not empty");
11991 CanUseFirst = CanUseSecond =
true;
11997 if (!FirstHasInfo && !SecondHasInfo)
12000 bool NeedParamInfo =
false;
12004 for (
size_t I = 0; I < E; ++I) {
12015 bool FirstNoEscape = FirstParam.
isNoEscape();
12016 bool SecondNoEscape = SecondParam.
isNoEscape();
12017 bool IsNoEscape = FirstNoEscape && SecondNoEscape;
12019 if (NewParamInfos.back().getOpaqueValue())
12020 NeedParamInfo =
true;
12021 if (FirstNoEscape != IsNoEscape)
12022 CanUseFirst =
false;
12023 if (SecondNoEscape != IsNoEscape)
12024 CanUseSecond =
false;
12027 if (!NeedParamInfo)
12028 NewParamInfos.clear();
12034 if (
auto It = ObjCLayouts.find(D); It != ObjCLayouts.end()) {
12035 It->second =
nullptr;
12036 for (
auto *SubClass : ObjCSubClasses[D])
12048 if (LHSCan == RHSCan)
12050 if (RHSCan->isFunctionType()) {
12059 if (ResReturnType.
isNull())
12061 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
12078 Qualifiers RQuals = RHSCan.getLocalQualifiers();
12079 if (LQuals != RQuals) {
12092 assert((GC_L != GC_R) &&
"unequal qualifier sets had only equal elements");
12108 if (ResQT == LHSBaseQT)
12110 if (ResQT == RHSBaseQT)
12121 if (
const auto *ED =
T->getAsEnumDecl())
12122 T = ED->getIntegerType();
12123 if (
T->isBooleanType())
12126 return EIT->getNumBits();
12132 assert((
T->hasIntegerRepresentation() ||
T->isEnumeralType() ||
12133 T->isFixedPointType()) &&
12134 "Unexpected type");
12139 VTy->getNumElements(), VTy->getVectorKind());
12147 if (
const auto *ED =
T->getAsEnumDecl())
12148 T = ED->getIntegerType();
12151 case BuiltinType::Char_U:
12153 case BuiltinType::Char_S:
12154 case BuiltinType::SChar:
12155 case BuiltinType::Char8:
12157 case BuiltinType::Short:
12159 case BuiltinType::Int:
12161 case BuiltinType::Long:
12163 case BuiltinType::LongLong:
12165 case BuiltinType::Int128:
12170 case BuiltinType::WChar_S:
12173 case BuiltinType::ShortAccum:
12175 case BuiltinType::Accum:
12177 case BuiltinType::LongAccum:
12179 case BuiltinType::SatShortAccum:
12181 case BuiltinType::SatAccum:
12183 case BuiltinType::SatLongAccum:
12185 case BuiltinType::ShortFract:
12187 case BuiltinType::Fract:
12189 case BuiltinType::LongFract:
12191 case BuiltinType::SatShortFract:
12193 case BuiltinType::SatFract:
12195 case BuiltinType::SatLongFract:
12198 assert((
T->hasUnsignedIntegerRepresentation() ||
12199 T->isUnsignedFixedPointType()) &&
12200 "Unexpected signed integer or fixed point type");
12206 assert((
T->hasIntegerRepresentation() ||
T->isEnumeralType() ||
12207 T->isFixedPointType()) &&
12208 "Unexpected type");
12213 VTy->getNumElements(), VTy->getVectorKind());
12221 if (
const auto *ED =
T->getAsEnumDecl())
12222 T = ED->getIntegerType();
12225 case BuiltinType::Char_S:
12227 case BuiltinType::Char_U:
12228 case BuiltinType::UChar:
12229 case BuiltinType::Char8:
12231 case BuiltinType::UShort:
12233 case BuiltinType::UInt:
12235 case BuiltinType::ULong:
12237 case BuiltinType::ULongLong:
12239 case BuiltinType::UInt128:
12244 case BuiltinType::WChar_U:
12247 case BuiltinType::UShortAccum:
12249 case BuiltinType::UAccum:
12251 case BuiltinType::ULongAccum:
12253 case BuiltinType::SatUShortAccum:
12255 case BuiltinType::SatUAccum:
12257 case BuiltinType::SatULongAccum:
12259 case BuiltinType::UShortFract:
12261 case BuiltinType::UFract:
12263 case BuiltinType::ULongFract:
12265 case BuiltinType::SatUShortFract:
12267 case BuiltinType::SatUFract:
12269 case BuiltinType::SatULongFract:
12273 (
T->hasSignedIntegerRepresentation() ||
T->isSignedFixedPointType()) &&
12274 "Unexpected signed integer or fixed point type");
12299 bool AllowTypeModifiers) {
12303 RequiresICE =
false;
12308 bool IsSpecial =
false;
12312 default: Done =
true; --Str;
break;
12314 RequiresICE =
true;
12317 assert(!
Unsigned &&
"Can't use both 'S' and 'U' modifiers!");
12318 assert(!
Signed &&
"Can't use 'S' modifier multiple times!");
12322 assert(!
Signed &&
"Can't use both 'S' and 'U' modifiers!");
12323 assert(!
Unsigned &&
"Can't use 'U' modifier multiple times!");
12327 assert(!IsSpecial &&
"Can't use 'L' with 'W', 'N', 'Z' or 'O' modifiers");
12328 assert(HowLong <= 2 &&
"Can't have LLLL modifier");
12333 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12334 assert(HowLong == 0 &&
"Can't use both 'L' and 'N' modifiers!");
12338 if (Context.getTargetInfo().getLongWidth() == 32)
12343 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12344 assert(HowLong == 0 &&
"Can't use both 'L' and 'W' modifiers!");
12348 switch (Context.getTargetInfo().getInt64Type()) {
12350 llvm_unreachable(
"Unexpected integer type");
12361 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12362 assert(HowLong == 0 &&
"Can't use both 'L' and 'Z' modifiers!");
12366 switch (Context.getTargetInfo().getIntTypeByWidth(32,
true)) {
12368 llvm_unreachable(
"Unexpected integer type");
12381 assert(!IsSpecial &&
"Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
12382 assert(HowLong == 0 &&
"Can't use both 'L' and 'O' modifiers!");
12386 if (Context.getLangOpts().OpenCL)
12398 default: llvm_unreachable(
"Unknown builtin type letter!");
12401 "Bad modifiers used with 'x'!");
12402 Type = Context.Float16Ty;
12406 "Bad modifiers used with 'y'!");
12407 Type = Context.BFloat16Ty;
12411 "Bad modifiers used with 'v'!");
12412 Type = Context.VoidTy;
12416 "Bad modifiers used with 'h'!");
12417 Type = Context.HalfTy;
12421 "Bad modifiers used with 'f'!");
12422 Type = Context.FloatTy;
12426 "Bad modifiers used with 'd'!");
12428 Type = Context.LongDoubleTy;
12429 else if (HowLong == 2)
12430 Type = Context.Float128Ty;
12432 Type = Context.DoubleTy;
12435 assert(HowLong == 0 &&
"Bad modifiers used with 's'!");
12437 Type = Context.UnsignedShortTy;
12439 Type = Context.ShortTy;
12443 Type =
Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
12444 else if (HowLong == 2)
12445 Type =
Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
12446 else if (HowLong == 1)
12447 Type =
Unsigned ? Context.UnsignedLongTy : Context.LongTy;
12449 Type =
Unsigned ? Context.UnsignedIntTy : Context.IntTy;
12452 assert(HowLong == 0 &&
"Bad modifiers used with 'c'!");
12454 Type = Context.SignedCharTy;
12456 Type = Context.UnsignedCharTy;
12458 Type = Context.CharTy;
12461 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'b'!");
12462 Type = Context.BoolTy;
12465 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'z'!");
12466 Type = Context.getSizeType();
12469 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'w'!");
12470 Type = Context.getWideCharType();
12473 Type = Context.getCFConstantStringType();
12476 Type = Context.getObjCIdType();
12479 Type = Context.getObjCSelType();
12482 Type = Context.getObjCSuperType();
12485 Type = Context.getBuiltinVaListType();
12486 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12497 Type = Context.getBuiltinVaListType();
12498 assert(!
Type.isNull() &&
"builtin va list type not initialized!");
12500 Type = Context.getArrayDecayedType(
Type);
12502 Type = Context.getLValueReferenceType(
Type);
12506 unsigned NumElements = strtoul(Str, &End, 10);
12507 assert(End != Str &&
"Missing vector size");
12511 RequiresICE,
false);
12512 assert(!RequiresICE &&
"Can't require vector ICE");
12514 Type = Context.getScalableVectorType(ElementType, NumElements);
12520 Type = Context.SveCountTy;
12524 Type = Context.AMDGPUBufferRsrcTy;
12528 Type = Context.AMDGPUTextureTy;
12532 llvm_unreachable(
"Unexpected target builtin type");
12538 unsigned NumElements = strtoul(Str, &End, 10);
12539 assert(End != Str &&
"Missing vector size");
12543 RequiresICE,
false);
12544 assert(!RequiresICE &&
"Can't require vector ICE");
12553 unsigned NumElements = strtoul(Str, &End, 10);
12554 assert(End != Str &&
"Missing vector size");
12560 Type = Context.getExtVectorType(ElementType, NumElements);
12566 assert(!RequiresICE &&
"Can't require complex ICE");
12567 Type = Context.getComplexType(ElementType);
12571 Type = Context.getPointerDiffType();
12574 Type = Context.getFILEType();
12575 if (
Type.isNull()) {
12582 Type = Context.getsigjmp_bufType();
12584 Type = Context.getjmp_bufType();
12586 if (
Type.isNull()) {
12592 assert(HowLong == 0 && !
Signed && !
Unsigned &&
"Bad modifiers for 'K'!");
12593 Type = Context.getucontext_tType();
12595 if (
Type.isNull()) {
12601 Type = Context.getProcessIDType();
12604 Type = Context.MFloat8Ty;
12609 Done = !AllowTypeModifiers;
12611 switch (
char c = *Str++) {
12612 default: Done =
true; --Str;
break;
12618 unsigned AddrSpace = strtoul(Str, &End, 10);
12621 Type = Context.getAddrSpaceQualType(
12623 Context.getLangASForBuiltinAddressSpace(AddrSpace));
12627 Type = Context.getPointerType(
Type);
12629 Type = Context.getLValueReferenceType(
Type);
12637 Type = Context.getVolatileType(
Type);
12646 "Integer constant 'I' type must be an integer");
12659 bool AllowTypeModifiers)
const {
12666 unsigned *IntegerConstantArgs)
const {
12667 const char *TypeStr =
BuiltinInfo.getTypeString(Id);
12668 if (TypeStr[0] ==
'\0') {
12675 bool RequiresICE =
false;
12678 RequiresICE,
true);
12682 assert(!RequiresICE &&
"Result of intrinsic cannot be required to be an ICE");
12684 while (TypeStr[0] && TypeStr[0] !=
'.') {
12691 if (RequiresICE && IntegerConstantArgs)
12692 *IntegerConstantArgs |= 1 << ArgTypes.size();
12698 ArgTypes.push_back(Ty);
12701 if (Id == Builtin::BI__GetExceptionInfo)
12704 assert((TypeStr[0] !=
'.' || TypeStr[1] == 0) &&
12705 "'.' should only occur at end of builtin type list!");
12707 bool Variadic = (TypeStr[0] ==
'.');
12714 if (ArgTypes.empty() && Variadic && !
getLangOpts().requiresStrictPrototypes())
12764 if ((!Context.getLangOpts().CPlusPlus &&
12765 !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12766 !FD->
hasAttr<DLLExportAttr>()) ||
12767 FD->
hasAttr<GNUInlineAttr>()) {
12785 if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12800 if (D->
hasAttr<DLLImportAttr>()) {
12803 }
else if (D->
hasAttr<DLLExportAttr>()) {
12806 }
else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice) {
12809 if (D->
hasAttr<CUDAGlobalAttr>() &&
12818 if (Context.shouldExternalize(D))
12833 switch (Source->hasExternalDefinitions(D)) {
12860 if (Context.getLangOpts().CPlusPlus &&
12861 Context.getLangOpts().IncrementalExtensions &&
12877 if (!LexicalContext)
12882 auto StaticLocalLinkage =
12894 return StaticLocalLinkage;
12900 if (Context.isMSStaticDataMemberInlineDefinition(VD))
12906 switch (Context.getInlineVariableDefinitionKind(VD)) {
12921 return StrongLinkage;
12924 return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
12939 llvm_unreachable(
"Invalid Linkage!");
12949 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
12950 if (!VD->isFileVarDecl())
12955 if (VD->getDescribedVarTemplate() ||
12958 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
12984 if (D->
hasAttr<WeakRefAttr>())
12991 if (LangOpts.SYCLIsDevice)
12993 D->
hasAttr<SYCLExternalAttr>());
12999 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
13001 if (!FD->doesThisDeclarationHaveABody())
13002 return FD->doesDeclarationForceExternallyVisibleDefinition();
13005 if (FD->
hasAttr<ConstructorAttr>() || FD->
hasAttr<DestructorAttr>())
13010 if (
getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
13011 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
13030 assert(VD->isFileVarDecl() &&
"Expected file scoped var");
13034 if (LangOpts.OpenMP &&
13035 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
13042 if (VD->shouldEmitInExternalSource())
13055 if (VD->needsDestruction(*
this))
13059 if (VD->hasInitWithSideEffects())
13064 if (
const auto *DD = dyn_cast<DecompositionDecl>(VD)) {
13065 for (
const auto *BD : DD->flat_bindings())
13066 if (
const auto *BindingVD = BD->getHoldingVar())
13076 llvm::function_ref<
void(
FunctionDecl *)> Pred)
const {
13077 assert(FD->
isMultiVersion() &&
"Only valid for multiversioned functions");
13078 llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
13083 for (
auto *CurDecl :
13087 SeenDecls.insert(CurFD).second) {
13094 bool IsCXXMethod)
const {
13097 return ABI->getDefaultMethodCallConv(IsVariadic);
13099 switch (LangOpts.getDefaultCallingConv()) {
13127 return Target->getDefaultCallingConv();
13132 return ABI->isNearlyEmpty(RD);
13137 auto ABI = Target->getCXXABI();
13138 if (ABI.isMicrosoft())
13141 auto ComponentLayout =
getLangOpts().RelativeCXXABIVTables
13147 return VTContext.get();
13153 switch (
T->getCXXABI().getKind()) {
13154 case TargetCXXABI::AppleARM64:
13155 case TargetCXXABI::Fuchsia:
13156 case TargetCXXABI::GenericAArch64:
13157 case TargetCXXABI::GenericItanium:
13158 case TargetCXXABI::GenericARM:
13159 case TargetCXXABI::GenericMIPS:
13160 case TargetCXXABI::iOS:
13161 case TargetCXXABI::WebAssembly:
13162 case TargetCXXABI::WatchOS:
13163 case TargetCXXABI::XL:
13165 case TargetCXXABI::Microsoft:
13168 llvm_unreachable(
"Unsupported ABI");
13172 assert(
T.getCXXABI().getKind() != TargetCXXABI::Microsoft &&
13173 "Device mangle context does not support Microsoft mangling.");
13174 switch (
T.getCXXABI().getKind()) {
13175 case TargetCXXABI::AppleARM64:
13176 case TargetCXXABI::Fuchsia:
13177 case TargetCXXABI::GenericAArch64:
13178 case TargetCXXABI::GenericItanium:
13179 case TargetCXXABI::GenericARM:
13180 case TargetCXXABI::GenericMIPS:
13181 case TargetCXXABI::iOS:
13182 case TargetCXXABI::WebAssembly:
13183 case TargetCXXABI::WatchOS:
13184 case TargetCXXABI::XL:
13188 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
13189 return RD->getDeviceLambdaManglingNumber();
13190 return std::nullopt;
13193 case TargetCXXABI::Microsoft:
13197 llvm_unreachable(
"Unsupported ABI");
13203 return ASTRecordLayouts.getMemorySize() +
13204 llvm::capacity_in_bytes(ObjCLayouts) +
13205 llvm::capacity_in_bytes(KeyFunctions) +
13206 llvm::capacity_in_bytes(ObjCImpls) +
13207 llvm::capacity_in_bytes(BlockVarCopyInits) +
13208 llvm::capacity_in_bytes(DeclAttrs) +
13209 llvm::capacity_in_bytes(TemplateOrInstantiation) +
13210 llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
13211 llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
13212 llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
13213 llvm::capacity_in_bytes(OverriddenMethods) +
13214 llvm::capacity_in_bytes(Types) +
13215 llvm::capacity_in_bytes(VariableArrayTypes);
13223 unsigned Signed)
const {
13226 if (!QualTy && DestWidth == 128)
13255 llvm_unreachable(
"Unhandled TargetInfo::RealType value");
13262 MangleNumbers[ND] = Number;
13265 Listener->AddedManglingNumber(ND, Number);
13269 bool ForAuxTarget)
const {
13270 auto I = MangleNumbers.find(ND);
13271 unsigned Res = I != MangleNumbers.end() ? I->second : 1;
13274 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice) {
13275 Res = ForAuxTarget ? Res >> 16 : Res & 0xFFFF;
13277 assert(!ForAuxTarget &&
"Only CUDA/HIP host compilation supports mangling "
13278 "number for aux target");
13280 return Res > 1 ? Res : 1;
13287 StaticLocalNumbers[VD] = Number;
13290 Listener->AddedStaticLocalNumbers(VD, Number);
13294 auto I = StaticLocalNumbers.find(VD);
13295 return I != StaticLocalNumbers.end() ? I->second : 1;
13299 bool IsDestroying) {
13300 if (!IsDestroying) {
13312 bool IsTypeAware) {
13313 if (!IsTypeAware) {
13326 assert(LangOpts.CPlusPlus);
13327 std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
13335 assert(LangOpts.CPlusPlus);
13336 std::unique_ptr<MangleNumberingContext> &MCtx =
13337 ExtraMangleNumberingContexts[D];
13343std::unique_ptr<MangleNumberingContext>
13345 return ABI->createMangleNumberingContext();
13350 return ABI->getCopyConstructorForExceptionObject(
13356 return ABI->addCopyConstructorForExceptionObject(
13363 return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
13368 return ABI->getTypedefNameForUnnamedTagDecl(TD);
13373 return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
13377 return ABI->getDeclaratorForUnnamedTagDecl(TD);
13381 ParamIndices[D] =
index;
13385 ParameterIndexTable::const_iterator I = ParamIndices.find(D);
13386 assert(I != ParamIndices.end() &&
13387 "ParmIndices lacks entry set by ParmVarDecl");
13392 unsigned Length)
const {
13418 assert(
MSGuidTagDecl &&
"building MS GUID without MS extensions?");
13420 llvm::FoldingSetNodeID ID;
13424 if (
MSGuidDecl *Existing = MSGuidDecls.FindNodeOrInsertPos(ID, InsertPos))
13428 MSGuidDecl *
New = MSGuidDecl::Create(*
this, GUIDType, Parts);
13429 MSGuidDecls.InsertNode(
New, InsertPos);
13435 const APValue &APVal)
const {
13436 llvm::FoldingSetNodeID ID;
13441 UnnamedGlobalConstantDecls.FindNodeOrInsertPos(ID, InsertPos))
13445 UnnamedGlobalConstantDecl::Create(*
this, Ty, APVal);
13446 UnnamedGlobalConstantDecls.InsertNode(
New, InsertPos);
13452 assert(
T->isRecordType() &&
"template param object of unexpected type");
13458 llvm::FoldingSetNodeID ID;
13463 TemplateParamObjectDecls.FindNodeOrInsertPos(ID, InsertPos))
13467 TemplateParamObjectDecls.InsertNode(
New, InsertPos);
13473 if (!
T.isOSDarwin())
13476 if (!(
T.isiOS() &&
T.isOSVersionLT(7)) &&
13477 !(
T.isMacOSX() &&
T.isOSVersionLT(10, 9)))
13486 return (Size != Align ||
toBits(sizeChars) > MaxInlineWidthInBits);
13493 if (MethodDecl->
hasAttr<UnavailableAttr>()
13494 || MethodDecl->
hasAttr<DeprecatedAttr>())
13508 IM != EM && IF != EF; ++IM, ++IF) {
13539 llvm::FoldingSetNodeID IDX, IDY;
13540 X->Profile(IDX, *
this,
true);
13541 Y->
Profile(IDY, *
this,
true);
13555 for (
const Decl *DX :
X->redecls()) {
13560 if (DX->isFirstDecl())
13563 llvm_unreachable(
"Corrupt redecls chain");
13566template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13568 return cast_or_null<T>(
13570 const_cast<Decl *
>(cast_or_null<Decl>(Y))));
13573template <
class T, std::enable_if_t<std::is_base_of_v<Decl, T>,
bool> = true>
13581 bool IgnoreDeduced =
false) {
13596 bool IgnoreDeduced) {
13604 assert(Xs.size() == Ys.size());
13606 for (
size_t I = 0; I < Rs.size(); ++I)
13613 return X->getAttributeLoc() == Y->getAttributeLoc() ?
X->getAttributeLoc()
13623 switch (
X.getKind()) {
13653 auto NExpX =
X.getNumTemplateExpansions();
13667 if (Xs.size() != Ys.size())
13669 R.resize(Xs.size());
13670 for (
size_t I = 0; I < R.size(); ++I) {
13683 assert(!Different);
13711 assert(!IsSame &&
"Should be the same NestedNameSpecifier");
13713 return std::nullopt;
13718 assert(Kind == NNS2.
getKind());
13723 auto Kind = Namespace1->getKind();
13724 if (Kind != Namespace2->getKind() ||
13725 (Kind == Decl::NamespaceAlias &&
13730 Namespace2->getNamespace()),
13764 llvm_unreachable(
"singletons did not compare equal");
13772 const T *Y,
bool IsSame) {
13773 return ::getCommonNNS(Ctx,
X->getQualifier(), Y->getQualifier(), IsSame);
13786 QualType EX =
X->getElementType(), EY = Y->getElementType();
13795 QY += EY.getQualifiers() - RQ;
13807 assert(Ctx.
hasSameExpr(
X->getSizeExpr(), Y->getSizeExpr()));
13808 return X->getSizeExpr();
13813 return X->getSizeModifier();
13819 return X->getIndexTypeCVRQualifiers();
13829 llvm::DenseMap<QualType, unsigned>
Found;
13830 for (
auto Ts : {
X, Y}) {
13837 Out.emplace_back(
T);
13843FunctionProtoType::ExceptionSpecInfo
13847 bool AcceptDependent)
const {
13873 assert(AcceptDependent &&
13874 "computing composite pointer type of dependent types");
13889 llvm_unreachable(
"These ESTs should be handled above");
13894 assert(EST2 ==
EST_Dynamic &&
"other cases should already be handled");
13898 Result.Exceptions = ExceptionTypeStorage;
13905 llvm_unreachable(
"shouldn't see unresolved exception specifications here");
13908 llvm_unreachable(
"invalid ExceptionSpecificationType");
13917#define UNEXPECTED_TYPE(Class, Kind) \
13918 case Type::Class: \
13919 llvm_unreachable("Unexpected " Kind ": " #Class);
13921#define NON_CANONICAL_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "non-canonical")
13922#define TYPE(Class, Base)
13923#include "clang/AST/TypeNodes.inc"
13925#define SUGAR_FREE_TYPE(Class) UNEXPECTED_TYPE(Class, "sugar-free")
13936#undef SUGAR_FREE_TYPE
13937#define NON_UNIQUE_TYPE(Class) UNEXPECTED_TYPE(Class, "non-unique")
13940#undef NON_UNIQUE_TYPE
13944#undef UNEXPECTED_TYPE
13948 assert(AX->getDeducedType().isNull());
13949 assert(AY->getDeducedType().isNull());
13950 assert(AX->getKeyword() == AY->getKeyword());
13951 assert(AX->isInstantiationDependentType() ==
13952 AY->isInstantiationDependentType());
13954 AY->getTypeConstraintArguments());
13957 AX->containsUnexpandedParameterPack(),
13959 AY->getTypeConstraintConcept()),
13962 case Type::IncompleteArray: {
13969 case Type::DependentSizedArray: {
13977 case Type::ConstantArray: {
13980 assert(AX->getSize() == AY->getSize());
13981 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13982 ? AX->getSizeExpr()
13988 case Type::ArrayParameter: {
13991 assert(AX->getSize() == AY->getSize());
13992 const Expr *SizeExpr = Ctx.
hasSameExpr(AX->getSizeExpr(), AY->getSizeExpr())
13993 ? AX->getSizeExpr()
14000 case Type::Atomic: {
14005 case Type::Complex: {
14009 case Type::Pointer: {
14013 case Type::BlockPointer: {
14017 case Type::ObjCObjectPointer: {
14022 case Type::MemberPointer: {
14026 PY->getMostRecentCXXRecordDecl()));
14030 PX->getMostRecentCXXRecordDecl());
14032 case Type::LValueReference: {
14037 PX->isSpelledAsLValue() ||
14038 PY->isSpelledAsLValue());
14040 case Type::RValueReference: {
14046 case Type::DependentAddressSpace: {
14049 assert(Ctx.
hasSameExpr(PX->getAddrSpaceExpr(), PY->getAddrSpaceExpr()));
14051 PX->getAddrSpaceExpr(),
14054 case Type::FunctionNoProto: {
14057 assert(FX->getExtInfo() == FY->getExtInfo());
14062 case Type::FunctionProto: {
14066 EPIY = FY->getExtProtoInfo();
14067 assert(EPIX.
ExtInfo == EPIY.ExtInfo);
14074 assert(EPIX.
TypeQuals == EPIY.TypeQuals);
14075 assert(EPIX.
Variadic == EPIY.Variadic);
14084 auto P =
getCommonTypes(Ctx, FX->param_types(), FY->param_types(),
14092 case Type::ObjCObject: {
14095 std::equal(OX->getProtocols().begin(), OX->getProtocols().end(),
14096 OY->getProtocols().begin(), OY->getProtocols().end(),
14098 return P0->getCanonicalDecl() == P1->getCanonicalDecl();
14100 "protocol lists must be the same");
14102 OY->getTypeArgsAsWritten());
14105 OX->getProtocols(),
14106 OX->isKindOfTypeAsWritten() && OY->isKindOfTypeAsWritten());
14108 case Type::ConstantMatrix: {
14111 assert(MX->getNumRows() == MY->getNumRows());
14112 assert(MX->getNumColumns() == MY->getNumColumns());
14114 MX->getNumRows(), MX->getNumColumns());
14116 case Type::DependentSizedMatrix: {
14119 assert(Ctx.
hasSameExpr(MX->getRowExpr(), MY->getRowExpr()));
14120 assert(Ctx.
hasSameExpr(MX->getColumnExpr(), MY->getColumnExpr()));
14125 case Type::Vector: {
14127 assert(VX->getNumElements() == VY->getNumElements());
14128 assert(VX->getVectorKind() == VY->getVectorKind());
14130 VX->getNumElements(), VX->getVectorKind());
14132 case Type::ExtVector: {
14134 assert(VX->getNumElements() == VY->getNumElements());
14136 VX->getNumElements());
14138 case Type::DependentSizedExtVector: {
14145 case Type::DependentVector: {
14148 assert(VX->getVectorKind() == VY->getVectorKind());
14155 case Type::InjectedClassName: {
14163 case Type::TemplateSpecialization: {
14167 TY->template_arguments());
14171 TY->getTemplateName(),
14173 As, {},
X->getCanonicalTypeInternal());
14175 case Type::Decltype: {
14178 assert(DX->isDependentType());
14179 assert(DY->isDependentType());
14180 assert(Ctx.
hasSameExpr(DX->getUnderlyingExpr(), DY->getUnderlyingExpr()));
14184 case Type::PackIndexing: {
14187 assert(DX->isDependentType());
14188 assert(DY->isDependentType());
14189 assert(Ctx.
hasSameExpr(DX->getIndexExpr(), DY->getIndexExpr()));
14192 case Type::DependentName: {
14195 assert(NX->getIdentifier() == NY->getIdentifier());
14200 case Type::UnaryTransform: {
14203 assert(TX->getUTTKind() == TY->getUTTKind());
14207 TY->getUnderlyingType()),
14210 case Type::PackExpansion: {
14213 assert(PX->getNumExpansions() == PY->getNumExpansions());
14216 PX->getNumExpansions(),
false);
14220 assert(PX->isReadOnly() == PY->isReadOnly());
14225 case Type::TemplateTypeParm: {
14228 assert(TX->getDepth() == TY->getDepth());
14229 assert(TX->getIndex() == TY->getIndex());
14230 assert(TX->isParameterPack() == TY->isParameterPack());
14232 TX->getDepth(), TX->getIndex(), TX->isParameterPack(),
14236 llvm_unreachable(
"Unknown Type Class");
14246#define UNEXPECTED_TYPE(Class, Kind) \
14247 case Type::Class: \
14248 llvm_unreachable("Unexpected " Kind ": " #Class);
14249#define TYPE(Class, Base)
14250#define DEPENDENT_TYPE(Class, Base) UNEXPECTED_TYPE(Class, "dependent")
14251#include "clang/AST/TypeNodes.inc"
14253#define CANONICAL_TYPE(Class) UNEXPECTED_TYPE(Class, "canonical")
14279#undef CANONICAL_TYPE
14281#undef UNEXPECTED_TYPE
14283 case Type::Adjusted: {
14285 QualType OX = AX->getOriginalType(), OY = AY->getOriginalType();
14292 case Type::Decayed: {
14294 QualType OX = DX->getOriginalType(), OY = DY->getOriginalType();
14301 case Type::Attributed: {
14303 AttributedType::Kind Kind = AX->getAttrKind();
14304 if (Kind != AY->getAttrKind())
14306 QualType MX = AX->getModifiedType(), MY = AY->getModifiedType();
14314 case Type::BTFTagAttributed: {
14316 const BTFTypeTagAttr *AX = BX->getAttr();
14318 if (AX->getBTFTypeTag() !=
14327 if (KW != AY->getKeyword())
14331 AY->getTypeConstraintConcept());
14335 AY->getTypeConstraintArguments())) {
14343 false,
false, CD, As);
14345 case Type::PackIndexing:
14346 case Type::Decltype:
14348 case Type::DeducedTemplateSpecialization:
14351 case Type::MacroQualified: {
14355 if (IX != MY->getMacroIdentifier())
14359 case Type::SubstTemplateTypeParm: {
14366 unsigned Index = SX->getIndex();
14367 if (Index != SY->getIndex())
14369 auto PackIndex = SX->getPackIndex();
14370 if (PackIndex != SY->getPackIndex())
14373 CD, Index, PackIndex,
14374 SX->getFinal() && SY->getFinal());
14376 case Type::ObjCTypeParam:
14382 case Type::TemplateSpecialization: {
14387 TY->getTemplateName(),
true);
14392 TY->template_arguments()))
14398 case Type::Typedef: {
14408 case Type::TypeOf: {
14419 case Type::TypeOfExpr:
14422 case Type::UnaryTransform: {
14425 UnaryTransformType::UTTKind KX = UX->getUTTKind();
14426 if (KX != UY->getUTTKind())
14428 QualType BX = UX->getBaseType(), BY = UY->getBaseType();
14435 case Type::Using: {
14444 case Type::MemberPointer: {
14448 assert(Cls == PY->getMostRecentCXXRecordDecl());
14453 case Type::CountAttributed: {
14456 if (DX->isCountInBytes() != DY->isCountInBytes())
14458 if (DX->isOrNull() != DY->isOrNull())
14460 Expr *CEX = DX->getCountExpr();
14461 Expr *CEY = DY->getCountExpr();
14465 DX->isCountInBytes(), DX->isOrNull(),
14476 DX->isCountInBytes(), DX->isOrNull(),
14479 case Type::PredefinedSugar:
14484 llvm_unreachable(
"Unhandled Type Class");
14491 QualType NT =
T.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
14506 if (
X.isCanonical())
14535 if (SX.
Ty != SY.Ty) {
14543 while (!Xs.empty() && !Ys.empty() && Xs.back().Ty == Ys.back().Ty) {
14546 SX = Xs.pop_back_val();
14547 SY = Ys.pop_back_val();
14550 if (KeepCommonQualifiers)
14557 while (!Xs.empty() && !Ys.empty()) {
14560 SX = Xs.pop_back_val();
14561 SY = Ys.pop_back_val();
14566 SX.
Ty = Underlying.Ty;
14569 QX -= Underlying.Quals;
14587 llvm_unreachable(
"Not a saturated fixed point type!");
14588 case BuiltinType::SatShortAccum:
14590 case BuiltinType::SatAccum:
14592 case BuiltinType::SatLongAccum:
14594 case BuiltinType::SatUShortAccum:
14596 case BuiltinType::SatUAccum:
14598 case BuiltinType::SatULongAccum:
14600 case BuiltinType::SatShortFract:
14602 case BuiltinType::SatFract:
14604 case BuiltinType::SatLongFract:
14606 case BuiltinType::SatUShortFract:
14608 case BuiltinType::SatUFract:
14610 case BuiltinType::SatULongFract:
14622 llvm_unreachable(
"Not a fixed point type!");
14623 case BuiltinType::ShortAccum:
14625 case BuiltinType::Accum:
14627 case BuiltinType::LongAccum:
14629 case BuiltinType::UShortAccum:
14631 case BuiltinType::UAccum:
14633 case BuiltinType::ULongAccum:
14635 case BuiltinType::ShortFract:
14637 case BuiltinType::Fract:
14639 case BuiltinType::LongFract:
14641 case BuiltinType::UShortFract:
14643 case BuiltinType::UFract:
14645 case BuiltinType::ULongFract:
14651 if (LangOpts.OpenCL)
14675 llvm_unreachable(
"Not a fixed point type!");
14676 case BuiltinType::ShortAccum:
14677 case BuiltinType::SatShortAccum:
14678 return Target.getShortAccumScale();
14679 case BuiltinType::Accum:
14680 case BuiltinType::SatAccum:
14681 return Target.getAccumScale();
14682 case BuiltinType::LongAccum:
14683 case BuiltinType::SatLongAccum:
14684 return Target.getLongAccumScale();
14685 case BuiltinType::UShortAccum:
14686 case BuiltinType::SatUShortAccum:
14687 return Target.getUnsignedShortAccumScale();
14688 case BuiltinType::UAccum:
14689 case BuiltinType::SatUAccum:
14690 return Target.getUnsignedAccumScale();
14691 case BuiltinType::ULongAccum:
14692 case BuiltinType::SatULongAccum:
14693 return Target.getUnsignedLongAccumScale();
14694 case BuiltinType::ShortFract:
14695 case BuiltinType::SatShortFract:
14696 return Target.getShortFractScale();
14697 case BuiltinType::Fract:
14698 case BuiltinType::SatFract:
14699 return Target.getFractScale();
14700 case BuiltinType::LongFract:
14701 case BuiltinType::SatLongFract:
14702 return Target.getLongFractScale();
14703 case BuiltinType::UShortFract:
14704 case BuiltinType::SatUShortFract:
14705 return Target.getUnsignedShortFractScale();
14706 case BuiltinType::UFract:
14707 case BuiltinType::SatUFract:
14708 return Target.getUnsignedFractScale();
14709 case BuiltinType::ULongFract:
14710 case BuiltinType::SatULongFract:
14711 return Target.getUnsignedLongFractScale();
14721 llvm_unreachable(
"Not a fixed point type!");
14722 case BuiltinType::ShortAccum:
14723 case BuiltinType::SatShortAccum:
14724 return Target.getShortAccumIBits();
14725 case BuiltinType::Accum:
14726 case BuiltinType::SatAccum:
14727 return Target.getAccumIBits();
14728 case BuiltinType::LongAccum:
14729 case BuiltinType::SatLongAccum:
14730 return Target.getLongAccumIBits();
14731 case BuiltinType::UShortAccum:
14732 case BuiltinType::SatUShortAccum:
14733 return Target.getUnsignedShortAccumIBits();
14734 case BuiltinType::UAccum:
14735 case BuiltinType::SatUAccum:
14736 return Target.getUnsignedAccumIBits();
14737 case BuiltinType::ULongAccum:
14738 case BuiltinType::SatULongAccum:
14739 return Target.getUnsignedLongAccumIBits();
14740 case BuiltinType::ShortFract:
14741 case BuiltinType::SatShortFract:
14742 case BuiltinType::Fract:
14743 case BuiltinType::SatFract:
14744 case BuiltinType::LongFract:
14745 case BuiltinType::SatLongFract:
14746 case BuiltinType::UShortFract:
14747 case BuiltinType::SatUShortFract:
14748 case BuiltinType::UFract:
14749 case BuiltinType::SatUFract:
14750 case BuiltinType::ULongFract:
14751 case BuiltinType::SatULongFract:
14756llvm::FixedPointSemantics
14759 "Can only get the fixed point semantics for a "
14760 "fixed point or integer type.");
14762 return llvm::FixedPointSemantics::GetIntegerSemantics(
14766 return llvm::FixedPointSemantics(
14769 !isSigned &&
getTargetInfo().doUnsignedFixedPointTypesHavePadding());
14784 "Expected unsigned fixed point type");
14787 case BuiltinType::UShortAccum:
14789 case BuiltinType::UAccum:
14791 case BuiltinType::ULongAccum:
14793 case BuiltinType::SatUShortAccum:
14795 case BuiltinType::SatUAccum:
14797 case BuiltinType::SatULongAccum:
14799 case BuiltinType::UShortFract:
14801 case BuiltinType::UFract:
14803 case BuiltinType::ULongFract:
14805 case BuiltinType::SatUShortFract:
14807 case BuiltinType::SatUFract:
14809 case BuiltinType::SatULongFract:
14812 llvm_unreachable(
"Unexpected unsigned fixed point type");
14820 std::vector<std::string> BackendFeats;
14821 llvm::AArch64::ExtensionSet FeatureBits;
14822 for (StringRef F : FMVFeatStrings)
14823 if (
auto FMVExt = llvm::AArch64::parseFMVExtension(F))
14825 FeatureBits.enable(*FMVExt->ID);
14826 FeatureBits.toLLVMFeatureList(BackendFeats);
14827 return BackendFeats;
14832 assert(TD !=
nullptr);
14835 llvm::erase_if(
ParsedAttr.Features, [&](
const std::string &Feat) {
14836 return !Target->isValidFeatureName(StringRef{Feat}.substr(1));
14847 Target->getTargetOpts().CPU,
14848 Target->getTargetOpts().Features);
14855 StringRef TargetCPU = Target->getTargetOpts().CPU;
14857 if (
const auto *TD = FD->
getAttr<TargetAttr>()) {
14863 if (!Target->getTriple().isAArch64())
14866 Target->getTargetOpts().FeaturesAsWritten.begin(),
14867 Target->getTargetOpts().FeaturesAsWritten.end());
14878 }
else if (
const auto *SD = FD->
getAttr<CPUSpecificAttr>()) {
14880 Target->getCPUSpecificCPUDispatchFeatures(
14882 std::vector<std::string> Features(FeaturesTmp.begin(), FeaturesTmp.end());
14883 Features.insert(Features.begin(),
14884 Target->getTargetOpts().FeaturesAsWritten.begin(),
14885 Target->getTargetOpts().FeaturesAsWritten.end());
14886 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14887 }
else if (
const auto *TC = FD->
getAttr<TargetClonesAttr>()) {
14888 if (Target->getTriple().isAArch64()) {
14892 Features.insert(Features.begin(),
14893 Target->getTargetOpts().FeaturesAsWritten.begin(),
14894 Target->getTargetOpts().FeaturesAsWritten.end());
14895 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14896 }
else if (Target->getTriple().isRISCV()) {
14898 std::vector<std::string> Features;
14899 if (VersionStr !=
"default") {
14901 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14904 Features.insert(Features.begin(),
14905 Target->getTargetOpts().FeaturesAsWritten.begin(),
14906 Target->getTargetOpts().FeaturesAsWritten.end());
14907 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14909 std::vector<std::string> Features;
14911 if (VersionStr.starts_with(
"arch="))
14912 TargetCPU = VersionStr.drop_front(
sizeof(
"arch=") - 1);
14913 else if (VersionStr !=
"default")
14914 Features.push_back((StringRef{
"+"} + VersionStr).str());
14915 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14917 }
else if (
const auto *TV = FD->
getAttr<TargetVersionAttr>()) {
14918 std::vector<std::string> Features;
14919 if (Target->getTriple().isRISCV()) {
14921 Features.insert(Features.begin(),
ParsedAttr.Features.begin(),
14924 assert(Target->getTriple().isAArch64());
14926 TV->getFeatures(Feats);
14929 Features.insert(Features.begin(),
14930 Target->getTargetOpts().FeaturesAsWritten.begin(),
14931 Target->getTargetOpts().FeaturesAsWritten.end());
14932 Target->initFeatureMap(FeatureMap,
getDiagnostics(), TargetCPU, Features);
14934 FeatureMap = Target->getTargetOpts().FeatureMap;
14945 auto DeviceDiscriminatorOverrider =
14947 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
14949 return RD->getDeviceLambdaManglingNumber();
14950 return std::nullopt;
14953 Context, Context.getDiagnostics(), DeviceDiscriminatorOverrider)};
14961 std::string Buffer;
14962 Buffer.reserve(128);
14963 llvm::raw_string_ostream Out(Buffer);
14964 MC->mangleCanonicalTypeName(KernelNameType, Out);
14965 std::string KernelName = Out.str();
14967 return {KernelNameType, FD, KernelName};
14976 const auto *SKEPAttr = FD->
getAttr<SYCLKernelEntryPointAttr>();
14977 assert(SKEPAttr &&
"Missing sycl_kernel_entry_point attribute");
14986 "SYCL kernel name conflict");
15001 return &IT->second;
15007 return *OMPTraitInfoVector.back();
15014 return DB << Section.
Decl;
15015 return DB <<
"a prior #pragma section";
15019 bool IsInternalVar =
15022 bool IsExplicitDeviceVar = (D->
hasAttr<CUDADeviceAttr>() &&
15023 !D->
getAttr<CUDADeviceAttr>()->isImplicit()) ||
15024 (D->
hasAttr<CUDAConstantAttr>() &&
15025 !D->
getAttr<CUDAConstantAttr>()->isImplicit());
15029 return (IsInternalVar &&
15030 (D->
hasAttr<HIPManagedAttr>() || IsExplicitDeviceVar)) ||
15031 (D->
hasAttr<CUDAGlobalAttr>() &&
15038 (D->
hasAttr<HIPManagedAttr>() || D->
hasAttr<CUDAGlobalAttr>() ||
15043 if (!CUIDHash.empty())
15045 if (LangOpts.CUID.empty())
15046 return StringRef();
15047 CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.CUID),
true);
15057 assert(PrimaryBase);
15060 auto Base = Layout.getPrimaryBase();
15061 if (!
Base ||
Base == PrimaryBase || !
Base->isPolymorphic())
15063 PrimaryBase =
Base;
15065 return PrimaryBase;
15069 StringRef MangledName) {
15071 assert(
Method->isVirtual());
15072 bool DefaultIncludesPointerAuth =
15073 LangOpts.PointerAuthCalls || LangOpts.PointerAuthIntrinsics;
15075 if (!DefaultIncludesPointerAuth)
15078 auto Existing = ThunksToBeAbbreviated.find(VirtualMethodDecl);
15079 if (Existing != ThunksToBeAbbreviated.end())
15080 return Existing->second.contains(MangledName.str());
15083 llvm::StringMap<llvm::SmallVector<std::string, 2>> Thunks;
15085 if (
const auto *ThunkInfos = VtableContext->getThunkInfo(VirtualMethodDecl)) {
15087 for (
const auto &Thunk : *ThunkInfos) {
15089 llvm::raw_svector_ostream ElidedNameStream(ElidedName);
15095 Mangler->mangleThunk(
Method, Thunk,
true,
15098 llvm::raw_svector_ostream mangledNameStream(MangledName);
15102 mangledNameStream);
15104 Mangler->mangleThunk(
Method, Thunk,
false,
15105 mangledNameStream);
15107 Thunks[ElidedName].push_back(std::string(MangledName));
15110 llvm::StringSet<> SimplifiedThunkNames;
15111 for (
auto &ThunkList : Thunks) {
15112 llvm::sort(ThunkList.second);
15113 SimplifiedThunkNames.insert(ThunkList.second[0]);
15115 bool Result = SimplifiedThunkNames.contains(MangledName);
15116 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.
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,...
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
bool ObjCQualifiedClassTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS)
ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and Class<pr1, ...>.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
bool propertyTypesAreCompatible(QualType, QualType)
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
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...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
QualType getCorrespondingUnsaturatedType(QualType Ty) const
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
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 ...
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
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.
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
void Profile(llvm::FoldingSetNodeID &ID)
Represents a pointer type decayed from an array or function type.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isFileContext() const
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
void addDecl(Decl *D)
Add the declaration D into this context.
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
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