1 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements decl-related attribute processing.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTMutationListener.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/Mangle.h"
24 #include "clang/AST/RecursiveASTVisitor.h"
25 #include "clang/Basic/CharInfo.h"
26 #include "clang/Basic/SourceManager.h"
27 #include "clang/Basic/TargetInfo.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/DeclSpec.h"
30 #include "clang/Sema/DelayedDiagnostic.h"
31 #include "clang/Sema/Initialization.h"
32 #include "clang/Sema/Lookup.h"
33 #include "clang/Sema/Scope.h"
34 #include "clang/Sema/ScopeInfo.h"
35 #include "clang/Sema/SemaInternal.h"
36 #include "llvm/ADT/STLExtras.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/Support/MathExtras.h"
40 using namespace clang;
43 namespace AttributeLangSupport {
49 } // end namespace AttributeLangSupport
51 //===----------------------------------------------------------------------===//
53 //===----------------------------------------------------------------------===//
55 /// isFunctionOrMethod - Return true if the given decl has function
56 /// type (function or function-typed variable) or an Objective-C
58 static bool isFunctionOrMethod(const Decl *D) {
59 return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
62 /// Return true if the given decl has function type (function or
63 /// function-typed variable) or an Objective-C method or a block.
64 static bool isFunctionOrMethodOrBlock(const Decl *D) {
65 return isFunctionOrMethod(D) || isa<BlockDecl>(D);
68 /// Return true if the given decl has a declarator that should have
69 /// been processed by Sema::GetTypeForDeclarator.
70 static bool hasDeclarator(const Decl *D) {
71 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
72 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
73 isa<ObjCPropertyDecl>(D);
76 /// hasFunctionProto - Return true if the given decl has a argument
77 /// information. This decl should have already passed
78 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
79 static bool hasFunctionProto(const Decl *D) {
80 if (const FunctionType *FnTy = D->getFunctionType())
81 return isa<FunctionProtoType>(FnTy);
82 return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
85 /// getFunctionOrMethodNumParams - Return number of function or method
86 /// parameters. It is an error to call this on a K&R function (use
87 /// hasFunctionProto first).
88 static unsigned getFunctionOrMethodNumParams(const Decl *D) {
89 if (const FunctionType *FnTy = D->getFunctionType())
90 return cast<FunctionProtoType>(FnTy)->getNumParams();
91 if (const auto *BD = dyn_cast<BlockDecl>(D))
92 return BD->getNumParams();
93 return cast<ObjCMethodDecl>(D)->param_size();
96 static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
97 if (const FunctionType *FnTy = D->getFunctionType())
98 return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
99 if (const auto *BD = dyn_cast<BlockDecl>(D))
100 return BD->getParamDecl(Idx)->getType();
102 return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
105 static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
106 if (const auto *FD = dyn_cast<FunctionDecl>(D))
107 return FD->getParamDecl(Idx)->getSourceRange();
108 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
109 return MD->parameters()[Idx]->getSourceRange();
110 if (const auto *BD = dyn_cast<BlockDecl>(D))
111 return BD->getParamDecl(Idx)->getSourceRange();
112 return SourceRange();
115 static QualType getFunctionOrMethodResultType(const Decl *D) {
116 if (const FunctionType *FnTy = D->getFunctionType())
117 return FnTy->getReturnType();
118 return cast<ObjCMethodDecl>(D)->getReturnType();
121 static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) {
122 if (const auto *FD = dyn_cast<FunctionDecl>(D))
123 return FD->getReturnTypeSourceRange();
124 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
125 return MD->getReturnTypeSourceRange();
126 return SourceRange();
129 static bool isFunctionOrMethodVariadic(const Decl *D) {
130 if (const FunctionType *FnTy = D->getFunctionType())
131 return cast<FunctionProtoType>(FnTy)->isVariadic();
132 if (const auto *BD = dyn_cast<BlockDecl>(D))
133 return BD->isVariadic();
134 return cast<ObjCMethodDecl>(D)->isVariadic();
137 static bool isInstanceMethod(const Decl *D) {
138 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D))
139 return MethodDecl->isInstance();
143 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
144 const auto *PT = T->getAs<ObjCObjectPointerType>();
148 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
152 IdentifierInfo* ClsName = Cls->getIdentifier();
154 // FIXME: Should we walk the chain of classes?
155 return ClsName == &Ctx.Idents.get("NSString") ||
156 ClsName == &Ctx.Idents.get("NSMutableString");
159 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
160 const auto *PT = T->getAs<PointerType>();
164 const auto *RT = PT->getPointeeType()->getAs<RecordType>();
168 const RecordDecl *RD = RT->getDecl();
169 if (RD->getTagKind() != TTK_Struct)
172 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
175 static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
176 // FIXME: Include the type in the argument list.
177 return AL.getNumArgs() + AL.hasParsedType();
180 template <typename Compare>
181 static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
182 unsigned Num, unsigned Diag,
184 if (Comp(getNumAttributeArgs(AL), Num)) {
185 S.Diag(AL.getLoc(), Diag) << AL.getName() << Num;
192 /// Check if the attribute has exactly as many args as Num. May
194 static bool checkAttributeNumArgs(Sema &S, const ParsedAttr &AL, unsigned Num) {
195 return checkAttributeNumArgsImpl(S, AL, Num,
196 diag::err_attribute_wrong_number_arguments,
197 std::not_equal_to<unsigned>());
200 /// Check if the attribute has at least as many args as Num. May
202 static bool checkAttributeAtLeastNumArgs(Sema &S, const ParsedAttr &AL,
204 return checkAttributeNumArgsImpl(S, AL, Num,
205 diag::err_attribute_too_few_arguments,
206 std::less<unsigned>());
209 /// Check if the attribute has at most as many args as Num. May
211 static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
213 return checkAttributeNumArgsImpl(S, AL, Num,
214 diag::err_attribute_too_many_arguments,
215 std::greater<unsigned>());
218 /// A helper function to provide Attribute Location for the Attr types
219 /// AND the ParsedAttr.
220 template <typename AttrInfo>
221 static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
222 SourceLocation>::type
223 getAttrLoc(const AttrInfo &AL) {
224 return AL.getLocation();
226 static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
228 /// A helper function to provide Attribute Name for the Attr types
229 /// AND the ParsedAttr.
230 template <typename AttrInfo>
231 static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
232 const AttrInfo *>::type
233 getAttrName(const AttrInfo &AL) {
236 static const IdentifierInfo *getAttrName(const ParsedAttr &AL) {
240 /// If Expr is a valid integer constant, get the value of the integer
241 /// expression and return success or failure. May output an error.
242 template <typename AttrInfo>
243 static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
244 uint32_t &Val, unsigned Idx = UINT_MAX) {
246 if (Expr->isTypeDependent() || Expr->isValueDependent() ||
247 !Expr->isIntegerConstantExpr(I, S.Context)) {
249 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
250 << getAttrName(AI) << Idx << AANT_ArgumentIntegerConstant
251 << Expr->getSourceRange();
253 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type)
254 << getAttrName(AI) << AANT_ArgumentIntegerConstant
255 << Expr->getSourceRange();
260 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
261 << I.toString(10, false) << 32 << /* Unsigned */ 1;
265 Val = (uint32_t)I.getZExtValue();
269 /// Wrapper around checkUInt32Argument, with an extra check to be sure
270 /// that the result will fit into a regular (signed) int. All args have the same
271 /// purpose as they do in checkUInt32Argument.
272 template <typename AttrInfo>
273 static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
274 int &Val, unsigned Idx = UINT_MAX) {
276 if (!checkUInt32Argument(S, AI, Expr, UVal, Idx))
279 if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
280 llvm::APSInt I(32); // for toString
282 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
283 << I.toString(10, false) << 32 << /* Unsigned */ 0;
291 /// Diagnose mutually exclusive attributes when present on a given
292 /// declaration. Returns true if diagnosed.
293 template <typename AttrTy>
294 static bool checkAttrMutualExclusion(Sema &S, Decl *D, SourceRange Range,
295 IdentifierInfo *Ident) {
296 if (const auto *A = D->getAttr<AttrTy>()) {
297 S.Diag(Range.getBegin(), diag::err_attributes_are_not_compatible) << Ident
299 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
305 /// Check if IdxExpr is a valid parameter index for a function or
306 /// instance method D. May output an error.
308 /// \returns true if IdxExpr is a valid index.
309 template <typename AttrInfo>
310 static bool checkFunctionOrMethodParameterIndex(
311 Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum,
312 const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
313 assert(isFunctionOrMethodOrBlock(D));
315 // In C++ the implicit 'this' function parameter also counts.
316 // Parameters are counted from one.
317 bool HP = hasFunctionProto(D);
318 bool HasImplicitThisParam = isInstanceMethod(D);
319 bool IV = HP && isFunctionOrMethodVariadic(D);
321 (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
324 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
325 !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
326 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
327 << getAttrName(AI) << AttrArgNum << AANT_ArgumentIntegerConstant
328 << IdxExpr->getSourceRange();
332 unsigned IdxSource = IdxInt.getLimitedValue(UINT_MAX);
333 if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
334 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
335 << getAttrName(AI) << AttrArgNum << IdxExpr->getSourceRange();
338 if (HasImplicitThisParam && !CanIndexImplicitThis) {
339 if (IdxSource == 1) {
340 S.Diag(getAttrLoc(AI),
341 diag::err_attribute_invalid_implicit_this_argument)
342 << getAttrName(AI) << IdxExpr->getSourceRange();
347 Idx = ParamIdx(IdxSource, D);
351 /// Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
352 /// If not emit an error and return false. If the argument is an identifier it
353 /// will emit an error with a fixit hint and treat it as if it was a string
355 bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
357 SourceLocation *ArgLocation) {
358 // Look for identifiers. If we have one emit a hint to fix it to a literal.
359 if (AL.isArgIdent(ArgNum)) {
360 IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum);
361 Diag(Loc->Loc, diag::err_attribute_argument_type)
362 << AL.getName() << AANT_ArgumentString
363 << FixItHint::CreateInsertion(Loc->Loc, "\"")
364 << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
365 Str = Loc->Ident->getName();
367 *ArgLocation = Loc->Loc;
371 // Now check for an actual string literal.
372 Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
373 const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
375 *ArgLocation = ArgExpr->getLocStart();
377 if (!Literal || !Literal->isAscii()) {
378 Diag(ArgExpr->getLocStart(), diag::err_attribute_argument_type)
379 << AL.getName() << AANT_ArgumentString;
383 Str = Literal->getString();
387 /// Applies the given attribute to the Decl without performing any
388 /// additional semantic checking.
389 template <typename AttrType>
390 static void handleSimpleAttribute(Sema &S, Decl *D, const ParsedAttr &AL) {
391 D->addAttr(::new (S.Context) AttrType(AL.getRange(), S.Context,
392 AL.getAttributeSpellingListIndex()));
395 template <typename AttrType>
396 static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
397 const ParsedAttr &AL) {
398 handleSimpleAttribute<AttrType>(S, D, AL);
401 /// Applies the given attribute to the Decl so long as the Decl doesn't
402 /// already have one of the given incompatible attributes.
403 template <typename AttrType, typename IncompatibleAttrType,
404 typename... IncompatibleAttrTypes>
405 static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
406 const ParsedAttr &AL) {
407 if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, AL.getRange(),
410 handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
414 /// Check if the passed-in expression is of type int or bool.
415 static bool isIntOrBool(Expr *Exp) {
416 QualType QT = Exp->getType();
417 return QT->isBooleanType() || QT->isIntegerType();
421 // Check to see if the type is a smart pointer of some kind. We assume
422 // it's a smart pointer if it defines both operator-> and operator*.
423 static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
424 DeclContextLookupResult Res1 = RT->getDecl()->lookup(
425 S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
429 DeclContextLookupResult Res2 = RT->getDecl()->lookup(
430 S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
437 /// Check if passed in Decl is a pointer type.
438 /// Note that this function may produce an error message.
439 /// \return true if the Decl is a pointer type; false otherwise
440 static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
441 const ParsedAttr &AL) {
442 const auto *VD = cast<ValueDecl>(D);
443 QualType QT = VD->getType();
444 if (QT->isAnyPointerType())
447 if (const auto *RT = QT->getAs<RecordType>()) {
448 // If it's an incomplete type, it could be a smart pointer; skip it.
449 // (We don't want to force template instantiation if we can avoid it,
450 // since that would alter the order in which templates are instantiated.)
451 if (RT->isIncompleteType())
454 if (threadSafetyCheckIsSmartPointer(S, RT))
458 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
459 << AL.getName() << QT;
463 /// Checks that the passed in QualType either is of RecordType or points
464 /// to RecordType. Returns the relevant RecordType, null if it does not exit.
465 static const RecordType *getRecordType(QualType QT) {
466 if (const auto *RT = QT->getAs<RecordType>())
469 // Now check if we point to record type.
470 if (const auto *PT = QT->getAs<PointerType>())
471 return PT->getPointeeType()->getAs<RecordType>();
476 static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
477 const RecordType *RT = getRecordType(Ty);
482 // Don't check for the capability if the class hasn't been defined yet.
483 if (RT->isIncompleteType())
486 // Allow smart pointers to be used as capability objects.
487 // FIXME -- Check the type that the smart pointer points to.
488 if (threadSafetyCheckIsSmartPointer(S, RT))
491 // Check if the record itself has a capability.
492 RecordDecl *RD = RT->getDecl();
493 if (RD->hasAttr<CapabilityAttr>())
496 // Else check if any base classes have a capability.
497 if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
498 CXXBasePaths BPaths(false, false);
499 if (CRD->lookupInBases([](const CXXBaseSpecifier *BS, CXXBasePath &) {
500 const auto *Type = BS->getType()->getAs<RecordType>();
501 return Type->getDecl()->hasAttr<CapabilityAttr>();
508 static bool checkTypedefTypeForCapability(QualType Ty) {
509 const auto *TD = Ty->getAs<TypedefType>();
513 TypedefNameDecl *TN = TD->getDecl();
517 return TN->hasAttr<CapabilityAttr>();
520 static bool typeHasCapability(Sema &S, QualType Ty) {
521 if (checkTypedefTypeForCapability(Ty))
524 if (checkRecordTypeForCapability(S, Ty))
530 static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
531 // Capability expressions are simple expressions involving the boolean logic
532 // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
533 // a DeclRefExpr is found, its type should be checked to determine whether it
534 // is a capability or not.
536 if (const auto *E = dyn_cast<CastExpr>(Ex))
537 return isCapabilityExpr(S, E->getSubExpr());
538 else if (const auto *E = dyn_cast<ParenExpr>(Ex))
539 return isCapabilityExpr(S, E->getSubExpr());
540 else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
541 if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf ||
542 E->getOpcode() == UO_Deref)
543 return isCapabilityExpr(S, E->getSubExpr());
545 } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
546 if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
547 return isCapabilityExpr(S, E->getLHS()) &&
548 isCapabilityExpr(S, E->getRHS());
552 return typeHasCapability(S, Ex->getType());
555 /// Checks that all attribute arguments, starting from Sidx, resolve to
556 /// a capability object.
557 /// \param Sidx The attribute argument index to start checking with.
558 /// \param ParamIdxOk Whether an argument can be indexing into a function
560 static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
561 const ParsedAttr &AL,
562 SmallVectorImpl<Expr *> &Args,
564 bool ParamIdxOk = false) {
565 for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) {
566 Expr *ArgExp = AL.getArgAsExpr(Idx);
568 if (ArgExp->isTypeDependent()) {
569 // FIXME -- need to check this again on template instantiation
570 Args.push_back(ArgExp);
574 if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
575 if (StrLit->getLength() == 0 ||
576 (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
577 // Pass empty strings to the analyzer without warnings.
578 // Treat "*" as the universal lock.
579 Args.push_back(ArgExp);
583 // We allow constant strings to be used as a placeholder for expressions
584 // that are not valid C++ syntax, but warn that they are ignored.
585 S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL.getName();
586 Args.push_back(ArgExp);
590 QualType ArgTy = ArgExp->getType();
592 // A pointer to member expression of the form &MyClass::mu is treated
593 // specially -- we need to look at the type of the member.
594 if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
595 if (UOp->getOpcode() == UO_AddrOf)
596 if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
597 if (DRE->getDecl()->isCXXInstanceMember())
598 ArgTy = DRE->getDecl()->getType();
600 // First see if we can just cast to record type, or pointer to record type.
601 const RecordType *RT = getRecordType(ArgTy);
603 // Now check if we index into a record type function param.
604 if(!RT && ParamIdxOk) {
605 const auto *FD = dyn_cast<FunctionDecl>(D);
606 const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
608 unsigned int NumParams = FD->getNumParams();
609 llvm::APInt ArgValue = IL->getValue();
610 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
611 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
612 if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
613 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
614 << AL.getName() << Idx + 1 << NumParams;
617 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
621 // If the type does not have a capability, see if the components of the
622 // expression have capabilities. This allows for writing C code where the
623 // capability may be on the type, and the expression is a capability
624 // boolean logic expression. Eg) requires_capability(A || B && !C)
625 if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
626 S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
627 << AL.getName() << ArgTy;
629 Args.push_back(ArgExp);
633 //===----------------------------------------------------------------------===//
634 // Attribute Implementations
635 //===----------------------------------------------------------------------===//
637 static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
638 if (!threadSafetyCheckIsPointer(S, D, AL))
641 D->addAttr(::new (S.Context)
642 PtGuardedVarAttr(AL.getRange(), S.Context,
643 AL.getAttributeSpellingListIndex()));
646 static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
648 SmallVector<Expr *, 1> Args;
649 // check that all arguments are lockable objects
650 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
651 unsigned Size = Args.size();
660 static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
662 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
665 D->addAttr(::new (S.Context) GuardedByAttr(
666 AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
669 static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
671 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
674 if (!threadSafetyCheckIsPointer(S, D, AL))
677 D->addAttr(::new (S.Context) PtGuardedByAttr(
678 AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
681 static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
682 SmallVectorImpl<Expr *> &Args) {
683 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
686 // Check that this attribute only applies to lockable types.
687 QualType QT = cast<ValueDecl>(D)->getType();
688 if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
689 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
694 // Check that all arguments are lockable objects.
695 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
702 static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
703 SmallVector<Expr *, 1> Args;
704 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
707 Expr **StartArg = &Args[0];
708 D->addAttr(::new (S.Context) AcquiredAfterAttr(
709 AL.getRange(), S.Context, StartArg, Args.size(),
710 AL.getAttributeSpellingListIndex()));
713 static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
714 SmallVector<Expr *, 1> Args;
715 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
718 Expr **StartArg = &Args[0];
719 D->addAttr(::new (S.Context) AcquiredBeforeAttr(
720 AL.getRange(), S.Context, StartArg, Args.size(),
721 AL.getAttributeSpellingListIndex()));
724 static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
725 SmallVectorImpl<Expr *> &Args) {
726 // zero or more arguments ok
727 // check that all arguments are lockable objects
728 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true);
733 static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
734 SmallVector<Expr *, 1> Args;
735 if (!checkLockFunAttrCommon(S, D, AL, Args))
738 unsigned Size = Args.size();
739 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
740 D->addAttr(::new (S.Context)
741 AssertSharedLockAttr(AL.getRange(), S.Context, StartArg, Size,
742 AL.getAttributeSpellingListIndex()));
745 static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
746 const ParsedAttr &AL) {
747 SmallVector<Expr *, 1> Args;
748 if (!checkLockFunAttrCommon(S, D, AL, Args))
751 unsigned Size = Args.size();
752 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
753 D->addAttr(::new (S.Context) AssertExclusiveLockAttr(
754 AL.getRange(), S.Context, StartArg, Size,
755 AL.getAttributeSpellingListIndex()));
758 /// Checks to be sure that the given parameter number is in bounds, and
759 /// is an integral type. Will emit appropriate diagnostics if this returns
762 /// AttrArgNo is used to actually retrieve the argument, so it's base-0.
763 template <typename AttrInfo>
764 static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
765 const AttrInfo &AI, unsigned AttrArgNo) {
766 assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument");
767 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
769 if (!checkFunctionOrMethodParameterIndex(S, FD, AI, AttrArgNo + 1, AttrArg,
773 const ParmVarDecl *Param = FD->getParamDecl(Idx.getASTIndex());
774 if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
775 SourceLocation SrcLoc = AttrArg->getLocStart();
776 S.Diag(SrcLoc, diag::err_attribute_integers_only)
777 << getAttrName(AI) << Param->getSourceRange();
783 static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
784 if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
785 !checkAttributeAtMostNumArgs(S, AL, 2))
788 const auto *FD = cast<FunctionDecl>(D);
789 if (!FD->getReturnType()->isPointerType()) {
790 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
795 const Expr *SizeExpr = AL.getArgAsExpr(0);
797 // Parameter indices are 1-indexed, hence Index=1
798 if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Index=*/1))
800 if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/0))
802 ParamIdx SizeArgNo(SizeArgNoVal, D);
804 ParamIdx NumberArgNo;
805 if (AL.getNumArgs() == 2) {
806 const Expr *NumberExpr = AL.getArgAsExpr(1);
808 // Parameter indices are 1-based, hence Index=2
809 if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Index=*/2))
811 if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/1))
813 NumberArgNo = ParamIdx(Val, D);
816 D->addAttr(::new (S.Context)
817 AllocSizeAttr(AL.getRange(), S.Context, SizeArgNo, NumberArgNo,
818 AL.getAttributeSpellingListIndex()));
821 static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
822 SmallVectorImpl<Expr *> &Args) {
823 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
826 if (!isIntOrBool(AL.getArgAsExpr(0))) {
827 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
828 << AL.getName() << 1 << AANT_ArgumentIntOrBool;
832 // check that all arguments are lockable objects
833 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1);
838 static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
839 const ParsedAttr &AL) {
840 SmallVector<Expr*, 2> Args;
841 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
844 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(
845 AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(), Args.size(),
846 AL.getAttributeSpellingListIndex()));
849 static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
850 const ParsedAttr &AL) {
851 SmallVector<Expr*, 2> Args;
852 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
855 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
856 AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(),
857 Args.size(), AL.getAttributeSpellingListIndex()));
860 static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
861 // check that the argument is lockable object
862 SmallVector<Expr*, 1> Args;
863 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
864 unsigned Size = Args.size();
868 D->addAttr(::new (S.Context)
869 LockReturnedAttr(AL.getRange(), S.Context, Args[0],
870 AL.getAttributeSpellingListIndex()));
873 static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
874 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
877 // check that all arguments are lockable objects
878 SmallVector<Expr*, 1> Args;
879 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
880 unsigned Size = Args.size();
883 Expr **StartArg = &Args[0];
885 D->addAttr(::new (S.Context)
886 LocksExcludedAttr(AL.getRange(), S.Context, StartArg, Size,
887 AL.getAttributeSpellingListIndex()));
890 static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
891 Expr *&Cond, StringRef &Msg) {
892 Cond = AL.getArgAsExpr(0);
893 if (!Cond->isTypeDependent()) {
894 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
895 if (Converted.isInvalid())
897 Cond = Converted.get();
900 if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg))
904 Msg = "<no message provided>";
906 SmallVector<PartialDiagnosticAt, 8> Diags;
907 if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
908 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
910 S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr)
912 for (const PartialDiagnosticAt &PDiag : Diags)
913 S.Diag(PDiag.first, PDiag.second);
919 static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
920 S.Diag(AL.getLoc(), diag::ext_clang_enable_if);
924 if (checkFunctionConditionAttr(S, D, AL, Cond, Msg))
925 D->addAttr(::new (S.Context)
926 EnableIfAttr(AL.getRange(), S.Context, Cond, Msg,
927 AL.getAttributeSpellingListIndex()));
931 /// Determines if a given Expr references any of the given function's
932 /// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
933 class ArgumentDependenceChecker
934 : public RecursiveASTVisitor<ArgumentDependenceChecker> {
936 const CXXRecordDecl *ClassType;
938 llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
942 ArgumentDependenceChecker(const FunctionDecl *FD) {
944 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
945 ClassType = MD->getParent();
949 Parms.insert(FD->param_begin(), FD->param_end());
952 bool referencesArgs(Expr *E) {
958 bool VisitCXXThisExpr(CXXThisExpr *E) {
959 assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&
960 "`this` doesn't refer to the enclosing class?");
965 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
966 if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
967 if (Parms.count(PVD)) {
976 static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
977 S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);
981 if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg))
984 StringRef DiagTypeStr;
985 if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr))
988 DiagnoseIfAttr::DiagnosticType DiagType;
989 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
990 S.Diag(AL.getArgAsExpr(2)->getLocStart(),
991 diag::err_diagnose_if_invalid_diagnostic_type);
995 bool ArgDependent = false;
996 if (const auto *FD = dyn_cast<FunctionDecl>(D))
997 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
998 D->addAttr(::new (S.Context) DiagnoseIfAttr(
999 AL.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent,
1000 cast<NamedDecl>(D), AL.getAttributeSpellingListIndex()));
1003 static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1004 if (D->hasAttr<PassObjectSizeAttr>()) {
1005 S.Diag(D->getLocStart(), diag::err_attribute_only_once_per_parameter)
1010 Expr *E = AL.getArgAsExpr(0);
1012 if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1))
1015 // pass_object_size's argument is passed in as the second argument of
1016 // __builtin_object_size. So, it has the same constraints as that second
1017 // argument; namely, it must be in the range [0, 3].
1019 S.Diag(E->getLocStart(), diag::err_attribute_argument_outof_range)
1020 << AL.getName() << 0 << 3 << E->getSourceRange();
1024 // pass_object_size is only supported on constant pointer parameters; as a
1025 // kindness to users, we allow the parameter to be non-const for declarations.
1026 // At this point, we have no clue if `D` belongs to a function declaration or
1027 // definition, so we defer the constness check until later.
1028 if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1029 S.Diag(D->getLocStart(), diag::err_attribute_pointers_only)
1030 << AL.getName() << 1;
1034 D->addAttr(::new (S.Context) PassObjectSizeAttr(
1035 AL.getRange(), S.Context, (int)Type, AL.getAttributeSpellingListIndex()));
1038 static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1039 ConsumableAttr::ConsumedState DefaultState;
1041 if (AL.isArgIdent(0)) {
1042 IdentifierLoc *IL = AL.getArgAsIdent(0);
1043 if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1045 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1046 << AL.getName() << IL->Ident;
1050 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1051 << AL.getName() << AANT_ArgumentIdentifier;
1055 D->addAttr(::new (S.Context)
1056 ConsumableAttr(AL.getRange(), S.Context, DefaultState,
1057 AL.getAttributeSpellingListIndex()));
1060 static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
1061 const ParsedAttr &AL) {
1062 ASTContext &CurrContext = S.getASTContext();
1063 QualType ThisType = MD->getThisType(CurrContext)->getPointeeType();
1065 if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1066 if (!RD->hasAttr<ConsumableAttr>()) {
1067 S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) <<
1068 RD->getNameAsString();
1077 static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1078 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1081 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1084 SmallVector<CallableWhenAttr::ConsumedState, 3> States;
1085 for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
1086 CallableWhenAttr::ConsumedState CallableState;
1088 StringRef StateString;
1090 if (AL.isArgIdent(ArgIndex)) {
1091 IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
1092 StateString = Ident->Ident->getName();
1095 if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc))
1099 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1101 S.Diag(Loc, diag::warn_attribute_type_not_supported)
1102 << AL.getName() << StateString;
1106 States.push_back(CallableState);
1109 D->addAttr(::new (S.Context)
1110 CallableWhenAttr(AL.getRange(), S.Context, States.data(),
1111 States.size(), AL.getAttributeSpellingListIndex()));
1114 static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1115 ParamTypestateAttr::ConsumedState ParamState;
1117 if (AL.isArgIdent(0)) {
1118 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1119 StringRef StateString = Ident->Ident->getName();
1121 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1123 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1124 << AL.getName() << StateString;
1128 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) <<
1129 AL.getName() << AANT_ArgumentIdentifier;
1133 // FIXME: This check is currently being done in the analysis. It can be
1134 // enabled here only after the parser propagates attributes at
1135 // template specialization definition, not declaration.
1136 //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1137 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1139 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1140 // S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1141 // ReturnType.getAsString();
1145 D->addAttr(::new (S.Context)
1146 ParamTypestateAttr(AL.getRange(), S.Context, ParamState,
1147 AL.getAttributeSpellingListIndex()));
1150 static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1151 ReturnTypestateAttr::ConsumedState ReturnState;
1153 if (AL.isArgIdent(0)) {
1154 IdentifierLoc *IL = AL.getArgAsIdent(0);
1155 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1157 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1158 << AL.getName() << IL->Ident;
1162 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) <<
1163 AL.getName() << AANT_ArgumentIdentifier;
1167 // FIXME: This check is currently being done in the analysis. It can be
1168 // enabled here only after the parser propagates attributes at
1169 // template specialization definition, not declaration.
1170 //QualType ReturnType;
1172 //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1173 // ReturnType = Param->getType();
1175 //} else if (const CXXConstructorDecl *Constructor =
1176 // dyn_cast<CXXConstructorDecl>(D)) {
1177 // ReturnType = Constructor->getThisType(S.getASTContext())->getPointeeType();
1181 // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1184 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1186 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1187 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1188 // ReturnType.getAsString();
1192 D->addAttr(::new (S.Context)
1193 ReturnTypestateAttr(AL.getRange(), S.Context, ReturnState,
1194 AL.getAttributeSpellingListIndex()));
1197 static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1198 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1201 SetTypestateAttr::ConsumedState NewState;
1202 if (AL.isArgIdent(0)) {
1203 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1204 StringRef Param = Ident->Ident->getName();
1205 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1206 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1207 << AL.getName() << Param;
1211 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) <<
1212 AL.getName() << AANT_ArgumentIdentifier;
1216 D->addAttr(::new (S.Context)
1217 SetTypestateAttr(AL.getRange(), S.Context, NewState,
1218 AL.getAttributeSpellingListIndex()));
1221 static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1222 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1225 TestTypestateAttr::ConsumedState TestState;
1226 if (AL.isArgIdent(0)) {
1227 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1228 StringRef Param = Ident->Ident->getName();
1229 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1230 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1231 << AL.getName() << Param;
1235 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) <<
1236 AL.getName() << AANT_ArgumentIdentifier;
1240 D->addAttr(::new (S.Context)
1241 TestTypestateAttr(AL.getRange(), S.Context, TestState,
1242 AL.getAttributeSpellingListIndex()));
1245 static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1246 // Remember this typedef decl, we will need it later for diagnostics.
1247 S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1250 static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1251 if (auto *TD = dyn_cast<TagDecl>(D))
1252 TD->addAttr(::new (S.Context) PackedAttr(AL.getRange(), S.Context,
1253 AL.getAttributeSpellingListIndex()));
1254 else if (auto *FD = dyn_cast<FieldDecl>(D)) {
1255 bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
1256 !FD->getType()->isIncompleteType() &&
1258 S.Context.getTypeAlign(FD->getType()) <= 8);
1260 if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
1261 if (BitfieldByteAligned)
1262 // The PS4 target needs to maintain ABI backwards compatibility.
1263 S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1264 << AL.getName() << FD->getType();
1266 FD->addAttr(::new (S.Context) PackedAttr(
1267 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1269 // Report warning about changed offset in the newer compiler versions.
1270 if (BitfieldByteAligned)
1271 S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);
1273 FD->addAttr(::new (S.Context) PackedAttr(
1274 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1278 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL.getName();
1281 static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
1282 // The IBOutlet/IBOutletCollection attributes only apply to instance
1283 // variables or properties of Objective-C classes. The outlet must also
1284 // have an object reference type.
1285 if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {
1286 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1287 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1288 << AL.getName() << VD->getType() << 0;
1292 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1293 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1294 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1295 << AL.getName() << PD->getType() << 1;
1300 S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL.getName();
1307 static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
1308 if (!checkIBOutletCommon(S, D, AL))
1311 D->addAttr(::new (S.Context)
1312 IBOutletAttr(AL.getRange(), S.Context,
1313 AL.getAttributeSpellingListIndex()));
1316 static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {
1318 // The iboutletcollection attribute can have zero or one arguments.
1319 if (AL.getNumArgs() > 1) {
1320 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
1321 << AL.getName() << 1;
1325 if (!checkIBOutletCommon(S, D, AL))
1330 if (AL.hasParsedType())
1331 PT = AL.getTypeArg();
1333 PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(),
1334 S.getScopeForContext(D->getDeclContext()->getParent()));
1336 S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1341 TypeSourceInfo *QTLoc = nullptr;
1342 QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1344 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc());
1346 // Diagnose use of non-object type in iboutletcollection attribute.
1347 // FIXME. Gnu attribute extension ignores use of builtin types in
1348 // attributes. So, __attribute__((iboutletcollection(char))) will be
1349 // treated as __attribute__((iboutletcollection())).
1350 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1352 QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1353 : diag::err_iboutletcollection_type) << QT;
1357 D->addAttr(::new (S.Context)
1358 IBOutletCollectionAttr(AL.getRange(), S.Context, QTLoc,
1359 AL.getAttributeSpellingListIndex()));
1362 bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) {
1364 if (T->isReferenceType())
1367 T = T.getNonReferenceType();
1370 // The nonnull attribute, and other similar attributes, can be applied to a
1371 // transparent union that contains a pointer type.
1372 if (const RecordType *UT = T->getAsUnionType()) {
1373 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1374 RecordDecl *UD = UT->getDecl();
1375 for (const auto *I : UD->fields()) {
1376 QualType QT = I->getType();
1377 if (QT->isAnyPointerType() || QT->isBlockPointerType())
1383 return T->isAnyPointerType() || T->isBlockPointerType();
1386 static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
1387 SourceRange AttrParmRange,
1388 SourceRange TypeRange,
1389 bool isReturnValue = false) {
1390 if (!S.isValidPointerAttrType(T)) {
1392 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1393 << AL.getName() << AttrParmRange << TypeRange;
1395 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1396 << AL.getName() << AttrParmRange << TypeRange << 0;
1402 static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1403 SmallVector<ParamIdx, 8> NonNullArgs;
1404 for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
1405 Expr *Ex = AL.getArgAsExpr(I);
1407 if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx))
1410 // Is the function argument a pointer type?
1411 if (Idx.getASTIndex() < getFunctionOrMethodNumParams(D) &&
1412 !attrNonNullArgCheck(
1413 S, getFunctionOrMethodParamType(D, Idx.getASTIndex()), AL,
1414 Ex->getSourceRange(),
1415 getFunctionOrMethodParamRange(D, Idx.getASTIndex())))
1418 NonNullArgs.push_back(Idx);
1421 // If no arguments were specified to __attribute__((nonnull)) then all pointer
1422 // arguments have a nonnull attribute; warn if there aren't any. Skip this
1423 // check if the attribute came from a macro expansion or a template
1425 if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
1426 !S.inTemplateInstantiation()) {
1427 bool AnyPointers = isFunctionOrMethodVariadic(D);
1428 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1429 I != E && !AnyPointers; ++I) {
1430 QualType T = getFunctionOrMethodParamType(D, I);
1431 if (T->isDependentType() || S.isValidPointerAttrType(T))
1436 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1439 ParamIdx *Start = NonNullArgs.data();
1440 unsigned Size = NonNullArgs.size();
1441 llvm::array_pod_sort(Start, Start + Size);
1442 D->addAttr(::new (S.Context)
1443 NonNullAttr(AL.getRange(), S.Context, Start, Size,
1444 AL.getAttributeSpellingListIndex()));
1447 static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
1448 const ParsedAttr &AL) {
1449 if (AL.getNumArgs() > 0) {
1450 if (D->getFunctionType()) {
1451 handleNonNullAttr(S, D, AL);
1453 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1454 << D->getSourceRange();
1459 // Is the argument a pointer type?
1460 if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(),
1461 D->getSourceRange()))
1464 D->addAttr(::new (S.Context)
1465 NonNullAttr(AL.getRange(), S.Context, nullptr, 0,
1466 AL.getAttributeSpellingListIndex()));
1469 static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1470 QualType ResultType = getFunctionOrMethodResultType(D);
1471 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1472 if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
1473 /* isReturnValue */ true))
1476 D->addAttr(::new (S.Context)
1477 ReturnsNonNullAttr(AL.getRange(), S.Context,
1478 AL.getAttributeSpellingListIndex()));
1481 static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1482 if (D->isInvalidDecl())
1485 // noescape only applies to pointer types.
1486 QualType T = cast<ParmVarDecl>(D)->getType();
1487 if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
1488 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1489 << AL.getName() << AL.getRange() << 0;
1493 D->addAttr(::new (S.Context) NoEscapeAttr(
1494 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1497 static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1498 Expr *E = AL.getArgAsExpr(0),
1499 *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
1500 S.AddAssumeAlignedAttr(AL.getRange(), D, E, OE,
1501 AL.getAttributeSpellingListIndex());
1504 static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1505 S.AddAllocAlignAttr(AL.getRange(), D, AL.getArgAsExpr(0),
1506 AL.getAttributeSpellingListIndex());
1509 void Sema::AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
1510 Expr *OE, unsigned SpellingListIndex) {
1511 QualType ResultType = getFunctionOrMethodResultType(D);
1512 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1514 AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1515 SourceLocation AttrLoc = AttrRange.getBegin();
1517 if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1518 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1519 << &TmpAttr << AttrRange << SR;
1523 if (!E->isValueDependent()) {
1525 if (!E->isIntegerConstantExpr(I, Context)) {
1527 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1528 << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1529 << E->getSourceRange();
1531 Diag(AttrLoc, diag::err_attribute_argument_type)
1532 << &TmpAttr << AANT_ArgumentIntegerConstant
1533 << E->getSourceRange();
1537 if (!I.isPowerOf2()) {
1538 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1539 << E->getSourceRange();
1545 if (!OE->isValueDependent()) {
1547 if (!OE->isIntegerConstantExpr(I, Context)) {
1548 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1549 << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1550 << OE->getSourceRange();
1556 D->addAttr(::new (Context)
1557 AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1560 void Sema::AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
1561 unsigned SpellingListIndex) {
1562 QualType ResultType = getFunctionOrMethodResultType(D);
1564 AllocAlignAttr TmpAttr(AttrRange, Context, ParamIdx(), SpellingListIndex);
1565 SourceLocation AttrLoc = AttrRange.getBegin();
1567 if (!ResultType->isDependentType() &&
1568 !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1569 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1570 << &TmpAttr << AttrRange << getFunctionOrMethodResultSourceRange(D);
1575 const auto *FuncDecl = cast<FunctionDecl>(D);
1576 if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1577 /*AttrArgNo=*/1, ParamExpr, Idx))
1580 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
1581 if (!Ty->isDependentType() && !Ty->isIntegralType(Context)) {
1582 Diag(ParamExpr->getLocStart(), diag::err_attribute_integers_only)
1584 << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
1588 D->addAttr(::new (Context)
1589 AllocAlignAttr(AttrRange, Context, Idx, SpellingListIndex));
1592 /// Normalize the attribute, __foo__ becomes foo.
1593 /// Returns true if normalization was applied.
1594 static bool normalizeName(StringRef &AttrName) {
1595 if (AttrName.size() > 4 && AttrName.startswith("__") &&
1596 AttrName.endswith("__")) {
1597 AttrName = AttrName.drop_front(2).drop_back(2);
1603 static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1604 // This attribute must be applied to a function declaration. The first
1605 // argument to the attribute must be an identifier, the name of the resource,
1606 // for example: malloc. The following arguments must be argument indexes, the
1607 // arguments must be of integer type for Returns, otherwise of pointer type.
1608 // The difference between Holds and Takes is that a pointer may still be used
1609 // after being held. free() should be __attribute((ownership_takes)), whereas
1610 // a list append function may well be __attribute((ownership_holds)).
1612 if (!AL.isArgIdent(0)) {
1613 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1614 << AL.getName() << 1 << AANT_ArgumentIdentifier;
1618 // Figure out our Kind.
1619 OwnershipAttr::OwnershipKind K =
1620 OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1621 AL.getAttributeSpellingListIndex()).getOwnKind();
1625 case OwnershipAttr::Takes:
1626 case OwnershipAttr::Holds:
1627 if (AL.getNumArgs() < 2) {
1628 S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments)
1629 << AL.getName() << 2;
1633 case OwnershipAttr::Returns:
1634 if (AL.getNumArgs() > 2) {
1635 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
1636 << AL.getName() << 1;
1642 IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident;
1644 StringRef ModuleName = Module->getName();
1645 if (normalizeName(ModuleName)) {
1646 Module = &S.PP.getIdentifierTable().get(ModuleName);
1649 SmallVector<ParamIdx, 8> OwnershipArgs;
1650 for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1651 Expr *Ex = AL.getArgAsExpr(i);
1653 if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1656 // Is the function argument a pointer type?
1657 QualType T = getFunctionOrMethodParamType(D, Idx.getASTIndex());
1658 int Err = -1; // No error
1660 case OwnershipAttr::Takes:
1661 case OwnershipAttr::Holds:
1662 if (!T->isAnyPointerType() && !T->isBlockPointerType())
1665 case OwnershipAttr::Returns:
1666 if (!T->isIntegerType())
1671 S.Diag(AL.getLoc(), diag::err_ownership_type) << AL.getName() << Err
1672 << Ex->getSourceRange();
1676 // Check we don't have a conflict with another ownership attribute.
1677 for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1678 // Cannot have two ownership attributes of different kinds for the same
1680 if (I->getOwnKind() != K && I->args_end() !=
1681 std::find(I->args_begin(), I->args_end(), Idx)) {
1682 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1683 << AL.getName() << I;
1685 } else if (K == OwnershipAttr::Returns &&
1686 I->getOwnKind() == OwnershipAttr::Returns) {
1687 // A returns attribute conflicts with any other returns attribute using
1688 // a different index.
1689 if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1690 S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1691 << I->args_begin()->getSourceIndex();
1693 S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1694 << Idx.getSourceIndex() << Ex->getSourceRange();
1699 OwnershipArgs.push_back(Idx);
1702 ParamIdx *Start = OwnershipArgs.data();
1703 unsigned Size = OwnershipArgs.size();
1704 llvm::array_pod_sort(Start, Start + Size);
1705 D->addAttr(::new (S.Context)
1706 OwnershipAttr(AL.getLoc(), S.Context, Module, Start, Size,
1707 AL.getAttributeSpellingListIndex()));
1710 static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1711 // Check the attribute arguments.
1712 if (AL.getNumArgs() > 1) {
1713 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
1714 << AL.getName() << 1;
1720 // static int a __attribute__((weakref ("v2")));
1721 // static int b() __attribute__((weakref ("f3")));
1723 // and ignores the attributes of
1725 // static int a __attribute__((weakref ("v2")));
1728 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1729 if (!Ctx->isFileContext()) {
1730 S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context)
1731 << cast<NamedDecl>(D);
1735 // The GCC manual says
1737 // At present, a declaration to which `weakref' is attached can only
1742 // Without a TARGET,
1743 // given as an argument to `weakref' or to `alias', `weakref' is
1744 // equivalent to `weak'.
1746 // gcc 4.4.1 will accept
1747 // int a7 __attribute__((weakref));
1749 // int a7 __attribute__((weak));
1750 // This looks like a bug in gcc. We reject that for now. We should revisit
1751 // it if this behaviour is actually used.
1754 // static ((alias ("y"), weakref)).
1755 // Should we? How to check that weakref is before or after alias?
1757 // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1758 // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1759 // StringRef parameter it was given anyway.
1761 if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str))
1762 // GCC will accept anything as the argument of weakref. Should we
1763 // check for an existing decl?
1764 D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,
1765 AL.getAttributeSpellingListIndex()));
1767 D->addAttr(::new (S.Context)
1768 WeakRefAttr(AL.getRange(), S.Context,
1769 AL.getAttributeSpellingListIndex()));
1772 static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1774 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1777 // Aliases should be on declarations, not definitions.
1778 const auto *FD = cast<FunctionDecl>(D);
1779 if (FD->isThisDeclarationADefinition()) {
1780 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;
1784 D->addAttr(::new (S.Context) IFuncAttr(AL.getRange(), S.Context, Str,
1785 AL.getAttributeSpellingListIndex()));
1788 static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1790 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1793 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1794 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);
1797 if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
1798 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);
1801 // Aliases should be on declarations, not definitions.
1802 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
1803 if (FD->isThisDeclarationADefinition()) {
1804 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;
1808 const auto *VD = cast<VarDecl>(D);
1809 if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1810 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;
1815 // FIXME: check if target symbol exists in current file
1817 D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,
1818 AL.getAttributeSpellingListIndex()));
1821 static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1823 SourceLocation LiteralLoc;
1824 // Check that it is a string.
1825 if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc))
1828 // Check that the value.
1829 if (Model != "global-dynamic" && Model != "local-dynamic"
1830 && Model != "initial-exec" && Model != "local-exec") {
1831 S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1835 D->addAttr(::new (S.Context)
1836 TLSModelAttr(AL.getRange(), S.Context, Model,
1837 AL.getAttributeSpellingListIndex()));
1840 static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1841 QualType ResultType = getFunctionOrMethodResultType(D);
1842 if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1843 D->addAttr(::new (S.Context) RestrictAttr(
1844 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1848 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1849 << AL.getName() << getFunctionOrMethodResultSourceRange(D);
1852 static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1853 FunctionDecl *FD = cast<FunctionDecl>(D);
1854 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1857 SmallVector<IdentifierInfo *, 8> CPUs;
1858 for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {
1859 if (!AL.isArgIdent(ArgNo)) {
1860 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1861 << AL.getName() << AANT_ArgumentIdentifier;
1865 IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo);
1866 StringRef CPUName = CPUArg->Ident->getName().trim();
1868 if (!S.Context.getTargetInfo().validateCPUSpecificCPUDispatch(CPUName)) {
1869 S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value)
1870 << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch);
1874 const TargetInfo &Target = S.Context.getTargetInfo();
1875 if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) {
1876 return Target.CPUSpecificManglingCharacter(CPUName) ==
1877 Target.CPUSpecificManglingCharacter(Cur->getName());
1879 S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);
1882 CPUs.push_back(CPUArg->Ident);
1885 FD->setIsMultiVersion(true);
1886 if (AL.getKind() == ParsedAttr::AT_CPUSpecific)
1887 D->addAttr(::new (S.Context) CPUSpecificAttr(
1888 AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
1889 AL.getAttributeSpellingListIndex()));
1891 D->addAttr(::new (S.Context) CPUDispatchAttr(
1892 AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
1893 AL.getAttributeSpellingListIndex()));
1896 static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1897 if (S.LangOpts.CPlusPlus) {
1898 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
1899 << AL.getName() << AttributeLangSupport::Cpp;
1903 if (CommonAttr *CA = S.mergeCommonAttr(D, AL.getRange(), AL.getName(),
1904 AL.getAttributeSpellingListIndex()))
1908 static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1909 if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, AL.getRange(),
1913 if (AL.isDeclspecAttribute()) {
1914 const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
1915 const auto &Arch = Triple.getArch();
1916 if (Arch != llvm::Triple::x86 &&
1917 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
1918 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch)
1919 << AL.getName() << Triple.getArchName();
1924 D->addAttr(::new (S.Context) NakedAttr(AL.getRange(), S.Context,
1925 AL.getAttributeSpellingListIndex()));
1928 static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
1929 if (hasDeclarator(D)) return;
1931 if (!isa<ObjCMethodDecl>(D)) {
1932 S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
1933 << Attrs.getName() << ExpectedFunctionOrMethod;
1937 D->addAttr(::new (S.Context) NoReturnAttr(
1938 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
1941 static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
1942 if (!S.getLangOpts().CFProtectionBranch)
1943 S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
1945 handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
1948 bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
1949 if (!checkAttributeNumArgs(*this, Attrs, 0)) {
1957 bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
1958 // Check whether the attribute is valid on the current target.
1959 if (!AL.existsInTarget(Context.getTargetInfo())) {
1960 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL.getName();
1968 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1970 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
1971 // because 'analyzer_noreturn' does not impact the type.
1972 if (!isFunctionOrMethodOrBlock(D)) {
1973 ValueDecl *VD = dyn_cast<ValueDecl>(D);
1974 if (!VD || (!VD->getType()->isBlockPointerType() &&
1975 !VD->getType()->isFunctionPointerType())) {
1977 AL.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
1978 : diag::warn_attribute_wrong_decl_type)
1979 << AL.getName() << ExpectedFunctionMethodOrBlock;
1984 D->addAttr(::new (S.Context)
1985 AnalyzerNoReturnAttr(AL.getRange(), S.Context,
1986 AL.getAttributeSpellingListIndex()));
1989 // PS3 PPU-specific.
1990 static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1992 Returning a Vector Class in Registers
1994 According to the PPU ABI specifications, a class with a single member of
1995 vector type is returned in memory when used as the return value of a
1997 This results in inefficient code when implementing vector classes. To return
1998 the value in a single vector register, add the vecreturn attribute to the
1999 class definition. This attribute is also applicable to struct types.
2005 __vector float xyzw;
2006 } __attribute__((vecreturn));
2008 Vector Add(Vector lhs, Vector rhs)
2011 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2012 return result; // This will be returned in a register
2015 if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2016 S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
2020 const auto *R = cast<RecordDecl>(D);
2023 if (!isa<CXXRecordDecl>(R)) {
2024 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2028 if (!cast<CXXRecordDecl>(R)->isPOD()) {
2029 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2033 for (const auto *I : R->fields()) {
2034 if ((count == 1) || !I->getType()->isVectorType()) {
2035 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2041 D->addAttr(::new (S.Context) VecReturnAttr(
2042 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
2045 static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
2046 const ParsedAttr &AL) {
2047 if (isa<ParmVarDecl>(D)) {
2048 // [[carries_dependency]] can only be applied to a parameter if it is a
2049 // parameter of a function declaration or lambda.
2050 if (!(Scope->getFlags() & clang::Scope::FunctionDeclarationScope)) {
2052 diag::err_carries_dependency_param_not_function_decl);
2057 D->addAttr(::new (S.Context) CarriesDependencyAttr(
2058 AL.getRange(), S.Context,
2059 AL.getAttributeSpellingListIndex()));
2062 static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2063 bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();
2065 // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2066 // about using it as an extension.
2067 if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr)
2068 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL.getName();
2070 D->addAttr(::new (S.Context) UnusedAttr(
2071 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
2074 static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2075 uint32_t priority = ConstructorAttr::DefaultPriority;
2076 if (AL.getNumArgs() &&
2077 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2080 D->addAttr(::new (S.Context)
2081 ConstructorAttr(AL.getRange(), S.Context, priority,
2082 AL.getAttributeSpellingListIndex()));
2085 static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2086 uint32_t priority = DestructorAttr::DefaultPriority;
2087 if (AL.getNumArgs() &&
2088 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2091 D->addAttr(::new (S.Context)
2092 DestructorAttr(AL.getRange(), S.Context, priority,
2093 AL.getAttributeSpellingListIndex()));
2096 template <typename AttrTy>
2097 static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
2098 // Handle the case where the attribute has a text message.
2100 if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
2103 D->addAttr(::new (S.Context) AttrTy(AL.getRange(), S.Context, Str,
2104 AL.getAttributeSpellingListIndex()));
2107 static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
2108 const ParsedAttr &AL) {
2109 if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2110 S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2111 << AL.getName() << AL.getRange();
2115 D->addAttr(::new (S.Context)
2116 ObjCExplicitProtocolImplAttr(AL.getRange(), S.Context,
2117 AL.getAttributeSpellingListIndex()));
2120 static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
2121 IdentifierInfo *Platform,
2122 VersionTuple Introduced,
2123 VersionTuple Deprecated,
2124 VersionTuple Obsoleted) {
2125 StringRef PlatformName
2126 = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2127 if (PlatformName.empty())
2128 PlatformName = Platform->getName();
2130 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2131 // of these steps are needed).
2132 if (!Introduced.empty() && !Deprecated.empty() &&
2133 !(Introduced <= Deprecated)) {
2134 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2135 << 1 << PlatformName << Deprecated.getAsString()
2136 << 0 << Introduced.getAsString();
2140 if (!Introduced.empty() && !Obsoleted.empty() &&
2141 !(Introduced <= Obsoleted)) {
2142 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2143 << 2 << PlatformName << Obsoleted.getAsString()
2144 << 0 << Introduced.getAsString();
2148 if (!Deprecated.empty() && !Obsoleted.empty() &&
2149 !(Deprecated <= Obsoleted)) {
2150 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2151 << 2 << PlatformName << Obsoleted.getAsString()
2152 << 1 << Deprecated.getAsString();
2159 /// Check whether the two versions match.
2161 /// If either version tuple is empty, then they are assumed to match. If
2162 /// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2163 static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2164 bool BeforeIsOkay) {
2165 if (X.empty() || Y.empty())
2171 if (BeforeIsOkay && X < Y)
2177 AvailabilityAttr *Sema::mergeAvailabilityAttr(NamedDecl *D, SourceRange Range,
2178 IdentifierInfo *Platform,
2180 VersionTuple Introduced,
2181 VersionTuple Deprecated,
2182 VersionTuple Obsoleted,
2186 StringRef Replacement,
2187 AvailabilityMergeKind AMK,
2188 unsigned AttrSpellingListIndex) {
2189 VersionTuple MergedIntroduced = Introduced;
2190 VersionTuple MergedDeprecated = Deprecated;
2191 VersionTuple MergedObsoleted = Obsoleted;
2192 bool FoundAny = false;
2193 bool OverrideOrImpl = false;
2196 case AMK_Redeclaration:
2197 OverrideOrImpl = false;
2201 case AMK_ProtocolImplementation:
2202 OverrideOrImpl = true;
2206 if (D->hasAttrs()) {
2207 AttrVec &Attrs = D->getAttrs();
2208 for (unsigned i = 0, e = Attrs.size(); i != e;) {
2209 const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2215 IdentifierInfo *OldPlatform = OldAA->getPlatform();
2216 if (OldPlatform != Platform) {
2221 // If there is an existing availability attribute for this platform that
2222 // is explicit and the new one is implicit use the explicit one and
2223 // discard the new implicit attribute.
2224 if (!OldAA->isImplicit() && Implicit) {
2228 // If there is an existing attribute for this platform that is implicit
2229 // and the new attribute is explicit then erase the old one and
2230 // continue processing the attributes.
2231 if (!Implicit && OldAA->isImplicit()) {
2232 Attrs.erase(Attrs.begin() + i);
2238 VersionTuple OldIntroduced = OldAA->getIntroduced();
2239 VersionTuple OldDeprecated = OldAA->getDeprecated();
2240 VersionTuple OldObsoleted = OldAA->getObsoleted();
2241 bool OldIsUnavailable = OldAA->getUnavailable();
2243 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2244 !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2245 !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2246 !(OldIsUnavailable == IsUnavailable ||
2247 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2248 if (OverrideOrImpl) {
2250 VersionTuple FirstVersion;
2251 VersionTuple SecondVersion;
2252 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2254 FirstVersion = OldIntroduced;
2255 SecondVersion = Introduced;
2256 } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2258 FirstVersion = Deprecated;
2259 SecondVersion = OldDeprecated;
2260 } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2262 FirstVersion = Obsoleted;
2263 SecondVersion = OldObsoleted;
2267 Diag(OldAA->getLocation(),
2268 diag::warn_mismatched_availability_override_unavail)
2269 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2270 << (AMK == AMK_Override);
2272 Diag(OldAA->getLocation(),
2273 diag::warn_mismatched_availability_override)
2275 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2276 << FirstVersion.getAsString() << SecondVersion.getAsString()
2277 << (AMK == AMK_Override);
2279 if (AMK == AMK_Override)
2280 Diag(Range.getBegin(), diag::note_overridden_method);
2282 Diag(Range.getBegin(), diag::note_protocol_method);
2284 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2285 Diag(Range.getBegin(), diag::note_previous_attribute);
2288 Attrs.erase(Attrs.begin() + i);
2293 VersionTuple MergedIntroduced2 = MergedIntroduced;
2294 VersionTuple MergedDeprecated2 = MergedDeprecated;
2295 VersionTuple MergedObsoleted2 = MergedObsoleted;
2297 if (MergedIntroduced2.empty())
2298 MergedIntroduced2 = OldIntroduced;
2299 if (MergedDeprecated2.empty())
2300 MergedDeprecated2 = OldDeprecated;
2301 if (MergedObsoleted2.empty())
2302 MergedObsoleted2 = OldObsoleted;
2304 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2305 MergedIntroduced2, MergedDeprecated2,
2306 MergedObsoleted2)) {
2307 Attrs.erase(Attrs.begin() + i);
2312 MergedIntroduced = MergedIntroduced2;
2313 MergedDeprecated = MergedDeprecated2;
2314 MergedObsoleted = MergedObsoleted2;
2320 MergedIntroduced == Introduced &&
2321 MergedDeprecated == Deprecated &&
2322 MergedObsoleted == Obsoleted)
2325 // Only create a new attribute if !OverrideOrImpl, but we want to do
2327 if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2328 MergedDeprecated, MergedObsoleted) &&
2330 auto *Avail = ::new (Context) AvailabilityAttr(Range, Context, Platform,
2331 Introduced, Deprecated,
2332 Obsoleted, IsUnavailable, Message,
2333 IsStrict, Replacement,
2334 AttrSpellingListIndex);
2335 Avail->setImplicit(Implicit);
2341 static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2342 if (!checkAttributeNumArgs(S, AL, 1))
2344 IdentifierLoc *Platform = AL.getArgAsIdent(0);
2345 unsigned Index = AL.getAttributeSpellingListIndex();
2347 IdentifierInfo *II = Platform->Ident;
2348 if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2349 S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2352 auto *ND = dyn_cast<NamedDecl>(D);
2353 if (!ND) // We warned about this already, so just return.
2356 AvailabilityChange Introduced = AL.getAvailabilityIntroduced();
2357 AvailabilityChange Deprecated = AL.getAvailabilityDeprecated();
2358 AvailabilityChange Obsoleted = AL.getAvailabilityObsoleted();
2359 bool IsUnavailable = AL.getUnavailableLoc().isValid();
2360 bool IsStrict = AL.getStrictLoc().isValid();
2362 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getMessageExpr()))
2363 Str = SE->getString();
2364 StringRef Replacement;
2365 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getReplacementExpr()))
2366 Replacement = SE->getString();
2368 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND, AL.getRange(), II,
2374 IsStrict, Replacement,
2378 D->addAttr(NewAttr);
2380 // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2381 // matches before the start of the watchOS platform.
2382 if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2383 IdentifierInfo *NewII = nullptr;
2384 if (II->getName() == "ios")
2385 NewII = &S.Context.Idents.get("watchos");
2386 else if (II->getName() == "ios_app_extension")
2387 NewII = &S.Context.Idents.get("watchos_app_extension");
2390 auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
2391 if (Version.empty())
2393 auto Major = Version.getMajor();
2394 auto NewMajor = Major >= 9 ? Major - 7 : 0;
2395 if (NewMajor >= 2) {
2396 if (Version.getMinor().hasValue()) {
2397 if (Version.getSubminor().hasValue())
2398 return VersionTuple(NewMajor, Version.getMinor().getValue(),
2399 Version.getSubminor().getValue());
2401 return VersionTuple(NewMajor, Version.getMinor().getValue());
2405 return VersionTuple(2, 0);
2408 auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2409 auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2410 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2412 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2425 D->addAttr(NewAttr);
2427 } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2428 // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2429 // matches before the start of the tvOS platform.
2430 IdentifierInfo *NewII = nullptr;
2431 if (II->getName() == "ios")
2432 NewII = &S.Context.Idents.get("tvos");
2433 else if (II->getName() == "ios_app_extension")
2434 NewII = &S.Context.Idents.get("tvos_app_extension");
2437 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2450 D->addAttr(NewAttr);
2455 static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
2456 const ParsedAttr &AL) {
2457 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
2459 assert(checkAttributeAtMostNumArgs(S, AL, 3) &&
2460 "Invalid number of arguments in an external_source_symbol attribute");
2463 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(0)))
2464 Language = SE->getString();
2465 StringRef DefinedIn;
2466 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(1)))
2467 DefinedIn = SE->getString();
2468 bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr;
2470 D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2471 AL.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
2472 AL.getAttributeSpellingListIndex()));
2476 static T *mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range,
2477 typename T::VisibilityType value,
2478 unsigned attrSpellingListIndex) {
2479 T *existingAttr = D->getAttr<T>();
2481 typename T::VisibilityType existingValue = existingAttr->getVisibility();
2482 if (existingValue == value)
2484 S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2485 S.Diag(range.getBegin(), diag::note_previous_attribute);
2488 return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
2491 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2492 VisibilityAttr::VisibilityType Vis,
2493 unsigned AttrSpellingListIndex) {
2494 return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2495 AttrSpellingListIndex);
2498 TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2499 TypeVisibilityAttr::VisibilityType Vis,
2500 unsigned AttrSpellingListIndex) {
2501 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2502 AttrSpellingListIndex);
2505 static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
2506 bool isTypeVisibility) {
2507 // Visibility attributes don't mean anything on a typedef.
2508 if (isa<TypedefNameDecl>(D)) {
2509 S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored)
2514 // 'type_visibility' can only go on a type or namespace.
2515 if (isTypeVisibility &&
2516 !(isa<TagDecl>(D) ||
2517 isa<ObjCInterfaceDecl>(D) ||
2518 isa<NamespaceDecl>(D))) {
2519 S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2520 << AL.getName() << ExpectedTypeOrNamespace;
2524 // Check that the argument is a string literal.
2526 SourceLocation LiteralLoc;
2527 if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
2530 VisibilityAttr::VisibilityType type;
2531 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2532 S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
2533 << AL.getName() << TypeStr;
2537 // Complain about attempts to use protected visibility on targets
2538 // (like Darwin) that don't support it.
2539 if (type == VisibilityAttr::Protected &&
2540 !S.Context.getTargetInfo().hasProtectedVisibility()) {
2541 S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
2542 type = VisibilityAttr::Default;
2545 unsigned Index = AL.getAttributeSpellingListIndex();
2547 if (isTypeVisibility) {
2548 newAttr = S.mergeTypeVisibilityAttr(D, AL.getRange(),
2549 (TypeVisibilityAttr::VisibilityType) type,
2552 newAttr = S.mergeVisibilityAttr(D, AL.getRange(), type, Index);
2555 D->addAttr(newAttr);
2558 static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2559 const auto *M = cast<ObjCMethodDecl>(D);
2560 if (!AL.isArgIdent(0)) {
2561 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2562 << AL.getName() << 1 << AANT_ArgumentIdentifier;
2566 IdentifierLoc *IL = AL.getArgAsIdent(0);
2567 ObjCMethodFamilyAttr::FamilyKind F;
2568 if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2569 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
2570 << AL.getName() << IL->Ident;
2574 if (F == ObjCMethodFamilyAttr::OMF_init &&
2575 !M->getReturnType()->isObjCObjectPointerType()) {
2576 S.Diag(M->getLocation(), diag::err_init_method_bad_return_type)
2577 << M->getReturnType();
2578 // Ignore the attribute.
2582 D->addAttr(new (S.Context) ObjCMethodFamilyAttr(
2583 AL.getRange(), S.Context, F, AL.getAttributeSpellingListIndex()));
2586 static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
2587 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2588 QualType T = TD->getUnderlyingType();
2589 if (!T->isCARCBridgableType()) {
2590 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2594 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2595 QualType T = PD->getType();
2596 if (!T->isCARCBridgableType()) {
2597 S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2602 // It is okay to include this attribute on properties, e.g.:
2604 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2606 // In this case it follows tradition and suppresses an error in the above
2608 S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2610 D->addAttr(::new (S.Context)
2611 ObjCNSObjectAttr(AL.getRange(), S.Context,
2612 AL.getAttributeSpellingListIndex()));
2615 static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
2616 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2617 QualType T = TD->getUnderlyingType();
2618 if (!T->isObjCObjectPointerType()) {
2619 S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2623 S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2626 D->addAttr(::new (S.Context)
2627 ObjCIndependentClassAttr(AL.getRange(), S.Context,
2628 AL.getAttributeSpellingListIndex()));
2631 static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2632 if (!AL.isArgIdent(0)) {
2633 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2634 << AL.getName() << 1 << AANT_ArgumentIdentifier;
2638 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
2639 BlocksAttr::BlockType type;
2640 if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2641 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
2642 << AL.getName() << II;
2646 D->addAttr(::new (S.Context)
2647 BlocksAttr(AL.getRange(), S.Context, type,
2648 AL.getAttributeSpellingListIndex()));
2651 static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2652 unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2653 if (AL.getNumArgs() > 0) {
2654 Expr *E = AL.getArgAsExpr(0);
2655 llvm::APSInt Idx(32);
2656 if (E->isTypeDependent() || E->isValueDependent() ||
2657 !E->isIntegerConstantExpr(Idx, S.Context)) {
2658 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2659 << AL.getName() << 1 << AANT_ArgumentIntegerConstant
2660 << E->getSourceRange();
2664 if (Idx.isSigned() && Idx.isNegative()) {
2665 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2666 << E->getSourceRange();
2670 sentinel = Idx.getZExtValue();
2673 unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2674 if (AL.getNumArgs() > 1) {
2675 Expr *E = AL.getArgAsExpr(1);
2676 llvm::APSInt Idx(32);
2677 if (E->isTypeDependent() || E->isValueDependent() ||
2678 !E->isIntegerConstantExpr(Idx, S.Context)) {
2679 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2680 << AL.getName() << 2 << AANT_ArgumentIntegerConstant
2681 << E->getSourceRange();
2684 nullPos = Idx.getZExtValue();
2686 if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2687 // FIXME: This error message could be improved, it would be nice
2688 // to say what the bounds actually are.
2689 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2690 << E->getSourceRange();
2695 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2696 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2697 if (isa<FunctionNoProtoType>(FT)) {
2698 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2702 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2703 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2706 } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
2707 if (!MD->isVariadic()) {
2708 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2711 } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
2712 if (!BD->isVariadic()) {
2713 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2716 } else if (const auto *V = dyn_cast<VarDecl>(D)) {
2717 QualType Ty = V->getType();
2718 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2719 const FunctionType *FT = Ty->isFunctionPointerType()
2720 ? D->getFunctionType()
2721 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2722 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2723 int m = Ty->isFunctionPointerType() ? 0 : 1;
2724 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2728 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2729 << AL.getName() << ExpectedFunctionMethodOrBlock;
2733 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2734 << AL.getName() << ExpectedFunctionMethodOrBlock;
2737 D->addAttr(::new (S.Context)
2738 SentinelAttr(AL.getRange(), S.Context, sentinel, nullPos,
2739 AL.getAttributeSpellingListIndex()));
2742 static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
2743 if (D->getFunctionType() &&
2744 D->getFunctionType()->getReturnType()->isVoidType()) {
2745 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method)
2746 << AL.getName() << 0;
2749 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
2750 if (MD->getReturnType()->isVoidType()) {
2751 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method)
2752 << AL.getName() << 1;
2756 // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2757 // about using it as an extension.
2758 if (!S.getLangOpts().CPlusPlus17 && AL.isCXX11Attribute() &&
2760 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL.getName();
2762 D->addAttr(::new (S.Context)
2763 WarnUnusedResultAttr(AL.getRange(), S.Context,
2764 AL.getAttributeSpellingListIndex()));
2767 static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2768 // weak_import only applies to variable & function declarations.
2770 if (!D->canBeWeakImported(isDef)) {
2772 S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
2774 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2775 (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2776 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2777 // Nothing to warn about here.
2779 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2780 << AL.getName() << ExpectedVariableOrFunction;
2785 D->addAttr(::new (S.Context)
2786 WeakImportAttr(AL.getRange(), S.Context,
2787 AL.getAttributeSpellingListIndex()));
2790 // Handles reqd_work_group_size and work_group_size_hint.
2791 template <typename WorkGroupAttr>
2792 static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2794 for (unsigned i = 0; i < 3; ++i) {
2795 const Expr *E = AL.getArgAsExpr(i);
2796 if (!checkUInt32Argument(S, AL, E, WGSize[i], i))
2798 if (WGSize[i] == 0) {
2799 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2800 << AL.getName() << E->getSourceRange();
2805 WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2806 if (Existing && !(Existing->getXDim() == WGSize[0] &&
2807 Existing->getYDim() == WGSize[1] &&
2808 Existing->getZDim() == WGSize[2]))
2809 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL.getName();
2811 D->addAttr(::new (S.Context) WorkGroupAttr(AL.getRange(), S.Context,
2812 WGSize[0], WGSize[1], WGSize[2],
2813 AL.getAttributeSpellingListIndex()));
2816 // Handles intel_reqd_sub_group_size.
2817 static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2819 const Expr *E = AL.getArgAsExpr(0);
2820 if (!checkUInt32Argument(S, AL, E, SGSize))
2823 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2824 << AL.getName() << E->getSourceRange();
2828 OpenCLIntelReqdSubGroupSizeAttr *Existing =
2829 D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
2830 if (Existing && Existing->getSubGroupSize() != SGSize)
2831 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL.getName();
2833 D->addAttr(::new (S.Context) OpenCLIntelReqdSubGroupSizeAttr(
2834 AL.getRange(), S.Context, SGSize,
2835 AL.getAttributeSpellingListIndex()));
2838 static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
2839 if (!AL.hasParsedType()) {
2840 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
2841 << AL.getName() << 1;
2845 TypeSourceInfo *ParmTSI = nullptr;
2846 QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI);
2847 assert(ParmTSI && "no type source info for attribute argument");
2849 if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2850 (ParmType->isBooleanType() ||
2851 !ParmType->isIntegralType(S.getASTContext()))) {
2852 S.Diag(AL.getLoc(), diag::err_attribute_argument_vec_type_hint)
2857 if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2858 if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2859 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL.getName();
2864 D->addAttr(::new (S.Context) VecTypeHintAttr(AL.getLoc(), S.Context,
2866 AL.getAttributeSpellingListIndex()));
2869 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2871 unsigned AttrSpellingListIndex) {
2872 // Explicit or partial specializations do not inherit
2873 // the section attribute from the primary template.
2874 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2875 if (AttrSpellingListIndex == SectionAttr::Declspec_allocate &&
2876 FD->isFunctionTemplateSpecialization())
2879 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2880 if (ExistingAttr->getName() == Name)
2882 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2884 Diag(Range.getBegin(), diag::note_previous_attribute);
2887 return ::new (Context) SectionAttr(Range, Context, Name,
2888 AttrSpellingListIndex);
2891 bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2892 std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2893 if (!Error.empty()) {
2894 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
2901 static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2902 // Make sure that there is a string literal as the sections's single
2905 SourceLocation LiteralLoc;
2906 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
2909 if (!S.checkSectionName(LiteralLoc, Str))
2912 // If the target wants to validate the section specifier, make it happen.
2913 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
2914 if (!Error.empty()) {
2915 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
2920 unsigned Index = AL.getAttributeSpellingListIndex();
2921 SectionAttr *NewAttr = S.mergeSectionAttr(D, AL.getRange(), Str, Index);
2923 D->addAttr(NewAttr);
2926 static bool checkCodeSegName(Sema&S, SourceLocation LiteralLoc, StringRef CodeSegName) {
2927 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
2928 if (!Error.empty()) {
2929 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
2930 << 0 /*'code-seg'*/;
2936 CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, SourceRange Range,
2938 unsigned AttrSpellingListIndex) {
2939 // Explicit or partial specializations do not inherit
2940 // the code_seg attribute from the primary template.
2941 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2942 if (FD->isFunctionTemplateSpecialization())
2945 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
2946 if (ExistingAttr->getName() == Name)
2948 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2950 Diag(Range.getBegin(), diag::note_previous_attribute);
2953 return ::new (Context) CodeSegAttr(Range, Context, Name,
2954 AttrSpellingListIndex);
2957 static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2959 SourceLocation LiteralLoc;
2960 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
2962 if (!checkCodeSegName(S, LiteralLoc, Str))
2964 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
2965 if (!ExistingAttr->isImplicit()) {
2967 ExistingAttr->getName() == Str
2968 ? diag::warn_duplicate_codeseg_attribute
2969 : diag::err_conflicting_codeseg_attribute);
2972 D->dropAttr<CodeSegAttr>();
2974 if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL.getRange(), Str,
2975 AL.getAttributeSpellingListIndex()))
2979 // Check for things we'd like to warn about. Multiversioning issues are
2980 // handled later in the process, once we know how many exist.
2981 bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
2982 enum FirstParam { Unsupported, Duplicate };
2983 enum SecondParam { None, Architecture };
2984 for (auto Str : {"tune=", "fpmath="})
2985 if (AttrStr.find(Str) != StringRef::npos)
2986 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2987 << Unsupported << None << Str;
2989 TargetAttr::ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);
2991 if (!ParsedAttrs.Architecture.empty() &&
2992 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
2993 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2994 << Unsupported << Architecture << ParsedAttrs.Architecture;
2996 if (ParsedAttrs.DuplicateArchitecture)
2997 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
2998 << Duplicate << None << "arch=";
3000 for (const auto &Feature : ParsedAttrs.Features) {
3001 auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
3002 if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
3003 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3004 << Unsupported << None << CurFeature;
3010 static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3012 SourceLocation LiteralLoc;
3013 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
3014 S.checkTargetAttr(LiteralLoc, Str))
3017 unsigned Index = AL.getAttributeSpellingListIndex();
3018 TargetAttr *NewAttr =
3019 ::new (S.Context) TargetAttr(AL.getRange(), S.Context, Str, Index);
3020 D->addAttr(NewAttr);
3023 static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3024 Expr *E = AL.getArgAsExpr(0);
3026 if (!checkUInt32Argument(S, AL, E, VecWidth)) {
3031 MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>();
3032 if (Existing && Existing->getVectorWidth() != VecWidth) {
3033 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL.getName();
3037 D->addAttr(::new (S.Context)
3038 MinVectorWidthAttr(AL.getRange(), S.Context, VecWidth,
3039 AL.getAttributeSpellingListIndex()));
3042 static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3043 Expr *E = AL.getArgAsExpr(0);
3044 SourceLocation Loc = E->getExprLoc();
3045 FunctionDecl *FD = nullptr;
3046 DeclarationNameInfo NI;
3048 // gcc only allows for simple identifiers. Since we support more than gcc, we
3049 // will warn the user.
3050 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
3051 if (DRE->hasQualifier())
3052 S.Diag(Loc, diag::warn_cleanup_ext);
3053 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3054 NI = DRE->getNameInfo();
3056 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3060 } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3061 if (ULE->hasExplicitTemplateArgs())
3062 S.Diag(Loc, diag::warn_cleanup_ext);
3063 FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
3064 NI = ULE->getNameInfo();
3066 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3068 if (ULE->getType() == S.Context.OverloadTy)
3069 S.NoteAllOverloadCandidates(ULE);
3073 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3077 if (FD->getNumParams() != 1) {
3078 S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3083 // We're currently more strict than GCC about what function types we accept.
3084 // If this ever proves to be a problem it should be easy to fix.
3085 QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
3086 QualType ParamTy = FD->getParamDecl(0)->getType();
3087 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
3088 ParamTy, Ty) != Sema::Compatible) {
3089 S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3090 << NI.getName() << ParamTy << Ty;
3094 D->addAttr(::new (S.Context)
3095 CleanupAttr(AL.getRange(), S.Context, FD,
3096 AL.getAttributeSpellingListIndex()));
3099 static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
3100 const ParsedAttr &AL) {
3101 if (!AL.isArgIdent(0)) {
3102 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3103 << AL.getName() << 0 << AANT_ArgumentIdentifier;
3107 EnumExtensibilityAttr::Kind ExtensibilityKind;
3108 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3109 if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3110 ExtensibilityKind)) {
3111 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
3112 << AL.getName() << II;
3116 D->addAttr(::new (S.Context) EnumExtensibilityAttr(
3117 AL.getRange(), S.Context, ExtensibilityKind,
3118 AL.getAttributeSpellingListIndex()));
3121 /// Handle __attribute__((format_arg((idx)))) attribute based on
3122 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3123 static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3124 Expr *IdxExpr = AL.getArgAsExpr(0);
3126 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
3129 // Make sure the format string is really a string.
3130 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
3132 bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3133 if (NotNSStringTy &&
3134 !isCFStringType(Ty, S.Context) &&
3135 (!Ty->isPointerType() ||
3136 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3137 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3138 << "a string type" << IdxExpr->getSourceRange()
3139 << getFunctionOrMethodParamRange(D, 0);
3142 Ty = getFunctionOrMethodResultType(D);
3143 if (!isNSStringType(Ty, S.Context) &&
3144 !isCFStringType(Ty, S.Context) &&
3145 (!Ty->isPointerType() ||
3146 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3147 S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
3148 << (NotNSStringTy ? "string type" : "NSString")
3149 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3153 D->addAttr(::new (S.Context) FormatArgAttr(
3154 AL.getRange(), S.Context, Idx, AL.getAttributeSpellingListIndex()));
3157 enum FormatAttrKind {
3166 /// getFormatAttrKind - Map from format attribute names to supported format
3168 static FormatAttrKind getFormatAttrKind(StringRef Format) {
3169 return llvm::StringSwitch<FormatAttrKind>(Format)
3170 // Check for formats that get handled specially.
3171 .Case("NSString", NSStringFormat)
3172 .Case("CFString", CFStringFormat)
3173 .Case("strftime", StrftimeFormat)
3175 // Otherwise, check for supported formats.
3176 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3177 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3178 .Case("kprintf", SupportedFormat) // OpenBSD.
3179 .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3180 .Case("os_trace", SupportedFormat)
3181 .Case("os_log", SupportedFormat)
3183 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3184 .Default(InvalidFormat);
3187 /// Handle __attribute__((init_priority(priority))) attributes based on
3188 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3189 static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3190 if (!S.getLangOpts().CPlusPlus) {
3191 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL.getName();
3195 if (S.getCurFunctionOrMethodDecl()) {
3196 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3200 QualType T = cast<VarDecl>(D)->getType();
3201 if (S.Context.getAsArrayType(T))
3202 T = S.Context.getBaseElementType(T);
3203 if (!T->getAs<RecordType>()) {
3204 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3209 Expr *E = AL.getArgAsExpr(0);
3210 uint32_t prioritynum;
3211 if (!checkUInt32Argument(S, AL, E, prioritynum)) {
3216 if (prioritynum < 101 || prioritynum > 65535) {
3217 S.Diag(AL.getLoc(), diag::err_attribute_argument_outof_range)
3218 << E->getSourceRange() << AL.getName() << 101 << 65535;
3222 D->addAttr(::new (S.Context)
3223 InitPriorityAttr(AL.getRange(), S.Context, prioritynum,
3224 AL.getAttributeSpellingListIndex()));
3227 FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range,
3228 IdentifierInfo *Format, int FormatIdx,
3230 unsigned AttrSpellingListIndex) {
3231 // Check whether we already have an equivalent format attribute.
3232 for (auto *F : D->specific_attrs<FormatAttr>()) {
3233 if (F->getType() == Format &&
3234 F->getFormatIdx() == FormatIdx &&
3235 F->getFirstArg() == FirstArg) {
3236 // If we don't have a valid location for this attribute, adopt the
3238 if (F->getLocation().isInvalid())
3244 return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
3245 FirstArg, AttrSpellingListIndex);
3248 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3249 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3250 static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3251 if (!AL.isArgIdent(0)) {
3252 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3253 << AL.getName() << 1 << AANT_ArgumentIdentifier;
3257 // In C++ the implicit 'this' function parameter also counts, and they are
3258 // counted from one.
3259 bool HasImplicitThisParam = isInstanceMethod(D);
3260 unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3262 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3263 StringRef Format = II->getName();
3265 if (normalizeName(Format)) {
3266 // If we've modified the string name, we need a new identifier for it.
3267 II = &S.Context.Idents.get(Format);
3270 // Check for supported formats.
3271 FormatAttrKind Kind = getFormatAttrKind(Format);
3273 if (Kind == IgnoredFormat)
3276 if (Kind == InvalidFormat) {
3277 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
3278 << AL.getName() << II->getName();
3282 // checks for the 2nd argument
3283 Expr *IdxExpr = AL.getArgAsExpr(1);
3285 if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
3288 if (Idx < 1 || Idx > NumArgs) {
3289 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3290 << AL.getName() << 2 << IdxExpr->getSourceRange();
3294 // FIXME: Do we need to bounds check?
3295 unsigned ArgIdx = Idx - 1;
3297 if (HasImplicitThisParam) {
3300 diag::err_format_attribute_implicit_this_format_string)
3301 << IdxExpr->getSourceRange();
3307 // make sure the format string is really a string
3308 QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
3310 if (Kind == CFStringFormat) {
3311 if (!isCFStringType(Ty, S.Context)) {
3312 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3313 << "a CFString" << IdxExpr->getSourceRange()
3314 << getFunctionOrMethodParamRange(D, ArgIdx);
3317 } else if (Kind == NSStringFormat) {
3318 // FIXME: do we need to check if the type is NSString*? What are the
3320 if (!isNSStringType(Ty, S.Context)) {
3321 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3322 << "an NSString" << IdxExpr->getSourceRange()
3323 << getFunctionOrMethodParamRange(D, ArgIdx);
3326 } else if (!Ty->isPointerType() ||
3327 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
3328 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3329 << "a string type" << IdxExpr->getSourceRange()
3330 << getFunctionOrMethodParamRange(D, ArgIdx);
3334 // check the 3rd argument
3335 Expr *FirstArgExpr = AL.getArgAsExpr(2);
3337 if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
3340 // check if the function is variadic if the 3rd argument non-zero
3341 if (FirstArg != 0) {
3342 if (isFunctionOrMethodVariadic(D)) {
3343 ++NumArgs; // +1 for ...
3345 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
3350 // strftime requires FirstArg to be 0 because it doesn't read from any
3351 // variable the input is just the current time + the format string.
3352 if (Kind == StrftimeFormat) {
3353 if (FirstArg != 0) {
3354 S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter)
3355 << FirstArgExpr->getSourceRange();
3358 // if 0 it disables parameter checking (to use with e.g. va_list)
3359 } else if (FirstArg != 0 && FirstArg != NumArgs) {
3360 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3361 << AL.getName() << 3 << FirstArgExpr->getSourceRange();
3365 FormatAttr *NewAttr = S.mergeFormatAttr(D, AL.getRange(), II,
3367 AL.getAttributeSpellingListIndex());
3369 D->addAttr(NewAttr);
3372 static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3373 // Try to find the underlying union declaration.
3374 RecordDecl *RD = nullptr;
3375 const auto *TD = dyn_cast<TypedefNameDecl>(D);
3376 if (TD && TD->getUnderlyingType()->isUnionType())
3377 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3379 RD = dyn_cast<RecordDecl>(D);
3381 if (!RD || !RD->isUnion()) {
3382 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
3383 << AL.getName() << ExpectedUnion;
3387 if (!RD->isCompleteDefinition()) {
3388 if (!RD->isBeingDefined())
3390 diag::warn_transparent_union_attribute_not_definition);
3394 RecordDecl::field_iterator Field = RD->field_begin(),
3395 FieldEnd = RD->field_end();
3396 if (Field == FieldEnd) {
3397 S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3401 FieldDecl *FirstField = *Field;
3402 QualType FirstType = FirstField->getType();
3403 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3404 S.Diag(FirstField->getLocation(),
3405 diag::warn_transparent_union_attribute_floating)
3406 << FirstType->isVectorType() << FirstType;
3410 if (FirstType->isIncompleteType())
3412 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3413 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3414 for (; Field != FieldEnd; ++Field) {
3415 QualType FieldType = Field->getType();
3416 if (FieldType->isIncompleteType())
3418 // FIXME: this isn't fully correct; we also need to test whether the
3419 // members of the union would all have the same calling convention as the
3420 // first member of the union. Checking just the size and alignment isn't
3421 // sufficient (consider structs passed on the stack instead of in registers
3423 if (S.Context.getTypeSize(FieldType) != FirstSize ||
3424 S.Context.getTypeAlign(FieldType) > FirstAlign) {
3425 // Warn if we drop the attribute.
3426 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3427 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3428 : S.Context.getTypeAlign(FieldType);
3429 S.Diag(Field->getLocation(),
3430 diag::warn_transparent_union_attribute_field_size_align)
3431 << isSize << Field->getDeclName() << FieldBits;
3432 unsigned FirstBits = isSize? FirstSize : FirstAlign;
3433 S.Diag(FirstField->getLocation(),
3434 diag::note_transparent_union_first_field_size_align)
3435 << isSize << FirstBits;
3440 RD->addAttr(::new (S.Context)
3441 TransparentUnionAttr(AL.getRange(), S.Context,
3442 AL.getAttributeSpellingListIndex()));
3445 static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3446 // Make sure that there is a string literal as the annotation's single
3449 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
3452 // Don't duplicate annotations that are already set.
3453 for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
3454 if (I->getAnnotation() == Str)
3458 D->addAttr(::new (S.Context)
3459 AnnotateAttr(AL.getRange(), S.Context, Str,
3460 AL.getAttributeSpellingListIndex()));
3463 static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3464 S.AddAlignValueAttr(AL.getRange(), D, AL.getArgAsExpr(0),
3465 AL.getAttributeSpellingListIndex());
3468 void Sema::AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
3469 unsigned SpellingListIndex) {
3470 AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
3471 SourceLocation AttrLoc = AttrRange.getBegin();
3474 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
3475 T = TD->getUnderlyingType();
3476 else if (const auto *VD = dyn_cast<ValueDecl>(D))
3479 llvm_unreachable("Unknown decl type for align_value");
3481 if (!T->isDependentType() && !T->isAnyPointerType() &&
3482 !T->isReferenceType() && !T->isMemberPointerType()) {
3483 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3484 << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
3488 if (!E->isValueDependent()) {
3489 llvm::APSInt Alignment;
3491 = VerifyIntegerConstantExpression(E, &Alignment,
3492 diag::err_align_value_attribute_argument_not_int,
3493 /*AllowFold*/ false);
3494 if (ICE.isInvalid())
3497 if (!Alignment.isPowerOf2()) {
3498 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3499 << E->getSourceRange();
3503 D->addAttr(::new (Context)
3504 AlignValueAttr(AttrRange, Context, ICE.get(),
3505 SpellingListIndex));
3509 // Save dependent expressions in the AST to be instantiated.
3510 D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
3513 static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3514 // check the attribute arguments.
3515 if (AL.getNumArgs() > 1) {
3516 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
3517 << AL.getName() << 1;
3521 if (AL.getNumArgs() == 0) {
3522 D->addAttr(::new (S.Context) AlignedAttr(AL.getRange(), S.Context,
3523 true, nullptr, AL.getAttributeSpellingListIndex()));
3527 Expr *E = AL.getArgAsExpr(0);
3528 if (AL.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
3529 S.Diag(AL.getEllipsisLoc(),
3530 diag::err_pack_expansion_without_parameter_packs);
3534 if (!AL.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
3537 S.AddAlignedAttr(AL.getRange(), D, E, AL.getAttributeSpellingListIndex(),
3538 AL.isPackExpansion());
3541 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3542 unsigned SpellingListIndex, bool IsPackExpansion) {
3543 AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3544 SourceLocation AttrLoc = AttrRange.getBegin();
3546 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3547 if (TmpAttr.isAlignas()) {
3548 // C++11 [dcl.align]p1:
3549 // An alignment-specifier may be applied to a variable or to a class
3550 // data member, but it shall not be applied to a bit-field, a function
3551 // parameter, the formal parameter of a catch clause, or a variable
3552 // declared with the register storage class specifier. An
3553 // alignment-specifier may also be applied to the declaration of a class
3554 // or enumeration type.
3556 // An alignment attribute shall not be specified in a declaration of
3557 // a typedef, or a bit-field, or a function, or a parameter, or an
3558 // object declared with the register storage-class specifier.
3560 if (isa<ParmVarDecl>(D)) {
3562 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
3563 if (VD->getStorageClass() == SC_Register)
3565 if (VD->isExceptionVariable())
3567 } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
3568 if (FD->isBitField())
3570 } else if (!isa<TagDecl>(D)) {
3571 Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
3572 << (TmpAttr.isC11() ? ExpectedVariableOrField
3573 : ExpectedVariableFieldOrTag);
3576 if (DiagKind != -1) {
3577 Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3578 << &TmpAttr << DiagKind;
3583 if (E->isValueDependent()) {
3584 // We can't support a dependent alignment on a non-dependent type,
3585 // because we have no way to model that a type is "alignment-dependent"
3586 // but not dependent in any other way.
3587 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
3588 if (!TND->getUnderlyingType()->isDependentType()) {
3589 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
3590 << E->getSourceRange();
3595 // Save dependent expressions in the AST to be instantiated.
3596 AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
3597 AA->setPackExpansion(IsPackExpansion);
3602 // FIXME: Cache the number on the AL object?
3603 llvm::APSInt Alignment;
3605 = VerifyIntegerConstantExpression(E, &Alignment,
3606 diag::err_aligned_attribute_argument_not_int,
3607 /*AllowFold*/ false);
3608 if (ICE.isInvalid())
3611 uint64_t AlignVal = Alignment.getZExtValue();
3613 // C++11 [dcl.align]p2:
3614 // -- if the constant expression evaluates to zero, the alignment
3615 // specifier shall have no effect
3617 // An alignment specification of zero has no effect.
3618 if (!(TmpAttr.isAlignas() && !Alignment)) {
3619 if (!llvm::isPowerOf2_64(AlignVal)) {
3620 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3621 << E->getSourceRange();
3626 // Alignment calculations can wrap around if it's greater than 2**28.
3627 unsigned MaxValidAlignment =
3628 Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192
3630 if (AlignVal > MaxValidAlignment) {
3631 Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3632 << E->getSourceRange();
3636 if (Context.getTargetInfo().isTLSSupported()) {
3637 unsigned MaxTLSAlign =
3638 Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign())
3640 const auto *VD = dyn_cast<VarDecl>(D);
3641 if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
3642 VD->getTLSKind() != VarDecl::TLS_None) {
3643 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3644 << (unsigned)AlignVal << VD << MaxTLSAlign;
3649 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3650 ICE.get(), SpellingListIndex);
3651 AA->setPackExpansion(IsPackExpansion);
3655 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3656 unsigned SpellingListIndex, bool IsPackExpansion) {
3657 // FIXME: Cache the number on the AL object if non-dependent?
3658 // FIXME: Perform checking of type validity
3659 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3661 AA->setPackExpansion(IsPackExpansion);
3665 void Sema::CheckAlignasUnderalignment(Decl *D) {
3666 assert(D->hasAttrs() && "no attributes on decl");
3668 QualType UnderlyingTy, DiagTy;
3669 if (const auto *VD = dyn_cast<ValueDecl>(D)) {
3670 UnderlyingTy = DiagTy = VD->getType();
3672 UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3673 if (const auto *ED = dyn_cast<EnumDecl>(D))
3674 UnderlyingTy = ED->getIntegerType();
3676 if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3679 // C++11 [dcl.align]p5, C11 6.7.5/4:
3680 // The combined effect of all alignment attributes in a declaration shall
3681 // not specify an alignment that is less strict than the alignment that
3682 // would otherwise be required for the entity being declared.
3683 AlignedAttr *AlignasAttr = nullptr;
3685 for (auto *I : D->specific_attrs<AlignedAttr>()) {
3686 if (I->isAlignmentDependent())
3690 Align = std::max(Align, I->getAlignment(Context));
3693 if (AlignasAttr && Align) {
3694 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3695 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3696 if (NaturalAlign > RequestedAlign)
3697 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3698 << DiagTy << (unsigned)NaturalAlign.getQuantity();
3702 bool Sema::checkMSInheritanceAttrOnDefinition(
3703 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3704 MSInheritanceAttr::Spelling SemanticSpelling) {
3705 assert(RD->hasDefinition() && "RD has no definition!");
3707 // We may not have seen base specifiers or any virtual methods yet. We will
3708 // have to wait until the record is defined to catch any mismatches.
3709 if (!RD->getDefinition()->isCompleteDefinition())
3712 // The unspecified model never matches what a definition could need.
3713 if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3717 if (RD->calculateInheritanceModel() == SemanticSpelling)
3720 if (RD->calculateInheritanceModel() <= SemanticSpelling)
3724 Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3725 << 0 /*definition*/;
3726 Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3727 << RD->getNameAsString();
3731 /// parseModeAttrArg - Parses attribute mode string and returns parsed type
3733 static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
3734 bool &IntegerMode, bool &ComplexMode) {
3736 ComplexMode = false;
3737 switch (Str.size()) {
3759 if (Str[1] == 'F') {
3760 IntegerMode = false;
3761 } else if (Str[1] == 'C') {
3762 IntegerMode = false;
3764 } else if (Str[1] != 'I') {
3769 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3770 // pointer on PIC16 and other embedded platforms.
3772 DestWidth = S.Context.getTargetInfo().getRegisterWidth();
3773 else if (Str == "byte")
3774 DestWidth = S.Context.getTargetInfo().getCharWidth();
3777 if (Str == "pointer")
3778 DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3781 if (Str == "unwind_word")
3782 DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
3787 /// handleModeAttr - This attribute modifies the width of a decl with primitive
3790 /// Despite what would be logical, the mode attribute is a decl attribute, not a
3791 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3792 /// HImode, not an intermediate pointer.
3793 static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3794 // This attribute isn't documented, but glibc uses it. It changes
3795 // the width of an int or unsigned int to the specified size.
3796 if (!AL.isArgIdent(0)) {
3797 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) << AL.getName()
3798 << AANT_ArgumentIdentifier;
3802 IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident;
3804 S.AddModeAttr(AL.getRange(), D, Name, AL.getAttributeSpellingListIndex());
3807 void Sema::AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
3808 unsigned SpellingListIndex, bool InInstantiation) {
3809 StringRef Str = Name->getName();
3811 SourceLocation AttrLoc = AttrRange.getBegin();
3813 unsigned DestWidth = 0;
3814 bool IntegerMode = true;
3815 bool ComplexMode = false;
3816 llvm::APInt VectorSize(64, 0);
3817 if (Str.size() >= 4 && Str[0] == 'V') {
3818 // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
3819 size_t StrSize = Str.size();
3820 size_t VectorStringLength = 0;
3821 while ((VectorStringLength + 1) < StrSize &&
3822 isdigit(Str[VectorStringLength + 1]))
3823 ++VectorStringLength;
3824 if (VectorStringLength &&
3825 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
3826 VectorSize.isPowerOf2()) {
3827 parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
3828 IntegerMode, ComplexMode);
3829 // Avoid duplicate warning from template instantiation.
3830 if (!InInstantiation)
3831 Diag(AttrLoc, diag::warn_vector_mode_deprecated);
3838 parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
3840 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3841 // and friends, at least with glibc.
3842 // FIXME: Make sure floating-point mappings are accurate
3843 // FIXME: Support XF and TF types
3845 Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
3850 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
3851 OldTy = TD->getUnderlyingType();
3852 else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
3853 // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
3854 // Try to get type from enum declaration, default to int.
3855 OldTy = ED->getIntegerType();
3857 OldTy = Context.IntTy;
3859 OldTy = cast<ValueDecl>(D)->getType();
3861 if (OldTy->isDependentType()) {
3862 D->addAttr(::new (Context)
3863 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3867 // Base type can also be a vector type (see PR17453).
3868 // Distinguish between base type and base element type.
3869 QualType OldElemTy = OldTy;
3870 if (const auto *VT = OldTy->getAs<VectorType>())
3871 OldElemTy = VT->getElementType();
3873 // GCC allows 'mode' attribute on enumeration types (even incomplete), except
3874 // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
3875 // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
3876 if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
3877 VectorSize.getBoolValue()) {
3878 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
3881 bool IntegralOrAnyEnumType =
3882 OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
3884 if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
3885 !IntegralOrAnyEnumType)
3886 Diag(AttrLoc, diag::err_mode_not_primitive);
3887 else if (IntegerMode) {
3888 if (!IntegralOrAnyEnumType)
3889 Diag(AttrLoc, diag::err_mode_wrong_type);
3890 } else if (ComplexMode) {
3891 if (!OldElemTy->isComplexType())
3892 Diag(AttrLoc, diag::err_mode_wrong_type);
3894 if (!OldElemTy->isFloatingType())
3895 Diag(AttrLoc, diag::err_mode_wrong_type);
3901 NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
3902 OldElemTy->isSignedIntegerType());
3904 NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
3906 if (NewElemTy.isNull()) {
3907 Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
3912 NewElemTy = Context.getComplexType(NewElemTy);
3915 QualType NewTy = NewElemTy;
3916 if (VectorSize.getBoolValue()) {
3917 NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
3918 VectorType::GenericVector);
3919 } else if (const auto *OldVT = OldTy->getAs<VectorType>()) {
3920 // Complex machine mode does not support base vector types.
3922 Diag(AttrLoc, diag::err_complex_mode_vector_type);
3925 unsigned NumElements = Context.getTypeSize(OldElemTy) *
3926 OldVT->getNumElements() /
3927 Context.getTypeSize(NewElemTy);
3929 Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
3932 if (NewTy.isNull()) {
3933 Diag(AttrLoc, diag::err_mode_wrong_type);
3937 // Install the new type.
3938 if (auto *TD = dyn_cast<TypedefNameDecl>(D))
3939 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
3940 else if (auto *ED = dyn_cast<EnumDecl>(D))
3941 ED->setIntegerType(NewTy);
3943 cast<ValueDecl>(D)->setType(NewTy);
3945 D->addAttr(::new (Context)
3946 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3949 static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3950 D->addAttr(::new (S.Context)
3951 NoDebugAttr(AL.getRange(), S.Context,
3952 AL.getAttributeSpellingListIndex()));
3955 AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
3956 IdentifierInfo *Ident,
3957 unsigned AttrSpellingListIndex) {
3958 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
3959 Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
3960 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
3964 if (D->hasAttr<AlwaysInlineAttr>())
3967 return ::new (Context) AlwaysInlineAttr(Range, Context,
3968 AttrSpellingListIndex);
3971 CommonAttr *Sema::mergeCommonAttr(Decl *D, SourceRange Range,
3972 IdentifierInfo *Ident,
3973 unsigned AttrSpellingListIndex) {
3974 if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, Range, Ident))
3977 return ::new (Context) CommonAttr(Range, Context, AttrSpellingListIndex);
3980 InternalLinkageAttr *
3981 Sema::mergeInternalLinkageAttr(Decl *D, SourceRange Range,
3982 IdentifierInfo *Ident,
3983 unsigned AttrSpellingListIndex) {
3984 if (const auto *VD = dyn_cast<VarDecl>(D)) {
3985 // Attribute applies to Var but not any subclass of it (like ParmVar,
3986 // ImplicitParm or VarTemplateSpecialization).
3987 if (VD->getKind() != Decl::Var) {
3988 Diag(Range.getBegin(), diag::warn_attribute_wrong_decl_type)
3989 << Ident << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
3990 : ExpectedVariableOrFunction);
3993 // Attribute does not apply to non-static local variables.
3994 if (VD->hasLocalStorage()) {
3995 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4000 if (checkAttrMutualExclusion<CommonAttr>(*this, D, Range, Ident))
4003 return ::new (Context)
4004 InternalLinkageAttr(Range, Context, AttrSpellingListIndex);
4007 MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
4008 unsigned AttrSpellingListIndex) {
4009 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4010 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
4011 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4015 if (D->hasAttr<MinSizeAttr>())
4018 return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
4021 OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
4022 unsigned AttrSpellingListIndex) {
4023 if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
4024 Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4025 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4026 D->dropAttr<AlwaysInlineAttr>();
4028 if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
4029 Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4030 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4031 D->dropAttr<MinSizeAttr>();
4034 if (D->hasAttr<OptimizeNoneAttr>())
4037 return ::new (Context) OptimizeNoneAttr(Range, Context,
4038 AttrSpellingListIndex);
4041 static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4042 if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, AL.getRange(),
4046 if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
4047 D, AL.getRange(), AL.getName(),
4048 AL.getAttributeSpellingListIndex()))
4052 static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4053 if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
4054 D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4055 D->addAttr(MinSize);
4058 static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4059 if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
4060 D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4061 D->addAttr(Optnone);
4064 static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4065 if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL.getRange(),
4068 const auto *VD = cast<VarDecl>(D);
4069 if (!VD->hasGlobalStorage()) {
4070 S.Diag(AL.getLoc(), diag::err_cuda_nonglobal_constant);
4073 D->addAttr(::new (S.Context) CUDAConstantAttr(
4074 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4077 static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4078 if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL.getRange(),
4081 const auto *VD = cast<VarDecl>(D);
4082 // extern __shared__ is only allowed on arrays with no length (e.g.
4084 if (!S.getLangOpts().CUDARelocatableDeviceCode && VD->hasExternalStorage() &&
4085 !isa<IncompleteArrayType>(VD->getType())) {
4086 S.Diag(AL.getLoc(), diag::err_cuda_extern_shared) << VD;
4089 if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
4090 S.CUDADiagIfHostCode(AL.getLoc(), diag::err_cuda_host_shared)
4091 << S.CurrentCUDATarget())
4093 D->addAttr(::new (S.Context) CUDASharedAttr(
4094 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4097 static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4098 if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, AL.getRange(),
4100 checkAttrMutualExclusion<CUDAHostAttr>(S, D, AL.getRange(),
4104 const auto *FD = cast<FunctionDecl>(D);
4105 if (!FD->getReturnType()->isVoidType()) {
4106 SourceRange RTRange = FD->getReturnTypeSourceRange();
4107 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
4109 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
4113 if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4114 if (Method->isInstance()) {
4115 S.Diag(Method->getLocStart(), diag::err_kern_is_nonstatic_method)
4119 S.Diag(Method->getLocStart(), diag::warn_kern_is_method) << Method;
4121 // Only warn for "inline" when compiling for host, to cut down on noise.
4122 if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
4123 S.Diag(FD->getLocStart(), diag::warn_kern_is_inline) << FD;
4125 D->addAttr(::new (S.Context)
4126 CUDAGlobalAttr(AL.getRange(), S.Context,
4127 AL.getAttributeSpellingListIndex()));
4130 static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4131 const auto *Fn = cast<FunctionDecl>(D);
4132 if (!Fn->isInlineSpecified()) {
4133 S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4137 D->addAttr(::new (S.Context)
4138 GNUInlineAttr(AL.getRange(), S.Context,
4139 AL.getAttributeSpellingListIndex()));
4142 static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4143 if (hasDeclarator(D)) return;
4145 // Diagnostic is emitted elsewhere: here we store the (valid) AL
4146 // in the Decl node for syntactic reasoning, e.g., pretty-printing.
4148 if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr))
4151 if (!isa<ObjCMethodDecl>(D)) {
4152 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4153 << AL.getName() << ExpectedFunctionOrMethod;
4157 switch (AL.getKind()) {
4158 case ParsedAttr::AT_FastCall:
4159 D->addAttr(::new (S.Context)
4160 FastCallAttr(AL.getRange(), S.Context,
4161 AL.getAttributeSpellingListIndex()));
4163 case ParsedAttr::AT_StdCall:
4164 D->addAttr(::new (S.Context)
4165 StdCallAttr(AL.getRange(), S.Context,
4166 AL.getAttributeSpellingListIndex()));
4168 case ParsedAttr::AT_ThisCall:
4169 D->addAttr(::new (S.Context)
4170 ThisCallAttr(AL.getRange(), S.Context,
4171 AL.getAttributeSpellingListIndex()));
4173 case ParsedAttr::AT_CDecl:
4174 D->addAttr(::new (S.Context)
4175 CDeclAttr(AL.getRange(), S.Context,
4176 AL.getAttributeSpellingListIndex()));
4178 case ParsedAttr::AT_Pascal:
4179 D->addAttr(::new (S.Context)
4180 PascalAttr(AL.getRange(), S.Context,
4181 AL.getAttributeSpellingListIndex()));
4183 case ParsedAttr::AT_SwiftCall:
4184 D->addAttr(::new (S.Context)
4185 SwiftCallAttr(AL.getRange(), S.Context,
4186 AL.getAttributeSpellingListIndex()));
4188 case ParsedAttr::AT_VectorCall:
4189 D->addAttr(::new (S.Context)
4190 VectorCallAttr(AL.getRange(), S.Context,
4191 AL.getAttributeSpellingListIndex()));
4193 case ParsedAttr::AT_MSABI:
4194 D->addAttr(::new (S.Context)
4195 MSABIAttr(AL.getRange(), S.Context,
4196 AL.getAttributeSpellingListIndex()));
4198 case ParsedAttr::AT_SysVABI:
4199 D->addAttr(::new (S.Context)
4200 SysVABIAttr(AL.getRange(), S.Context,
4201 AL.getAttributeSpellingListIndex()));
4203 case ParsedAttr::AT_RegCall:
4204 D->addAttr(::new (S.Context) RegCallAttr(
4205 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4207 case ParsedAttr::AT_Pcs: {
4208 PcsAttr::PCSType PCS;
4211 PCS = PcsAttr::AAPCS;
4214 PCS = PcsAttr::AAPCS_VFP;
4217 llvm_unreachable("unexpected calling convention in pcs attribute");
4220 D->addAttr(::new (S.Context)
4221 PcsAttr(AL.getRange(), S.Context, PCS,
4222 AL.getAttributeSpellingListIndex()));
4225 case ParsedAttr::AT_IntelOclBicc:
4226 D->addAttr(::new (S.Context)
4227 IntelOclBiccAttr(AL.getRange(), S.Context,
4228 AL.getAttributeSpellingListIndex()));
4230 case ParsedAttr::AT_PreserveMost:
4231 D->addAttr(::new (S.Context) PreserveMostAttr(
4232 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4234 case ParsedAttr::AT_PreserveAll:
4235 D->addAttr(::new (S.Context) PreserveAllAttr(
4236 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4239 llvm_unreachable("unexpected attribute kind");
4243 static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4244 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
4247 std::vector<StringRef> DiagnosticIdentifiers;
4248 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
4251 if (!S.checkStringLiteralArgumentAttr(AL, I, RuleName, nullptr))
4254 // FIXME: Warn if the rule name is unknown. This is tricky because only
4255 // clang-tidy knows about available rules.
4256 DiagnosticIdentifiers.push_back(RuleName);
4258 D->addAttr(::new (S.Context) SuppressAttr(
4259 AL.getRange(), S.Context, DiagnosticIdentifiers.data(),
4260 DiagnosticIdentifiers.size(), AL.getAttributeSpellingListIndex()));
4263 bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
4264 const FunctionDecl *FD) {
4265 if (Attrs.isInvalid())
4268 if (Attrs.hasProcessingCache()) {
4269 CC = (CallingConv) Attrs.getProcessingCache();
4273 unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
4274 if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
4279 // TODO: diagnose uses of these conventions on the wrong target.
4280 switch (Attrs.getKind()) {
4281 case ParsedAttr::AT_CDecl:
4284 case ParsedAttr::AT_FastCall:
4285 CC = CC_X86FastCall;
4287 case ParsedAttr::AT_StdCall:
4290 case ParsedAttr::AT_ThisCall:
4291 CC = CC_X86ThisCall;
4293 case ParsedAttr::AT_Pascal:
4296 case ParsedAttr::AT_SwiftCall:
4299 case ParsedAttr::AT_VectorCall:
4300 CC = CC_X86VectorCall;
4302 case ParsedAttr::AT_RegCall:
4305 case ParsedAttr::AT_MSABI:
4306 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
4309 case ParsedAttr::AT_SysVABI:
4310 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
4313 case ParsedAttr::AT_Pcs: {
4315 if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
4319 if (StrRef == "aapcs") {
4322 } else if (StrRef == "aapcs-vfp") {
4328 Diag(Attrs.getLoc(), diag::err_invalid_pcs);
4331 case ParsedAttr::AT_IntelOclBicc:
4332 CC = CC_IntelOclBicc;
4334 case ParsedAttr::AT_PreserveMost:
4335 CC = CC_PreserveMost;
4337 case ParsedAttr::AT_PreserveAll:
4338 CC = CC_PreserveAll;
4340 default: llvm_unreachable("unexpected attribute kind");
4343 const TargetInfo &TI = Context.getTargetInfo();
4344 TargetInfo::CallingConvCheckResult A = TI.checkCallingConvention(CC);
4345 if (A != TargetInfo::CCCR_OK) {
4346 if (A == TargetInfo::CCCR_Warning)
4347 Diag(Attrs.getLoc(), diag::warn_cconv_ignored) << Attrs.getName();
4349 // This convention is not valid for the target. Use the default function or
4350 // method calling convention.
4351 bool IsCXXMethod = false, IsVariadic = false;
4353 IsCXXMethod = FD->isCXXInstanceMember();
4354 IsVariadic = FD->isVariadic();
4356 CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
4359 Attrs.setProcessingCache((unsigned) CC);
4363 /// Pointer-like types in the default address space.
4364 static bool isValidSwiftContextType(QualType Ty) {
4365 if (!Ty->hasPointerRepresentation())
4366 return Ty->isDependentType();
4367 return Ty->getPointeeType().getAddressSpace() == LangAS::Default;
4370 /// Pointers and references in the default address space.
4371 static bool isValidSwiftIndirectResultType(QualType Ty) {
4372 if (const auto *PtrType = Ty->getAs<PointerType>()) {
4373 Ty = PtrType->getPointeeType();
4374 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4375 Ty = RefType->getPointeeType();
4377 return Ty->isDependentType();
4379 return Ty.getAddressSpace() == LangAS::Default;
4382 /// Pointers and references to pointers in the default address space.
4383 static bool isValidSwiftErrorResultType(QualType Ty) {
4384 if (const auto *PtrType = Ty->getAs<PointerType>()) {
4385 Ty = PtrType->getPointeeType();
4386 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4387 Ty = RefType->getPointeeType();
4389 return Ty->isDependentType();
4391 if (!Ty.getQualifiers().empty())
4393 return isValidSwiftContextType(Ty);
4396 static void handleParameterABIAttr(Sema &S, Decl *D, const ParsedAttr &Attrs,
4398 S.AddParameterABIAttr(Attrs.getRange(), D, Abi,
4399 Attrs.getAttributeSpellingListIndex());
4402 void Sema::AddParameterABIAttr(SourceRange range, Decl *D, ParameterABI abi,
4403 unsigned spellingIndex) {
4405 QualType type = cast<ParmVarDecl>(D)->getType();
4407 if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
4408 if (existingAttr->getABI() != abi) {
4409 Diag(range.getBegin(), diag::err_attributes_are_not_compatible)
4410 << getParameterABISpelling(abi) << existingAttr;
4411 Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
4417 case ParameterABI::Ordinary:
4418 llvm_unreachable("explicit attribute for ordinary parameter ABI?");
4420 case ParameterABI::SwiftContext:
4421 if (!isValidSwiftContextType(type)) {
4422 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4423 << getParameterABISpelling(abi)
4424 << /*pointer to pointer */ 0 << type;
4426 D->addAttr(::new (Context)
4427 SwiftContextAttr(range, Context, spellingIndex));
4430 case ParameterABI::SwiftErrorResult:
4431 if (!isValidSwiftErrorResultType(type)) {
4432 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4433 << getParameterABISpelling(abi)
4434 << /*pointer to pointer */ 1 << type;
4436 D->addAttr(::new (Context)
4437 SwiftErrorResultAttr(range, Context, spellingIndex));
4440 case ParameterABI::SwiftIndirectResult:
4441 if (!isValidSwiftIndirectResultType(type)) {
4442 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4443 << getParameterABISpelling(abi)
4444 << /*pointer*/ 0 << type;
4446 D->addAttr(::new (Context)
4447 SwiftIndirectResultAttr(range, Context, spellingIndex));
4450 llvm_unreachable("bad parameter ABI attribute");
4453 /// Checks a regparm attribute, returning true if it is ill-formed and
4454 /// otherwise setting numParams to the appropriate value.
4455 bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) {
4459 if (!checkAttributeNumArgs(*this, AL, 1)) {
4465 Expr *NumParamsExpr = AL.getArgAsExpr(0);
4466 if (!checkUInt32Argument(*this, AL, NumParamsExpr, NP)) {
4471 if (Context.getTargetInfo().getRegParmMax() == 0) {
4472 Diag(AL.getLoc(), diag::err_attribute_regparm_wrong_platform)
4473 << NumParamsExpr->getSourceRange();
4479 if (numParams > Context.getTargetInfo().getRegParmMax()) {
4480 Diag(AL.getLoc(), diag::err_attribute_regparm_invalid_number)
4481 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4489 // Checks whether an argument of launch_bounds attribute is
4490 // acceptable, performs implicit conversion to Rvalue, and returns
4491 // non-nullptr Expr result on success. Otherwise, it returns nullptr
4492 // and may output an error.
4493 static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4494 const CUDALaunchBoundsAttr &AL,
4495 const unsigned Idx) {
4496 if (S.DiagnoseUnexpandedParameterPack(E))
4499 // Accept template arguments for now as they depend on something else.
4500 // We'll get to check them when they eventually get instantiated.
4501 if (E->isValueDependent())
4505 if (!E->isIntegerConstantExpr(I, S.Context)) {
4506 S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
4507 << &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
4510 // Make sure we can fit it in 32 bits.
4511 if (!I.isIntN(32)) {
4512 S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
4513 << 32 << /* Unsigned */ 1;
4517 S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
4518 << &AL << Idx << E->getSourceRange();
4520 // We may need to perform implicit conversion of the argument.
4521 InitializedEntity Entity = InitializedEntity::InitializeParameter(
4522 S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
4523 ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
4524 assert(!ValArg.isInvalid() &&
4525 "Unexpected PerformCopyInitialization() failure.");
4527 return ValArg.getAs<Expr>();
4530 void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
4531 Expr *MinBlocks, unsigned SpellingListIndex) {
4532 CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
4534 MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
4535 if (MaxThreads == nullptr)
4539 MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
4540 if (MinBlocks == nullptr)
4544 D->addAttr(::new (Context) CUDALaunchBoundsAttr(
4545 AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
4548 static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4549 if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
4550 !checkAttributeAtMostNumArgs(S, AL, 2))
4553 S.AddLaunchBoundsAttr(AL.getRange(), D, AL.getArgAsExpr(0),
4554 AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr,
4555 AL.getAttributeSpellingListIndex());
4558 static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
4559 const ParsedAttr &AL) {
4560 if (!AL.isArgIdent(0)) {
4561 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4562 << AL.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
4566 ParamIdx ArgumentIdx;
4567 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, AL.getArgAsExpr(1),
4571 ParamIdx TypeTagIdx;
4572 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 3, AL.getArgAsExpr(2),
4576 bool IsPointer = AL.getName()->getName() == "pointer_with_type_tag";
4578 // Ensure that buffer has a pointer type.
4579 unsigned ArgumentIdxAST = ArgumentIdx.getASTIndex();
4580 if (ArgumentIdxAST >= getFunctionOrMethodNumParams(D) ||
4581 !getFunctionOrMethodParamType(D, ArgumentIdxAST)->isPointerType())
4582 S.Diag(AL.getLoc(), diag::err_attribute_pointers_only)
4583 << AL.getName() << 0;
4586 D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(
4587 AL.getRange(), S.Context, AL.getArgAsIdent(0)->Ident, ArgumentIdx,
4588 TypeTagIdx, IsPointer, AL.getAttributeSpellingListIndex()));
4591 static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
4592 const ParsedAttr &AL) {
4593 if (!AL.isArgIdent(0)) {
4594 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4595 << AL.getName() << 1 << AANT_ArgumentIdentifier;
4599 if (!checkAttributeNumArgs(S, AL, 1))
4602 if (!isa<VarDecl>(D)) {
4603 S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type)
4604 << AL.getName() << ExpectedVariable;
4608 IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident;
4609 TypeSourceInfo *MatchingCTypeLoc = nullptr;
4610 S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc);
4611 assert(MatchingCTypeLoc && "no type source info for attribute argument");
4613 D->addAttr(::new (S.Context)
4614 TypeTagForDatatypeAttr(AL.getRange(), S.Context, PointerKind,
4616 AL.getLayoutCompatible(),
4618 AL.getAttributeSpellingListIndex()));
4621 static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4624 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0),
4626 true /* CanIndexImplicitThis */))
4629 // ArgCount isn't a parameter index [0;n), it's a count [1;n]
4630 D->addAttr(::new (S.Context) XRayLogArgsAttr(
4631 AL.getRange(), S.Context, ArgCount.getSourceIndex(),
4632 AL.getAttributeSpellingListIndex()));
4635 //===----------------------------------------------------------------------===//
4636 // Checker-specific attribute handlers.
4637 //===----------------------------------------------------------------------===//
4639 static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) {
4640 return QT->isDependentType() || QT->isObjCRetainableType();
4643 static bool isValidSubjectOfNSAttribute(Sema &S, QualType QT) {
4644 return QT->isDependentType() || QT->isObjCObjectPointerType() ||
4645 S.Context.isObjCNSObjectType(QT);
4648 static bool isValidSubjectOfCFAttribute(Sema &S, QualType QT) {
4649 return QT->isDependentType() || QT->isPointerType() ||
4650 isValidSubjectOfNSAttribute(S, QT);
4653 static void handleNSConsumedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4654 S.AddNSConsumedAttr(AL.getRange(), D, AL.getAttributeSpellingListIndex(),
4655 AL.getKind() == ParsedAttr::AT_NSConsumed,
4656 /*template instantiation*/ false);
4659 void Sema::AddNSConsumedAttr(SourceRange AttrRange, Decl *D,
4660 unsigned SpellingIndex, bool IsNSConsumed,
4661 bool IsTemplateInstantiation) {
4662 const auto *Param = cast<ParmVarDecl>(D);
4666 TypeOK = isValidSubjectOfNSAttribute(*this, Param->getType());
4668 TypeOK = isValidSubjectOfCFAttribute(*this, Param->getType());
4671 // These attributes are normally just advisory, but in ARC, ns_consumed
4672 // is significant. Allow non-dependent code to contain inappropriate
4673 // attributes even in ARC, but require template instantiations to be
4674 // set up correctly.
4675 Diag(D->getLocStart(), (IsTemplateInstantiation && IsNSConsumed &&
4676 getLangOpts().ObjCAutoRefCount
4677 ? diag::err_ns_attribute_wrong_parameter_type
4678 : diag::warn_ns_attribute_wrong_parameter_type))
4679 << AttrRange << (IsNSConsumed ? "ns_consumed" : "cf_consumed")
4680 << (IsNSConsumed ? /*objc pointers*/ 0 : /*cf pointers*/ 1);
4685 D->addAttr(::new (Context)
4686 NSConsumedAttr(AttrRange, Context, SpellingIndex));
4688 D->addAttr(::new (Context)
4689 CFConsumedAttr(AttrRange, Context, SpellingIndex));
4692 bool Sema::checkNSReturnsRetainedReturnType(SourceLocation Loc, QualType QT) {
4693 if (isValidSubjectOfNSReturnsRetainedAttribute(QT))
4696 Diag(Loc, diag::warn_ns_attribute_wrong_return_type)
4697 << "'ns_returns_retained'" << 0 << 0;
4701 static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
4702 const ParsedAttr &AL) {
4703 QualType ReturnType;
4705 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
4706 ReturnType = MD->getReturnType();
4707 else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
4708 (AL.getKind() == ParsedAttr::AT_NSReturnsRetained))
4709 return; // ignore: was handled as a type attribute
4710 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D))
4711 ReturnType = PD->getType();
4712 else if (const auto *FD = dyn_cast<FunctionDecl>(D))
4713 ReturnType = FD->getReturnType();
4714 else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {
4715 ReturnType = Param->getType()->getPointeeType();
4716 if (ReturnType.isNull()) {
4717 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4718 << AL.getName() << /*pointer-to-CF*/2
4722 } else if (AL.isUsedAsTypeAttr()) {
4725 AttributeDeclKind ExpectedDeclKind;
4726 switch (AL.getKind()) {
4727 default: llvm_unreachable("invalid ownership attribute");
4728 case ParsedAttr::AT_NSReturnsRetained:
4729 case ParsedAttr::AT_NSReturnsAutoreleased:
4730 case ParsedAttr::AT_NSReturnsNotRetained:
4731 ExpectedDeclKind = ExpectedFunctionOrMethod;
4734 case ParsedAttr::AT_CFReturnsRetained:
4735 case ParsedAttr::AT_CFReturnsNotRetained:
4736 ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
4739 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4740 << AL.getRange() << AL.getName() << ExpectedDeclKind;
4746 switch (AL.getKind()) {
4747 default: llvm_unreachable("invalid ownership attribute");
4748 case ParsedAttr::AT_NSReturnsRetained:
4749 TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType);
4753 case ParsedAttr::AT_NSReturnsAutoreleased:
4754 case ParsedAttr::AT_NSReturnsNotRetained:
4755 TypeOK = isValidSubjectOfNSAttribute(S, ReturnType);
4759 case ParsedAttr::AT_CFReturnsRetained:
4760 case ParsedAttr::AT_CFReturnsNotRetained:
4761 TypeOK = isValidSubjectOfCFAttribute(S, ReturnType);
4767 if (AL.isUsedAsTypeAttr())
4770 if (isa<ParmVarDecl>(D)) {
4771 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4772 << AL.getName() << /*pointer-to-CF*/2
4775 // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
4780 } SubjectKind = Function;
4781 if (isa<ObjCMethodDecl>(D))
4782 SubjectKind = Method;
4783 else if (isa<ObjCPropertyDecl>(D))
4784 SubjectKind = Property;
4785 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4786 << AL.getName() << SubjectKind << Cf
4792 switch (AL.getKind()) {
4794 llvm_unreachable("invalid ownership attribute");
4795 case ParsedAttr::AT_NSReturnsAutoreleased:
4796 D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
4797 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4799 case ParsedAttr::AT_CFReturnsNotRetained:
4800 D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
4801 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4803 case ParsedAttr::AT_NSReturnsNotRetained:
4804 D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
4805 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4807 case ParsedAttr::AT_CFReturnsRetained:
4808 D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
4809 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4811 case ParsedAttr::AT_NSReturnsRetained:
4812 D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
4813 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4818 static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
4819 const ParsedAttr &Attrs) {
4820 const int EP_ObjCMethod = 1;
4821 const int EP_ObjCProperty = 2;
4823 SourceLocation loc = Attrs.getLoc();
4824 QualType resultType;
4825 if (isa<ObjCMethodDecl>(D))
4826 resultType = cast<ObjCMethodDecl>(D)->getReturnType();
4828 resultType = cast<ObjCPropertyDecl>(D)->getType();
4830 if (!resultType->isReferenceType() &&
4831 (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
4832 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4835 << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
4836 << /*non-retainable pointer*/ 2;
4838 // Drop the attribute.
4842 D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
4843 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
4846 static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
4847 const ParsedAttr &Attrs) {
4848 const auto *Method = cast<ObjCMethodDecl>(D);
4850 const DeclContext *DC = Method->getDeclContext();
4851 if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
4852 S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4853 << Attrs.getName() << 0;
4854 S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
4857 if (Method->getMethodFamily() == OMF_dealloc) {
4858 S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4859 << Attrs.getName() << 1;
4863 D->addAttr(::new (S.Context) ObjCRequiresSuperAttr(
4864 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
4867 static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4868 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
4871 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << AL.getName() << 0;
4875 // Typedefs only allow objc_bridge(id) and have some additional checking.
4876 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
4877 if (!Parm->Ident->isStr("id")) {
4878 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_id)
4883 // Only allow 'cv void *'.
4884 QualType T = TD->getUnderlyingType();
4885 if (!T->isVoidPointerType()) {
4886 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
4891 D->addAttr(::new (S.Context)
4892 ObjCBridgeAttr(AL.getRange(), S.Context, Parm->Ident,
4893 AL.getAttributeSpellingListIndex()));
4896 static void handleObjCBridgeMutableAttr(Sema &S, Decl *D,
4897 const ParsedAttr &AL) {
4898 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
4901 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << AL.getName() << 0;
4905 D->addAttr(::new (S.Context)
4906 ObjCBridgeMutableAttr(AL.getRange(), S.Context, Parm->Ident,
4907 AL.getAttributeSpellingListIndex()));
4910 static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D,
4911 const ParsedAttr &AL) {
4912 IdentifierInfo *RelatedClass =
4913 AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr;
4914 if (!RelatedClass) {
4915 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << AL.getName() << 0;
4918 IdentifierInfo *ClassMethod =
4919 AL.getArgAsIdent(1) ? AL.getArgAsIdent(1)->Ident : nullptr;
4920 IdentifierInfo *InstanceMethod =
4921 AL.getArgAsIdent(2) ? AL.getArgAsIdent(2)->Ident : nullptr;
4922 D->addAttr(::new (S.Context)
4923 ObjCBridgeRelatedAttr(AL.getRange(), S.Context, RelatedClass,
4924 ClassMethod, InstanceMethod,
4925 AL.getAttributeSpellingListIndex()));
4928 static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
4929 const ParsedAttr &AL) {
4930 ObjCInterfaceDecl *IFace;
4931 if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
4932 IFace = CatDecl->getClassInterface();
4934 IFace = cast<ObjCInterfaceDecl>(D->getDeclContext());
4939 IFace->setHasDesignatedInitializers();
4940 D->addAttr(::new (S.Context)
4941 ObjCDesignatedInitializerAttr(AL.getRange(), S.Context,
4942 AL.getAttributeSpellingListIndex()));
4945 static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) {
4946 StringRef MetaDataName;
4947 if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName))
4949 D->addAttr(::new (S.Context)
4950 ObjCRuntimeNameAttr(AL.getRange(), S.Context,
4952 AL.getAttributeSpellingListIndex()));
4955 // When a user wants to use objc_boxable with a union or struct
4956 // but they don't have access to the declaration (legacy/third-party code)
4957 // then they can 'enable' this feature with a typedef:
4958 // typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
4959 static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) {
4960 bool notify = false;
4962 auto *RD = dyn_cast<RecordDecl>(D);
4963 if (RD && RD->getDefinition()) {
4964 RD = RD->getDefinition();
4969 ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
4970 ObjCBoxableAttr(AL.getRange(), S.Context,
4971 AL.getAttributeSpellingListIndex());
4972 RD->addAttr(BoxableAttr);
4974 // we need to notify ASTReader/ASTWriter about
4975 // modification of existing declaration
4976 if (ASTMutationListener *L = S.getASTMutationListener())
4977 L->AddedAttributeToRecord(BoxableAttr, RD);
4982 static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4983 if (hasDeclarator(D)) return;
4985 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4986 << AL.getRange() << AL.getName() << ExpectedVariable;
4989 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
4990 const ParsedAttr &AL) {
4991 const auto *VD = cast<ValueDecl>(D);
4992 QualType QT = VD->getType();
4994 if (!QT->isDependentType() &&
4995 !QT->isObjCLifetimeType()) {
4996 S.Diag(AL.getLoc(), diag::err_objc_precise_lifetime_bad_type)
5001 Qualifiers::ObjCLifetime Lifetime = QT.getObjCLifetime();
5003 // If we have no lifetime yet, check the lifetime we're presumably
5005 if (Lifetime == Qualifiers::OCL_None && !QT->isDependentType())
5006 Lifetime = QT->getObjCARCImplicitLifetime();
5009 case Qualifiers::OCL_None:
5010 assert(QT->isDependentType() &&
5011 "didn't infer lifetime for non-dependent type?");
5014 case Qualifiers::OCL_Weak: // meaningful
5015 case Qualifiers::OCL_Strong: // meaningful
5018 case Qualifiers::OCL_ExplicitNone:
5019 case Qualifiers::OCL_Autoreleasing:
5020 S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
5021 << (Lifetime == Qualifiers::OCL_Autoreleasing);
5025 D->addAttr(::new (S.Context)
5026 ObjCPreciseLifetimeAttr(AL.getRange(), S.Context,
5027 AL.getAttributeSpellingListIndex()));
5030 //===----------------------------------------------------------------------===//
5031 // Microsoft specific attribute handlers.
5032 //===----------------------------------------------------------------------===//
5034 UuidAttr *Sema::mergeUuidAttr(Decl *D, SourceRange Range,
5035 unsigned AttrSpellingListIndex, StringRef Uuid) {
5036 if (const auto *UA = D->getAttr<UuidAttr>()) {
5037 if (UA->getGuid().equals_lower(Uuid))
5039 Diag(UA->getLocation(), diag::err_mismatched_uuid);
5040 Diag(Range.getBegin(), diag::note_previous_uuid);
5041 D->dropAttr<UuidAttr>();
5044 return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
5047 static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5048 if (!S.LangOpts.CPlusPlus) {
5049 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5050 << AL.getName() << AttributeLangSupport::C;
5055 SourceLocation LiteralLoc;
5056 if (!S.checkStringLiteralArgumentAttr(AL, 0, StrRef, &LiteralLoc))
5059 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
5060 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
5061 if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
5062 StrRef = StrRef.drop_front().drop_back();
5064 // Validate GUID length.
5065 if (StrRef.size() != 36) {
5066 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5070 for (unsigned i = 0; i < 36; ++i) {
5071 if (i == 8 || i == 13 || i == 18 || i == 23) {
5072 if (StrRef[i] != '-') {
5073 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5076 } else if (!isHexDigit(StrRef[i])) {
5077 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5082 // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's
5083 // the only thing in the [] list, the [] too), and add an insertion of
5084 // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas
5085 // separating attributes nor of the [ and the ] are in the AST.
5086 // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc"
5088 if (AL.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.
5089 S.Diag(AL.getLoc(), diag::warn_atl_uuid_deprecated);
5091 UuidAttr *UA = S.mergeUuidAttr(D, AL.getRange(),
5092 AL.getAttributeSpellingListIndex(), StrRef);
5097 static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5098 if (!S.LangOpts.CPlusPlus) {
5099 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5100 << AL.getName() << AttributeLangSupport::C;
5103 MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
5104 D, AL.getRange(), /*BestCase=*/true,
5105 AL.getAttributeSpellingListIndex(),
5106 (MSInheritanceAttr::Spelling)AL.getSemanticSpelling());
5109 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
5113 static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5114 const auto *VD = cast<VarDecl>(D);
5115 if (!S.Context.getTargetInfo().isTLSSupported()) {
5116 S.Diag(AL.getLoc(), diag::err_thread_unsupported);
5119 if (VD->getTSCSpec() != TSCS_unspecified) {
5120 S.Diag(AL.getLoc(), diag::err_declspec_thread_on_thread_variable);
5123 if (VD->hasLocalStorage()) {
5124 S.Diag(AL.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
5127 D->addAttr(::new (S.Context) ThreadAttr(AL.getRange(), S.Context,
5128 AL.getAttributeSpellingListIndex()));
5131 static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5132 SmallVector<StringRef, 4> Tags;
5133 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
5135 if (!S.checkStringLiteralArgumentAttr(AL, I, Tag))
5137 Tags.push_back(Tag);
5140 if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
5141 if (!NS->isInline()) {
5142 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5145 if (NS->isAnonymousNamespace()) {
5146 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5149 if (AL.getNumArgs() == 0)
5150 Tags.push_back(NS->getName());
5151 } else if (!checkAttributeAtLeastNumArgs(S, AL, 1))
5154 // Store tags sorted and without duplicates.
5155 llvm::sort(Tags.begin(), Tags.end());
5156 Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5158 D->addAttr(::new (S.Context)
5159 AbiTagAttr(AL.getRange(), S.Context, Tags.data(), Tags.size(),
5160 AL.getAttributeSpellingListIndex()));
5163 static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5164 // Check the attribute arguments.
5165 if (AL.getNumArgs() > 1) {
5166 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
5167 << AL.getName() << 1;
5172 SourceLocation ArgLoc;
5174 if (AL.getNumArgs() == 0)
5176 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5179 ARMInterruptAttr::InterruptType Kind;
5180 if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5181 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
5182 << AL.getName() << Str << ArgLoc;
5186 unsigned Index = AL.getAttributeSpellingListIndex();
5187 D->addAttr(::new (S.Context)
5188 ARMInterruptAttr(AL.getLoc(), S.Context, Kind, Index));
5191 static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5192 if (!checkAttributeNumArgs(S, AL, 1))
5195 if (!AL.isArgExpr(0)) {
5196 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) << AL.getName()
5197 << AANT_ArgumentIntegerConstant;
5201 // FIXME: Check for decl - it should be void ()(void).
5203 Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
5204 llvm::APSInt NumParams(32);
5205 if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
5206 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
5207 << AL.getName() << AANT_ArgumentIntegerConstant
5208 << NumParamsExpr->getSourceRange();
5212 unsigned Num = NumParams.getLimitedValue(255);
5213 if ((Num & 1) || Num > 30) {
5214 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
5215 << AL.getName() << (int)NumParams.getSExtValue()
5216 << NumParamsExpr->getSourceRange();
5220 D->addAttr(::new (S.Context)
5221 MSP430InterruptAttr(AL.getLoc(), S.Context, Num,
5222 AL.getAttributeSpellingListIndex()));
5223 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5226 static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5227 // Only one optional argument permitted.
5228 if (AL.getNumArgs() > 1) {
5229 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
5230 << AL.getName() << 1;
5235 SourceLocation ArgLoc;
5237 if (AL.getNumArgs() == 0)
5239 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5242 // Semantic checks for a function with the 'interrupt' attribute for MIPS:
5243 // a) Must be a function.
5244 // b) Must have no parameters.
5245 // c) Must have the 'void' return type.
5246 // d) Cannot have the 'mips16' attribute, as that instruction set
5247 // lacks the 'eret' instruction.
5248 // e) The attribute itself must either have no argument or one of the
5249 // valid interrupt types, see [MipsInterruptDocs].
5251 if (!isFunctionOrMethod(D)) {
5252 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5253 << "'interrupt'" << ExpectedFunctionOrMethod;
5257 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5258 S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5263 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5264 S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5269 if (checkAttrMutualExclusion<Mips16Attr>(S, D, AL.getRange(),
5273 MipsInterruptAttr::InterruptType Kind;
5274 if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5275 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
5276 << AL.getName() << "'" + std::string(Str) + "'";
5280 D->addAttr(::new (S.Context) MipsInterruptAttr(
5281 AL.getLoc(), S.Context, Kind, AL.getAttributeSpellingListIndex()));
5284 static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5285 // Semantic checks for a function with the 'interrupt' attribute.
5286 // a) Must be a function.
5287 // b) Must have the 'void' return type.
5288 // c) Must take 1 or 2 arguments.
5289 // d) The 1st argument must be a pointer.
5290 // e) The 2nd argument (if any) must be an unsigned integer.
5291 if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) ||
5292 CXXMethodDecl::isStaticOverloadedOperator(
5293 cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {
5294 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
5295 << AL.getName() << ExpectedFunctionWithProtoType;
5298 // Interrupt handler must have void return type.
5299 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5300 S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(),
5301 diag::err_anyx86_interrupt_attribute)
5302 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5308 // Interrupt handler must have 1 or 2 parameters.
5309 unsigned NumParams = getFunctionOrMethodNumParams(D);
5310 if (NumParams < 1 || NumParams > 2) {
5311 S.Diag(D->getLocStart(), diag::err_anyx86_interrupt_attribute)
5312 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5318 // The first argument must be a pointer.
5319 if (!getFunctionOrMethodParamType(D, 0)->isPointerType()) {
5320 S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(),
5321 diag::err_anyx86_interrupt_attribute)
5322 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5328 // The second argument, if present, must be an unsigned integer.
5330 S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86_64
5333 if (NumParams == 2 &&
5334 (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
5335 S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
5336 S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
5337 diag::err_anyx86_interrupt_attribute)
5338 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5341 << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
5344 D->addAttr(::new (S.Context) AnyX86InterruptAttr(
5345 AL.getLoc(), S.Context, AL.getAttributeSpellingListIndex()));
5346 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5349 static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5350 if (!isFunctionOrMethod(D)) {
5351 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5352 << "'interrupt'" << ExpectedFunction;
5356 if (!checkAttributeNumArgs(S, AL, 0))
5359 handleSimpleAttribute<AVRInterruptAttr>(S, D, AL);
5362 static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5363 if (!isFunctionOrMethod(D)) {
5364 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5365 << "'signal'" << ExpectedFunction;
5369 if (!checkAttributeNumArgs(S, AL, 0))
5372 handleSimpleAttribute<AVRSignalAttr>(S, D, AL);
5376 static void handleRISCVInterruptAttr(Sema &S, Decl *D,
5377 const ParsedAttr &AL) {
5378 // Warn about repeated attributes.
5379 if (const auto *A = D->getAttr<RISCVInterruptAttr>()) {
5380 S.Diag(AL.getRange().getBegin(),
5381 diag::warn_riscv_repeated_interrupt_attribute);
5382 S.Diag(A->getLocation(), diag::note_riscv_repeated_interrupt_attribute);
5386 // Check the attribute argument. Argument is optional.
5387 if (!checkAttributeAtMostNumArgs(S, AL, 1))
5391 SourceLocation ArgLoc;
5393 // 'machine'is the default interrupt mode.
5394 if (AL.getNumArgs() == 0)
5396 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5399 // Semantic checks for a function with the 'interrupt' attribute:
5400 // - Must be a function.
5401 // - Must have no parameters.
5402 // - Must have the 'void' return type.
5403 // - The attribute itself must either have no argument or one of the
5404 // valid interrupt types, see [RISCVInterruptDocs].
5406 if (D->getFunctionType() == nullptr) {
5407 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5408 << "'interrupt'" << ExpectedFunction;
5412 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5413 S.Diag(D->getLocation(), diag::warn_riscv_interrupt_attribute) << 0;
5417 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5418 S.Diag(D->getLocation(), diag::warn_riscv_interrupt_attribute) << 1;
5422 RISCVInterruptAttr::InterruptType Kind;
5423 if (!RISCVInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5424 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
5425 << AL.getName() << Str << ArgLoc;
5429 D->addAttr(::new (S.Context) RISCVInterruptAttr(
5430 AL.getLoc(), S.Context, Kind, AL.getAttributeSpellingListIndex()));
5433 static void handleInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5434 // Dispatch the interrupt attribute based on the current target.
5435 switch (S.Context.getTargetInfo().getTriple().getArch()) {
5436 case llvm::Triple::msp430:
5437 handleMSP430InterruptAttr(S, D, AL);
5439 case llvm::Triple::mipsel:
5440 case llvm::Triple::mips:
5441 handleMipsInterruptAttr(S, D, AL);
5443 case llvm::Triple::x86:
5444 case llvm::Triple::x86_64:
5445 handleAnyX86InterruptAttr(S, D, AL);
5447 case llvm::Triple::avr:
5448 handleAVRInterruptAttr(S, D, AL);
5450 case llvm::Triple::riscv32:
5451 case llvm::Triple::riscv64:
5452 handleRISCVInterruptAttr(S, D, AL);
5455 handleARMInterruptAttr(S, D, AL);
5460 static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D,
5461 const ParsedAttr &AL) {
5463 Expr *MinExpr = AL.getArgAsExpr(0);
5464 if (!checkUInt32Argument(S, AL, MinExpr, Min))
5468 Expr *MaxExpr = AL.getArgAsExpr(1);
5469 if (!checkUInt32Argument(S, AL, MaxExpr, Max))
5472 if (Min == 0 && Max != 0) {
5473 S.Diag(AL.getLoc(), diag::err_attribute_argument_invalid)
5474 << AL.getName() << 0;
5478 S.Diag(AL.getLoc(), diag::err_attribute_argument_invalid)
5479 << AL.getName() << 1;
5483 D->addAttr(::new (S.Context)
5484 AMDGPUFlatWorkGroupSizeAttr(AL.getLoc(), S.Context, Min, Max,
5485 AL.getAttributeSpellingListIndex()));
5488 static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5490 Expr *MinExpr = AL.getArgAsExpr(0);
5491 if (!checkUInt32Argument(S, AL, MinExpr, Min))
5495 if (AL.getNumArgs() == 2) {
5496 Expr *MaxExpr = AL.getArgAsExpr(1);
5497 if (!checkUInt32Argument(S, AL, MaxExpr, Max))
5501 if (Min == 0 && Max != 0) {
5502 S.Diag(AL.getLoc(), diag::err_attribute_argument_invalid)
5503 << AL.getName() << 0;
5506 if (Max != 0 && Min > Max) {
5507 S.Diag(AL.getLoc(), diag::err_attribute_argument_invalid)
5508 << AL.getName() << 1;
5512 D->addAttr(::new (S.Context)
5513 AMDGPUWavesPerEUAttr(AL.getLoc(), S.Context, Min, Max,
5514 AL.getAttributeSpellingListIndex()));
5517 static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5518 uint32_t NumSGPR = 0;
5519 Expr *NumSGPRExpr = AL.getArgAsExpr(0);
5520 if (!checkUInt32Argument(S, AL, NumSGPRExpr, NumSGPR))
5523 D->addAttr(::new (S.Context)
5524 AMDGPUNumSGPRAttr(AL.getLoc(), S.Context, NumSGPR,
5525 AL.getAttributeSpellingListIndex()));
5528 static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5529 uint32_t NumVGPR = 0;
5530 Expr *NumVGPRExpr = AL.getArgAsExpr(0);
5531 if (!checkUInt32Argument(S, AL, NumVGPRExpr, NumVGPR))
5534 D->addAttr(::new (S.Context)
5535 AMDGPUNumVGPRAttr(AL.getLoc(), S.Context, NumVGPR,
5536 AL.getAttributeSpellingListIndex()));
5539 static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
5540 const ParsedAttr &AL) {
5541 // If we try to apply it to a function pointer, don't warn, but don't
5542 // do anything, either. It doesn't matter anyway, because there's nothing
5543 // special about calling a force_align_arg_pointer function.
5544 const auto *VD = dyn_cast<ValueDecl>(D);
5545 if (VD && VD->getType()->isFunctionPointerType())
5547 // Also don't warn on function pointer typedefs.
5548 const auto *TD = dyn_cast<TypedefNameDecl>(D);
5549 if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
5550 TD->getUnderlyingType()->isFunctionType()))
5552 // Attribute can only be applied to function types.
5553 if (!isa<FunctionDecl>(D)) {
5554 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
5555 << AL.getName() << ExpectedFunction;
5559 D->addAttr(::new (S.Context)
5560 X86ForceAlignArgPointerAttr(AL.getRange(), S.Context,
5561 AL.getAttributeSpellingListIndex()));
5564 static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL) {
5566 Expr *VersionExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
5567 if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Version))
5570 // TODO: Investigate what happens with the next major version of MSVC.
5571 if (Version != LangOptions::MSVC2015) {
5572 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
5573 << AL.getName() << Version << VersionExpr->getSourceRange();
5577 D->addAttr(::new (S.Context)
5578 LayoutVersionAttr(AL.getRange(), S.Context, Version,
5579 AL.getAttributeSpellingListIndex()));
5582 DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
5583 unsigned AttrSpellingListIndex) {
5584 if (D->hasAttr<DLLExportAttr>()) {
5585 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
5589 if (D->hasAttr<DLLImportAttr>())
5592 return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
5595 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
5596 unsigned AttrSpellingListIndex) {
5597 if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
5598 Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
5599 D->dropAttr<DLLImportAttr>();
5602 if (D->hasAttr<DLLExportAttr>())
5605 return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
5608 static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {
5609 if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
5610 S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5611 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
5616 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
5617 if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport &&
5618 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5619 // MinGW doesn't allow dllimport on inline functions.
5620 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
5626 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
5627 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5628 MD->getParent()->isLambda()) {
5629 S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A.getName();
5634 unsigned Index = A.getAttributeSpellingListIndex();
5635 Attr *NewAttr = A.getKind() == ParsedAttr::AT_DLLExport
5636 ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
5637 : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
5639 D->addAttr(NewAttr);
5643 Sema::mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
5644 unsigned AttrSpellingListIndex,
5645 MSInheritanceAttr::Spelling SemanticSpelling) {
5646 if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
5647 if (IA->getSemanticSpelling() == SemanticSpelling)
5649 Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
5650 << 1 /*previous declaration*/;
5651 Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
5652 D->dropAttr<MSInheritanceAttr>();
5655 auto *RD = cast<CXXRecordDecl>(D);
5656 if (RD->hasDefinition()) {
5657 if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
5658 SemanticSpelling)) {
5662 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
5663 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5664 << 1 /*partial specialization*/;
5667 if (RD->getDescribedClassTemplate()) {
5668 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5669 << 0 /*primary template*/;
5674 return ::new (Context)
5675 MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
5678 static void handleCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5679 // The capability attributes take a single string parameter for the name of
5680 // the capability they represent. The lockable attribute does not take any
5681 // parameters. However, semantically, both attributes represent the same
5682 // concept, and so they use the same semantic attribute. Eventually, the
5683 // lockable attribute will be removed.
5685 // For backward compatibility, any capability which has no specified string
5686 // literal will be considered a "mutex."
5687 StringRef N("mutex");
5688 SourceLocation LiteralLoc;
5689 if (AL.getKind() == ParsedAttr::AT_Capability &&
5690 !S.checkStringLiteralArgumentAttr(AL, 0, N, &LiteralLoc))
5693 // Currently, there are only two names allowed for a capability: role and
5694 // mutex (case insensitive). Diagnose other capability names.
5695 if (!N.equals_lower("mutex") && !N.equals_lower("role"))
5696 S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
5698 D->addAttr(::new (S.Context) CapabilityAttr(AL.getRange(), S.Context, N,
5699 AL.getAttributeSpellingListIndex()));
5702 static void handleAssertCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5703 SmallVector<Expr*, 1> Args;
5704 if (!checkLockFunAttrCommon(S, D, AL, Args))
5707 D->addAttr(::new (S.Context) AssertCapabilityAttr(AL.getRange(), S.Context,
5708 Args.data(), Args.size(),
5709 AL.getAttributeSpellingListIndex()));
5712 static void handleAcquireCapabilityAttr(Sema &S, Decl *D,
5713 const ParsedAttr &AL) {
5714 SmallVector<Expr*, 1> Args;
5715 if (!checkLockFunAttrCommon(S, D, AL, Args))
5718 D->addAttr(::new (S.Context) AcquireCapabilityAttr(AL.getRange(),
5720 Args.data(), Args.size(),
5721 AL.getAttributeSpellingListIndex()));
5724 static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D,
5725 const ParsedAttr &AL) {
5726 SmallVector<Expr*, 2> Args;
5727 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
5730 D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(AL.getRange(),
5735 AL.getAttributeSpellingListIndex()));
5738 static void handleReleaseCapabilityAttr(Sema &S, Decl *D,
5739 const ParsedAttr &AL) {
5740 // Check that all arguments are lockable objects.
5741 SmallVector<Expr *, 1> Args;
5742 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, true);
5744 D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
5745 AL.getRange(), S.Context, Args.data(), Args.size(),
5746 AL.getAttributeSpellingListIndex()));
5749 static void handleRequiresCapabilityAttr(Sema &S, Decl *D,
5750 const ParsedAttr &AL) {
5751 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
5754 // check that all arguments are lockable objects
5755 SmallVector<Expr*, 1> Args;
5756 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
5760 RequiresCapabilityAttr *RCA = ::new (S.Context)
5761 RequiresCapabilityAttr(AL.getRange(), S.Context, Args.data(),
5762 Args.size(), AL.getAttributeSpellingListIndex());
5767 static void handleDeprecatedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5768 if (const auto *NSD = dyn_cast<NamespaceDecl>(D)) {
5769 if (NSD->isAnonymousNamespace()) {
5770 S.Diag(AL.getLoc(), diag::warn_deprecated_anonymous_namespace);
5771 // Do not want to attach the attribute to the namespace because that will
5772 // cause confusing diagnostic reports for uses of declarations within the
5778 // Handle the cases where the attribute has a text message.
5779 StringRef Str, Replacement;
5780 if (AL.isArgExpr(0) && AL.getArgAsExpr(0) &&
5781 !S.checkStringLiteralArgumentAttr(AL, 0, Str))
5784 // Only support a single optional message for Declspec and CXX11.
5785 if (AL.isDeclspecAttribute() || AL.isCXX11Attribute())
5786 checkAttributeAtMostNumArgs(S, AL, 1);
5787 else if (AL.isArgExpr(1) && AL.getArgAsExpr(1) &&
5788 !S.checkStringLiteralArgumentAttr(AL, 1, Replacement))
5791 if (!S.getLangOpts().CPlusPlus14)
5792 if (AL.isCXX11Attribute() &&
5793 !(AL.hasScope() && AL.getScopeName()->isStr("gnu")))
5794 S.Diag(AL.getLoc(), diag::ext_cxx14_attr) << AL.getName();
5796 D->addAttr(::new (S.Context)
5797 DeprecatedAttr(AL.getRange(), S.Context, Str, Replacement,
5798 AL.getAttributeSpellingListIndex()));
5801 static bool isGlobalVar(const Decl *D) {
5802 if (const auto *S = dyn_cast<VarDecl>(D))
5803 return S->hasGlobalStorage();
5807 static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5808 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
5811 std::vector<StringRef> Sanitizers;
5813 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
5814 StringRef SanitizerName;
5815 SourceLocation LiteralLoc;
5817 if (!S.checkStringLiteralArgumentAttr(AL, I, SanitizerName, &LiteralLoc))
5820 if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 0)
5821 S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
5822 else if (isGlobalVar(D) && SanitizerName != "address")
5823 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5824 << AL.getName() << ExpectedFunctionOrMethod;
5825 Sanitizers.push_back(SanitizerName);
5828 D->addAttr(::new (S.Context) NoSanitizeAttr(
5829 AL.getRange(), S.Context, Sanitizers.data(), Sanitizers.size(),
5830 AL.getAttributeSpellingListIndex()));
5833 static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
5834 const ParsedAttr &AL) {
5835 StringRef AttrName = AL.getName()->getName();
5836 normalizeName(AttrName);
5837 StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
5838 .Case("no_address_safety_analysis", "address")
5839 .Case("no_sanitize_address", "address")
5840 .Case("no_sanitize_thread", "thread")
5841 .Case("no_sanitize_memory", "memory");
5842 if (isGlobalVar(D) && SanitizerName != "address")
5843 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5844 << AL.getName() << ExpectedFunction;
5845 D->addAttr(::new (S.Context)
5846 NoSanitizeAttr(AL.getRange(), S.Context, &SanitizerName, 1,
5847 AL.getAttributeSpellingListIndex()));
5850 static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5851 if (InternalLinkageAttr *Internal =
5852 S.mergeInternalLinkageAttr(D, AL.getRange(), AL.getName(),
5853 AL.getAttributeSpellingListIndex()))
5854 D->addAttr(Internal);
5857 static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5858 if (S.LangOpts.OpenCLVersion != 200)
5859 S.Diag(AL.getLoc(), diag::err_attribute_requires_opencl_version)
5860 << AL.getName() << "2.0" << 0;
5862 S.Diag(AL.getLoc(), diag::warn_opencl_attr_deprecated_ignored)
5863 << AL.getName() << "2.0";
5866 /// Handles semantic checking for features that are common to all attributes,
5867 /// such as checking whether a parameter was properly specified, or the correct
5868 /// number of arguments were passed, etc.
5869 static bool handleCommonAttributeFeatures(Sema &S, Decl *D,
5870 const ParsedAttr &AL) {
5871 // Several attributes carry different semantics than the parsing requires, so
5872 // those are opted out of the common argument checks.
5874 // We also bail on unknown and ignored attributes because those are handled
5875 // as part of the target-specific handling logic.
5876 if (AL.getKind() == ParsedAttr::UnknownAttribute)
5878 // Check whether the attribute requires specific language extensions to be
5880 if (!AL.diagnoseLangOpts(S))
5882 // Check whether the attribute appertains to the given subject.
5883 if (!AL.diagnoseAppertainsTo(S, D))
5885 if (AL.hasCustomParsing())
5888 if (AL.getMinArgs() == AL.getMaxArgs()) {
5889 // If there are no optional arguments, then checking for the argument count
5891 if (!checkAttributeNumArgs(S, AL, AL.getMinArgs()))
5894 // There are optional arguments, so checking is slightly more involved.
5895 if (AL.getMinArgs() &&
5896 !checkAttributeAtLeastNumArgs(S, AL, AL.getMinArgs()))
5898 else if (!AL.hasVariadicArg() && AL.getMaxArgs() &&
5899 !checkAttributeAtMostNumArgs(S, AL, AL.getMaxArgs()))
5903 if (S.CheckAttrTarget(AL))
5909 static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5910 if (D->isInvalidDecl())
5913 // Check if there is only one access qualifier.
5914 if (D->hasAttr<OpenCLAccessAttr>()) {
5915 S.Diag(AL.getLoc(), diag::err_opencl_multiple_access_qualifiers)
5916 << D->getSourceRange();
5917 D->setInvalidDecl(true);
5921 // OpenCL v2.0 s6.6 - read_write can be used for image types to specify that an
5922 // image object can be read and written.
5923 // OpenCL v2.0 s6.13.6 - A kernel cannot read from and write to the same pipe
5924 // object. Using the read_write (or __read_write) qualifier with the pipe
5925 // qualifier is a compilation error.
5926 if (const auto *PDecl = dyn_cast<ParmVarDecl>(D)) {
5927 const Type *DeclTy = PDecl->getType().getCanonicalType().getTypePtr();
5928 if (AL.getName()->getName().find("read_write") != StringRef::npos) {
5929 if (S.getLangOpts().OpenCLVersion < 200 || DeclTy->isPipeType()) {
5930 S.Diag(AL.getLoc(), diag::err_opencl_invalid_read_write)
5931 << AL.getName() << PDecl->getType() << DeclTy->isImageType();
5932 D->setInvalidDecl(true);
5938 D->addAttr(::new (S.Context) OpenCLAccessAttr(
5939 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
5942 //===----------------------------------------------------------------------===//
5943 // Top Level Sema Entry Points
5944 //===----------------------------------------------------------------------===//
5946 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
5947 /// the attribute applies to decls. If the attribute is a type attribute, just
5948 /// silently ignore it if a GNU attribute.
5949 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
5950 const ParsedAttr &AL,
5951 bool IncludeCXX11Attributes) {
5952 if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
5955 // Ignore C++11 attributes on declarator chunks: they appertain to the type
5957 if (AL.isCXX11Attribute() && !IncludeCXX11Attributes)
5960 // Unknown attributes are automatically warned on. Target-specific attributes
5961 // which do not apply to the current target architecture are treated as
5962 // though they were unknown attributes.
5963 if (AL.getKind() == ParsedAttr::UnknownAttribute ||
5964 !AL.existsInTarget(S.Context.getTargetInfo())) {
5965 S.Diag(AL.getLoc(), AL.isDeclspecAttribute()
5966 ? diag::warn_unhandled_ms_attribute_ignored
5967 : diag::warn_unknown_attribute_ignored)
5972 if (handleCommonAttributeFeatures(S, D, AL))
5975 switch (AL.getKind()) {
5977 if (!AL.isStmtAttr()) {
5978 // Type attributes are handled elsewhere; silently move on.
5979 assert(AL.isTypeAttr() && "Non-type attribute not handled");
5982 S.Diag(AL.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
5983 << AL.getName() << D->getLocation();
5985 case ParsedAttr::AT_Interrupt:
5986 handleInterruptAttr(S, D, AL);
5988 case ParsedAttr::AT_X86ForceAlignArgPointer:
5989 handleX86ForceAlignArgPointerAttr(S, D, AL);
5991 case ParsedAttr::AT_DLLExport:
5992 case ParsedAttr::AT_DLLImport:
5993 handleDLLAttr(S, D, AL);
5995 case ParsedAttr::AT_Mips16:
5996 handleSimpleAttributeWithExclusions<Mips16Attr, MicroMipsAttr,
5997 MipsInterruptAttr>(S, D, AL);
5999 case ParsedAttr::AT_NoMips16:
6000 handleSimpleAttribute<NoMips16Attr>(S, D, AL);
6002 case ParsedAttr::AT_MicroMips:
6003 handleSimpleAttributeWithExclusions<MicroMipsAttr, Mips16Attr>(S, D, AL);
6005 case ParsedAttr::AT_NoMicroMips:
6006 handleSimpleAttribute<NoMicroMipsAttr>(S, D, AL);
6008 case ParsedAttr::AT_MipsLongCall:
6009 handleSimpleAttributeWithExclusions<MipsLongCallAttr, MipsShortCallAttr>(
6012 case ParsedAttr::AT_MipsShortCall:
6013 handleSimpleAttributeWithExclusions<MipsShortCallAttr, MipsLongCallAttr>(
6016 case ParsedAttr::AT_AMDGPUFlatWorkGroupSize:
6017 handleAMDGPUFlatWorkGroupSizeAttr(S, D, AL);
6019 case ParsedAttr::AT_AMDGPUWavesPerEU:
6020 handleAMDGPUWavesPerEUAttr(S, D, AL);
6022 case ParsedAttr::AT_AMDGPUNumSGPR:
6023 handleAMDGPUNumSGPRAttr(S, D, AL);
6025 case ParsedAttr::AT_AMDGPUNumVGPR:
6026 handleAMDGPUNumVGPRAttr(S, D, AL);
6028 case ParsedAttr::AT_AVRSignal:
6029 handleAVRSignalAttr(S, D, AL);
6031 case ParsedAttr::AT_IBAction:
6032 handleSimpleAttribute<IBActionAttr>(S, D, AL);
6034 case ParsedAttr::AT_IBOutlet:
6035 handleIBOutlet(S, D, AL);
6037 case ParsedAttr::AT_IBOutletCollection:
6038 handleIBOutletCollection(S, D, AL);
6040 case ParsedAttr::AT_IFunc:
6041 handleIFuncAttr(S, D, AL);
6043 case ParsedAttr::AT_Alias:
6044 handleAliasAttr(S, D, AL);
6046 case ParsedAttr::AT_Aligned:
6047 handleAlignedAttr(S, D, AL);
6049 case ParsedAttr::AT_AlignValue:
6050 handleAlignValueAttr(S, D, AL);
6052 case ParsedAttr::AT_AllocSize:
6053 handleAllocSizeAttr(S, D, AL);
6055 case ParsedAttr::AT_AlwaysInline:
6056 handleAlwaysInlineAttr(S, D, AL);
6058 case ParsedAttr::AT_Artificial:
6059 handleSimpleAttribute<ArtificialAttr>(S, D, AL);
6061 case ParsedAttr::AT_AnalyzerNoReturn:
6062 handleAnalyzerNoReturnAttr(S, D, AL);
6064 case ParsedAttr::AT_TLSModel:
6065 handleTLSModelAttr(S, D, AL);
6067 case ParsedAttr::AT_Annotate:
6068 handleAnnotateAttr(S, D, AL);
6070 case ParsedAttr::AT_Availability:
6071 handleAvailabilityAttr(S, D, AL);
6073 case ParsedAttr::AT_CarriesDependency:
6074 handleDependencyAttr(S, scope, D, AL);
6076 case ParsedAttr::AT_CPUDispatch:
6077 case ParsedAttr::AT_CPUSpecific:
6078 handleCPUSpecificAttr(S, D, AL);
6080 case ParsedAttr::AT_Common:
6081 handleCommonAttr(S, D, AL);
6083 case ParsedAttr::AT_CUDAConstant:
6084 handleConstantAttr(S, D, AL);
6086 case ParsedAttr::AT_PassObjectSize:
6087 handlePassObjectSizeAttr(S, D, AL);
6089 case ParsedAttr::AT_Constructor:
6090 handleConstructorAttr(S, D, AL);
6092 case ParsedAttr::AT_CXX11NoReturn:
6093 handleSimpleAttribute<CXX11NoReturnAttr>(S, D, AL);
6095 case ParsedAttr::AT_Deprecated:
6096 handleDeprecatedAttr(S, D, AL);
6098 case ParsedAttr::AT_Destructor:
6099 handleDestructorAttr(S, D, AL);
6101 case ParsedAttr::AT_EnableIf:
6102 handleEnableIfAttr(S, D, AL);
6104 case ParsedAttr::AT_DiagnoseIf:
6105 handleDiagnoseIfAttr(S, D, AL);
6107 case ParsedAttr::AT_ExtVectorType:
6108 handleExtVectorTypeAttr(S, D, AL);
6110 case ParsedAttr::AT_ExternalSourceSymbol:
6111 handleExternalSourceSymbolAttr(S, D, AL);
6113 case ParsedAttr::AT_MinSize:
6114 handleMinSizeAttr(S, D, AL);
6116 case ParsedAttr::AT_OptimizeNone:
6117 handleOptimizeNoneAttr(S, D, AL);
6119 case ParsedAttr::AT_FlagEnum:
6120 handleSimpleAttribute<FlagEnumAttr>(S, D, AL);
6122 case ParsedAttr::AT_EnumExtensibility:
6123 handleEnumExtensibilityAttr(S, D, AL);
6125 case ParsedAttr::AT_Flatten:
6126 handleSimpleAttribute<FlattenAttr>(S, D, AL);
6128 case ParsedAttr::AT_Format:
6129 handleFormatAttr(S, D, AL);
6131 case ParsedAttr::AT_FormatArg:
6132 handleFormatArgAttr(S, D, AL);
6134 case ParsedAttr::AT_CUDAGlobal:
6135 handleGlobalAttr(S, D, AL);
6137 case ParsedAttr::AT_CUDADevice:
6138 handleSimpleAttributeWithExclusions<CUDADeviceAttr, CUDAGlobalAttr>(S, D,
6141 case ParsedAttr::AT_CUDAHost:
6142 handleSimpleAttributeWithExclusions<CUDAHostAttr, CUDAGlobalAttr>(S, D, AL);
6144 case ParsedAttr::AT_GNUInline:
6145 handleGNUInlineAttr(S, D, AL);
6147 case ParsedAttr::AT_CUDALaunchBounds:
6148 handleLaunchBoundsAttr(S, D, AL);
6150 case ParsedAttr::AT_Restrict:
6151 handleRestrictAttr(S, D, AL);
6153 case ParsedAttr::AT_LifetimeBound:
6154 handleSimpleAttribute<LifetimeBoundAttr>(S, D, AL);
6156 case ParsedAttr::AT_MayAlias:
6157 handleSimpleAttribute<MayAliasAttr>(S, D, AL);
6159 case ParsedAttr::AT_Mode:
6160 handleModeAttr(S, D, AL);
6162 case ParsedAttr::AT_NoAlias:
6163 handleSimpleAttribute<NoAliasAttr>(S, D, AL);
6165 case ParsedAttr::AT_NoCommon:
6166 handleSimpleAttribute<NoCommonAttr>(S, D, AL);
6168 case ParsedAttr::AT_NoSplitStack:
6169 handleSimpleAttribute<NoSplitStackAttr>(S, D, AL);
6171 case ParsedAttr::AT_NonNull:
6172 if (auto *PVD = dyn_cast<ParmVarDecl>(D))
6173 handleNonNullAttrParameter(S, PVD, AL);
6175 handleNonNullAttr(S, D, AL);
6177 case ParsedAttr::AT_ReturnsNonNull:
6178 handleReturnsNonNullAttr(S, D, AL);
6180 case ParsedAttr::AT_NoEscape:
6181 handleNoEscapeAttr(S, D, AL);
6183 case ParsedAttr::AT_AssumeAligned:
6184 handleAssumeAlignedAttr(S, D, AL);
6186 case ParsedAttr::AT_AllocAlign:
6187 handleAllocAlignAttr(S, D, AL);
6189 case ParsedAttr::AT_Overloadable:
6190 handleSimpleAttribute<OverloadableAttr>(S, D, AL);
6192 case ParsedAttr::AT_Ownership:
6193 handleOwnershipAttr(S, D, AL);
6195 case ParsedAttr::AT_Cold:
6196 handleSimpleAttributeWithExclusions<ColdAttr, HotAttr>(S, D, AL);
6198 case ParsedAttr::AT_Hot:
6199 handleSimpleAttributeWithExclusions<HotAttr, ColdAttr>(S, D, AL);
6201 case ParsedAttr::AT_Naked:
6202 handleNakedAttr(S, D, AL);
6204 case ParsedAttr::AT_NoReturn:
6205 handleNoReturnAttr(S, D, AL);
6207 case ParsedAttr::AT_AnyX86NoCfCheck:
6208 handleNoCfCheckAttr(S, D, AL);
6210 case ParsedAttr::AT_NoThrow:
6211 handleSimpleAttribute<NoThrowAttr>(S, D, AL);
6213 case ParsedAttr::AT_CUDAShared:
6214 handleSharedAttr(S, D, AL);
6216 case ParsedAttr::AT_VecReturn:
6217 handleVecReturnAttr(S, D, AL);
6219 case ParsedAttr::AT_ObjCOwnership:
6220 handleObjCOwnershipAttr(S, D, AL);
6222 case ParsedAttr::AT_ObjCPreciseLifetime:
6223 handleObjCPreciseLifetimeAttr(S, D, AL);
6225 case ParsedAttr::AT_ObjCReturnsInnerPointer:
6226 handleObjCReturnsInnerPointerAttr(S, D, AL);
6228 case ParsedAttr::AT_ObjCRequiresSuper:
6229 handleObjCRequiresSuperAttr(S, D, AL);
6231 case ParsedAttr::AT_ObjCBridge:
6232 handleObjCBridgeAttr(S, D, AL);
6234 case ParsedAttr::AT_ObjCBridgeMutable:
6235 handleObjCBridgeMutableAttr(S, D, AL);
6237 case ParsedAttr::AT_ObjCBridgeRelated:
6238 handleObjCBridgeRelatedAttr(S, D, AL);
6240 case ParsedAttr::AT_ObjCDesignatedInitializer:
6241 handleObjCDesignatedInitializer(S, D, AL);
6243 case ParsedAttr::AT_ObjCRuntimeName:
6244 handleObjCRuntimeName(S, D, AL);
6246 case ParsedAttr::AT_ObjCRuntimeVisible:
6247 handleSimpleAttribute<ObjCRuntimeVisibleAttr>(S, D, AL);
6249 case ParsedAttr::AT_ObjCBoxable:
6250 handleObjCBoxable(S, D, AL);
6252 case ParsedAttr::AT_CFAuditedTransfer:
6253 handleSimpleAttributeWithExclusions<CFAuditedTransferAttr,
6254 CFUnknownTransferAttr>(S, D, AL);
6256 case ParsedAttr::AT_CFUnknownTransfer:
6257 handleSimpleAttributeWithExclusions<CFUnknownTransferAttr,
6258 CFAuditedTransferAttr>(S, D, AL);
6260 case ParsedAttr::AT_CFConsumed:
6261 case ParsedAttr::AT_NSConsumed:
6262 handleNSConsumedAttr(S, D, AL);
6264 case ParsedAttr::AT_NSConsumesSelf:
6265 handleSimpleAttribute<NSConsumesSelfAttr>(S, D, AL);
6267 case ParsedAttr::AT_NSReturnsAutoreleased:
6268 case ParsedAttr::AT_NSReturnsNotRetained:
6269 case ParsedAttr::AT_CFReturnsNotRetained:
6270 case ParsedAttr::AT_NSReturnsRetained:
6271 case ParsedAttr::AT_CFReturnsRetained:
6272 handleNSReturnsRetainedAttr(S, D, AL);
6274 case ParsedAttr::AT_WorkGroupSizeHint:
6275 handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, AL);
6277 case ParsedAttr::AT_ReqdWorkGroupSize:
6278 handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, AL);
6280 case ParsedAttr::AT_OpenCLIntelReqdSubGroupSize:
6281 handleSubGroupSize(S, D, AL);
6283 case ParsedAttr::AT_VecTypeHint:
6284 handleVecTypeHint(S, D, AL);
6286 case ParsedAttr::AT_RequireConstantInit:
6287 handleSimpleAttribute<RequireConstantInitAttr>(S, D, AL);
6289 case ParsedAttr::AT_InitPriority:
6290 handleInitPriorityAttr(S, D, AL);
6292 case ParsedAttr::AT_Packed:
6293 handlePackedAttr(S, D, AL);
6295 case ParsedAttr::AT_Section:
6296 handleSectionAttr(S, D, AL);
6298 case ParsedAttr::AT_CodeSeg:
6299 handleCodeSegAttr(S, D, AL);
6301 case ParsedAttr::AT_Target:
6302 handleTargetAttr(S, D, AL);
6304 case ParsedAttr::AT_MinVectorWidth:
6305 handleMinVectorWidthAttr(S, D, AL);
6307 case ParsedAttr::AT_Unavailable:
6308 handleAttrWithMessage<UnavailableAttr>(S, D, AL);
6310 case ParsedAttr::AT_ArcWeakrefUnavailable:
6311 handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, AL);
6313 case ParsedAttr::AT_ObjCRootClass:
6314 handleSimpleAttribute<ObjCRootClassAttr>(S, D, AL);
6316 case ParsedAttr::AT_ObjCSubclassingRestricted:
6317 handleSimpleAttribute<ObjCSubclassingRestrictedAttr>(S, D, AL);
6319 case ParsedAttr::AT_ObjCExplicitProtocolImpl:
6320 handleObjCSuppresProtocolAttr(S, D, AL);
6322 case ParsedAttr::AT_ObjCRequiresPropertyDefs:
6323 handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, AL);
6325 case ParsedAttr::AT_Unused:
6326 handleUnusedAttr(S, D, AL);
6328 case ParsedAttr::AT_ReturnsTwice:
6329 handleSimpleAttribute<ReturnsTwiceAttr>(S, D, AL);
6331 case ParsedAttr::AT_NotTailCalled:
6332 handleSimpleAttributeWithExclusions<NotTailCalledAttr, AlwaysInlineAttr>(
6335 case ParsedAttr::AT_DisableTailCalls:
6336 handleSimpleAttributeWithExclusions<DisableTailCallsAttr, NakedAttr>(S, D,
6339 case ParsedAttr::AT_Used:
6340 handleSimpleAttribute<UsedAttr>(S, D, AL);
6342 case ParsedAttr::AT_Visibility:
6343 handleVisibilityAttr(S, D, AL, false);
6345 case ParsedAttr::AT_TypeVisibility:
6346 handleVisibilityAttr(S, D, AL, true);
6348 case ParsedAttr::AT_WarnUnused:
6349 handleSimpleAttribute<WarnUnusedAttr>(S, D, AL);
6351 case ParsedAttr::AT_WarnUnusedResult:
6352 handleWarnUnusedResult(S, D, AL);
6354 case ParsedAttr::AT_Weak:
6355 handleSimpleAttribute<WeakAttr>(S, D, AL);
6357 case ParsedAttr::AT_WeakRef:
6358 handleWeakRefAttr(S, D, AL);
6360 case ParsedAttr::AT_WeakImport:
6361 handleWeakImportAttr(S, D, AL);
6363 case ParsedAttr::AT_TransparentUnion:
6364 handleTransparentUnionAttr(S, D, AL);
6366 case ParsedAttr::AT_ObjCException:
6367 handleSimpleAttribute<ObjCExceptionAttr>(S, D, AL);
6369 case ParsedAttr::AT_ObjCMethodFamily:
6370 handleObjCMethodFamilyAttr(S, D, AL);
6372 case ParsedAttr::AT_ObjCNSObject:
6373 handleObjCNSObject(S, D, AL);
6375 case ParsedAttr::AT_ObjCIndependentClass:
6376 handleObjCIndependentClass(S, D, AL);
6378 case ParsedAttr::AT_Blocks:
6379 handleBlocksAttr(S, D, AL);
6381 case ParsedAttr::AT_Sentinel:
6382 handleSentinelAttr(S, D, AL);
6384 case ParsedAttr::AT_Const:
6385 handleSimpleAttribute<ConstAttr>(S, D, AL);
6387 case ParsedAttr::AT_Pure:
6388 handleSimpleAttribute<PureAttr>(S, D, AL);
6390 case ParsedAttr::AT_Cleanup:
6391 handleCleanupAttr(S, D, AL);
6393 case ParsedAttr::AT_NoDebug:
6394 handleNoDebugAttr(S, D, AL);
6396 case ParsedAttr::AT_NoDuplicate:
6397 handleSimpleAttribute<NoDuplicateAttr>(S, D, AL);
6399 case ParsedAttr::AT_Convergent:
6400 handleSimpleAttribute<ConvergentAttr>(S, D, AL);
6402 case ParsedAttr::AT_NoInline:
6403 handleSimpleAttribute<NoInlineAttr>(S, D, AL);
6405 case ParsedAttr::AT_NoInstrumentFunction: // Interacts with -pg.
6406 handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, AL);
6408 case ParsedAttr::AT_NoStackProtector:
6409 // Interacts with -fstack-protector options.
6410 handleSimpleAttribute<NoStackProtectorAttr>(S, D, AL);
6412 case ParsedAttr::AT_StdCall:
6413 case ParsedAttr::AT_CDecl:
6414 case ParsedAttr::AT_FastCall:
6415 case ParsedAttr::AT_ThisCall:
6416 case ParsedAttr::AT_Pascal:
6417 case ParsedAttr::AT_RegCall:
6418 case ParsedAttr::AT_SwiftCall:
6419 case ParsedAttr::AT_VectorCall:
6420 case ParsedAttr::AT_MSABI:
6421 case ParsedAttr::AT_SysVABI:
6422 case ParsedAttr::AT_Pcs:
6423 case ParsedAttr::AT_IntelOclBicc:
6424 case ParsedAttr::AT_PreserveMost:
6425 case ParsedAttr::AT_PreserveAll:
6426 handleCallConvAttr(S, D, AL);
6428 case ParsedAttr::AT_Suppress:
6429 handleSuppressAttr(S, D, AL);
6431 case ParsedAttr::AT_OpenCLKernel:
6432 handleSimpleAttribute<OpenCLKernelAttr>(S, D, AL);
6434 case ParsedAttr::AT_OpenCLAccess:
6435 handleOpenCLAccessAttr(S, D, AL);
6437 case ParsedAttr::AT_OpenCLNoSVM:
6438 handleOpenCLNoSVMAttr(S, D, AL);
6440 case ParsedAttr::AT_SwiftContext:
6441 handleParameterABIAttr(S, D, AL, ParameterABI::SwiftContext);
6443 case ParsedAttr::AT_SwiftErrorResult:
6444 handleParameterABIAttr(S, D, AL, ParameterABI::SwiftErrorResult);
6446 case ParsedAttr::AT_SwiftIndirectResult:
6447 handleParameterABIAttr(S, D, AL, ParameterABI::SwiftIndirectResult);
6449 case ParsedAttr::AT_InternalLinkage:
6450 handleInternalLinkageAttr(S, D, AL);
6452 case ParsedAttr::AT_LTOVisibilityPublic:
6453 handleSimpleAttribute<LTOVisibilityPublicAttr>(S, D, AL);
6456 // Microsoft attributes:
6457 case ParsedAttr::AT_EmptyBases:
6458 handleSimpleAttribute<EmptyBasesAttr>(S, D, AL);
6460 case ParsedAttr::AT_LayoutVersion:
6461 handleLayoutVersion(S, D, AL);
6463 case ParsedAttr::AT_TrivialABI:
6464 handleSimpleAttribute<TrivialABIAttr>(S, D, AL);
6466 case ParsedAttr::AT_MSNoVTable:
6467 handleSimpleAttribute<MSNoVTableAttr>(S, D, AL);
6469 case ParsedAttr::AT_MSStruct:
6470 handleSimpleAttribute<MSStructAttr>(S, D, AL);
6472 case ParsedAttr::AT_Uuid:
6473 handleUuidAttr(S, D, AL);
6475 case ParsedAttr::AT_MSInheritance:
6476 handleMSInheritanceAttr(S, D, AL);
6478 case ParsedAttr::AT_SelectAny:
6479 handleSimpleAttribute<SelectAnyAttr>(S, D, AL);
6481 case ParsedAttr::AT_Thread:
6482 handleDeclspecThreadAttr(S, D, AL);
6485 case ParsedAttr::AT_AbiTag:
6486 handleAbiTagAttr(S, D, AL);
6489 // Thread safety attributes:
6490 case ParsedAttr::AT_AssertExclusiveLock:
6491 handleAssertExclusiveLockAttr(S, D, AL);
6493 case ParsedAttr::AT_AssertSharedLock:
6494 handleAssertSharedLockAttr(S, D, AL);
6496 case ParsedAttr::AT_GuardedVar:
6497 handleSimpleAttribute<GuardedVarAttr>(S, D, AL);
6499 case ParsedAttr::AT_PtGuardedVar:
6500 handlePtGuardedVarAttr(S, D, AL);
6502 case ParsedAttr::AT_ScopedLockable:
6503 handleSimpleAttribute<ScopedLockableAttr>(S, D, AL);
6505 case ParsedAttr::AT_NoSanitize:
6506 handleNoSanitizeAttr(S, D, AL);
6508 case ParsedAttr::AT_NoSanitizeSpecific:
6509 handleNoSanitizeSpecificAttr(S, D, AL);
6511 case ParsedAttr::AT_NoThreadSafetyAnalysis:
6512 handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, AL);
6514 case ParsedAttr::AT_GuardedBy:
6515 handleGuardedByAttr(S, D, AL);
6517 case ParsedAttr::AT_PtGuardedBy:
6518 handlePtGuardedByAttr(S, D, AL);
6520 case ParsedAttr::AT_ExclusiveTrylockFunction:
6521 handleExclusiveTrylockFunctionAttr(S, D, AL);
6523 case ParsedAttr::AT_LockReturned:
6524 handleLockReturnedAttr(S, D, AL);
6526 case ParsedAttr::AT_LocksExcluded:
6527 handleLocksExcludedAttr(S, D, AL);
6529 case ParsedAttr::AT_SharedTrylockFunction:
6530 handleSharedTrylockFunctionAttr(S, D, AL);
6532 case ParsedAttr::AT_AcquiredBefore:
6533 handleAcquiredBeforeAttr(S, D, AL);
6535 case ParsedAttr::AT_AcquiredAfter:
6536 handleAcquiredAfterAttr(S, D, AL);
6539 // Capability analysis attributes.
6540 case ParsedAttr::AT_Capability:
6541 case ParsedAttr::AT_Lockable:
6542 handleCapabilityAttr(S, D, AL);
6544 case ParsedAttr::AT_RequiresCapability:
6545 handleRequiresCapabilityAttr(S, D, AL);
6548 case ParsedAttr::AT_AssertCapability:
6549 handleAssertCapabilityAttr(S, D, AL);
6551 case ParsedAttr::AT_AcquireCapability:
6552 handleAcquireCapabilityAttr(S, D, AL);
6554 case ParsedAttr::AT_ReleaseCapability:
6555 handleReleaseCapabilityAttr(S, D, AL);
6557 case ParsedAttr::AT_TryAcquireCapability:
6558 handleTryAcquireCapabilityAttr(S, D, AL);
6561 // Consumed analysis attributes.
6562 case ParsedAttr::AT_Consumable:
6563 handleConsumableAttr(S, D, AL);
6565 case ParsedAttr::AT_ConsumableAutoCast:
6566 handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, AL);
6568 case ParsedAttr::AT_ConsumableSetOnRead:
6569 handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, AL);
6571 case ParsedAttr::AT_CallableWhen:
6572 handleCallableWhenAttr(S, D, AL);
6574 case ParsedAttr::AT_ParamTypestate:
6575 handleParamTypestateAttr(S, D, AL);
6577 case ParsedAttr::AT_ReturnTypestate:
6578 handleReturnTypestateAttr(S, D, AL);
6580 case ParsedAttr::AT_SetTypestate:
6581 handleSetTypestateAttr(S, D, AL);
6583 case ParsedAttr::AT_TestTypestate:
6584 handleTestTypestateAttr(S, D, AL);
6587 // Type safety attributes.
6588 case ParsedAttr::AT_ArgumentWithTypeTag:
6589 handleArgumentWithTypeTagAttr(S, D, AL);
6591 case ParsedAttr::AT_TypeTagForDatatype:
6592 handleTypeTagForDatatypeAttr(S, D, AL);
6594 case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:
6595 handleSimpleAttribute<AnyX86NoCallerSavedRegistersAttr>(S, D, AL);
6597 case ParsedAttr::AT_RenderScriptKernel:
6598 handleSimpleAttribute<RenderScriptKernelAttr>(S, D, AL);
6601 case ParsedAttr::AT_XRayInstrument:
6602 handleSimpleAttribute<XRayInstrumentAttr>(S, D, AL);
6604 case ParsedAttr::AT_XRayLogArgs:
6605 handleXRayLogArgsAttr(S, D, AL);
6610 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
6611 /// attribute list to the specified decl, ignoring any type attributes.
6612 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
6613 const ParsedAttributesView &AttrList,
6614 bool IncludeCXX11Attributes) {
6615 if (AttrList.empty())
6618 for (const ParsedAttr &AL : AttrList)
6619 ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes);
6621 // FIXME: We should be able to handle these cases in TableGen.
6623 // static int a9 __attribute__((weakref));
6624 // but that looks really pointless. We reject it.
6625 if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
6626 Diag(AttrList.begin()->getLoc(), diag::err_attribute_weakref_without_alias)
6627 << cast<NamedDecl>(D);
6628 D->dropAttr<WeakRefAttr>();
6632 // FIXME: We should be able to handle this in TableGen as well. It would be
6633 // good to have a way to specify "these attributes must appear as a group",
6634 // for these. Additionally, it would be good to have a way to specify "these
6635 // attribute must never appear as a group" for attributes like cold and hot.
6636 if (!D->hasAttr<OpenCLKernelAttr>()) {
6637 // These attributes cannot be applied to a non-kernel function.
6638 if (const auto *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
6639 // FIXME: This emits a different error message than
6640 // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
6641 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6642 D->setInvalidDecl();
6643 } else if (const auto *A = D->getAttr<WorkGroupSizeHintAttr>()) {
6644 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6645 D->setInvalidDecl();
6646 } else if (const auto *A = D->getAttr<VecTypeHintAttr>()) {
6647 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6648 D->setInvalidDecl();
6649 } else if (const auto *A = D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
6650 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6651 D->setInvalidDecl();
6652 } else if (!D->hasAttr<CUDAGlobalAttr>()) {
6653 if (const auto *A = D->getAttr<AMDGPUFlatWorkGroupSizeAttr>()) {
6654 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6655 << A << ExpectedKernelFunction;
6656 D->setInvalidDecl();
6657 } else if (const auto *A = D->getAttr<AMDGPUWavesPerEUAttr>()) {
6658 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6659 << A << ExpectedKernelFunction;
6660 D->setInvalidDecl();
6661 } else if (const auto *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
6662 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6663 << A << ExpectedKernelFunction;
6664 D->setInvalidDecl();
6665 } else if (const auto *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
6666 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6667 << A << ExpectedKernelFunction;
6668 D->setInvalidDecl();
6674 // Helper for delayed processing TransparentUnion attribute.
6675 void Sema::ProcessDeclAttributeDelayed(Decl *D,
6676 const ParsedAttributesView &AttrList) {
6677 for (const ParsedAttr &AL : AttrList)
6678 if (AL.getKind() == ParsedAttr::AT_TransparentUnion) {
6679 handleTransparentUnionAttr(*this, D, AL);
6684 // Annotation attributes are the only attributes allowed after an access
6686 bool Sema::ProcessAccessDeclAttributeList(
6687 AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList) {
6688 for (const ParsedAttr &AL : AttrList) {
6689 if (AL.getKind() == ParsedAttr::AT_Annotate) {
6690 ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute());
6692 Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
6699 /// checkUnusedDeclAttributes - Check a list of attributes to see if it
6700 /// contains any decl attributes that we should warn about.
6701 static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A) {
6702 for (const ParsedAttr &AL : A) {
6703 // Only warn if the attribute is an unignored, non-type attribute.
6704 if (AL.isUsedAsTypeAttr() || AL.isInvalid())
6706 if (AL.getKind() == ParsedAttr::IgnoredAttribute)
6709 if (AL.getKind() == ParsedAttr::UnknownAttribute) {
6710 S.Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
6711 << AL.getName() << AL.getRange();
6713 S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl)
6714 << AL.getName() << AL.getRange();
6719 /// checkUnusedDeclAttributes - Given a declarator which is not being
6720 /// used to build a declaration, complain about any decl attributes
6721 /// which might be lying around on it.
6722 void Sema::checkUnusedDeclAttributes(Declarator &D) {
6723 ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes());
6724 ::checkUnusedDeclAttributes(*this, D.getAttributes());
6725 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
6726 ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
6729 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
6730 /// \#pragma weak needs a non-definition decl and source may not have one.
6731 NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
6732 SourceLocation Loc) {
6733 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
6734 NamedDecl *NewD = nullptr;
6735 if (auto *FD = dyn_cast<FunctionDecl>(ND)) {
6736 FunctionDecl *NewFD;
6737 // FIXME: Missing call to CheckFunctionDeclaration().
6739 // FIXME: Is the qualifier info correct?
6740 // FIXME: Is the DeclContext correct?
6741 NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
6742 Loc, Loc, DeclarationName(II),
6743 FD->getType(), FD->getTypeSourceInfo(),
6744 SC_None, false/*isInlineSpecified*/,
6746 false/*isConstexprSpecified*/);
6749 if (FD->getQualifier())
6750 NewFD->setQualifierInfo(FD->getQualifierLoc());
6752 // Fake up parameter variables; they are declared as if this were
6754 QualType FDTy = FD->getType();
6755 if (const auto *FT = FDTy->getAs<FunctionProtoType>()) {
6756 SmallVector<ParmVarDecl*, 16> Params;
6757 for (const auto &AI : FT->param_types()) {
6758 ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI);
6759 Param->setScopeInfo(0, Params.size());
6760 Params.push_back(Param);
6762 NewFD->setParams(Params);
6764 } else if (auto *VD = dyn_cast<VarDecl>(ND)) {
6765 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
6766 VD->getInnerLocStart(), VD->getLocation(), II,
6767 VD->getType(), VD->getTypeSourceInfo(),
6768 VD->getStorageClass());
6769 if (VD->getQualifier())
6770 cast<VarDecl>(NewD)->setQualifierInfo(VD->getQualifierLoc());
6775 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
6776 /// applied to it, possibly with an alias.
6777 void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
6778 if (W.getUsed()) return; // only do this once
6780 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
6781 IdentifierInfo *NDId = ND->getIdentifier();
6782 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
6783 NewD->addAttr(AliasAttr::CreateImplicit(Context, NDId->getName(),
6785 NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6786 WeakTopLevelDecl.push_back(NewD);
6787 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
6788 // to insert Decl at TU scope, sorry.
6789 DeclContext *SavedContext = CurContext;
6790 CurContext = Context.getTranslationUnitDecl();
6791 NewD->setDeclContext(CurContext);
6792 NewD->setLexicalDeclContext(CurContext);
6793 PushOnScopeChains(NewD, S);
6794 CurContext = SavedContext;
6795 } else { // just add weak to existing
6796 ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6800 void Sema::ProcessPragmaWeak(Scope *S, Decl *D) {
6801 // It's valid to "forward-declare" #pragma weak, in which case we
6803 LoadExternalWeakUndeclaredIdentifiers();
6804 if (!WeakUndeclaredIdentifiers.empty()) {
6805 NamedDecl *ND = nullptr;
6806 if (auto *VD = dyn_cast<VarDecl>(D))
6807 if (VD->isExternC())
6809 if (auto *FD = dyn_cast<FunctionDecl>(D))
6810 if (FD->isExternC())
6813 if (IdentifierInfo *Id = ND->getIdentifier()) {
6814 auto I = WeakUndeclaredIdentifiers.find(Id);
6815 if (I != WeakUndeclaredIdentifiers.end()) {
6816 WeakInfo W = I->second;
6817 DeclApplyPragmaWeak(S, ND, W);
6818 WeakUndeclaredIdentifiers[Id] = W;
6825 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
6826 /// it, apply them to D. This is a bit tricky because PD can have attributes
6827 /// specified in many different places, and we need to find and apply them all.
6828 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
6829 // Apply decl attributes from the DeclSpec if present.
6830 if (!PD.getDeclSpec().getAttributes().empty())
6831 ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes());
6833 // Walk the declarator structure, applying decl attributes that were in a type
6834 // position to the decl itself. This handles cases like:
6835 // int *__attr__(x)** D;
6836 // when X is a decl attribute.
6837 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
6838 ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(),
6839 /*IncludeCXX11Attributes=*/false);
6841 // Finally, apply any attributes on the decl itself.
6842 ProcessDeclAttributeList(S, D, PD.getAttributes());
6844 // Apply additional attributes specified by '#pragma clang attribute'.
6845 AddPragmaAttributes(S, D);
6848 /// Is the given declaration allowed to use a forbidden type?
6849 /// If so, it'll still be annotated with an attribute that makes it
6850 /// illegal to actually use.
6851 static bool isForbiddenTypeAllowed(Sema &S, Decl *D,
6852 const DelayedDiagnostic &diag,
6853 UnavailableAttr::ImplicitReason &reason) {
6854 // Private ivars are always okay. Unfortunately, people don't
6855 // always properly make their ivars private, even in system headers.
6856 // Plus we need to make fields okay, too.
6857 if (!isa<FieldDecl>(D) && !isa<ObjCPropertyDecl>(D) &&
6858 !isa<FunctionDecl>(D))
6861 // Silently accept unsupported uses of __weak in both user and system
6862 // declarations when it's been disabled, for ease of integration with
6863 // -fno-objc-arc files. We do have to take some care against attempts
6864 // to define such things; for now, we've only done that for ivars
6866 if ((isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {
6867 if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled ||
6868 diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {
6869 reason = UnavailableAttr::IR_ForbiddenWeak;
6874 // Allow all sorts of things in system headers.
6875 if (S.Context.getSourceManager().isInSystemHeader(D->getLocation())) {
6876 // Currently, all the failures dealt with this way are due to ARC
6878 reason = UnavailableAttr::IR_ARCForbiddenType;
6885 /// Handle a delayed forbidden-type diagnostic.
6886 static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &DD,
6888 auto Reason = UnavailableAttr::IR_None;
6889 if (D && isForbiddenTypeAllowed(S, D, DD, Reason)) {
6890 assert(Reason && "didn't set reason?");
6891 D->addAttr(UnavailableAttr::CreateImplicit(S.Context, "", Reason, DD.Loc));
6894 if (S.getLangOpts().ObjCAutoRefCount)
6895 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
6896 // FIXME: we may want to suppress diagnostics for all
6897 // kind of forbidden type messages on unavailable functions.
6898 if (FD->hasAttr<UnavailableAttr>() &&
6899 DD.getForbiddenTypeDiagnostic() ==
6900 diag::err_arc_array_param_no_ownership) {
6901 DD.Triggered = true;
6906 S.Diag(DD.Loc, DD.getForbiddenTypeDiagnostic())
6907 << DD.getForbiddenTypeOperand() << DD.getForbiddenTypeArgument();
6908 DD.Triggered = true;
6911 static const AvailabilityAttr *getAttrForPlatform(ASTContext &Context,
6913 // Check each AvailabilityAttr to find the one for this platform.
6914 for (const auto *A : D->attrs()) {
6915 if (const auto *Avail = dyn_cast<AvailabilityAttr>(A)) {
6916 // FIXME: this is copied from CheckAvailability. We should try to
6919 // Check if this is an App Extension "platform", and if so chop off
6920 // the suffix for matching with the actual platform.
6921 StringRef ActualPlatform = Avail->getPlatform()->getName();
6922 StringRef RealizedPlatform = ActualPlatform;
6923 if (Context.getLangOpts().AppExt) {
6924 size_t suffix = RealizedPlatform.rfind("_app_extension");
6925 if (suffix != StringRef::npos)
6926 RealizedPlatform = RealizedPlatform.slice(0, suffix);
6929 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
6931 // Match the platform name.
6932 if (RealizedPlatform == TargetPlatform)
6939 /// The diagnostic we should emit for \c D, and the declaration that
6940 /// originated it, or \c AR_Available.
6942 /// \param D The declaration to check.
6943 /// \param Message If non-null, this will be populated with the message from
6944 /// the availability attribute that is selected.
6945 static std::pair<AvailabilityResult, const NamedDecl *>
6946 ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message) {
6947 AvailabilityResult Result = D->getAvailability(Message);
6949 // For typedefs, if the typedef declaration appears available look
6950 // to the underlying type to see if it is more restrictive.
6951 while (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
6952 if (Result == AR_Available) {
6953 if (const auto *TT = TD->getUnderlyingType()->getAs<TagType>()) {
6955 Result = D->getAvailability(Message);
6962 // Forward class declarations get their attributes from their definition.
6963 if (const auto *IDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
6964 if (IDecl->getDefinition()) {
6965 D = IDecl->getDefinition();
6966 Result = D->getAvailability(Message);
6970 if (const auto *ECD = dyn_cast<EnumConstantDecl>(D))
6971 if (Result == AR_Available) {
6972 const DeclContext *DC = ECD->getDeclContext();
6973 if (const auto *TheEnumDecl = dyn_cast<EnumDecl>(DC)) {
6974 Result = TheEnumDecl->getAvailability(Message);
6983 /// whether we should emit a diagnostic for \c K and \c DeclVersion in
6984 /// the context of \c Ctx. For example, we should emit an unavailable diagnostic
6985 /// in a deprecated context, but not the other way around.
6986 static bool ShouldDiagnoseAvailabilityInContext(Sema &S, AvailabilityResult K,
6987 VersionTuple DeclVersion,
6989 assert(K != AR_Available && "Expected an unavailable declaration here!");
6991 // Checks if we should emit the availability diagnostic in the context of C.
6992 auto CheckContext = [&](const Decl *C) {
6993 if (K == AR_NotYetIntroduced) {
6994 if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, C))
6995 if (AA->getIntroduced() >= DeclVersion)
6997 } else if (K == AR_Deprecated)
6998 if (C->isDeprecated())
7001 if (C->isUnavailable())
7007 if (CheckContext(Ctx))
7010 // An implementation implicitly has the availability of the interface.
7011 // Unless it is "+load" method.
7012 if (const auto *MethodD = dyn_cast<ObjCMethodDecl>(Ctx))
7013 if (MethodD->isClassMethod() &&
7014 MethodD->getSelector().getAsString() == "load")
7017 if (const auto *CatOrImpl = dyn_cast<ObjCImplDecl>(Ctx)) {
7018 if (const ObjCInterfaceDecl *Interface = CatOrImpl->getClassInterface())
7019 if (CheckContext(Interface))
7022 // A category implicitly has the availability of the interface.
7023 else if (const auto *CatD = dyn_cast<ObjCCategoryDecl>(Ctx))
7024 if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
7025 if (CheckContext(Interface))
7027 } while ((Ctx = cast_or_null<Decl>(Ctx->getDeclContext())));
7033 shouldDiagnoseAvailabilityByDefault(const ASTContext &Context,
7034 const VersionTuple &DeploymentVersion,
7035 const VersionTuple &DeclVersion) {
7036 const auto &Triple = Context.getTargetInfo().getTriple();
7037 VersionTuple ForceAvailabilityFromVersion;
7038 switch (Triple.getOS()) {
7039 case llvm::Triple::IOS:
7040 case llvm::Triple::TvOS:
7041 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/11);
7043 case llvm::Triple::WatchOS:
7044 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/4);
7046 case llvm::Triple::Darwin:
7047 case llvm::Triple::MacOSX:
7048 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/10, /*Minor=*/13);
7051 // New targets should always warn about availability.
7052 return Triple.getVendor() == llvm::Triple::Apple;
7054 return DeploymentVersion >= ForceAvailabilityFromVersion ||
7055 DeclVersion >= ForceAvailabilityFromVersion;
7058 static NamedDecl *findEnclosingDeclToAnnotate(Decl *OrigCtx) {
7059 for (Decl *Ctx = OrigCtx; Ctx;
7060 Ctx = cast_or_null<Decl>(Ctx->getDeclContext())) {
7061 if (isa<TagDecl>(Ctx) || isa<FunctionDecl>(Ctx) || isa<ObjCMethodDecl>(Ctx))
7062 return cast<NamedDecl>(Ctx);
7063 if (auto *CD = dyn_cast<ObjCContainerDecl>(Ctx)) {
7064 if (auto *Imp = dyn_cast<ObjCImplDecl>(Ctx))
7065 return Imp->getClassInterface();
7070 return dyn_cast<NamedDecl>(OrigCtx);
7075 struct AttributeInsertion {
7080 static AttributeInsertion createInsertionAfter(const NamedDecl *D) {
7081 return {" ", D->getLocEnd(), ""};
7083 static AttributeInsertion createInsertionAfter(SourceLocation Loc) {
7084 return {" ", Loc, ""};
7086 static AttributeInsertion createInsertionBefore(const NamedDecl *D) {
7087 return {"", D->getLocStart(), "\n"};
7091 } // end anonymous namespace
7093 /// Tries to parse a string as ObjC method name.
7095 /// \param Name The string to parse. Expected to originate from availability
7096 /// attribute argument.
7097 /// \param SlotNames The vector that will be populated with slot names. In case
7098 /// of unsuccessful parsing can contain invalid data.
7099 /// \returns A number of method parameters if parsing was successful, None
7101 static Optional<unsigned>
7102 tryParseObjCMethodName(StringRef Name, SmallVectorImpl<StringRef> &SlotNames,
7103 const LangOptions &LangOpts) {
7104 // Accept replacements starting with - or + as valid ObjC method names.
7105 if (!Name.empty() && (Name.front() == '-' || Name.front() == '+'))
7106 Name = Name.drop_front(1);
7109 Name.split(SlotNames, ':');
7111 if (Name.back() == ':') {
7112 // Remove an empty string at the end that doesn't represent any slot.
7113 SlotNames.pop_back();
7114 NumParams = SlotNames.size();
7116 if (SlotNames.size() != 1)
7117 // Not a valid method name, just a colon-separated string.
7121 // Verify all slot names are valid.
7122 bool AllowDollar = LangOpts.DollarIdents;
7123 for (StringRef S : SlotNames) {
7126 if (!isValidIdentifier(S, AllowDollar))
7132 /// Returns a source location in which it's appropriate to insert a new
7133 /// attribute for the given declaration \D.
7134 static Optional<AttributeInsertion>
7135 createAttributeInsertion(const NamedDecl *D, const SourceManager &SM,
7136 const LangOptions &LangOpts) {
7137 if (isa<ObjCPropertyDecl>(D))
7138 return AttributeInsertion::createInsertionAfter(D);
7139 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
7142 return AttributeInsertion::createInsertionAfter(D);
7144 if (const auto *TD = dyn_cast<TagDecl>(D)) {
7145 SourceLocation Loc =
7146 Lexer::getLocForEndOfToken(TD->getInnerLocStart(), 0, SM, LangOpts);
7147 if (Loc.isInvalid())
7149 // Insert after the 'struct'/whatever keyword.
7150 return AttributeInsertion::createInsertionAfter(Loc);
7152 return AttributeInsertion::createInsertionBefore(D);
7155 /// Actually emit an availability diagnostic for a reference to an unavailable
7158 /// \param Ctx The context that the reference occurred in
7159 /// \param ReferringDecl The exact declaration that was referenced.
7160 /// \param OffendingDecl A related decl to \c ReferringDecl that has an
7161 /// availability attribute corresponding to \c K attached to it. Note that this
7162 /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
7163 /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
7164 /// and OffendingDecl is the EnumDecl.
7165 static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K,
7166 Decl *Ctx, const NamedDecl *ReferringDecl,
7167 const NamedDecl *OffendingDecl,
7169 ArrayRef<SourceLocation> Locs,
7170 const ObjCInterfaceDecl *UnknownObjCClass,
7171 const ObjCPropertyDecl *ObjCProperty,
7172 bool ObjCPropertyAccess) {
7173 // Diagnostics for deprecated or unavailable.
7174 unsigned diag, diag_message, diag_fwdclass_message;
7175 unsigned diag_available_here = diag::note_availability_specified_here;
7176 SourceLocation NoteLocation = OffendingDecl->getLocation();
7178 // Matches 'diag::note_property_attribute' options.
7179 unsigned property_note_select;
7181 // Matches diag::note_availability_specified_here.
7182 unsigned available_here_select_kind;
7184 VersionTuple DeclVersion;
7185 if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, OffendingDecl))
7186 DeclVersion = AA->getIntroduced();
7188 if (!ShouldDiagnoseAvailabilityInContext(S, K, DeclVersion, Ctx))
7191 SourceLocation Loc = Locs.front();
7193 // The declaration can have multiple availability attributes, we are looking
7195 const AvailabilityAttr *A = getAttrForPlatform(S.Context, OffendingDecl);
7196 if (A && A->isInherited()) {
7197 for (const Decl *Redecl = OffendingDecl->getMostRecentDecl(); Redecl;
7198 Redecl = Redecl->getPreviousDecl()) {
7199 const AvailabilityAttr *AForRedecl =
7200 getAttrForPlatform(S.Context, Redecl);
7201 if (AForRedecl && !AForRedecl->isInherited()) {
7202 // If D is a declaration with inherited attributes, the note should
7203 // point to the declaration with actual attributes.
7204 NoteLocation = Redecl->getLocation();
7211 case AR_NotYetIntroduced: {
7212 // We would like to emit the diagnostic even if -Wunguarded-availability is
7213 // not specified for deployment targets >= to iOS 11 or equivalent or
7214 // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7216 const AvailabilityAttr *AA =
7217 getAttrForPlatform(S.getASTContext(), OffendingDecl);
7218 VersionTuple Introduced = AA->getIntroduced();
7220 bool UseNewWarning = shouldDiagnoseAvailabilityByDefault(
7221 S.Context, S.Context.getTargetInfo().getPlatformMinVersion(),
7223 unsigned Warning = UseNewWarning ? diag::warn_unguarded_availability_new
7224 : diag::warn_unguarded_availability;
7226 S.Diag(Loc, Warning)
7228 << AvailabilityAttr::getPrettyPlatformName(
7229 S.getASTContext().getTargetInfo().getPlatformName())
7230 << Introduced.getAsString();
7232 S.Diag(OffendingDecl->getLocation(), diag::note_availability_specified_here)
7233 << OffendingDecl << /* partial */ 3;
7235 if (const auto *Enclosing = findEnclosingDeclToAnnotate(Ctx)) {
7236 if (const auto *TD = dyn_cast<TagDecl>(Enclosing))
7237 if (TD->getDeclName().isEmpty()) {
7238 S.Diag(TD->getLocation(),
7239 diag::note_decl_unguarded_availability_silence)
7240 << /*Anonymous*/ 1 << TD->getKindName();
7243 auto FixitNoteDiag =
7244 S.Diag(Enclosing->getLocation(),
7245 diag::note_decl_unguarded_availability_silence)
7246 << /*Named*/ 0 << Enclosing;
7247 // Don't offer a fixit for declarations with availability attributes.
7248 if (Enclosing->hasAttr<AvailabilityAttr>())
7250 if (!S.getPreprocessor().isMacroDefined("API_AVAILABLE"))
7252 Optional<AttributeInsertion> Insertion = createAttributeInsertion(
7253 Enclosing, S.getSourceManager(), S.getLangOpts());
7256 std::string PlatformName =
7257 AvailabilityAttr::getPlatformNameSourceSpelling(
7258 S.getASTContext().getTargetInfo().getPlatformName())
7260 std::string Introduced =
7261 OffendingDecl->getVersionIntroduced().getAsString();
7262 FixitNoteDiag << FixItHint::CreateInsertion(
7264 (llvm::Twine(Insertion->Prefix) + "API_AVAILABLE(" + PlatformName +
7265 "(" + Introduced + "))" + Insertion->Suffix)
7271 diag = !ObjCPropertyAccess ? diag::warn_deprecated
7272 : diag::warn_property_method_deprecated;
7273 diag_message = diag::warn_deprecated_message;
7274 diag_fwdclass_message = diag::warn_deprecated_fwdclass_message;
7275 property_note_select = /* deprecated */ 0;
7276 available_here_select_kind = /* deprecated */ 2;
7277 if (const auto *AL = OffendingDecl->getAttr<DeprecatedAttr>())
7278 NoteLocation = AL->getLocation();
7281 case AR_Unavailable:
7282 diag = !ObjCPropertyAccess ? diag::err_unavailable
7283 : diag::err_property_method_unavailable;
7284 diag_message = diag::err_unavailable_message;
7285 diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
7286 property_note_select = /* unavailable */ 1;
7287 available_here_select_kind = /* unavailable */ 0;
7289 if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {
7290 if (AL->isImplicit() && AL->getImplicitReason()) {
7291 // Most of these failures are due to extra restrictions in ARC;
7292 // reflect that in the primary diagnostic when applicable.
7293 auto flagARCError = [&] {
7294 if (S.getLangOpts().ObjCAutoRefCount &&
7295 S.getSourceManager().isInSystemHeader(
7296 OffendingDecl->getLocation()))
7297 diag = diag::err_unavailable_in_arc;
7300 switch (AL->getImplicitReason()) {
7301 case UnavailableAttr::IR_None: break;
7303 case UnavailableAttr::IR_ARCForbiddenType:
7305 diag_available_here = diag::note_arc_forbidden_type;
7308 case UnavailableAttr::IR_ForbiddenWeak:
7309 if (S.getLangOpts().ObjCWeakRuntime)
7310 diag_available_here = diag::note_arc_weak_disabled;
7312 diag_available_here = diag::note_arc_weak_no_runtime;
7315 case UnavailableAttr::IR_ARCForbiddenConversion:
7317 diag_available_here = diag::note_performs_forbidden_arc_conversion;
7320 case UnavailableAttr::IR_ARCInitReturnsUnrelated:
7322 diag_available_here = diag::note_arc_init_returns_unrelated;
7325 case UnavailableAttr::IR_ARCFieldWithOwnership:
7327 diag_available_here = diag::note_arc_field_with_ownership;
7335 llvm_unreachable("Warning for availability of available declaration?");
7338 SmallVector<FixItHint, 12> FixIts;
7339 if (K == AR_Deprecated) {
7340 StringRef Replacement;
7341 if (auto AL = OffendingDecl->getAttr<DeprecatedAttr>())
7342 Replacement = AL->getReplacement();
7343 if (auto AL = getAttrForPlatform(S.Context, OffendingDecl))
7344 Replacement = AL->getReplacement();
7346 CharSourceRange UseRange;
7347 if (!Replacement.empty())
7349 CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
7350 if (UseRange.isValid()) {
7351 if (const auto *MethodDecl = dyn_cast<ObjCMethodDecl>(ReferringDecl)) {
7352 Selector Sel = MethodDecl->getSelector();
7353 SmallVector<StringRef, 12> SelectorSlotNames;
7354 Optional<unsigned> NumParams = tryParseObjCMethodName(
7355 Replacement, SelectorSlotNames, S.getLangOpts());
7356 if (NumParams && NumParams.getValue() == Sel.getNumArgs()) {
7357 assert(SelectorSlotNames.size() == Locs.size());
7358 for (unsigned I = 0; I < Locs.size(); ++I) {
7359 if (!Sel.getNameForSlot(I).empty()) {
7360 CharSourceRange NameRange = CharSourceRange::getCharRange(
7361 Locs[I], S.getLocForEndOfToken(Locs[I]));
7362 FixIts.push_back(FixItHint::CreateReplacement(
7363 NameRange, SelectorSlotNames[I]));
7366 FixItHint::CreateInsertion(Locs[I], SelectorSlotNames[I]));
7369 FixIts.push_back(FixItHint::CreateReplacement(UseRange, Replacement));
7371 FixIts.push_back(FixItHint::CreateReplacement(UseRange, Replacement));
7375 if (!Message.empty()) {
7376 S.Diag(Loc, diag_message) << ReferringDecl << Message << FixIts;
7378 S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7379 << ObjCProperty->getDeclName() << property_note_select;
7380 } else if (!UnknownObjCClass) {
7381 S.Diag(Loc, diag) << ReferringDecl << FixIts;
7383 S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7384 << ObjCProperty->getDeclName() << property_note_select;
7386 S.Diag(Loc, diag_fwdclass_message) << ReferringDecl << FixIts;
7387 S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
7390 S.Diag(NoteLocation, diag_available_here)
7391 << OffendingDecl << available_here_select_kind;
7394 static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD,
7396 assert(DD.Kind == DelayedDiagnostic::Availability &&
7397 "Expected an availability diagnostic here");
7399 DD.Triggered = true;
7400 DoEmitAvailabilityWarning(
7401 S, DD.getAvailabilityResult(), Ctx, DD.getAvailabilityReferringDecl(),
7402 DD.getAvailabilityOffendingDecl(), DD.getAvailabilityMessage(),
7403 DD.getAvailabilitySelectorLocs(), DD.getUnknownObjCClass(),
7404 DD.getObjCProperty(), false);
7407 void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
7408 assert(DelayedDiagnostics.getCurrentPool());
7409 DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
7410 DelayedDiagnostics.popWithoutEmitting(state);
7412 // When delaying diagnostics to run in the context of a parsed
7413 // declaration, we only want to actually emit anything if parsing
7417 // We emit all the active diagnostics in this pool or any of its
7418 // parents. In general, we'll get one pool for the decl spec
7419 // and a child pool for each declarator; in a decl group like:
7420 // deprecated_typedef foo, *bar, baz();
7421 // only the declarator pops will be passed decls. This is correct;
7422 // we really do need to consider delayed diagnostics from the decl spec
7423 // for each of the different declarations.
7424 const DelayedDiagnosticPool *pool = &poppedPool;
7426 for (DelayedDiagnosticPool::pool_iterator
7427 i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
7428 // This const_cast is a bit lame. Really, Triggered should be mutable.
7429 DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
7433 switch (diag.Kind) {
7434 case DelayedDiagnostic::Availability:
7435 // Don't bother giving deprecation/unavailable diagnostics if
7436 // the decl is invalid.
7437 if (!decl->isInvalidDecl())
7438 handleDelayedAvailabilityCheck(*this, diag, decl);
7441 case DelayedDiagnostic::Access:
7442 HandleDelayedAccessCheck(diag, decl);
7445 case DelayedDiagnostic::ForbiddenType:
7446 handleDelayedForbiddenType(*this, diag, decl);
7450 } while ((pool = pool->getParent()));
7453 /// Given a set of delayed diagnostics, re-emit them as if they had
7454 /// been delayed in the current context instead of in the given pool.
7455 /// Essentially, this just moves them to the current pool.
7456 void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
7457 DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
7458 assert(curPool && "re-emitting in undelayed context not supported");
7459 curPool->steal(pool);
7462 static void EmitAvailabilityWarning(Sema &S, AvailabilityResult AR,
7463 const NamedDecl *ReferringDecl,
7464 const NamedDecl *OffendingDecl,
7466 ArrayRef<SourceLocation> Locs,
7467 const ObjCInterfaceDecl *UnknownObjCClass,
7468 const ObjCPropertyDecl *ObjCProperty,
7469 bool ObjCPropertyAccess) {
7470 // Delay if we're currently parsing a declaration.
7471 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
7472 S.DelayedDiagnostics.add(
7473 DelayedDiagnostic::makeAvailability(
7474 AR, Locs, ReferringDecl, OffendingDecl, UnknownObjCClass,
7475 ObjCProperty, Message, ObjCPropertyAccess));
7479 Decl *Ctx = cast<Decl>(S.getCurLexicalContext());
7480 DoEmitAvailabilityWarning(S, AR, Ctx, ReferringDecl, OffendingDecl,
7481 Message, Locs, UnknownObjCClass, ObjCProperty,
7482 ObjCPropertyAccess);
7487 /// Returns true if the given statement can be a body-like child of \p Parent.
7488 bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
7489 switch (Parent->getStmtClass()) {
7490 case Stmt::IfStmtClass:
7491 return cast<IfStmt>(Parent)->getThen() == S ||
7492 cast<IfStmt>(Parent)->getElse() == S;
7493 case Stmt::WhileStmtClass:
7494 return cast<WhileStmt>(Parent)->getBody() == S;
7495 case Stmt::DoStmtClass:
7496 return cast<DoStmt>(Parent)->getBody() == S;
7497 case Stmt::ForStmtClass:
7498 return cast<ForStmt>(Parent)->getBody() == S;
7499 case Stmt::CXXForRangeStmtClass:
7500 return cast<CXXForRangeStmt>(Parent)->getBody() == S;
7501 case Stmt::ObjCForCollectionStmtClass:
7502 return cast<ObjCForCollectionStmt>(Parent)->getBody() == S;
7503 case Stmt::CaseStmtClass:
7504 case Stmt::DefaultStmtClass:
7505 return cast<SwitchCase>(Parent)->getSubStmt() == S;
7511 class StmtUSEFinder : public RecursiveASTVisitor<StmtUSEFinder> {
7515 bool VisitStmt(Stmt *S) { return S != Target; }
7517 /// Returns true if the given statement is present in the given declaration.
7518 static bool isContained(const Stmt *Target, const Decl *D) {
7519 StmtUSEFinder Visitor;
7520 Visitor.Target = Target;
7521 return !Visitor.TraverseDecl(const_cast<Decl *>(D));
7525 /// Traverses the AST and finds the last statement that used a given
7527 class LastDeclUSEFinder : public RecursiveASTVisitor<LastDeclUSEFinder> {
7531 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7532 if (DRE->getDecl() == D)
7537 static const Stmt *findLastStmtThatUsesDecl(const Decl *D,
7538 const CompoundStmt *Scope) {
7539 LastDeclUSEFinder Visitor;
7541 for (auto I = Scope->body_rbegin(), E = Scope->body_rend(); I != E; ++I) {
7543 if (!Visitor.TraverseStmt(const_cast<Stmt *>(S)))
7550 /// This class implements -Wunguarded-availability.
7552 /// This is done with a traversal of the AST of a function that makes reference
7553 /// to a partially available declaration. Whenever we encounter an \c if of the
7554 /// form: \c if(@available(...)), we use the version from the condition to visit
7555 /// the then statement.
7556 class DiagnoseUnguardedAvailability
7557 : public RecursiveASTVisitor<DiagnoseUnguardedAvailability> {
7558 typedef RecursiveASTVisitor<DiagnoseUnguardedAvailability> Base;
7563 /// Stack of potentially nested 'if (@available(...))'s.
7564 SmallVector<VersionTuple, 8> AvailabilityStack;
7565 SmallVector<const Stmt *, 16> StmtStack;
7567 void DiagnoseDeclAvailability(NamedDecl *D, SourceRange Range);
7570 DiagnoseUnguardedAvailability(Sema &SemaRef, Decl *Ctx)
7571 : SemaRef(SemaRef), Ctx(Ctx) {
7572 AvailabilityStack.push_back(
7573 SemaRef.Context.getTargetInfo().getPlatformMinVersion());
7576 bool TraverseDecl(Decl *D) {
7577 // Avoid visiting nested functions to prevent duplicate warnings.
7578 if (!D || isa<FunctionDecl>(D))
7580 return Base::TraverseDecl(D);
7583 bool TraverseStmt(Stmt *S) {
7586 StmtStack.push_back(S);
7587 bool Result = Base::TraverseStmt(S);
7588 StmtStack.pop_back();
7592 void IssueDiagnostics(Stmt *S) { TraverseStmt(S); }
7594 bool TraverseIfStmt(IfStmt *If);
7596 bool TraverseLambdaExpr(LambdaExpr *E) { return true; }
7598 // for 'case X:' statements, don't bother looking at the 'X'; it can't lead
7599 // to any useful diagnostics.
7600 bool TraverseCaseStmt(CaseStmt *CS) { return TraverseStmt(CS->getSubStmt()); }
7602 bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *PRE) {
7603 if (PRE->isClassReceiver())
7604 DiagnoseDeclAvailability(PRE->getClassReceiver(), PRE->getReceiverLocation());
7608 bool VisitObjCMessageExpr(ObjCMessageExpr *Msg) {
7609 if (ObjCMethodDecl *D = Msg->getMethodDecl())
7610 DiagnoseDeclAvailability(
7611 D, SourceRange(Msg->getSelectorStartLoc(), Msg->getLocEnd()));
7615 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7616 DiagnoseDeclAvailability(DRE->getDecl(),
7617 SourceRange(DRE->getLocStart(), DRE->getLocEnd()));
7621 bool VisitMemberExpr(MemberExpr *ME) {
7622 DiagnoseDeclAvailability(ME->getMemberDecl(),
7623 SourceRange(ME->getLocStart(), ME->getLocEnd()));
7627 bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
7628 SemaRef.Diag(E->getLocStart(), diag::warn_at_available_unchecked_use)
7629 << (!SemaRef.getLangOpts().ObjC1);
7633 bool VisitTypeLoc(TypeLoc Ty);
7636 void DiagnoseUnguardedAvailability::DiagnoseDeclAvailability(
7637 NamedDecl *D, SourceRange Range) {
7638 AvailabilityResult Result;
7639 const NamedDecl *OffendingDecl;
7640 std::tie(Result, OffendingDecl) =
7641 ShouldDiagnoseAvailabilityOfDecl(D, nullptr);
7642 if (Result != AR_Available) {
7643 // All other diagnostic kinds have already been handled in
7644 // DiagnoseAvailabilityOfDecl.
7645 if (Result != AR_NotYetIntroduced)
7648 const AvailabilityAttr *AA =
7649 getAttrForPlatform(SemaRef.getASTContext(), OffendingDecl);
7650 VersionTuple Introduced = AA->getIntroduced();
7652 if (AvailabilityStack.back() >= Introduced)
7655 // If the context of this function is less available than D, we should not
7656 // emit a diagnostic.
7657 if (!ShouldDiagnoseAvailabilityInContext(SemaRef, Result, Introduced, Ctx))
7660 // We would like to emit the diagnostic even if -Wunguarded-availability is
7661 // not specified for deployment targets >= to iOS 11 or equivalent or
7662 // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7665 shouldDiagnoseAvailabilityByDefault(
7667 SemaRef.Context.getTargetInfo().getPlatformMinVersion(), Introduced)
7668 ? diag::warn_unguarded_availability_new
7669 : diag::warn_unguarded_availability;
7671 SemaRef.Diag(Range.getBegin(), DiagKind)
7673 << AvailabilityAttr::getPrettyPlatformName(
7674 SemaRef.getASTContext().getTargetInfo().getPlatformName())
7675 << Introduced.getAsString();
7677 SemaRef.Diag(OffendingDecl->getLocation(),
7678 diag::note_availability_specified_here)
7679 << OffendingDecl << /* partial */ 3;
7682 SemaRef.Diag(Range.getBegin(), diag::note_unguarded_available_silence)
7684 << (SemaRef.getLangOpts().ObjC1 ? /*@available*/ 0
7685 : /*__builtin_available*/ 1);
7687 // Find the statement which should be enclosed in the if @available check.
7688 if (StmtStack.empty())
7690 const Stmt *StmtOfUse = StmtStack.back();
7691 const CompoundStmt *Scope = nullptr;
7692 for (const Stmt *S : llvm::reverse(StmtStack)) {
7693 if (const auto *CS = dyn_cast<CompoundStmt>(S)) {
7697 if (isBodyLikeChildStmt(StmtOfUse, S)) {
7698 // The declaration won't be seen outside of the statement, so we don't
7699 // have to wrap the uses of any declared variables in if (@available).
7700 // Therefore we can avoid setting Scope here.
7705 const Stmt *LastStmtOfUse = nullptr;
7706 if (isa<DeclStmt>(StmtOfUse) && Scope) {
7707 for (const Decl *D : cast<DeclStmt>(StmtOfUse)->decls()) {
7708 if (StmtUSEFinder::isContained(StmtStack.back(), D)) {
7709 LastStmtOfUse = LastDeclUSEFinder::findLastStmtThatUsesDecl(D, Scope);
7715 const SourceManager &SM = SemaRef.getSourceManager();
7716 SourceLocation IfInsertionLoc =
7717 SM.getExpansionLoc(StmtOfUse->getLocStart());
7718 SourceLocation StmtEndLoc =
7719 SM.getExpansionRange(
7720 (LastStmtOfUse ? LastStmtOfUse : StmtOfUse)->getLocEnd())
7722 if (SM.getFileID(IfInsertionLoc) != SM.getFileID(StmtEndLoc))
7725 StringRef Indentation = Lexer::getIndentationForLine(IfInsertionLoc, SM);
7726 const char *ExtraIndentation = " ";
7727 std::string FixItString;
7728 llvm::raw_string_ostream FixItOS(FixItString);
7729 FixItOS << "if (" << (SemaRef.getLangOpts().ObjC1 ? "@available"
7730 : "__builtin_available")
7732 << AvailabilityAttr::getPlatformNameSourceSpelling(
7733 SemaRef.getASTContext().getTargetInfo().getPlatformName())
7734 << " " << Introduced.getAsString() << ", *)) {\n"
7735 << Indentation << ExtraIndentation;
7736 FixitDiag << FixItHint::CreateInsertion(IfInsertionLoc, FixItOS.str());
7737 SourceLocation ElseInsertionLoc = Lexer::findLocationAfterToken(
7738 StmtEndLoc, tok::semi, SM, SemaRef.getLangOpts(),
7739 /*SkipTrailingWhitespaceAndNewLine=*/false);
7740 if (ElseInsertionLoc.isInvalid())
7742 Lexer::getLocForEndOfToken(StmtEndLoc, 0, SM, SemaRef.getLangOpts());
7743 FixItOS.str().clear();
7745 << Indentation << "} else {\n"
7746 << Indentation << ExtraIndentation
7747 << "// Fallback on earlier versions\n"
7748 << Indentation << "}";
7749 FixitDiag << FixItHint::CreateInsertion(ElseInsertionLoc, FixItOS.str());
7753 bool DiagnoseUnguardedAvailability::VisitTypeLoc(TypeLoc Ty) {
7754 const Type *TyPtr = Ty.getTypePtr();
7755 SourceRange Range{Ty.getBeginLoc(), Ty.getEndLoc()};
7757 if (Range.isInvalid())
7760 if (const auto *TT = dyn_cast<TagType>(TyPtr)) {
7761 TagDecl *TD = TT->getDecl();
7762 DiagnoseDeclAvailability(TD, Range);
7764 } else if (const auto *TD = dyn_cast<TypedefType>(TyPtr)) {
7765 TypedefNameDecl *D = TD->getDecl();
7766 DiagnoseDeclAvailability(D, Range);
7768 } else if (const auto *ObjCO = dyn_cast<ObjCObjectType>(TyPtr)) {
7769 if (NamedDecl *D = ObjCO->getInterface())
7770 DiagnoseDeclAvailability(D, Range);
7776 bool DiagnoseUnguardedAvailability::TraverseIfStmt(IfStmt *If) {
7777 VersionTuple CondVersion;
7778 if (auto *E = dyn_cast<ObjCAvailabilityCheckExpr>(If->getCond())) {
7779 CondVersion = E->getVersion();
7781 // If we're using the '*' case here or if this check is redundant, then we
7782 // use the enclosing version to check both branches.
7783 if (CondVersion.empty() || CondVersion <= AvailabilityStack.back())
7784 return TraverseStmt(If->getThen()) && TraverseStmt(If->getElse());
7786 // This isn't an availability checking 'if', we can just continue.
7787 return Base::TraverseIfStmt(If);
7790 AvailabilityStack.push_back(CondVersion);
7791 bool ShouldContinue = TraverseStmt(If->getThen());
7792 AvailabilityStack.pop_back();
7794 return ShouldContinue && TraverseStmt(If->getElse());
7797 } // end anonymous namespace
7799 void Sema::DiagnoseUnguardedAvailabilityViolations(Decl *D) {
7800 Stmt *Body = nullptr;
7802 if (auto *FD = D->getAsFunction()) {
7803 // FIXME: We only examine the pattern decl for availability violations now,
7804 // but we should also examine instantiated templates.
7805 if (FD->isTemplateInstantiation())
7808 Body = FD->getBody();
7809 } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
7810 Body = MD->getBody();
7811 else if (auto *BD = dyn_cast<BlockDecl>(D))
7812 Body = BD->getBody();
7814 assert(Body && "Need a body here!");
7816 DiagnoseUnguardedAvailability(*this, D).IssueDiagnostics(Body);
7819 void Sema::DiagnoseAvailabilityOfDecl(NamedDecl *D,
7820 ArrayRef<SourceLocation> Locs,
7821 const ObjCInterfaceDecl *UnknownObjCClass,
7822 bool ObjCPropertyAccess,
7823 bool AvoidPartialAvailabilityChecks) {
7824 std::string Message;
7825 AvailabilityResult Result;
7826 const NamedDecl* OffendingDecl;
7827 // See if this declaration is unavailable, deprecated, or partial.
7828 std::tie(Result, OffendingDecl) = ShouldDiagnoseAvailabilityOfDecl(D, &Message);
7829 if (Result == AR_Available)
7832 if (Result == AR_NotYetIntroduced) {
7833 if (AvoidPartialAvailabilityChecks)
7836 // We need to know the @available context in the current function to
7837 // diagnose this use, let DiagnoseUnguardedAvailabilityViolations do that
7838 // when we're done parsing the current function.
7839 if (getCurFunctionOrMethodDecl()) {
7840 getEnclosingFunction()->HasPotentialAvailabilityViolations = true;
7842 } else if (getCurBlock() || getCurLambda()) {
7843 getCurFunction()->HasPotentialAvailabilityViolations = true;
7848 const ObjCPropertyDecl *ObjCPDecl = nullptr;
7849 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
7850 if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
7851 AvailabilityResult PDeclResult = PD->getAvailability(nullptr);
7852 if (PDeclResult == Result)
7857 EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Message, Locs,
7858 UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);