55#include "llvm/ADT/APSInt.h"
56#include "llvm/ADT/ArrayRef.h"
57#include "llvm/ADT/STLExtras.h"
58#include "llvm/ADT/SmallVector.h"
59#include "llvm/ADT/StringRef.h"
60#include "llvm/ADT/StringSwitch.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/ErrorHandling.h"
63#include "llvm/Support/raw_ostream.h"
64#include "llvm/TargetParser/Triple.h"
90 if (
auto *ND = dyn_cast_or_null<NamedDecl>(TheDecl)) {
104TranslationUnitDecl::TranslationUnitDecl(
ASTContext &ctx)
106 DeclContext(TranslationUnit), redeclarable_base(ctx), Ctx(ctx) {}
168 Kind.IgnoreExplicitVisibility =
true;
174 assert(!kind.IgnoreExplicitVisibility &&
175 "asking for explicit visibility when we shouldn't be");
182 return isa<TypeDecl>(D) ||
183 isa<ClassTemplateDecl>(D) ||
184 isa<ObjCInterfaceDecl>(D);
190static std::enable_if_t<!std::is_base_of_v<RedeclarableTemplateDecl, T>,
bool>
193 D->getMemberSpecializationInfo()) {
194 return member->isExplicitSpecialization();
210 switch (
attr->getVisibility()) {
218 llvm_unreachable(
"bad visibility kind");
222static std::optional<Visibility>
227 if (
const auto *A = D->
getAttr<TypeVisibilityAttr>()) {
233 if (
const auto *A = D->
getAttr<VisibilityAttr>()) {
250LinkageInfo LinkageComputer::getLVForTemplateParameterList(
256 if (isa<TemplateTypeParmDecl>(
P))
263 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
P)) {
265 if (!NTTP->isExpandedParameterPack()) {
266 if (!NTTP->getType()->isDependentType()) {
267 LV.
merge(getLVForType(*NTTP->getType(), computation));
273 for (
unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
275 if (!
type->isDependentType())
283 const auto *TTP = cast<TemplateTemplateParmDecl>(
P);
286 if (!TTP->isExpandedParameterPack()) {
287 LV.
merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
293 for (
unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
295 LV.
merge(getLVForTemplateParameterList(
296 TTP->getExpansionTemplateParameters(i), computation));
304 const Decl *Ret =
nullptr;
306 while (DC->
getDeclKind() != Decl::TranslationUnit) {
307 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
308 Ret = cast<Decl>(DC);
325 switch (Arg.getKind()) {
332 LV.
merge(getLVForType(*Arg.getAsType(), computation));
349 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
354 LV.
merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
357 llvm_unreachable(
"bad template argument kind");
366 return getLVForTemplateArgumentList(TArgs.
asArray(), computation);
378 return !fn->
hasAttr<VisibilityAttr>();
388void LinkageComputer::mergeTemplateLV(
392 bool considerVisibility =
409 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
462void LinkageComputer::mergeTemplateLV(
485 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
486 if (considerVisibility)
519void LinkageComputer::mergeTemplateLV(
LinkageInfo &LV,
536 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
537 if (considerVisibility)
545 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
548 const auto *FD = dyn_cast<FunctionDecl>(D);
554 = FD->getTemplateSpecializationInfo()) {
557 FD->getMemberSpecializationInfo()) {
558 TSK = MSI->getTemplateSpecializationKind();
571 const T *
First = D->getFirstDecl();
572 return First->isInExternCContext();
576 if (
const auto *SD = dyn_cast<LinkageSpecDecl>(D.
getDeclContext()))
577 if (!SD->hasBraces())
585 return M->isModulePurview();
600 llvm_unreachable(
"unexpected module ownership kind");
605 return M->isInterfaceOrPartition();
618 if (
auto *TD = dyn_cast<TemplateDecl>(D))
619 D = TD->getTemplatedDecl();
621 if (
auto *VD = dyn_cast<VarDecl>(D))
622 return VD->getStorageClass();
623 if (
auto *FD = dyn_cast<FunctionDecl>(D))
624 return FD->getStorageClass();
630LinkageComputer::getLVForNamespaceScopeDecl(
const NamedDecl *D,
632 bool IgnoreVarTypeLinkage) {
634 "Not a name having namespace scope");
648 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
657 if (Context.
getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
658 !Var->getType().isVolatileQualified() && !Var->isInline() &&
660 !isa<VarTemplateSpecializationDecl>(Var) &&
661 !Var->getDescribedVarTemplate()) {
666 if (Var->getStorageClass() !=
SC_Extern &&
675 Var->getStorageClass() ==
SC_None)
681 }
else if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
683 const VarDecl *VD = IFD->getVarDecl();
684 assert(VD &&
"Expected a VarDecl in this IndirectFieldDecl!");
685 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
687 assert(!isa<FieldDecl>(D) &&
"Didn't expect a FieldDecl!");
692 const auto *Var = dyn_cast<VarDecl>(D);
693 const auto *Func = dyn_cast<FunctionDecl>(D);
721 !isa<TranslationUnitDecl>(DC);
723 const auto *ND = dyn_cast<NamespaceDecl>(DC);
725 if (std::optional<Visibility> Vis =
765 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
789 !IgnoreVarTypeLinkage) {
790 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
807 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
808 mergeTemplateLV(LV, spec, computation);
812 }
else if (
const auto *Function = dyn_cast<FunctionDecl>(D)) {
827 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Function)))
843 TypeAsWritten = TSI->getType();
852 =
Function->getTemplateSpecializationInfo()) {
853 mergeTemplateLV(LV, Function, specInfo, computation);
862 }
else if (
const auto *Tag = dyn_cast<TagDecl>(D)) {
864 if (!Tag->hasNameForLinkage())
870 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
871 mergeTemplateLV(LV, spec, computation);
876 }
else if (isa<EnumConstantDecl>(D)) {
884 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
895 }
else if (isa<NamespaceDecl>(D)) {
900 }
else if (isa<ObjCInterfaceDecl>(D)) {
903 }
else if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
906 if (!TD->getAnonDeclWithTypedefName(
true))
909 }
else if (isa<MSGuidDecl>(D)) {
927LinkageComputer::getLVForClassMember(
const NamedDecl *D,
929 bool IgnoreVarTypeLinkage) {
940 if (!(isa<CXXMethodDecl>(D) ||
943 isa<IndirectFieldDecl>(D) ||
945 isa<TemplateDecl>(D)))
983 const NamedDecl *explicitSpecSuppressor =
nullptr;
985 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
988 QualType TypeAsWritten = MD->getType();
990 TypeAsWritten = TSI->getType();
997 = MD->getTemplateSpecializationInfo()) {
998 mergeTemplateLV(LV, MD, spec, computation);
1000 explicitSpecSuppressor = MD;
1002 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
1005 explicitSpecSuppressor = MD;
1015 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
1018 }
else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
1019 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
1020 mergeTemplateLV(LV, spec, computation);
1022 explicitSpecSuppressor = spec;
1030 explicitSpecSuppressor = RD;
1034 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
1035 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1036 mergeTemplateLV(LV, spec, computation);
1040 if (!IgnoreVarTypeLinkage) {
1050 explicitSpecSuppressor = VD;
1054 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
1055 bool considerVisibility =
1063 if (
const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1071 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1075 bool considerClassVisibility =
true;
1076 if (explicitSpecSuppressor &&
1081 considerClassVisibility =
false;
1089void NamedDecl::anchor() {}
1127 if (
auto *VD = dyn_cast<VarDecl>(
this))
1130 if (
auto *FD = dyn_cast<FunctionDecl>(
this))
1131 if (FD->isExternC())
1143 if (name.front() ==
'C')
1144 if (name ==
"CFStringCreateWithFormat" ||
1145 name ==
"CFStringCreateWithFormatAndArguments" ||
1146 name ==
"CFStringAppendFormat" ||
1147 name ==
"CFStringAppendFormatAndArguments")
1177 !isa<NamespaceDecl>(
this))
1187static std::optional<Visibility>
1190 bool IsMostRecent) {
1199 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1201 if (InstantiatedFrom)
1208 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1212 while (TD !=
nullptr) {
1214 if (Vis != std::nullopt)
1216 TD = TD->getPreviousDecl();
1218 return std::nullopt;
1222 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1224 if (MostRecent != ND)
1228 if (
const auto *Var = dyn_cast<VarDecl>(ND)) {
1229 if (Var->isStaticDataMember()) {
1231 if (InstantiatedFrom)
1235 if (
const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1236 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1239 return std::nullopt;
1242 if (
const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1247 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1253 if (InstantiatedFrom)
1256 return std::nullopt;
1260 if (
const auto *TD = dyn_cast<TemplateDecl>(ND))
1263 return std::nullopt;
1266std::optional<Visibility>
1277 Owner = dyn_cast<NamedDecl>(DC);
1278 else if (isa<ParmVarDecl>(ContextDecl))
1281 else if (isa<ImplicitConceptSpecializationDecl>(ContextDecl)) {
1286 Owner = cast<NamedDecl>(ContextDecl);
1296 auto *VD = dyn_cast<VarDecl>(Owner);
1312 if (
const auto *Function = dyn_cast<FunctionDecl>(D)) {
1313 if (
Function->isInAnonymousNamespace() &&
1323 if (std::optional<Visibility> Vis =
1335 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
1336 if (Var->hasExternalStorage()) {
1344 if (std::optional<Visibility> Vis =
1359 if (!Var->isStaticLocal())
1372 if (
const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1373 if (!BD->getBlockManglingNumber())
1376 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1377 BD->getBlockManglingContextDecl(), computation);
1379 const auto *FD = cast<FunctionDecl>(OuterD);
1380 if (!FD->isInlined() &&
1390 !Context.
getLangOpts().VisibilityInlinesHiddenStaticLocalVar) {
1391 assert(cast<VarDecl>(D)->isStaticLocal());
1395 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1415 bool IgnoreVarTypeLinkage) {
1417 if (D->
hasAttr<InternalLinkageAttr>())
1432 case Decl::ImplicitParam:
1434 case Decl::NamespaceAlias:
1437 case Decl::UsingEnum:
1438 case Decl::UsingShadow:
1439 case Decl::UsingDirective:
1442 case Decl::EnumConstant:
1449 case Decl::TypeAlias:
1452 if (!cast<TypedefNameDecl>(D)
1453 ->getAnonDeclWithTypedefName(
true))
1457 case Decl::TemplateTemplateParm:
1458 case Decl::NonTypeTemplateParm:
1459 case Decl::ObjCAtDefsField:
1460 case Decl::ObjCCategory:
1461 case Decl::ObjCCategoryImpl:
1462 case Decl::ObjCCompatibleAlias:
1463 case Decl::ObjCImplementation:
1464 case Decl::ObjCMethod:
1465 case Decl::ObjCProperty:
1466 case Decl::ObjCPropertyImpl:
1467 case Decl::ObjCProtocol:
1470 case Decl::CXXRecord: {
1471 const auto *Record = cast<CXXRecordDecl>(D);
1472 if (Record->isLambda()) {
1473 if (Record->hasKnownLambdaInternalLinkage() ||
1474 !Record->getLambdaManglingNumber()) {
1479 return getLVForClosure(
1480 Record->getDeclContext()->getRedeclContext(),
1481 Record->getLambdaContextDecl(), computation);
1487 case Decl::TemplateParamObject: {
1490 auto *TPO = cast<TemplateParamObjectDecl>(D);
1491 LinkageInfo LV = getLVForType(*TPO->getType(), computation);
1492 LV.
merge(getLVForValue(TPO->getValue(), computation));
1499 return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1509 return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1523 return getLVForLocalDecl(D, computation);
1534 if (D->
hasAttr<InternalLinkageAttr>())
1540 if (std::optional<LinkageInfo> LI = lookup(D, computation))
1548 cache(D, computation, LV);
1555 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1562 for (
auto *I : D->
redecls()) {
1563 auto *T = cast<NamedDecl>(I);
1566 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1588 if (isa<NamespaceDecl>(
this))
1621 if (
auto *ND = dyn_cast<NamedDecl>(
this))
1635 llvm_unreachable(
"unknown module kind");
1639 Name.
print(OS, Policy);
1647 std::string QualName;
1648 llvm::raw_string_ostream OS(QualName);
1671 llvm::raw_svector_ostream NameOS(NameBuffer);
1673 if (NameBuffer.empty())
1674 OS <<
"(anonymous)";
1690 if (
auto *MD = dyn_cast<ObjCMethodDecl>(
this)) {
1691 if (
auto *ID = MD->getClassInterface())
1693 }
else if (
auto *PD = dyn_cast<ObjCPropertyDecl>(
this)) {
1694 if (
auto *MD = PD->getGetterMethodDecl())
1695 if (
auto *ID = MD->getClassInterface())
1697 }
else if (
auto *ID = dyn_cast<ObjCIvarDecl>(
this)) {
1698 if (
auto *CI = ID->getContainingInterface())
1706 ContextsTy Contexts;
1712 if (
P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1713 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1718 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(NameInScope))
1722 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1726 Contexts.push_back(Ctx);
1730 for (
const DeclContext *DC : llvm::reverse(Contexts)) {
1731 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1732 OS << Spec->getName();
1736 Spec->getSpecializedTemplate()->getTemplateParameters());
1737 }
else if (
const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1738 if (ND->isAnonymousNamespace()) {
1739 OS << (
P.MSVCFormatting ?
"`anonymous namespace\'"
1740 :
"(anonymous namespace)");
1744 }
else if (
const auto *RD = dyn_cast<RecordDecl>(DC)) {
1745 if (!RD->getIdentifier())
1746 OS <<
"(anonymous " << RD->getKindName() <<
')';
1749 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1751 if (FD->hasWrittenPrototype())
1752 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<
FunctionType>());
1756 unsigned NumParams = FD->getNumParams();
1757 for (
unsigned i = 0; i < NumParams; ++i) {
1760 OS << FD->getParamDecl(i)->getType().stream(
P);
1770 }
else if (
const auto *ED = dyn_cast<EnumDecl>(DC)) {
1783 OS << *cast<NamedDecl>(DC);
1804#define DECL(Type, Base) \
1806 return isRedeclarableImpl((Type##Decl *)nullptr);
1807#define ABSTRACT_DECL(DECL)
1808#include "clang/AST/DeclNodes.inc"
1810 llvm_unreachable(
"unknown decl kind");
1826 if (isa<ObjCMethodDecl>(
this))
1831 if (isa<ParmVarDecl>(
this))
1843 if (
auto *UD = dyn_cast<UsingDecl>(
this)) {
1847 cast<UsingDecl>(OldD)->getQualifier());
1849 if (
auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(
this)) {
1853 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1893NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1895 if (
auto *UD = dyn_cast<UsingShadowDecl>(ND))
1896 ND = UD->getTargetDecl();
1898 if (
auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1899 return AD->getClassInterface();
1901 if (
auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1902 return AD->getNamespace();
1912 if (isa<UsingShadowDecl>(D))
1913 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1915 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1917 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D->
getAsFunction()))
1918 return MD->isInstance();
1926template <
typename DeclT>
1928 if (
decl->getNumTemplateParameterLists() > 0)
1929 return decl->getTemplateParameterList(0)->getTemplateLoc();
1930 return decl->getInnerLocStart();
1948 if (!hasExtInfo()) {
1954 getExtInfo()->TInfo = savedTInfo;
1957 getExtInfo()->QualifierLoc = QualifierLoc;
1958 }
else if (hasExtInfo()) {
1960 getExtInfo()->QualifierLoc = QualifierLoc;
1965 assert(TrailingRequiresClause);
1967 if (!hasExtInfo()) {
1973 getExtInfo()->TInfo = savedTInfo;
1976 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
1981 assert(!TPLists.empty());
1983 if (!hasExtInfo()) {
1989 getExtInfo()->TInfo = savedTInfo;
1992 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
2010 case Type::BlockPointer:
2013 case Type::MemberPointer:
2016 case Type::LValueReference:
2017 case Type::RValueReference:
2020 case Type::PackExpansion:
2021 QT = cast<PackExpansionType>(T)->getPattern();
2024 case Type::ConstantArray:
2025 case Type::DependentSizedArray:
2026 case Type::IncompleteArray:
2027 case Type::VariableArray:
2028 case Type::FunctionProto:
2029 case Type::FunctionNoProto:
2041 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2055 if (!TPLists.empty()) {
2076 llvm_unreachable(
"Invalid storage class");
2085 static_assert(
sizeof(VarDeclBitfields) <=
sizeof(
unsigned),
2086 "VarDeclBitfields too large!");
2088 "ParmVarDeclBitfields too large!");
2090 "NonParmVarDeclBitfields too large!");
2099 return new (
C, DC)
VarDecl(Var,
C, DC, StartL, IdL,
Id, T, TInfo, S);
2116 if (!hasAttr<ThreadAttr>() &&
2119 hasAttr<OMPThreadPrivateDeclAttr>()))
2123 hasAttr<OMPThreadPrivateDeclAttr>())
2132 llvm_unreachable(
"Unknown thread storage class specifier!");
2150 if (!D.hasExternalFormalLinkage())
2180 assert(D.getASTContext().getLangOpts().CPlusPlus);
2235 isa<VarTemplatePartialSpecializationDecl>(
this)))
2254 if (
const auto *SAA = getAttr<SelectAnyAttr>())
2255 if (!SAA->isInherited())
2261 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2263 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2264 !VTSD->IsCompleteDefinition)
2296 VarDecl *LastTentative =
nullptr;
2301 Kind =
Decl->isThisDeclarationADefinition();
2306 LastTentative =
Decl;
2309 return LastTentative;
2315 if (I->isThisDeclarationADefinition(
C) ==
Definition)
2326 Kind = std::max(
Kind, I->isThisDeclarationADefinition(
C));
2336 if (
auto Expr = I->getInit()) {
2345 if (
auto *
P = dyn_cast<ParmVarDecl>(
this))
2346 if (
P->hasUnparsedDefaultArg() ||
P->hasUninstantiatedDefaultArg())
2349 return !
Init.isNull();
2356 if (
auto *S =
Init.dyn_cast<
Stmt *>())
2357 return cast<Expr>(S);
2360 return cast<Expr>(Eval->Value.isOffset()
2362 : Eval->Value.get(
nullptr));
2367 return ES->Value.getAddressOfPointer(
getASTContext().getExternalSource());
2369 return Init.getAddrOfPtr1();
2378 if (I->isThisDeclarationADefinition()) {
2405 Eval->~EvaluatedStmt();
2417 if (!Lang.CPlusPlus && !Lang.OpenCL)
2421 if (isa<ParmVarDecl>(
this))
2430 if (Lang.CPlusPlus11 &&
getType()->isReferenceType())
2441 if (
getType()->isIntegralOrEnumerationType())
2453 const VarDecl *DefVD =
nullptr;
2455 if (!
Init ||
Init->isValueDependent() ||
getType()->isDependentType())
2501 bool IsConstantInitialization)
const {
2505 assert(!
Init->isValueDependent());
2522 IsConstantInitialization);
2527 if (IsConstantInitialization && Ctx.
getLangOpts().CPlusPlus11 &&
2555 assert(
Init &&
"no initializer");
2585 "already evaluated var value before checking for constant init");
2588 assert(!
getInit()->isValueDependent());
2592 evaluateValueImpl(Notes,
true) && Notes.empty();
2603 return isa<PackExpansionType>(
getType());
2606template<
typename DeclT>
2609 if (
auto *Def = D->getDefinition())
2625 llvm::any_of(specific_attrs<AlignedAttr>(), [](
const AlignedAttr *AA) {
2626 return AA->isAlignmentDependent();
2645 if (
auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2647 auto From = VDTemplSpec->getInstantiatedFrom();
2649 while (!VTD->isMemberSpecialization()) {
2650 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2659 while (!VTPSD->isMemberSpecialization()) {
2660 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2665 return getDefinitionOrSelf<VarDecl>(VTPSD);
2673 while (!VarTemplate->isMemberSpecialization()) {
2674 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2677 VarTemplate = NewVT;
2690 return cast<VarDecl>(MSI->getInstantiatedFrom());
2696 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2697 return Spec->getSpecializationKind();
2700 return MSI->getTemplateSpecializationKind();
2708 return MSI->getTemplateSpecializationKind();
2710 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2711 return Spec->getSpecializationKind();
2717 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2718 return Spec->getPointOfInstantiation();
2721 return MSI->getPointOfInstantiation();
2744 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2746 isa<IncompleteArrayType>(
getType()))
2755 !hasAttr<AlwaysDestroyAttr>()));
2771 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2773 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2775 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2778 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2782 return InitTy->
getSize() != 0;
2786 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2788 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2790 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2793 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2801 if (FlexibleArrayOffset + FlexibleArraySize < RL.
getSize())
2803 return FlexibleArrayOffset + FlexibleArraySize - RL.
getSize();
2817 assert((isa<VarTemplateSpecializationDecl>(
this) ||
2819 "not a variable or static data member template specialization");
2822 dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2823 Spec->setSpecializationKind(TSK);
2825 PointOfInstantiation.
isValid() &&
2826 Spec->getPointOfInstantiation().isInvalid()) {
2827 Spec->setPointOfInstantiation(PointOfInstantiation);
2829 L->InstantiationRequested(
this);
2832 MSI->setTemplateSpecializationKind(TSK);
2834 MSI->getPointOfInstantiation().isInvalid()) {
2835 MSI->setPointOfInstantiation(PointOfInstantiation);
2837 L->InstantiationRequested(
this);
2845 assert(
getASTContext().getTemplateOrSpecializationInfo(
this).isNull() &&
2846 "Previous template or instantiation?");
2859 return new (
C, DC)
ParmVarDecl(ParmVar,
C, DC, StartLoc, IdLoc,
Id, T, TInfo,
2866 if (
const auto *DT = dyn_cast<DecayedType>(T))
2867 return DT->getOriginalType();
2894 if (hasAttr<NSConsumedAttr>())
2900 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2910 "Default argument is not yet instantiated!");
2913 if (
auto *E = dyn_cast_or_null<FullExpr>(Arg))
2914 return E->getSubExpr();
2936 return E->getSourceRange();
2941 llvm_unreachable(
"Invalid default argument kind.");
2951 "Wrong kind of initialization expression!");
2952 return cast_or_null<Expr>(
Init.get<
Stmt *>());
2963void ParmVarDecl::setParameterIndexLarge(
unsigned parameterIndex) {
2968unsigned ParmVarDecl::getParameterIndexLarge()
const {
2980 bool UsesFPIntrin,
bool isInlineSpecified,
2982 Expr *TrailingRequiresClause)
2986 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.
getInfo()) {
3015 if (TrailingRequiresClause)
3028 if (
const auto *FT =
getType()->getAs<FunctionProtoType>())
3029 return FT->isVariadic();
3037 totalSizeToAlloc<DeclAccessPair>(Lookups.size()),
3040 Info->NumLookups = Lookups.size();
3041 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3048 assert(!
Body &&
"can't replace function body with defaulted function info");
3061 if (I->doesThisDeclarationHaveABody()) {
3078 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3091 return InstantiatedFrom->getFriendObjectKind() &&
3092 InstantiatedFrom->isThisDeclarationADefinition();
3099 return InstantiatedFrom->getFriendObjectKind() &&
3100 InstantiatedFrom->isThisDeclarationADefinition();
3107 bool CheckForPendingFriendDefinition)
const {
3109 if (FD->isThisDeclarationADefinition()) {
3129 if (CheckForPendingFriendDefinition &&
3130 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3143 assert(!
Definition->FunctionDeclBits.HasDefaultedFunctionInfo &&
3144 "definition should not have a body");
3162 Parent->markedVirtualFunctionPure();
3165template<std::
size_t Len>
3168 return II && II->
isStr(Str);
3202 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
this);
3203 MD && MD->isLambdaStaticInvoker())
3204 return MD->getParent()->getLambdaCallOperator()->isImmediateFunction();
3234 return llvm::StringSwitch<bool>(
getName())
3247 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3248 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3249 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3250 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3257 if (proto->getNumParams() != 2 || proto->isVariadic())
3266 return (proto->getParamType(1).getCanonicalType() == Context.
VoidPtrTy);
3270 std::optional<unsigned> *AlignmentParam,
bool *IsNothrow)
const {
3273 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3274 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3275 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3276 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3287 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4 || FPT->isVariadic())
3292 if (FPT->getNumParams() == 1)
3295 unsigned Params = 1;
3296 QualType Ty = FPT->getParamType(Params);
3299 auto Consume = [&] {
3301 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) :
QualType();
3305 bool IsSizedDelete =
false;
3307 (
getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3308 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3310 IsSizedDelete =
true;
3319 *AlignmentParam = Params;
3342 T = TD->getDecl()->getUnderlyingType();
3344 if (II && II->
isStr(
"__hot_cold_t"))
3348 return Params == FPT->getNumParams();
3373 llvm_unreachable(
"Unknown GVALinkage");
3387 RD->getIdentifier()->isStr(
"destroying_delete_t");
3399 if (hasAttr<OpenCLKernelAttr>())
3409 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
this))
3410 return Method->isStatic();
3418 if (
const auto *Namespace = cast<NamespaceDecl>(DC)) {
3419 if (!Namespace->getDeclName())
3428 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3429 hasAttr<C11NoReturnAttr>())
3432 if (
auto *FnTy =
getType()->getAs<FunctionType>())
3433 return FnTy->getNoReturnAttr();
3461 if (hasAttr<TargetAttr>())
3463 if (hasAttr<TargetVersionAttr>())
3465 if (hasAttr<CPUDispatchAttr>())
3467 if (hasAttr<CPUSpecificAttr>())
3469 if (hasAttr<TargetClonesAttr>())
3484 (hasAttr<TargetAttr>() || hasAttr<TargetVersionAttr>());
3498 assert((!PrevDecl || PrevFunTmpl) &&
"Function/function template mismatch");
3499 FunTmpl->setPreviousDecl(PrevFunTmpl);
3522 unsigned BuiltinID = 0;
3524 if (
const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3525 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3526 }
else if (
const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3527 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3528 }
else if (
const auto *A = getAttr<BuiltinAttr>()) {
3529 BuiltinID = A->getID();
3537 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3538 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3561 if (Context.
getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3562 !hasAttr<CUDAHostAttr>() &&
3563 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3572 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3588 assert(!ParamInfo &&
"Already has param info!");
3589 assert(NewParamInfo.size() ==
getNumParams() &&
"Parameter count mismatch!");
3592 if (!NewParamInfo.empty()) {
3594 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3608 unsigned NumRequiredArgs = 0;
3609 unsigned MinParamsSoFar = 0;
3611 if (!Param->isParameterPack()) {
3613 if (!Param->hasDefaultArg())
3614 NumRequiredArgs = MinParamsSoFar;
3617 return NumRequiredArgs;
3633 assert(
isInlined() &&
"expected to get called on an inlined function!");
3637 !hasAttr<DLLExportAttr>())
3642 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3654 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3684 "Must have a declaration without a body.");
3698 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3708 bool FoundBody =
false;
3733 bool FoundBody =
false;
3758 !
SM.isBeforeInTranslationUnit(RTRange.
getEnd(), Boundary))
3804 hasAttr<AliasAttr>()) &&
3805 "Must be a function definition");
3806 assert(
isInlined() &&
"Function must be inline");
3809 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3823 for (
auto *Redecl :
redecls()) {
3824 if (Redecl->isInlineSpecified() &&
3834 "should not use C inline rules in C++");
3840 for (
auto *Redecl :
redecls()) {
3869 if (TemplateOrSpecialization.isNull())
3871 if (
const auto *ND = TemplateOrSpecialization.dyn_cast<
NamedDecl *>()) {
3872 if (isa<FunctionDecl>(ND))
3874 assert(isa<FunctionTemplateDecl>(ND) &&
3875 "No other valid types in NamedDecl");
3882 if (TemplateOrSpecialization.is
3886 llvm_unreachable(
"Did we miss a TemplateOrSpecialization type?");
3891 return cast<FunctionDecl>(Info->getInstantiatedFrom());
3900 if (
auto *FTSI = TemplateOrSpecialization
3901 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3902 return FTSI->getMemberSpecializationInfo();
3907FunctionDecl::setInstantiationOfMemberFunction(
ASTContext &
C,
3910 assert(TemplateOrSpecialization.isNull() &&
3911 "Member function is already a specialization");
3914 TemplateOrSpecialization = Info;
3918 return dyn_cast_or_null<FunctionTemplateDecl>(
3919 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
3924 assert(TemplateOrSpecialization.isNull() &&
3925 "Member function is already a specialization");
3926 TemplateOrSpecialization = Template;
3930 assert(TemplateOrSpecialization.isNull() &&
3931 "Function is already a specialization");
3932 TemplateOrSpecialization = FD;
3936 return dyn_cast_or_null<FunctionDecl>(
3937 TemplateOrSpecialization.dyn_cast<
NamedDecl *>());
3961 bool HasPattern =
false;
3963 HasPattern = PatternDecl->
hasBody(PatternDecl);
3969 if (!HasPattern || !PatternDecl)
3993 dyn_cast<CXXMethodDecl>(
this))) {
4005 if (ForDefinition &&
4011 if (ForDefinition &&
4018 while (!ForDefinition || !Primary->isMemberSpecialization()) {
4019 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
4022 Primary = NewPrimary;
4033 = TemplateOrSpecialization
4034 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4035 return Info->getTemplate();
4042 return TemplateOrSpecialization
4049 = TemplateOrSpecialization
4050 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4051 return Info->TemplateArguments;
4059 = TemplateOrSpecialization
4060 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
4061 return Info->TemplateArgumentsAsWritten;
4067FunctionDecl::setFunctionTemplateSpecialization(
ASTContext &
C,
4074 assert((TemplateOrSpecialization.isNull() ||
4076 "Member function is already a specialization");
4078 "Must specify the type of function template specialization");
4079 assert((TemplateOrSpecialization.isNull() ||
4081 "Member specialization must be an explicit specialization");
4084 C,
this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
4085 PointOfInstantiation,
4087 TemplateOrSpecialization = Info;
4095 assert(TemplateOrSpecialization.isNull());
4099 TemplateOrSpecialization = Info;
4104 return TemplateOrSpecialization
4113 totalSizeToAlloc<TemplateArgumentLoc, FunctionTemplateDecl *>(
4118DependentFunctionTemplateSpecializationInfo::
4121 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
4122 NumTemplates = Ts.
size();
4123 NumArgs = TArgs.
size();
4126 for (
unsigned I = 0, E = Ts.
size(); I != E; ++I)
4127 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
4130 for (
unsigned I = 0, E = TArgs.
size(); I != E; ++I)
4138 TemplateOrSpecialization
4139 .dyn_cast<FunctionTemplateSpecializationInfo *>())
4140 return FTSInfo->getTemplateSpecializationKind();
4144 return MSInfo->getTemplateSpecializationKind();
4169 TemplateOrSpecialization
4170 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
4171 if (
auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4172 return MSInfo->getTemplateSpecializationKind();
4173 return FTSInfo->getTemplateSpecializationKind();
4178 return MSInfo->getTemplateSpecializationKind();
4187 = TemplateOrSpecialization.dyn_cast<
4189 FTSInfo->setTemplateSpecializationKind(TSK);
4191 PointOfInstantiation.
isValid() &&
4192 FTSInfo->getPointOfInstantiation().isInvalid()) {
4193 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4195 L->InstantiationRequested(
this);
4199 MSInfo->setTemplateSpecializationKind(TSK);
4201 PointOfInstantiation.
isValid() &&
4202 MSInfo->getPointOfInstantiation().isInvalid()) {
4203 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4205 L->InstantiationRequested(
this);
4208 llvm_unreachable(
"Function cannot have a template specialization kind");
4213 = TemplateOrSpecialization.dyn_cast<
4215 return FTSInfo->getPointOfInstantiation();
4218 return MSInfo->getPointOfInstantiation();
4239 if (FunTmpl->getTemplatedDecl()->hasBody(
Definition))
4258 case Builtin::BI__builtin_memset:
4259 case Builtin::BI__builtin___memset_chk:
4260 case Builtin::BImemset:
4261 return Builtin::BImemset;
4263 case Builtin::BI__builtin_memcpy:
4264 case Builtin::BI__builtin___memcpy_chk:
4265 case Builtin::BImemcpy:
4266 return Builtin::BImemcpy;
4268 case Builtin::BI__builtin_mempcpy:
4269 case Builtin::BI__builtin___mempcpy_chk:
4270 case Builtin::BImempcpy:
4271 return Builtin::BImempcpy;
4273 case Builtin::BI__builtin_memmove:
4274 case Builtin::BI__builtin___memmove_chk:
4275 case Builtin::BImemmove:
4276 return Builtin::BImemmove;
4278 case Builtin::BIstrlcpy:
4279 case Builtin::BI__builtin___strlcpy_chk:
4280 return Builtin::BIstrlcpy;
4282 case Builtin::BIstrlcat:
4283 case Builtin::BI__builtin___strlcat_chk:
4284 return Builtin::BIstrlcat;
4286 case Builtin::BI__builtin_memcmp:
4287 case Builtin::BImemcmp:
4288 return Builtin::BImemcmp;
4290 case Builtin::BI__builtin_bcmp:
4291 case Builtin::BIbcmp:
4292 return Builtin::BIbcmp;
4294 case Builtin::BI__builtin_strncpy:
4295 case Builtin::BI__builtin___strncpy_chk:
4296 case Builtin::BIstrncpy:
4297 return Builtin::BIstrncpy;
4299 case Builtin::BI__builtin_strncmp:
4300 case Builtin::BIstrncmp:
4301 return Builtin::BIstrncmp;
4303 case Builtin::BI__builtin_strncasecmp:
4304 case Builtin::BIstrncasecmp:
4305 return Builtin::BIstrncasecmp;
4307 case Builtin::BI__builtin_strncat:
4308 case Builtin::BI__builtin___strncat_chk:
4309 case Builtin::BIstrncat:
4310 return Builtin::BIstrncat;
4312 case Builtin::BI__builtin_strndup:
4313 case Builtin::BIstrndup:
4314 return Builtin::BIstrndup;
4316 case Builtin::BI__builtin_strlen:
4317 case Builtin::BIstrlen:
4318 return Builtin::BIstrlen;
4320 case Builtin::BI__builtin_bzero:
4321 case Builtin::BIbzero:
4322 return Builtin::BIbzero;
4324 case Builtin::BIfree:
4325 return Builtin::BIfree;
4329 if (FnInfo->
isStr(
"memset"))
4330 return Builtin::BImemset;
4331 if (FnInfo->
isStr(
"memcpy"))
4332 return Builtin::BImemcpy;
4333 if (FnInfo->
isStr(
"mempcpy"))
4334 return Builtin::BImempcpy;
4335 if (FnInfo->
isStr(
"memmove"))
4336 return Builtin::BImemmove;
4337 if (FnInfo->
isStr(
"memcmp"))
4338 return Builtin::BImemcmp;
4339 if (FnInfo->
isStr(
"bcmp"))
4340 return Builtin::BIbcmp;
4341 if (FnInfo->
isStr(
"strncpy"))
4342 return Builtin::BIstrncpy;
4343 if (FnInfo->
isStr(
"strncmp"))
4344 return Builtin::BIstrncmp;
4345 if (FnInfo->
isStr(
"strncasecmp"))
4346 return Builtin::BIstrncasecmp;
4347 if (FnInfo->
isStr(
"strncat"))
4348 return Builtin::BIstrncat;
4349 if (FnInfo->
isStr(
"strndup"))
4350 return Builtin::BIstrndup;
4351 if (FnInfo->
isStr(
"strlen"))
4352 return Builtin::BIstrlen;
4353 if (FnInfo->
isStr(
"bzero"))
4354 return Builtin::BIbzero;
4356 if (FnInfo->
isStr(
"free"))
4357 return Builtin::BIfree;
4365 assert(hasODRHash());
4374 setHasODRHash(
true);
4381 setHasODRHash(
true);
4395 return new (
C, DC)
FieldDecl(Decl::Field, DC, StartLoc, IdLoc,
Id, T, TInfo,
4396 BW, Mutable, InitStyle);
4409 if (
const auto *Record =
getType()->getAs<RecordType>())
4410 return Record->getDecl()->isAnonymousStructOrUnion();
4420 return cast_or_null<Expr>(
4422 : InitPtr.
get(
nullptr));
4454 if (!hasAttr<NoUniqueAddressAttr>())
4463 assert(
isInvalidDecl() &&
"valid field has incomplete type");
4469 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4470 if (!CXXRD->isEmpty())
4486 if (Canonical !=
this)
4489 if (CachedFieldIndex)
return CachedFieldIndex - 1;
4493 assert(RD &&
"requested index for field of struct with no definition");
4495 for (
auto *Field : RD->
fields()) {
4496 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4497 assert(Field->getCanonicalDecl()->CachedFieldIndex == Index + 1 &&
4498 "overflow in field numbering");
4502 assert(CachedFieldIndex &&
"failed to find field in parent");
4503 return CachedFieldIndex - 1;
4517 "capturing type in non-lambda or captured record.");
4518 assert(StorageKind == ISK_NoInit && !BitField &&
4519 "bit-field or field with default member initializer cannot capture "
4521 StorageKind = ISK_CapturedVLAType;
4535 "EnumDecl not matched with TTK_Enum");
4543 TagDeclBits.IsThisDeclarationADemotedDefinition =
false;
4559 TypedefNameDeclOrQualifier = TDD;
4570 if (
auto *D = dyn_cast<CXXRecordDecl>(
this)) {
4571 struct CXXRecordDecl::DefinitionData *
Data =
4572 new (
getASTContext())
struct CXXRecordDecl::DefinitionData(D);
4574 cast<CXXRecordDecl>(I)->DefinitionData =
Data;
4579 assert((!isa<CXXRecordDecl>(
this) ||
4581 "definition completed but not started");
4587 L->CompletedTagDefinition(
this);
4592 return const_cast<TagDecl *
>(
this);
4597 if (II->isOutOfDate()) {
4603 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this))
4604 return CXXRD->getDefinition();
4607 if (R->isCompleteDefinition())
4623 if (getExtInfo()->NumTemplParamLists == 0) {
4637 if (Name.isIdentifier() && !Name.getAsIdentifierInfo()) {
4647 Name.print(OS, Policy);
4652 assert(!TPLists.empty());
4667 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed)
4669 assert(Scoped || !ScopedUsingClassTag);
4670 IntegerType =
nullptr;
4671 setNumPositiveBits(0);
4672 setNumNegativeBits(0);
4674 setScopedUsingClassTag(ScopedUsingClassTag);
4676 setHasODRHash(
false);
4680void EnumDecl::anchor() {}
4686 bool IsScopedUsingClassTag,
bool IsFixed) {
4688 IsScoped, IsScopedUsingClassTag, IsFixed);
4689 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4690 C.getTypeDeclType(
Enum, PrevDecl);
4697 nullptr,
nullptr,
false,
false,
false);
4698 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4704 return TI->getTypeLoc().getSourceRange();
4710 unsigned NumPositiveBits,
4711 unsigned NumNegativeBits) {
4715 PromotionType = NewPromotionType;
4716 setNumPositiveBits(NumPositiveBits);
4717 setNumNegativeBits(NumNegativeBits);
4722 if (
const auto *A = getAttr<EnumExtensibilityAttr>())
4723 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4728 return isClosed() && hasAttr<FlagEnumAttr>();
4732 return isClosed() && !hasAttr<FlagEnumAttr>();
4737 return MSI->getTemplateSpecializationKind();
4745 assert(MSI &&
"Not an instantiated member enumeration?");
4748 PointOfInstantiation.
isValid() &&
4764 "couldn't find pattern for enum instantiation");
4769 if (SpecializationInfo)
4777 assert(!SpecializationInfo &&
"Member enum is already a specialization");
4787 setHasODRHash(
true);
4798 Res.setEnd(TSI->getTypeLoc().getEndLoc());
4808 if (NumNegativeBits) {
4809 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
4810 Max = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
4813 Max = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
4814 Min = llvm::APInt::getZero(Bitwidth);
4826 :
TagDecl(DK, TK,
C, DC, IdLoc,
Id, PrevDecl, StartLoc) {
4827 assert(
classof(
static_cast<Decl *
>(
this)) &&
"Invalid Kind!");
4849 StartLoc, IdLoc,
Id, PrevDecl);
4852 C.getTypeDeclType(R, PrevDecl);
4870 if (
auto RD = dyn_cast<CXXRecordDecl>(
this))
4871 return RD->isLambda();
4876 return hasAttr<CapturedRecordAttr>();
4888 for (
const FieldDecl *FD : Def->fields()) {
4900 LoadFieldsFromExternalStorage();
4904 return D->field_begin();
4926 return hasAttr<MSStructAttr>() ||
C.getLangOpts().MSBitfields == 1;
4935void RecordDecl::LoadFieldsFromExternalStorage()
const {
4950 for (
unsigned i=0, e=Decls.size(); i != e; ++i)
4951 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
4957 auto [ExternalFirst, ExternalLast] =
4960 ExternalLast->NextInContextAndBits.setPointer(
FirstDecl);
4969 (SanitizerKind::Address | SanitizerKind::KernelAddress);
4970 if (!EnabledAsanMask || !Context.
getLangOpts().SanitizeAddressFieldPadding)
4973 const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this);
4975 int ReasonToReject = -1;
4976 if (!CXXRD || CXXRD->isExternCContext())
4978 else if (CXXRD->hasAttr<PackedAttr>())
4980 else if (CXXRD->isUnion())
4982 else if (CXXRD->isTriviallyCopyable())
4984 else if (CXXRD->hasTrivialDestructor())
4986 else if (CXXRD->isStandardLayout())
4996 if (ReasonToReject >= 0)
4999 diag::remark_sanitize_address_insert_extra_padding_rejected)
5004 diag::remark_sanitize_address_insert_extra_padding_accepted)
5007 return ReasonToReject < 0;
5011 for (
const auto *I :
fields()) {
5012 if (I->getIdentifier())
5015 if (
const auto *RT = I->getType()->getAs<
RecordType>())
5017 RT->getDecl()->findFirstNamedDataMember())
5018 return NamedDataMember;