55 #include "llvm/ADT/APSInt.h"
56 #include "llvm/ADT/ArrayRef.h"
57 #include "llvm/ADT/None.h"
58 #include "llvm/ADT/Optional.h"
59 #include "llvm/ADT/STLExtras.h"
60 #include "llvm/ADT/SmallVector.h"
61 #include "llvm/ADT/StringRef.h"
62 #include "llvm/ADT/StringSwitch.h"
63 #include "llvm/ADT/Triple.h"
64 #include "llvm/Support/Casting.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/raw_ostream.h"
74 #include <type_traits>
76 using namespace clang;
91 if (
auto *ND = dyn_cast_or_null<NamedDecl>(TheDecl)) {
105 TranslationUnitDecl::TranslationUnitDecl(
ASTContext &ctx)
107 DeclContext(TranslationUnit), redeclarable_base(ctx), Ctx(ctx) {}
169 Kind.IgnoreExplicitVisibility =
true;
175 assert(!
kind.IgnoreExplicitVisibility &&
176 "asking for explicit visibility when we shouldn't be");
183 return isa<TypeDecl>(D) ||
184 isa<ClassTemplateDecl>(D) ||
185 isa<ObjCInterfaceDecl>(D);
190 template <
class T>
static typename
191 std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value,
bool>
::type
194 D->getMemberSpecializationInfo()) {
195 return member->isExplicitSpecialization();
211 switch (
attr->getVisibility()) {
219 llvm_unreachable(
"bad visibility kind");
228 if (
const auto *A = D->
getAttr<TypeVisibilityAttr>()) {
234 if (
const auto *A = D->
getAttr<VisibilityAttr>()) {
251 LinkageInfo LinkageComputer::getLVForTemplateParameterList(
257 if (isa<TemplateTypeParmDecl>(
P))
264 if (
const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
P)) {
266 if (!NTTP->isExpandedParameterPack()) {
267 if (!NTTP->getType()->isDependentType()) {
268 LV.
merge(getLVForType(*NTTP->getType(), computation));
274 for (
unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
276 if (!
type->isDependentType())
284 const auto *TTP = cast<TemplateTemplateParmDecl>(
P);
287 if (!TTP->isExpandedParameterPack()) {
288 LV.
merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
294 for (
unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
296 LV.
merge(getLVForTemplateParameterList(
297 TTP->getExpansionTemplateParameters(i), computation));
307 while (DC->
getDeclKind() != Decl::TranslationUnit) {
308 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
309 Ret = cast<Decl>(DC);
326 switch (Arg.getKind()) {
333 LV.
merge(getLVForType(*Arg.getAsType(), computation));
350 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
355 LV.
merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
358 llvm_unreachable(
"bad template argument kind");
367 return getLVForTemplateArgumentList(TArgs.
asArray(), computation);
379 return !fn->
hasAttr<VisibilityAttr>();
389 void LinkageComputer::mergeTemplateLV(
393 bool considerVisibility =
411 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
464 void LinkageComputer::mergeTemplateLV(
482 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
483 if (considerVisibility)
516 void LinkageComputer::mergeTemplateLV(
LinkageInfo &LV,
534 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
535 if (considerVisibility)
543 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
546 const auto *FD = dyn_cast<FunctionDecl>(D);
552 = FD->getTemplateSpecializationInfo()) {
555 FD->getMemberSpecializationInfo()) {
556 TSK = MSI->getTemplateSpecializationKind();
569 const T *
First = D->getFirstDecl();
570 return First->isInExternCContext();
574 if (
const auto *SD = dyn_cast<LinkageSpecDecl>(D.
getDeclContext()))
575 if (!SD->hasBraces())
583 return M->isModulePurview();
597 llvm_unreachable(
"unexpected module ownership kind");
624 !isa<NamespaceDecl>(D))
631 if (
auto *TD = dyn_cast<TemplateDecl>(D))
632 D = TD->getTemplatedDecl();
634 if (
auto *VD = dyn_cast<VarDecl>(D))
635 return VD->getStorageClass();
636 if (
auto *FD = dyn_cast<FunctionDecl>(D))
637 return FD->getStorageClass();
643 LinkageComputer::getLVForNamespaceScopeDecl(
const NamedDecl *D,
645 bool IgnoreVarTypeLinkage) {
647 "Not a name having namespace scope");
661 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
669 Var->getType().isConstQualified() &&
670 !Var->getType().isVolatileQualified() &&
673 !isa<VarTemplateSpecializationDecl>(Var) &&
674 !Var->getDescribedVarTemplate()) {
679 if (Var->getStorageClass() !=
SC_Extern &&
688 Var->getStorageClass() ==
SC_None)
694 }
else if (
const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
696 const VarDecl *VD = IFD->getVarDecl();
697 assert(VD &&
"Expected a VarDecl in this IndirectFieldDecl!");
698 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
700 assert(!isa<FieldDecl>(D) &&
"Didn't expect a FieldDecl!");
705 const auto *Var = dyn_cast<VarDecl>(D);
706 const auto *Func = dyn_cast<FunctionDecl>(D);
734 !isa<TranslationUnitDecl>(DC);
736 const auto *ND = dyn_cast<NamespaceDecl>(DC);
777 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
801 !IgnoreVarTypeLinkage) {
802 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
819 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
820 mergeTemplateLV(LV, spec, computation);
824 }
else if (
const auto *Function = dyn_cast<FunctionDecl>(D)) {
846 TypeAsWritten = TSI->getType();
855 =
Function->getTemplateSpecializationInfo()) {
856 mergeTemplateLV(LV, Function, specInfo, computation);
865 }
else if (
const auto *Tag = dyn_cast<TagDecl>(D)) {
867 if (!Tag->hasNameForLinkage())
873 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
874 mergeTemplateLV(LV, spec, computation);
879 }
else if (isa<EnumConstantDecl>(D)) {
887 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
898 }
else if (isa<NamespaceDecl>(D)) {
903 }
else if (isa<ObjCInterfaceDecl>(D)) {
906 }
else if (
auto *TD = dyn_cast<TypedefNameDecl>(D)) {
909 if (!TD->getAnonDeclWithTypedefName(
true))
912 }
else if (isa<MSGuidDecl>(D)) {
930 LinkageComputer::getLVForClassMember(
const NamedDecl *D,
932 bool IgnoreVarTypeLinkage) {
943 if (!(isa<CXXMethodDecl>(D) ||
946 isa<IndirectFieldDecl>(D) ||
948 isa<TemplateDecl>(D)))
986 const NamedDecl *explicitSpecSuppressor =
nullptr;
988 if (
const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
991 QualType TypeAsWritten = MD->getType();
993 TypeAsWritten = TSI->getType();
1000 = MD->getTemplateSpecializationInfo()) {
1001 mergeTemplateLV(LV, MD, spec, computation);
1003 explicitSpecSuppressor = MD;
1005 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
1008 explicitSpecSuppressor = MD;
1011 }
else if (
const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
1012 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
1013 mergeTemplateLV(LV, spec, computation);
1015 explicitSpecSuppressor = spec;
1023 explicitSpecSuppressor = RD;
1027 }
else if (
const auto *VD = dyn_cast<VarDecl>(D)) {
1028 if (
const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1029 mergeTemplateLV(LV, spec, computation);
1033 if (!IgnoreVarTypeLinkage) {
1043 explicitSpecSuppressor = VD;
1047 }
else if (
const auto *temp = dyn_cast<TemplateDecl>(D)) {
1048 bool considerVisibility =
1056 if (
const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1064 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1068 bool considerClassVisibility =
true;
1069 if (explicitSpecSuppressor &&
1074 considerClassVisibility =
false;
1083 void NamedDecl::anchor() {}
1121 if (
auto *VD = dyn_cast<VarDecl>(
this))
1124 if (
auto *FD = dyn_cast<FunctionDecl>(
this))
1125 if (FD->isExternC())
1137 if (
name.front() ==
'C')
1138 if (
name ==
"CFStringCreateWithFormat" ||
1139 name ==
"CFStringCreateWithFormatAndArguments" ||
1140 name ==
"CFStringAppendFormat" ||
1141 name ==
"CFStringAppendFormatAndArguments")
1161 bool IsMostRecent) {
1170 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1172 if (InstantiatedFrom)
1179 if (
const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1183 while (TD !=
nullptr) {
1187 TD = TD->getPreviousDecl();
1193 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1195 if (MostRecent != ND)
1199 if (
const auto *Var = dyn_cast<VarDecl>(ND)) {
1200 if (Var->isStaticDataMember()) {
1202 if (InstantiatedFrom)
1206 if (
const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1207 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1213 if (
const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1218 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1224 if (InstantiatedFrom)
1231 if (
const auto *TD = dyn_cast<TemplateDecl>(ND))
1248 Owner = dyn_cast<NamedDecl>(DC);
1249 else if (isa<ParmVarDecl>(ContextDecl))
1253 Owner = cast<NamedDecl>(ContextDecl);
1262 auto *VD = dyn_cast<VarDecl>(Owner);
1278 if (
const auto *Function = dyn_cast<FunctionDecl>(D)) {
1279 if (Function->isInAnonymousNamespace() &&
1284 if (Function->getCanonicalDecl()->getStorageClass() ==
SC_Static)
1301 if (
const auto *Var = dyn_cast<VarDecl>(D)) {
1302 if (Var->hasExternalStorage()) {
1324 if (!Var->isStaticLocal())
1337 if (
const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1338 if (!BD->getBlockManglingNumber())
1341 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1342 BD->getBlockManglingContextDecl(), computation);
1344 const auto *FD = cast<FunctionDecl>(OuterD);
1345 if (!FD->isInlined() &&
1355 !Context.
getLangOpts().VisibilityInlinesHiddenStaticLocalVar) {
1356 assert(cast<VarDecl>(D)->isStaticLocal());
1360 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1380 bool IgnoreVarTypeLinkage) {
1382 if (D->
hasAttr<InternalLinkageAttr>())
1397 case Decl::ImplicitParam:
1399 case Decl::NamespaceAlias:
1402 case Decl::UsingEnum:
1403 case Decl::UsingShadow:
1404 case Decl::UsingDirective:
1407 case Decl::EnumConstant:
1414 case Decl::TypeAlias:
1417 if (!cast<TypedefNameDecl>(D)
1418 ->getAnonDeclWithTypedefName(
true))
1422 case Decl::TemplateTemplateParm:
1423 case Decl::NonTypeTemplateParm:
1424 case Decl::ObjCAtDefsField:
1425 case Decl::ObjCCategory:
1426 case Decl::ObjCCategoryImpl:
1427 case Decl::ObjCCompatibleAlias:
1428 case Decl::ObjCImplementation:
1429 case Decl::ObjCMethod:
1430 case Decl::ObjCProperty:
1431 case Decl::ObjCPropertyImpl:
1432 case Decl::ObjCProtocol:
1435 case Decl::CXXRecord: {
1436 const auto *Record = cast<CXXRecordDecl>(D);
1437 if (Record->isLambda()) {
1438 if (Record->hasKnownLambdaInternalLinkage() ||
1439 !Record->getLambdaManglingNumber()) {
1444 return getLVForClosure(
1445 Record->getDeclContext()->getRedeclContext(),
1446 Record->getLambdaContextDecl(), computation);
1452 case Decl::TemplateParamObject: {
1455 auto *TPO = cast<TemplateParamObjectDecl>(D);
1456 LinkageInfo LV = getLVForType(*TPO->getType(), computation);
1457 LV.
merge(getLVForValue(TPO->getValue(), computation));
1464 return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1474 return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1488 return getLVForLocalDecl(D, computation);
1499 if (D->
hasAttr<InternalLinkageAttr>())
1513 cache(D, computation, LV);
1520 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1528 auto *T = cast<NamedDecl>(I);
1531 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1553 if (isa<NamespaceDecl>(
this))
1584 if (
auto *ND = dyn_cast<NamedDecl>(
this))
1598 llvm_unreachable(
"unknown module kind");
1607 llvm::raw_string_ostream OS(QualName);
1630 llvm::raw_svector_ostream NameOS(NameBuffer);
1632 if (NameBuffer.empty())
1633 OS <<
"(anonymous)";
1649 if (
auto *MD = dyn_cast<ObjCMethodDecl>(
this)) {
1650 if (
auto *
ID = MD->getClassInterface())
1652 }
else if (
auto *PD = dyn_cast<ObjCPropertyDecl>(
this)) {
1653 if (
auto *MD = PD->getGetterMethodDecl())
1654 if (
auto *
ID = MD->getClassInterface())
1656 }
else if (
auto *
ID = dyn_cast<ObjCIvarDecl>(
this)) {
1657 if (
auto *CI =
ID->getContainingInterface())
1665 ContextsTy Contexts;
1671 if (
P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1672 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1677 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(NameInScope))
1681 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1685 Contexts.push_back(Ctx);
1689 for (
const DeclContext *DC : llvm::reverse(Contexts)) {
1690 if (
const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1691 OS << Spec->getName();
1695 Spec->getSpecializedTemplate()->getTemplateParameters());
1696 }
else if (
const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1697 if (ND->isAnonymousNamespace()) {
1698 OS << (
P.MSVCFormatting ?
"`anonymous namespace\'"
1699 :
"(anonymous namespace)");
1703 }
else if (
const auto *RD = dyn_cast<RecordDecl>(DC)) {
1704 if (!RD->getIdentifier())
1705 OS <<
"(anonymous " << RD->getKindName() <<
')';
1708 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1710 if (FD->hasWrittenPrototype())
1711 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<
FunctionType>());
1715 unsigned NumParams = FD->getNumParams();
1716 for (
unsigned i = 0; i < NumParams; ++i) {
1719 OS << FD->getParamDecl(i)->getType().stream(
P);
1729 }
else if (
const auto *ED = dyn_cast<EnumDecl>(DC)) {
1742 OS << *cast<NamedDecl>(DC);
1763 #define DECL(Type, Base) \
1765 return isRedeclarableImpl((Type##Decl *)nullptr);
1766 #define ABSTRACT_DECL(DECL)
1767 #include "clang/AST/DeclNodes.inc"
1769 llvm_unreachable(
"unknown decl kind");
1785 if (isa<ObjCMethodDecl>(
this))
1790 if (isa<ParmVarDecl>(
this))
1802 if (
auto *UD = dyn_cast<UsingDecl>(
this)) {
1806 cast<UsingDecl>(OldD)->getQualifier());
1808 if (
auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(
this)) {
1812 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1852 NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1854 if (
auto *UD = dyn_cast<UsingShadowDecl>(ND))
1855 ND = UD->getTargetDecl();
1857 if (
auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1858 return AD->getClassInterface();
1860 if (
auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1861 return AD->getNamespace();
1871 if (isa<UsingShadowDecl>(D))
1872 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1874 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1876 if (
const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D->
getAsFunction()))
1877 return MD->isInstance();
1885 template <
typename DeclT>
1887 if (
decl->getNumTemplateParameterLists() > 0)
1888 return decl->getTemplateParameterList(0)->getTemplateLoc();
1889 return decl->getInnerLocStart();
1907 if (!hasExtInfo()) {
1913 getExtInfo()->TInfo = savedTInfo;
1916 getExtInfo()->QualifierLoc = QualifierLoc;
1917 }
else if (hasExtInfo()) {
1919 getExtInfo()->QualifierLoc = QualifierLoc;
1924 assert(TrailingRequiresClause);
1926 if (!hasExtInfo()) {
1932 getExtInfo()->TInfo = savedTInfo;
1935 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
1940 assert(!TPLists.empty());
1942 if (!hasExtInfo()) {
1948 getExtInfo()->TInfo = savedTInfo;
1951 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
1969 case Type::BlockPointer:
1972 case Type::MemberPointer:
1975 case Type::LValueReference:
1976 case Type::RValueReference:
1979 case Type::PackExpansion:
1980 QT = cast<PackExpansionType>(T)->getPattern();
1983 case Type::ConstantArray:
1984 case Type::DependentSizedArray:
1985 case Type::IncompleteArray:
1986 case Type::VariableArray:
1987 case Type::FunctionProto:
1988 case Type::FunctionNoProto:
2000 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2014 if (!TPLists.empty()) {
2035 llvm_unreachable(
"Invalid storage class");
2044 static_assert(
sizeof(VarDeclBitfields) <=
sizeof(
unsigned),
2045 "VarDeclBitfields too large!");
2047 "ParmVarDeclBitfields too large!");
2049 "NonParmVarDeclBitfields too large!");
2058 return new (C, DC)
VarDecl(Var, C, DC, StartL, IdL,
Id, T, TInfo, S);
2075 if (!hasAttr<ThreadAttr>() &&
2078 hasAttr<OMPThreadPrivateDeclAttr>()))
2082 hasAttr<OMPThreadPrivateDeclAttr>())
2091 llvm_unreachable(
"Unknown thread storage class specifier!");
2105 template<
typename T>
2109 if (!D.hasExternalFormalLinkage())
2133 template<
typename T>
2139 assert(D.getASTContext().getLangOpts().CPlusPlus);
2194 isa<VarTemplatePartialSpecializationDecl>(
this)))
2213 if (
const auto *SAA = getAttr<SelectAnyAttr>())
2214 if (!SAA->isInherited())
2220 if (
auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2222 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2223 !VTSD->IsCompleteDefinition)
2255 VarDecl *LastTentative =
nullptr;
2260 Kind =
Decl->isThisDeclarationADefinition();
2265 LastTentative =
Decl;
2268 return LastTentative;
2274 if (I->isThisDeclarationADefinition(C) ==
Definition)
2295 if (
auto Expr = I->getInit()) {
2304 if (
auto *
P = dyn_cast<ParmVarDecl>(
this))
2305 if (
P->hasUnparsedDefaultArg() ||
P->hasUninstantiatedDefaultArg())
2308 return !
Init.isNull();
2315 if (
auto *S =
Init.dyn_cast<
Stmt *>())
2316 return cast<Expr>(S);
2325 return Init.getAddrOfPtr1();
2334 if (I->isThisDeclarationADefinition()) {
2361 Eval->~EvaluatedStmt();
2373 if (!Lang.CPlusPlus && !Lang.OpenCL)
2377 if (isa<ParmVarDecl>(
this))
2386 if (Lang.CPlusPlus11 &&
getType()->isReferenceType())
2397 if (
getType()->isIntegralOrEnumerationType())
2409 const VarDecl *DefVD =
nullptr;
2411 if (!
Init ||
Init->isValueDependent() ||
getType()->isDependentType())
2457 bool IsConstantInitialization)
const {
2460 const auto *
Init = cast<Expr>(Eval->
Value);
2461 assert(!
Init->isValueDependent());
2477 bool Result =
Init->EvaluateAsInitializer(Eval->
Evaluated, Ctx,
this, Notes,
2478 IsConstantInitialization);
2483 if (IsConstantInitialization && Ctx.
getLangOpts().CPlusPlus11 &&
2498 return Result ? &Eval->
Evaluated :
nullptr;
2511 assert(
Init &&
"no initializer");
2541 "already evaluated var value before checking for constant init");
2544 assert(!cast<Expr>(Eval->
Value)->isValueDependent());
2548 evaluateValueImpl(Notes,
true) && Notes.empty();
2559 return isa<PackExpansionType>(
getType());
2562 template<
typename DeclT>
2565 if (
auto *Def = D->getDefinition())
2581 llvm::any_of(specific_attrs<AlignedAttr>(), [](
const AlignedAttr *AA) {
2582 return AA->isAlignmentDependent();
2601 if (
auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2603 auto From = VDTemplSpec->getInstantiatedFrom();
2605 while (!VTD->isMemberSpecialization()) {
2606 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2615 while (!VTPSD->isMemberSpecialization()) {
2616 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2621 return getDefinitionOrSelf<VarDecl>(VTPSD);
2629 while (!VarTemplate->isMemberSpecialization()) {
2630 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2633 VarTemplate = NewVT;
2646 return cast<VarDecl>(MSI->getInstantiatedFrom());
2652 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2653 return Spec->getSpecializationKind();
2656 return MSI->getTemplateSpecializationKind();
2664 return MSI->getTemplateSpecializationKind();
2666 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2667 return Spec->getSpecializationKind();
2673 if (
const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(
this))
2674 return Spec->getPointOfInstantiation();
2677 return MSI->getPointOfInstantiation();
2700 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2702 isa<IncompleteArrayType>(
getType()))
2711 !hasAttr<AlwaysDestroyAttr>()));
2727 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2729 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2731 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2734 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2738 return InitTy->
getSize() != 0;
2742 assert(
hasInit() &&
"Expect initializer to check for flexible array init");
2744 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2746 auto *List = dyn_cast<InitListExpr>(
getInit()->IgnoreParens());
2749 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2757 if (FlexibleArrayOffset + FlexibleArraySize < RL.
getSize())
2759 return FlexibleArrayOffset + FlexibleArraySize - RL.
getSize();
2773 assert((isa<VarTemplateSpecializationDecl>(
this) ||
2775 "not a variable or static data member template specialization");
2778 dyn_cast<VarTemplateSpecializationDecl>(
this)) {
2779 Spec->setSpecializationKind(TSK);
2781 PointOfInstantiation.
isValid() &&
2782 Spec->getPointOfInstantiation().isInvalid()) {
2783 Spec->setPointOfInstantiation(PointOfInstantiation);
2785 L->InstantiationRequested(
this);
2788 MSI->setTemplateSpecializationKind(TSK);
2790 MSI->getPointOfInstantiation().isInvalid()) {
2791 MSI->setPointOfInstantiation(PointOfInstantiation);
2793 L->InstantiationRequested(
this);
2801 assert(
getASTContext().getTemplateOrSpecializationInfo(
this).isNull() &&
2802 "Previous template or instantiation?");
2815 return new (C, DC)
ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc,
Id, T, TInfo,
2822 if (
const auto *DT = dyn_cast<DecayedType>(T))
2823 return DT->getOriginalType();
2850 if (hasAttr<NSConsumedAttr>())
2856 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2866 "Default argument is not yet instantiated!");
2869 if (
auto *E = dyn_cast_or_null<FullExpr>(Arg))
2870 if (!isa<ConstantExpr>(E))
2871 return E->getSubExpr();
2893 return E->getSourceRange();
2898 llvm_unreachable(
"Invalid default argument kind.");
2908 "Wrong kind of initialization expression!");
2909 return cast_or_null<Expr>(
Init.get<
Stmt *>());
2920 void ParmVarDecl::setParameterIndexLarge(
unsigned parameterIndex) {
2925 unsigned ParmVarDecl::getParameterIndexLarge()
const {
2937 bool UsesFPIntrin,
bool isInlineSpecified,
2939 Expr *TrailingRequiresClause)
2943 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.
getInfo()) {
2970 if (TrailingRequiresClause)
2983 if (
const auto *FT =
getType()->getAs<FunctionProtoType>())
2984 return FT->isVariadic();
2992 totalSizeToAlloc<DeclAccessPair>(Lookups.size()),
2995 Info->NumLookups = Lookups.size();
2996 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3003 assert(!
Body &&
"can't replace function body with defaulted function info");
3016 if (I->doesThisDeclarationHaveABody()) {
3033 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3046 return InstantiatedFrom->getFriendObjectKind() &&
3047 InstantiatedFrom->isThisDeclarationADefinition();
3054 return InstantiatedFrom->getFriendObjectKind() &&
3055 InstantiatedFrom->isThisDeclarationADefinition();
3062 bool CheckForPendingFriendDefinition)
const {
3064 if (FD->isThisDeclarationADefinition()) {
3084 if (CheckForPendingFriendDefinition &&
3085 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3098 assert(!Definition->FunctionDeclBits.HasDefaultedFunctionInfo &&
3099 "definition should not have a body");
3100 if (Definition->Body)
3101 return Definition->Body.get(
getASTContext().getExternalSource());
3117 Parent->markedVirtualFunctionPure();
3120 template<std::
size_t Len>
3123 return II && II->
isStr(Str);
3151 return llvm::StringSwitch<bool>(
getName())
3163 assert(
getDeclName().getCXXOverloadedOperator() == OO_New ||
3164 getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3165 getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
3166 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
3172 if (proto->getNumParams() != 2 || proto->isVariadic())
3181 return (proto->getParamType(1).getCanonicalType() == Context.
VoidPtrTy);
3188 if (
getDeclName().getCXXOverloadedOperator() != OO_New &&
3189 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3190 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3191 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3202 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
3207 if (FPT->getNumParams() == 1)
3210 unsigned Params = 1;
3211 QualType Ty = FPT->getParamType(Params);
3214 auto Consume = [&] {
3216 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) :
QualType();
3220 bool IsSizedDelete =
false;
3222 (
getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3223 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3225 IsSizedDelete =
true;
3234 *AlignmentParam = Params;
3250 return Params == FPT->getNumParams();
3258 return hasBody(Definition) && Definition->isInlineSpecified() &&
3259 Definition->hasAttr<AlwaysInlineAttr>() &&
3260 Definition->hasAttr<GNUInlineAttr>();
3274 RD->getIdentifier()->isStr(
"destroying_delete_t");
3286 if (hasAttr<OpenCLKernelAttr>())
3296 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
this))
3297 return Method->isStatic();
3305 if (
const auto *Namespace = cast<NamespaceDecl>(DC)) {
3306 if (!Namespace->getDeclName())
3315 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3316 hasAttr<C11NoReturnAttr>())
3319 if (
auto *FnTy =
getType()->getAs<FunctionType>())
3320 return FnTy->getNoReturnAttr();
3327 if (hasAttr<TargetAttr>())
3329 if (hasAttr<CPUDispatchAttr>())
3331 if (hasAttr<CPUSpecificAttr>())
3333 if (hasAttr<TargetClonesAttr>())
3361 assert((!PrevDecl || PrevFunTmpl) &&
"Function/function template mismatch");
3362 FunTmpl->setPreviousDecl(PrevFunTmpl);
3385 unsigned BuiltinID = 0;
3387 if (
const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3388 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3389 }
else if (
const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3390 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3391 }
else if (
const auto *A = getAttr<BuiltinAttr>()) {
3392 BuiltinID = A->getID();
3400 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3401 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3424 if (Context.
getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3425 !hasAttr<CUDAHostAttr>() &&
3426 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3435 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3451 assert(!ParamInfo &&
"Already has param info!");
3452 assert(NewParamInfo.size() ==
getNumParams() &&
"Parameter count mismatch!");
3455 if (!NewParamInfo.empty()) {
3456 ParamInfo =
new (C)
ParmVarDecl*[NewParamInfo.size()];
3457 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3471 unsigned NumRequiredArgs = 0;
3472 unsigned MinParamsSoFar = 0;
3474 if (!Param->isParameterPack()) {
3476 if (!Param->hasDefaultArg())
3477 NumRequiredArgs = MinParamsSoFar;
3480 return NumRequiredArgs;
3496 assert(
isInlined() &&
"expected to get called on an inlined function!");
3500 !hasAttr<DLLExportAttr>())
3505 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3517 if (!FD->isImplicit() && FD->getStorageClass() ==
SC_Extern)
3547 "Must have a declaration without a body.");
3553 if (
hasBody(Definition) && Definition->isInlined() &&
3561 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3571 bool FoundBody =
false;
3596 bool FoundBody =
false;
3621 !
SM.isBeforeInTranslationUnit(RTRange.
getEnd(), Boundary))
3667 hasAttr<AliasAttr>()) &&
3668 "Must be a function definition");
3669 assert(
isInlined() &&
"Function must be inline");
3672 if (Context.
getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3686 for (
auto Redecl :
redecls()) {
3687 if (Redecl->isInlineSpecified() &&
3697 "should not use C inline rules in C++");
3703 for (
auto Redecl :
redecls()) {
3732 if (TemplateOrSpecialization.isNull())
3740 if (TemplateOrSpecialization.is
3744 llvm_unreachable(
"Did we miss a TemplateOrSpecialization type?");
3749 return cast<FunctionDecl>(Info->getInstantiatedFrom());
3758 if (
auto *FTSI = TemplateOrSpecialization
3759 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3760 return FTSI->getMemberSpecializationInfo();
3765 FunctionDecl::setInstantiationOfMemberFunction(
ASTContext &C,
3768 assert(TemplateOrSpecialization.isNull() &&
3769 "Member function is already a specialization");
3772 TemplateOrSpecialization = Info;
3780 assert(TemplateOrSpecialization.isNull() &&
3781 "Member function is already a specialization");
3782 TemplateOrSpecialization = Template;
3806 bool HasPattern =
false;
3808 HasPattern = PatternDecl->
hasBody(PatternDecl);
3814 if (!HasPattern || !PatternDecl)
3838 dyn_cast<CXXMethodDecl>(
this))) {
3863 while (!
ForDefinition || !Primary->isMemberSpecialization()) {
3864 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
3867 Primary = NewPrimary;
3878 = TemplateOrSpecialization
3879 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3880 return Info->getTemplate();
3887 return TemplateOrSpecialization
3894 = TemplateOrSpecialization
3895 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3896 return Info->TemplateArguments;
3904 = TemplateOrSpecialization
3905 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3906 return Info->TemplateArgumentsAsWritten;
3912 FunctionDecl::setFunctionTemplateSpecialization(
ASTContext &C,
3919 assert((TemplateOrSpecialization.isNull() ||
3921 "Member function is already a specialization");
3923 "Must specify the type of function template specialization");
3924 assert((TemplateOrSpecialization.isNull() ||
3926 "Member specialization must be an explicit specialization");
3929 C,
this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
3930 PointOfInstantiation,
3932 TemplateOrSpecialization = Info;
3940 assert(TemplateOrSpecialization.isNull());
3944 TemplateOrSpecialization = Info;
3949 return TemplateOrSpecialization
3958 totalSizeToAlloc<TemplateArgumentLoc, FunctionTemplateDecl *>(
3963 DependentFunctionTemplateSpecializationInfo::
3966 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
3967 NumTemplates = Ts.
size();
3968 NumArgs = TArgs.
size();
3971 for (
unsigned I = 0, E = Ts.
size(); I != E; ++I)
3972 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
3975 for (
unsigned I = 0, E = TArgs.
size(); I != E; ++I)
3983 TemplateOrSpecialization
3984 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3985 return FTSInfo->getTemplateSpecializationKind();
3989 return MSInfo->getTemplateSpecializationKind();
4014 TemplateOrSpecialization
4015 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
4016 if (
auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4017 return MSInfo->getTemplateSpecializationKind();
4018 return FTSInfo->getTemplateSpecializationKind();
4023 return MSInfo->getTemplateSpecializationKind();
4032 = TemplateOrSpecialization.dyn_cast<
4034 FTSInfo->setTemplateSpecializationKind(TSK);
4036 PointOfInstantiation.
isValid() &&
4037 FTSInfo->getPointOfInstantiation().isInvalid()) {
4038 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4040 L->InstantiationRequested(
this);
4044 MSInfo->setTemplateSpecializationKind(TSK);
4046 PointOfInstantiation.
isValid() &&
4047 MSInfo->getPointOfInstantiation().isInvalid()) {
4048 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4050 L->InstantiationRequested(
this);
4053 llvm_unreachable(
"Function cannot have a template specialization kind");
4058 = TemplateOrSpecialization.dyn_cast<
4060 return FTSInfo->getPointOfInstantiation();
4063 return MSInfo->getPointOfInstantiation();
4077 return Definition->isOutOfLine();
4084 if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
4085 return Definition->isOutOfLine();
4103 case Builtin::BI__builtin_memset:
4104 case Builtin::BI__builtin___memset_chk:
4105 case Builtin::BImemset:
4106 return Builtin::BImemset;
4108 case Builtin::BI__builtin_memcpy:
4109 case Builtin::BI__builtin___memcpy_chk:
4110 case Builtin::BImemcpy:
4111 return Builtin::BImemcpy;
4113 case Builtin::BI__builtin_mempcpy:
4114 case Builtin::BI__builtin___mempcpy_chk:
4115 case Builtin::BImempcpy:
4116 return Builtin::BImempcpy;
4118 case Builtin::BI__builtin_memmove:
4119 case Builtin::BI__builtin___memmove_chk:
4120 case Builtin::BImemmove:
4121 return Builtin::BImemmove;
4123 case Builtin::BIstrlcpy:
4124 case Builtin::BI__builtin___strlcpy_chk:
4125 return Builtin::BIstrlcpy;
4127 case Builtin::BIstrlcat:
4128 case Builtin::BI__builtin___strlcat_chk:
4129 return Builtin::BIstrlcat;
4131 case Builtin::BI__builtin_memcmp:
4132 case Builtin::BImemcmp:
4133 return Builtin::BImemcmp;
4135 case Builtin::BI__builtin_bcmp:
4136 case Builtin::BIbcmp:
4137 return Builtin::BIbcmp;
4139 case Builtin::BI__builtin_strncpy:
4140 case Builtin::BI__builtin___strncpy_chk:
4141 case Builtin::BIstrncpy:
4142 return Builtin::BIstrncpy;
4144 case Builtin::BI__builtin_strncmp:
4145 case Builtin::BIstrncmp:
4146 return Builtin::BIstrncmp;
4148 case Builtin::BI__builtin_strncasecmp:
4149 case Builtin::BIstrncasecmp:
4150 return Builtin::BIstrncasecmp;
4152 case Builtin::BI__builtin_strncat:
4153 case Builtin::BI__builtin___strncat_chk:
4154 case Builtin::BIstrncat:
4155 return Builtin::BIstrncat;
4157 case Builtin::BI__builtin_strndup:
4158 case Builtin::BIstrndup:
4159 return Builtin::BIstrndup;
4161 case Builtin::BI__builtin_strlen:
4162 case Builtin::BIstrlen:
4163 return Builtin::BIstrlen;
4165 case Builtin::BI__builtin_bzero:
4166 case Builtin::BIbzero:
4167 return Builtin::BIbzero;
4169 case Builtin::BIfree:
4170 return Builtin::BIfree;
4174 if (FnInfo->
isStr(
"memset"))
4175 return Builtin::BImemset;
4176 if (FnInfo->
isStr(
"memcpy"))
4177 return Builtin::BImemcpy;
4178 if (FnInfo->
isStr(
"mempcpy"))
4179 return Builtin::BImempcpy;
4180 if (FnInfo->
isStr(
"memmove"))
4181 return Builtin::BImemmove;
4182 if (FnInfo->
isStr(
"memcmp"))
4183 return Builtin::BImemcmp;
4184 if (FnInfo->
isStr(
"bcmp"))
4185 return Builtin::BIbcmp;
4186 if (FnInfo->
isStr(
"strncpy"))
4187 return Builtin::BIstrncpy;
4188 if (FnInfo->
isStr(
"strncmp"))
4189 return Builtin::BIstrncmp;
4190 if (FnInfo->
isStr(
"strncasecmp"))
4191 return Builtin::BIstrncasecmp;
4192 if (FnInfo->
isStr(
"strncat"))
4193 return Builtin::BIstrncat;
4194 if (FnInfo->
isStr(
"strndup"))
4195 return Builtin::BIstrndup;
4196 if (FnInfo->
isStr(
"strlen"))
4197 return Builtin::BIstrlen;
4198 if (FnInfo->
isStr(
"bzero"))
4199 return Builtin::BIbzero;
4201 if (FnInfo->
isStr(
"free"))
4202 return Builtin::BIfree;
4210 assert(hasODRHash());
4219 setHasODRHash(
true);
4226 setHasODRHash(
true);
4240 return new (
C, DC)
FieldDecl(Decl::Field, DC, StartLoc, IdLoc,
Id, T, TInfo,
4241 BW, Mutable, InitStyle);
4254 if (
const auto *Record =
getType()->getAs<RecordType>())
4255 return Record->getDecl()->isAnonymousStructOrUnion();
4277 if (!hasAttr<NoUniqueAddressAttr>())
4286 assert(
isInvalidDecl() &&
"valid field has incomplete type");
4292 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4293 if (!CXXRD->isEmpty())
4305 if (Canonical !=
this)
4308 if (CachedFieldIndex)
return CachedFieldIndex - 1;
4312 assert(RD &&
"requested index for field of struct with no definition");
4314 for (
auto *Field : RD->
fields()) {
4315 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4319 assert(CachedFieldIndex &&
"failed to find field in parent");
4320 return CachedFieldIndex - 1;
4334 "capturing type in non-lambda or captured record.");
4335 assert(InitStorage.getInt() == ISK_NoInit &&
4336 InitStorage.getPointer() ==
nullptr &&
4337 "bit width, initializer or captured type already set");
4339 ISK_CapturedVLAType);
4352 "EnumDecl not matched with TTK_Enum");
4360 TagDeclBits.IsThisDeclarationADemotedDefinition =
false;
4376 TypedefNameDeclOrQualifier = TDD;
4387 if (
auto *D = dyn_cast<CXXRecordDecl>(
this)) {
4388 struct CXXRecordDecl::DefinitionData *Data =
4389 new (
getASTContext())
struct CXXRecordDecl::DefinitionData(D);
4391 cast<CXXRecordDecl>(I)->DefinitionData = Data;
4396 assert((!isa<CXXRecordDecl>(
this) ||
4398 "definition completed but not started");
4404 L->CompletedTagDefinition(
this);
4409 return const_cast<TagDecl *
>(
this);
4414 if (II->isOutOfDate()) {
4420 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this))
4421 return CXXRD->getDefinition();
4424 if (R->isCompleteDefinition())
4440 if (getExtInfo()->NumTemplParamLists == 0) {
4452 assert(!TPLists.empty());
4467 bool Scoped,
bool ScopedUsingClassTag,
bool Fixed)
4469 assert(Scoped || !ScopedUsingClassTag);
4470 IntegerType =
nullptr;
4471 setNumPositiveBits(0);
4472 setNumNegativeBits(0);
4474 setScopedUsingClassTag(ScopedUsingClassTag);
4476 setHasODRHash(
false);
4480 void EnumDecl::anchor() {}
4486 bool IsScopedUsingClassTag,
bool IsFixed) {
4488 IsScoped, IsScopedUsingClassTag, IsFixed);
4489 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4490 C.getTypeDeclType(
Enum, PrevDecl);
4497 nullptr,
nullptr,
false,
false,
false);
4498 Enum->setMayHaveOutOfDateDef(
C.getLangOpts().Modules);
4504 return TI->getTypeLoc().getSourceRange();
4510 unsigned NumPositiveBits,
4511 unsigned NumNegativeBits) {
4515 PromotionType = NewPromotionType;
4516 setNumPositiveBits(NumPositiveBits);
4517 setNumNegativeBits(NumNegativeBits);
4522 if (
const auto *A = getAttr<EnumExtensibilityAttr>())
4523 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4528 return isClosed() && hasAttr<FlagEnumAttr>();
4532 return isClosed() && !hasAttr<FlagEnumAttr>();
4537 return MSI->getTemplateSpecializationKind();
4545 assert(MSI &&
"Not an instantiated member enumeration?");
4548 PointOfInstantiation.
isValid() &&
4564 "couldn't find pattern for enum instantiation");
4569 if (SpecializationInfo)
4577 assert(!SpecializationInfo &&
"Member enum is already a specialization");
4587 setHasODRHash(
true);
4598 Res.setEnd(TSI->getTypeLoc().getEndLoc());
4611 :
TagDecl(DK, TK,
C, DC, IdLoc,
Id, PrevDecl, StartLoc) {
4612 assert(
classof(
static_cast<Decl *
>(
this)) &&
"Invalid Kind!");
4633 StartLoc, IdLoc,
Id, PrevDecl);
4636 C.getTypeDeclType(R, PrevDecl);
4654 if (
auto RD = dyn_cast<CXXRecordDecl>(
this))
4655 return RD->isLambda();
4660 return hasAttr<CapturedRecordAttr>();
4672 for (
const FieldDecl *FD : Def->fields()) {
4684 LoadFieldsFromExternalStorage();
4707 return hasAttr<MSStructAttr>() ||
C.getLangOpts().MSBitfields == 1;
4716 void RecordDecl::LoadFieldsFromExternalStorage()
const {
4731 for (
unsigned i=0, e=Decls.size(); i != e; ++i)
4732 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
4745 (SanitizerKind::Address | SanitizerKind::KernelAddress);
4746 if (!EnabledAsanMask || !Context.
getLangOpts().SanitizeAddressFieldPadding)
4749 const auto *CXXRD = dyn_cast<CXXRecordDecl>(
this);
4751 int ReasonToReject = -1;
4752 if (!CXXRD || CXXRD->isExternCContext())
4754 else if (CXXRD->hasAttr<PackedAttr>())
4756 else if (CXXRD->isUnion())
4758 else if (CXXRD->isTriviallyCopyable())
4760 else if (CXXRD->hasTrivialDestructor())
4762 else if (CXXRD->isStandardLayout())
4772 if (ReasonToReject >= 0)
4775 diag::remark_sanitize_address_insert_extra_padding_rejected)
4780 diag::remark_sanitize_address_insert_extra_padding_accepted)
4783 return ReasonToReject < 0;
4787 for (
const auto *I :
fields()) {
4788 if (I->getIdentifier())
4791 if (
const auto *RT = I->getType()->getAs<
RecordType>())
4793 RT->getDecl()->findFirstNamedDataMember())
4794 return NamedDataMember;
4816 assert(!ParamInfo &&
"Already has param info!");
4819 if (!NewParamInfo.empty()) {
4820 NumParams = NewParamInfo.size();
4822 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
4827 bool CapturesCXXThis) {
4829 this->NumCaptures = Captures.size();
4831 if (Captures.empty()) {
4832 this->Captures =
nullptr;
4836 this->Captures = Captures.copy(Context).data();
4842 if (I.getVariable() == variable)
4856 void TranslationUnitDecl::anchor() {}
4862 void PragmaCommentDecl::anchor() {}
4870 new (
C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
4872 memcpy(PCD->getTrailingObjects<
char>(), Arg.data(), Arg.size());
4873 PCD->getTrailingObjects<
char>()[Arg.size()] =
'\0';
4880 return new (
C,
ID, additionalSizeToAlloc<char>(ArgSize + 1))
4884 void PragmaDetectMismatchDecl::anchor() {}
4890 size_t ValueStart = Name.size() + 1;
4892 new (
C, DC, additionalSizeToAlloc<char>(ValueStart +
Value.size() + 1))
4894 memcpy(PDMD->getTrailingObjects<
char>(), Name.data(), Name.size());
4895 PDMD->getTrailingObjects<
char>()[Name.size()] =
'\0';
4896 memcpy(PDMD->getTrailingObjects<
char>() + ValueStart,
Value.data(),
4898 PDMD->getTrailingObjects<
char>()[ValueStart +
Value.size()] =
'\0';
4904 unsigned NameValueSize) {
4905 return new (
C,
ID, additionalSizeToAlloc<char>(NameValueSize + 1))
4909 void ExternCContextDecl::anchor() {}
4916 void LabelDecl::anchor() {}
4920 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, IdentL);
4926 assert(GnuLabelL != IdentL &&
"Use this only for GNU local labels");
4927 return new (
C, DC)
LabelDecl(DC, IdentL, II,
nullptr, GnuLabelL);
4936 char *Buffer =
new (
getASTContext(), 1)
char[Name.size() + 1];
4937 memcpy(Buffer, Name.data(), Name.size());
4938 Buffer[Name.size()] =
'\0';
4942 void ValueDecl::anchor() {}
4946 return MostRecent->hasAttr<WeakAttr>() ||
4950 void ImplicitParamDecl::anchor() {}
4973 bool isInlineSpecified,
bool hasWrittenPrototype,
4975 Expr *TrailingRequiresClause) {
4977 Function,
C, DC, StartLoc, NameInfo, T, TInfo, SC,
UsesFPIntrin,
4997 CapturedDecl::CapturedDecl(
DeclContext *DC,
unsigned NumParams)
4999 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr,
false) {}
5002 unsigned NumParams) {
5003 return new (
C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5008 unsigned NumParams) {
5009 return new (
C,
ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5032 void IndirectFieldDecl::anchor() {}
5038 :
ValueDecl(IndirectField, DC, L, N, T), Chaining(CH.data()),
5039 ChainingSize(CH.size()) {
5042 if (
C.getLangOpts().CPlusPlus)
5066 void TypeDecl::anchor() {}
5074 void TypedefNameDecl::anchor() {}
5079 auto *ThisTypedef =
this;
5080 if (AnyRedecl && OwningTypedef) {
5084 if (OwningTypedef == ThisTypedef)
5085 return TT->getDecl();
5091 bool TypedefNameDecl::isTransparentTagSlow()
const {
5092 auto determineIsTransparent = [&]() {
5094 if (
auto *TD = TT->getDecl()) {
5095 if (TD->getName() !=
getName())
5102 return SM.getSpellingLoc(TTLoc) ==
SM.getSpellingLoc(TDLoc);
5108 bool isTransparent = determineIsTransparent();
5109 MaybeModedTInfo.setInt((isTransparent << 1) | 1);
5110 return isTransparent;
5134 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5142 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5146 void FileScopeAsmDecl::anchor() {}
5161 void EmptyDecl::anchor() {}
5178 unsigned Result = 1;
5189 :
Decl(Import, DC, StartLoc), ImportedModule(Imported),
5190 NextLocalImportAndComplete(nullptr,
true) {
5192 auto *StoredLocs = getTrailingObjects<SourceLocation>();
5193 std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
5199 :
Decl(Import, DC, StartLoc), ImportedModule(Imported),
5200 NextLocalImportAndComplete(nullptr,
false) {
5201 *getTrailingObjects<SourceLocation>() = EndLoc;
5208 additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
5209 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
5216 ImportDecl *Import =
new (
C, DC, additionalSizeToAlloc<SourceLocation>(1))
5223 unsigned NumLocations) {
5224 return new (
C,
ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
5229 if (!isImportComplete())
5232 const auto *StoredLocs = getTrailingObjects<SourceLocation>();
5233 return llvm::makeArrayRef(StoredLocs,
5238 if (!isImportComplete())
5248 void ExportDecl::anchor() {}