Lines Matching refs:Attr
170 static unsigned getNumAttributeArgs(const AttributeList &Attr) {
172 return Attr.getNumArgs() + Attr.hasParsedType();
176 static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &Attr,
179 if (Comp(getNumAttributeArgs(Attr), Num)) {
180 S.Diag(Attr.getLoc(), Diag) << Attr.getName() << Num;
189 static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
191 return checkAttributeNumArgsImpl(S, Attr, Num,
198 static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr,
200 return checkAttributeNumArgsImpl(S, Attr, Num,
207 static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &Attr,
209 return checkAttributeNumArgsImpl(S, Attr, Num,
216 static bool checkUInt32Argument(Sema &S, const AttributeList &Attr,
223 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
224 << Attr.getName() << Idx << AANT_ArgumentIntegerConstant
227 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
228 << Attr.getName() << AANT_ArgumentIntegerConstant
247 const AttributeList &Attr) {
249 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
250 << Attr.getName() << A;
261 const AttributeList &Attr,
278 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
279 << Attr.getName() << AttrArgNum << AANT_ArgumentIntegerConstant
286 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
287 << Attr.getName() << AttrArgNum << IdxExpr->getSourceRange();
293 S.Diag(Attr.getLoc(),
295 << Attr.getName() << IdxExpr->getSourceRange();
304 /// \brief Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
308 bool Sema::checkStringLiteralArgumentAttr(const AttributeList &Attr,
312 if (Attr.isArgIdent(ArgNum)) {
313 IdentifierLoc *Loc = Attr.getArgAsIdent(ArgNum);
315 << Attr.getName() << AANT_ArgumentString
325 Expr *ArgExpr = Attr.getArgAsExpr(ArgNum);
332 << Attr.getName() << AANT_ArgumentString;
344 const AttributeList &Attr) {
345 D->addAttr(::new (S.Context) AttrType(Attr.getRange(), S.Context,
346 Attr.getAttributeSpellingListIndex()));
376 const AttributeList &Attr) {
393 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
394 << Attr.getName() << QT;
498 const AttributeList &Attr,
502 for (unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
503 Expr *ArgExp = Attr.getArgAsExpr(Idx);
522 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
523 Attr.getName();
551 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
552 << Attr.getName() << Idx + 1 << NumParams;
564 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
565 << Attr.getName() << ArgTy;
576 const AttributeList &Attr) {
577 if (!threadSafetyCheckIsPointer(S, D, Attr))
581 PtGuardedVarAttr(Attr.getRange(), S.Context,
582 Attr.getAttributeSpellingListIndex()));
586 const AttributeList &Attr,
590 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
600 static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) {
602 if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
605 D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg,
606 Attr.getAttributeSpellingListIndex()));
610 const AttributeList &Attr) {
612 if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
615 if (!threadSafetyCheckIsPointer(S, D, Attr))
618 D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
620 Attr.getAttributeSpellingListIndex()));
624 const AttributeList &Attr,
626 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
634 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
635 << Attr.getName();
641 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
649 const AttributeList &Attr) {
651 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
656 AcquiredAfterAttr(Attr.getRange(), S.Context,
658 Attr.getAttributeSpellingListIndex()));
662 const AttributeList &Attr) {
664 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
669 AcquiredBeforeAttr(Attr.getRange(), S.Context,
671 Attr.getAttributeSpellingListIndex()));
675 const AttributeList &Attr,
679 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
685 const AttributeList &Attr) {
687 if (!checkLockFunAttrCommon(S, D, Attr, Args))
693 AssertSharedLockAttr(Attr.getRange(), S.Context, StartArg, Size,
694 Attr.getAttributeSpellingListIndex()));
698 const AttributeList &Attr) {
700 if (!checkLockFunAttrCommon(S, D, Attr, Args))
706 AssertExclusiveLockAttr(Attr.getRange(), S.Context,
708 Attr.getAttributeSpellingListIndex()));
713 const AttributeList &Attr,
715 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
718 if (!isIntOrBool(Attr.getArgAsExpr(0))) {
719 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
720 << Attr.getName() << 1 << AANT_ArgumentIntOrBool;
725 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 1);
731 const AttributeList &Attr) {
733 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
737 SharedTrylockFunctionAttr(Attr.getRange(), S.Context,
738 Attr.getArgAsExpr(0),
740 Attr.getAttributeSpellingListIndex()));
744 const AttributeList &Attr) {
746 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
750 Attr.getRange(), S.Context, Attr.getArgAsExpr(0), Args.data(),
751 Args.size(), Attr.getAttributeSpellingListIndex()));
755 const AttributeList &Attr) {
758 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
764 LockReturnedAttr(Attr.getRange(), S.Context, Args[0],
765 Attr.getAttributeSpellingListIndex()));
769 const AttributeList &Attr) {
770 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
775 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
782 LocksExcludedAttr(Attr.getRange(), S.Context, StartArg, Size,
783 Attr.getAttributeSpellingListIndex()));
786 static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
787 Expr *Cond = Attr.getArgAsExpr(0);
796 if (!S.checkStringLiteralArgumentAttr(Attr, 1, Msg))
803 S.Diag(Attr.getLoc(), diag::err_enable_if_never_constant_expr);
810 EnableIfAttr(Attr.getRange(), S.Context, Cond, Msg,
811 Attr.getAttributeSpellingListIndex()));
814 static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
817 if (Attr.isArgIdent(0)) {
818 IdentifierLoc *IL = Attr.getArgAsIdent(0);
822 << Attr.getName() << IL->Ident;
826 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
827 << Attr.getName() << AANT_ArgumentIdentifier;
832 ConsumableAttr(Attr.getRange(), S.Context, DefaultState,
833 Attr.getAttributeSpellingListIndex()));
838 const AttributeList &Attr) {
844 S.Diag(Attr.getLoc(), diag::warn_attr_on_unconsumable_class) <<
856 const AttributeList &Attr) {
857 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
860 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
864 for (unsigned ArgIndex = 0; ArgIndex < Attr.getNumArgs(); ++ArgIndex) {
869 if (Attr.isArgIdent(ArgIndex)) {
870 IdentifierLoc *Ident = Attr.getArgAsIdent(ArgIndex);
874 if (!S.checkStringLiteralArgumentAttr(Attr, ArgIndex, StateString, &Loc))
881 << Attr.getName() << StateString;
889 CallableWhenAttr(Attr.getRange(), S.Context, States.data(),
890 States.size(), Attr.getAttributeSpellingListIndex()));
895 const AttributeList &Attr) {
898 if (Attr.isArgIdent(0)) {
899 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
905 << Attr.getName() << StateString;
909 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
910 Attr.getName() << AANT_ArgumentIdentifier;
921 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
927 ParamTypestateAttr(Attr.getRange(), S.Context, ParamState,
928 Attr.getAttributeSpellingListIndex()));
933 const AttributeList &Attr) {
936 if (Attr.isArgIdent(0)) {
937 IdentifierLoc *IL = Attr.getArgAsIdent(0);
941 << Attr.getName() << IL->Ident;
945 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
946 Attr.getName() << AANT_ArgumentIdentifier;
970 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
976 ReturnTypestateAttr(Attr.getRange(), S.Context, ReturnState,
977 Attr.getAttributeSpellingListIndex()));
981 static void handleSetTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
982 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
986 if (Attr.isArgIdent(0)) {
987 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
991 << Attr.getName() << Param;
995 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
996 Attr.getName() << AANT_ArgumentIdentifier;
1001 SetTypestateAttr(Attr.getRange(), S.Context, NewState,
1002 Attr.getAttributeSpellingListIndex()));
1006 const AttributeList &Attr) {
1007 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1011 if (Attr.isArgIdent(0)) {
1012 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1016 << Attr.getName() << Param;
1020 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1021 Attr.getName() << AANT_ArgumentIdentifier;
1026 TestTypestateAttr(Attr.getRange(), S.Context, TestState,
1027 Attr.getAttributeSpellingListIndex()));
1031 const AttributeList &Attr) {
1036 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1038 TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context,
1039 Attr.getAttributeSpellingListIndex()));
1046 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1047 << Attr.getName() << FD->getType();
1050 PackedAttr(Attr.getRange(), S.Context,
1051 Attr.getAttributeSpellingListIndex()));
1053 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1056 static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
1062 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1063 << Attr.getName() << VD->getType() << 0;
1069 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1070 << Attr.getName() << PD->getType() << 1;
1075 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
1082 static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
1083 if (!checkIBOutletCommon(S, D, Attr))
1087 IBOutletAttr(Attr.getRange(), S.Context,
1088 Attr.getAttributeSpellingListIndex()));
1092 const AttributeList &Attr) {
1095 if (Attr.getNumArgs() > 1) {
1096 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1097 << Attr.getName() << 1;
1101 if (!checkIBOutletCommon(S, D, Attr))
1106 if (Attr.hasParsedType())
1107 PT = Attr.getTypeArg();
1109 PT = S.getTypeName(S.Context.Idents.get("NSObject"), Attr.getLoc(),
1112 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1120 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, Attr.getLoc());
1127 S.Diag(Attr.getLoc(),
1134 IBOutletCollectionAttr(Attr.getRange(), S.Context, QTLoc,
1135 Attr.getAttributeSpellingListIndex()));
1162 static bool attrNonNullArgCheck(Sema &S, QualType T, const AttributeList &Attr,
1167 S.Diag(Attr.getLoc(), isReturnValue
1170 << Attr.getName() << AttrParmRange << TypeRange;
1176 static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1178 for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
1179 Expr *Ex = Attr.getArgAsExpr(I);
1181 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, I + 1, Ex, Idx))
1186 !attrNonNullArgCheck(S, getFunctionOrMethodParamType(D, Idx), Attr,
1198 if (NonNullArgs.empty() && Attr.getLoc().isFileID() &&
1209 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1216 NonNullAttr(Attr.getRange(), S.Context, Start, Size,
1217 Attr.getAttributeSpellingListIndex()));
1221 const AttributeList &Attr) {
1222 if (Attr.getNumArgs() > 0) {
1224 handleNonNullAttr(S, D, Attr);
1226 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1233 if (!attrNonNullArgCheck(S, D->getType(), Attr, SourceRange(),
1238 NonNullAttr(Attr.getRange(), S.Context, nullptr, 0,
1239 Attr.getAttributeSpellingListIndex()));
1243 const AttributeList &Attr) {
1246 if (!attrNonNullArgCheck(S, ResultType, Attr, SourceRange(), SR,
1251 ReturnsNonNullAttr(Attr.getRange(), S.Context,
1252 Attr.getAttributeSpellingListIndex()));
1256 const AttributeList &Attr) {
1257 Expr *E = Attr.getArgAsExpr(0),
1258 *OE = Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr;
1259 S.AddAssumeAlignedAttr(Attr.getRange(), D, E, OE,
1260 Attr.getAttributeSpellingListIndex());
1426 static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1428 if (Attr.getNumArgs() > 1) {
1429 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1430 << Attr.getName() << 1;
1448 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context)
1479 if (Attr.getNumArgs() && S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1482 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1483 Attr.getAttributeSpellingListIndex()));
1486 WeakRefAttr(Attr.getRange(), S.Context,
1487 Attr.getAttributeSpellingListIndex()));
1490 static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1492 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1496 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1503 S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD;
1509 S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << VD;
1516 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1517 Attr.getAttributeSpellingListIndex()));
1520 static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1521 if (checkAttrMutualExclusion<HotAttr>(S, D, Attr))
1524 D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context,
1525 Attr.getAttributeSpellingListIndex()));
1528 static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1529 if (checkAttrMutualExclusion<ColdAttr>(S, D, Attr))
1532 D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context,
1533 Attr.getAttributeSpellingListIndex()));
1537 const AttributeList &Attr) {
1541 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Model, &LiteralLoc))
1552 TLSModelAttr(Attr.getRange(), S.Context, Model,
1553 Attr.getAttributeSpellingListIndex()));
1556 static void handleKernelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1559 KernelAttr(Attr.getRange(), S.Context,
1560 Attr.getAttributeSpellingListIndex()));
1562 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "kernel";
1566 static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1570 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1574 S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1575 << Attr.getName() << getFunctionOrMethodResultSourceRange(D);
1578 static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1580 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
1581 << Attr.getName() << AttributeLangSupport::Cpp;
1585 D->addAttr(::new (S.Context) CommonAttr(Attr.getRange(), S.Context,
1586 Attr.getAttributeSpellingListIndex()));
1615 const AttributeList &Attr) {
1623 S.Diag(Attr.getLoc(),
1624 Attr.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
1626 << Attr.getName() << ExpectedFunctionMethodOrBlock;
1632 AnalyzerNoReturnAttr(Attr.getRange(), S.Context,
1633 Attr.getAttributeSpellingListIndex()));
1637 static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1662 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << A;
1670 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1675 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
1681 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1688 VecReturnAttr(Attr.getRange(), S.Context,
1689 Attr.getAttributeSpellingListIndex()));
1693 const AttributeList &Attr) {
1698 S.Diag(Attr.getLoc(),
1705 Attr.getRange(), S.Context,
1706 Attr.getAttributeSpellingListIndex()));
1709 static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1712 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1716 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1717 << Attr.getName() << ExpectedVariableOrFunction;
1722 UsedAttr(Attr.getRange(), S.Context,
1723 Attr.getAttributeSpellingListIndex()));
1726 static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1728 if (Attr.getNumArgs() &&
1729 !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
1733 ConstructorAttr(Attr.getRange(), S.Context, priority,
1734 Attr.getAttributeSpellingListIndex()));
1737 static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1739 if (Attr.getNumArgs() &&
1740 !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
1744 DestructorAttr(Attr.getRange(), S.Context, priority,
1745 Attr.getAttributeSpellingListIndex()));
1750 const AttributeList &Attr) {
1753 if (Attr.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1756 D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str,
1757 Attr.getAttributeSpellingListIndex()));
1761 const AttributeList &Attr) {
1763 S.Diag(Attr.getLoc(), diag::err_objc_attr_protocol_requires_definition)
1764 << Attr.getName() << Attr.getRange();
1769 ObjCExplicitProtocolImplAttr(Attr.getRange(), S.Context,
1770 Attr.getAttributeSpellingListIndex()));
1956 const AttributeList &Attr) {
1957 if (!checkAttributeNumArgs(S, Attr, 1))
1959 IdentifierLoc *Platform = Attr.getArgAsIdent(0);
1960 unsigned Index = Attr.getAttributeSpellingListIndex();
1969 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1973 AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1974 AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1975 AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
1976 bool IsUnavailable = Attr.getUnavailableLoc().isValid();
1979 dyn_cast_or_null<StringLiteral>(Attr.getMessageExpr()))
1982 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND, Attr.getRange(), II,
2023 static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr,
2027 S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
2028 << Attr.getName();
2037 S.Diag(Attr.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2038 << Attr.getName() << ExpectedTypeOrNamespace;
2045 if (!S.checkStringLiteralArgumentAttr(Attr, 0, TypeStr, &LiteralLoc))
2051 << Attr.getName() << TypeStr;
2059 S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
2063 unsigned Index = Attr.getAttributeSpellingListIndex();
2064 clang::Attr *newAttr;
2066 newAttr = S.mergeTypeVisibilityAttr(D, Attr.getRange(),
2070 newAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type, Index);
2077 const AttributeList &Attr) {
2079 if (!Attr.isArgIdent(0)) {
2080 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2081 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2085 IdentifierLoc *IL = Attr.getArgAsIdent(0);
2088 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << Attr.getName()
2101 method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
2103 Attr.getAttributeSpellingListIndex()));
2106 static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
2131 ObjCNSObjectAttr(Attr.getRange(), S.Context,
2132 Attr.getAttributeSpellingListIndex()));
2135 static void handleObjCIndependentClass(Sema &S, Decl *D, const AttributeList &Attr) {
2147 ObjCIndependentClassAttr(Attr.getRange(), S.Context,
2148 Attr.getAttributeSpellingListIndex()));
2151 static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2152 if (!Attr.isArgIdent(0)) {
2153 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2154 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2158 IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2161 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2162 << Attr.getName() << II;
2167 BlocksAttr(Attr.getRange(), S.Context, type,
2168 Attr.getAttributeSpellingListIndex()));
2171 static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2173 if (Attr.getNumArgs() > 0) {
2174 Expr *E = Attr.getArgAsExpr(0);
2178 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2179 << Attr.getName() << 1 << AANT_ArgumentIntegerConstant
2185 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2194 if (Attr.getNumArgs() > 1) {
2195 Expr *E = Attr.getArgAsExpr(1);
2199 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2200 << Attr.getName() << 2 << AANT_ArgumentIntegerConstant
2209 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2218 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2223 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2228 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2233 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2244 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2248 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2249 << Attr.getName() << ExpectedFunctionMethodOrBlock;
2253 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2254 << Attr.getName() << ExpectedFunctionMethodOrBlock;
2258 SentinelAttr(Attr.getRange(), S.Context, sentinel, nullPos,
2259 Attr.getAttributeSpellingListIndex()));
2262 static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
2265 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2266 << Attr.getName() << 0;
2271 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2272 << Attr.getName() << 1;
2277 WarnUnusedResultAttr(Attr.getRange(), S.Context,
2278 Attr.getAttributeSpellingListIndex()));
2281 static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2286 S.Diag(Attr.getLoc(), diag::warn_attribute_invalid_on_definition)
2293 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2294 << Attr.getName() << ExpectedVariableOrFunction;
2300 WeakImportAttr(Attr.getRange(), S.Context,
2301 Attr.getAttributeSpellingListIndex()));
2307 const AttributeList &Attr) {
2310 const Expr *E = Attr.getArgAsExpr(i);
2311 if (!checkUInt32Argument(S, Attr, E, WGSize[i], i))
2314 S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2315 << Attr.getName() << E->getSourceRange();
2324 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2326 D->addAttr(::new (S.Context) WorkGroupAttr(Attr.getRange(), S.Context,
2328 Attr.getAttributeSpellingListIndex()));
2331 static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &Attr) {
2332 if (!Attr.hasParsedType()) {
2333 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2334 << Attr.getName() << 1;
2339 QualType ParmType = S.GetTypeFromParser(Attr.getTypeArg(), &ParmTSI);
2345 S.Diag(Attr.getLoc(), diag::err_attribute_argument_vec_type_hint)
2352 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2357 D->addAttr(::new (S.Context) VecTypeHintAttr(Attr.getLoc(), S.Context,
2359 Attr.getAttributeSpellingListIndex()));
2385 static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2390 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
2404 unsigned Index = Attr.getAttributeSpellingListIndex();
2405 SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(), Str, Index);
2411 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2414 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2418 Expr *E = Attr.getArgAsExpr(0);
2470 CleanupAttr(Attr.getRange(), S.Context, FD,
2471 Attr.getAttributeSpellingListIndex()));
2476 static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2477 Expr *IdxExpr = Attr.getArgAsExpr(0);
2479 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, IdxExpr, Idx))
2490 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2500 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
2513 FormatArgAttr(Attr.getRange(), S.Context, Val.getZExtValue(),
2514 Attr.getAttributeSpellingListIndex()));
2549 const AttributeList &Attr) {
2551 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2556 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2557 Attr.setInvalid();
2564 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2565 Attr.setInvalid();
2569 Expr *E = Attr.getArgAsExpr(0);
2571 if (!checkUInt32Argument(S, Attr, E, prioritynum)) {
2572 Attr.setInvalid();
2577 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
2579 Attr.setInvalid();
2583 InitPriorityAttr(Attr.getRange(), S.Context, prioritynum,
2584 Attr.getAttributeSpellingListIndex()));
2610 static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2611 if (!Attr.isArgIdent(0)) {
2612 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2613 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2622 IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2639 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2640 << Attr.getName() << II->getName();
2645 Expr *IdxExpr = Attr.getArgAsExpr(1);
2647 if (!checkUInt32Argument(S, Attr, IdxExpr, Idx, 2))
2651 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2652 << Attr.getName() << 2 << IdxExpr->getSourceRange();
2661 S.Diag(Attr.getLoc(),
2674 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2683 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2690 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2697 Expr *FirstArgExpr = Attr.getArgAsExpr(2);
2699 if (!checkUInt32Argument(S, Attr, FirstArgExpr, FirstArg, 3))
2716 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
2722 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2723 << Attr.getName() << 3 << FirstArgExpr->getSourceRange();
2727 FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), II,
2729 Attr.getAttributeSpellingListIndex());
2735 const AttributeList &Attr) {
2745 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2746 << Attr.getName() << ExpectedUnion;
2751 S.Diag(Attr.getLoc(),
2759 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
2799 TransparentUnionAttr(Attr.getRange(), S.Context,
2800 Attr.getAttributeSpellingListIndex()));
2803 static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2807 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
2817 AnnotateAttr(Attr.getRange(), S.Context, Str,
2818 Attr.getAttributeSpellingListIndex()));
2822 const AttributeList &Attr) {
2823 S.AddAlignValueAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
2824 Attr.getAttributeSpellingListIndex());
2873 static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2875 if (Attr.getNumArgs() > 1) {
2876 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2877 << Attr.getName() << 1;
2881 if (Attr.getNumArgs() == 0) {
2882 D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
2883 true, nullptr, Attr.getAttributeSpellingListIndex()));
2887 Expr *E = Attr.getArgAsExpr(0);
2888 if (Attr.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
2889 S.Diag(Attr.getEllipsisLoc(),
2894 if (!Attr.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
2900 S.Diag(Attr.getLoc(), diag::err_alignment_dependent_typedef_name)
2907 S.AddAlignedAttr(Attr.getRange(), D, E, Attr.getAttributeSpellingListIndex(),
2908 Attr.isPackExpansion());
2961 // FIXME: Cache the number on the Attr object?
2998 // FIXME: Cache the number on the Attr object if non-dependent?
3078 static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3081 if (!Attr.isArgIdent(0)) {
3082 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
3087 IdentifierInfo *Name = Attr.getArgAsIdent(0)->Ident;
3141 << Attr.getName() << Attr.getRange();
3146 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
3149 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3152 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3155 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3163 S.Diag(Attr.getLoc(), diag::err_machine_mode) << 0 /*Unknown*/ << Name;
3176 S.Diag(Attr.getLoc(), diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
3191 ModeAttr(Attr.getRange(), S.Context, Name,
3192 Attr.getAttributeSpellingListIndex()));
3195 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3198 S.Diag(Attr.getLoc(),
3200 << Attr.getName();
3202 S.Diag(Attr.getLoc(),
3204 << Attr.getName();
3209 NoDebugAttr(Attr.getRange(), S.Context,
3210 Attr.getAttributeSpellingListIndex()));
3264 const AttributeList &Attr) {
3266 D, Attr.getRange(), Attr.getName(),
3267 Attr.getAttributeSpellingListIndex()))
3271 static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3273 D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
3278 const AttributeList &Attr) {
3280 D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
3284 static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3296 CUDAGlobalAttr(Attr.getRange(), S.Context,
3297 Attr.getAttributeSpellingListIndex()));
3300 static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3303 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
3308 GNUInlineAttr(Attr.getRange(), S.Context,
3309 Attr.getAttributeSpellingListIndex()));
3312 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3316 // Diagnostic is emitted elsewhere: here we store the (valid) Attr
3319 if (S.CheckCallingConvAttr(Attr, CC, FD))
3323 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3324 << Attr.getName() << ExpectedFunctionOrMethod;
3328 switch (Attr.getKind()) {
3331 FastCallAttr(Attr.getRange(), S.Context,
3332 Attr.getAttributeSpellingListIndex()));
3336 StdCallAttr(Attr.getRange(), S.Context,
3337 Attr.getAttributeSpellingListIndex()));
3341 ThisCallAttr(Attr.getRange(), S.Context,
3342 Attr.getAttributeSpellingListIndex()));
3346 CDeclAttr(Attr.getRange(), S.Context,
3347 Attr.getAttributeSpellingListIndex()));
3351 PascalAttr(Attr.getRange(), S.Context,
3352 Attr.getAttributeSpellingListIndex()));
3356 VectorCallAttr(Attr.getRange(), S.Context,
3357 Attr.getAttributeSpellingListIndex()));
3361 MSABIAttr(Attr.getRange(), S.Context,
3362 Attr.getAttributeSpellingListIndex()));
3366 SysVABIAttr(Attr.getRange(), S.Context,
3367 Attr.getAttributeSpellingListIndex()));
3383 PcsAttr(Attr.getRange(), S.Context, PCS,
3384 Attr.getAttributeSpellingListIndex()));
3389 IntelOclBiccAttr(Attr.getRange(), S.Context,
3390 Attr.getAttributeSpellingListIndex()));
3467 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3468 if (Attr.isInvalid())
3471 if (!checkAttributeNumArgs(*this, Attr, 1)) {
3472 Attr.setInvalid();
3477 Expr *NumParamsExpr = Attr.getArgAsExpr(0);
3478 if (!checkUInt32Argument(*this, Attr, NumParamsExpr, NP)) {
3479 Attr.setInvalid();
3484 Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
3486 Attr.setInvalid();
3492 Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
3494 Attr.setInvalid();
3502 const AttributeList &Attr) {
3504 if (!checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), MaxThreads, 1))
3506 if (Attr.getNumArgs() > 1 && !checkUInt32Argument(S, Attr,
3507 Attr.getArgAsExpr(1),
3512 CUDALaunchBoundsAttr(Attr.getRange(), S.Context,
3514 Attr.getAttributeSpellingListIndex()));
3518 const AttributeList &Attr) {
3519 if (!Attr.isArgIdent(0)) {
3520 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3521 << Attr.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
3525 if (!checkAttributeNumArgs(S, Attr, 3))
3528 IdentifierInfo *ArgumentKind = Attr.getArgAsIdent(0)->Ident;
3531 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3532 << Attr.getName() << ExpectedFunctionOrMethod;
3537 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 2, Attr.getArgAsExpr(1),
3542 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 3, Attr.getArgAsExpr(2),
3546 bool IsPointer = (Attr.getName()->getName() == "pointer_with_type_tag");
3551 S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
3552 << Attr.getName();
3557 ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
3559 Attr.getAttributeSpellingListIndex()));
3563 const AttributeList &Attr) {
3564 if (!Attr.isArgIdent(0)) {
3565 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3566 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
3570 if (!checkAttributeNumArgs(S, Attr, 1))
3574 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3575 << Attr.getName() << ExpectedVariable;
3579 IdentifierInfo *PointerKind = Attr.getArgAsIdent(0)->Ident;
3581 S.GetTypeFromParser(Attr.getMatchingCType(), &MatchingCTypeLoc);
3585 TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
3587 Attr.getLayoutCompatible(),
3588 Attr.getMustBeNull(),
3589 Attr.getAttributeSpellingListIndex()));
3612 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3616 if (Attr.getKind() == AttributeList::AT_NSConsumed) {
3626 << Attr.getRange() << Attr.getName() << cf;
3632 CFConsumedAttr(Attr.getRange(), S.Context,
3633 Attr.getAttributeSpellingListIndex()));
3636 NSConsumedAttr(Attr.getRange(), S.Context,
3637 Attr.getAttributeSpellingListIndex()));
3641 const AttributeList &Attr) {
3648 (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
3656 << Attr.getRange() << Attr.getName()
3663 switch (Attr.getKind()) {
3685 << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
3689 switch (Attr.getKind()) {
3694 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3698 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3702 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3706 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3710 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3766 const AttributeList &Attr) {
3767 if (checkAttrMutualExclusion<CFUnknownTransferAttr>(S, D, Attr))
3771 CFAuditedTransferAttr(Attr.getRange(), S.Context,
3772 Attr.getAttributeSpellingListIndex()));
3776 const AttributeList &Attr) {
3777 if (checkAttrMutualExclusion<CFAuditedTransferAttr>(S, D, Attr))
3781 CFUnknownTransferAttr(Attr.getRange(), S.Context,
3782 Attr.getAttributeSpellingListIndex()));
3786 const AttributeList &Attr) {
3787 IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3790 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3797 S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_id)
3798 << Attr.getName();
3805 S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
3811 ObjCBridgeAttr(Attr.getRange(), S.Context, Parm->Ident,
3812 Attr.getAttributeSpellingListIndex()));
3816 const AttributeList &Attr) {
3817 IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3820 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3825 ObjCBridgeMutableAttr(Attr.getRange(), S.Context, Parm->Ident,
3826 Attr.getAttributeSpellingListIndex()));
3830 const AttributeList &Attr) {
3832 Attr.isArgIdent(0) ? Attr.getArgAsIdent(0)->Ident : nullptr;
3834 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3838 Attr.getArgAsIdent(1) ? Attr.getArgAsIdent(1)->Ident : nullptr;
3840 Attr.getArgAsIdent(2) ? Attr.getArgAsIdent(2)->Ident : nullptr;
3842 ObjCBridgeRelatedAttr(Attr.getRange(), S.Context, RelatedClass,
3844 Attr.getAttributeSpellingListIndex()));
3848 const AttributeList &Attr) {
3861 ObjCDesignatedInitializerAttr(Attr.getRange(), S.Context,
3862 Attr.getAttributeSpellingListIndex()));
3866 const AttributeList &Attr) {
3868 if (!S.checkStringLiteralArgumentAttr(Attr, 0, MetaDataName))
3871 ObjCRuntimeNameAttr(Attr.getRange(), S.Context,
3873 Attr.getAttributeSpellingListIndex()));
3877 const AttributeList &Attr) {
3881 << Attr.getRange() << Attr.getName() << ExpectedVariable;
3885 const AttributeList &Attr) {
3891 S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
3915 S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
3921 ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
3922 Attr.getAttributeSpellingListIndex()));
3929 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3931 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
3932 << Attr.getName() << AttributeLangSupport::C;
3937 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3938 << Attr.getName() << ExpectedClass;
3944 if (!S.checkStringLiteralArgumentAttr(Attr, 0, StrRef, &LiteralLoc))
3970 D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context, StrRef,
3971 Attr.getAttributeSpellingListIndex()));
3974 static void handleMSInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3976 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
3977 << Attr.getName() << AttributeLangSupport::C;
3981 D, Attr.getRange(), /*BestCase=*/true,
3982 Attr.getAttributeSpellingListIndex(),
3983 (MSInheritanceAttr::Spelling)Attr.getSemanticSpelling());
3989 const AttributeList &Attr) {
3992 S.Diag(Attr.getLoc(), diag::err_thread_unsupported);
3996 S.Diag(Attr.getLoc(), diag::err_declspec_thread_on_thread_variable);
4000 S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
4004 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4008 const AttributeList &Attr) {
4010 if (Attr.getNumArgs() > 1) {
4011 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
4012 << Attr.getName() << 1;
4019 if (Attr.getNumArgs() == 0)
4021 else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
4026 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
4027 << Attr.getName() << Str << ArgLoc;
4031 unsigned Index = Attr.getAttributeSpellingListIndex();
4033 ARMInterruptAttr(Attr.getLoc(), S.Context, Kind, Index));
4037 const AttributeList &Attr) {
4038 if (!checkAttributeNumArgs(S, Attr, 1))
4041 if (!Attr.isArgExpr(0)) {
4042 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
4049 Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4052 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
4053 << Attr.getName() << AANT_ArgumentIntegerConstant
4060 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
4061 << Attr.getName() << (int)NumParams.getSExtValue()
4067 MSP430InterruptAttr(Attr.getLoc(), S.Context, Num,
4068 Attr.getAttributeSpellingListIndex()));
4072 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4075 handleMSP430InterruptAttr(S, D, Attr);
4077 handleARMInterruptAttr(S, D, Attr);
4081 const AttributeList &Attr) {
4083 Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4084 if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4088 AMDGPUNumVGPRAttr(Attr.getLoc(), S.Context,
4090 Attr.getAttributeSpellingListIndex()));
4094 const AttributeList &Attr) {
4096 Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4097 if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4101 AMDGPUNumSGPRAttr(Attr.getLoc(), S.Context,
4103 Attr.getAttributeSpellingListIndex()));
4107 const AttributeList& Attr) {
4121 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4122 << Attr.getName() << /* function */0;
4127 X86ForceAlignArgPointerAttr(Attr.getRange(), S.Context,
4128 Attr.getAttributeSpellingListIndex()));
4176 Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
4177 ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
4178 : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
4219 static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4230 if (Attr.getKind() == AttributeList::AT_Capability &&
4231 !S.checkStringLiteralArgumentAttr(Attr, 0, N, &LiteralLoc))
4239 D->addAttr(::new (S.Context) CapabilityAttr(Attr.getRange(), S.Context, N,
4240 Attr.getAttributeSpellingListIndex()));
4244 const AttributeList &Attr) {
4245 D->addAttr(::new (S.Context) AssertCapabilityAttr(Attr.getRange(), S.Context,
4246 Attr.getArgAsExpr(0),
4247 Attr.getAttributeSpellingListIndex()));
4251 const AttributeList &Attr) {
4253 if (!checkLockFunAttrCommon(S, D, Attr, Args))
4256 D->addAttr(::new (S.Context) AcquireCapabilityAttr(Attr.getRange(),
4259 Attr.getAttributeSpellingListIndex()));
4263 const AttributeList &Attr) {
4265 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
4268 D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(Attr.getRange(),
4270 Attr.getArgAsExpr(0),
4273 Attr.getAttributeSpellingListIndex()));
4277 const AttributeList &Attr) {
4280 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, true);
4283 Attr.getRange(), S.Context, Args.data(), Args.size(),
4284 Attr.getAttributeSpellingListIndex()));
4288 const AttributeList &Attr) {
4289 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4294 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
4299 RequiresCapabilityAttr(Attr.getRange(), S.Context, Args.data(),
4300 Args.size(), Attr.getAttributeSpellingListIndex());
4305 static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4308 S.Diag(Attr.getLoc(), diag::warn_deprecated_anonymous_namespace);
4317 if (Attr.isCXX11Attribute() &&
4318 !(Attr.hasScope() && Attr.getScopeName()->isStr("gnu")))
4319 S.Diag(Attr.getLoc(), diag::ext_deprecated_attr_is_a_cxx14_extension);
4321 handleAttrWithMessage<DeprecatedAttr>(S, D, Attr);
4328 const AttributeList &Attr) {
4334 if (Attr.hasCustomParsing() ||
4335 Attr.getKind() == AttributeList::UnknownAttribute)
4340 if (!Attr.diagnoseLangOpts(S))
4343 if (Attr.getMinArgs() == Attr.getMaxArgs()) {
4346 if (!checkAttributeNumArgs(S, Attr, Attr.getMinArgs()))
4350 if (Attr.getMinArgs() &&
4351 !checkAttributeAtLeastNumArgs(S, Attr, Attr.getMinArgs()))
4353 else if (!Attr.hasVariadicArg() && Attr.getMaxArgs() &&
4354 !checkAttributeAtMostNumArgs(S, Attr, Attr.getMaxArgs()))
4359 if (!Attr.diagnoseAppertainsTo(S, D))
4373 const AttributeList &Attr,
4375 if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
4380 if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
4386 if (Attr.getKind() == AttributeList::UnknownAttribute ||
4387 !Attr.existsInTarget(S.Context.getTargetInfo().getTriple())) {
4388 S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute()
4391 << Attr.getName();
4395 if (handleCommonAttributeFeatures(S, scope, D, Attr))
4398 switch (Attr.getKind()) {
4401 assert(Attr.isTypeAttr() && "Non-type attribute not handled");
4404 handleInterruptAttr(S, D, Attr);
4407 handleX86ForceAlignArgPointerAttr(S, D, Attr);
4411 handleDLLAttr(S, D, Attr);
4414 handleSimpleAttribute<Mips16Attr>(S, D, Attr);
4417 handleSimpleAttribute<NoMips16Attr>(S, D, Attr);
4420 handleAMDGPUNumVGPRAttr(S, D, Attr);
4423 handleAMDGPUNumSGPRAttr(S, D, Attr);
4426 handleSimpleAttribute<IBActionAttr>(S, D, Attr);
4429 handleIBOutlet(S, D, Attr);
4432 handleIBOutletCollection(S, D, Attr);
4435 handleAliasAttr(S, D, Attr);
4438 handleAlignedAttr(S, D, Attr);
4441 handleAlignValueAttr(S, D, Attr);
4444 handleAlwaysInlineAttr(S, D, Attr);
4447 handleAnalyzerNoReturnAttr(S, D, Attr);
4450 handleTLSModelAttr(S, D, Attr);
4453 handleAnnotateAttr(S, D, Attr);
4456 handleAvailabilityAttr(S, D, Attr);
4459 handleDependencyAttr(S, scope, D, Attr);
4462 handleCommonAttr(S, D, Attr);
4465 handleSimpleAttribute<CUDAConstantAttr>(S, D, Attr);
4468 handleConstructorAttr(S, D, Attr);
4471 handleSimpleAttribute<CXX11NoReturnAttr>(S, D, Attr);
4474 handleDeprecatedAttr(S, D, Attr);
4477 handleDestructorAttr(S, D, Attr);
4480 handleEnableIfAttr(S, D, Attr);
4483 handleExtVectorTypeAttr(S, scope, D, Attr);
4486 handleMinSizeAttr(S, D, Attr);
4489 handleOptimizeNoneAttr(S, D, Attr);
4492 handleSimpleAttribute<FlagEnumAttr>(S, D, Attr);
4495 handleSimpleAttribute<FlattenAttr>(S, D, Attr);
4498 handleFormatAttr(S, D, Attr);
4501 handleFormatArgAttr(S, D, Attr);
4504 handleGlobalAttr(S, D, Attr);
4507 handleSimpleAttribute<CUDADeviceAttr>(S, D, Attr);
4510 handleSimpleAttribute<CUDAHostAttr>(S, D, Attr);
4513 handleGNUInlineAttr(S, D, Attr);
4516 handleLaunchBoundsAttr(S, D, Attr);
4519 handleKernelAttr(S, D, Attr);
4522 handleRestrictAttr(S, D, Attr);
4525 handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
4528 handleModeAttr(S, D, Attr);
4531 handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
4534 handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
4538 handleNonNullAttrParameter(S, PVD, Attr);
4540 handleNonNullAttr(S, D, Attr);
4543 handleReturnsNonNullAttr(S, D, Attr);
4546 handleAssumeAlignedAttr(S, D, Attr);
4549 handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
4552 handleOwnershipAttr(S, D, Attr);
4555 handleColdAttr(S, D, Attr);
4558 handleHotAttr(S, D, Attr);
4561 handleSimpleAttribute<NakedAttr>(S, D, Attr);
4564 handleNoReturnAttr(S, D, Attr);
4567 handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
4570 handleSimpleAttribute<CUDASharedAttr>(S, D, Attr);
4573 handleVecReturnAttr(S, D, Attr);
4577 handleObjCOwnershipAttr(S, D, Attr);
4580 handleObjCPreciseLifetimeAttr(S, D, Attr);
4584 handleObjCReturnsInnerPointerAttr(S, D, Attr);
4588 handleObjCRequiresSuperAttr(S, D, Attr);
4592 handleObjCBridgeAttr(S, scope, D, Attr);
4596 handleObjCBridgeMutableAttr(S, scope, D, Attr);
4600 handleObjCBridgeRelatedAttr(S, scope, D, Attr);
4604 handleObjCDesignatedInitializer(S, D, Attr);
4608 handleObjCRuntimeName(S, D, Attr);
4612 handleCFAuditedTransferAttr(S, D, Attr);
4615 handleCFUnknownTransferAttr(S, D, Attr);
4620 handleNSConsumedAttr(S, D, Attr);
4623 handleSimpleAttribute<NSConsumesSelfAttr>(S, D, Attr);
4631 handleNSReturnsRetainedAttr(S, D, Attr);
4634 handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, Attr);
4637 handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, Attr);
4640 handleVecTypeHint(S, D, Attr);
4644 handleInitPriorityAttr(S, D, Attr);
4648 handlePackedAttr(S, D, Attr);
4651 handleSectionAttr(S, D, Attr);
4654 handleAttrWithMessage<UnavailableAttr>(S, D, Attr);
4657 handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, Attr);
4660 handleSimpleAttribute<ObjCRootClassAttr>(S, D, Attr);
4663 handleObjCSuppresProtocolAttr(S, D, Attr);
4666 handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, Attr);
4669 handleSimpleAttribute<UnusedAttr>(S, D, Attr);
4672 handleSimpleAttribute<ReturnsTwiceAttr>(S, D, Attr);
4675 handleUsedAttr(S, D, Attr);
4678 handleVisibilityAttr(S, D, Attr, false);
4681 handleVisibilityAttr(S, D, Attr, true);
4684 handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
4687 handleWarnUnusedResult(S, D, Attr);
4690 handleSimpleAttribute<WeakAttr>(S, D, Attr);
4693 handleWeakRefAttr(S, D, Attr);
4696 handleWeakImportAttr(S, D, Attr);
4699 handleTransparentUnionAttr(S, D, Attr);
4702 handleSimpleAttribute<ObjCExceptionAttr>(S, D, Attr);
4705 handleObjCMethodFamilyAttr(S, D, Attr);
4708 handleObjCNSObject(S, D, Attr);
4711 handleObjCIndependentClass(S, D, Attr);
4714 handleBlocksAttr(S, D, Attr);
4717 handleSentinelAttr(S, D, Attr);
4720 handleSimpleAttribute<ConstAttr>(S, D, Attr);
4723 handleSimpleAttribute<PureAttr>(S, D, Attr);
4726 handleCleanupAttr(S, D, Attr);
4729 handleNoDebugAttr(S, D, Attr);
4732 handleSimpleAttribute<NoDuplicateAttr>(S, D, Attr);
4735 handleSimpleAttribute<NoInlineAttr>(S, D, Attr);
4738 handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, Attr);
4750 handleCallConvAttr(S, D, Attr);
4753 handleSimpleAttribute<OpenCLKernelAttr>(S, D, Attr);
4756 handleSimpleAttribute<OpenCLImageAccessAttr>(S, D, Attr);
4761 handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
4764 handleSimpleAttribute<MSStructAttr>(S, D, Attr);
4767 handleUuidAttr(S, D, Attr);
4770 handleMSInheritanceAttr(S, D, Attr);
4773 handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
4776 handleDeclspecThreadAttr(S, D, Attr);
4781 handleAssertExclusiveLockAttr(S, D, Attr);
4784 handleAssertSharedLockAttr(S, D, Attr);
4787 handleSimpleAttribute<GuardedVarAttr>(S, D, Attr);
4790 handlePtGuardedVarAttr(S, D, Attr);
4793 handleSimpleAttribute<ScopedLockableAttr>(S, D, Attr);
4796 handleSimpleAttribute<NoSanitizeAddressAttr>(S, D, Attr);
4799 handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, Attr);
4802 handleSimpleAttribute<NoSanitizeThreadAttr>(S, D, Attr);
4805 handleSimpleAttribute<NoSanitizeMemoryAttr>(S, D, Attr);
4808 handleGuardedByAttr(S, D, Attr);
4811 handlePtGuardedByAttr(S, D, Attr);
4814 handleExclusiveTrylockFunctionAttr(S, D, Attr);
4817 handleLockReturnedAttr(S, D, Attr);
4820 handleLocksExcludedAttr(S, D, Attr);
4823 handleSharedTrylockFunctionAttr(S, D, Attr);
4826 handleAcquiredBeforeAttr(S, D, Attr);
4829 handleAcquiredAfterAttr(S, D, Attr);
4835 handleCapabilityAttr(S, D, Attr);
4838 handleRequiresCapabilityAttr(S, D, Attr);
4842 handleAssertCapabilityAttr(S, D, Attr);
4845 handleAcquireCapabilityAttr(S, D, Attr);
4848 handleReleaseCapabilityAttr(S, D, Attr);
4851 handleTryAcquireCapabilityAttr(S, D, Attr);
4856 handleConsumableAttr(S, D, Attr);
4859 handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, Attr);
4862 handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, Attr);
4865 handleCallableWhenAttr(S, D, Attr);
4868 handleParamTypestateAttr(S, D, Attr);
4871 handleReturnTypestateAttr(S, D, Attr);
4874 handleSetTypestateAttr(S, D, Attr);
4877 handleTestTypestateAttr(S, D, Attr);
4882 handleArgumentWithTypeTagAttr(S, D, Attr);
4885 handleTypeTagForDatatypeAttr(S, D, Attr);
4915 if (Attr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
4920 } else if (Attr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
4923 } else if (Attr *A = D->getAttr<VecTypeHintAttr>()) {
4926 } else if (Attr *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
4930 } else if (Attr *A = D->getAttr<AMDGPUNumSGPRAttr>()) {