62#include "llvm/ADT/STLExtras.h"
63#include "llvm/ADT/STLForwardCompat.h"
64#include "llvm/ADT/StringExtras.h"
65#include "llvm/Demangle/Demangle.h"
66#include "llvm/IR/Assumptions.h"
67#include "llvm/MC/MCSectionMachO.h"
68#include "llvm/Support/Error.h"
69#include "llvm/Support/MathExtras.h"
70#include "llvm/Support/raw_ostream.h"
71#include "llvm/TargetParser/Triple.h"
95template <
typename AttrInfo>
102 if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
106 <<
toString(I, 10,
false) << 32 << 0;
115 const Expr *
E, StringRef &Str,
121 if (!Literal || (!Literal->isUnevaluated() && !Literal->isOrdinary())) {
127 Str = Literal->getString();
137 Diag(
Loc->Loc, diag::err_attribute_argument_type)
141 Str =
Loc->Ident->getName();
143 *ArgLocation =
Loc->Loc;
153 if (!Literal || (!Literal->isUnevaluated() && !Literal->isOrdinary())) {
158 Str = Literal->getString();
180 bool foundStarOperator = IsOverloadedOperatorPresent(
Record, OO_Star);
181 bool foundArrowOperator = IsOverloadedOperatorPresent(
Record, OO_Arrow);
182 if (foundStarOperator && foundArrowOperator)
189 for (
const auto &BaseSpecifier : CXXRecord->bases()) {
190 if (!foundStarOperator)
191 foundStarOperator = IsOverloadedOperatorPresent(
192 BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);
193 if (!foundArrowOperator)
194 foundArrowOperator = IsOverloadedOperatorPresent(
195 BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);
198 if (foundStarOperator && foundArrowOperator)
209 const auto *VD = cast<ValueDecl>(
D);
218 if (RT->isIncompleteType())
225 S.
Diag(AL.
getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;
242template <
typename AttrType>
249 if (
const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
251 return !Base->hasAttr<AttrType>();
273 return checkRecordDeclForAttr<CapabilityAttr>(RT->
getDecl());
285 return TN->
hasAttr<CapabilityAttr>();
304 if (
const auto *
E = dyn_cast<CastExpr>(Ex))
306 else if (
const auto *
E = dyn_cast<ParenExpr>(Ex))
308 else if (
const auto *
E = dyn_cast<UnaryOperator>(Ex)) {
309 if (
E->getOpcode() == UO_LNot ||
E->getOpcode() == UO_AddrOf ||
310 E->getOpcode() == UO_Deref)
313 }
else if (
const auto *
E = dyn_cast<BinaryOperator>(Ex)) {
314 if (
E->getOpcode() == BO_LAnd ||
E->getOpcode() == BO_LOr)
332 bool ParamIdxOk =
false) {
337 const auto *MD = dyn_cast<const CXXMethodDecl>(
D);
338 if (MD && !MD->isStatic()) {
341 if (!checkRecordDeclForAttr<CapabilityAttr>(RD) &&
342 !checkRecordDeclForAttr<ScopedLockableAttr>(RD))
344 diag::warn_thread_attribute_not_on_capability_member)
345 << AL << MD->getParent();
347 S.
Diag(AL.
getLoc(), diag::warn_thread_attribute_not_on_non_static_member)
352 for (
unsigned Idx = Sidx; Idx < AL.
getNumArgs(); ++Idx) {
357 Args.push_back(ArgExp);
361 if (
const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
362 if (StrLit->getLength() == 0 ||
363 (StrLit->isOrdinary() && StrLit->getString() ==
"*")) {
366 Args.push_back(ArgExp);
372 S.
Diag(AL.
getLoc(), diag::warn_thread_attribute_ignored) << AL;
373 Args.push_back(ArgExp);
381 if (
const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
382 if (UOp->getOpcode() == UO_AddrOf)
383 if (
const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
384 if (DRE->getDecl()->isCXXInstanceMember())
385 ArgTy = DRE->getDecl()->getType();
391 if(!RT && ParamIdxOk) {
392 const auto *FD = dyn_cast<FunctionDecl>(
D);
393 const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
395 unsigned int NumParams = FD->getNumParams();
396 llvm::APInt ArgValue = IL->getValue();
397 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
398 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
399 if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
401 diag::err_attribute_argument_out_of_bounds_extra_info)
402 << AL << Idx + 1 << NumParams;
405 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
414 S.
Diag(AL.
getLoc(), diag::warn_thread_attribute_argument_not_lockable)
417 Args.push_back(ArgExp);
437 unsigned Size = Args.size();
471 QualType QT = cast<ValueDecl>(
D)->getType();
473 S.
Diag(AL.
getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL;
490 Expr **StartArg = &Args[0];
492 AcquiredAfterAttr(S.
Context, AL, StartArg, Args.size()));
500 Expr **StartArg = &Args[0];
502 AcquiredBeforeAttr(S.
Context, AL, StartArg, Args.size()));
519 unsigned Size = Args.size();
520 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
522 AssertSharedLockAttr(S.
Context, AL, StartArg, Size));
531 unsigned Size = Args.size();
532 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
534 AssertExclusiveLockAttr(S.
Context, AL, StartArg, Size));
542template <
typename AttrInfo>
544 unsigned AttrArgNo) {
545 assert(AI.isArgExpr(AttrArgNo) &&
"Expected expression argument");
546 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
555 S.
Diag(SrcLoc, diag::err_attribute_integers_only)
570 S.
Diag(AL.
getLoc(), diag::warn_attribute_return_pointers_only) << AL;
596 AllocSizeAttr(S.
Context, AL, SizeArgNo, NumberArgNo));
605 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
640 unsigned Size = Args.size();
654 unsigned Size = Args.size();
657 Expr **StartArg = &Args[0];
660 LocksExcludedAttr(S.
Context, AL, StartArg, Size));
664 Expr *&Cond, StringRef &Msg) {
670 Cond = Converted.
get();
677 Msg =
"<no message provided>";
683 S.
Diag(AL.
getLoc(), diag::err_attr_cond_never_constant_expr) << AL;
685 S.
Diag(PDiag.first, PDiag.second);
692 S.
Diag(AL.
getLoc(), diag::ext_clang_enable_if);
701 StringRef NewUserDiagnostic;
710 const auto *PD = isa<CXXRecordDecl>(
D)
711 ? cast<DeclContext>(
D)
713 if (
const auto *RD = dyn_cast<CXXRecordDecl>(PD); RD && RD->isLocalClass()) {
715 diag::warn_attribute_exclude_from_explicit_instantiation_local_class)
716 << AL << !isa<CXXRecordDecl>(
D);
720 ExcludeFromExplicitInstantiationAttr(S.
Context, AL));
726class ArgumentDependenceChecker
737 if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
745 bool referencesArgs(
Expr *
E) {
753 "`this` doesn't refer to the enclosing class?");
759 if (
const auto *PVD = dyn_cast<ParmVarDecl>(DRE->
getDecl()))
760 if (Parms.count(PVD)) {
771 const auto *DeclFD = cast<FunctionDecl>(
D);
773 if (
const auto *MethodDecl = dyn_cast<CXXMethodDecl>(DeclFD))
774 if (!MethodDecl->isStatic()) {
775 S.
Diag(AL.
getLoc(), diag::err_attribute_no_member_function) << AL;
787 S.
Diag(
Loc, diag::err_attribute_argument_n_type) << AL << Index <<
T;
793 auto *F = dyn_cast_if_present<DeclRefExpr>(AL.
getArgAsExpr(0));
796 return dyn_cast_if_present<FunctionDecl>(F->getFoundDecl());
805 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments_for)
812 for (
unsigned I = 1; I < AL.
getNumArgs(); ++I) {
824 if (Index > DeclFD->getNumParams()) {
825 S.
Diag(AL.
getLoc(), diag::err_attribute_bounds_for_function)
826 << AL << Index << DeclFD << DeclFD->getNumParams();
831 QualType T2 = DeclFD->getParamDecl(Index - 1)->getType();
836 << AL << Index << DeclFD << T2 << I << AttrFD << T1;
840 Indices.push_back(Index - 1);
844 S.
Context, AL, AttrFD, Indices.data(), Indices.size()));
848 S.
Diag(AL.
getLoc(), diag::ext_clang_diagnose_if);
855 StringRef DiagTypeStr;
859 DiagnoseIfAttr::DiagnosticType DiagType;
860 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
862 diag::err_diagnose_if_invalid_diagnostic_type);
866 bool ArgDependent =
false;
867 if (
const auto *FD = dyn_cast<FunctionDecl>(
D))
868 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
870 S.
Context, AL, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(
D)));
874 static constexpr const StringRef kWildcard =
"*";
877 bool HasWildcard =
false;
879 const auto AddBuiltinName = [&Names, &HasWildcard](StringRef Name) {
880 if (Name == kWildcard)
882 Names.push_back(Name);
886 if (
const auto *NBA =
D->
getAttr<NoBuiltinAttr>())
887 for (StringRef BuiltinName : NBA->builtinNames())
888 AddBuiltinName(BuiltinName);
892 AddBuiltinName(kWildcard);
894 for (
unsigned I = 0,
E = AL.
getNumArgs(); I !=
E; ++I) {
895 StringRef BuiltinName;
901 AddBuiltinName(BuiltinName);
903 S.
Diag(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name)
904 << BuiltinName << AL;
909 Names.erase(std::unique(Names.begin(), Names.end()), Names.end());
912 if (HasWildcard && Names.size() > 1)
914 diag::err_attribute_no_builtin_wildcard_or_builtin_name)
920 NoBuiltinAttr(S.
Context, AL, Names.data(), Names.size()));
924 if (
D->
hasAttr<PassObjectSizeAttr>()) {
925 S.
Diag(
D->
getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL;
947 if (!cast<ParmVarDecl>(
D)->getType()->isPointerType()) {
956 ConsumableAttr::ConsumedState DefaultState;
960 if (!ConsumableAttr::ConvertStrToConsumedState(IL->
Ident->
getName(),
962 S.
Diag(IL->
Loc, diag::warn_attribute_type_not_supported) << AL
967 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
980 if (!RD->hasAttr<ConsumableAttr>()) {
981 S.
Diag(AL.
getLoc(), diag::warn_attr_on_unconsumable_class) << RD;
998 for (
unsigned ArgIndex = 0; ArgIndex < AL.
getNumArgs(); ++ArgIndex) {
999 CallableWhenAttr::ConsumedState CallableState;
1001 StringRef StateString;
1012 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1014 S.
Diag(
Loc, diag::warn_attribute_type_not_supported) << AL << StateString;
1018 States.push_back(CallableState);
1022 CallableWhenAttr(S.
Context, AL, States.data(), States.size()));
1026 ParamTypestateAttr::ConsumedState ParamState;
1032 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1034 S.
Diag(Ident->
Loc, diag::warn_attribute_type_not_supported)
1035 << AL << StateString;
1039 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
1060 ReturnTypestateAttr::ConsumedState ReturnState;
1064 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->
Ident->
getName(),
1066 S.
Diag(IL->
Loc, diag::warn_attribute_type_not_supported) << AL
1071 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
1108 SetTypestateAttr::ConsumedState NewState;
1112 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1113 S.
Diag(Ident->
Loc, diag::warn_attribute_type_not_supported) << AL
1118 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
1130 TestTypestateAttr::ConsumedState TestState;
1134 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1135 S.
Diag(Ident->
Loc, diag::warn_attribute_type_not_supported) << AL
1140 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
1154 if (
auto *TD = dyn_cast<TagDecl>(
D))
1156 else if (
auto *FD = dyn_cast<FieldDecl>(
D)) {
1163 if (BitfieldByteAligned)
1165 S.
Diag(AL.
getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1171 if (BitfieldByteAligned)
1172 S.
Diag(AL.
getLoc(), diag::warn_attribute_packed_for_bitfield);
1178 S.
Diag(AL.
getLoc(), diag::warn_attribute_ignored) << AL;
1182 auto *RD = cast<CXXRecordDecl>(
D);
1184 assert(CTD &&
"attribute does not appertain to this declaration");
1195 if (
const auto *CTSD = dyn_cast_if_present<ClassTemplateSpecializationDecl>(
1197 Template = CTSD->getSpecializedTemplate();
1199 while (TST && TST->isTypeAlias())
1202 Template = TST->getTemplateName().getAsTemplateDecl();
1211 S.
Diag(AL.
getLoc(), diag::err_attribute_preferred_name_arg_invalid)
1214 S.
Diag(TT->getDecl()->getLocation(), diag::note_entity_declared_at)
1223 T =
T.getNonReferenceType();
1229 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1231 for (
const auto *I : UD->
fields()) {
1245 bool isReturnValue =
false) {
1248 S.
Diag(AL.
getLoc(), diag::warn_attribute_return_pointers_only)
1249 << AL << AttrParmRange << TypeRange;
1251 S.
Diag(AL.
getLoc(), diag::warn_attribute_pointers_only)
1252 << AL << AttrParmRange << TypeRange << 0;
1260 for (
unsigned I = 0; I < AL.
getNumArgs(); ++I) {
1274 NonNullArgs.push_back(Idx);
1285 I !=
E && !AnyPointers; ++I) {
1292 S.
Diag(AL.
getLoc(), diag::warn_attribute_nonnull_no_pointers);
1295 ParamIdx *Start = NonNullArgs.data();
1296 unsigned Size = NonNullArgs.size();
1297 llvm::array_pod_sort(Start, Start + Size);
1307 S.
Diag(AL.
getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1336 QualType T = cast<ParmVarDecl>(
D)->getType();
1338 S.
Diag(AL.
getLoc(), diag::warn_attribute_pointers_only)
1361 AssumeAlignedAttr TmpAttr(
Context, CI,
E, OE);
1365 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1366 << &TmpAttr << TmpAttr.getRange() << SR;
1371 std::optional<llvm::APSInt> I = llvm::APSInt(64);
1374 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1378 Diag(AttrLoc, diag::err_attribute_argument_type)
1384 if (!I->isPowerOf2()) {
1385 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1391 Diag(CI.
getLoc(), diag::warn_assume_aligned_too_great)
1396 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1414 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1420 const auto *FuncDecl = cast<FunctionDecl>(
D);
1430 << FuncDecl->getParamDecl(Idx.
getASTIndex())->getSourceRange();
1440 if (AttrName.size() > 4 && AttrName.starts_with(
"__") &&
1441 AttrName.ends_with(
"__")) {
1442 AttrName = AttrName.drop_front(2).drop_back(2);
1458 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
1464 OwnershipAttr::OwnershipKind K =
1465 OwnershipAttr(S.
Context, AL,
nullptr,
nullptr, 0).getOwnKind();
1469 case OwnershipAttr::Takes:
1470 case OwnershipAttr::Holds:
1472 S.
Diag(AL.
getLoc(), diag::err_attribute_too_few_arguments) << AL << 2;
1476 case OwnershipAttr::Returns:
1478 S.
Diag(AL.
getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
1486 StringRef ModuleName =
Module->getName();
1492 for (
unsigned i = 1; i < AL.
getNumArgs(); ++i) {
1502 case OwnershipAttr::Takes:
1503 case OwnershipAttr::Holds:
1507 case OwnershipAttr::Returns:
1513 S.
Diag(AL.
getLoc(), diag::err_ownership_type) << AL << Err
1522 if (I->getOwnKind() != K && llvm::is_contained(I->args(), Idx)) {
1523 S.
Diag(AL.
getLoc(), diag::err_attributes_are_not_compatible)
1526 I->isRegularKeywordAttribute());
1528 }
else if (K == OwnershipAttr::Returns &&
1529 I->getOwnKind() == OwnershipAttr::Returns) {
1532 if (!llvm::is_contained(I->args(), Idx)) {
1533 S.
Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1534 << I->args_begin()->getSourceIndex();
1536 S.
Diag(AL.
getLoc(), diag::note_ownership_returns_index_mismatch)
1540 }
else if (K == OwnershipAttr::Takes &&
1541 I->getOwnKind() == OwnershipAttr::Takes) {
1542 if (I->getModule()->getName() != ModuleName) {
1543 S.
Diag(I->getLocation(), diag::err_ownership_takes_class_mismatch)
1544 << I->getModule()->getName();
1545 S.
Diag(AL.
getLoc(), diag::note_ownership_takes_class_mismatch)
1552 OwnershipArgs.push_back(Idx);
1555 ParamIdx *Start = OwnershipArgs.data();
1556 unsigned Size = OwnershipArgs.size();
1557 llvm::array_pod_sort(Start, Start + Size);
1565 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1581 S.
Diag(AL.
getLoc(), diag::err_attribute_weakref_not_global_context)
1582 << cast<NamedDecl>(
D);
1626 std::unique_ptr<char, llvm::FreeDeleter> Demangled;
1628 Demangled.reset(llvm::itaniumDemangle(Str,
false));
1637 if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND))
1639 if (MC->shouldMangleDeclName(ND)) {
1640 llvm::raw_svector_ostream Out(Name);
1644 Name = ND->getIdentifier()->getName();
1658 const auto *FD = cast<FunctionDecl>(
D);
1660 S.
Diag(AL.
getLoc(), diag::err_alias_is_definition) << FD << 1;
1674 S.
Diag(AL.
getLoc(), diag::err_alias_not_supported_on_darwin);
1682 S.
Diag(AL.
getLoc(), diag::err_alias_not_supported_on_nvptx);
1686 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
1688 S.
Diag(AL.
getLoc(), diag::err_alias_is_definition) << FD << 0;
1692 const auto *VD = cast<VarDecl>(
D);
1693 if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1694 S.
Diag(AL.
getLoc(), diag::err_alias_is_definition) << VD << 0;
1711 if (Model !=
"global-dynamic" && Model !=
"local-dynamic"
1712 && Model !=
"initial-exec" && Model !=
"local-exec") {
1713 S.
Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1727 S.
Diag(AL.
getLoc(), diag::warn_attribute_return_pointers_only)
1735 if (checkAttrMutualExclusion<CPUSpecificAttr>(S,
D, AL))
1739 S.
Diag(AL.
getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
1740 S.
Diag(
Other->getLocation(), diag::note_conflicting_attribute);
1743 }
else if (AL.
getParsedKind() == ParsedAttr::AT_CPUSpecific) {
1744 if (checkAttrMutualExclusion<CPUDispatchAttr>(S,
D, AL))
1748 S.
Diag(AL.
getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
1749 S.
Diag(
Other->getLocation(), diag::note_conflicting_attribute);
1756 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
1757 if (MD->getParent()->isLambda()) {
1758 S.
Diag(AL.
getLoc(), diag::err_attribute_dll_lambda) << AL;
1769 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
1778 S.
Diag(CPUArg->
Loc, diag::err_invalid_cpu_specific_dispatch_value)
1779 << CPUName << (AL.
getKind() == ParsedAttr::AT_CPUDispatch);
1785 return Target.CPUSpecificManglingCharacter(CPUName) ==
1788 S.
Diag(AL.
getLoc(), diag::warn_multiversion_duplicate_entries);
1791 CPUs.push_back(CPUArg->
Ident);
1795 if (AL.
getKind() == ParsedAttr::AT_CPUSpecific)
1797 CPUSpecificAttr(S.
Context, AL, CPUs.data(), CPUs.size()));
1800 CPUDispatchAttr(S.
Context, AL, CPUs.data(), CPUs.size()));
1805 S.
Diag(AL.
getLoc(), diag::err_attribute_not_supported_in_lang)
1816 const auto &Arch = Triple.getArch();
1817 if (Arch != llvm::Triple::x86 &&
1818 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
1819 S.
Diag(AL.
getLoc(), diag::err_attribute_not_supported_on_arch)
1820 << AL << Triple.getArchName();
1826 if (S.
getLangOpts().MSVCCompat && isa<CXXMethodDecl>(
D)) {
1827 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_decl_type_str)
1839 if (!isa<ObjCMethodDecl>(
D)) {
1840 S.
Diag(Attrs.
getLoc(), diag::warn_attribute_wrong_decl_type)
1866 S.
Diag(Attrs.
getLoc(), diag::warn_nocf_check_attribute_ignored);
1868 handleSimpleAttribute<AnyX86NoCfCheckAttr>(S,
D, Attrs);
1884 ? diag::err_keyword_not_supported_on_target
1885 : diag::warn_unknown_attribute_ignored)
1903 ? diag::err_attribute_wrong_decl_type
1904 : diag::warn_attribute_wrong_decl_type)
1940 if (VecReturnAttr *A =
D->
getAttr<VecReturnAttr>()) {
1941 S.
Diag(AL.
getLoc(), diag::err_repeat_attribute) << A;
1945 const auto *R = cast<RecordDecl>(
D);
1948 if (!isa<CXXRecordDecl>(R)) {
1949 S.
Diag(AL.
getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1953 if (!cast<CXXRecordDecl>(R)->isPOD()) {
1954 S.
Diag(AL.
getLoc(), diag::err_attribute_vecreturn_only_pod_record);
1958 for (
const auto *I : R->fields()) {
1959 if ((count == 1) || !I->getType()->isVectorType()) {
1960 S.
Diag(AL.
getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1971 if (isa<ParmVarDecl>(
D)) {
1976 diag::err_carries_dependency_param_not_function_decl);
1990 S.
Diag(AL.
getLoc(), diag::ext_cxx17_attr) << AL;
1996 uint32_t priority = ConstructorAttr::DefaultPriority;
1998 S.
Diag(AL.
getLoc(), diag::err_hlsl_init_priority_unsupported);
2009 uint32_t priority = DestructorAttr::DefaultPriority;
2017template <
typename AttrTy>
2029 VersionTuple Introduced,
2030 VersionTuple Deprecated,
2031 VersionTuple Obsoleted) {
2032 StringRef PlatformName
2033 = AvailabilityAttr::getPrettyPlatformName(Platform->
getName());
2034 if (PlatformName.empty())
2035 PlatformName = Platform->
getName();
2039 if (!Introduced.empty() && !Deprecated.empty() &&
2040 !(Introduced <= Deprecated)) {
2042 << 1 << PlatformName << Deprecated.getAsString()
2043 << 0 << Introduced.getAsString();
2047 if (!Introduced.empty() && !Obsoleted.empty() &&
2048 !(Introduced <= Obsoleted)) {
2050 << 2 << PlatformName << Obsoleted.getAsString()
2051 << 0 << Introduced.getAsString();
2055 if (!Deprecated.empty() && !Obsoleted.empty() &&
2056 !(Deprecated <= Obsoleted)) {
2058 << 2 << PlatformName << Obsoleted.getAsString()
2059 << 1 << Deprecated.getAsString();
2071 bool BeforeIsOkay) {
2072 if (
X.empty() || Y.empty())
2078 if (BeforeIsOkay &&
X < Y)
2086 bool Implicit, VersionTuple Introduced, VersionTuple Deprecated,
2087 VersionTuple Obsoleted,
bool IsUnavailable, StringRef Message,
2090 VersionTuple MergedIntroduced = Introduced;
2091 VersionTuple MergedDeprecated = Deprecated;
2092 VersionTuple MergedObsoleted = Obsoleted;
2093 bool FoundAny =
false;
2094 bool OverrideOrImpl =
false;
2098 OverrideOrImpl =
false;
2104 OverrideOrImpl =
true;
2110 for (
unsigned i = 0, e = Attrs.size(); i != e;) {
2111 const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2118 if (OldPlatform != Platform) {
2124 if (OldEnvironment != Environment) {
2132 if (OldAA->getPriority() <
Priority)
2138 if (OldAA->getPriority() >
Priority) {
2139 Attrs.erase(Attrs.begin() + i);
2145 VersionTuple OldIntroduced = OldAA->getIntroduced();
2146 VersionTuple OldDeprecated = OldAA->getDeprecated();
2147 VersionTuple OldObsoleted = OldAA->getObsoleted();
2148 bool OldIsUnavailable = OldAA->getUnavailable();
2150 if (!
versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2151 !
versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2153 !(OldIsUnavailable == IsUnavailable ||
2154 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2155 if (OverrideOrImpl) {
2157 VersionTuple FirstVersion;
2158 VersionTuple SecondVersion;
2159 if (!
versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2161 FirstVersion = OldIntroduced;
2162 SecondVersion = Introduced;
2163 }
else if (!
versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2165 FirstVersion = Deprecated;
2166 SecondVersion = OldDeprecated;
2167 }
else if (!
versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2169 FirstVersion = Obsoleted;
2170 SecondVersion = OldObsoleted;
2174 Diag(OldAA->getLocation(),
2175 diag::warn_mismatched_availability_override_unavail)
2176 << AvailabilityAttr::getPrettyPlatformName(Platform->
getName())
2187 Diag(OldAA->getLocation(),
2188 diag::warn_mismatched_availability_override)
2190 << AvailabilityAttr::getPrettyPlatformName(Platform->
getName())
2191 << FirstVersion.getAsString() << SecondVersion.getAsString()
2195 Diag(CI.
getLoc(), diag::note_overridden_method);
2197 Diag(CI.
getLoc(), diag::note_protocol_method);
2199 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2200 Diag(CI.
getLoc(), diag::note_previous_attribute);
2203 Attrs.erase(Attrs.begin() + i);
2208 VersionTuple MergedIntroduced2 = MergedIntroduced;
2209 VersionTuple MergedDeprecated2 = MergedDeprecated;
2210 VersionTuple MergedObsoleted2 = MergedObsoleted;
2212 if (MergedIntroduced2.empty())
2213 MergedIntroduced2 = OldIntroduced;
2214 if (MergedDeprecated2.empty())
2215 MergedDeprecated2 = OldDeprecated;
2216 if (MergedObsoleted2.empty())
2217 MergedObsoleted2 = OldObsoleted;
2220 MergedIntroduced2, MergedDeprecated2,
2221 MergedObsoleted2)) {
2222 Attrs.erase(Attrs.begin() + i);
2227 MergedIntroduced = MergedIntroduced2;
2228 MergedDeprecated = MergedDeprecated2;
2229 MergedObsoleted = MergedObsoleted2;
2235 MergedIntroduced == Introduced &&
2236 MergedDeprecated == Deprecated &&
2237 MergedObsoleted == Obsoleted)
2243 MergedDeprecated, MergedObsoleted) &&
2245 auto *Avail = ::new (
Context) AvailabilityAttr(
2246 Context, CI, Platform, Introduced, Deprecated, Obsoleted, IsUnavailable,
2247 Message, IsStrict, Replacement,
Priority, Environment);
2255 if (isa<UsingDecl, UnresolvedUsingTypenameDecl, UnresolvedUsingValueDecl>(
2267 if (AvailabilityAttr::getPrettyPlatformName(II->
getName()).empty())
2268 S.
Diag(Platform->
Loc, diag::warn_availability_unknown_platform)
2271 auto *ND = dyn_cast<NamedDecl>(
D);
2281 if (
const auto *SE = dyn_cast_if_present<StringLiteral>(AL.
getMessageExpr()))
2282 Str = SE->getString();
2283 StringRef Replacement;
2284 if (
const auto *SE =
2286 Replacement = SE->getString();
2288 if (II->
isStr(
"swift")) {
2290 (!IsUnavailable && !Deprecated.
isValid())) {
2292 diag::warn_availability_swift_unavailable_deprecated_only);
2297 if (II->
isStr(
"fuchsia")) {
2298 std::optional<unsigned>
Min, Sub;
2300 (Sub = Introduced.
Version.getSubminor())) {
2301 S.
Diag(AL.
getLoc(), diag::warn_availability_fuchsia_unavailable_minor);
2316 if (EnvironmentLoc) {
2318 IIEnvironment = EnvironmentLoc->
Ident;
2319 if (AvailabilityAttr::getEnvironmentType(
2321 llvm::Triple::EnvironmentType::UnknownEnvironment)
2322 S.
Diag(EnvironmentLoc->
Loc, diag::warn_availability_unknown_environment)
2323 << EnvironmentLoc->
Ident;
2325 S.
Diag(EnvironmentLoc->
Loc, diag::err_availability_unexpected_parameter)
2326 <<
"environment" << 1;
2332 Obsoleted.
Version, IsUnavailable, Str, IsStrict, Replacement,
2343 else if (II->
getName() ==
"ios_app_extension")
2348 const auto *IOSToWatchOSMapping =
2353 auto adjustWatchOSVersion =
2354 [IOSToWatchOSMapping](VersionTuple Version) -> VersionTuple {
2355 if (Version.empty())
2357 auto MinimumWatchOSVersion = VersionTuple(2, 0);
2359 if (IOSToWatchOSMapping) {
2360 if (
auto MappedVersion = IOSToWatchOSMapping->map(
2361 Version, MinimumWatchOSVersion, std::nullopt)) {
2362 return *MappedVersion;
2366 auto Major = Version.getMajor();
2367 auto NewMajor = Major >= 9 ? Major - 7 : 0;
2368 if (NewMajor >= 2) {
2369 if (Version.getMinor()) {
2370 if (Version.getSubminor())
2371 return VersionTuple(NewMajor, *Version.getMinor(),
2372 *Version.getSubminor());
2374 return VersionTuple(NewMajor, *Version.getMinor());
2376 return VersionTuple(NewMajor);
2379 return MinimumWatchOSVersion;
2382 auto NewIntroduced = adjustWatchOSVersion(Introduced.
Version);
2383 auto NewDeprecated = adjustWatchOSVersion(Deprecated.
Version);
2384 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.
Version);
2387 ND, AL, NewII,
true , NewIntroduced, NewDeprecated,
2388 NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,
2400 else if (II->
getName() ==
"ios_app_extension")
2405 const auto *IOSToTvOSMapping =
2410 auto AdjustTvOSVersion =
2411 [IOSToTvOSMapping](VersionTuple Version) -> VersionTuple {
2412 if (Version.empty())
2415 if (IOSToTvOSMapping) {
2416 if (
auto MappedVersion = IOSToTvOSMapping->map(
2417 Version, VersionTuple(0, 0), std::nullopt)) {
2418 return *MappedVersion;
2424 auto NewIntroduced = AdjustTvOSVersion(Introduced.
Version);
2425 auto NewDeprecated = AdjustTvOSVersion(Deprecated.
Version);
2426 auto NewObsoleted = AdjustTvOSVersion(Obsoleted.
Version);
2429 ND, AL, NewII,
true , NewIntroduced, NewDeprecated,
2430 NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,
2437 llvm::Triple::IOS &&
2439 auto GetSDKInfo = [&]() {
2448 else if (II->
getName() ==
"ios_app_extension")
2451 auto MinMacCatalystVersion = [](
const VersionTuple &
V) {
2454 if (
V.getMajor() < 13 ||
2455 (
V.getMajor() == 13 &&
V.getMinor() && *
V.getMinor() < 1))
2456 return VersionTuple(13, 1);
2460 ND, AL, NewII,
true ,
2461 MinMacCatalystVersion(Introduced.
Version),
2462 MinMacCatalystVersion(Deprecated.
Version),
2463 MinMacCatalystVersion(Obsoleted.
Version), IsUnavailable, Str,
2468 }
else if (II->
getName() ==
"macos" && GetSDKInfo() &&
2470 !Obsoleted.
Version.empty())) {
2471 if (
const auto *MacOStoMacCatalystMapping =
2472 GetSDKInfo()->getVersionMapping(
2479 auto RemapMacOSVersion =
2480 [&](
const VersionTuple &
V) -> std::optional<VersionTuple> {
2482 return std::nullopt;
2484 if (
V.getMajor() == 100000)
2485 return VersionTuple(100000);
2487 return MacOStoMacCatalystMapping->map(
V, VersionTuple(13, 1),
2490 std::optional<VersionTuple> NewIntroduced =
2491 RemapMacOSVersion(Introduced.
Version),
2493 RemapMacOSVersion(Deprecated.
Version),
2495 RemapMacOSVersion(Obsoleted.
Version);
2496 if (NewIntroduced || NewDeprecated || NewObsoleted) {
2497 auto VersionOrEmptyVersion =
2498 [](
const std::optional<VersionTuple> &
V) -> VersionTuple {
2499 return V ? *
V : VersionTuple();
2502 ND, AL, NewII,
true ,
2503 VersionOrEmptyVersion(NewIntroduced),
2504 VersionOrEmptyVersion(NewDeprecated),
2505 VersionOrEmptyVersion(NewObsoleted),
false, Str,
2524 if (
const auto *SE = dyn_cast_if_present<StringLiteral>(AL.
getArgAsExpr(0)))
2526 StringRef DefinedIn;
2527 if (
const auto *SE = dyn_cast_if_present<StringLiteral>(AL.
getArgAsExpr(1)))
2528 DefinedIn = SE->getString();
2529 bool IsGeneratedDeclaration = AL.
getArgAsIdent(2) !=
nullptr;
2531 if (
const auto *SE = dyn_cast_if_present<StringLiteral>(AL.
getArgAsExpr(3)))
2532 USR = SE->getString();
2540 typename T::VisibilityType value) {
2543 typename T::VisibilityType existingValue = existingAttr->
getVisibility();
2544 if (existingValue == value)
2546 S.
Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2547 S.
Diag(CI.
getLoc(), diag::note_previous_attribute);
2555 VisibilityAttr::VisibilityType Vis) {
2556 return ::mergeVisibilityAttr<VisibilityAttr>(*
this,
D, CI, Vis);
2561 TypeVisibilityAttr::VisibilityType Vis) {
2562 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*
this,
D, CI, Vis);
2566 bool isTypeVisibility) {
2568 if (isa<TypedefNameDecl>(
D)) {
2574 if (isTypeVisibility && !(isa<TagDecl>(
D) || isa<ObjCInterfaceDecl>(
D) ||
2575 isa<NamespaceDecl>(
D))) {
2587 VisibilityAttr::VisibilityType
type;
2588 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr,
type)) {
2589 S.
Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL
2596 if (
type == VisibilityAttr::Protected &&
2598 S.
Diag(AL.
getLoc(), diag::warn_attribute_protected_visibility);
2599 type = VisibilityAttr::Default;
2603 if (isTypeVisibility) {
2605 D, AL, (TypeVisibilityAttr::VisibilityType)
type);
2614 unsigned sentinel = (
unsigned)SentinelAttr::DefaultSentinel;
2617 std::optional<llvm::APSInt> Idx = llvm::APSInt(32);
2619 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
2624 if (Idx->isSigned() && Idx->isNegative()) {
2625 S.
Diag(AL.
getLoc(), diag::err_attribute_sentinel_less_than_zero)
2630 sentinel = Idx->getZExtValue();
2633 unsigned nullPos = (
unsigned)SentinelAttr::DefaultNullPos;
2636 std::optional<llvm::APSInt> Idx = llvm::APSInt(32);
2638 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
2642 nullPos = Idx->getZExtValue();
2644 if ((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) {
2647 S.
Diag(AL.
getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2653 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
2655 if (isa<FunctionNoProtoType>(FT)) {
2656 S.
Diag(AL.
getLoc(), diag::warn_attribute_sentinel_named_arguments);
2660 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2661 S.
Diag(AL.
getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2664 }
else if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D)) {
2665 if (!MD->isVariadic()) {
2666 S.
Diag(AL.
getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2669 }
else if (
const auto *BD = dyn_cast<BlockDecl>(
D)) {
2670 if (!BD->isVariadic()) {
2671 S.
Diag(AL.
getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2674 }
else if (
const auto *
V = dyn_cast<VarDecl>(
D)) {
2682 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2684 S.
Diag(AL.
getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2688 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
2694 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
2705 !isa<CXXConstructorDecl>(
D)) {
2706 S.
Diag(AL.
getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
2709 if (
const auto *MD = dyn_cast<ObjCMethodDecl>(
D))
2710 if (MD->getReturnType()->isVoidType()) {
2711 S.
Diag(AL.
getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
2719 if (isa<VarDecl>(
D))
2720 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type_str)
2722 <<
"functions, classes, or enumerations";
2731 if (LO.CPlusPlus && !LO.CPlusPlus20)
2732 S.
Diag(AL.
getLoc(), diag::ext_cxx20_attr) << AL;
2740 }
else if (LO.CPlusPlus && !LO.CPlusPlus17)
2741 S.
Diag(AL.
getLoc(), diag::ext_cxx17_attr) << AL;
2746 isa<TypedefNameDecl>(
D)) {
2747 S.
Diag(AL.
getLoc(), diag::warn_unused_result_typedef_unsupported_spelling)
2760 S.
Diag(AL.
getLoc(), diag::warn_attribute_invalid_on_definition)
2762 else if (isa<ObjCPropertyDecl>(
D) || isa<ObjCMethodDecl>(
D) ||
2764 (isa<ObjCInterfaceDecl>(
D) || isa<EnumDecl>(
D)))) {
2767 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
2777template <
typename WorkGroupAttr>
2780 for (
unsigned i = 0; i < 3; ++i) {
2785 if (WGSize[i] == 0) {
2786 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_is_zero)
2792 WorkGroupAttr *Existing =
D->
getAttr<WorkGroupAttr>();
2793 if (Existing && !(Existing->getXDim() == WGSize[0] &&
2794 Existing->getYDim() == WGSize[1] &&
2795 Existing->getZDim() == WGSize[2]))
2796 S.
Diag(AL.
getLoc(), diag::warn_duplicate_attribute) << AL;
2799 WorkGroupAttr(S.
Context, AL, WGSize[0], WGSize[1], WGSize[2]));
2804 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
2810 assert(ParmTSI &&
"no type source info for attribute argument");
2815 S.
Diag(AL.
getLoc(), diag::err_attribute_invalid_argument) << 2 << AL;
2819 if (VecTypeHintAttr *A =
D->
getAttr<VecTypeHintAttr>()) {
2821 S.
Diag(AL.
getLoc(), diag::warn_duplicate_attribute) << AL;
2833 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
2838 if (SectionAttr *ExistingAttr =
D->
getAttr<SectionAttr>()) {
2839 if (ExistingAttr->getName() == Name)
2841 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2843 Diag(CI.
getLoc(), diag::note_previous_attribute);
2851 return llvm::Error::success();
2854 StringRef Segment, Section;
2855 unsigned TAA, StubSize;
2857 return llvm::MCSectionMachO::ParseSectionSpecifier(SecName, Segment, Section,
2858 TAA, HasTAA, StubSize);
2863 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
2888 cast<NamedDecl>(
D));
2899 llvm::CodeModel::Model CM;
2900 if (!CodeModelAttr::ConvertStrToModel(Str, CM)) {
2901 S.
Diag(LiteralLoc, diag::err_attr_codemodel_arg) << Str;
2911 StringRef CodeSegName) {
2913 S.
Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
2925 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
2929 if (
const auto *ExistingAttr =
D->
getAttr<CodeSegAttr>()) {
2930 if (ExistingAttr->getName() == Name)
2932 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2934 Diag(CI.
getLoc(), diag::note_previous_attribute);
2947 if (
const auto *ExistingAttr =
D->
getAttr<CodeSegAttr>()) {
2948 if (!ExistingAttr->isImplicit()) {
2950 ExistingAttr->getName() == Str
2951 ? diag::warn_duplicate_codeseg_attribute
2952 : diag::err_conflicting_codeseg_attribute);
2962 enum FirstParam { Unsupported, Duplicate,
Unknown };
2963 enum SecondParam {
None, CPU, Tune };
2965 if (AttrStr.contains(
"fpmath="))
2966 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2967 << Unsupported <<
None <<
"fpmath=" <<
Target;
2971 AttrStr.contains(
"tune="))
2972 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2978 if (!ParsedAttrs.
CPU.empty() &&
2980 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2983 if (!ParsedAttrs.
Tune.empty() &&
2985 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2990 return Diag(LiteralLoc, diag::err_duplicate_target_attribute)
2994 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2997 for (
const auto &Feature : ParsedAttrs.
Features) {
2998 auto CurFeature = StringRef(Feature).drop_front();
3000 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3001 << Unsupported <<
None << CurFeature <<
Target;
3010 if (DiagMsg.empty())
3011 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3012 << Unsupported <<
None <<
"branch-protection" <<
Target;
3013 return Diag(LiteralLoc, diag::err_invalid_branch_protection_spec)
3016 if (!DiagMsg.empty())
3017 Diag(LiteralLoc, diag::warn_unsupported_branch_protection_spec) << DiagMsg;
3023 StringRef AttrStr) {
3024 enum FirstParam { Unsupported };
3025 enum SecondParam {
None };
3028 AttrStr.split(Features,
"+");
3029 for (
auto &CurFeature : Features) {
3030 CurFeature = CurFeature.trim();
3031 if (CurFeature ==
"default")
3034 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3039 return Diag(LiteralLoc, diag::err_sme_streaming_cannot_be_multiversioned);
3049 TargetVersionAttr *NewAttr =
3061 TargetAttr *NewAttr = ::new (S.
Context) TargetAttr(S.
Context, AL, Str);
3067 Decl *
D,
bool &HasDefault,
bool &HasCommas,
bool &HasNotDefault,
3069 enum FirstParam { Unsupported, Duplicate,
Unknown };
3070 enum SecondParam {
None, CPU, Tune };
3072 HasCommas = HasCommas || Str.contains(
',');
3075 if (Str.size() == 0)
3076 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3079 std::pair<StringRef, StringRef> Parts = {{}, Str};
3080 while (!Parts.second.empty()) {
3081 Parts = Parts.second.split(
',');
3082 StringRef Cur = Parts.first.trim();
3084 Literal->getLocationOfByte(Cur.data() - Literal->getString().data(),
3087 bool DefaultIsDupe =
false;
3088 bool HasCodeGenImpact =
false;
3090 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3095 if (Cur ==
"default") {
3096 DefaultIsDupe = HasDefault;
3098 if (llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)
3099 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3101 StringsBuffer.push_back(Cur);
3103 std::pair<StringRef, StringRef> CurParts = {{}, Cur};
3105 while (!CurParts.second.empty()) {
3106 CurParts = CurParts.second.split(
'+');
3107 StringRef CurFeature = CurParts.first.trim();
3109 Diag(CurLoc, diag::warn_unsupported_target_attribute)
3114 HasCodeGenImpact =
true;
3115 CurFeatures.push_back(CurFeature);
3118 llvm::sort(CurFeatures);
3120 for (
auto &CurFeat : CurFeatures) {
3123 Res.append(CurFeat);
3125 if (llvm::is_contained(StringsBuffer, Res) || DefaultIsDupe)
3126 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3127 else if (!HasCodeGenImpact)
3130 Diag(CurLoc, diag::warn_target_clone_no_impact_options);
3131 else if (!Res.empty()) {
3132 StringsBuffer.push_back(Res);
3133 HasNotDefault =
true;
3138 return Diag(LiteralLoc,
3139 diag::err_sme_streaming_cannot_be_multiversioned);
3142 if (Cur.starts_with(
"arch=")) {
3144 Cur.drop_front(
sizeof(
"arch=") - 1)))
3145 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3146 << Unsupported << CPU << Cur.drop_front(
sizeof(
"arch=") - 1)
3148 }
else if (Cur ==
"default") {
3149 DefaultIsDupe = HasDefault;
3152 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3154 if (llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)
3155 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3157 StringsBuffer.push_back(Cur);
3160 if (Str.rtrim().ends_with(
","))
3161 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3174 S.
Diag(AL.
getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
3175 S.
Diag(
Other->getLocation(), diag::note_conflicting_attribute);
3178 if (checkAttrMutualExclusion<TargetClonesAttr>(S,
D, AL))
3183 bool HasCommas =
false, HasDefault =
false, HasNotDefault =
false;
3185 for (
unsigned I = 0,
E = AL.
getNumArgs(); I !=
E; ++I) {
3192 HasDefault, HasCommas, HasNotDefault, StringsBuffer))
3195 for (
auto &SmallStr : StringsBuffer)
3196 Strings.push_back(SmallStr.str());
3199 S.
Diag(AL.
getLoc(), diag::warn_target_clone_mixed_values);
3204 Strings.push_back(
"default");
3208 S.
Diag(AL.
getLoc(), diag::err_target_clone_must_have_default);
3214 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
3215 if (MD->getParent()->isLambda()) {
3227 cast<FunctionDecl>(
D)->setIsMultiVersion();
3228 TargetClonesAttr *NewAttr = ::new (S.
Context)
3229 TargetClonesAttr(S.
Context, AL, Strings.data(), Strings.size());
3241 MinVectorWidthAttr *Existing =
D->
getAttr<MinVectorWidthAttr>();
3242 if (Existing && Existing->getVectorWidth() != VecWidth) {
3243 S.
Diag(AL.
getLoc(), diag::warn_duplicate_attribute) << AL;
3258 if (
auto *DRE = dyn_cast<DeclRefExpr>(
E)) {
3260 S.
Diag(
Loc, diag::warn_cleanup_ext);
3261 FD = dyn_cast<FunctionDecl>(DRE->
getDecl());
3264 S.
Diag(
Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3268 }
else if (
auto *ULE = dyn_cast<UnresolvedLookupExpr>(
E)) {
3269 if (ULE->hasExplicitTemplateArgs())
3270 S.
Diag(
Loc, diag::warn_cleanup_ext);
3272 NI = ULE->getNameInfo();
3274 S.
Diag(
Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3281 S.
Diag(
Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3286 S.
Diag(
Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3297 S.
Diag(
Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3298 << NI.
getName() << ParamTy << Ty;
3312 S.
Context, VariableReference, UnaryOperatorKind::UO_AddrOf,
3332 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
3337 EnumExtensibilityAttr::Kind ExtensibilityKind;
3339 if (!EnumExtensibilityAttr::ConvertStrToKind(II->
getName(),
3340 ExtensibilityKind)) {
3341 S.
Diag(AL.
getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
3346 EnumExtensibilityAttr(S.
Context, AL, ExtensibilityKind));
3364 S.
Diag(AL.
getLoc(), diag::err_format_attribute_not)
3372 if (
auto *OMD = dyn_cast<ObjCMethodDecl>(
D))
3373 if (
auto *
Interface = OMD->getClassInterface())
3380 S.
Diag(AL.
getLoc(), diag::err_format_attribute_result_not)
3381 << (NotNSStringTy ?
"string type" :
"NSString")
3401 return llvm::StringSwitch<FormatAttrKind>(Format)
3415 .Cases(
"gcc_diag",
"gcc_cdiag",
"gcc_cxxdiag",
"gcc_tdiag",
IgnoredFormat)
3423 S.
Diag(AL.
getLoc(), diag::warn_attribute_ignored) << AL;
3428 S.
Diag(AL.
getLoc(), diag::err_hlsl_init_priority_unsupported);
3433 S.
Diag(AL.
getLoc(), diag::err_init_priority_object_attr);
3441 S.
Diag(AL.
getLoc(), diag::err_init_priority_object_attr);
3447 uint32_t prioritynum;
3456 if ((prioritynum < 101 || prioritynum > 65535) &&
3458 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_range)
3467 StringRef NewUserDiagnostic) {
3468 if (
const auto *EA =
D->
getAttr<ErrorAttr>()) {
3470 assert((NewAttr ==
"error" || NewAttr ==
"warning") &&
3471 "unexpected normalized full name");
3472 bool Match = (EA->isError() && NewAttr ==
"error") ||
3473 (EA->isWarning() && NewAttr ==
"warning");
3475 Diag(EA->getLocation(), diag::err_attributes_are_not_compatible)
3478 EA->isRegularKeywordAttribute());
3479 Diag(CI.
getLoc(), diag::note_conflicting_attribute);
3482 if (EA->getUserDiagnostic() != NewUserDiagnostic) {
3483 Diag(CI.
getLoc(), diag::warn_duplicate_attribute) << EA;
3484 Diag(EA->getLoc(), diag::note_previous_attribute);
3488 return ::new (
Context) ErrorAttr(
Context, CI, NewUserDiagnostic);
3496 if (F->getType() == Format &&
3497 F->getFormatIdx() == FormatIdx &&
3498 F->getFirstArg() == FirstArg) {
3501 if (F->getLocation().isInvalid())
3507 return ::new (
Context) FormatAttr(
Context, CI, Format, FormatIdx, FirstArg);
3514 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
3525 StringRef Format = II->
getName();
3539 S.
Diag(AL.
getLoc(), diag::warn_attribute_type_not_supported)
3550 if (Idx < 1 || Idx > NumArgs) {
3551 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
3557 unsigned ArgIdx = Idx - 1;
3559 if (HasImplicitThisParam) {
3562 diag::err_format_attribute_implicit_this_format_string)
3575 S.
Diag(AL.
getLoc(), diag::err_format_attribute_not)
3587 if (FirstArg != 0) {
3591 S.
Diag(AL.
getLoc(), diag::err_format_strftime_third_parameter)
3599 if (FirstArg != NumArgs + 1) {
3600 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
3603 std::to_string(NumArgs + 1));
3609 if (FirstArg <= Idx) {
3613 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
3629 S.
Diag(AL.
getLoc(), diag::err_callback_attribute_no_callee)
3638 assert(FD &&
"Expected a function declaration!");
3640 llvm::StringMap<int> NameIdxMapping;
3641 NameIdxMapping[
"__"] = -1;
3643 NameIdxMapping[
"this"] = 0;
3647 NameIdxMapping[PVD->getName()] = Idx++;
3649 auto UnknownName = NameIdxMapping.end();
3652 for (
unsigned I = 0,
E = AL.
getNumArgs(); I <
E; ++I) {
3658 auto It = NameIdxMapping.find(IdLoc->
Ident->
getName());
3659 if (It == UnknownName) {
3660 S.
Diag(AL.
getLoc(), diag::err_callback_attribute_argument_unknown)
3666 ArgIdx = It->second;
3673 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
3679 if (ArgIdx < -1 || ArgIdx > NumArgs) {
3680 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
3687 llvm_unreachable(
"Unexpected ParsedAttr argument type!");
3690 if (ArgIdx == 0 && !HasImplicitThisParam) {
3691 S.
Diag(AL.
getLoc(), diag::err_callback_implicit_this_not_available)
3698 if (!HasImplicitThisParam && ArgIdx > 0)
3701 EncodingIndices.push_back(ArgIdx);
3704 int CalleeIdx = EncodingIndices.front();
3708 if (CalleeIdx < (
int)HasImplicitThisParam) {
3709 S.
Diag(AL.
getLoc(), diag::err_callback_attribute_invalid_callee)
3716 const Type *CalleeType =
3720 S.
Diag(AL.
getLoc(), diag::err_callback_callee_no_function_type)
3725 const Type *CalleeFnType =
3730 const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);
3731 if (!CalleeFnProtoType) {
3732 S.
Diag(AL.
getLoc(), diag::err_callback_callee_no_function_type)
3737 if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {
3738 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments)
3739 << AL << (
unsigned)(EncodingIndices.size() - 1);
3743 if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {
3744 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments)
3745 << AL << (
unsigned)(EncodingIndices.size() - 1);
3749 if (CalleeFnProtoType->isVariadic()) {
3761 S.
Context, AL, EncodingIndices.data(), EncodingIndices.size()));
3774 QualType T = cast<ParmVarDecl>(
D)->getType();
3777 S.
Diag(AL.
getLoc(), diag::err_called_once_attribute_wrong_type);
3787 const auto *TD = dyn_cast<TypedefNameDecl>(
D);
3788 if (TD && TD->getUnderlyingType()->isUnionType())
3789 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3791 RD = dyn_cast<RecordDecl>(
D);
3794 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
3802 diag::warn_transparent_union_attribute_not_definition);
3808 if (Field == FieldEnd) {
3809 S.
Diag(AL.
getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3817 diag::warn_transparent_union_attribute_floating)
3826 for (; Field != FieldEnd; ++Field) {
3827 QualType FieldType = Field->getType();
3841 S.
Diag(Field->getLocation(),
3842 diag::warn_transparent_union_attribute_field_size_align)
3843 << isSize << *Field << FieldBits;
3844 unsigned FirstBits = isSize ? FirstSize : FirstAlign;
3846 diag::note_transparent_union_first_field_size_align)
3847 << isSize << FirstBits;
3857 auto *
Attr = AnnotateAttr::Create(
Context, Str, Args.data(), Args.size(), CI);
3873 for (
unsigned Idx = 1; Idx < AL.
getNumArgs(); Idx++) {
3886 AlignValueAttr TmpAttr(
Context, CI,
E);
3890 if (
const auto *TD = dyn_cast<TypedefNameDecl>(
D))
3891 T = TD->getUnderlyingType();
3892 else if (
const auto *VD = dyn_cast<ValueDecl>(
D))
3895 llvm_unreachable(
"Unknown decl type for align_value");
3899 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3905 llvm::APSInt Alignment;
3907 E, &Alignment, diag::err_align_value_attribute_argument_not_int);
3911 if (!Alignment.isPowerOf2()) {
3912 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3934 diag::err_pack_expansion_without_parameter_packs);
3949 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
3961 diag::err_pack_expansion_without_parameter_packs);
3988 const AlignedAttr &
Attr,
3991 if (isa<ParmVarDecl>(
D)) {
3993 }
else if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
3996 if (VD->isExceptionVariable())
3998 }
else if (
const auto *FD = dyn_cast<FieldDecl>(
D)) {
3999 if (FD->isBitField())
4001 }
else if (
const auto *ED = dyn_cast<EnumDecl>(
D)) {
4002 if (ED->getLangOpts().CPlusPlus)
4004 }
else if (!isa<TagDecl>(
D)) {
4005 return S.
Diag(AttrLoc, diag::err_attribute_wrong_decl_type)
4010 if (DiagKind != -1) {
4011 return S.
Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
4012 << &
Attr << DiagKind;
4018 bool IsPackExpansion) {
4019 AlignedAttr TmpAttr(
Context, CI,
true,
E);
4023 if (TmpAttr.isAlignas() &&
4031 if (
const auto *TND = dyn_cast<TypedefNameDecl>(
D)) {
4032 if (!TND->getUnderlyingType()->isDependentType()) {
4033 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
4041 AA->setPackExpansion(IsPackExpansion);
4047 llvm::APSInt Alignment;
4049 E, &Alignment, diag::err_aligned_attribute_argument_not_int);
4057 Diag(AttrLoc, diag::err_attribute_aligned_too_great)
4062 uint64_t AlignVal = Alignment.getZExtValue();
4068 if (!(TmpAttr.isAlignas() && !Alignment)) {
4069 if (!llvm::isPowerOf2_64(AlignVal)) {
4070 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
4076 const auto *VD = dyn_cast<VarDecl>(
D);
4078 unsigned MaxTLSAlign =
4081 if (MaxTLSAlign && AlignVal > MaxTLSAlign &&
4083 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
4084 << (
unsigned)AlignVal << VD << MaxTLSAlign;
4092 const Type *Ty = VD->getType().getTypePtr();
4094 Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
4095 << VD->getType() << 16;
4101 AA->setPackExpansion(IsPackExpansion);
4102 AA->setCachedAlignmentValue(
4109 AlignedAttr TmpAttr(
Context, CI,
false, TS);
4113 if (TmpAttr.isAlignas() &&
4121 if (
const auto *TND = dyn_cast<TypedefNameDecl>(
D)) {
4122 if (!TND->getUnderlyingType()->isDependentType()) {
4123 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
4129 AlignedAttr *AA = ::new (
Context) AlignedAttr(
Context, CI,
false, TS);
4130 AA->setPackExpansion(IsPackExpansion);
4135 const auto *VD = dyn_cast<VarDecl>(
D);
4136 unsigned AlignVal = TmpAttr.getAlignment(
Context);
4140 const Type *Ty = VD->getType().getTypePtr();
4143 Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
4144 << VD->getType() << 16;
4149 AlignedAttr *AA = ::new (
Context) AlignedAttr(
Context, CI,
false, TS);
4150 AA->setPackExpansion(IsPackExpansion);
4151 AA->setCachedAlignmentValue(AlignVal);
4156 assert(
D->
hasAttrs() &&
"no attributes on decl");
4159 if (
const auto *VD = dyn_cast<ValueDecl>(
D)) {
4160 UnderlyingTy = DiagTy = VD->getType();
4163 if (
const auto *ED = dyn_cast<EnumDecl>(
D))
4164 UnderlyingTy = ED->getIntegerType();
4173 AlignedAttr *AlignasAttr =
nullptr;
4174 AlignedAttr *LastAlignedAttr =
nullptr;
4177 if (I->isAlignmentDependent())
4181 Align = std::max(Align, I->getAlignment(
Context));
4182 LastAlignedAttr = I;
4186 Diag(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type)
4187 << LastAlignedAttr << DiagTy;
4188 }
else if (AlignasAttr && Align) {
4191 if (NaturalAlign > RequestedAlign)
4192 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
4228 bool &IntegerMode,
bool &ComplexMode,
4231 ComplexMode =
false;
4233 switch (Str.size()) {
4253 DestWidth = Str[1] ==
'I' ? 0 : 128;
4261 DestWidth = Str[1] ==
'I' ? 0 : 128;
4264 if (Str[1] ==
'F') {
4265 IntegerMode =
false;
4266 }
else if (Str[1] ==
'C') {
4267 IntegerMode =
false;
4269 }
else if (Str[1] !=
'I') {
4278 else if (Str ==
"byte")
4282 if (Str ==
"pointer")
4286 if (Str ==
"unwind_word")
4302 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
4314 StringRef Str = Name->getName();
4318 unsigned DestWidth = 0;
4319 bool IntegerMode =
true;
4320 bool ComplexMode =
false;
4322 llvm::APInt VectorSize(64, 0);
4323 if (Str.size() >= 4 && Str[0] ==
'V') {
4325 size_t StrSize = Str.size();
4326 size_t VectorStringLength = 0;
4327 while ((VectorStringLength + 1) < StrSize &&
4328 isdigit(Str[VectorStringLength + 1]))
4329 ++VectorStringLength;
4330 if (VectorStringLength &&
4331 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
4332 VectorSize.isPowerOf2()) {
4334 IntegerMode, ComplexMode, ExplicitType);
4336 if (!InInstantiation)
4337 Diag(AttrLoc, diag::warn_vector_mode_deprecated);
4352 Diag(AttrLoc, diag::err_machine_mode) << 0 << Name;
4357 if (
const auto *TD = dyn_cast<TypedefNameDecl>(
D))
4358 OldTy = TD->getUnderlyingType();
4359 else if (
const auto *ED = dyn_cast<EnumDecl>(
D)) {
4362 OldTy = ED->getIntegerType();
4366 OldTy = cast<ValueDecl>(
D)->getType();
4377 OldElemTy = VT->getElementType();
4383 VectorSize.getBoolValue()) {
4384 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << CI.
getRange();
4392 !IntegralOrAnyEnumType)
4393 Diag(AttrLoc, diag::err_mode_not_primitive);
4394 else if (IntegerMode) {
4395 if (!IntegralOrAnyEnumType)
4396 Diag(AttrLoc, diag::err_mode_wrong_type);
4397 }
else if (ComplexMode) {
4399 Diag(AttrLoc, diag::err_mode_wrong_type);
4402 Diag(AttrLoc, diag::err_mode_wrong_type);
4413 if (NewElemTy.
isNull()) {
4415 if (!(DestWidth == 128 &&
getLangOpts().CUDAIsDevice))
4416 Diag(AttrLoc, diag::err_machine_mode) << 1 << Name;
4425 if (VectorSize.getBoolValue()) {
4431 Diag(AttrLoc, diag::err_complex_mode_vector_type);
4435 OldVT->getNumElements() /
4442 Diag(AttrLoc, diag::err_mode_wrong_type);
4447 if (
auto *TD = dyn_cast<TypedefNameDecl>(
D))
4448 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
4449 else if (
auto *ED = dyn_cast<EnumDecl>(
D))
4450 ED->setIntegerType(NewTy);
4452 cast<ValueDecl>(
D)->setType(NewTy);
4464 if (OptimizeNoneAttr *Optnone =
D->
getAttr<OptimizeNoneAttr>()) {
4465 Diag(CI.
getLoc(), diag::warn_attribute_ignored) << Ident;
4466 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4470 if (
D->
hasAttr<AlwaysInlineAttr>())
4478 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
4481 if (VD->getKind() != Decl::Var) {
4482 Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
4489 if (VD->hasLocalStorage()) {
4490 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4497InternalLinkageAttr *
4499 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
4502 if (VD->getKind() != Decl::Var) {
4503 Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type)
4504 << &AL << AL.isRegularKeywordAttribute()
4510 if (VD->hasLocalStorage()) {
4511 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4520 if (OptimizeNoneAttr *Optnone =
D->
getAttr<OptimizeNoneAttr>()) {
4521 Diag(CI.
getLoc(), diag::warn_attribute_ignored) <<
"'minsize'";
4522 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4534 if (AlwaysInlineAttr *Inline =
D->
getAttr<AlwaysInlineAttr>()) {
4535 Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4536 Diag(CI.
getLoc(), diag::note_conflicting_attribute);
4539 if (MinSizeAttr *MinSize =
D->
getAttr<MinSizeAttr>()) {
4540 Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4541 Diag(CI.
getLoc(), diag::note_conflicting_attribute);
4545 if (
D->
hasAttr<OptimizeNoneAttr>())
4552 if (AlwaysInlineAttr *Inline =
4568 const auto *VD = cast<VarDecl>(
D);
4569 if (VD->hasLocalStorage()) {
4570 S.
Diag(AL.
getLoc(), diag::err_cuda_nonstatic_constdev);
4575 if (
auto *A =
D->
getAttr<CUDAConstantAttr>()) {
4576 if (!A->isImplicit())
4584 const auto *VD = cast<VarDecl>(
D);
4587 if (!S.
getLangOpts().GPURelocatableDeviceCode && VD->hasExternalStorage() &&
4588 !isa<IncompleteArrayType>(VD->getType())) {
4589 S.
Diag(AL.
getLoc(), diag::err_cuda_extern_shared) << VD;
4592 if (S.
getLangOpts().CUDA && VD->hasLocalStorage() &&
4600 const auto *FD = cast<FunctionDecl>(
D);
4611 if (
const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4612 if (Method->isInstance()) {
4613 S.
Diag(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method)
4617 S.
Diag(Method->getBeginLoc(), diag::warn_kern_is_method) << Method;
4623 if (AL.
getKind() == ParsedAttr::AT_NVPTXKernel)
4636 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
4637 if (VD->hasLocalStorage()) {
4638 S.
Diag(AL.
getLoc(), diag::err_cuda_nonstatic_constdev);
4643 if (
auto *A =
D->
getAttr<CUDADeviceAttr>()) {
4644 if (!A->isImplicit())
4652 if (
const auto *VD = dyn_cast<VarDecl>(
D)) {
4653 if (VD->hasLocalStorage()) {
4654 S.
Diag(AL.
getLoc(), diag::err_cuda_nonstatic_constdev);
4665 const auto *Fn = cast<FunctionDecl>(
D);
4666 if (!Fn->isInlineSpecified()) {
4667 S.
Diag(AL.
getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4672 S.
Diag(AL.
getLoc(), diag::warn_gnu_inline_cplusplus_without_extern);
4688 if (!isa<ObjCMethodDecl>(
D)) {
4689 S.
Diag(AL.
getLoc(), diag::warn_attribute_wrong_decl_type)
4695 case ParsedAttr::AT_FastCall:
4698 case ParsedAttr::AT_StdCall:
4701 case ParsedAttr::AT_ThisCall:
4704 case ParsedAttr::AT_CDecl:
4707 case ParsedAttr::AT_Pascal:
4710 case ParsedAttr::AT_SwiftCall:
4713 case ParsedAttr::AT_SwiftAsyncCall:
4716 case ParsedAttr::AT_VectorCall:
4719 case ParsedAttr::AT_MSABI:
4722 case ParsedAttr::AT_SysVABI:
4725 case ParsedAttr::AT_RegCall:
4728 case ParsedAttr::AT_Pcs: {
4729 PcsAttr::PCSType PCS;
4732 PCS = PcsAttr::AAPCS;
4735 PCS = PcsAttr::AAPCS_VFP;
4738 llvm_unreachable(
"unexpected calling convention in pcs attribute");
4744 case ParsedAttr::AT_AArch64VectorPcs:
4747 case ParsedAttr::AT_AArch64SVEPcs:
4750 case ParsedAttr::AT_AMDGPUKernelCall:
4753 case ParsedAttr::AT_IntelOclBicc:
4756 case ParsedAttr::AT_PreserveMost:
4759 case ParsedAttr::AT_PreserveAll:
4762 case ParsedAttr::AT_M68kRTD:
4765 case ParsedAttr::AT_PreserveNone:
4768 case ParsedAttr::AT_RISCVVectorCC:
4772 llvm_unreachable(
"unexpected attribute kind");
4783 std::vector<StringRef> DiagnosticIdentifiers;
4784 for (
unsigned I = 0,
E = AL.
getNumArgs(); I !=
E; ++I) {
4790 DiagnosticIdentifiers.push_back(RuleName);
4793 SuppressAttr(S.
Context, AL, DiagnosticIdentifiers.data(),
4794 DiagnosticIdentifiers.size()));
4803 unsigned SelectIdx = ~0
U;
4809 if (SelectIdx != ~0
U) {
4810 S.
Diag(AL.
getLoc(), diag::err_attribute_invalid_argument)
4822 if (AL.
getKind() == ParsedAttr::AT_Owner) {
4823 if (checkAttrMutualExclusion<PointerAttr>(S,
D, AL))
4825 if (
const auto *OAttr =
D->
getAttr<OwnerAttr>()) {
4826 const Type *ExistingDerefType = OAttr->getDerefTypeLoc()
4827 ? OAttr->getDerefType().getTypePtr()
4830 S.
Diag(AL.
getLoc(), diag::err_attributes_are_not_compatible)
4833 OAttr->isRegularKeywordAttribute());
4834 S.
Diag(OAttr->getLocation(), diag::note_conflicting_attribute);
4839 Redecl->addAttr(::new (S.
Context) OwnerAttr(S.
Context, AL, DerefTypeLoc));
4842 if (checkAttrMutualExclusion<OwnerAttr>(S,
D, AL))
4844 if (
const auto *PAttr =
D->
getAttr<PointerAttr>()) {
4845 const Type *ExistingDerefType = PAttr->getDerefTypeLoc()
4846 ? PAttr->getDerefType().getTypePtr()
4849 S.
Diag(AL.
getLoc(), diag::err_attributes_are_not_compatible)
4852 PAttr->isRegularKeywordAttribute());
4853 S.
Diag(PAttr->getLocation(), diag::note_conflicting_attribute);
4858 Redecl->addAttr(::new (S.
Context)
4859 PointerAttr(S.
Context, AL, DerefTypeLoc));
4865 if (checkAttrMutualExclusion<NoRandomizeLayoutAttr>(S,
D, AL))
4867 if (!
D->
hasAttr<RandomizeLayoutAttr>())
4873 if (checkAttrMutualExclusion<RandomizeLayoutAttr>(S,
D, AL))
4875 if (!
D->
hasAttr<NoRandomizeLayoutAttr>())
4890 unsigned ReqArgs = Attrs.
getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
4898 case ParsedAttr::AT_CDecl:
4901 case ParsedAttr::AT_FastCall:
4904 case ParsedAttr::AT_StdCall:
4907 case ParsedAttr::AT_ThisCall:
4910 case ParsedAttr::AT_Pascal:
4913 case ParsedAttr::AT_SwiftCall:
4916 case ParsedAttr::AT_SwiftAsyncCall:
4919 case ParsedAttr::AT_VectorCall:
4922 case ParsedAttr::AT_AArch64VectorPcs:
4925 case ParsedAttr::AT_AArch64SVEPcs:
4928 case ParsedAttr::AT_AMDGPUKernelCall:
4931 case ParsedAttr::AT_RegCall:
4934 case ParsedAttr::AT_MSABI:
4938 case ParsedAttr::AT_SysVABI:
4942 case ParsedAttr::AT_Pcs: {
4948 if (StrRef ==
"aapcs") {
4951 }
else if (StrRef ==
"aapcs-vfp") {
4960 case ParsedAttr::AT_IntelOclBicc:
4963 case ParsedAttr::AT_PreserveMost:
4966 case ParsedAttr::AT_PreserveAll:
4969 case ParsedAttr::AT_M68kRTD:
4972 case ParsedAttr::AT_PreserveNone:
4975 case ParsedAttr::AT_RISCVVectorCC:
4978 default: llvm_unreachable(
"unexpected attribute kind");
4991 bool CheckHost =
false, CheckDevice =
false;
4992 switch (CudaTarget) {
5005 llvm_unreachable(
"unexpected cuda target");
5007 auto *HostTI =
LangOpts.CUDAIsDevice ? Aux : &TI;
5008 auto *DeviceTI =
LangOpts.CUDAIsDevice ? &TI : Aux;
5009 if (CheckHost && HostTI)
5012 A = DeviceTI->checkCallingConvention(CC);
5030 Diag(Attrs.
getLoc(), diag::error_cconv_unsupported)
5035 Diag(Attrs.
getLoc(), diag::warn_cconv_unsupported)
5040 bool IsCXXMethod =
false, IsVariadic =
false;
5071 Diag(AL.
getLoc(), diag::err_attribute_regparm_wrong_platform)
5079 Diag(AL.
getLoc(), diag::err_attribute_regparm_invalid_number)
5091 llvm_unreachable(
"getOffloadArch is only valid for NVPTX triple");
5101 const CUDALaunchBoundsAttr &AL,
5102 const unsigned Idx) {
5111 std::optional<llvm::APSInt> I = llvm::APSInt(64);
5118 if (!I->isIntN(32)) {
5120 <<
toString(*I, 10,
false) << 32 << 1;
5132 "Unexpected PerformCopyInitialization() failure.");
5137CUDALaunchBoundsAttr *
5139 Expr *MinBlocks,
Expr *MaxBlocks) {
5140 CUDALaunchBoundsAttr TmpAttr(
Context, CI, MaxThreads, MinBlocks, MaxBlocks);
5158 MaxBlocks =
nullptr;
5167 CUDALaunchBoundsAttr(
Context, CI, MaxThreads, MinBlocks, MaxBlocks);
5189 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
5207 unsigned ArgumentIdxAST = ArgumentIdx.
getASTIndex();
5210 S.
Diag(AL.
getLoc(), diag::err_attribute_pointers_only) << AL << 0;
5221 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
5229 if (!isa<VarDecl>(
D)) {
5230 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_decl_type)
5238 assert(MatchingCTypeLoc &&
"no type source info for attribute argument");
5261 S.
Diag(AL.
getLoc(), diag::err_aix_attr_unsupported) << AL;
5264 uint32_t Count = 0, Offset = 0;
5271 if (Count < Offset) {
5272 S.
Diag(S.
getAttrLoc(AL), diag::err_attribute_argument_out_of_range)
5278 PatchableFunctionEntryAttr(S.
Context, AL, Count, Offset));
5283 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_n_type)
5290 StringRef AliasName = cast<FunctionDecl>(
D)->getIdentifier()->getName();
5300 (!IsAArch64 && !IsARM && !IsRISCV && !IsHLSL)) {
5301 S.
Diag(AL.
getLoc(), diag::err_attribute_builtin_alias) << AL;
5312 if (
auto *CRD = dyn_cast<CXXRecordDecl>(
D);
5313 !CRD || !(CRD->isClass() || CRD->isStruct())) {
5319 handleSimpleAttribute<TypeNullableAttr>(S,
D, AL);
5324 S.
Diag(AL.
getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
5330 assert(ParmTSI &&
"no type source info for attribute argument");
5332 diag::err_incomplete_type);
5342 StringRef UuidAsWritten,
MSGuidDecl *GuidDecl) {
5343 if (
const auto *UA =
D->
getAttr<UuidAttr>()) {
5346 if (!UA->getGuid().empty()) {
5347 Diag(UA->getLocation(), diag::err_mismatched_uuid);
5353 return ::new (
Context) UuidAttr(
Context, CI, UuidAsWritten, GuidDecl);
5358 S.
Diag(AL.
getLoc(), diag::err_attribute_not_supported_in_lang)
5363 StringRef OrigStrRef;
5370 StringRef StrRef = OrigStrRef;
5371 if (StrRef.size() == 38 && StrRef.front() ==
'{' && StrRef.back() ==
'}')
5372 StrRef = StrRef.drop_front().drop_back();
5375 if (StrRef.size() != 36) {
5376 S.
Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5380 for (
unsigned i = 0; i < 36; ++i) {
5381 if (i == 8 || i == 13 || i == 18 || i == 23) {
5382 if (StrRef[i] !=
'-') {
5383 S.
Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5387 S.
Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5394 StrRef.substr(0, 8).getAsInteger(16, Parsed.
Part1);
5395 StrRef.substr(9, 4).getAsInteger(16, Parsed.
Part2);
5396 StrRef.substr(14, 4).getAsInteger(16, Parsed.
Part3);
5397 for (
unsigned i = 0; i != 8; ++i)
5398 StrRef.substr(19 + 2 * i + (i >= 2 ? 1 : 0), 2)
5409 S.
Diag(AL.
getLoc(), diag::warn_atl_uuid_deprecated);
5418 S.
Diag(AL.
getLoc(), diag::err_attribute_not_supported_in_lang)
5431 const auto *VD = cast<VarDecl>(
D);
5433 S.
Diag(AL.
getLoc(), diag::err_thread_unsupported);
5437 S.
Diag(AL.
getLoc(), diag::err_declspec_thread_on_thread_variable);
5440 if (VD->hasLocalStorage()) {
5441 S.
Diag(AL.
getLoc(), diag::err_thread_non_global) <<
"__declspec(thread)";
5449 S.
Diag(AL.
getLoc(), diag::warn_unknown_attribute_ignored)
5453 auto *FD = cast<FunctionDecl>(
D);
5455 S.
Diag(AL.
getLoc(), diag::err_ms_constexpr_cannot_be_applied)
5459 if (
auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
5460 if (!S.
getLangOpts().CPlusPlus20 && MD->isVirtual()) {
5461 S.
Diag(AL.
getLoc(), diag::err_ms_constexpr_cannot_be_applied)
5471 for (
unsigned I = 0,
E = AL.
getNumArgs(); I !=
E; ++I) {
5475 Tags.push_back(Tag);
5478 if (
const auto *NS = dyn_cast<NamespaceDecl>(
D)) {
5479 if (!NS->isInline()) {
5480 S.
Diag(AL.
getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5483 if (NS->isAnonymousNamespace()) {
5484 S.
Diag(AL.
getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5488 Tags.push_back(NS->getName());
5494 Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5497 AbiTagAttr(S.
Context, AL, Tags.data(), Tags.size()));
5502 if (I->getBTFDeclTag() == Tag)
5521 return ::new (
Context) BTFDeclTagAttr(
Context, AL, AL.getBTFDeclTag());
5527 case llvm::Triple::msp430:
5530 case llvm::Triple::mipsel:
5531 case llvm::Triple::mips:
5534 case llvm::Triple::m68k:
5537 case llvm::Triple::x86:
5538 case llvm::Triple::x86_64:
5541 case llvm::Triple::avr:
5544 case llvm::Triple::riscv32:
5545 case llvm::Triple::riscv64:
5562 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_out_of_bounds)
5578 Diag(CI.
getLoc(), diag::warn_attribute_ignored) <<
"'dllimport'";
5590 if (DLLImportAttr *Import =
D->
getAttr<DLLImportAttr>()) {
5591 Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
5602 if (isa<ClassTemplatePartialSpecializationDecl>(
D) &&
5608 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
5618 if (
const auto *MD = dyn_cast<CXXMethodDecl>(
D)) {
5620 MD->getParent()->isLambda()) {
5626 Attr *NewAttr = A.
getKind() == ParsedAttr::AT_DLLExport
5637 if (MSInheritanceAttr *IA =
D->
getAttr<MSInheritanceAttr>()) {
5638 if (IA->getInheritanceModel() == Model)
5640 Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
5642 Diag(CI.
getLoc(), diag::note_previous_ms_inheritance);
5646 auto *RD = cast<CXXRecordDecl>(
D);
5647 if (RD->hasDefinition()) {
5653 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
5654 Diag(CI.
getLoc(), diag::warn_ignored_ms_inheritance)
5658 if (RD->getDescribedClassTemplate()) {
5659 Diag(CI.
getLoc(), diag::warn_ignored_ms_inheritance)
5677 StringRef N(
"mutex");
5679 if (AL.
getKind() == ParsedAttr::AT_Capability &&
5692 AssertCapabilityAttr(S.
Context, AL, Args.data(), Args.size()));
5736 RequiresCapabilityAttr *RCA = ::new (S.
Context)
5737 RequiresCapabilityAttr(S.
Context, AL, Args.data(), Args.size());
5743 if (
const auto *NSD = dyn_cast<NamespaceDecl>(
D)) {
5744 if (NSD->isAnonymousNamespace()) {
5745 S.
Diag(AL.
getLoc(), diag::warn_deprecated_anonymous_namespace);
5759 StringRef Str, Replacement;
5772 S.
Diag(AL.
getLoc(), diag::ext_cxx14_attr) << AL;
5778 if (
const auto *S = dyn_cast<VarDecl>(
D))
5779 return S->hasGlobalStorage();
5784 return Sanitizer ==
"address" || Sanitizer ==
"hwaddress" ||
5785 Sanitizer ==
"memtag";
5792 std::vector<StringRef> Sanitizers;
5794 for (
unsigned I = 0,
E = AL.
getNumArgs(); I !=
E; ++I) {
5795 StringRef SanitizerName;
5803 SanitizerName !=
"coverage")
5804 S.
Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
5807 << AL << SanitizerName;
5808 Sanitizers.push_back(SanitizerName);
5812 Sanitizers.size()));
5819 StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
5820 .Case(
"no_address_safety_analysis",
"address")
5821 .Case(
"no_sanitize_address",
"address")
5822 .Case(
"no_sanitize_thread",
"thread")
5823 .Case(
"no_sanitize_memory",
"memory");
5836 unsigned TranslatedSpellingIndex = 0;
5838 TranslatedSpellingIndex = 1;
5843 NoSanitizeAttr(S.
Context, Info, &SanitizerName, 1));
5858 ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind Kind;
5859 if (!ZeroCallUsedRegsAttr::ConvertStrToZeroCallUsedRegsKind(KindStr, Kind)) {
5860 S.
Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
5870 auto *FD = dyn_cast<FieldDecl>(
D);
5880 case ParsedAttr::AT_CountedBy:
5881 CountInBytes =
false;
5884 case ParsedAttr::AT_CountedByOrNull:
5885 CountInBytes =
false;
5888 case ParsedAttr::AT_SizedBy:
5889 CountInBytes =
true;
5892 case ParsedAttr::AT_SizedByOrNull:
5893 CountInBytes =
true;
5897 llvm_unreachable(
"unexpected counted_by family attribute");
5905 FD->
getType(), CountExpr, CountInBytes, OrNull);
5916 FunctionReturnThunksAttr::Kind Kind;
5917 if (!FunctionReturnThunksAttr::ConvertStrToKind(KindStr, Kind)) {
5918 S.
Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
5925 D->
dropAttr<FunctionReturnThunksAttr>();
5931 assert(isa<TypedefNameDecl>(
D) &&
"This attribute only applies to a typedef");
5932 handleSimpleAttribute<AvailableOnlyInDefaultEvalMethodAttr>(S,
D, AL);
5936 auto *VDecl = dyn_cast<VarDecl>(
D);
5937 if (VDecl && !VDecl->isFunctionPointerType()) {
5938 S.
Diag(AL.
getLoc(), diag::warn_attribute_ignored_non_function_pointer)
5950 if (!cast<VarDecl>(
D)->hasGlobalStorage()) {
5952 << (A.
getKind() == ParsedAttr::AT_AlwaysDestroy);
5956 if (A.
getKind() == ParsedAttr::AT_AlwaysDestroy)
5957 handleSimpleAttribute<AlwaysDestroyAttr>(S,
D, A);
5959 handleSimpleAttribute<NoDestroyAttr>(S,
D, A);
5963 assert(cast<VarDecl>(
D)->getStorageDuration() ==
SD_Automatic &&
5964 "uninitialized is only valid on automatic duration variables");
5973 if (!isa<BlockDecl>(
D)) {
5975 bool IsKernReturnT =
false;
5977 IsKernReturnT = (TT->getDecl()->getName() ==
"kern_return_t");
5982 diag::warn_mig_server_routine_does_not_return_kern_return_t);
5987 handleSimpleAttribute<MIGServerRoutineAttr>(S,
D, AL);
5992 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
5995 S.
Diag(AL.
getLoc(), diag::warn_declspec_allocator_nonpointer)
6001 handleSimpleAttribute<MSAllocatorAttr>(S,
D, AL);
6008 if (
const auto *PVD = dyn_cast<ParmVarDecl>(
D)) {
6009 if (PVD->getType()->isIntegerType()) {
6010 S.
Diag(AL.
getLoc(), diag::err_attribute_output_parameter)
6021template<
typename Attr>
6029template<
typename Attr>
6038 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
6043 CFGuardAttr::GuardArg Arg;
6045 if (!CFGuardAttr::ConvertStrToGuardArg(II->
getName(), Arg)) {
6046 S.
Diag(AL.
getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
6054template <
typename AttrTy>
6057 auto I = llvm::find_if(Attrs,
6058 [Name](
const AttrTy *A) {
6059 return A->getTCBName() == Name;
6061 return I == Attrs.end() ? nullptr : *I;
6064template <
typename AttrTy,
typename ConflictingAttrTy>
6071 if (
const ConflictingAttrTy *ConflictingAttr =
6072 findEnforceTCBAttrByName<ConflictingAttrTy>(
D, Argument)) {
6075 S.
Diag(AL.
getLoc(), diag::err_tcb_conflicting_attributes)
6089template <
typename AttrTy,
typename ConflictingAttrTy>
6092 StringRef TCBName = AL.getTCBName();
6093 if (
const ConflictingAttrTy *ConflictingAttr =
6094 findEnforceTCBAttrByName<ConflictingAttrTy>(
D, TCBName)) {
6095 S.
Diag(ConflictingAttr->getLoc(), diag::err_tcb_conflicting_attributes)
6096 << ConflictingAttr->getAttrName()->getName()
6097 << AL.getAttrName()->getName() << TCBName;
6100 S.
Diag(AL.getLoc(), diag::note_conflicting_attribute);
6108 return ::new(Context) AttrTy(Context, AL, AL.getTCBName());
6112 return mergeEnforceTCBAttrImpl<EnforceTCBAttr, EnforceTCBLeafAttr>(
6117 Decl *
D,
const EnforceTCBLeafAttr &AL) {
6118 return mergeEnforceTCBAttrImpl<EnforceTCBLeafAttr, EnforceTCBAttr>(
6127 S.
Diag(AL.
getLoc(), diag::err_attribute_too_many_arguments) << AL << 4;
6132 S.
Diag(AL.
getLoc(), diag::err_attribute_too_few_arguments) << AL;
6137 if (
D->
getAttr<VTablePointerAuthenticationAttr>()) {
6138 S.
Diag(AL.
getLoc(), diag::err_duplicated_vtable_pointer_auth) <<
Decl;
6142 auto KeyType = VTablePointerAuthenticationAttr::VPtrAuthKeyType::DefaultKey;
6145 if (!VTablePointerAuthenticationAttr::ConvertStrToVPtrAuthKeyType(
6147 S.
Diag(IL->
Loc, diag::err_invalid_authentication_key) << IL->
Ident;
6150 if (KeyType == VTablePointerAuthenticationAttr::DefaultKey &&
6152 S.
Diag(AL.
getLoc(), diag::err_no_default_vtable_pointer_auth) << 0;
6156 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
6161 auto AddressDiversityMode = VTablePointerAuthenticationAttr::
6162 AddressDiscriminationMode::DefaultAddressDiscrimination;
6166 if (!VTablePointerAuthenticationAttr::
6167 ConvertStrToAddressDiscriminationMode(IL->
Ident->
getName(),
6168 AddressDiversityMode)) {
6169 S.
Diag(IL->
Loc, diag::err_invalid_address_discrimination) << IL->
Ident;
6172 if (AddressDiversityMode ==
6173 VTablePointerAuthenticationAttr::DefaultAddressDiscrimination &&
6175 S.
Diag(IL->
Loc, diag::err_no_default_vtable_pointer_auth) << 1;
6179 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
6184 auto ED = VTablePointerAuthenticationAttr::ExtraDiscrimination::
6185 DefaultExtraDiscrimination;
6189 if (!VTablePointerAuthenticationAttr::ConvertStrToExtraDiscrimination(
6191 S.
Diag(IL->
Loc, diag::err_invalid_extra_discrimination) << IL->
Ident;
6194 if (ED == VTablePointerAuthenticationAttr::DefaultExtraDiscrimination &&
6196 S.
Diag(AL.
getLoc(), diag::err_no_default_vtable_pointer_auth) << 2;
6200 S.
Diag(AL.
getLoc(), diag::err_attribute_argument_type)
6205 uint32_t CustomDiscriminationValue = 0;
6206 if (ED == VTablePointerAuthenticationAttr::CustomDiscrimination) {
6208 S.
Diag(AL.
getLoc(), diag::err_missing_custom_discrimination) << AL << 4;
6213 S.
Diag(AL.
getLoc(), diag::err_attribute_too_many_arguments) << AL << 4;
6218 CustomDiscriminationValue)) {
6219 S.
Diag(AL.
getLoc(), diag::err_invalid_custom_discrimination);
6222 }
else if (NumArgs > 3) {
6223 S.
Diag(AL.
getLoc(), diag::err_attribute_too_many_arguments) << AL << 3;
6228 S.
Context, AL, KeyType, AddressDiversityMode, ED,
6229 CustomDiscriminationValue));
6245 for (
size_t I = 0; I < std::min(AL.
getNumArgs(), AttrNumArgs); ++I) {
6246 bool IsLastAttrArg = I == (AttrNumArgs - 1);
6249 if (IsLastAttrArg && AttrHasVariadicArg)
6256 if (isa<PackExpansionExpr>(
E))
6257 return !(IsLastAttrArg && ArgMemberCanHoldExpr);
6284 !Options.IncludeCXX11Attributes)
6294 ? (
unsigned)diag::err_keyword_not_supported_on_target
6296 ? (
unsigned)diag::warn_unhandled_ms_attribute_ignored
6297 : (
unsigned)diag::warn_unknown_attribute_ignored)
6309 if (MustDelayArgs) {
6319 assert(AL.
isTypeAttr() &&
"Non-type attribute not handled");
6322 if (Options.IgnoreTypeAttributes)
6340 isa<DeclaratorDecl, TypeAliasDecl>(
D)) {
6345 S.
Diag(AL.
getLoc(), diag::warn_type_attribute_deprecated_on_decl)
6354 if (AL.
getKind() == ParsedAttr::AT_Regparm) {
6367 if (AL.
getKind() == ParsedAttr::AT_VectorSize) {
6377 if (AL.
getKind() == ParsedAttr::AT_NoDeref) {
6388 S.
Diag(AL.
getLoc(), diag::err_attribute_invalid_on_decl)
6391 case ParsedAttr::AT_Interrupt:
6394 case ParsedAttr::AT_X86ForceAlignArgPointer:
6397 case ParsedAttr::AT_ReadOnlyPlacement:
6398 handleSimpleAttribute<ReadOnlyPlacementAttr>(S,
D, AL);
6400 case ParsedAttr::AT_DLLExport:
6401 case ParsedAttr::AT_DLLImport:
6404 case ParsedAttr::AT_AMDGPUFlatWorkGroupSize:
6407 case ParsedAttr::AT_AMDGPUWavesPerEU:
6410 case ParsedAttr::AT_AMDGPUNumSGPR:
6413 case ParsedAttr::AT_AMDGPUNumVGPR:
6416 case ParsedAttr::AT_AMDGPUMaxNumWorkGroups:
6419 case ParsedAttr::AT_AVRSignal:
6422 case ParsedAttr::AT_BPFPreserveAccessIndex:
6425 case ParsedAttr::AT_BPFPreserveStaticOffset:
6426 handleSimpleAttribute<BPFPreserveStaticOffsetAttr>(S,
D, AL);
6428 case ParsedAttr::AT_BTFDeclTag:
6431 case ParsedAttr::AT_WebAssemblyExportName:
6434 case ParsedAttr::AT_WebAssemblyImportModule:
6437 case ParsedAttr::AT_WebAssemblyImportName:
6440 case ParsedAttr::AT_IBOutlet:
6443 case ParsedAttr::AT_IBOutletCollection:
6446 case ParsedAttr::AT_IFunc:
6449 case ParsedAttr::AT_Alias:
6452 case ParsedAttr::AT_Aligned:
6455 case ParsedAttr::AT_AlignValue:
6458 case ParsedAttr::AT_AllocSize:
6461 case ParsedAttr::AT_AlwaysInline:
6464 case ParsedAttr::AT_AnalyzerNoReturn:
6467 case ParsedAttr::AT_TLSModel:
6470 case ParsedAttr::AT_Annotate:
6473 case ParsedAttr::AT_Availability:
6476 case ParsedAttr::AT_CarriesDependency:
6479 case ParsedAttr::AT_CPUDispatch:
6480 case ParsedAttr::AT_CPUSpecific:
6483 case ParsedAttr::AT_Common:
6486 case ParsedAttr::AT_CUDAConstant:
6489 case ParsedAttr::AT_PassObjectSize:
6492 case ParsedAttr::AT_Constructor:
6495 case ParsedAttr::AT_Deprecated:
6498 case ParsedAttr::AT_Destructor:
6501 case ParsedAttr::AT_EnableIf:
6504 case ParsedAttr::AT_Error:
6507 case ParsedAttr::AT_ExcludeFromExplicitInstantiation:
6510 case ParsedAttr::AT_DiagnoseIf:
6513 case ParsedAttr::AT_DiagnoseAsBuiltin:
6516 case ParsedAttr::AT_NoBuiltin:
6519 case ParsedAttr::AT_ExtVectorType:
6522 case ParsedAttr::AT_ExternalSourceSymbol:
6525 case ParsedAttr::AT_MinSize:
6528 case ParsedAttr::AT_OptimizeNone:
6531 case ParsedAttr::AT_EnumExtensibility:
6534 case ParsedAttr::AT_SYCLKernel:
6537 case ParsedAttr::AT_SYCLSpecialClass:
6538 handleSimpleAttribute<SYCLSpecialClassAttr>(S,
D, AL);
6540 case ParsedAttr::AT_Format:
6543 case ParsedAttr::AT_FormatArg:
6546 case ParsedAttr::AT_Callback:
6549 case ParsedAttr::AT_CalledOnce:
6552 case ParsedAttr::AT_NVPTXKernel:
6553 case ParsedAttr::AT_CUDAGlobal:
6556 case ParsedAttr::AT_CUDADevice:
6559 case ParsedAttr::AT_HIPManaged:
6562 case ParsedAttr::AT_GNUInline:
6565 case ParsedAttr::AT_CUDALaunchBounds:
6568 case ParsedAttr::AT_Restrict:
6571 case ParsedAttr::AT_Mode:
6574 case ParsedAttr::AT_NonNull:
6575 if (
auto *PVD = dyn_cast<ParmVarDecl>(
D))
6580 case ParsedAttr::AT_ReturnsNonNull:
6583 case ParsedAttr::AT_NoEscape:
6586 case ParsedAttr::AT_MaybeUndef:
6587 handleSimpleAttribute<MaybeUndefAttr>(S,
D, AL);
6589 case ParsedAttr::AT_AssumeAligned:
6592 case ParsedAttr::AT_AllocAlign:
6595 case ParsedAttr::AT_Ownership:
6598 case ParsedAttr::AT_Naked:
6601 case ParsedAttr::AT_NoReturn:
6604 case ParsedAttr::AT_CXX11NoReturn:
6607 case ParsedAttr::AT_AnyX86NoCfCheck:
6610 case ParsedAttr::AT_NoThrow:
6612 handleSimpleAttribute<NoThrowAttr>(S,
D, AL);
6614 case ParsedAttr::AT_CUDAShared:
6617 case ParsedAttr::AT_VecReturn:
6620 case ParsedAttr::AT_ObjCOwnership:
6623 case ParsedAttr::AT_ObjCPreciseLifetime:
6626 case ParsedAttr::AT_ObjCReturnsInnerPointer:
6629 case ParsedAttr::AT_ObjCRequiresSuper:
6632 case ParsedAttr::AT_ObjCBridge:
6635 case ParsedAttr::AT_ObjCBridgeMutable:
6638 case ParsedAttr::AT_ObjCBridgeRelated:
6641 case ParsedAttr::AT_ObjCDesignatedInitializer:
6644 case ParsedAttr::AT_ObjCRuntimeName:
6647 case ParsedAttr::AT_ObjCBoxable:
6650 case ParsedAttr::AT_NSErrorDomain:
6653 case ParsedAttr::AT_CFConsumed:
6654 case ParsedAttr::AT_NSConsumed:
6655 case ParsedAttr::AT_OSConsumed:
6660 case ParsedAttr::AT_OSReturnsRetainedOnZero:
6661 handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnZeroAttr>(
6663 diag::warn_ns_attribute_wrong_parameter_type,
6666 case ParsedAttr::AT_OSReturnsRetainedOnNonZero:
6667 handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnNonZeroAttr>(
6669 diag::warn_ns_attribute_wrong_parameter_type,
6672 case ParsedAttr::AT_NSReturnsAutoreleased:
6673 case ParsedAttr::AT_NSReturnsNotRetained:
6674 case ParsedAttr::AT_NSReturnsRetained:
6675 case ParsedAttr::AT_CFReturnsNotRetained:
6676 case ParsedAttr::AT_CFReturnsRetained:
6677 case ParsedAttr::AT_OSReturnsNotRetained:
6678 case ParsedAttr::AT_OSReturnsRetained:
6681 case ParsedAttr::AT_WorkGroupSizeHint:
6682 handleWorkGroupSize<WorkGroupSizeHintAttr>(S,
D, AL);
6684 case ParsedAttr::AT_ReqdWorkGroupSize:
6685 handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S,
D, AL);
6687 case ParsedAttr::AT_OpenCLIntelReqdSubGroupSize:
6690 case ParsedAttr::AT_VecTypeHint:
6693 case ParsedAttr::AT_InitPriority:
6696 case ParsedAttr::AT_Packed:
6699 case ParsedAttr::AT_PreferredName:
6702 case ParsedAttr::AT_Section:
6705 case ParsedAttr::AT_CodeModel:
6708 case ParsedAttr::AT_RandomizeLayout:
6711 case ParsedAttr::AT_NoRandomizeLayout:
6714 case ParsedAttr::AT_CodeSeg:
6717 case ParsedAttr::AT_Target:
6720 case ParsedAttr::AT_TargetVersion:
6723 case ParsedAttr::AT_TargetClones:
6726 case ParsedAttr::AT_MinVectorWidth:
6729 case ParsedAttr::AT_Unavailable:
6730 handleAttrWithMessage<UnavailableAttr>(S,
D, AL);
6732 case ParsedAttr::AT_OMPAssume:
6735 case ParsedAttr::AT_ObjCDirect:
6738 case ParsedAttr::AT_ObjCDirectMembers:
6740 handleSimpleAttribute<ObjCDirectMembersAttr>(S,
D, AL);
6742 case ParsedAttr::AT_ObjCExplicitProtocolImpl:
6745 case ParsedAttr::AT_Unused:
6748 case ParsedAttr::AT_Visibility:
6751 case ParsedAttr::AT_TypeVisibility:
6754 case ParsedAttr::AT_WarnUnusedResult:
6757 case ParsedAttr::AT_WeakRef:
6760 case ParsedAttr::AT_WeakImport:
6763 case ParsedAttr::AT_TransparentUnion:
6766 case ParsedAttr::AT_ObjCMethodFamily:
6769 case ParsedAttr::AT_ObjCNSObject:
6772 case ParsedAttr::AT_ObjCIndependentClass:
6775 case ParsedAttr::AT_Blocks:
6778 case ParsedAttr::AT_Sentinel:
6781 case ParsedAttr::AT_Cleanup:
6784 case ParsedAttr::AT_NoDebug:
6787 case ParsedAttr::AT_CmseNSEntry:
6790 case ParsedAttr::AT_StdCall:
6791 case ParsedAttr::AT_CDecl:
6792 case ParsedAttr::AT_FastCall:
6793 case ParsedAttr::AT_ThisCall:
6794 case ParsedAttr::AT_Pascal:
6795 case ParsedAttr::AT_RegCall:
6796 case ParsedAttr::AT_SwiftCall:
6797 case ParsedAttr::AT_SwiftAsyncCall:
6798 case ParsedAttr::AT_VectorCall:
6799 case ParsedAttr::AT_MSABI:
6800 case ParsedAttr::AT_SysVABI:
6801 case ParsedAttr::AT_Pcs:
6802 case ParsedAttr::AT_IntelOclBicc:
6803 case ParsedAttr::AT_PreserveMost:
6804 case ParsedAttr::AT_PreserveAll:
6805 case ParsedAttr::AT_AArch64VectorPcs:
6806 case ParsedAttr::AT_AArch64SVEPcs:
6807 case ParsedAttr::AT_AMDGPUKernelCall:
6808 case ParsedAttr::AT_M68kRTD:
6809 case ParsedAttr::AT_PreserveNone:
6810 case ParsedAttr::AT_RISCVVectorCC:
6813 case ParsedAttr::AT_Suppress:
6816 case ParsedAttr::AT_Owner:
6817 case ParsedAttr::AT_Pointer:
6820 case ParsedAttr::AT_OpenCLAccess:
6823 case ParsedAttr::AT_OpenCLNoSVM:
6826 case ParsedAttr::AT_SwiftContext:
6829 case ParsedAttr::AT_SwiftAsyncContext:
6832 case ParsedAttr::AT_SwiftErrorResult:
6835 case ParsedAttr::AT_SwiftIndirectResult:
6838 case ParsedAttr::AT_InternalLinkage:
6841 case ParsedAttr::AT_ZeroCallUsedRegs:
6844 case ParsedAttr::AT_FunctionReturnThunks:
6847 case ParsedAttr::AT_NoMerge:
6850 case ParsedAttr::AT_NoUniqueAddress:
6854 case ParsedAttr::AT_AvailableOnlyInDefaultEvalMethod:
6858 case ParsedAttr::AT_CountedBy:
6859 case ParsedAttr::AT_CountedByOrNull:
6860 case ParsedAttr::AT_SizedBy:
6861 case ParsedAttr::AT_SizedByOrNull:
6866 case ParsedAttr::AT_LayoutVersion:
6869 case ParsedAttr::AT_Uuid:
6872 case ParsedAttr::AT_MSInheritance:
6875 case ParsedAttr::AT_Thread:
6878 case ParsedAttr::AT_MSConstexpr:
6883 case ParsedAttr::AT_HLSLNumThreads:
6886 case ParsedAttr::AT_HLSLSV_GroupIndex:
6887 handleSimpleAttribute<HLSLSV_GroupIndexAttr>(S,
D, AL);
6889 case ParsedAttr::AT_HLSLSV_DispatchThreadID:
6892 case ParsedAttr::AT_HLSLPackOffset:
6895 case ParsedAttr::AT_HLSLShader:
6898 case ParsedAttr::AT_HLSLResourceBinding:
6901 case ParsedAttr::AT_HLSLResourceClass:
6904 case ParsedAttr::AT_HLSLParamModifier:
6908 case ParsedAttr::AT_AbiTag:
6911 case ParsedAttr::AT_CFGuard:
6916 case ParsedAttr::AT_AssertExclusiveLock:
6919 case ParsedAttr::AT_AssertSharedLock:
6922 case ParsedAttr::AT_PtGuardedVar:
6925 case ParsedAttr::AT_NoSanitize:
6928 case ParsedAttr::AT_NoSanitizeSpecific:
6931 case ParsedAttr::AT_GuardedBy:
6934 case ParsedAttr::AT_PtGuardedBy:
6937 case ParsedAttr::AT_ExclusiveTrylockFunction:
6940 case ParsedAttr::AT_LockReturned:
6943 case ParsedAttr::AT_LocksExcluded:
6946 case ParsedAttr::AT_SharedTrylockFunction:
6949 case ParsedAttr::AT_AcquiredBefore:
6952 case ParsedAttr::AT_AcquiredAfter:
6957 case ParsedAttr::AT_Capability:
6958 case ParsedAttr::AT_Lockable:
6961 case ParsedAttr::AT_RequiresCapability:
6965 case ParsedAttr::AT_AssertCapability:
6968 case ParsedAttr::AT_AcquireCapability:
6971 case ParsedAttr::AT_ReleaseCapability:
6974 case ParsedAttr::AT_TryAcquireCapability:
6979 case ParsedAttr::AT_Consumable:
6982 case ParsedAttr::AT_CallableWhen:
6985 case ParsedAttr::AT_ParamTypestate:
6988 case ParsedAttr::AT_ReturnTypestate:
6991 case ParsedAttr::AT_SetTypestate:
6994 case ParsedAttr::AT_TestTypestate:
6999 case ParsedAttr::AT_ArgumentWithTypeTag:
7002 case ParsedAttr::AT_TypeTagForDatatype:
7007 case ParsedAttr::AT_SwiftAsyncName:
7010 case ParsedAttr::AT_SwiftAttr:
7013 case ParsedAttr::AT_SwiftBridge:
7016 case ParsedAttr::AT_SwiftError:
7019 case ParsedAttr::AT_SwiftName:
7022 case ParsedAttr::AT_SwiftNewType:
7025 case ParsedAttr::AT_SwiftAsync:
7028 case ParsedAttr::AT_SwiftAsyncError:
7033 case ParsedAttr::AT_XRayLogArgs:
7037 case ParsedAttr::AT_PatchableFunctionEntry:
7041 case ParsedAttr::AT_AlwaysDestroy:
7042 case ParsedAttr::AT_NoDestroy:
7046 case ParsedAttr::AT_Uninitialized:
7050 case ParsedAttr::AT_ObjCExternallyRetained:
7054 case ParsedAttr::AT_MIGServerRoutine:
7058 case ParsedAttr::AT_MSAllocator:
7062 case ParsedAttr::AT_ArmBuiltinAlias:
7066 case ParsedAttr::AT_ArmLocallyStreaming:
7067 handleSimpleAttribute<ArmLocallyStreamingAttr>(S,
D, AL);
7070 case ParsedAttr::AT_ArmNew:
7074 case ParsedAttr::AT_AcquireHandle:
7078 case ParsedAttr::AT_ReleaseHandle:
7079 handleHandleAttr<ReleaseHandleAttr>(S,
D, AL);
7082 case ParsedAttr::AT_UnsafeBufferUsage:
7083 handleUnsafeBufferUsage<UnsafeBufferUsageAttr>(S,
D, AL);
7086 case ParsedAttr::AT_UseHandle:
7087 handleHandleAttr<UseHandleAttr>(S,
D, AL);
7090 case ParsedAttr::AT_EnforceTCB:
7091 handleEnforceTCBAttr<EnforceTCBAttr, EnforceTCBLeafAttr>(S,
D, AL);
7094 case ParsedAttr::AT_EnforceTCBLeaf:
7095 handleEnforceTCBAttr<EnforceTCBLeafAttr, EnforceTCBAttr>(S,
D, AL);
7098 case ParsedAttr::AT_BuiltinAlias:
7102 case ParsedAttr::AT_PreferredType:
7106 case ParsedAttr::AT_UsingIfExists:
7107 handleSimpleAttribute<UsingIfExistsAttr>(S,
D, AL);
7110 case ParsedAttr::AT_TypeNullable:
7114 case ParsedAttr::AT_VTablePointerAuthentication:
7123 if (AttrList.
empty())
7134 Diag(AttrList.
begin()->getLoc(), diag::err_attribute_weakref_without_alias)
7135 << cast<NamedDecl>(
D);
7144 if (!
D->
hasAttr<OpenCLKernelAttr>()) {
7146 if (
const auto *A =
D->
getAttr<ReqdWorkGroupSizeAttr>()) {
7151 }
else if (
const auto *A =
D->
getAttr<WorkGroupSizeHintAttr>()) {
7154 }
else if (
const auto *A =
D->
getAttr<VecTypeHintAttr>()) {
7157 }
else if (
const auto *A =
D->
getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
7160 }
else if (!
D->
hasAttr<CUDAGlobalAttr>()) {
7161 if (
const auto *A =
D->
getAttr<AMDGPUFlatWorkGroupSizeAttr>()) {
7165 }
else if (
const auto *A =
D->
getAttr<AMDGPUWavesPerEUAttr>()) {
7169 }
else if (
const auto *A =
D->
getAttr<AMDGPUNumSGPRAttr>()) {
7173 }
else if (
const auto *A =
D->
getAttr<AMDGPUNumVGPRAttr>()) {
7186 if (
D->
hasAttr<ObjCDesignatedInitializerAttr>() &&
7187 cast<ObjCMethodDecl>(
D)->getMethodFamily() !=
OMF_init) {
7189 D->
dropAttr<ObjCDesignatedInitializerAttr>();
7196 if (AL.getKind() == ParsedAttr::AT_TransparentUnion) {
7203 if (
D &&
D->
hasAttr<BPFPreserveAccessIndexAttr>())
7210 if (AL.getKind() == ParsedAttr::AT_Annotate) {
7214 Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
7226 if (AL.isUsedAsTypeAttr() || AL.isInvalid())
7232 S.
Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
7233 << AL << AL.getRange();
7235 S.
Diag(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL
7245 for (
unsigned i = 0, e =
D.getNumTypeObjects(); i != e; ++i)
7251 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
7253 if (
auto *FD = dyn_cast<FunctionDecl>(ND)) {
7275 for (
const auto &AI : FT->param_types()) {
7278 Params.push_back(Param);
7280 NewFD->setParams(Params);
7282 }
else if (
auto *VD = dyn_cast<VarDecl>(ND)) {
7284 VD->getInnerLocStart(), VD->getLocation(), II,
7285 VD->getType(), VD->getTypeSourceInfo(),
7286 VD->getStorageClass());
7287 if (VD->getQualifier())
7288 cast<VarDecl>(NewD)->setQualifierInfo(VD->getQualifierLoc());
7321 if (
auto *VD = dyn_cast<VarDecl>(
D))
7322 if (VD->isExternC())
7324 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
7332 auto &WeakInfos = I->second;
7333 for (
const auto &W : WeakInfos)
7335 std::remove_reference_t<
decltype(WeakInfos)> EmptyWeakInfos;
7336 WeakInfos.swap(EmptyWeakInfos);
7348 auto ProcessAttributesWithSliding =
7356 if ((AL.isStandardAttributeSyntax() || AL.isAlignas()) &&
7357 AL.slidesFromDeclToDeclSpecLegacyBehavior()) {
7362 AL.diagnoseAppertainsTo(*
this,
D);
7377 .WithIncludeCXX11Attributes(
false)
7378 .WithIgnoreTypeAttributes(
true));
7387 .WithIncludeCXX11Attributes(
false)
7388 .WithIgnoreTypeAttributes(
true));
7406 UnavailableAttr::ImplicitReason &reason) {
7410 if (!isa<FieldDecl>(
D) && !isa<ObjCPropertyDecl>(
D) &&
7411 !isa<FunctionDecl>(
D))
7419 if ((isa<ObjCIvarDecl>(
D) || isa<ObjCPropertyDecl>(
D))) {
7422 reason = UnavailableAttr::IR_ForbiddenWeak;
7431 reason = UnavailableAttr::IR_ARCForbiddenType;
7441 auto Reason = UnavailableAttr::IR_None;
7443 assert(Reason &&
"didn't set reason?");
7448 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
7451 if (FD->
hasAttr<UnavailableAttr>() &&
7453 diag::err_arc_array_param_no_ownership) {
7484 bool AnyAccessFailures =
false;
7492 switch (diag.
Kind) {
7496 if (!
decl->isInvalidDecl())
7504 if (AnyAccessFailures && isa<DecompositionDecl>(
decl))
7508 AnyAccessFailures =
true;
7521 assert(curPool &&
"re-emitting in undelayed context not supported");
7522 curPool->
steal(pool);
Defines the clang::ASTContext interface.
static SmallString< 64 > normalizeName(const IdentifierInfo *Name, const IdentifierInfo *Scope, AttributeCommonInfo::Syntax SyntaxUsed)
static OffloadArch getOffloadArch(CodeGenModule &CGM)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines helper utilities for supporting the HLSL runtime environment.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Defines the clang::LangOptions interface.
llvm::MachO::Target Target
llvm::MachO::Record Record
static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y)
Check whether the two versions match.
static unsigned getNumAttributeArgs(const ParsedAttr &AL)
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis functions specific to AMDGPU.
This file declares semantic analysis functions specific to ARM.
This file declares semantic analysis functions specific to AVR.
This file declares semantic analysis functions specific to BPF.
This file declares semantic analysis for CUDA constructs.
static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleHandleAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, Expr *&Arg)
static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePatchableFunctionEntryAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCountedByAttrField(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL)
Handle attribute((format(type,idx,firstarg))) attributes based on http://gcc.gnu.org/onlinedocs/gcc/F...
static void handleUninitializedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleRequiresCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleBTFDeclTagAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleStandardNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &A)
static void handleMIGServerRoutineAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleZeroCallUsedRegsAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleDiagnoseAsBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleEnumExtensibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static T * mergeVisibilityAttr(Sema &S, Decl *D, const AttributeCommonInfo &CI, typename T::VisibilityType value)
static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD, const ParsedAttr &AL)
static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A)
static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs)
static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A)
checkUnusedDeclAttributes - Check a list of attributes to see if it contains any decl attributes that...
static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleBuiltinAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleVTablePointerAuthentication(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleEnforceTCBAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D, const ParsedAttr &AL, SmallVectorImpl< Expr * > &Args, unsigned Sidx=0, bool ParamIdxOk=false)
Checks that all attribute arguments, starting from Sidx, resolve to a capability object.
static void handleErrorAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc, StringRef CodeSegName)
static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL)
Handle attribute((format_arg((idx)))) attribute based on http://gcc.gnu.org/onlinedocs/gcc/Function-A...
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL, const Sema::ProcessDeclAttributeOptions &Options)
ProcessDeclAttribute - Apply the specific attribute to the specified decl if the attribute applies to...
static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNoMergeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleManagedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleUnsafeBufferUsage(Sema &S, Decl *D, const ParsedAttr &AL)
static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL, SourceRange AttrParmRange, SourceRange TypeRange, bool isReturnValue=false)
static void handleAcquireCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCalledOnceAttr(Sema &S, Decl *D, const ParsedAttr &AL)
Handle 'called_once' attribute.
static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL, Expr *&Cond, StringRef &Msg)
static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleExternalSourceSymbolAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D, const ParsedAttr &AL)
static bool checkParamIsIntegerType(Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNo)
Checks to be sure that the given parameter number is in bounds, and is an integral type.
static bool checkRecordTypeForCapability(Sema &S, QualType Ty)
static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, SmallVectorImpl< Expr * > &Args)
static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleMSAllocatorAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static AttrTy * mergeEnforceTCBAttrImpl(Sema &S, Decl *D, const AttrTy &AL)
static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleTargetClonesAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePreferredTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleDeviceAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAssertCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL, bool isTypeVisibility)
static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static FormatAttrKind getFormatAttrKind(StringRef Format)
getFormatAttrKind - Map from format attribute names to supported format types.
static void handleNullableTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAcquireHandleAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleMSConstexprAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, SmallVectorImpl< Expr * > &Args)
static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth, bool &IntegerMode, bool &ComplexMode, FloatModeKind &ExplicitType)
parseModeAttrArg - Parses attribute mode string and returns parsed type attribute.
static void handleExcludeFromExplicitInstantiationAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted)
static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D, const ParsedAttr &AL)
static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNoUniqueAddressAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool validateAlignasAppliedType(Sema &S, Decl *D, const AlignedAttr &Attr, SourceLocation AttrLoc)
Perform checking of type validity.
static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleFunctionReturnThunksAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleDeprecatedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static unsigned getNumAttributeArgs(const ParsedAttr &AL)
static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCodeModelAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool hasBTFDeclTagAttr(Decl *D, StringRef Tag)
static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &DD, Decl *D)
Handle a delayed forbidden-type diagnostic.
static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, SmallVectorImpl< Expr * > &Args)
static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static Expr * makeLaunchBoundsArgExpr(Sema &S, Expr *E, const CUDALaunchBoundsAttr &AL, const unsigned Idx)
static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL)
Handle attribute((callback(CalleeIdx, PayloadIdx0, ...))) attributes.
static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
Handle attribute((init_priority(priority))) attributes based on http://gcc.gnu.org/onlinedocs/gcc/C_0...
static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkRecordDeclForAttr(const RecordDecl *RD)
static void handleDestroyAttr(Sema &S, Decl *D, const ParsedAttr &A)
static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleRandomizeLayoutAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void markUsedForAliasOrIfunc(Sema &S, Decl *D, const ParsedAttr &AL, StringRef Str)
static bool isCapabilityExpr(Sema &S, const Expr *Ex)
static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs)
static const AttrTy * findEnforceTCBAttrByName(Decl *D, StringRef Name)
static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAvailableOnlyInDefaultEvalMethod(Sema &S, Decl *D, const ParsedAttr &AL)
static bool MustDelayAttributeArguments(const ParsedAttr &AL)
static void handleNoRandomizeLayoutAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleTargetVersionAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAssertExclusiveLockAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool isIntOrBool(Expr *Exp)
Check if the passed-in expression is of type int or bool.
static bool isSanitizerAttributeAllowedOnGlobals(StringRef Sanitizer)
static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkTypedefTypeForCapability(QualType Ty)
static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleReleaseCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool typeHasCapability(Sema &S, QualType Ty)
static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType *RT)
static bool isFunctionLike(const Type &T)
static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleCFGuardAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, const ParsedAttr &AL)
Check if passed in Decl is a pointer type.
static bool isForbiddenTypeAllowed(Sema &S, Decl *D, const DelayedDiagnostic &diag, UnavailableAttr::ImplicitReason &reason)
Is the given declaration allowed to use a forbidden type? If so, it'll still be annotated with an att...
static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL)
handleModeAttr - This attribute modifies the width of a decl with primitive type.
static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handlePreferredName(Sema &S, Decl *D, const ParsedAttr &AL)
static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr, int &Val, unsigned Idx=UINT_MAX)
Wrapper around checkUInt32Argument, with an extra check to be sure that the result will fit into a re...
static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static bool isGlobalVar(const Decl *D)
static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL)
static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL)
This file declares semantic analysis for HLSL constructs.
This file declares semantic analysis functions specific to M68k.
This file declares semantic analysis functions specific to MIPS.
This file declares semantic analysis functions specific to MSP430.
This file declares semantic analysis for Objective-C.
This file declares semantic analysis routines for OpenCL.
This file declares semantic analysis for OpenMP constructs and clauses.
This file declares semantic analysis functions specific to RISC-V.
This file declares semantic analysis for SYCL constructs.
This file declares semantic analysis functions specific to Swift.
This file declares semantic analysis functions specific to Wasm.
This file declares semantic analysis functions specific to X86.
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
static QualType getPointeeType(const MemRegion *R)
Enumerates target-specific builtins in their own namespaces within namespace clang.
C Language Family Type Representation.
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
MSGuidDecl * getMSGuidDecl(MSGuidDeclParts Parts) const
Return a declaration for the global GUID object representing the given GUID value.
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
DeclarationNameTable DeclarationNames
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.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const LangOptions & getLangOpts() const
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
const TargetInfo * getAuxTargetInfo() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Represents an access specifier followed by colon ':'.
Attr - This represents one attribute.
bool isMicrosoftAttribute() const
bool isClangScope() const
void setAttributeSpellingListIndex(unsigned V)
std::string getNormalizedFullName() const
Gets the normalized full name, which consists of both scope and name and with surrounding underscores...
bool isCXX11Attribute() const
bool isDeclspecAttribute() const
SourceRange getRange() const
bool isC23Attribute() const
unsigned getAttributeSpellingListIndex() const
const IdentifierInfo * getScopeName() const
bool isGNUAttribute() const
bool isRegularKeywordAttribute() const
SourceLocation getLoc() const
const IdentifierInfo * getAttrName() const
bool isStandardAttributeSyntax() const
The attribute is spelled [[]] in either C or C++ mode, including standard attributes spelled with a k...
Kind getParsedKind() const
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
This class is used for builtin types like 'int'.
static bool isBuiltinFunc(llvm::StringRef Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Represents a static or instance method of a struct/union/class.
QualType getFunctionObjectParameterType() const
Represents a C++ struct/union/class.
CXXRecordDecl * getDefinition() const
bool hasDefinition() const
MSInheritanceModel calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
Represents the this expression in C++.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Declaration of a class template.
const RelatedTargetVersionMapping * getVersionMapping(OSEnvPair Kind) const
The results of name lookup within a DeclContext.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
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
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
A reference to a declared variable, function, enum, etc.
DeclarationNameInfo getNameInfo() const
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
ParsedAttributes & getAttributes()
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
bool canBeWeakImported(bool &IsDefinition) const
Determines whether this symbol can be weak-imported, e.g., whether it would be well-formed to add the...
bool isInvalidDecl() const
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
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.
void setLexicalDeclContext(DeclContext *DC)
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
The name of a declaration.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
SourceLocation getTypeSpecStartLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
TypeSourceInfo * getTypeSourceInfo() const
Information about one declarator, including the parsed type information and the identifier.
const DeclaratorChunk & getTypeObject(unsigned i) const
Return the specified TypeInfo from this declarator.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
const ParsedAttributes & getAttributes() const
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
const ParsedAttributesView & getDeclarationAttributes() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
This represents one expression.
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluated - Return true if this expression might be usable in a constant exp...
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.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Represents difference between two FPOptions values.
Represents a member of a struct/union/class.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Represents a function declaration or definition.
const ParmVarDecl * getParamDecl(unsigned i) const
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
param_iterator param_end()
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
QualType getReturnType() const
ArrayRef< ParmVarDecl * > parameters() const
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
param_iterator param_begin()
bool isVariadic() const
Whether this function is variadic.
bool isConstexprSpecified() const
bool isExternC() const
Determines whether this function is a function with external, C linkage.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Represents a prototype with parameter type info, e.g.
Declaration of a template function.
FunctionType - C99 6.7.5.3 - Function Declarators.
QualType getReturnType() const
GlobalDecl - represents a global declaration.
One of these records is kept for each identifier that is lexed.
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Describes an entity that is being initialized.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
void push_back(const T &LocalValue)
Represents the results of name lookup.
Describes a module or submodule.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
A C++ nested-name-specifier augmented with source location information.
ObjCMethodDecl - Represents an instance or class method declaration.
Represents one property declaration in an Objective-C interface.
void * getAsOpaquePtr() const
static OpaquePtr getFromOpaquePtr(void *P)
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
unsigned getSourceIndex() const
Get the parameter index as it would normally be encoded for attributes at the source level of represe...
unsigned getASTIndex() const
Get the parameter index as it would normally be encoded at the AST level of representation: zero-orig...
Represents a parameter to a function.
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
ParsedAttr - Represents a syntactic attribute.
bool isPackExpansion() const
const AvailabilityChange & getAvailabilityDeprecated() const
unsigned getSemanticSpelling() const
If the parsed attribute has a semantic equivalent, and it would have a semantic Spelling enumeration ...
bool existsInTarget(const TargetInfo &Target) const
bool checkExactlyNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has exactly as many args as Num.
IdentifierLoc * getArgAsIdent(unsigned Arg) const
bool hasParsedType() const
const AvailabilityChange & getAvailabilityIntroduced() const
void setInvalid(bool b=true) const
bool hasVariadicArg() const
const ParsedAttrInfo & getInfo() const
void handleAttrWithDelayedArgs(Sema &S, Decl *D) const
const Expr * getReplacementExpr() const
bool hasProcessingCache() const
SourceLocation getUnavailableLoc() const
unsigned getProcessingCache() const
const IdentifierLoc * getEnvironment() const
bool acceptsExprPack() const
const Expr * getMessageExpr() const
const ParsedType & getMatchingCType() const
const ParsedType & getTypeArg() const
SourceLocation getStrictLoc() const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
bool isArgIdent(unsigned Arg) const
Expr * getArgAsExpr(unsigned Arg) const
bool getMustBeNull() const
bool checkAtLeastNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at least as many args as Num.
bool isUsedAsTypeAttr() const
unsigned getNumArgMembers() const
bool isPragmaClangAttribute() const
True if the attribute is specified using '#pragma clang attribute'.
bool slidesFromDeclToDeclSpecLegacyBehavior() const
Returns whether a [[]] attribute, if specified ahead of a declaration, should be applied to the decl-...
AttributeCommonInfo::Kind getKind() const
void setProcessingCache(unsigned value) const
bool isParamExpr(size_t N) const
bool isArgExpr(unsigned Arg) const
bool getLayoutCompatible() const
ArgsUnion getArg(unsigned Arg) const
getArg - Return the specified argument.
SourceLocation getEllipsisLoc() const
bool checkAtMostNumArgs(class Sema &S, unsigned Num) const
Check if the attribute has at most as many args as Num.
const AvailabilityChange & getAvailabilityObsoleted() const
void addAtEnd(ParsedAttr *newAttr)
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
IdentifierTable & getIdentifierTable()
A (possibly-)qualified type.
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.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
const Type * getTypePtrOrNull() const
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Scope - A scope is a transient data structure that is used while parsing the program.
unsigned getFlags() const
getFlags - Return the flags for this scope.
@ FunctionDeclarationScope
This is a scope that corresponds to the parameters within a function prototype for a function declara...
void handleAMDGPUMaxNumWorkGroupsAttr(Decl *D, const ParsedAttr &AL)
void handleAMDGPUFlatWorkGroupSizeAttr(Decl *D, const ParsedAttr &AL)
void handleAMDGPUNumSGPRAttr(Decl *D, const ParsedAttr &AL)
void handleAMDGPUNumVGPRAttr(Decl *D, const ParsedAttr &AL)
void handleAMDGPUWavesPerEUAttr(Decl *D, const ParsedAttr &AL)
bool MveAliasValid(unsigned BuiltinID, StringRef AliasName)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
bool CdeAliasValid(unsigned BuiltinID, StringRef AliasName)
void handleBuiltinAliasAttr(Decl *D, const ParsedAttr &AL)
void handleNewAttr(Decl *D, const ParsedAttr &AL)
void handleCmseNSEntryAttr(Decl *D, const ParsedAttr &AL)
bool SveAliasValid(unsigned BuiltinID, StringRef AliasName)
void handleSignalAttr(Decl *D, const ParsedAttr &AL)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
void handlePreserveAIRecord(RecordDecl *RD)
void handlePreserveAccessIndexAttr(Decl *D, const ParsedAttr &AL)
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
CUDAFunctionTarget CurrentTarget()
Gets the CUDA target for the current context.
SemaDiagnosticBuilder DiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as host cod...
void handleResourceClassAttr(Decl *D, const ParsedAttr &AL)
void handleShaderAttr(Decl *D, const ParsedAttr &AL)
void handleSV_DispatchThreadIDAttr(Decl *D, const ParsedAttr &AL)
void handlePackOffsetAttr(Decl *D, const ParsedAttr &AL)
void handleParamModifierAttr(Decl *D, const ParsedAttr &AL)
void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL)
void handleNumThreadsAttr(Decl *D, const ParsedAttr &AL)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
void handleRuntimeName(Decl *D, const ParsedAttr &AL)
void handleNSObject(Decl *D, const ParsedAttr &AL)
bool isValidOSObjectOutParameter(const Decl *D)
void handleNSErrorDomain(Decl *D, const ParsedAttr &Attr)
void handleXReturnsXRetainedAttr(Decl *D, const ParsedAttr &AL)
void handleExternallyRetainedAttr(Decl *D, const ParsedAttr &AL)
void handleMethodFamilyAttr(Decl *D, const ParsedAttr &AL)
void handleIndependentClass(Decl *D, const ParsedAttr &AL)
void handleIBOutlet(Decl *D, const ParsedAttr &AL)
void handleReturnsInnerPointerAttr(Decl *D, const ParsedAttr &Attrs)
void handleSuppresProtocolAttr(Decl *D, const ParsedAttr &AL)
void handleOwnershipAttr(Decl *D, const ParsedAttr &AL)
void handleBlocksAttr(Decl *D, const ParsedAttr &AL)
void handleBridgeMutableAttr(Decl *D, const ParsedAttr &AL)
Sema::RetainOwnershipKind parsedAttrToRetainOwnershipKind(const ParsedAttr &AL)
void handleRequiresSuperAttr(Decl *D, const ParsedAttr &Attrs)
void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, Sema::RetainOwnershipKind K, bool IsTemplateInstantiation)
void handleDesignatedInitializer(Decl *D, const ParsedAttr &AL)
void handleBridgeRelatedAttr(Decl *D, const ParsedAttr &AL)
void handleIBOutletCollection(Decl *D, const ParsedAttr &AL)
bool isCFStringType(QualType T)
void handleDirectAttr(Decl *D, const ParsedAttr &AL)
bool isNSStringType(QualType T, bool AllowNSAttributedString=false)
void handleBoxable(Decl *D, const ParsedAttr &AL)
void handleDirectMembersAttr(Decl *D, const ParsedAttr &AL)
void handleBridgeAttr(Decl *D, const ParsedAttr &AL)
void handlePreciseLifetimeAttr(Decl *D, const ParsedAttr &AL)
void handleSubGroupSize(Decl *D, const ParsedAttr &AL)
void handleNoSVMAttr(Decl *D, const ParsedAttr &AL)
void handleAccessAttr(Decl *D, const ParsedAttr &AL)
void handleOMPAssumeAttr(Decl *D, const ParsedAttr &AL)
bool isAliasValid(unsigned BuiltinID, StringRef AliasName)
void handleInterruptAttr(Decl *D, const ParsedAttr &AL)
void handleKernelAttr(Decl *D, const ParsedAttr &AL)
void handleBridge(Decl *D, const ParsedAttr &AL)
void handleAsyncAttr(Decl *D, const ParsedAttr &AL)
void handleAsyncName(Decl *D, const ParsedAttr &AL)
void handleNewType(Decl *D, const ParsedAttr &AL)
void handleError(Decl *D, const ParsedAttr &AL)
void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, ParameterABI abi)
void handleAsyncError(Decl *D, const ParsedAttr &AL)
void handleName(Decl *D, const ParsedAttr &AL)
void handleAttrAttr(Decl *D, const ParsedAttr &AL)
void handleWebAssemblyImportNameAttr(Decl *D, const ParsedAttr &AL)
void handleWebAssemblyImportModuleAttr(Decl *D, const ParsedAttr &AL)
void handleWebAssemblyExportNameAttr(Decl *D, const ParsedAttr &AL)
void handleForceAlignArgPointerAttr(Decl *D, const ParsedAttr &AL)
void handleAnyInterruptAttr(Decl *D, const ParsedAttr &AL)
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
void popWithoutEmitting(DelayedDiagnosticsState state)
Leave a delayed-diagnostic state that was previously pushed.
Sema - This implements semantic analysis and AST building for C.
bool ConstantFoldAttrArgs(const AttributeCommonInfo &CI, MutableArrayRef< Expr * > Args)
ConstantFoldAttrArgs - Folds attribute arguments into ConstantExprs (unless they are value dependent ...
BTFDeclTagAttr * mergeBTFDeclTagAttr(Decl *D, const BTFDeclTagAttr &AL)
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
EnforceTCBAttr * mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL)
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
Determine if type T is a valid subject for a nonnull and similar attributes.
static std::enable_if_t< std::is_base_of_v< Attr, AttrInfo >, SourceLocation > getAttrLoc(const AttrInfo &AL)
A helper function to provide Attribute Location for the Attr types AND the ParsedAttr.
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, TypeVisibilityAttr::VisibilityType Vis)
void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE)
AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular declaration.
bool checkSectionName(SourceLocation LiteralLoc, StringRef Str)
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A, bool SkipArgCountCheck=false)
Handles semantic checking for features that are common to all attributes, such as checking whether a ...
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList)
Annotation attributes are the only attributes allowed after an access specifier.
DLLImportAttr * mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI)
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
void PopParsingDeclaration(ParsingDeclState state, Decl *decl)
ErrorAttr * mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic)
bool CheckCountedByAttrOnField(FieldDecl *FD, Expr *E, llvm::SmallVectorImpl< TypeCoupledDeclRefInfo > &Decls, bool CountInBytes, bool OrNull)
Check if applying the specified attribute variant from the "counted by" family of attributes to Field...
void redelayDiagnostics(sema::DelayedDiagnosticPool &pool)
Given a set of delayed diagnostics, re-emit them as if they had been delayed in the current context i...
bool checkTargetVersionAttr(SourceLocation Loc, Decl *D, StringRef Str)
Check Target Version attrs.
VisibilityAttr * mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, VisibilityAttr::VisibilityType Vis)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
ASTContext & getASTContext() const
@ None
This is not a defaultable comparison operator.
bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC, const FunctionDecl *FD=nullptr, CUDAFunctionTarget CFT=CUDAFunctionTarget::InvalidTarget)
Check validaty of calling convention attribute attr.
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr, TemplateSpecCandidateSet *FailedTSC=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
QualType BuildCountAttributedArrayOrPointerType(QualType WrappedTy, Expr *CountExpr, bool CountInBytes, bool OrNull)
void ProcessPragmaWeak(Scope *S, Decl *D)
bool CheckAttrNoArgs(const ParsedAttr &CurrAttr)
bool UnifySection(StringRef SectionName, int SectionFlags, NamedDecl *TheDecl)
FPOptions & getCurFPFeatures()
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
@ UPPC_Expression
An arbitrary expression.
const LangOptions & getLangOpts() const
void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
MinSizeAttr * mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI)
const LangOptions & LangOpts
static const uint64_t MaximumAlignment
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident)
void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AttrList, const ProcessDeclAttributeOptions &Options=ProcessDeclAttributeOptions())
ProcessDeclAttributeList - Apply all the decl attributes in the specified attribute list to the speci...
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, Expr *ParamExpr)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value)
Checks a regparm attribute, returning true if it is ill-formed and otherwise setting numParams to the...
void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Annot, MutableArrayRef< Expr * > Args)
AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
void ProcessDeclAttributeDelayed(Decl *D, const ParsedAttributesView &AttrList)
Helper for delayed processing TransparentUnion or BPFPreserveAccessIndexAttr attribute.
bool checkUInt32Argument(const AttrInfo &AI, const Expr *Expr, uint32_t &Val, unsigned Idx=UINT_MAX, bool StrictlyUnsigned=false)
If Expr is a valid integer constant, get the value of the integer expression and return success or fa...
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, bool BestCase, MSInheritanceModel Model)
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL)
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
ExprResult PerformContextuallyConvertToBool(Expr *From)
PerformContextuallyConvertToBool - Perform a contextual conversion of the expression From to bool (C+...
@ Compatible
Compatible - the types are compatible according to the standard.
NamedDecl * DeclClonePragmaWeak(NamedDecl *ND, const IdentifierInfo *II, SourceLocation Loc)
DeclClonePragmaWeak - clone existing decl (maybe definition), #pragma weak needs a non-definition dec...
DLLExportAttr * mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI)
CodeSegAttr * mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
SectionAttr * mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, StringRef Name)
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
SourceManager & getSourceManager() const
bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str)
llvm::Error isValidSectionSpecifier(StringRef Str)
Used to implement to perform semantic checking on attribute((section("foo"))) specifiers.
void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, Expr *MaxThreads, Expr *MinBlocks, Expr *MaxBlocks)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration.
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI)
void checkUnusedDeclAttributes(Declarator &D)
checkUnusedDeclAttributes - Given a declarator which is not being used to build a declaration,...
bool CheckAttrTarget(const ParsedAttr &CurrAttr)
EnforceTCBLeafAttr * mergeEnforceTCBLeafAttr(Decl *D, const EnforceTCBLeafAttr &AL)
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType(), bool TakingAddress=false)
FormatAttr * mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Format, int FormatIdx, int FirstArg)
@ AP_PragmaClangAttribute
The availability attribute was applied using '#pragma clang attribute'.
@ AP_InferredFromOtherPlatform
The availability attribute for a specific platform was inferred from an availability attribute for an...
@ AP_Explicit
The availability attribute was specified explicitly next to the declaration.
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated",...
@ AMK_None
Don't merge availability attributes at all.
@ AMK_Override
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
@ AMK_ProtocolImplementation
Merge availability attributes for an implementation of a protocol requirement.
@ AMK_OptionalProtocolImplementation
Merge availability attributes for an implementation of an optional protocol requirement.
@ AMK_Redeclaration
Merge availability attributes for a redeclaration, which requires an exact match.
SmallVector< Decl *, 2 > WeakTopLevelDecl
WeakTopLevelDecl - Translation-unit scoped declarations generated by #pragma weak during processing o...
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
UuidAttr * mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, StringRef UuidAsWritten, MSGuidDecl *GuidDecl)
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
bool checkTargetClonesAttrString(SourceLocation LiteralLoc, StringRef Str, const StringLiteral *Literal, Decl *D, bool &HasDefault, bool &HasCommas, bool &HasNotDefault, SmallVectorImpl< SmallString< 64 > > &StringsBuffer)
void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx)
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in it, apply them to D.
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, const WeakInfo &W)
DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak applied to it,...
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, int Priority, IdentifierInfo *IIEnvironment)
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
bool checkFunctionOrMethodParameterIndex(const Decl *D, const AttrInfo &AI, unsigned AttrArgNum, const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis=false)
Check if IdxExpr is a valid parameter index for a function or instance method D.
void ProcessAPINotes(Decl *D)
Map any API notes provided for this declaration to attributes on the declaration.
void CheckAlignasUnderalignment(Decl *D)
void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx)
DarwinSDKInfo * getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc, StringRef Platform)
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing,...
CUDALaunchBoundsAttr * CreateLaunchBoundsAttr(const AttributeCommonInfo &CI, Expr *MaxThreads, Expr *MinBlocks, Expr *MaxBlocks)
Create an CUDALaunchBoundsAttr attribute.
bool LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation=false, bool ForceNoCPlusPlus=false)
Perform unqualified name lookup starting from a given scope.
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E)
AddAlignValueAttr - Adds an align_value attribute to a particular declaration.
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceModel SemanticSpelling)
bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument E is a ASCII string literal.
bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto)
CheckFunctionCall - Check a direct function call for various correctness and safety properties not st...
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
bool isBeingDefined() const
Return true if this decl is currently being defined.
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
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.
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const
Determines whether a given calling convention is valid for the target.
bool isTLSSupported() const
Whether the target supports thread-local storage.
unsigned getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
virtual unsigned getRegisterWidth() const
Return the "preferred" register width on this target.
virtual bool validateCpuSupports(StringRef Name) const
virtual bool doesFeatureAffectCodeGen(StringRef Feature) const
Returns true if feature has an impact on target code generation.
virtual bool validateCPUSpecificCPUDispatch(StringRef Name) const
virtual bool hasProtectedVisibility() const
Does this target support "protected" visibility?
unsigned getRegParmMax() const
virtual unsigned getUnwindWordWidth() const
virtual bool isValidFeatureName(StringRef Feature) const
Determine whether this TargetInfo supports the given feature.
unsigned getCharWidth() const
virtual ParsedTargetAttr parseTargetAttr(StringRef Str) const
virtual bool supportsTargetAttributeTune() const
Determine whether this TargetInfo supports tune in target attribute.
virtual bool shouldDLLImportComdatSymbols() const
Does this target aim for semantic compatibility with Microsoft C++ code using dllimport/export attrib...
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
virtual bool isValidCPUName(StringRef Name) const
Determine whether this TargetInfo supports the given CPU name.
const llvm::VersionTuple & getSDKVersion() const
virtual bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const
Determine if this TargetInfo supports the given branch protection specification.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Represents a type template specialization; the template must be a class template, a type alias templa...
const Type * getTypeForDecl() const
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
SourceLocation getBeginLoc() const
Get the begin source location.
A container of type source information.
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
bool isSizelessType() const
As an extension, we classify types as one of "sized" or "sizeless"; every type is one or the other.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBlockPointerType() const
bool isBooleanType() const
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
bool isFunctionPointerType() const
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
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.
bool isExtVectorType() const
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
bool isBitIntType() const
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
bool isMemberPointerType() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Visibility getVisibility() const
Determine the visibility of this type.
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isVectorType() const
bool isFloatingType() const
bool isAnyPointerType() const
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 isTypedefNameType() const
Determines whether this type is written as a typedef-name.
Base class for declarations which introduce a typedef-name.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
Represents a dependent using declaration which was marked with typename.
Represents a dependent using declaration which was not marked with typename.
Represents a C++ using-declaration.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
void setType(QualType newType)
Represents a variable declaration or definition.
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
@ TLS_None
Not a TLS variable.
Represents a GCC generic vector type.
Captures information about a #pragma weak directive.
const IdentifierInfo * getAlias() const
SourceLocation getLocation() const
A collection of diagnostics which were delayed.
const DelayedDiagnosticPool * getParent() const
void steal(DelayedDiagnosticPool &pool)
Steal the diagnostics from the given pool.
pool_iterator pool_end() const
SmallVectorImpl< DelayedDiagnostic >::const_iterator pool_iterator
pool_iterator pool_begin() const
A diagnostic message which has been conditionally emitted pending the complete parsing of the current...
QualType getForbiddenTypeOperand() const
unsigned getForbiddenTypeDiagnostic() const
The diagnostic ID to emit.
unsigned getForbiddenTypeArgument() const
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
bool isa(CodeGen::Address addr)
@ ExpectedFunctionMethodOrBlock
@ ExpectedTypeOrNamespace
@ ExpectedVariableFieldOrTag
@ ExpectedVariableOrField
@ ExpectedFunctionOrMethod
@ ExpectedVariableOrFunction
@ ExpectedFunctionVariableOrClass
bool hasDeclarator(const Decl *D)
Return true if the given decl has a declarator that should have been processed by Sema::GetTypeForDec...
QualType getFunctionOrMethodResultType(const Decl *D)
bool isInstanceMethod(const Decl *D)
@ OK_Ordinary
An ordinary object is located at an address in memory.
CudaVersion ToCudaVersion(llvm::VersionTuple)
SourceRange getFunctionOrMethodResultSourceRange(const Decl *D)
bool isFunctionOrMethodOrBlockForAttrSubject(const Decl *D)
Return true if the given decl has function type (function or function-typed variable) or an Objective...
QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx)
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Language
The language for the input, used to select and validate the language standard and possible actions.
AttributeArgumentNType
These constants match the enumerated choices of err_attribute_argument_n_type and err_attribute_argum...
@ AANT_ArgumentIntegerConstant
@ AANT_ArgumentBuiltinFunction
@ AANT_ArgumentIdentifier
@ SD_Automatic
Automatic storage duration (most local variables).
@ Result
The result type of a method or function.
@ SwiftAsyncContext
This parameter (which must have pointer type) uses the special Swift asynchronous context-pointer ABI...
@ SwiftErrorResult
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
@ SwiftIndirectResult
This parameter (which must have pointer type) is a Swift indirect result parameter.
@ SwiftContext
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment.
bool isFunctionOrMethodVariadic(const Decl *D)
bool isFuncOrMethodForAttrSubject(const Decl *D)
isFuncOrMethodForAttrSubject - Return true if the given decl has function type (function or function-...
OffloadArch StringToOffloadArch(llvm::StringRef S)
LLVM_READONLY bool isHexDigit(unsigned char c)
Return true if this character is an ASCII hex digit: [0-9a-fA-F].
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Parse a single value from a -fsanitize= or -fno-sanitize= value list.
const char * OffloadArchToString(OffloadArch A)
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
MSInheritanceModel
Assigned inheritance model for a class in the MS C++ ABI.
bool hasFunctionProto(const Decl *D)
hasFunctionProto - Return true if the given decl has a argument information.
unsigned getFunctionOrMethodNumParams(const Decl *D)
getFunctionOrMethodNumParams - Return number of function or method parameters.
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ Generic
not a target-specific vector type
SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx)
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
@ Union
The "union" keyword introduces the elaborated-type-specifier.
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
@ Other
Other implicit parameter.
@ Implicit
An implicit conversion.
Represents information about a change in availability for an entity, which is part of the encoding of...
VersionTuple Version
The version number at which the change occurred.
bool isValid() const
Determine whether this availability change is valid.
static constexpr OSEnvPair macOStoMacCatalystPair()
Returns the os-environment mapping pair that's used to represent the macOS -> Mac Catalyst version ma...
static constexpr OSEnvPair iOStoWatchOSPair()
Returns the os-environment mapping pair that's used to represent the iOS -> watchOS version mapping.
static constexpr OSEnvPair iOStoTvOSPair()
Returns the os-environment mapping pair that's used to represent the iOS -> tvOS version mapping.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
DeclarationName getName() const
getName - Returns the embedded declaration name.
const ParsedAttributesView & getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Wraps an identifier and optional source location for the identifier.
Parts of a decomposed MSGuidDecl.
uint16_t Part2
...-89ab-...
uint32_t Part1
{01234567-...
uint16_t Part3
...-cdef-...
uint8_t Part4And5[8]
...-0123-456789abcdef}
virtual AttrHandling handleDeclAttribute(Sema &S, Decl *D, const ParsedAttr &Attr) const
If this ParsedAttrInfo knows how to handle this ParsedAttr applied to this Decl then do so and return...
Contains information gathered from parsing the contents of TargetAttr.
std::vector< std::string > Features
StringRef BranchProtection