clang  3.7.0
SemaDeclAttr.cpp
Go to the documentation of this file.
1 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements decl-related attribute processing.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/Mangle.h"
24 #include "clang/Basic/CharInfo.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Sema/DeclSpec.h"
30 #include "clang/Sema/Lookup.h"
31 #include "clang/Sema/Scope.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/Support/MathExtras.h"
34 using namespace clang;
35 using namespace sema;
36 
37 namespace AttributeLangSupport {
38  enum LANG {
39  C,
40  Cpp,
42  };
43 }
44 
45 //===----------------------------------------------------------------------===//
46 // Helper functions
47 //===----------------------------------------------------------------------===//
48 
49 /// isFunctionOrMethod - Return true if the given decl has function
50 /// type (function or function-typed variable) or an Objective-C
51 /// method.
52 static bool isFunctionOrMethod(const Decl *D) {
53  return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
54 }
55 /// \brief Return true if the given decl has function type (function or
56 /// function-typed variable) or an Objective-C method or a block.
57 static bool isFunctionOrMethodOrBlock(const Decl *D) {
58  return isFunctionOrMethod(D) || isa<BlockDecl>(D);
59 }
60 
61 /// Return true if the given decl has a declarator that should have
62 /// been processed by Sema::GetTypeForDeclarator.
63 static bool hasDeclarator(const Decl *D) {
64  // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
65  return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
66  isa<ObjCPropertyDecl>(D);
67 }
68 
69 /// hasFunctionProto - Return true if the given decl has a argument
70 /// information. This decl should have already passed
71 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
72 static bool hasFunctionProto(const Decl *D) {
73  if (const FunctionType *FnTy = D->getFunctionType())
74  return isa<FunctionProtoType>(FnTy);
75  return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
76 }
77 
78 /// getFunctionOrMethodNumParams - Return number of function or method
79 /// parameters. It is an error to call this on a K&R function (use
80 /// hasFunctionProto first).
81 static unsigned getFunctionOrMethodNumParams(const Decl *D) {
82  if (const FunctionType *FnTy = D->getFunctionType())
83  return cast<FunctionProtoType>(FnTy)->getNumParams();
84  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
85  return BD->getNumParams();
86  return cast<ObjCMethodDecl>(D)->param_size();
87 }
88 
89 static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
90  if (const FunctionType *FnTy = D->getFunctionType())
91  return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
92  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
93  return BD->getParamDecl(Idx)->getType();
94 
95  return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
96 }
97 
98 static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
99  if (const auto *FD = dyn_cast<FunctionDecl>(D))
100  return FD->getParamDecl(Idx)->getSourceRange();
101  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
102  return MD->parameters()[Idx]->getSourceRange();
103  if (const auto *BD = dyn_cast<BlockDecl>(D))
104  return BD->getParamDecl(Idx)->getSourceRange();
105  return SourceRange();
106 }
107 
109  if (const FunctionType *FnTy = D->getFunctionType())
110  return cast<FunctionType>(FnTy)->getReturnType();
111  return cast<ObjCMethodDecl>(D)->getReturnType();
112 }
113 
115  if (const auto *FD = dyn_cast<FunctionDecl>(D))
116  return FD->getReturnTypeSourceRange();
117  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
118  return MD->getReturnTypeSourceRange();
119  return SourceRange();
120 }
121 
122 static bool isFunctionOrMethodVariadic(const Decl *D) {
123  if (const FunctionType *FnTy = D->getFunctionType()) {
124  const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
125  return proto->isVariadic();
126  }
127  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
128  return BD->isVariadic();
129 
130  return cast<ObjCMethodDecl>(D)->isVariadic();
131 }
132 
133 static bool isInstanceMethod(const Decl *D) {
134  if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
135  return MethodDecl->isInstance();
136  return false;
137 }
138 
139 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
141  if (!PT)
142  return false;
143 
145  if (!Cls)
146  return false;
147 
148  IdentifierInfo* ClsName = Cls->getIdentifier();
149 
150  // FIXME: Should we walk the chain of classes?
151  return ClsName == &Ctx.Idents.get("NSString") ||
152  ClsName == &Ctx.Idents.get("NSMutableString");
153 }
154 
155 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
156  const PointerType *PT = T->getAs<PointerType>();
157  if (!PT)
158  return false;
159 
160  const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
161  if (!RT)
162  return false;
163 
164  const RecordDecl *RD = RT->getDecl();
165  if (RD->getTagKind() != TTK_Struct)
166  return false;
167 
168  return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
169 }
170 
171 static unsigned getNumAttributeArgs(const AttributeList &Attr) {
172  // FIXME: Include the type in the argument list.
173  return Attr.getNumArgs() + Attr.hasParsedType();
174 }
175 
176 template <typename Compare>
178  unsigned Num, unsigned Diag,
179  Compare Comp) {
180  if (Comp(getNumAttributeArgs(Attr), Num)) {
181  S.Diag(Attr.getLoc(), Diag) << Attr.getName() << Num;
182  return false;
183  }
184 
185  return true;
186 }
187 
188 /// \brief Check if the attribute has exactly as many args as Num. May
189 /// output an error.
191  unsigned Num) {
192  return checkAttributeNumArgsImpl(S, Attr, Num,
193  diag::err_attribute_wrong_number_arguments,
194  std::not_equal_to<unsigned>());
195 }
196 
197 /// \brief Check if the attribute has at least as many args as Num. May
198 /// output an error.
200  unsigned Num) {
201  return checkAttributeNumArgsImpl(S, Attr, Num,
202  diag::err_attribute_too_few_arguments,
203  std::less<unsigned>());
204 }
205 
206 /// \brief Check if the attribute has at most as many args as Num. May
207 /// output an error.
209  unsigned Num) {
210  return checkAttributeNumArgsImpl(S, Attr, Num,
211  diag::err_attribute_too_many_arguments,
212  std::greater<unsigned>());
213 }
214 
215 /// \brief If Expr is a valid integer constant, get the value of the integer
216 /// expression and return success or failure. May output an error.
218  const Expr *Expr, uint32_t &Val,
219  unsigned Idx = UINT_MAX) {
220  llvm::APSInt I(32);
221  if (Expr->isTypeDependent() || Expr->isValueDependent() ||
222  !Expr->isIntegerConstantExpr(I, S.Context)) {
223  if (Idx != UINT_MAX)
224  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
225  << Attr.getName() << Idx << AANT_ArgumentIntegerConstant
226  << Expr->getSourceRange();
227  else
228  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
230  << Expr->getSourceRange();
231  return false;
232  }
233 
234  if (!I.isIntN(32)) {
235  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
236  << I.toString(10, false) << 32 << /* Unsigned */ 1;
237  return false;
238  }
239 
240  Val = (uint32_t)I.getZExtValue();
241  return true;
242 }
243 
244 /// \brief Diagnose mutually exclusive attributes when present on a given
245 /// declaration. Returns true if diagnosed.
246 template <typename AttrTy>
248  const AttributeList &Attr) {
249  if (AttrTy *A = D->getAttr<AttrTy>()) {
250  S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
251  << Attr.getName() << A;
252  return true;
253  }
254  return false;
255 }
256 
257 /// \brief Check if IdxExpr is a valid parameter index for a function or
258 /// instance method D. May output an error.
259 ///
260 /// \returns true if IdxExpr is a valid index.
262  const AttributeList &Attr,
263  unsigned AttrArgNum,
264  const Expr *IdxExpr,
265  uint64_t &Idx) {
266  assert(isFunctionOrMethodOrBlock(D));
267 
268  // In C++ the implicit 'this' function parameter also counts.
269  // Parameters are counted from one.
270  bool HP = hasFunctionProto(D);
271  bool HasImplicitThisParam = isInstanceMethod(D);
272  bool IV = HP && isFunctionOrMethodVariadic(D);
273  unsigned NumParams =
274  (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
275 
276  llvm::APSInt IdxInt;
277  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
278  !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
279  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
280  << Attr.getName() << AttrArgNum << AANT_ArgumentIntegerConstant
281  << IdxExpr->getSourceRange();
282  return false;
283  }
284 
285  Idx = IdxInt.getLimitedValue();
286  if (Idx < 1 || (!IV && Idx > NumParams)) {
287  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
288  << Attr.getName() << AttrArgNum << IdxExpr->getSourceRange();
289  return false;
290  }
291  Idx--; // Convert to zero-based.
292  if (HasImplicitThisParam) {
293  if (Idx == 0) {
294  S.Diag(Attr.getLoc(),
295  diag::err_attribute_invalid_implicit_this_argument)
296  << Attr.getName() << IdxExpr->getSourceRange();
297  return false;
298  }
299  --Idx;
300  }
301 
302  return true;
303 }
304 
305 /// \brief Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
306 /// If not emit an error and return false. If the argument is an identifier it
307 /// will emit an error with a fixit hint and treat it as if it was a string
308 /// literal.
310  unsigned ArgNum, StringRef &Str,
311  SourceLocation *ArgLocation) {
312  // Look for identifiers. If we have one emit a hint to fix it to a literal.
313  if (Attr.isArgIdent(ArgNum)) {
314  IdentifierLoc *Loc = Attr.getArgAsIdent(ArgNum);
315  Diag(Loc->Loc, diag::err_attribute_argument_type)
316  << Attr.getName() << AANT_ArgumentString
317  << FixItHint::CreateInsertion(Loc->Loc, "\"")
318  << FixItHint::CreateInsertion(PP.getLocForEndOfToken(Loc->Loc), "\"");
319  Str = Loc->Ident->getName();
320  if (ArgLocation)
321  *ArgLocation = Loc->Loc;
322  return true;
323  }
324 
325  // Now check for an actual string literal.
326  Expr *ArgExpr = Attr.getArgAsExpr(ArgNum);
327  StringLiteral *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
328  if (ArgLocation)
329  *ArgLocation = ArgExpr->getLocStart();
330 
331  if (!Literal || !Literal->isAscii()) {
332  Diag(ArgExpr->getLocStart(), diag::err_attribute_argument_type)
333  << Attr.getName() << AANT_ArgumentString;
334  return false;
335  }
336 
337  Str = Literal->getString();
338  return true;
339 }
340 
341 /// \brief Applies the given attribute to the Decl without performing any
342 /// additional semantic checking.
343 template <typename AttrType>
344 static void handleSimpleAttribute(Sema &S, Decl *D,
345  const AttributeList &Attr) {
346  D->addAttr(::new (S.Context) AttrType(Attr.getRange(), S.Context,
348 }
349 
350 /// \brief Check if the passed-in expression is of type int or bool.
351 static bool isIntOrBool(Expr *Exp) {
352  QualType QT = Exp->getType();
353  return QT->isBooleanType() || QT->isIntegerType();
354 }
355 
356 
357 // Check to see if the type is a smart pointer of some kind. We assume
358 // it's a smart pointer if it defines both operator-> and operator*.
360  DeclContextLookupResult Res1 = RT->getDecl()->lookup(
362  if (Res1.empty())
363  return false;
364 
365  DeclContextLookupResult Res2 = RT->getDecl()->lookup(
367  if (Res2.empty())
368  return false;
369 
370  return true;
371 }
372 
373 /// \brief Check if passed in Decl is a pointer type.
374 /// Note that this function may produce an error message.
375 /// \return true if the Decl is a pointer type; false otherwise
376 static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
377  const AttributeList &Attr) {
378  const ValueDecl *vd = cast<ValueDecl>(D);
379  QualType QT = vd->getType();
380  if (QT->isAnyPointerType())
381  return true;
382 
383  if (const RecordType *RT = QT->getAs<RecordType>()) {
384  // If it's an incomplete type, it could be a smart pointer; skip it.
385  // (We don't want to force template instantiation if we can avoid it,
386  // since that would alter the order in which templates are instantiated.)
387  if (RT->isIncompleteType())
388  return true;
389 
391  return true;
392  }
393 
394  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
395  << Attr.getName() << QT;
396  return false;
397 }
398 
399 /// \brief Checks that the passed in QualType either is of RecordType or points
400 /// to RecordType. Returns the relevant RecordType, null if it does not exit.
401 static const RecordType *getRecordType(QualType QT) {
402  if (const RecordType *RT = QT->getAs<RecordType>())
403  return RT;
404 
405  // Now check if we point to record type.
406  if (const PointerType *PT = QT->getAs<PointerType>())
407  return PT->getPointeeType()->getAs<RecordType>();
408 
409  return nullptr;
410 }
411 
413  const RecordType *RT = getRecordType(Ty);
414 
415  if (!RT)
416  return false;
417 
418  // Don't check for the capability if the class hasn't been defined yet.
419  if (RT->isIncompleteType())
420  return true;
421 
422  // Allow smart pointers to be used as capability objects.
423  // FIXME -- Check the type that the smart pointer points to.
425  return true;
426 
427  // Check if the record itself has a capability.
428  RecordDecl *RD = RT->getDecl();
429  if (RD->hasAttr<CapabilityAttr>())
430  return true;
431 
432  // Else check if any base classes have a capability.
433  if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
434  CXXBasePaths BPaths(false, false);
435  if (CRD->lookupInBases([](const CXXBaseSpecifier *BS, CXXBasePath &P,
436  void *) {
437  return BS->getType()->getAs<RecordType>()
438  ->getDecl()->hasAttr<CapabilityAttr>();
439  }, nullptr, BPaths))
440  return true;
441  }
442  return false;
443 }
444 
446  const auto *TD = Ty->getAs<TypedefType>();
447  if (!TD)
448  return false;
449 
450  TypedefNameDecl *TN = TD->getDecl();
451  if (!TN)
452  return false;
453 
454  return TN->hasAttr<CapabilityAttr>();
455 }
456 
457 static bool typeHasCapability(Sema &S, QualType Ty) {
459  return true;
460 
461  if (checkRecordTypeForCapability(S, Ty))
462  return true;
463 
464  return false;
465 }
466 
467 static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
468  // Capability expressions are simple expressions involving the boolean logic
469  // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
470  // a DeclRefExpr is found, its type should be checked to determine whether it
471  // is a capability or not.
472 
473  if (const auto *E = dyn_cast<DeclRefExpr>(Ex))
474  return typeHasCapability(S, E->getType());
475  else if (const auto *E = dyn_cast<CastExpr>(Ex))
476  return isCapabilityExpr(S, E->getSubExpr());
477  else if (const auto *E = dyn_cast<ParenExpr>(Ex))
478  return isCapabilityExpr(S, E->getSubExpr());
479  else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
480  if (E->getOpcode() == UO_LNot)
481  return isCapabilityExpr(S, E->getSubExpr());
482  return false;
483  } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
484  if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
485  return isCapabilityExpr(S, E->getLHS()) &&
486  isCapabilityExpr(S, E->getRHS());
487  return false;
488  }
489 
490  return false;
491 }
492 
493 /// \brief Checks that all attribute arguments, starting from Sidx, resolve to
494 /// a capability object.
495 /// \param Sidx The attribute argument index to start checking with.
496 /// \param ParamIdxOk Whether an argument can be indexing into a function
497 /// parameter list.
499  const AttributeList &Attr,
501  int Sidx = 0,
502  bool ParamIdxOk = false) {
503  for (unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
504  Expr *ArgExp = Attr.getArgAsExpr(Idx);
505 
506  if (ArgExp->isTypeDependent()) {
507  // FIXME -- need to check this again on template instantiation
508  Args.push_back(ArgExp);
509  continue;
510  }
511 
512  if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
513  if (StrLit->getLength() == 0 ||
514  (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
515  // Pass empty strings to the analyzer without warnings.
516  // Treat "*" as the universal lock.
517  Args.push_back(ArgExp);
518  continue;
519  }
520 
521  // We allow constant strings to be used as a placeholder for expressions
522  // that are not valid C++ syntax, but warn that they are ignored.
523  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
524  Attr.getName();
525  Args.push_back(ArgExp);
526  continue;
527  }
528 
529  QualType ArgTy = ArgExp->getType();
530 
531  // A pointer to member expression of the form &MyClass::mu is treated
532  // specially -- we need to look at the type of the member.
533  if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp))
534  if (UOp->getOpcode() == UO_AddrOf)
535  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
536  if (DRE->getDecl()->isCXXInstanceMember())
537  ArgTy = DRE->getDecl()->getType();
538 
539  // First see if we can just cast to record type, or pointer to record type.
540  const RecordType *RT = getRecordType(ArgTy);
541 
542  // Now check if we index into a record type function param.
543  if(!RT && ParamIdxOk) {
544  FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
545  IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp);
546  if(FD && IL) {
547  unsigned int NumParams = FD->getNumParams();
548  llvm::APInt ArgValue = IL->getValue();
549  uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
550  uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
551  if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
552  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
553  << Attr.getName() << Idx + 1 << NumParams;
554  continue;
555  }
556  ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
557  }
558  }
559 
560  // If the type does not have a capability, see if the components of the
561  // expression have capabilities. This allows for writing C code where the
562  // capability may be on the type, and the expression is a capability
563  // boolean logic expression. Eg) requires_capability(A || B && !C)
564  if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
565  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
566  << Attr.getName() << ArgTy;
567 
568  Args.push_back(ArgExp);
569  }
570 }
571 
572 //===----------------------------------------------------------------------===//
573 // Attribute Implementations
574 //===----------------------------------------------------------------------===//
575 
577  const AttributeList &Attr) {
578  if (!threadSafetyCheckIsPointer(S, D, Attr))
579  return;
580 
581  D->addAttr(::new (S.Context)
582  PtGuardedVarAttr(Attr.getRange(), S.Context,
584 }
585 
587  const AttributeList &Attr,
588  Expr* &Arg) {
590  // check that all arguments are lockable objects
591  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
592  unsigned Size = Args.size();
593  if (Size != 1)
594  return false;
595 
596  Arg = Args[0];
597 
598  return true;
599 }
600 
601 static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) {
602  Expr *Arg = nullptr;
603  if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
604  return;
605 
606  D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg,
608 }
609 
610 static void handlePtGuardedByAttr(Sema &S, Decl *D,
611  const AttributeList &Attr) {
612  Expr *Arg = nullptr;
613  if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
614  return;
615 
616  if (!threadSafetyCheckIsPointer(S, D, Attr))
617  return;
618 
619  D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
620  S.Context, Arg,
622 }
623 
625  const AttributeList &Attr,
626  SmallVectorImpl<Expr *> &Args) {
627  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
628  return false;
629 
630  // Check that this attribute only applies to lockable types.
631  QualType QT = cast<ValueDecl>(D)->getType();
632  if (!QT->isDependentType()) {
633  const RecordType *RT = getRecordType(QT);
634  if (!RT || !RT->getDecl()->hasAttr<CapabilityAttr>()) {
635  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
636  << Attr.getName();
637  return false;
638  }
639  }
640 
641  // Check that all arguments are lockable objects.
642  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
643  if (Args.empty())
644  return false;
645 
646  return true;
647 }
648 
650  const AttributeList &Attr) {
652  if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
653  return;
654 
655  Expr **StartArg = &Args[0];
656  D->addAttr(::new (S.Context)
657  AcquiredAfterAttr(Attr.getRange(), S.Context,
658  StartArg, Args.size(),
660 }
661 
663  const AttributeList &Attr) {
665  if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
666  return;
667 
668  Expr **StartArg = &Args[0];
669  D->addAttr(::new (S.Context)
670  AcquiredBeforeAttr(Attr.getRange(), S.Context,
671  StartArg, Args.size(),
673 }
674 
676  const AttributeList &Attr,
677  SmallVectorImpl<Expr *> &Args) {
678  // zero or more arguments ok
679  // check that all arguments are lockable objects
680  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
681 
682  return true;
683 }
684 
686  const AttributeList &Attr) {
688  if (!checkLockFunAttrCommon(S, D, Attr, Args))
689  return;
690 
691  unsigned Size = Args.size();
692  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
693  D->addAttr(::new (S.Context)
694  AssertSharedLockAttr(Attr.getRange(), S.Context, StartArg, Size,
696 }
697 
699  const AttributeList &Attr) {
701  if (!checkLockFunAttrCommon(S, D, Attr, Args))
702  return;
703 
704  unsigned Size = Args.size();
705  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
706  D->addAttr(::new (S.Context)
707  AssertExclusiveLockAttr(Attr.getRange(), S.Context,
708  StartArg, Size,
710 }
711 
712 
714  const AttributeList &Attr,
715  SmallVectorImpl<Expr *> &Args) {
716  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
717  return false;
718 
719  if (!isIntOrBool(Attr.getArgAsExpr(0))) {
720  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
721  << Attr.getName() << 1 << AANT_ArgumentIntOrBool;
722  return false;
723  }
724 
725  // check that all arguments are lockable objects
726  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 1);
727 
728  return true;
729 }
730 
732  const AttributeList &Attr) {
734  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
735  return;
736 
737  D->addAttr(::new (S.Context)
738  SharedTrylockFunctionAttr(Attr.getRange(), S.Context,
739  Attr.getArgAsExpr(0),
740  Args.data(), Args.size(),
742 }
743 
745  const AttributeList &Attr) {
747  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
748  return;
749 
750  D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
751  Attr.getRange(), S.Context, Attr.getArgAsExpr(0), Args.data(),
752  Args.size(), Attr.getAttributeSpellingListIndex()));
753 }
754 
756  const AttributeList &Attr) {
757  // check that the argument is lockable object
759  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
760  unsigned Size = Args.size();
761  if (Size == 0)
762  return;
763 
764  D->addAttr(::new (S.Context)
765  LockReturnedAttr(Attr.getRange(), S.Context, Args[0],
767 }
768 
770  const AttributeList &Attr) {
771  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
772  return;
773 
774  // check that all arguments are lockable objects
776  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
777  unsigned Size = Args.size();
778  if (Size == 0)
779  return;
780  Expr **StartArg = &Args[0];
781 
782  D->addAttr(::new (S.Context)
783  LocksExcludedAttr(Attr.getRange(), S.Context, StartArg, Size,
785 }
786 
787 static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
788  Expr *Cond = Attr.getArgAsExpr(0);
789  if (!Cond->isTypeDependent()) {
790  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
791  if (Converted.isInvalid())
792  return;
793  Cond = Converted.get();
794  }
795 
796  StringRef Msg;
797  if (!S.checkStringLiteralArgumentAttr(Attr, 1, Msg))
798  return;
799 
801  if (!Cond->isValueDependent() &&
802  !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
803  Diags)) {
804  S.Diag(Attr.getLoc(), diag::err_enable_if_never_constant_expr);
805  for (int I = 0, N = Diags.size(); I != N; ++I)
806  S.Diag(Diags[I].first, Diags[I].second);
807  return;
808  }
809 
810  D->addAttr(::new (S.Context)
811  EnableIfAttr(Attr.getRange(), S.Context, Cond, Msg,
813 }
814 
815 static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
816  ConsumableAttr::ConsumedState DefaultState;
817 
818  if (Attr.isArgIdent(0)) {
819  IdentifierLoc *IL = Attr.getArgAsIdent(0);
820  if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
821  DefaultState)) {
822  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
823  << Attr.getName() << IL->Ident;
824  return;
825  }
826  } else {
827  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
828  << Attr.getName() << AANT_ArgumentIdentifier;
829  return;
830  }
831 
832  D->addAttr(::new (S.Context)
833  ConsumableAttr(Attr.getRange(), S.Context, DefaultState,
835 }
836 
837 
838 static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
839  const AttributeList &Attr) {
840  ASTContext &CurrContext = S.getASTContext();
841  QualType ThisType = MD->getThisType(CurrContext)->getPointeeType();
842 
843  if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
844  if (!RD->hasAttr<ConsumableAttr>()) {
845  S.Diag(Attr.getLoc(), diag::warn_attr_on_unconsumable_class) <<
846  RD->getNameAsString();
847 
848  return false;
849  }
850  }
851 
852  return true;
853 }
854 
855 
857  const AttributeList &Attr) {
858  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
859  return;
860 
861  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
862  return;
863 
865  for (unsigned ArgIndex = 0; ArgIndex < Attr.getNumArgs(); ++ArgIndex) {
866  CallableWhenAttr::ConsumedState CallableState;
867 
868  StringRef StateString;
869  SourceLocation Loc;
870  if (Attr.isArgIdent(ArgIndex)) {
871  IdentifierLoc *Ident = Attr.getArgAsIdent(ArgIndex);
872  StateString = Ident->Ident->getName();
873  Loc = Ident->Loc;
874  } else {
875  if (!S.checkStringLiteralArgumentAttr(Attr, ArgIndex, StateString, &Loc))
876  return;
877  }
878 
879  if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
880  CallableState)) {
881  S.Diag(Loc, diag::warn_attribute_type_not_supported)
882  << Attr.getName() << StateString;
883  return;
884  }
885 
886  States.push_back(CallableState);
887  }
888 
889  D->addAttr(::new (S.Context)
890  CallableWhenAttr(Attr.getRange(), S.Context, States.data(),
891  States.size(), Attr.getAttributeSpellingListIndex()));
892 }
893 
894 
896  const AttributeList &Attr) {
898 
899  if (Attr.isArgIdent(0)) {
900  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
901  StringRef StateString = Ident->Ident->getName();
902 
903  if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
904  ParamState)) {
905  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
906  << Attr.getName() << StateString;
907  return;
908  }
909  } else {
910  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
912  return;
913  }
914 
915  // FIXME: This check is currently being done in the analysis. It can be
916  // enabled here only after the parser propagates attributes at
917  // template specialization definition, not declaration.
918  //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
919  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
920  //
921  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
922  // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
923  // ReturnType.getAsString();
924  // return;
925  //}
926 
927  D->addAttr(::new (S.Context)
928  ParamTypestateAttr(Attr.getRange(), S.Context, ParamState,
930 }
931 
932 
934  const AttributeList &Attr) {
936 
937  if (Attr.isArgIdent(0)) {
938  IdentifierLoc *IL = Attr.getArgAsIdent(0);
939  if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
940  ReturnState)) {
941  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
942  << Attr.getName() << IL->Ident;
943  return;
944  }
945  } else {
946  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
948  return;
949  }
950 
951  // FIXME: This check is currently being done in the analysis. It can be
952  // enabled here only after the parser propagates attributes at
953  // template specialization definition, not declaration.
954  //QualType ReturnType;
955  //
956  //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
957  // ReturnType = Param->getType();
958  //
959  //} else if (const CXXConstructorDecl *Constructor =
960  // dyn_cast<CXXConstructorDecl>(D)) {
961  // ReturnType = Constructor->getThisType(S.getASTContext())->getPointeeType();
962  //
963  //} else {
964  //
965  // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
966  //}
967  //
968  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
969  //
970  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
971  // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
972  // ReturnType.getAsString();
973  // return;
974  //}
975 
976  D->addAttr(::new (S.Context)
977  ReturnTypestateAttr(Attr.getRange(), S.Context, ReturnState,
979 }
980 
981 
982 static void handleSetTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
983  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
984  return;
985 
987  if (Attr.isArgIdent(0)) {
988  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
989  StringRef Param = Ident->Ident->getName();
990  if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
991  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
992  << Attr.getName() << Param;
993  return;
994  }
995  } else {
996  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
998  return;
999  }
1000 
1001  D->addAttr(::new (S.Context)
1002  SetTypestateAttr(Attr.getRange(), S.Context, NewState,
1004 }
1005 
1007  const AttributeList &Attr) {
1008  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1009  return;
1010 
1012  if (Attr.isArgIdent(0)) {
1013  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1014  StringRef Param = Ident->Ident->getName();
1015  if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1016  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1017  << Attr.getName() << Param;
1018  return;
1019  }
1020  } else {
1021  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1022  Attr.getName() << AANT_ArgumentIdentifier;
1023  return;
1024  }
1025 
1026  D->addAttr(::new (S.Context)
1027  TestTypestateAttr(Attr.getRange(), S.Context, TestState,
1029 }
1030 
1031 static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
1032  const AttributeList &Attr) {
1033  // Remember this typedef decl, we will need it later for diagnostics.
1034  S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1035 }
1036 
1037 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1038  if (TagDecl *TD = dyn_cast<TagDecl>(D))
1039  TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context,
1041  else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1042  // If the alignment is less than or equal to 8 bits, the packed attribute
1043  // has no effect.
1044  if (!FD->getType()->isDependentType() &&
1045  !FD->getType()->isIncompleteType() &&
1046  S.Context.getTypeAlign(FD->getType()) <= 8)
1047  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1048  << Attr.getName() << FD->getType();
1049  else
1050  FD->addAttr(::new (S.Context)
1051  PackedAttr(Attr.getRange(), S.Context,
1053  } else
1054  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1055 }
1056 
1057 static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
1058  // The IBOutlet/IBOutletCollection attributes only apply to instance
1059  // variables or properties of Objective-C classes. The outlet must also
1060  // have an object reference type.
1061  if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) {
1062  if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1063  S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1064  << Attr.getName() << VD->getType() << 0;
1065  return false;
1066  }
1067  }
1068  else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1069  if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1070  S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1071  << Attr.getName() << PD->getType() << 1;
1072  return false;
1073  }
1074  }
1075  else {
1076  S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
1077  return false;
1078  }
1079 
1080  return true;
1081 }
1082 
1083 static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
1084  if (!checkIBOutletCommon(S, D, Attr))
1085  return;
1086 
1087  D->addAttr(::new (S.Context)
1088  IBOutletAttr(Attr.getRange(), S.Context,
1090 }
1091 
1093  const AttributeList &Attr) {
1094 
1095  // The iboutletcollection attribute can have zero or one arguments.
1096  if (Attr.getNumArgs() > 1) {
1097  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1098  << Attr.getName() << 1;
1099  return;
1100  }
1101 
1102  if (!checkIBOutletCommon(S, D, Attr))
1103  return;
1104 
1105  ParsedType PT;
1106 
1107  if (Attr.hasParsedType())
1108  PT = Attr.getTypeArg();
1109  else {
1110  PT = S.getTypeName(S.Context.Idents.get("NSObject"), Attr.getLoc(),
1112  if (!PT) {
1113  S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1114  return;
1115  }
1116  }
1117 
1118  TypeSourceInfo *QTLoc = nullptr;
1119  QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1120  if (!QTLoc)
1121  QTLoc = S.Context.getTrivialTypeSourceInfo(QT, Attr.getLoc());
1122 
1123  // Diagnose use of non-object type in iboutletcollection attribute.
1124  // FIXME. Gnu attribute extension ignores use of builtin types in
1125  // attributes. So, __attribute__((iboutletcollection(char))) will be
1126  // treated as __attribute__((iboutletcollection())).
1127  if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1128  S.Diag(Attr.getLoc(),
1129  QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1130  : diag::err_iboutletcollection_type) << QT;
1131  return;
1132  }
1133 
1134  D->addAttr(::new (S.Context)
1135  IBOutletCollectionAttr(Attr.getRange(), S.Context, QTLoc,
1137 }
1138 
1140  if (RefOkay) {
1141  if (T->isReferenceType())
1142  return true;
1143  } else {
1144  T = T.getNonReferenceType();
1145  }
1146 
1147  // The nonnull attribute, and other similar attributes, can be applied to a
1148  // transparent union that contains a pointer type.
1149  if (const RecordType *UT = T->getAsUnionType()) {
1150  if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1151  RecordDecl *UD = UT->getDecl();
1152  for (const auto *I : UD->fields()) {
1153  QualType QT = I->getType();
1154  if (QT->isAnyPointerType() || QT->isBlockPointerType())
1155  return true;
1156  }
1157  }
1158  }
1159 
1160  return T->isAnyPointerType() || T->isBlockPointerType();
1161 }
1162 
1164  SourceRange AttrParmRange,
1165  SourceRange TypeRange,
1166  bool isReturnValue = false) {
1167  if (!S.isValidPointerAttrType(T)) {
1168  S.Diag(Attr.getLoc(), isReturnValue
1169  ? diag::warn_attribute_return_pointers_only
1170  : diag::warn_attribute_pointers_only)
1171  << Attr.getName() << AttrParmRange << TypeRange;
1172  return false;
1173  }
1174  return true;
1175 }
1176 
1177 static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1178  SmallVector<unsigned, 8> NonNullArgs;
1179  for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
1180  Expr *Ex = Attr.getArgAsExpr(I);
1181  uint64_t Idx;
1182  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, I + 1, Ex, Idx))
1183  return;
1184 
1185  // Is the function argument a pointer type?
1186  if (Idx < getFunctionOrMethodNumParams(D) &&
1188  Ex->getSourceRange(),
1190  continue;
1191 
1192  NonNullArgs.push_back(Idx);
1193  }
1194 
1195  // If no arguments were specified to __attribute__((nonnull)) then all pointer
1196  // arguments have a nonnull attribute; warn if there aren't any. Skip this
1197  // check if the attribute came from a macro expansion or a template
1198  // instantiation.
1199  if (NonNullArgs.empty() && Attr.getLoc().isFileID() &&
1200  S.ActiveTemplateInstantiations.empty()) {
1201  bool AnyPointers = isFunctionOrMethodVariadic(D);
1202  for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1203  I != E && !AnyPointers; ++I) {
1205  if (T->isDependentType() || S.isValidPointerAttrType(T))
1206  AnyPointers = true;
1207  }
1208 
1209  if (!AnyPointers)
1210  S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1211  }
1212 
1213  unsigned *Start = NonNullArgs.data();
1214  unsigned Size = NonNullArgs.size();
1215  llvm::array_pod_sort(Start, Start + Size);
1216  D->addAttr(::new (S.Context)
1217  NonNullAttr(Attr.getRange(), S.Context, Start, Size,
1219 }
1220 
1222  const AttributeList &Attr) {
1223  if (Attr.getNumArgs() > 0) {
1224  if (D->getFunctionType()) {
1225  handleNonNullAttr(S, D, Attr);
1226  } else {
1227  S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1228  << D->getSourceRange();
1229  }
1230  return;
1231  }
1232 
1233  // Is the argument a pointer type?
1234  if (!attrNonNullArgCheck(S, D->getType(), Attr, SourceRange(),
1235  D->getSourceRange()))
1236  return;
1237 
1238  D->addAttr(::new (S.Context)
1239  NonNullAttr(Attr.getRange(), S.Context, nullptr, 0,
1241 }
1242 
1244  const AttributeList &Attr) {
1245  QualType ResultType = getFunctionOrMethodResultType(D);
1247  if (!attrNonNullArgCheck(S, ResultType, Attr, SourceRange(), SR,
1248  /* isReturnValue */ true))
1249  return;
1250 
1251  D->addAttr(::new (S.Context)
1252  ReturnsNonNullAttr(Attr.getRange(), S.Context,
1254 }
1255 
1257  const AttributeList &Attr) {
1258  Expr *E = Attr.getArgAsExpr(0),
1259  *OE = Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr;
1260  S.AddAssumeAlignedAttr(Attr.getRange(), D, E, OE,
1262 }
1263 
1265  Expr *OE, unsigned SpellingListIndex) {
1266  QualType ResultType = getFunctionOrMethodResultType(D);
1268 
1269  AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1270  SourceLocation AttrLoc = AttrRange.getBegin();
1271 
1272  if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1273  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1274  << &TmpAttr << AttrRange << SR;
1275  return;
1276  }
1277 
1278  if (!E->isValueDependent()) {
1279  llvm::APSInt I(64);
1280  if (!E->isIntegerConstantExpr(I, Context)) {
1281  if (OE)
1282  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1283  << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1284  << E->getSourceRange();
1285  else
1286  Diag(AttrLoc, diag::err_attribute_argument_type)
1287  << &TmpAttr << AANT_ArgumentIntegerConstant
1288  << E->getSourceRange();
1289  return;
1290  }
1291 
1292  if (!I.isPowerOf2()) {
1293  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1294  << E->getSourceRange();
1295  return;
1296  }
1297  }
1298 
1299  if (OE) {
1300  if (!OE->isValueDependent()) {
1301  llvm::APSInt I(64);
1302  if (!OE->isIntegerConstantExpr(I, Context)) {
1303  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1304  << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1305  << OE->getSourceRange();
1306  return;
1307  }
1308  }
1309  }
1310 
1311  D->addAttr(::new (Context)
1312  AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1313 }
1314 
1315 static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
1316  // This attribute must be applied to a function declaration. The first
1317  // argument to the attribute must be an identifier, the name of the resource,
1318  // for example: malloc. The following arguments must be argument indexes, the
1319  // arguments must be of integer type for Returns, otherwise of pointer type.
1320  // The difference between Holds and Takes is that a pointer may still be used
1321  // after being held. free() should be __attribute((ownership_takes)), whereas
1322  // a list append function may well be __attribute((ownership_holds)).
1323 
1324  if (!AL.isArgIdent(0)) {
1325  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1326  << AL.getName() << 1 << AANT_ArgumentIdentifier;
1327  return;
1328  }
1329 
1330  // Figure out our Kind.
1331  OwnershipAttr::OwnershipKind K =
1332  OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1333  AL.getAttributeSpellingListIndex()).getOwnKind();
1334 
1335  // Check arguments.
1336  switch (K) {
1337  case OwnershipAttr::Takes:
1338  case OwnershipAttr::Holds:
1339  if (AL.getNumArgs() < 2) {
1340  S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments)
1341  << AL.getName() << 2;
1342  return;
1343  }
1344  break;
1345  case OwnershipAttr::Returns:
1346  if (AL.getNumArgs() > 2) {
1347  S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
1348  << AL.getName() << 1;
1349  return;
1350  }
1351  break;
1352  }
1353 
1355 
1356  // Normalize the argument, __foo__ becomes foo.
1357  StringRef ModuleName = Module->getName();
1358  if (ModuleName.startswith("__") && ModuleName.endswith("__") &&
1359  ModuleName.size() > 4) {
1360  ModuleName = ModuleName.drop_front(2).drop_back(2);
1361  Module = &S.PP.getIdentifierTable().get(ModuleName);
1362  }
1363 
1364  SmallVector<unsigned, 8> OwnershipArgs;
1365  for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1366  Expr *Ex = AL.getArgAsExpr(i);
1367  uint64_t Idx;
1368  if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1369  return;
1370 
1371  // Is the function argument a pointer type?
1373  int Err = -1; // No error
1374  switch (K) {
1375  case OwnershipAttr::Takes:
1376  case OwnershipAttr::Holds:
1377  if (!T->isAnyPointerType() && !T->isBlockPointerType())
1378  Err = 0;
1379  break;
1380  case OwnershipAttr::Returns:
1381  if (!T->isIntegerType())
1382  Err = 1;
1383  break;
1384  }
1385  if (-1 != Err) {
1386  S.Diag(AL.getLoc(), diag::err_ownership_type) << AL.getName() << Err
1387  << Ex->getSourceRange();
1388  return;
1389  }
1390 
1391  // Check we don't have a conflict with another ownership attribute.
1392  for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1393  // Cannot have two ownership attributes of different kinds for the same
1394  // index.
1395  if (I->getOwnKind() != K && I->args_end() !=
1396  std::find(I->args_begin(), I->args_end(), Idx)) {
1397  S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1398  << AL.getName() << I;
1399  return;
1400  } else if (K == OwnershipAttr::Returns &&
1401  I->getOwnKind() == OwnershipAttr::Returns) {
1402  // A returns attribute conflicts with any other returns attribute using
1403  // a different index. Note, diagnostic reporting is 1-based, but stored
1404  // argument indexes are 0-based.
1405  if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1406  S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1407  << *(I->args_begin()) + 1;
1408  if (I->args_size())
1409  S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1410  << (unsigned)Idx + 1 << Ex->getSourceRange();
1411  return;
1412  }
1413  }
1414  }
1415  OwnershipArgs.push_back(Idx);
1416  }
1417 
1418  unsigned* start = OwnershipArgs.data();
1419  unsigned size = OwnershipArgs.size();
1420  llvm::array_pod_sort(start, start + size);
1421 
1422  D->addAttr(::new (S.Context)
1423  OwnershipAttr(AL.getLoc(), S.Context, Module, start, size,
1425 }
1426 
1427 static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1428  // Check the attribute arguments.
1429  if (Attr.getNumArgs() > 1) {
1430  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1431  << Attr.getName() << 1;
1432  return;
1433  }
1434 
1435  NamedDecl *nd = cast<NamedDecl>(D);
1436 
1437  // gcc rejects
1438  // class c {
1439  // static int a __attribute__((weakref ("v2")));
1440  // static int b() __attribute__((weakref ("f3")));
1441  // };
1442  // and ignores the attributes of
1443  // void f(void) {
1444  // static int a __attribute__((weakref ("v2")));
1445  // }
1446  // we reject them
1447  const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1448  if (!Ctx->isFileContext()) {
1449  S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context)
1450  << nd;
1451  return;
1452  }
1453 
1454  // The GCC manual says
1455  //
1456  // At present, a declaration to which `weakref' is attached can only
1457  // be `static'.
1458  //
1459  // It also says
1460  //
1461  // Without a TARGET,
1462  // given as an argument to `weakref' or to `alias', `weakref' is
1463  // equivalent to `weak'.
1464  //
1465  // gcc 4.4.1 will accept
1466  // int a7 __attribute__((weakref));
1467  // as
1468  // int a7 __attribute__((weak));
1469  // This looks like a bug in gcc. We reject that for now. We should revisit
1470  // it if this behaviour is actually used.
1471 
1472  // GCC rejects
1473  // static ((alias ("y"), weakref)).
1474  // Should we? How to check that weakref is before or after alias?
1475 
1476  // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1477  // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1478  // StringRef parameter it was given anyway.
1479  StringRef Str;
1480  if (Attr.getNumArgs() && S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1481  // GCC will accept anything as the argument of weakref. Should we
1482  // check for an existing decl?
1483  D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1485 
1486  D->addAttr(::new (S.Context)
1487  WeakRefAttr(Attr.getRange(), S.Context,
1489 }
1490 
1491 static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1492  StringRef Str;
1493  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1494  return;
1495 
1496  if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1497  S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1498  return;
1499  }
1500 
1501  // Aliases should be on declarations, not definitions.
1502  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
1503  if (FD->isThisDeclarationADefinition()) {
1504  S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD;
1505  return;
1506  }
1507  } else {
1508  const auto *VD = cast<VarDecl>(D);
1509  if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1510  S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << VD;
1511  return;
1512  }
1513  }
1514 
1515  // FIXME: check if target symbol exists in current file
1516 
1517  D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1519 }
1520 
1521 static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1522  if (checkAttrMutualExclusion<HotAttr>(S, D, Attr))
1523  return;
1524 
1525  D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context,
1527 }
1528 
1529 static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1530  if (checkAttrMutualExclusion<ColdAttr>(S, D, Attr))
1531  return;
1532 
1533  D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context,
1535 }
1536 
1537 static void handleTLSModelAttr(Sema &S, Decl *D,
1538  const AttributeList &Attr) {
1539  StringRef Model;
1540  SourceLocation LiteralLoc;
1541  // Check that it is a string.
1542  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Model, &LiteralLoc))
1543  return;
1544 
1545  // Check that the value.
1546  if (Model != "global-dynamic" && Model != "local-dynamic"
1547  && Model != "initial-exec" && Model != "local-exec") {
1548  S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1549  return;
1550  }
1551 
1552  D->addAttr(::new (S.Context)
1553  TLSModelAttr(Attr.getRange(), S.Context, Model,
1555 }
1556 
1557 static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1558  QualType ResultType = getFunctionOrMethodResultType(D);
1559  if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1560  D->addAttr(::new (S.Context) RestrictAttr(
1561  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1562  return;
1563  }
1564 
1565  S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1567 }
1568 
1569 static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1570  if (S.LangOpts.CPlusPlus) {
1571  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
1572  << Attr.getName() << AttributeLangSupport::Cpp;
1573  return;
1574  }
1575 
1576  D->addAttr(::new (S.Context) CommonAttr(Attr.getRange(), S.Context,
1578 }
1579 
1580 static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
1581  if (hasDeclarator(D)) return;
1582 
1583  if (S.CheckNoReturnAttr(attr)) return;
1584 
1585  if (!isa<ObjCMethodDecl>(D)) {
1586  S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1587  << attr.getName() << ExpectedFunctionOrMethod;
1588  return;
1589  }
1590 
1591  D->addAttr(::new (S.Context)
1592  NoReturnAttr(attr.getRange(), S.Context,
1594 }
1595 
1597  if (!checkAttributeNumArgs(*this, attr, 0)) {
1598  attr.setInvalid();
1599  return true;
1600  }
1601 
1602  return false;
1603 }
1604 
1606  const AttributeList &Attr) {
1607 
1608  // The checking path for 'noreturn' and 'analyzer_noreturn' are different
1609  // because 'analyzer_noreturn' does not impact the type.
1610  if (!isFunctionOrMethodOrBlock(D)) {
1611  ValueDecl *VD = dyn_cast<ValueDecl>(D);
1612  if (!VD || (!VD->getType()->isBlockPointerType() &&
1613  !VD->getType()->isFunctionPointerType())) {
1614  S.Diag(Attr.getLoc(),
1615  Attr.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
1616  : diag::warn_attribute_wrong_decl_type)
1618  return;
1619  }
1620  }
1621 
1622  D->addAttr(::new (S.Context)
1623  AnalyzerNoReturnAttr(Attr.getRange(), S.Context,
1625 }
1626 
1627 // PS3 PPU-specific.
1628 static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1629 /*
1630  Returning a Vector Class in Registers
1631 
1632  According to the PPU ABI specifications, a class with a single member of
1633  vector type is returned in memory when used as the return value of a function.
1634  This results in inefficient code when implementing vector classes. To return
1635  the value in a single vector register, add the vecreturn attribute to the
1636  class definition. This attribute is also applicable to struct types.
1637 
1638  Example:
1639 
1640  struct Vector
1641  {
1642  __vector float xyzw;
1643  } __attribute__((vecreturn));
1644 
1645  Vector Add(Vector lhs, Vector rhs)
1646  {
1647  Vector result;
1648  result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
1649  return result; // This will be returned in a register
1650  }
1651 */
1652  if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
1653  S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << A;
1654  return;
1655  }
1656 
1657  RecordDecl *record = cast<RecordDecl>(D);
1658  int count = 0;
1659 
1660  if (!isa<CXXRecordDecl>(record)) {
1661  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1662  return;
1663  }
1664 
1665  if (!cast<CXXRecordDecl>(record)->isPOD()) {
1666  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
1667  return;
1668  }
1669 
1670  for (const auto *I : record->fields()) {
1671  if ((count == 1) || !I->getType()->isVectorType()) {
1672  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1673  return;
1674  }
1675  count++;
1676  }
1677 
1678  D->addAttr(::new (S.Context)
1679  VecReturnAttr(Attr.getRange(), S.Context,
1681 }
1682 
1684  const AttributeList &Attr) {
1685  if (isa<ParmVarDecl>(D)) {
1686  // [[carries_dependency]] can only be applied to a parameter if it is a
1687  // parameter of a function declaration or lambda.
1689  S.Diag(Attr.getLoc(),
1690  diag::err_carries_dependency_param_not_function_decl);
1691  return;
1692  }
1693  }
1694 
1695  D->addAttr(::new (S.Context) CarriesDependencyAttr(
1696  Attr.getRange(), S.Context,
1698 }
1699 
1700 static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1701  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1702  if (VD->hasLocalStorage()) {
1703  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1704  return;
1705  }
1706  } else if (!isFunctionOrMethod(D)) {
1707  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1708  << Attr.getName() << ExpectedVariableOrFunction;
1709  return;
1710  }
1711 
1712  D->addAttr(::new (S.Context)
1713  UsedAttr(Attr.getRange(), S.Context,
1715 }
1716 
1717 static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1718  uint32_t priority = ConstructorAttr::DefaultPriority;
1719  if (Attr.getNumArgs() &&
1720  !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
1721  return;
1722 
1723  D->addAttr(::new (S.Context)
1724  ConstructorAttr(Attr.getRange(), S.Context, priority,
1726 }
1727 
1728 static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1729  uint32_t priority = DestructorAttr::DefaultPriority;
1730  if (Attr.getNumArgs() &&
1731  !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
1732  return;
1733 
1734  D->addAttr(::new (S.Context)
1735  DestructorAttr(Attr.getRange(), S.Context, priority,
1737 }
1738 
1739 template <typename AttrTy>
1741  const AttributeList &Attr) {
1742  // Handle the case where the attribute has a text message.
1743  StringRef Str;
1744  if (Attr.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1745  return;
1746 
1747  D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str,
1749 }
1750 
1752  const AttributeList &Attr) {
1753  if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
1754  S.Diag(Attr.getLoc(), diag::err_objc_attr_protocol_requires_definition)
1755  << Attr.getName() << Attr.getRange();
1756  return;
1757  }
1758 
1759  D->addAttr(::new (S.Context)
1760  ObjCExplicitProtocolImplAttr(Attr.getRange(), S.Context,
1762 }
1763 
1765  IdentifierInfo *Platform,
1766  VersionTuple Introduced,
1767  VersionTuple Deprecated,
1768  VersionTuple Obsoleted) {
1769  StringRef PlatformName
1770  = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1771  if (PlatformName.empty())
1772  PlatformName = Platform->getName();
1773 
1774  // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
1775  // of these steps are needed).
1776  if (!Introduced.empty() && !Deprecated.empty() &&
1777  !(Introduced <= Deprecated)) {
1778  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1779  << 1 << PlatformName << Deprecated.getAsString()
1780  << 0 << Introduced.getAsString();
1781  return true;
1782  }
1783 
1784  if (!Introduced.empty() && !Obsoleted.empty() &&
1785  !(Introduced <= Obsoleted)) {
1786  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1787  << 2 << PlatformName << Obsoleted.getAsString()
1788  << 0 << Introduced.getAsString();
1789  return true;
1790  }
1791 
1792  if (!Deprecated.empty() && !Obsoleted.empty() &&
1793  !(Deprecated <= Obsoleted)) {
1794  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1795  << 2 << PlatformName << Obsoleted.getAsString()
1796  << 1 << Deprecated.getAsString();
1797  return true;
1798  }
1799 
1800  return false;
1801 }
1802 
1803 /// \brief Check whether the two versions match.
1804 ///
1805 /// If either version tuple is empty, then they are assumed to match. If
1806 /// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
1807 static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
1808  bool BeforeIsOkay) {
1809  if (X.empty() || Y.empty())
1810  return true;
1811 
1812  if (X == Y)
1813  return true;
1814 
1815  if (BeforeIsOkay && X < Y)
1816  return true;
1817 
1818  return false;
1819 }
1820 
1822  IdentifierInfo *Platform,
1823  VersionTuple Introduced,
1824  VersionTuple Deprecated,
1825  VersionTuple Obsoleted,
1826  bool IsUnavailable,
1827  StringRef Message,
1828  bool Override,
1829  unsigned AttrSpellingListIndex) {
1830  VersionTuple MergedIntroduced = Introduced;
1831  VersionTuple MergedDeprecated = Deprecated;
1832  VersionTuple MergedObsoleted = Obsoleted;
1833  bool FoundAny = false;
1834 
1835  if (D->hasAttrs()) {
1836  AttrVec &Attrs = D->getAttrs();
1837  for (unsigned i = 0, e = Attrs.size(); i != e;) {
1838  const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
1839  if (!OldAA) {
1840  ++i;
1841  continue;
1842  }
1843 
1844  IdentifierInfo *OldPlatform = OldAA->getPlatform();
1845  if (OldPlatform != Platform) {
1846  ++i;
1847  continue;
1848  }
1849 
1850  FoundAny = true;
1851  VersionTuple OldIntroduced = OldAA->getIntroduced();
1852  VersionTuple OldDeprecated = OldAA->getDeprecated();
1853  VersionTuple OldObsoleted = OldAA->getObsoleted();
1854  bool OldIsUnavailable = OldAA->getUnavailable();
1855 
1856  if (!versionsMatch(OldIntroduced, Introduced, Override) ||
1857  !versionsMatch(Deprecated, OldDeprecated, Override) ||
1858  !versionsMatch(Obsoleted, OldObsoleted, Override) ||
1859  !(OldIsUnavailable == IsUnavailable ||
1860  (Override && !OldIsUnavailable && IsUnavailable))) {
1861  if (Override) {
1862  int Which = -1;
1863  VersionTuple FirstVersion;
1864  VersionTuple SecondVersion;
1865  if (!versionsMatch(OldIntroduced, Introduced, Override)) {
1866  Which = 0;
1867  FirstVersion = OldIntroduced;
1868  SecondVersion = Introduced;
1869  } else if (!versionsMatch(Deprecated, OldDeprecated, Override)) {
1870  Which = 1;
1871  FirstVersion = Deprecated;
1872  SecondVersion = OldDeprecated;
1873  } else if (!versionsMatch(Obsoleted, OldObsoleted, Override)) {
1874  Which = 2;
1875  FirstVersion = Obsoleted;
1876  SecondVersion = OldObsoleted;
1877  }
1878 
1879  if (Which == -1) {
1880  Diag(OldAA->getLocation(),
1881  diag::warn_mismatched_availability_override_unavail)
1882  << AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1883  } else {
1884  Diag(OldAA->getLocation(),
1885  diag::warn_mismatched_availability_override)
1886  << Which
1887  << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
1888  << FirstVersion.getAsString() << SecondVersion.getAsString();
1889  }
1890  Diag(Range.getBegin(), diag::note_overridden_method);
1891  } else {
1892  Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
1893  Diag(Range.getBegin(), diag::note_previous_attribute);
1894  }
1895 
1896  Attrs.erase(Attrs.begin() + i);
1897  --e;
1898  continue;
1899  }
1900 
1901  VersionTuple MergedIntroduced2 = MergedIntroduced;
1902  VersionTuple MergedDeprecated2 = MergedDeprecated;
1903  VersionTuple MergedObsoleted2 = MergedObsoleted;
1904 
1905  if (MergedIntroduced2.empty())
1906  MergedIntroduced2 = OldIntroduced;
1907  if (MergedDeprecated2.empty())
1908  MergedDeprecated2 = OldDeprecated;
1909  if (MergedObsoleted2.empty())
1910  MergedObsoleted2 = OldObsoleted;
1911 
1912  if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
1913  MergedIntroduced2, MergedDeprecated2,
1914  MergedObsoleted2)) {
1915  Attrs.erase(Attrs.begin() + i);
1916  --e;
1917  continue;
1918  }
1919 
1920  MergedIntroduced = MergedIntroduced2;
1921  MergedDeprecated = MergedDeprecated2;
1922  MergedObsoleted = MergedObsoleted2;
1923  ++i;
1924  }
1925  }
1926 
1927  if (FoundAny &&
1928  MergedIntroduced == Introduced &&
1929  MergedDeprecated == Deprecated &&
1930  MergedObsoleted == Obsoleted)
1931  return nullptr;
1932 
1933  // Only create a new attribute if !Override, but we want to do
1934  // the checking.
1935  if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
1936  MergedDeprecated, MergedObsoleted) &&
1937  !Override) {
1938  return ::new (Context) AvailabilityAttr(Range, Context, Platform,
1939  Introduced, Deprecated,
1940  Obsoleted, IsUnavailable, Message,
1941  AttrSpellingListIndex);
1942  }
1943  return nullptr;
1944 }
1945 
1947  const AttributeList &Attr) {
1948  if (!checkAttributeNumArgs(S, Attr, 1))
1949  return;
1950  IdentifierLoc *Platform = Attr.getArgAsIdent(0);
1951  unsigned Index = Attr.getAttributeSpellingListIndex();
1952 
1953  IdentifierInfo *II = Platform->Ident;
1954  if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
1955  S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
1956  << Platform->Ident;
1957 
1958  NamedDecl *ND = dyn_cast<NamedDecl>(D);
1959  if (!ND) {
1960  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1961  return;
1962  }
1963 
1964  AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1965  AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1966  AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
1967  bool IsUnavailable = Attr.getUnavailableLoc().isValid();
1968  StringRef Str;
1969  if (const StringLiteral *SE =
1970  dyn_cast_or_null<StringLiteral>(Attr.getMessageExpr()))
1971  Str = SE->getString();
1972 
1973  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND, Attr.getRange(), II,
1974  Introduced.Version,
1975  Deprecated.Version,
1976  Obsoleted.Version,
1977  IsUnavailable, Str,
1978  /*Override=*/false,
1979  Index);
1980  if (NewAttr)
1981  D->addAttr(NewAttr);
1982 }
1983 
1984 template <class T>
1986  typename T::VisibilityType value,
1987  unsigned attrSpellingListIndex) {
1988  T *existingAttr = D->getAttr<T>();
1989  if (existingAttr) {
1990  typename T::VisibilityType existingValue = existingAttr->getVisibility();
1991  if (existingValue == value)
1992  return nullptr;
1993  S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
1994  S.Diag(range.getBegin(), diag::note_previous_attribute);
1995  D->dropAttr<T>();
1996  }
1997  return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
1998 }
1999 
2000 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2001  VisibilityAttr::VisibilityType Vis,
2002  unsigned AttrSpellingListIndex) {
2003  return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2004  AttrSpellingListIndex);
2005 }
2006 
2007 TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2008  TypeVisibilityAttr::VisibilityType Vis,
2009  unsigned AttrSpellingListIndex) {
2010  return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2011  AttrSpellingListIndex);
2012 }
2013 
2015  bool isTypeVisibility) {
2016  // Visibility attributes don't mean anything on a typedef.
2017  if (isa<TypedefNameDecl>(D)) {
2018  S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
2019  << Attr.getName();
2020  return;
2021  }
2022 
2023  // 'type_visibility' can only go on a type or namespace.
2024  if (isTypeVisibility &&
2025  !(isa<TagDecl>(D) ||
2026  isa<ObjCInterfaceDecl>(D) ||
2027  isa<NamespaceDecl>(D))) {
2028  S.Diag(Attr.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2029  << Attr.getName() << ExpectedTypeOrNamespace;
2030  return;
2031  }
2032 
2033  // Check that the argument is a string literal.
2034  StringRef TypeStr;
2035  SourceLocation LiteralLoc;
2036  if (!S.checkStringLiteralArgumentAttr(Attr, 0, TypeStr, &LiteralLoc))
2037  return;
2038 
2039  VisibilityAttr::VisibilityType type;
2040  if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2041  S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
2042  << Attr.getName() << TypeStr;
2043  return;
2044  }
2045 
2046  // Complain about attempts to use protected visibility on targets
2047  // (like Darwin) that don't support it.
2048  if (type == VisibilityAttr::Protected &&
2050  S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
2051  type = VisibilityAttr::Default;
2052  }
2053 
2054  unsigned Index = Attr.getAttributeSpellingListIndex();
2055  clang::Attr *newAttr;
2056  if (isTypeVisibility) {
2057  newAttr = S.mergeTypeVisibilityAttr(D, Attr.getRange(),
2058  (TypeVisibilityAttr::VisibilityType) type,
2059  Index);
2060  } else {
2061  newAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type, Index);
2062  }
2063  if (newAttr)
2064  D->addAttr(newAttr);
2065 }
2066 
2068  const AttributeList &Attr) {
2069  ObjCMethodDecl *method = cast<ObjCMethodDecl>(decl);
2070  if (!Attr.isArgIdent(0)) {
2071  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2072  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2073  return;
2074  }
2075 
2076  IdentifierLoc *IL = Attr.getArgAsIdent(0);
2077  ObjCMethodFamilyAttr::FamilyKind F;
2078  if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2079  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << Attr.getName()
2080  << IL->Ident;
2081  return;
2082  }
2083 
2084  if (F == ObjCMethodFamilyAttr::OMF_init &&
2085  !method->getReturnType()->isObjCObjectPointerType()) {
2086  S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
2087  << method->getReturnType();
2088  // Ignore the attribute.
2089  return;
2090  }
2091 
2092  method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
2093  S.Context, F,
2095 }
2096 
2097 static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
2098  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2099  QualType T = TD->getUnderlyingType();
2100  if (!T->isCARCBridgableType()) {
2101  S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2102  return;
2103  }
2104  }
2105  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2106  QualType T = PD->getType();
2107  if (!T->isCARCBridgableType()) {
2108  S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2109  return;
2110  }
2111  }
2112  else {
2113  // It is okay to include this attribute on properties, e.g.:
2114  //
2115  // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2116  //
2117  // In this case it follows tradition and suppresses an error in the above
2118  // case.
2119  S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2120  }
2121  D->addAttr(::new (S.Context)
2122  ObjCNSObjectAttr(Attr.getRange(), S.Context,
2124 }
2125 
2127  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2128  QualType T = TD->getUnderlyingType();
2129  if (!T->isObjCObjectPointerType()) {
2130  S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2131  return;
2132  }
2133  } else {
2134  S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2135  return;
2136  }
2137  D->addAttr(::new (S.Context)
2138  ObjCIndependentClassAttr(Attr.getRange(), S.Context,
2140 }
2141 
2142 static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2143  if (!Attr.isArgIdent(0)) {
2144  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2145  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2146  return;
2147  }
2148 
2149  IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2150  BlocksAttr::BlockType type;
2151  if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2152  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2153  << Attr.getName() << II;
2154  return;
2155  }
2156 
2157  D->addAttr(::new (S.Context)
2158  BlocksAttr(Attr.getRange(), S.Context, type,
2160 }
2161 
2162 static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2163  unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2164  if (Attr.getNumArgs() > 0) {
2165  Expr *E = Attr.getArgAsExpr(0);
2166  llvm::APSInt Idx(32);
2167  if (E->isTypeDependent() || E->isValueDependent() ||
2168  !E->isIntegerConstantExpr(Idx, S.Context)) {
2169  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2170  << Attr.getName() << 1 << AANT_ArgumentIntegerConstant
2171  << E->getSourceRange();
2172  return;
2173  }
2174 
2175  if (Idx.isSigned() && Idx.isNegative()) {
2176  S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2177  << E->getSourceRange();
2178  return;
2179  }
2180 
2181  sentinel = Idx.getZExtValue();
2182  }
2183 
2184  unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2185  if (Attr.getNumArgs() > 1) {
2186  Expr *E = Attr.getArgAsExpr(1);
2187  llvm::APSInt Idx(32);
2188  if (E->isTypeDependent() || E->isValueDependent() ||
2189  !E->isIntegerConstantExpr(Idx, S.Context)) {
2190  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2191  << Attr.getName() << 2 << AANT_ArgumentIntegerConstant
2192  << E->getSourceRange();
2193  return;
2194  }
2195  nullPos = Idx.getZExtValue();
2196 
2197  if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2198  // FIXME: This error message could be improved, it would be nice
2199  // to say what the bounds actually are.
2200  S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2201  << E->getSourceRange();
2202  return;
2203  }
2204  }
2205 
2206  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2207  const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2208  if (isa<FunctionNoProtoType>(FT)) {
2209  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2210  return;
2211  }
2212 
2213  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2214  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2215  return;
2216  }
2217  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
2218  if (!MD->isVariadic()) {
2219  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2220  return;
2221  }
2222  } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
2223  if (!BD->isVariadic()) {
2224  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2225  return;
2226  }
2227  } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
2228  QualType Ty = V->getType();
2229  if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2230  const FunctionType *FT = Ty->isFunctionPointerType()
2231  ? D->getFunctionType()
2232  : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2233  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2234  int m = Ty->isFunctionPointerType() ? 0 : 1;
2235  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2236  return;
2237  }
2238  } else {
2239  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2241  return;
2242  }
2243  } else {
2244  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2246  return;
2247  }
2248  D->addAttr(::new (S.Context)
2249  SentinelAttr(Attr.getRange(), S.Context, sentinel, nullPos,
2251 }
2252 
2254  if (D->getFunctionType() &&
2256  S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2257  << Attr.getName() << 0;
2258  return;
2259  }
2260  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2261  if (MD->getReturnType()->isVoidType()) {
2262  S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2263  << Attr.getName() << 1;
2264  return;
2265  }
2266 
2267  D->addAttr(::new (S.Context)
2268  WarnUnusedResultAttr(Attr.getRange(), S.Context,
2270 }
2271 
2272 static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2273  // weak_import only applies to variable & function declarations.
2274  bool isDef = false;
2275  if (!D->canBeWeakImported(isDef)) {
2276  if (isDef)
2277  S.Diag(Attr.getLoc(), diag::warn_attribute_invalid_on_definition)
2278  << "weak_import";
2279  else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2280  (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2281  (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2282  // Nothing to warn about here.
2283  } else
2284  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2285  << Attr.getName() << ExpectedVariableOrFunction;
2286 
2287  return;
2288  }
2289 
2290  D->addAttr(::new (S.Context)
2291  WeakImportAttr(Attr.getRange(), S.Context,
2293 }
2294 
2295 // Handles reqd_work_group_size and work_group_size_hint.
2296 template <typename WorkGroupAttr>
2297 static void handleWorkGroupSize(Sema &S, Decl *D,
2298  const AttributeList &Attr) {
2299  uint32_t WGSize[3];
2300  for (unsigned i = 0; i < 3; ++i) {
2301  const Expr *E = Attr.getArgAsExpr(i);
2302  if (!checkUInt32Argument(S, Attr, E, WGSize[i], i))
2303  return;
2304  if (WGSize[i] == 0) {
2305  S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2306  << Attr.getName() << E->getSourceRange();
2307  return;
2308  }
2309  }
2310 
2311  WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2312  if (Existing && !(Existing->getXDim() == WGSize[0] &&
2313  Existing->getYDim() == WGSize[1] &&
2314  Existing->getZDim() == WGSize[2]))
2315  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2316 
2317  D->addAttr(::new (S.Context) WorkGroupAttr(Attr.getRange(), S.Context,
2318  WGSize[0], WGSize[1], WGSize[2],
2320 }
2321 
2322 static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &Attr) {
2323  if (!Attr.hasParsedType()) {
2324  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2325  << Attr.getName() << 1;
2326  return;
2327  }
2328 
2329  TypeSourceInfo *ParmTSI = nullptr;
2330  QualType ParmType = S.GetTypeFromParser(Attr.getTypeArg(), &ParmTSI);
2331  assert(ParmTSI && "no type source info for attribute argument");
2332 
2333  if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2334  (ParmType->isBooleanType() ||
2335  !ParmType->isIntegralType(S.getASTContext()))) {
2336  S.Diag(Attr.getLoc(), diag::err_attribute_argument_vec_type_hint)
2337  << ParmType;
2338  return;
2339  }
2340 
2341  if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2342  if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2343  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2344  return;
2345  }
2346  }
2347 
2348  D->addAttr(::new (S.Context) VecTypeHintAttr(Attr.getLoc(), S.Context,
2349  ParmTSI,
2351 }
2352 
2353 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2354  StringRef Name,
2355  unsigned AttrSpellingListIndex) {
2356  if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2357  if (ExistingAttr->getName() == Name)
2358  return nullptr;
2359  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
2360  Diag(Range.getBegin(), diag::note_previous_attribute);
2361  return nullptr;
2362  }
2363  return ::new (Context) SectionAttr(Range, Context, Name,
2364  AttrSpellingListIndex);
2365 }
2366 
2367 bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2368  std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2369  if (!Error.empty()) {
2370  Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error;
2371  return false;
2372  }
2373  return true;
2374 }
2375 
2376 static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2377  // Make sure that there is a string literal as the sections's single
2378  // argument.
2379  StringRef Str;
2380  SourceLocation LiteralLoc;
2381  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
2382  return;
2383 
2384  if (!S.checkSectionName(LiteralLoc, Str))
2385  return;
2386 
2387  // If the target wants to validate the section specifier, make it happen.
2388  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
2389  if (!Error.empty()) {
2390  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
2391  << Error;
2392  return;
2393  }
2394 
2395  unsigned Index = Attr.getAttributeSpellingListIndex();
2396  SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(), Str, Index);
2397  if (NewAttr)
2398  D->addAttr(NewAttr);
2399 }
2400 
2401 // Check for things we'd like to warn about, no errors or validation for now.
2402 // TODO: Validation should use a backend target library that specifies
2403 // the allowable subtarget features and cpus. We could use something like a
2404 // TargetCodeGenInfo hook here to do validation.
2405 void Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
2406  for (auto Str : {"tune=", "fpmath="})
2407  if (AttrStr.find(Str) != StringRef::npos)
2408  Diag(LiteralLoc, diag::warn_unsupported_target_attribute) << Str;
2409 }
2410 
2411 static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2412  StringRef Str;
2413  SourceLocation LiteralLoc;
2414  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
2415  return;
2416  S.checkTargetAttr(LiteralLoc, Str);
2417  unsigned Index = Attr.getAttributeSpellingListIndex();
2418  TargetAttr *NewAttr =
2419  ::new (S.Context) TargetAttr(Attr.getRange(), S.Context, Str, Index);
2420  D->addAttr(NewAttr);
2421 }
2422 
2423 
2424 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2425  VarDecl *VD = cast<VarDecl>(D);
2426  if (!VD->hasLocalStorage()) {
2427  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2428  return;
2429  }
2430 
2431  Expr *E = Attr.getArgAsExpr(0);
2432  SourceLocation Loc = E->getExprLoc();
2433  FunctionDecl *FD = nullptr;
2435 
2436  // gcc only allows for simple identifiers. Since we support more than gcc, we
2437  // will warn the user.
2438  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
2439  if (DRE->hasQualifier())
2440  S.Diag(Loc, diag::warn_cleanup_ext);
2441  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
2442  NI = DRE->getNameInfo();
2443  if (!FD) {
2444  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
2445  << NI.getName();
2446  return;
2447  }
2448  } else if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2449  if (ULE->hasExplicitTemplateArgs())
2450  S.Diag(Loc, diag::warn_cleanup_ext);
2452  NI = ULE->getNameInfo();
2453  if (!FD) {
2454  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
2455  << NI.getName();
2456  if (ULE->getType() == S.Context.OverloadTy)
2458  return;
2459  }
2460  } else {
2461  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
2462  return;
2463  }
2464 
2465  if (FD->getNumParams() != 1) {
2466  S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
2467  << NI.getName();
2468  return;
2469  }
2470 
2471  // We're currently more strict than GCC about what function types we accept.
2472  // If this ever proves to be a problem it should be easy to fix.
2473  QualType Ty = S.Context.getPointerType(VD->getType());
2474  QualType ParamTy = FD->getParamDecl(0)->getType();
2476  ParamTy, Ty) != Sema::Compatible) {
2477  S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
2478  << NI.getName() << ParamTy << Ty;
2479  return;
2480  }
2481 
2482  D->addAttr(::new (S.Context)
2483  CleanupAttr(Attr.getRange(), S.Context, FD,
2485 }
2486 
2487 /// Handle __attribute__((format_arg((idx)))) attribute based on
2488 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2489 static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2490  Expr *IdxExpr = Attr.getArgAsExpr(0);
2491  uint64_t Idx;
2492  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, IdxExpr, Idx))
2493  return;
2494 
2495  // make sure the format string is really a string
2497 
2498  bool not_nsstring_type = !isNSStringType(Ty, S.Context);
2499  if (not_nsstring_type &&
2500  !isCFStringType(Ty, S.Context) &&
2501  (!Ty->isPointerType() ||
2502  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2503  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2504  << (not_nsstring_type ? "a string type" : "an NSString")
2505  << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
2506  return;
2507  }
2509  if (!isNSStringType(Ty, S.Context) &&
2510  !isCFStringType(Ty, S.Context) &&
2511  (!Ty->isPointerType() ||
2512  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2513  S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
2514  << (not_nsstring_type ? "string type" : "NSString")
2515  << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
2516  return;
2517  }
2518 
2519  // We cannot use the Idx returned from checkFunctionOrMethodParameterIndex
2520  // because that has corrected for the implicit this parameter, and is zero-
2521  // based. The attribute expects what the user wrote explicitly.
2522  llvm::APSInt Val;
2523  IdxExpr->EvaluateAsInt(Val, S.Context);
2524 
2525  D->addAttr(::new (S.Context)
2526  FormatArgAttr(Attr.getRange(), S.Context, Val.getZExtValue(),
2528 }
2529 
2537 };
2538 
2539 /// getFormatAttrKind - Map from format attribute names to supported format
2540 /// types.
2541 static FormatAttrKind getFormatAttrKind(StringRef Format) {
2542  return llvm::StringSwitch<FormatAttrKind>(Format)
2543  // Check for formats that get handled specially.
2544  .Case("NSString", NSStringFormat)
2545  .Case("CFString", CFStringFormat)
2546  .Case("strftime", StrftimeFormat)
2547 
2548  // Otherwise, check for supported formats.
2549  .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
2550  .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
2551  .Case("kprintf", SupportedFormat) // OpenBSD.
2552  .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
2553  .Case("os_trace", SupportedFormat)
2554 
2555  .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
2556  .Default(InvalidFormat);
2557 }
2558 
2559 /// Handle __attribute__((init_priority(priority))) attributes based on
2560 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
2562  const AttributeList &Attr) {
2563  if (!S.getLangOpts().CPlusPlus) {
2564  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2565  return;
2566  }
2567 
2568  if (S.getCurFunctionOrMethodDecl()) {
2569  S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2570  Attr.setInvalid();
2571  return;
2572  }
2573  QualType T = cast<VarDecl>(D)->getType();
2574  if (S.Context.getAsArrayType(T))
2575  T = S.Context.getBaseElementType(T);
2576  if (!T->getAs<RecordType>()) {
2577  S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2578  Attr.setInvalid();
2579  return;
2580  }
2581 
2582  Expr *E = Attr.getArgAsExpr(0);
2583  uint32_t prioritynum;
2584  if (!checkUInt32Argument(S, Attr, E, prioritynum)) {
2585  Attr.setInvalid();
2586  return;
2587  }
2588 
2589  if (prioritynum < 101 || prioritynum > 65535) {
2590  S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
2591  << E->getSourceRange();
2592  Attr.setInvalid();
2593  return;
2594  }
2595  D->addAttr(::new (S.Context)
2596  InitPriorityAttr(Attr.getRange(), S.Context, prioritynum,
2598 }
2599 
2601  IdentifierInfo *Format, int FormatIdx,
2602  int FirstArg,
2603  unsigned AttrSpellingListIndex) {
2604  // Check whether we already have an equivalent format attribute.
2605  for (auto *F : D->specific_attrs<FormatAttr>()) {
2606  if (F->getType() == Format &&
2607  F->getFormatIdx() == FormatIdx &&
2608  F->getFirstArg() == FirstArg) {
2609  // If we don't have a valid location for this attribute, adopt the
2610  // location.
2611  if (F->getLocation().isInvalid())
2612  F->setRange(Range);
2613  return nullptr;
2614  }
2615  }
2616 
2617  return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
2618  FirstArg, AttrSpellingListIndex);
2619 }
2620 
2621 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
2622 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2623 static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2624  if (!Attr.isArgIdent(0)) {
2625  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2626  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2627  return;
2628  }
2629 
2630  // In C++ the implicit 'this' function parameter also counts, and they are
2631  // counted from one.
2632  bool HasImplicitThisParam = isInstanceMethod(D);
2633  unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
2634 
2635  IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2636  StringRef Format = II->getName();
2637 
2638  // Normalize the argument, __foo__ becomes foo.
2639  if (Format.startswith("__") && Format.endswith("__")) {
2640  Format = Format.substr(2, Format.size() - 4);
2641  // If we've modified the string name, we need a new identifier for it.
2642  II = &S.Context.Idents.get(Format);
2643  }
2644 
2645  // Check for supported formats.
2647 
2648  if (Kind == IgnoredFormat)
2649  return;
2650 
2651  if (Kind == InvalidFormat) {
2652  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2653  << Attr.getName() << II->getName();
2654  return;
2655  }
2656 
2657  // checks for the 2nd argument
2658  Expr *IdxExpr = Attr.getArgAsExpr(1);
2659  uint32_t Idx;
2660  if (!checkUInt32Argument(S, Attr, IdxExpr, Idx, 2))
2661  return;
2662 
2663  if (Idx < 1 || Idx > NumArgs) {
2664  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2665  << Attr.getName() << 2 << IdxExpr->getSourceRange();
2666  return;
2667  }
2668 
2669  // FIXME: Do we need to bounds check?
2670  unsigned ArgIdx = Idx - 1;
2671 
2672  if (HasImplicitThisParam) {
2673  if (ArgIdx == 0) {
2674  S.Diag(Attr.getLoc(),
2675  diag::err_format_attribute_implicit_this_format_string)
2676  << IdxExpr->getSourceRange();
2677  return;
2678  }
2679  ArgIdx--;
2680  }
2681 
2682  // make sure the format string is really a string
2683  QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
2684 
2685  if (Kind == CFStringFormat) {
2686  if (!isCFStringType(Ty, S.Context)) {
2687  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2688  << "a CFString" << IdxExpr->getSourceRange()
2689  << getFunctionOrMethodParamRange(D, ArgIdx);
2690  return;
2691  }
2692  } else if (Kind == NSStringFormat) {
2693  // FIXME: do we need to check if the type is NSString*? What are the
2694  // semantics?
2695  if (!isNSStringType(Ty, S.Context)) {
2696  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2697  << "an NSString" << IdxExpr->getSourceRange()
2698  << getFunctionOrMethodParamRange(D, ArgIdx);
2699  return;
2700  }
2701  } else if (!Ty->isPointerType() ||
2702  !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
2703  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2704  << "a string type" << IdxExpr->getSourceRange()
2705  << getFunctionOrMethodParamRange(D, ArgIdx);
2706  return;
2707  }
2708 
2709  // check the 3rd argument
2710  Expr *FirstArgExpr = Attr.getArgAsExpr(2);
2711  uint32_t FirstArg;
2712  if (!checkUInt32Argument(S, Attr, FirstArgExpr, FirstArg, 3))
2713  return;
2714 
2715  // check if the function is variadic if the 3rd argument non-zero
2716  if (FirstArg != 0) {
2717  if (isFunctionOrMethodVariadic(D)) {
2718  ++NumArgs; // +1 for ...
2719  } else {
2720  S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
2721  return;
2722  }
2723  }
2724 
2725  // strftime requires FirstArg to be 0 because it doesn't read from any
2726  // variable the input is just the current time + the format string.
2727  if (Kind == StrftimeFormat) {
2728  if (FirstArg != 0) {
2729  S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
2730  << FirstArgExpr->getSourceRange();
2731  return;
2732  }
2733  // if 0 it disables parameter checking (to use with e.g. va_list)
2734  } else if (FirstArg != 0 && FirstArg != NumArgs) {
2735  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2736  << Attr.getName() << 3 << FirstArgExpr->getSourceRange();
2737  return;
2738  }
2739 
2740  FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), II,
2741  Idx, FirstArg,
2743  if (NewAttr)
2744  D->addAttr(NewAttr);
2745 }
2746 
2748  const AttributeList &Attr) {
2749  // Try to find the underlying union declaration.
2750  RecordDecl *RD = nullptr;
2751  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
2752  if (TD && TD->getUnderlyingType()->isUnionType())
2753  RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
2754  else
2755  RD = dyn_cast<RecordDecl>(D);
2756 
2757  if (!RD || !RD->isUnion()) {
2758  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2759  << Attr.getName() << ExpectedUnion;
2760  return;
2761  }
2762 
2763  if (!RD->isCompleteDefinition()) {
2764  S.Diag(Attr.getLoc(),
2765  diag::warn_transparent_union_attribute_not_definition);
2766  return;
2767  }
2768 
2770  FieldEnd = RD->field_end();
2771  if (Field == FieldEnd) {
2772  S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
2773  return;
2774  }
2775 
2776  FieldDecl *FirstField = *Field;
2777  QualType FirstType = FirstField->getType();
2778  if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
2779  S.Diag(FirstField->getLocation(),
2780  diag::warn_transparent_union_attribute_floating)
2781  << FirstType->isVectorType() << FirstType;
2782  return;
2783  }
2784 
2785  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
2786  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
2787  for (; Field != FieldEnd; ++Field) {
2788  QualType FieldType = Field->getType();
2789  // FIXME: this isn't fully correct; we also need to test whether the
2790  // members of the union would all have the same calling convention as the
2791  // first member of the union. Checking just the size and alignment isn't
2792  // sufficient (consider structs passed on the stack instead of in registers
2793  // as an example).
2794  if (S.Context.getTypeSize(FieldType) != FirstSize ||
2795  S.Context.getTypeAlign(FieldType) > FirstAlign) {
2796  // Warn if we drop the attribute.
2797  bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
2798  unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
2799  : S.Context.getTypeAlign(FieldType);
2800  S.Diag(Field->getLocation(),
2801  diag::warn_transparent_union_attribute_field_size_align)
2802  << isSize << Field->getDeclName() << FieldBits;
2803  unsigned FirstBits = isSize? FirstSize : FirstAlign;
2804  S.Diag(FirstField->getLocation(),
2805  diag::note_transparent_union_first_field_size_align)
2806  << isSize << FirstBits;
2807  return;
2808  }
2809  }
2810 
2811  RD->addAttr(::new (S.Context)
2812  TransparentUnionAttr(Attr.getRange(), S.Context,
2814 }
2815 
2816 static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2817  // Make sure that there is a string literal as the annotation's single
2818  // argument.
2819  StringRef Str;
2820  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
2821  return;
2822 
2823  // Don't duplicate annotations that are already set.
2824  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
2825  if (I->getAnnotation() == Str)
2826  return;
2827  }
2828 
2829  D->addAttr(::new (S.Context)
2830  AnnotateAttr(Attr.getRange(), S.Context, Str,
2832 }
2833 
2834 static void handleAlignValueAttr(Sema &S, Decl *D,
2835  const AttributeList &Attr) {
2836  S.AddAlignValueAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
2838 }
2839 
2841  unsigned SpellingListIndex) {
2842  AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
2843  SourceLocation AttrLoc = AttrRange.getBegin();
2844 
2845  QualType T;
2846  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
2847  T = TD->getUnderlyingType();
2848  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
2849  T = VD->getType();
2850  else
2851  llvm_unreachable("Unknown decl type for align_value");
2852 
2853  if (!T->isDependentType() && !T->isAnyPointerType() &&
2854  !T->isReferenceType() && !T->isMemberPointerType()) {
2855  Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
2856  << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
2857  return;
2858  }
2859 
2860  if (!E->isValueDependent()) {
2861  llvm::APSInt Alignment(32);
2862  ExprResult ICE
2863  = VerifyIntegerConstantExpression(E, &Alignment,
2864  diag::err_align_value_attribute_argument_not_int,
2865  /*AllowFold*/ false);
2866  if (ICE.isInvalid())
2867  return;
2868 
2869  if (!Alignment.isPowerOf2()) {
2870  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
2871  << E->getSourceRange();
2872  return;
2873  }
2874 
2875  D->addAttr(::new (Context)
2876  AlignValueAttr(AttrRange, Context, ICE.get(),
2877  SpellingListIndex));
2878  return;
2879  }
2880 
2881  // Save dependent expressions in the AST to be instantiated.
2882  D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
2883  return;
2884 }
2885 
2886 static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2887  // check the attribute arguments.
2888  if (Attr.getNumArgs() > 1) {
2889  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2890  << Attr.getName() << 1;
2891  return;
2892  }
2893 
2894  if (Attr.getNumArgs() == 0) {
2895  D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
2896  true, nullptr, Attr.getAttributeSpellingListIndex()));
2897  return;
2898  }
2899 
2900  Expr *E = Attr.getArgAsExpr(0);
2901  if (Attr.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
2902  S.Diag(Attr.getEllipsisLoc(),
2903  diag::err_pack_expansion_without_parameter_packs);
2904  return;
2905  }
2906 
2908  return;
2909 
2910  if (E->isValueDependent()) {
2911  if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
2912  if (!TND->getUnderlyingType()->isDependentType()) {
2913  S.Diag(Attr.getLoc(), diag::err_alignment_dependent_typedef_name)
2914  << E->getSourceRange();
2915  return;
2916  }
2917  }
2918  }
2919 
2920  S.AddAlignedAttr(Attr.getRange(), D, E, Attr.getAttributeSpellingListIndex(),
2921  Attr.isPackExpansion());
2922 }
2923 
2925  unsigned SpellingListIndex, bool IsPackExpansion) {
2926  AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
2927  SourceLocation AttrLoc = AttrRange.getBegin();
2928 
2929  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
2930  if (TmpAttr.isAlignas()) {
2931  // C++11 [dcl.align]p1:
2932  // An alignment-specifier may be applied to a variable or to a class
2933  // data member, but it shall not be applied to a bit-field, a function
2934  // parameter, the formal parameter of a catch clause, or a variable
2935  // declared with the register storage class specifier. An
2936  // alignment-specifier may also be applied to the declaration of a class
2937  // or enumeration type.
2938  // C11 6.7.5/2:
2939  // An alignment attribute shall not be specified in a declaration of
2940  // a typedef, or a bit-field, or a function, or a parameter, or an
2941  // object declared with the register storage-class specifier.
2942  int DiagKind = -1;
2943  if (isa<ParmVarDecl>(D)) {
2944  DiagKind = 0;
2945  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
2946  if (VD->getStorageClass() == SC_Register)
2947  DiagKind = 1;
2948  if (VD->isExceptionVariable())
2949  DiagKind = 2;
2950  } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
2951  if (FD->isBitField())
2952  DiagKind = 3;
2953  } else if (!isa<TagDecl>(D)) {
2954  Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
2955  << (TmpAttr.isC11() ? ExpectedVariableOrField
2957  return;
2958  }
2959  if (DiagKind != -1) {
2960  Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
2961  << &TmpAttr << DiagKind;
2962  return;
2963  }
2964  }
2965 
2966  if (E->isTypeDependent() || E->isValueDependent()) {
2967  // Save dependent expressions in the AST to be instantiated.
2968  AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
2969  AA->setPackExpansion(IsPackExpansion);
2970  D->addAttr(AA);
2971  return;
2972  }
2973 
2974  // FIXME: Cache the number on the Attr object?
2975  llvm::APSInt Alignment(32);
2976  ExprResult ICE
2977  = VerifyIntegerConstantExpression(E, &Alignment,
2978  diag::err_aligned_attribute_argument_not_int,
2979  /*AllowFold*/ false);
2980  if (ICE.isInvalid())
2981  return;
2982 
2983  // C++11 [dcl.align]p2:
2984  // -- if the constant expression evaluates to zero, the alignment
2985  // specifier shall have no effect
2986  // C11 6.7.5p6:
2987  // An alignment specification of zero has no effect.
2988  if (!(TmpAttr.isAlignas() && !Alignment)) {
2989  if(!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
2990  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
2991  << E->getSourceRange();
2992  return;
2993  }
2995  if (unsigned MaxAlign = Context.getTargetInfo().getMaxTLSAlign()) {
2996  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
2997  if (VD->getTLSKind()) {
2998  CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
2999  if (Alignment.getSExtValue() > MaxAlignChars.getQuantity()) {
3000  Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3001  << (unsigned)Alignment.getZExtValue() << VD
3002  << (unsigned)MaxAlignChars.getQuantity();
3003  return;
3004  }
3005  }
3006  }
3007  }
3008  }
3009  }
3010 
3011  // Alignment calculations can wrap around if it's greater than 2**28.
3012  unsigned MaxValidAlignment = TmpAttr.isDeclspec() ? 8192 : 268435456;
3013  if (Alignment.getZExtValue() > MaxValidAlignment) {
3014  Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3015  << E->getSourceRange();
3016  return;
3017  }
3018 
3019  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3020  ICE.get(), SpellingListIndex);
3021  AA->setPackExpansion(IsPackExpansion);
3022  D->addAttr(AA);
3023 }
3024 
3026  unsigned SpellingListIndex, bool IsPackExpansion) {
3027  // FIXME: Cache the number on the Attr object if non-dependent?
3028  // FIXME: Perform checking of type validity
3029  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3030  SpellingListIndex);
3031  AA->setPackExpansion(IsPackExpansion);
3032  D->addAttr(AA);
3033 }
3034 
3036  assert(D->hasAttrs() && "no attributes on decl");
3037 
3038  QualType UnderlyingTy, DiagTy;
3039  if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
3040  UnderlyingTy = DiagTy = VD->getType();
3041  } else {
3042  UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3043  if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
3044  UnderlyingTy = ED->getIntegerType();
3045  }
3046  if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3047  return;
3048 
3049  // C++11 [dcl.align]p5, C11 6.7.5/4:
3050  // The combined effect of all alignment attributes in a declaration shall
3051  // not specify an alignment that is less strict than the alignment that
3052  // would otherwise be required for the entity being declared.
3053  AlignedAttr *AlignasAttr = nullptr;
3054  unsigned Align = 0;
3055  for (auto *I : D->specific_attrs<AlignedAttr>()) {
3056  if (I->isAlignmentDependent())
3057  return;
3058  if (I->isAlignas())
3059  AlignasAttr = I;
3060  Align = std::max(Align, I->getAlignment(Context));
3061  }
3062 
3063  if (AlignasAttr && Align) {
3064  CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3065  CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3066  if (NaturalAlign > RequestedAlign)
3067  Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3068  << DiagTy << (unsigned)NaturalAlign.getQuantity();
3069  }
3070 }
3071 
3073  CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3074  MSInheritanceAttr::Spelling SemanticSpelling) {
3075  assert(RD->hasDefinition() && "RD has no definition!");
3076 
3077  // We may not have seen base specifiers or any virtual methods yet. We will
3078  // have to wait until the record is defined to catch any mismatches.
3079  if (!RD->getDefinition()->isCompleteDefinition())
3080  return false;
3081 
3082  // The unspecified model never matches what a definition could need.
3083  if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3084  return false;
3085 
3086  if (BestCase) {
3087  if (RD->calculateInheritanceModel() == SemanticSpelling)
3088  return false;
3089  } else {
3090  if (RD->calculateInheritanceModel() <= SemanticSpelling)
3091  return false;
3092  }
3093 
3094  Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3095  << 0 /*definition*/;
3096  Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3097  << RD->getNameAsString();
3098  return true;
3099 }
3100 
3101 /// handleModeAttr - This attribute modifies the width of a decl with primitive
3102 /// type.
3103 ///
3104 /// Despite what would be logical, the mode attribute is a decl attribute, not a
3105 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3106 /// HImode, not an intermediate pointer.
3107 static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3108  // This attribute isn't documented, but glibc uses it. It changes
3109  // the width of an int or unsigned int to the specified size.
3110  if (!Attr.isArgIdent(0)) {
3111  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
3113  return;
3114  }
3115 
3116  IdentifierInfo *Name = Attr.getArgAsIdent(0)->Ident;
3117  StringRef Str = Name->getName();
3118 
3119  // Normalize the attribute name, __foo__ becomes foo.
3120  if (Str.startswith("__") && Str.endswith("__"))
3121  Str = Str.substr(2, Str.size() - 4);
3122 
3123  unsigned DestWidth = 0;
3124  bool IntegerMode = true;
3125  bool ComplexMode = false;
3126  switch (Str.size()) {
3127  case 2:
3128  switch (Str[0]) {
3129  case 'Q': DestWidth = 8; break;
3130  case 'H': DestWidth = 16; break;
3131  case 'S': DestWidth = 32; break;
3132  case 'D': DestWidth = 64; break;
3133  case 'X': DestWidth = 96; break;
3134  case 'T': DestWidth = 128; break;
3135  }
3136  if (Str[1] == 'F') {
3137  IntegerMode = false;
3138  } else if (Str[1] == 'C') {
3139  IntegerMode = false;
3140  ComplexMode = true;
3141  } else if (Str[1] != 'I') {
3142  DestWidth = 0;
3143  }
3144  break;
3145  case 4:
3146  // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3147  // pointer on PIC16 and other embedded platforms.
3148  if (Str == "word")
3149  DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3150  else if (Str == "byte")
3151  DestWidth = S.Context.getTargetInfo().getCharWidth();
3152  break;
3153  case 7:
3154  if (Str == "pointer")
3155  DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3156  break;
3157  case 11:
3158  if (Str == "unwind_word")
3159  DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
3160  break;
3161  }
3162 
3163  QualType OldTy;
3164  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3165  OldTy = TD->getUnderlyingType();
3166  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3167  OldTy = VD->getType();
3168  else {
3169  S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
3170  << Attr.getName() << Attr.getRange();
3171  return;
3172  }
3173 
3174  // Base type can also be a vector type (see PR17453).
3175  // Distinguish between base type and base element type.
3176  QualType OldElemTy = OldTy;
3177  if (const VectorType *VT = OldTy->getAs<VectorType>())
3178  OldElemTy = VT->getElementType();
3179 
3180  if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType())
3181  S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
3182  else if (IntegerMode) {
3183  if (!OldElemTy->isIntegralOrEnumerationType())
3184  S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3185  } else if (ComplexMode) {
3186  if (!OldElemTy->isComplexType())
3187  S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3188  } else {
3189  if (!OldElemTy->isFloatingType())
3190  S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3191  }
3192 
3193  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3194  // and friends, at least with glibc.
3195  // FIXME: Make sure floating-point mappings are accurate
3196  // FIXME: Support XF and TF types
3197  if (!DestWidth) {
3198  S.Diag(Attr.getLoc(), diag::err_machine_mode) << 0 /*Unknown*/ << Name;
3199  return;
3200  }
3201 
3202  QualType NewElemTy;
3203 
3204  if (IntegerMode)
3205  NewElemTy = S.Context.getIntTypeForBitwidth(
3206  DestWidth, OldElemTy->isSignedIntegerType());
3207  else
3208  NewElemTy = S.Context.getRealTypeForBitwidth(DestWidth);
3209 
3210  if (NewElemTy.isNull()) {
3211  S.Diag(Attr.getLoc(), diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
3212  return;
3213  }
3214 
3215  if (ComplexMode) {
3216  NewElemTy = S.Context.getComplexType(NewElemTy);
3217  }
3218 
3219  QualType NewTy = NewElemTy;
3220  if (const VectorType *OldVT = OldTy->getAs<VectorType>()) {
3221  // Complex machine mode does not support base vector types.
3222  if (ComplexMode) {
3223  S.Diag(Attr.getLoc(), diag::err_complex_mode_vector_type);
3224  return;
3225  }
3226  unsigned NumElements = S.Context.getTypeSize(OldElemTy) *
3227  OldVT->getNumElements() /
3228  S.Context.getTypeSize(NewElemTy);
3229  NewTy =
3230  S.Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
3231  }
3232 
3233  if (NewTy.isNull()) {
3234  S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3235  return;
3236  }
3237 
3238  // Install the new type.
3239  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3240  TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
3241  else
3242  cast<ValueDecl>(D)->setType(NewTy);
3243 
3244  D->addAttr(::new (S.Context)
3245  ModeAttr(Attr.getRange(), S.Context, Name,
3247 }
3248 
3249 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3250  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
3251  if (!VD->hasGlobalStorage())
3252  S.Diag(Attr.getLoc(),
3253  diag::warn_attribute_requires_functions_or_static_globals)
3254  << Attr.getName();
3255  } else if (!isFunctionOrMethod(D)) {
3256  S.Diag(Attr.getLoc(),
3257  diag::warn_attribute_requires_functions_or_static_globals)
3258  << Attr.getName();
3259  return;
3260  }
3261 
3262  D->addAttr(::new (S.Context)
3263  NoDebugAttr(Attr.getRange(), S.Context,
3265 }
3266 
3267 AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
3268  IdentifierInfo *Ident,
3269  unsigned AttrSpellingListIndex) {
3270  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
3271  Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
3272  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
3273  return nullptr;
3274  }
3275 
3276  if (D->hasAttr<AlwaysInlineAttr>())
3277  return nullptr;
3278 
3279  return ::new (Context) AlwaysInlineAttr(Range, Context,
3280  AttrSpellingListIndex);
3281 }
3282 
3283 MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
3284  unsigned AttrSpellingListIndex) {
3285  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
3286  Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
3287  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
3288  return nullptr;
3289  }
3290 
3291  if (D->hasAttr<MinSizeAttr>())
3292  return nullptr;
3293 
3294  return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
3295 }
3296 
3297 OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
3298  unsigned AttrSpellingListIndex) {
3299  if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
3300  Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
3301  Diag(Range.getBegin(), diag::note_conflicting_attribute);
3302  D->dropAttr<AlwaysInlineAttr>();
3303  }
3304  if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
3305  Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
3306  Diag(Range.getBegin(), diag::note_conflicting_attribute);
3307  D->dropAttr<MinSizeAttr>();
3308  }
3309 
3310  if (D->hasAttr<OptimizeNoneAttr>())
3311  return nullptr;
3312 
3313  return ::new (Context) OptimizeNoneAttr(Range, Context,
3314  AttrSpellingListIndex);
3315 }
3316 
3318  const AttributeList &Attr) {
3319  if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
3320  D, Attr.getRange(), Attr.getName(),
3322  D->addAttr(Inline);
3323 }
3324 
3325 static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3326  if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
3327  D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
3328  D->addAttr(MinSize);
3329 }
3330 
3332  const AttributeList &Attr) {
3333  if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
3334  D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
3335  D->addAttr(Optnone);
3336 }
3337 
3338 static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3339  FunctionDecl *FD = cast<FunctionDecl>(D);
3340  if (!FD->getReturnType()->isVoidType()) {
3341  SourceRange RTRange = FD->getReturnTypeSourceRange();
3342  S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3343  << FD->getType()
3344  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
3345  : FixItHint());
3346  return;
3347  }
3348 
3349  D->addAttr(::new (S.Context)
3350  CUDAGlobalAttr(Attr.getRange(), S.Context,
3352 }
3353 
3354 static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3355  FunctionDecl *Fn = cast<FunctionDecl>(D);
3356  if (!Fn->isInlineSpecified()) {
3357  S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
3358  return;
3359  }
3360 
3361  D->addAttr(::new (S.Context)
3362  GNUInlineAttr(Attr.getRange(), S.Context,
3364 }
3365 
3366 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3367  if (hasDeclarator(D)) return;
3368 
3369  // Diagnostic is emitted elsewhere: here we store the (valid) Attr
3370  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
3371  CallingConv CC;
3372  if (S.CheckCallingConvAttr(Attr, CC, /*FD*/nullptr))
3373  return;
3374 
3375  if (!isa<ObjCMethodDecl>(D)) {
3376  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3377  << Attr.getName() << ExpectedFunctionOrMethod;
3378  return;
3379  }
3380 
3381  switch (Attr.getKind()) {
3382  case AttributeList::AT_FastCall:
3383  D->addAttr(::new (S.Context)
3384  FastCallAttr(Attr.getRange(), S.Context,
3386  return;
3387  case AttributeList::AT_StdCall:
3388  D->addAttr(::new (S.Context)
3389  StdCallAttr(Attr.getRange(), S.Context,
3391  return;
3392  case AttributeList::AT_ThisCall:
3393  D->addAttr(::new (S.Context)
3394  ThisCallAttr(Attr.getRange(), S.Context,
3396  return;
3397  case AttributeList::AT_CDecl:
3398  D->addAttr(::new (S.Context)
3399  CDeclAttr(Attr.getRange(), S.Context,
3401  return;
3402  case AttributeList::AT_Pascal:
3403  D->addAttr(::new (S.Context)
3404  PascalAttr(Attr.getRange(), S.Context,
3406  return;
3407  case AttributeList::AT_VectorCall:
3408  D->addAttr(::new (S.Context)
3409  VectorCallAttr(Attr.getRange(), S.Context,
3411  return;
3412  case AttributeList::AT_MSABI:
3413  D->addAttr(::new (S.Context)
3414  MSABIAttr(Attr.getRange(), S.Context,
3416  return;
3417  case AttributeList::AT_SysVABI:
3418  D->addAttr(::new (S.Context)
3419  SysVABIAttr(Attr.getRange(), S.Context,
3421  return;
3422  case AttributeList::AT_Pcs: {
3423  PcsAttr::PCSType PCS;
3424  switch (CC) {
3425  case CC_AAPCS:
3426  PCS = PcsAttr::AAPCS;
3427  break;
3428  case CC_AAPCS_VFP:
3429  PCS = PcsAttr::AAPCS_VFP;
3430  break;
3431  default:
3432  llvm_unreachable("unexpected calling convention in pcs attribute");
3433  }
3434 
3435  D->addAttr(::new (S.Context)
3436  PcsAttr(Attr.getRange(), S.Context, PCS,
3438  return;
3439  }
3440  case AttributeList::AT_IntelOclBicc:
3441  D->addAttr(::new (S.Context)
3442  IntelOclBiccAttr(Attr.getRange(), S.Context,
3444  return;
3445 
3446  default:
3447  llvm_unreachable("unexpected attribute kind");
3448  }
3449 }
3450 
3452  const FunctionDecl *FD) {
3453  if (attr.isInvalid())
3454  return true;
3455 
3456  unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0;
3457  if (!checkAttributeNumArgs(*this, attr, ReqArgs)) {
3458  attr.setInvalid();
3459  return true;
3460  }
3461 
3462  // TODO: diagnose uses of these conventions on the wrong target.
3463  switch (attr.getKind()) {
3464  case AttributeList::AT_CDecl: CC = CC_C; break;
3465  case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
3466  case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
3467  case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
3468  case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
3469  case AttributeList::AT_VectorCall: CC = CC_X86VectorCall; break;
3470  case AttributeList::AT_MSABI:
3471  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
3473  break;
3474  case AttributeList::AT_SysVABI:
3475  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
3476  CC_C;
3477  break;
3478  case AttributeList::AT_Pcs: {
3479  StringRef StrRef;
3480  if (!checkStringLiteralArgumentAttr(attr, 0, StrRef)) {
3481  attr.setInvalid();
3482  return true;
3483  }
3484  if (StrRef == "aapcs") {
3485  CC = CC_AAPCS;
3486  break;
3487  } else if (StrRef == "aapcs-vfp") {
3488  CC = CC_AAPCS_VFP;
3489  break;
3490  }
3491 
3492  attr.setInvalid();
3493  Diag(attr.getLoc(), diag::err_invalid_pcs);
3494  return true;
3495  }
3496  case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
3497  default: llvm_unreachable("unexpected attribute kind");
3498  }
3499 
3500  const TargetInfo &TI = Context.getTargetInfo();
3502  if (A != TargetInfo::CCCR_OK) {
3503  if (A == TargetInfo::CCCR_Warning)
3504  Diag(attr.getLoc(), diag::warn_cconv_ignored) << attr.getName();
3505 
3506  // This convention is not valid for the target. Use the default function or
3507  // method calling convention.
3509  if (FD)
3512  CC = TI.getDefaultCallingConv(MT);
3513  }
3514 
3515  return false;
3516 }
3517 
3518 /// Checks a regparm attribute, returning true if it is ill-formed and
3519 /// otherwise setting numParams to the appropriate value.
3520 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3521  if (Attr.isInvalid())
3522  return true;
3523 
3524  if (!checkAttributeNumArgs(*this, Attr, 1)) {
3525  Attr.setInvalid();
3526  return true;
3527  }
3528 
3529  uint32_t NP;
3530  Expr *NumParamsExpr = Attr.getArgAsExpr(0);
3531  if (!checkUInt32Argument(*this, Attr, NumParamsExpr, NP)) {
3532  Attr.setInvalid();
3533  return true;
3534  }
3535 
3536  if (Context.getTargetInfo().getRegParmMax() == 0) {
3537  Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
3538  << NumParamsExpr->getSourceRange();
3539  Attr.setInvalid();
3540  return true;
3541  }
3542 
3543  numParams = NP;
3544  if (numParams > Context.getTargetInfo().getRegParmMax()) {
3545  Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
3546  << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
3547  Attr.setInvalid();
3548  return true;
3549  }
3550 
3551  return false;
3552 }
3553 
3554 // Checks whether an argument of launch_bounds attribute is acceptable
3555 // May output an error.
3557  const CUDALaunchBoundsAttr &Attr,
3558  const unsigned Idx) {
3559 
3561  return false;
3562 
3563  // Accept template arguments for now as they depend on something else.
3564  // We'll get to check them when they eventually get instantiated.
3565  if (E->isValueDependent())
3566  return true;
3567 
3568  llvm::APSInt I(64);
3569  if (!E->isIntegerConstantExpr(I, S.Context)) {
3570  S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
3571  << &Attr << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
3572  return false;
3573  }
3574  // Make sure we can fit it in 32 bits.
3575  if (!I.isIntN(32)) {
3576  S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
3577  << 32 << /* Unsigned */ 1;
3578  return false;
3579  }
3580  if (I < 0)
3581  S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
3582  << &Attr << Idx << E->getSourceRange();
3583 
3584  return true;
3585 }
3586 
3587 void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
3588  Expr *MinBlocks, unsigned SpellingListIndex) {
3589  CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
3590  SpellingListIndex);
3591 
3592  if (!checkLaunchBoundsArgument(*this, MaxThreads, TmpAttr, 0))
3593  return;
3594 
3595  if (MinBlocks && !checkLaunchBoundsArgument(*this, MinBlocks, TmpAttr, 1))
3596  return;
3597 
3598  D->addAttr(::new (Context) CUDALaunchBoundsAttr(
3599  AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
3600 }
3601 
3603  const AttributeList &Attr) {
3604  if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
3605  !checkAttributeAtMostNumArgs(S, Attr, 2))
3606  return;
3607 
3608  S.AddLaunchBoundsAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
3609  Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr,
3611 }
3612 
3614  const AttributeList &Attr) {
3615  if (!Attr.isArgIdent(0)) {
3616  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3617  << Attr.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
3618  return;
3619  }
3620 
3621  if (!checkAttributeNumArgs(S, Attr, 3))
3622  return;
3623 
3624  IdentifierInfo *ArgumentKind = Attr.getArgAsIdent(0)->Ident;
3625 
3626  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
3627  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3628  << Attr.getName() << ExpectedFunctionOrMethod;
3629  return;
3630  }
3631 
3632  uint64_t ArgumentIdx;
3633  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 2, Attr.getArgAsExpr(1),
3634  ArgumentIdx))
3635  return;
3636 
3637  uint64_t TypeTagIdx;
3638  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 3, Attr.getArgAsExpr(2),
3639  TypeTagIdx))
3640  return;
3641 
3642  bool IsPointer = (Attr.getName()->getName() == "pointer_with_type_tag");
3643  if (IsPointer) {
3644  // Ensure that buffer has a pointer type.
3645  QualType BufferTy = getFunctionOrMethodParamType(D, ArgumentIdx);
3646  if (!BufferTy->isPointerType()) {
3647  S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
3648  << Attr.getName();
3649  }
3650  }
3651 
3652  D->addAttr(::new (S.Context)
3653  ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
3654  ArgumentIdx, TypeTagIdx, IsPointer,
3656 }
3657 
3659  const AttributeList &Attr) {
3660  if (!Attr.isArgIdent(0)) {
3661  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3662  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
3663  return;
3664  }
3665 
3666  if (!checkAttributeNumArgs(S, Attr, 1))
3667  return;
3668 
3669  if (!isa<VarDecl>(D)) {
3670  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3671  << Attr.getName() << ExpectedVariable;
3672  return;
3673  }
3674 
3675  IdentifierInfo *PointerKind = Attr.getArgAsIdent(0)->Ident;
3676  TypeSourceInfo *MatchingCTypeLoc = nullptr;
3677  S.GetTypeFromParser(Attr.getMatchingCType(), &MatchingCTypeLoc);
3678  assert(MatchingCTypeLoc && "no type source info for attribute argument");
3679 
3680  D->addAttr(::new (S.Context)
3681  TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
3682  MatchingCTypeLoc,
3683  Attr.getLayoutCompatible(),
3684  Attr.getMustBeNull(),
3686 }
3687 
3688 //===----------------------------------------------------------------------===//
3689 // Checker-specific attribute handlers.
3690 //===----------------------------------------------------------------------===//
3691 
3693  return type->isDependentType() ||
3694  type->isObjCRetainableType();
3695 }
3696 
3698  return type->isDependentType() ||
3699  type->isObjCObjectPointerType() ||
3700  S.Context.isObjCNSObjectType(type);
3701 }
3703  return type->isDependentType() ||
3704  type->isPointerType() ||
3705  isValidSubjectOfNSAttribute(S, type);
3706 }
3707 
3708 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3709  ParmVarDecl *param = cast<ParmVarDecl>(D);
3710  bool typeOK, cf;
3711 
3712  if (Attr.getKind() == AttributeList::AT_NSConsumed) {
3713  typeOK = isValidSubjectOfNSAttribute(S, param->getType());
3714  cf = false;
3715  } else {
3716  typeOK = isValidSubjectOfCFAttribute(S, param->getType());
3717  cf = true;
3718  }
3719 
3720  if (!typeOK) {
3721  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3722  << Attr.getRange() << Attr.getName() << cf;
3723  return;
3724  }
3725 
3726  if (cf)
3727  param->addAttr(::new (S.Context)
3728  CFConsumedAttr(Attr.getRange(), S.Context,
3730  else
3731  param->addAttr(::new (S.Context)
3732  NSConsumedAttr(Attr.getRange(), S.Context,
3734 }
3735 
3737  const AttributeList &Attr) {
3738 
3739  QualType returnType;
3740 
3741  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
3742  returnType = MD->getReturnType();
3743  else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
3744  (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
3745  return; // ignore: was handled as a type attribute
3746  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
3747  returnType = PD->getType();
3748  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
3749  returnType = FD->getReturnType();
3750  else if (auto *Param = dyn_cast<ParmVarDecl>(D)) {
3751  returnType = Param->getType()->getPointeeType();
3752  if (returnType.isNull()) {
3753  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3754  << Attr.getName() << /*pointer-to-CF*/2
3755  << Attr.getRange();
3756  return;
3757  }
3758  } else {
3759  AttributeDeclKind ExpectedDeclKind;
3760  switch (Attr.getKind()) {
3761  default: llvm_unreachable("invalid ownership attribute");
3762  case AttributeList::AT_NSReturnsRetained:
3763  case AttributeList::AT_NSReturnsAutoreleased:
3764  case AttributeList::AT_NSReturnsNotRetained:
3765  ExpectedDeclKind = ExpectedFunctionOrMethod;
3766  break;
3767 
3768  case AttributeList::AT_CFReturnsRetained:
3769  case AttributeList::AT_CFReturnsNotRetained:
3770  ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
3771  break;
3772  }
3773  S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3774  << Attr.getRange() << Attr.getName() << ExpectedDeclKind;
3775  return;
3776  }
3777 
3778  bool typeOK;
3779  bool cf;
3780  switch (Attr.getKind()) {
3781  default: llvm_unreachable("invalid ownership attribute");
3782  case AttributeList::AT_NSReturnsRetained:
3783  typeOK = isValidSubjectOfNSReturnsRetainedAttribute(returnType);
3784  cf = false;
3785  break;
3786 
3787  case AttributeList::AT_NSReturnsAutoreleased:
3788  case AttributeList::AT_NSReturnsNotRetained:
3789  typeOK = isValidSubjectOfNSAttribute(S, returnType);
3790  cf = false;
3791  break;
3792 
3793  case AttributeList::AT_CFReturnsRetained:
3794  case AttributeList::AT_CFReturnsNotRetained:
3795  typeOK = isValidSubjectOfCFAttribute(S, returnType);
3796  cf = true;
3797  break;
3798  }
3799 
3800  if (!typeOK) {
3801  if (isa<ParmVarDecl>(D)) {
3802  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3803  << Attr.getName() << /*pointer-to-CF*/2
3804  << Attr.getRange();
3805  } else {
3806  // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
3807  enum : unsigned {
3808  Function,
3809  Method,
3810  Property
3811  } SubjectKind = Function;
3812  if (isa<ObjCMethodDecl>(D))
3813  SubjectKind = Method;
3814  else if (isa<ObjCPropertyDecl>(D))
3815  SubjectKind = Property;
3816  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3817  << Attr.getName() << SubjectKind << cf
3818  << Attr.getRange();
3819  }
3820  return;
3821  }
3822 
3823  switch (Attr.getKind()) {
3824  default:
3825  llvm_unreachable("invalid ownership attribute");
3826  case AttributeList::AT_NSReturnsAutoreleased:
3827  D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
3828  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3829  return;
3830  case AttributeList::AT_CFReturnsNotRetained:
3831  D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
3832  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3833  return;
3834  case AttributeList::AT_NSReturnsNotRetained:
3835  D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
3836  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3837  return;
3838  case AttributeList::AT_CFReturnsRetained:
3839  D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
3840  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3841  return;
3842  case AttributeList::AT_NSReturnsRetained:
3843  D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
3844  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3845  return;
3846  };
3847 }
3848 
3850  const AttributeList &attr) {
3851  const int EP_ObjCMethod = 1;
3852  const int EP_ObjCProperty = 2;
3853 
3854  SourceLocation loc = attr.getLoc();
3855  QualType resultType;
3856  if (isa<ObjCMethodDecl>(D))
3857  resultType = cast<ObjCMethodDecl>(D)->getReturnType();
3858  else
3859  resultType = cast<ObjCPropertyDecl>(D)->getType();
3860 
3861  if (!resultType->isReferenceType() &&
3862  (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
3863  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3864  << SourceRange(loc)
3865  << attr.getName()
3866  << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
3867  << /*non-retainable pointer*/ 2;
3868 
3869  // Drop the attribute.
3870  return;
3871  }
3872 
3873  D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
3874  attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
3875 }
3876 
3878  const AttributeList &attr) {
3879  ObjCMethodDecl *method = cast<ObjCMethodDecl>(D);
3880 
3881  DeclContext *DC = method->getDeclContext();
3882  if (const ObjCProtocolDecl *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
3883  S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
3884  << attr.getName() << 0;
3885  S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
3886  return;
3887  }
3888  if (method->getMethodFamily() == OMF_dealloc) {
3889  S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
3890  << attr.getName() << 1;
3891  return;
3892  }
3893 
3894  method->addAttr(::new (S.Context)
3895  ObjCRequiresSuperAttr(attr.getRange(), S.Context,
3897 }
3898 
3900  const AttributeList &Attr) {
3901  if (checkAttrMutualExclusion<CFUnknownTransferAttr>(S, D, Attr))
3902  return;
3903 
3904  D->addAttr(::new (S.Context)
3905  CFAuditedTransferAttr(Attr.getRange(), S.Context,
3907 }
3908 
3910  const AttributeList &Attr) {
3911  if (checkAttrMutualExclusion<CFAuditedTransferAttr>(S, D, Attr))
3912  return;
3913 
3914  D->addAttr(::new (S.Context)
3915  CFUnknownTransferAttr(Attr.getRange(), S.Context,
3917 }
3918 
3919 static void handleObjCBridgeAttr(Sema &S, Scope *Sc, Decl *D,
3920  const AttributeList &Attr) {
3921  IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3922 
3923  if (!Parm) {
3924  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3925  return;
3926  }
3927 
3928  // Typedefs only allow objc_bridge(id) and have some additional checking.
3929  if (auto TD = dyn_cast<TypedefNameDecl>(D)) {
3930  if (!Parm->Ident->isStr("id")) {
3931  S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_id)
3932  << Attr.getName();
3933  return;
3934  }
3935 
3936  // Only allow 'cv void *'.
3937  QualType T = TD->getUnderlyingType();
3938  if (!T->isVoidPointerType()) {
3939  S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
3940  return;
3941  }
3942  }
3943 
3944  D->addAttr(::new (S.Context)
3945  ObjCBridgeAttr(Attr.getRange(), S.Context, Parm->Ident,
3947 }
3948 
3950  const AttributeList &Attr) {
3951  IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3952 
3953  if (!Parm) {
3954  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3955  return;
3956  }
3957 
3958  D->addAttr(::new (S.Context)
3959  ObjCBridgeMutableAttr(Attr.getRange(), S.Context, Parm->Ident,
3961 }
3962 
3964  const AttributeList &Attr) {
3965  IdentifierInfo *RelatedClass =
3966  Attr.isArgIdent(0) ? Attr.getArgAsIdent(0)->Ident : nullptr;
3967  if (!RelatedClass) {
3968  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3969  return;
3970  }
3971  IdentifierInfo *ClassMethod =
3972  Attr.getArgAsIdent(1) ? Attr.getArgAsIdent(1)->Ident : nullptr;
3973  IdentifierInfo *InstanceMethod =
3974  Attr.getArgAsIdent(2) ? Attr.getArgAsIdent(2)->Ident : nullptr;
3975  D->addAttr(::new (S.Context)
3976  ObjCBridgeRelatedAttr(Attr.getRange(), S.Context, RelatedClass,
3977  ClassMethod, InstanceMethod,
3979 }
3980 
3982  const AttributeList &Attr) {
3983  ObjCInterfaceDecl *IFace;
3984  if (ObjCCategoryDecl *CatDecl =
3985  dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
3986  IFace = CatDecl->getClassInterface();
3987  else
3988  IFace = cast<ObjCInterfaceDecl>(D->getDeclContext());
3989 
3990  if (!IFace)
3991  return;
3992 
3994  D->addAttr(::new (S.Context)
3995  ObjCDesignatedInitializerAttr(Attr.getRange(), S.Context,
3997 }
3998 
4000  const AttributeList &Attr) {
4001  StringRef MetaDataName;
4002  if (!S.checkStringLiteralArgumentAttr(Attr, 0, MetaDataName))
4003  return;
4004  D->addAttr(::new (S.Context)
4005  ObjCRuntimeNameAttr(Attr.getRange(), S.Context,
4006  MetaDataName,
4008 }
4009 
4010 // when a user wants to use objc_boxable with a union or struct
4011 // but she doesn't have access to the declaration (legacy/third-party code)
4012 // then she can 'enable' this feature via trick with a typedef
4013 // e.g.:
4014 // typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
4015 static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr) {
4016  bool notify = false;
4017 
4018  RecordDecl *RD = dyn_cast<RecordDecl>(D);
4019  if (RD && RD->getDefinition()) {
4020  RD = RD->getDefinition();
4021  notify = true;
4022  }
4023 
4024  if (RD) {
4025  ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
4026  ObjCBoxableAttr(Attr.getRange(), S.Context,
4028  RD->addAttr(BoxableAttr);
4029  if (notify) {
4030  // we need to notify ASTReader/ASTWriter about
4031  // modification of existing declaration
4033  L->AddedAttributeToRecord(BoxableAttr, RD);
4034  }
4035  }
4036 }
4037 
4039  const AttributeList &Attr) {
4040  if (hasDeclarator(D)) return;
4041 
4042  S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4043  << Attr.getRange() << Attr.getName() << ExpectedVariable;
4044 }
4045 
4047  const AttributeList &Attr) {
4048  ValueDecl *vd = cast<ValueDecl>(D);
4049  QualType type = vd->getType();
4050 
4051  if (!type->isDependentType() &&
4052  !type->isObjCLifetimeType()) {
4053  S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
4054  << type;
4055  return;
4056  }
4057 
4058  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
4059 
4060  // If we have no lifetime yet, check the lifetime we're presumably
4061  // going to infer.
4062  if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
4063  lifetime = type->getObjCARCImplicitLifetime();
4064 
4065  switch (lifetime) {
4066  case Qualifiers::OCL_None:
4067  assert(type->isDependentType() &&
4068  "didn't infer lifetime for non-dependent type?");
4069  break;
4070 
4071  case Qualifiers::OCL_Weak: // meaningful
4072  case Qualifiers::OCL_Strong: // meaningful
4073  break;
4074 
4077  S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
4078  << (lifetime == Qualifiers::OCL_Autoreleasing);
4079  break;
4080  }
4081 
4082  D->addAttr(::new (S.Context)
4083  ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
4085 }
4086 
4087 //===----------------------------------------------------------------------===//
4088 // Microsoft specific attribute handlers.
4089 //===----------------------------------------------------------------------===//
4090 
4091 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4092  if (!S.LangOpts.CPlusPlus) {
4093  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
4094  << Attr.getName() << AttributeLangSupport::C;
4095  return;
4096  }
4097 
4098  if (!isa<CXXRecordDecl>(D)) {
4099  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4100  << Attr.getName() << ExpectedClass;
4101  return;
4102  }
4103 
4104  StringRef StrRef;
4105  SourceLocation LiteralLoc;
4106  if (!S.checkStringLiteralArgumentAttr(Attr, 0, StrRef, &LiteralLoc))
4107  return;
4108 
4109  // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
4110  // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
4111  if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
4112  StrRef = StrRef.drop_front().drop_back();
4113 
4114  // Validate GUID length.
4115  if (StrRef.size() != 36) {
4116  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
4117  return;
4118  }
4119 
4120  for (unsigned i = 0; i < 36; ++i) {
4121  if (i == 8 || i == 13 || i == 18 || i == 23) {
4122  if (StrRef[i] != '-') {
4123  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
4124  return;
4125  }
4126  } else if (!isHexDigit(StrRef[i])) {
4127  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
4128  return;
4129  }
4130  }
4131 
4132  D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context, StrRef,
4134 }
4135 
4137  if (!S.LangOpts.CPlusPlus) {
4138  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
4139  << Attr.getName() << AttributeLangSupport::C;
4140  return;
4141  }
4142  MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
4143  D, Attr.getRange(), /*BestCase=*/true,
4145  (MSInheritanceAttr::Spelling)Attr.getSemanticSpelling());
4146  if (IA)
4147  D->addAttr(IA);
4148 }
4149 
4151  const AttributeList &Attr) {
4152  VarDecl *VD = cast<VarDecl>(D);
4153  if (!S.Context.getTargetInfo().isTLSSupported()) {
4154  S.Diag(Attr.getLoc(), diag::err_thread_unsupported);
4155  return;
4156  }
4157  if (VD->getTSCSpec() != TSCS_unspecified) {
4158  S.Diag(Attr.getLoc(), diag::err_declspec_thread_on_thread_variable);
4159  return;
4160  }
4161  if (VD->hasLocalStorage()) {
4162  S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
4163  return;
4164  }
4165  VD->addAttr(::new (S.Context) ThreadAttr(
4166  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4167 }
4168 
4170  const AttributeList &Attr) {
4171  // Check the attribute arguments.
4172  if (Attr.getNumArgs() > 1) {
4173  S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
4174  << Attr.getName() << 1;
4175  return;
4176  }
4177 
4178  StringRef Str;
4179  SourceLocation ArgLoc;
4180 
4181  if (Attr.getNumArgs() == 0)
4182  Str = "";
4183  else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
4184  return;
4185 
4186  ARMInterruptAttr::InterruptType Kind;
4187  if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
4188  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
4189  << Attr.getName() << Str << ArgLoc;
4190  return;
4191  }
4192 
4193  unsigned Index = Attr.getAttributeSpellingListIndex();
4194  D->addAttr(::new (S.Context)
4195  ARMInterruptAttr(Attr.getLoc(), S.Context, Kind, Index));
4196 }
4197 
4199  const AttributeList &Attr) {
4200  if (!checkAttributeNumArgs(S, Attr, 1))
4201  return;
4202 
4203  if (!Attr.isArgExpr(0)) {
4204  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
4206  return;
4207  }
4208 
4209  // FIXME: Check for decl - it should be void ()(void).
4210 
4211  Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4212  llvm::APSInt NumParams(32);
4213  if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
4214  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
4216  << NumParamsExpr->getSourceRange();
4217  return;
4218  }
4219 
4220  unsigned Num = NumParams.getLimitedValue(255);
4221  if ((Num & 1) || Num > 30) {
4222  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
4223  << Attr.getName() << (int)NumParams.getSExtValue()
4224  << NumParamsExpr->getSourceRange();
4225  return;
4226  }
4227 
4228  D->addAttr(::new (S.Context)
4229  MSP430InterruptAttr(Attr.getLoc(), S.Context, Num,
4231  D->addAttr(UsedAttr::CreateImplicit(S.Context));
4232 }
4233 
4234 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4235  // Dispatch the interrupt attribute based on the current target.
4236  if (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::msp430)
4237  handleMSP430InterruptAttr(S, D, Attr);
4238  else
4239  handleARMInterruptAttr(S, D, Attr);
4240 }
4241 
4243  const AttributeList &Attr) {
4244  uint32_t NumRegs;
4245  Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4246  if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4247  return;
4248 
4249  D->addAttr(::new (S.Context)
4250  AMDGPUNumVGPRAttr(Attr.getLoc(), S.Context,
4251  NumRegs,
4253 }
4254 
4256  const AttributeList &Attr) {
4257  uint32_t NumRegs;
4258  Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4259  if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4260  return;
4261 
4262  D->addAttr(::new (S.Context)
4263  AMDGPUNumSGPRAttr(Attr.getLoc(), S.Context,
4264  NumRegs,
4266 }
4267 
4269  const AttributeList& Attr) {
4270  // If we try to apply it to a function pointer, don't warn, but don't
4271  // do anything, either. It doesn't matter anyway, because there's nothing
4272  // special about calling a force_align_arg_pointer function.
4273  ValueDecl *VD = dyn_cast<ValueDecl>(D);
4274  if (VD && VD->getType()->isFunctionPointerType())
4275  return;
4276  // Also don't warn on function pointer typedefs.
4277  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
4278  if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
4280  return;
4281  // Attribute can only be applied to function types.
4282  if (!isa<FunctionDecl>(D)) {
4283  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4284  << Attr.getName() << /* function */0;
4285  return;
4286  }
4287 
4288  D->addAttr(::new (S.Context)
4289  X86ForceAlignArgPointerAttr(Attr.getRange(), S.Context,
4291 }
4292 
4293 DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
4294  unsigned AttrSpellingListIndex) {
4295  if (D->hasAttr<DLLExportAttr>()) {
4296  Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
4297  return nullptr;
4298  }
4299 
4300  if (D->hasAttr<DLLImportAttr>())
4301  return nullptr;
4302 
4303  return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
4304 }
4305 
4306 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
4307  unsigned AttrSpellingListIndex) {
4308  if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
4309  Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
4310  D->dropAttr<DLLImportAttr>();
4311  }
4312 
4313  if (D->hasAttr<DLLExportAttr>())
4314  return nullptr;
4315 
4316  return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
4317 }
4318 
4319 static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A) {
4320  if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
4322  S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
4323  << A.getName();
4324  return;
4325  }
4326 
4327  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
4328  if (FD->isInlined() && A.getKind() == AttributeList::AT_DLLImport &&
4330  // MinGW doesn't allow dllimport on inline functions.
4331  S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
4332  << A.getName();
4333  return;
4334  }
4335  }
4336 
4337  unsigned Index = A.getAttributeSpellingListIndex();
4338  Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
4339  ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
4340  : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
4341  if (NewAttr)
4342  D->addAttr(NewAttr);
4343 }
4344 
4345 MSInheritanceAttr *
4347  unsigned AttrSpellingListIndex,
4348  MSInheritanceAttr::Spelling SemanticSpelling) {
4349  if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
4350  if (IA->getSemanticSpelling() == SemanticSpelling)
4351  return nullptr;
4352  Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
4353  << 1 /*previous declaration*/;
4354  Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
4355  D->dropAttr<MSInheritanceAttr>();
4356  }
4357 
4358  CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
4359  if (RD->hasDefinition()) {
4360  if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
4361  SemanticSpelling)) {
4362  return nullptr;
4363  }
4364  } else {
4365  if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
4366  Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
4367  << 1 /*partial specialization*/;
4368  return nullptr;
4369  }
4370  if (RD->getDescribedClassTemplate()) {
4371  Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
4372  << 0 /*primary template*/;
4373  return nullptr;
4374  }
4375  }
4376 
4377  return ::new (Context)
4378  MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
4379 }
4380 
4381 static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4382  // The capability attributes take a single string parameter for the name of
4383  // the capability they represent. The lockable attribute does not take any
4384  // parameters. However, semantically, both attributes represent the same
4385  // concept, and so they use the same semantic attribute. Eventually, the
4386  // lockable attribute will be removed.
4387  //
4388  // For backward compatibility, any capability which has no specified string
4389  // literal will be considered a "mutex."
4390  StringRef N("mutex");
4391  SourceLocation LiteralLoc;
4392  if (Attr.getKind() == AttributeList::AT_Capability &&
4393  !S.checkStringLiteralArgumentAttr(Attr, 0, N, &LiteralLoc))
4394  return;
4395 
4396  // Currently, there are only two names allowed for a capability: role and
4397  // mutex (case insensitive). Diagnose other capability names.
4398  if (!N.equals_lower("mutex") && !N.equals_lower("role"))
4399  S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
4400 
4401  D->addAttr(::new (S.Context) CapabilityAttr(Attr.getRange(), S.Context, N,
4403 }
4404 
4406  const AttributeList &Attr) {
4407  D->addAttr(::new (S.Context) AssertCapabilityAttr(Attr.getRange(), S.Context,
4408  Attr.getArgAsExpr(0),
4410 }
4411 
4413  const AttributeList &Attr) {
4414  SmallVector<Expr*, 1> Args;
4415  if (!checkLockFunAttrCommon(S, D, Attr, Args))
4416  return;
4417 
4418  D->addAttr(::new (S.Context) AcquireCapabilityAttr(Attr.getRange(),
4419  S.Context,
4420  Args.data(), Args.size(),
4422 }
4423 
4425  const AttributeList &Attr) {
4426  SmallVector<Expr*, 2> Args;
4427  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
4428  return;
4429 
4430  D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(Attr.getRange(),
4431  S.Context,
4432  Attr.getArgAsExpr(0),
4433  Args.data(),
4434  Args.size(),
4436 }
4437 
4439  const AttributeList &Attr) {
4440  // Check that all arguments are lockable objects.
4442  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, true);
4443 
4444  D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
4445  Attr.getRange(), S.Context, Args.data(), Args.size(),
4447 }
4448 
4450  const AttributeList &Attr) {
4451  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4452  return;
4453 
4454  // check that all arguments are lockable objects
4455  SmallVector<Expr*, 1> Args;
4456  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
4457  if (Args.empty())
4458  return;
4459 
4460  RequiresCapabilityAttr *RCA = ::new (S.Context)
4461  RequiresCapabilityAttr(Attr.getRange(), S.Context, Args.data(),
4462  Args.size(), Attr.getAttributeSpellingListIndex());
4463 
4464  D->addAttr(RCA);
4465 }
4466 
4467 static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4468  if (auto *NSD = dyn_cast<NamespaceDecl>(D)) {
4469  if (NSD->isAnonymousNamespace()) {
4470  S.Diag(Attr.getLoc(), diag::warn_deprecated_anonymous_namespace);
4471  // Do not want to attach the attribute to the namespace because that will
4472  // cause confusing diagnostic reports for uses of declarations within the
4473  // namespace.
4474  return;
4475  }
4476  }
4477 
4478  if (!S.getLangOpts().CPlusPlus14)
4479  if (Attr.isCXX11Attribute() &&
4480  !(Attr.hasScope() && Attr.getScopeName()->isStr("gnu")))
4481  S.Diag(Attr.getLoc(), diag::ext_deprecated_attr_is_a_cxx14_extension);
4482 
4483  handleAttrWithMessage<DeprecatedAttr>(S, D, Attr);
4484 }
4485 
4486 static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4487  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4488  return;
4489 
4490  std::vector<std::string> Sanitizers;
4491 
4492  for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
4493  StringRef SanitizerName;
4494  SourceLocation LiteralLoc;
4495 
4496  if (!S.checkStringLiteralArgumentAttr(Attr, I, SanitizerName, &LiteralLoc))
4497  return;
4498 
4499  if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 0)
4500  S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
4501 
4502  Sanitizers.push_back(SanitizerName);
4503  }
4504 
4505  D->addAttr(::new (S.Context) NoSanitizeAttr(
4506  Attr.getRange(), S.Context, Sanitizers.data(), Sanitizers.size(),
4508 }
4509 
4511  const AttributeList &Attr) {
4512  std::string SanitizerName =
4513  llvm::StringSwitch<std::string>(Attr.getName()->getName())
4514  .Case("no_address_safety_analysis", "address")
4515  .Case("no_sanitize_address", "address")
4516  .Case("no_sanitize_thread", "thread")
4517  .Case("no_sanitize_memory", "memory");
4518  D->addAttr(::new (S.Context)
4519  NoSanitizeAttr(Attr.getRange(), S.Context, &SanitizerName, 1,
4521 }
4522 
4523 /// Handles semantic checking for features that are common to all attributes,
4524 /// such as checking whether a parameter was properly specified, or the correct
4525 /// number of arguments were passed, etc.
4526 static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D,
4527  const AttributeList &Attr) {
4528  // Several attributes carry different semantics than the parsing requires, so
4529  // those are opted out of the common handling.
4530  //
4531  // We also bail on unknown and ignored attributes because those are handled
4532  // as part of the target-specific handling logic.
4533  if (Attr.hasCustomParsing() ||
4535  return false;
4536 
4537  // Check whether the attribute requires specific language extensions to be
4538  // enabled.
4539  if (!Attr.diagnoseLangOpts(S))
4540  return true;
4541 
4542  if (Attr.getMinArgs() == Attr.getMaxArgs()) {
4543  // If there are no optional arguments, then checking for the argument count
4544  // is trivial.
4545  if (!checkAttributeNumArgs(S, Attr, Attr.getMinArgs()))
4546  return true;
4547  } else {
4548  // There are optional arguments, so checking is slightly more involved.
4549  if (Attr.getMinArgs() &&
4550  !checkAttributeAtLeastNumArgs(S, Attr, Attr.getMinArgs()))
4551  return true;
4552  else if (!Attr.hasVariadicArg() && Attr.getMaxArgs() &&
4553  !checkAttributeAtMostNumArgs(S, Attr, Attr.getMaxArgs()))
4554  return true;
4555  }
4556 
4557  // Check whether the attribute appertains to the given subject.
4558  if (!Attr.diagnoseAppertainsTo(S, D))
4559  return true;
4560 
4561  return false;
4562 }
4563 
4564 //===----------------------------------------------------------------------===//
4565 // Top Level Sema Entry Points
4566 //===----------------------------------------------------------------------===//
4567 
4568 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
4569 /// the attribute applies to decls. If the attribute is a type attribute, just
4570 /// silently ignore it if a GNU attribute.
4571 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
4572  const AttributeList &Attr,
4573  bool IncludeCXX11Attributes) {
4574  if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
4575  return;
4576 
4577  // Ignore C++11 attributes on declarator chunks: they appertain to the type
4578  // instead.
4579  if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
4580  return;
4581 
4582  // Unknown attributes are automatically warned on. Target-specific attributes
4583  // which do not apply to the current target architecture are treated as
4584  // though they were unknown attributes.
4585  if (Attr.getKind() == AttributeList::UnknownAttribute ||
4587  S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute()
4588  ? diag::warn_unhandled_ms_attribute_ignored
4589  : diag::warn_unknown_attribute_ignored)
4590  << Attr.getName();
4591  return;
4592  }
4593 
4594  if (handleCommonAttributeFeatures(S, scope, D, Attr))
4595  return;
4596 
4597  switch (Attr.getKind()) {
4598  default:
4599  // Type attributes are handled elsewhere; silently move on.
4600  assert(Attr.isTypeAttr() && "Non-type attribute not handled");
4601  break;
4602  case AttributeList::AT_Interrupt:
4603  handleInterruptAttr(S, D, Attr);
4604  break;
4605  case AttributeList::AT_X86ForceAlignArgPointer:
4607  break;
4608  case AttributeList::AT_DLLExport:
4609  case AttributeList::AT_DLLImport:
4610  handleDLLAttr(S, D, Attr);
4611  break;
4612  case AttributeList::AT_Mips16:
4613  handleSimpleAttribute<Mips16Attr>(S, D, Attr);
4614  break;
4615  case AttributeList::AT_NoMips16:
4616  handleSimpleAttribute<NoMips16Attr>(S, D, Attr);
4617  break;
4618  case AttributeList::AT_AMDGPUNumVGPR:
4619  handleAMDGPUNumVGPRAttr(S, D, Attr);
4620  break;
4621  case AttributeList::AT_AMDGPUNumSGPR:
4622  handleAMDGPUNumSGPRAttr(S, D, Attr);
4623  break;
4624  case AttributeList::AT_IBAction:
4625  handleSimpleAttribute<IBActionAttr>(S, D, Attr);
4626  break;
4627  case AttributeList::AT_IBOutlet:
4628  handleIBOutlet(S, D, Attr);
4629  break;
4630  case AttributeList::AT_IBOutletCollection:
4631  handleIBOutletCollection(S, D, Attr);
4632  break;
4633  case AttributeList::AT_Alias:
4634  handleAliasAttr(S, D, Attr);
4635  break;
4636  case AttributeList::AT_Aligned:
4637  handleAlignedAttr(S, D, Attr);
4638  break;
4639  case AttributeList::AT_AlignValue:
4640  handleAlignValueAttr(S, D, Attr);
4641  break;
4642  case AttributeList::AT_AlwaysInline:
4643  handleAlwaysInlineAttr(S, D, Attr);
4644  break;
4645  case AttributeList::AT_AnalyzerNoReturn:
4646  handleAnalyzerNoReturnAttr(S, D, Attr);
4647  break;
4648  case AttributeList::AT_TLSModel:
4649  handleTLSModelAttr(S, D, Attr);
4650  break;
4651  case AttributeList::AT_Annotate:
4652  handleAnnotateAttr(S, D, Attr);
4653  break;
4654  case AttributeList::AT_Availability:
4655  handleAvailabilityAttr(S, D, Attr);
4656  break;
4657  case AttributeList::AT_CarriesDependency:
4658  handleDependencyAttr(S, scope, D, Attr);
4659  break;
4660  case AttributeList::AT_Common:
4661  handleCommonAttr(S, D, Attr);
4662  break;
4663  case AttributeList::AT_CUDAConstant:
4664  handleSimpleAttribute<CUDAConstantAttr>(S, D, Attr);
4665  break;
4666  case AttributeList::AT_Constructor:
4667  handleConstructorAttr(S, D, Attr);
4668  break;
4669  case AttributeList::AT_CXX11NoReturn:
4670  handleSimpleAttribute<CXX11NoReturnAttr>(S, D, Attr);
4671  break;
4672  case AttributeList::AT_Deprecated:
4673  handleDeprecatedAttr(S, D, Attr);
4674  break;
4675  case AttributeList::AT_Destructor:
4676  handleDestructorAttr(S, D, Attr);
4677  break;
4678  case AttributeList::AT_EnableIf:
4679  handleEnableIfAttr(S, D, Attr);
4680  break;
4681  case AttributeList::AT_ExtVectorType:
4682  handleExtVectorTypeAttr(S, scope, D, Attr);
4683  break;
4684  case AttributeList::AT_MinSize:
4685  handleMinSizeAttr(S, D, Attr);
4686  break;
4687  case AttributeList::AT_OptimizeNone:
4688  handleOptimizeNoneAttr(S, D, Attr);
4689  break;
4690  case AttributeList::AT_FlagEnum:
4691  handleSimpleAttribute<FlagEnumAttr>(S, D, Attr);
4692  break;
4693  case AttributeList::AT_Flatten:
4694  handleSimpleAttribute<FlattenAttr>(S, D, Attr);
4695  break;
4696  case AttributeList::AT_Format:
4697  handleFormatAttr(S, D, Attr);
4698  break;
4699  case AttributeList::AT_FormatArg:
4700  handleFormatArgAttr(S, D, Attr);
4701  break;
4702  case AttributeList::AT_CUDAGlobal:
4703  handleGlobalAttr(S, D, Attr);
4704  break;
4705  case AttributeList::AT_CUDADevice:
4706  handleSimpleAttribute<CUDADeviceAttr>(S, D, Attr);
4707  break;
4708  case AttributeList::AT_CUDAHost:
4709  handleSimpleAttribute<CUDAHostAttr>(S, D, Attr);
4710  break;
4711  case AttributeList::AT_GNUInline:
4712  handleGNUInlineAttr(S, D, Attr);
4713  break;
4714  case AttributeList::AT_CUDALaunchBounds:
4715  handleLaunchBoundsAttr(S, D, Attr);
4716  break;
4717  case AttributeList::AT_Restrict:
4718  handleRestrictAttr(S, D, Attr);
4719  break;
4720  case AttributeList::AT_MayAlias:
4721  handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
4722  break;
4723  case AttributeList::AT_Mode:
4724  handleModeAttr(S, D, Attr);
4725  break;
4726  case AttributeList::AT_NoCommon:
4727  handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
4728  break;
4729  case AttributeList::AT_NoSplitStack:
4730  handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
4731  break;
4732  case AttributeList::AT_NonNull:
4733  if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D))
4734  handleNonNullAttrParameter(S, PVD, Attr);
4735  else
4736  handleNonNullAttr(S, D, Attr);
4737  break;
4738  case AttributeList::AT_ReturnsNonNull:
4739  handleReturnsNonNullAttr(S, D, Attr);
4740  break;
4741  case AttributeList::AT_AssumeAligned:
4742  handleAssumeAlignedAttr(S, D, Attr);
4743  break;
4744  case AttributeList::AT_Overloadable:
4745  handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
4746  break;
4747  case AttributeList::AT_Ownership:
4748  handleOwnershipAttr(S, D, Attr);
4749  break;
4750  case AttributeList::AT_Cold:
4751  handleColdAttr(S, D, Attr);
4752  break;
4753  case AttributeList::AT_Hot:
4754  handleHotAttr(S, D, Attr);
4755  break;
4756  case AttributeList::AT_Naked:
4757  handleSimpleAttribute<NakedAttr>(S, D, Attr);
4758  break;
4759  case AttributeList::AT_NoReturn:
4760  handleNoReturnAttr(S, D, Attr);
4761  break;
4762  case AttributeList::AT_NoThrow:
4763  handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
4764  break;
4765  case AttributeList::AT_CUDAShared:
4766  handleSimpleAttribute<CUDASharedAttr>(S, D, Attr);
4767  break;
4768  case AttributeList::AT_VecReturn:
4769  handleVecReturnAttr(S, D, Attr);
4770  break;
4771 
4772  case AttributeList::AT_ObjCOwnership:
4773  handleObjCOwnershipAttr(S, D, Attr);
4774  break;
4775  case AttributeList::AT_ObjCPreciseLifetime:
4776  handleObjCPreciseLifetimeAttr(S, D, Attr);
4777  break;
4778 
4779  case AttributeList::AT_ObjCReturnsInnerPointer:
4781  break;
4782 
4783  case AttributeList::AT_ObjCRequiresSuper:
4784  handleObjCRequiresSuperAttr(S, D, Attr);
4785  break;
4786 
4787  case AttributeList::AT_ObjCBridge:
4788  handleObjCBridgeAttr(S, scope, D, Attr);
4789  break;
4790 
4791  case AttributeList::AT_ObjCBridgeMutable:
4792  handleObjCBridgeMutableAttr(S, scope, D, Attr);
4793  break;
4794 
4795  case AttributeList::AT_ObjCBridgeRelated:
4796  handleObjCBridgeRelatedAttr(S, scope, D, Attr);
4797  break;
4798 
4799  case AttributeList::AT_ObjCDesignatedInitializer:
4800  handleObjCDesignatedInitializer(S, D, Attr);
4801  break;
4802 
4803  case AttributeList::AT_ObjCRuntimeName:
4804  handleObjCRuntimeName(S, D, Attr);
4805  break;
4806 
4807  case AttributeList::AT_ObjCBoxable:
4808  handleObjCBoxable(S, D, Attr);
4809  break;
4810 
4811  case AttributeList::AT_CFAuditedTransfer:
4812  handleCFAuditedTransferAttr(S, D, Attr);
4813  break;
4814  case AttributeList::AT_CFUnknownTransfer:
4815  handleCFUnknownTransferAttr(S, D, Attr);
4816  break;
4817 
4818  case AttributeList::AT_CFConsumed:
4819  case AttributeList::AT_NSConsumed:
4820  handleNSConsumedAttr(S, D, Attr);
4821  break;
4822  case AttributeList::AT_NSConsumesSelf:
4823  handleSimpleAttribute<NSConsumesSelfAttr>(S, D, Attr);
4824  break;
4825 
4826  case AttributeList::AT_NSReturnsAutoreleased:
4827  case AttributeList::AT_NSReturnsNotRetained:
4828  case AttributeList::AT_CFReturnsNotRetained:
4829  case AttributeList::AT_NSReturnsRetained:
4830  case AttributeList::AT_CFReturnsRetained:
4831  handleNSReturnsRetainedAttr(S, D, Attr);
4832  break;
4833  case AttributeList::AT_WorkGroupSizeHint:
4834  handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, Attr);
4835  break;
4836  case AttributeList::AT_ReqdWorkGroupSize:
4837  handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, Attr);
4838  break;
4839  case AttributeList::AT_VecTypeHint:
4840  handleVecTypeHint(S, D, Attr);
4841  break;
4842 
4843  case AttributeList::AT_InitPriority:
4844  handleInitPriorityAttr(S, D, Attr);
4845  break;
4846 
4847  case AttributeList::AT_Packed:
4848  handlePackedAttr(S, D, Attr);
4849  break;
4850  case AttributeList::AT_Section:
4851  handleSectionAttr(S, D, Attr);
4852  break;
4853  case AttributeList::AT_Target:
4854  handleTargetAttr(S, D, Attr);
4855  break;
4856  case AttributeList::AT_Unavailable:
4857  handleAttrWithMessage<UnavailableAttr>(S, D, Attr);
4858  break;
4859  case AttributeList::AT_ArcWeakrefUnavailable:
4860  handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, Attr);
4861  break;
4862  case AttributeList::AT_ObjCRootClass:
4863  handleSimpleAttribute<ObjCRootClassAttr>(S, D, Attr);
4864  break;
4865  case AttributeList::AT_ObjCExplicitProtocolImpl:
4866  handleObjCSuppresProtocolAttr(S, D, Attr);
4867  break;
4868  case AttributeList::AT_ObjCRequiresPropertyDefs:
4869  handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, Attr);
4870  break;
4871  case AttributeList::AT_Unused:
4872  handleSimpleAttribute<UnusedAttr>(S, D, Attr);
4873  break;
4874  case AttributeList::AT_ReturnsTwice:
4875  handleSimpleAttribute<ReturnsTwiceAttr>(S, D, Attr);
4876  break;
4877  case AttributeList::AT_Used:
4878  handleUsedAttr(S, D, Attr);
4879  break;
4880  case AttributeList::AT_Visibility:
4881  handleVisibilityAttr(S, D, Attr, false);
4882  break;
4883  case AttributeList::AT_TypeVisibility:
4884  handleVisibilityAttr(S, D, Attr, true);
4885  break;
4886  case AttributeList::AT_WarnUnused:
4887  handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
4888  break;
4889  case AttributeList::AT_WarnUnusedResult:
4890  handleWarnUnusedResult(S, D, Attr);
4891  break;
4892  case AttributeList::AT_Weak:
4893  handleSimpleAttribute<WeakAttr>(S, D, Attr);
4894  break;
4895  case AttributeList::AT_WeakRef:
4896  handleWeakRefAttr(S, D, Attr);
4897  break;
4898  case AttributeList::AT_WeakImport:
4899  handleWeakImportAttr(S, D, Attr);
4900  break;
4901  case AttributeList::AT_TransparentUnion:
4902  handleTransparentUnionAttr(S, D, Attr);
4903  break;
4904  case AttributeList::AT_ObjCException:
4905  handleSimpleAttribute<ObjCExceptionAttr>(S, D, Attr);
4906  break;
4907  case AttributeList::AT_ObjCMethodFamily:
4908  handleObjCMethodFamilyAttr(S, D, Attr);
4909  break;
4910  case AttributeList::AT_ObjCNSObject:
4911  handleObjCNSObject(S, D, Attr);
4912  break;
4913  case AttributeList::AT_ObjCIndependentClass:
4914  handleObjCIndependentClass(S, D, Attr);
4915  break;
4916  case AttributeList::AT_Blocks:
4917  handleBlocksAttr(S, D, Attr);
4918  break;
4919  case AttributeList::AT_Sentinel:
4920  handleSentinelAttr(S, D, Attr);
4921  break;
4922  case AttributeList::AT_Const:
4923  handleSimpleAttribute<ConstAttr>(S, D, Attr);
4924  break;
4925  case AttributeList::AT_Pure:
4926  handleSimpleAttribute<PureAttr>(S, D, Attr);
4927  break;
4928  case AttributeList::AT_Cleanup:
4929  handleCleanupAttr(S, D, Attr);
4930  break;
4931  case AttributeList::AT_NoDebug:
4932  handleNoDebugAttr(S, D, Attr);
4933  break;
4934  case AttributeList::AT_NoDuplicate:
4935  handleSimpleAttribute<NoDuplicateAttr>(S, D, Attr);
4936  break;
4937  case AttributeList::AT_NoInline:
4938  handleSimpleAttribute<NoInlineAttr>(S, D, Attr);
4939  break;
4940  case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg.
4941  handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, Attr);
4942  break;
4943  case AttributeList::AT_StdCall:
4944  case AttributeList::AT_CDecl:
4945  case AttributeList::AT_FastCall:
4946  case AttributeList::AT_ThisCall:
4947  case AttributeList::AT_Pascal:
4948  case AttributeList::AT_VectorCall:
4949  case AttributeList::AT_MSABI:
4950  case AttributeList::AT_SysVABI:
4951  case AttributeList::AT_Pcs:
4952  case AttributeList::AT_IntelOclBicc:
4953  handleCallConvAttr(S, D, Attr);
4954  break;
4955  case AttributeList::AT_OpenCLKernel:
4956  handleSimpleAttribute<OpenCLKernelAttr>(S, D, Attr);
4957  break;
4958  case AttributeList::AT_OpenCLImageAccess:
4959  handleSimpleAttribute<OpenCLImageAccessAttr>(S, D, Attr);
4960  break;
4961 
4962  // Microsoft attributes:
4963  case AttributeList::AT_MSNoVTable:
4964  handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
4965  break;
4966  case AttributeList::AT_MSStruct:
4967  handleSimpleAttribute<MSStructAttr>(S, D, Attr);
4968  break;
4969  case AttributeList::AT_Uuid:
4970  handleUuidAttr(S, D, Attr);
4971  break;
4972  case AttributeList::AT_MSInheritance:
4973  handleMSInheritanceAttr(S, D, Attr);
4974  break;
4975  case AttributeList::AT_SelectAny:
4976  handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
4977  break;
4978  case AttributeList::AT_Thread:
4979  handleDeclspecThreadAttr(S, D, Attr);
4980  break;
4981 
4982  // Thread safety attributes:
4983  case AttributeList::AT_AssertExclusiveLock:
4984  handleAssertExclusiveLockAttr(S, D, Attr);
4985  break;
4986  case AttributeList::AT_AssertSharedLock:
4987  handleAssertSharedLockAttr(S, D, Attr);
4988  break;
4989  case AttributeList::AT_GuardedVar:
4990  handleSimpleAttribute<GuardedVarAttr>(S, D, Attr);
4991  break;
4992  case AttributeList::AT_PtGuardedVar:
4993  handlePtGuardedVarAttr(S, D, Attr);
4994  break;
4995  case AttributeList::AT_ScopedLockable:
4996  handleSimpleAttribute<ScopedLockableAttr>(S, D, Attr);
4997  break;
4998  case AttributeList::AT_NoSanitize:
4999  handleNoSanitizeAttr(S, D, Attr);
5000  break;
5001  case AttributeList::AT_NoSanitizeSpecific:
5002  handleNoSanitizeSpecificAttr(S, D, Attr);
5003  break;
5004  case AttributeList::AT_NoThreadSafetyAnalysis:
5005  handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, Attr);
5006  break;
5007  case AttributeList::AT_GuardedBy:
5008  handleGuardedByAttr(S, D, Attr);
5009  break;
5010  case AttributeList::AT_PtGuardedBy:
5011  handlePtGuardedByAttr(S, D, Attr);
5012  break;
5013  case AttributeList::AT_ExclusiveTrylockFunction:
5015  break;
5016  case AttributeList::AT_LockReturned:
5017  handleLockReturnedAttr(S, D, Attr);
5018  break;
5019  case AttributeList::AT_LocksExcluded:
5020  handleLocksExcludedAttr(S, D, Attr);
5021  break;
5022  case AttributeList::AT_SharedTrylockFunction:
5023  handleSharedTrylockFunctionAttr(S, D, Attr);
5024  break;
5025  case AttributeList::AT_AcquiredBefore:
5026  handleAcquiredBeforeAttr(S, D, Attr);
5027  break;
5028  case AttributeList::AT_AcquiredAfter:
5029  handleAcquiredAfterAttr(S, D, Attr);
5030  break;
5031 
5032  // Capability analysis attributes.
5033  case AttributeList::AT_Capability:
5034  case AttributeList::AT_Lockable:
5035  handleCapabilityAttr(S, D, Attr);
5036  break;
5037  case AttributeList::AT_RequiresCapability:
5038  handleRequiresCapabilityAttr(S, D, Attr);
5039  break;
5040 
5041  case AttributeList::AT_AssertCapability:
5042  handleAssertCapabilityAttr(S, D, Attr);
5043  break;
5044  case AttributeList::AT_AcquireCapability:
5045  handleAcquireCapabilityAttr(S, D, Attr);
5046  break;
5047  case AttributeList::AT_ReleaseCapability:
5048  handleReleaseCapabilityAttr(S, D, Attr);
5049  break;
5050  case AttributeList::AT_TryAcquireCapability:
5051  handleTryAcquireCapabilityAttr(S, D, Attr);
5052  break;
5053 
5054  // Consumed analysis attributes.
5055  case AttributeList::AT_Consumable:
5056  handleConsumableAttr(S, D, Attr);
5057  break;
5058  case AttributeList::AT_ConsumableAutoCast:
5059  handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, Attr);
5060  break;
5061  case AttributeList::AT_ConsumableSetOnRead:
5062  handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, Attr);
5063  break;
5064  case AttributeList::AT_CallableWhen:
5065  handleCallableWhenAttr(S, D, Attr);
5066  break;
5067  case AttributeList::AT_ParamTypestate:
5068  handleParamTypestateAttr(S, D, Attr);
5069  break;
5070  case AttributeList::AT_ReturnTypestate:
5071  handleReturnTypestateAttr(S, D, Attr);
5072  break;
5073  case AttributeList::AT_SetTypestate:
5074  handleSetTypestateAttr(S, D, Attr);
5075  break;
5076  case AttributeList::AT_TestTypestate:
5077  handleTestTypestateAttr(S, D, Attr);
5078  break;
5079 
5080  // Type safety attributes.
5081  case AttributeList::AT_ArgumentWithTypeTag:
5082  handleArgumentWithTypeTagAttr(S, D, Attr);
5083  break;
5084  case AttributeList::AT_TypeTagForDatatype:
5085  handleTypeTagForDatatypeAttr(S, D, Attr);
5086  break;
5087  }
5088 }
5089 
5090 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
5091 /// attribute list to the specified decl, ignoring any type attributes.
5093  const AttributeList *AttrList,
5094  bool IncludeCXX11Attributes) {
5095  for (const AttributeList* l = AttrList; l; l = l->getNext())
5096  ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes);
5097 
5098  // FIXME: We should be able to handle these cases in TableGen.
5099  // GCC accepts
5100  // static int a9 __attribute__((weakref));
5101  // but that looks really pointless. We reject it.
5102  if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
5103  Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias)
5104  << cast<NamedDecl>(D);
5105  D->dropAttr<WeakRefAttr>();
5106  return;
5107  }
5108 
5109  // FIXME: We should be able to handle this in TableGen as well. It would be
5110  // good to have a way to specify "these attributes must appear as a group",
5111  // for these. Additionally, it would be good to have a way to specify "these
5112  // attribute must never appear as a group" for attributes like cold and hot.
5113  if (!D->hasAttr<OpenCLKernelAttr>()) {
5114  // These attributes cannot be applied to a non-kernel function.
5115  if (Attr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
5116  // FIXME: This emits a different error message than
5117  // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
5118  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
5119  D->setInvalidDecl();
5120  } else if (Attr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
5121  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
5122  D->setInvalidDecl();
5123  } else if (Attr *A = D->getAttr<VecTypeHintAttr>()) {
5124  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
5125  D->setInvalidDecl();
5126  } else if (Attr *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
5127  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5128  << A << ExpectedKernelFunction;
5129  D->setInvalidDecl();
5130  } else if (Attr *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
5131  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5132  << A << ExpectedKernelFunction;
5133  D->setInvalidDecl();
5134  }
5135  }
5136 }
5137 
5138 // Annotation attributes are the only attributes allowed after an access
5139 // specifier.
5141  const AttributeList *AttrList) {
5142  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
5143  if (l->getKind() == AttributeList::AT_Annotate) {
5144  ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute());
5145  } else {
5146  Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
5147  return true;
5148  }
5149  }
5150 
5151  return false;
5152 }
5153 
5154 /// checkUnusedDeclAttributes - Check a list of attributes to see if it
5155 /// contains any decl attributes that we should warn about.
5157  for ( ; A; A = A->getNext()) {
5158  // Only warn if the attribute is an unignored, non-type attribute.
5159  if (A->isUsedAsTypeAttr() || A->isInvalid()) continue;
5160  if (A->getKind() == AttributeList::IgnoredAttribute) continue;
5161 
5163  S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
5164  << A->getName() << A->getRange();
5165  } else {
5166  S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
5167  << A->getName() << A->getRange();
5168  }
5169  }
5170 }
5171 
5172 /// checkUnusedDeclAttributes - Given a declarator which is not being
5173 /// used to build a declaration, complain about any decl attributes
5174 /// which might be lying around on it.
5178  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
5180 }
5181 
5182 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
5183 /// \#pragma weak needs a non-definition decl and source may not have one.
5185  SourceLocation Loc) {
5186  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
5187  NamedDecl *NewD = nullptr;
5188  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
5189  FunctionDecl *NewFD;
5190  // FIXME: Missing call to CheckFunctionDeclaration().
5191  // FIXME: Mangling?
5192  // FIXME: Is the qualifier info correct?
5193  // FIXME: Is the DeclContext correct?
5194  NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
5195  Loc, Loc, DeclarationName(II),
5196  FD->getType(), FD->getTypeSourceInfo(),
5197  SC_None, false/*isInlineSpecified*/,
5198  FD->hasPrototype(),
5199  false/*isConstexprSpecified*/);
5200  NewD = NewFD;
5201 
5202  if (FD->getQualifier())
5203  NewFD->setQualifierInfo(FD->getQualifierLoc());
5204 
5205  // Fake up parameter variables; they are declared as if this were
5206  // a typedef.
5207  QualType FDTy = FD->getType();
5208  if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
5210  for (const auto &AI : FT->param_types()) {
5211  ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI);
5212  Param->setScopeInfo(0, Params.size());
5213  Params.push_back(Param);
5214  }
5215  NewFD->setParams(Params);
5216  }
5217  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
5218  NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
5219  VD->getInnerLocStart(), VD->getLocation(), II,
5220  VD->getType(), VD->getTypeSourceInfo(),
5221  VD->getStorageClass());
5222  if (VD->getQualifier()) {
5223  VarDecl *NewVD = cast<VarDecl>(NewD);
5224  NewVD->setQualifierInfo(VD->getQualifierLoc());
5225  }
5226  }
5227  return NewD;
5228 }
5229 
5230 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
5231 /// applied to it, possibly with an alias.
5233  if (W.getUsed()) return; // only do this once
5234  W.setUsed(true);
5235  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
5236  IdentifierInfo *NDId = ND->getIdentifier();
5237  NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
5238  NewD->addAttr(AliasAttr::CreateImplicit(Context, NDId->getName(),
5239  W.getLocation()));
5240  NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
5241  WeakTopLevelDecl.push_back(NewD);
5242  // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
5243  // to insert Decl at TU scope, sorry.
5244  DeclContext *SavedContext = CurContext;
5246  NewD->setDeclContext(CurContext);
5248  PushOnScopeChains(NewD, S);
5249  CurContext = SavedContext;
5250  } else { // just add weak to existing
5251  ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
5252  }
5253 }
5254 
5256  // It's valid to "forward-declare" #pragma weak, in which case we
5257  // have to do this.
5259  if (!WeakUndeclaredIdentifiers.empty()) {
5260  NamedDecl *ND = nullptr;
5261  if (VarDecl *VD = dyn_cast<VarDecl>(D))
5262  if (VD->isExternC())
5263  ND = VD;
5264  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
5265  if (FD->isExternC())
5266  ND = FD;
5267  if (ND) {
5268  if (IdentifierInfo *Id = ND->getIdentifier()) {
5269  auto I = WeakUndeclaredIdentifiers.find(Id);
5270  if (I != WeakUndeclaredIdentifiers.end()) {
5271  WeakInfo W = I->second;
5272  DeclApplyPragmaWeak(S, ND, W);
5273  WeakUndeclaredIdentifiers[Id] = W;
5274  }
5275  }
5276  }
5277  }
5278 }
5279 
5280 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
5281 /// it, apply them to D. This is a bit tricky because PD can have attributes
5282 /// specified in many different places, and we need to find and apply them all.
5284  // Apply decl attributes from the DeclSpec if present.
5285  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
5286  ProcessDeclAttributeList(S, D, Attrs);
5287 
5288  // Walk the declarator structure, applying decl attributes that were in a type
5289  // position to the decl itself. This handles cases like:
5290  // int *__attr__(x)** D;
5291  // when X is a decl attribute.
5292  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
5293  if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
5294  ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false);
5295 
5296  // Finally, apply any attributes on the decl itself.
5297  if (const AttributeList *Attrs = PD.getAttributes())
5298  ProcessDeclAttributeList(S, D, Attrs);
5299 }
5300 
5301 /// Is the given declaration allowed to use a forbidden type?
5303  // Private ivars are always okay. Unfortunately, people don't
5304  // always properly make their ivars private, even in system headers.
5305  // Plus we need to make fields okay, too.
5306  // Function declarations in sys headers will be marked unavailable.
5307  if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
5308  !isa<FunctionDecl>(decl))
5309  return false;
5310 
5311  // Require it to be declared in a system header.
5313 }
5314 
5315 /// Handle a delayed forbidden-type diagnostic.
5317  Decl *decl) {
5318  if (decl && isForbiddenTypeAllowed(S, decl)) {
5319  decl->addAttr(UnavailableAttr::CreateImplicit(S.Context,
5320  "this system declaration uses an unsupported type",
5321  diag.Loc));
5322  return;
5323  }
5324  if (S.getLangOpts().ObjCAutoRefCount)
5325  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
5326  // FIXME: we may want to suppress diagnostics for all
5327  // kind of forbidden type messages on unavailable functions.
5328  if (FD->hasAttr<UnavailableAttr>() &&
5329  diag.getForbiddenTypeDiagnostic() ==
5330  diag::err_arc_array_param_no_ownership) {
5331  diag.Triggered = true;
5332  return;
5333  }
5334  }
5335 
5336  S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
5338  diag.Triggered = true;
5339 }
5340 
5341 
5342 static bool isDeclDeprecated(Decl *D) {
5343  do {
5344  if (D->isDeprecated())
5345  return true;
5346  // A category implicitly has the availability of the interface.
5347  if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
5348  if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
5349  return Interface->isDeprecated();
5350  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
5351  return false;
5352 }
5353 
5354 static bool isDeclUnavailable(Decl *D) {
5355  do {
5356  if (D->isUnavailable())
5357  return true;
5358  // A category implicitly has the availability of the interface.
5359  if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
5360  if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
5361  return Interface->isUnavailable();
5362  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
5363  return false;
5364 }
5365 
5367  Decl *Ctx, const NamedDecl *D,
5368  StringRef Message, SourceLocation Loc,
5369  const ObjCInterfaceDecl *UnknownObjCClass,
5370  const ObjCPropertyDecl *ObjCProperty,
5371  bool ObjCPropertyAccess) {
5372  // Diagnostics for deprecated or unavailable.
5373  unsigned diag, diag_message, diag_fwdclass_message;
5374 
5375  // Matches 'diag::note_property_attribute' options.
5376  unsigned property_note_select;
5377 
5378  // Matches diag::note_availability_specified_here.
5379  unsigned available_here_select_kind;
5380 
5381  // Don't warn if our current context is deprecated or unavailable.
5382  switch (K) {
5383  case Sema::AD_Deprecation:
5384  if (isDeclDeprecated(Ctx) || isDeclUnavailable(Ctx))
5385  return;
5386  diag = !ObjCPropertyAccess ? diag::warn_deprecated
5387  : diag::warn_property_method_deprecated;
5388  diag_message = diag::warn_deprecated_message;
5389  diag_fwdclass_message = diag::warn_deprecated_fwdclass_message;
5390  property_note_select = /* deprecated */ 0;
5391  available_here_select_kind = /* deprecated */ 2;
5392  break;
5393 
5394  case Sema::AD_Unavailable:
5395  if (isDeclUnavailable(Ctx))
5396  return;
5397  diag = !ObjCPropertyAccess ? diag::err_unavailable
5398  : diag::err_property_method_unavailable;
5399  diag_message = diag::err_unavailable_message;
5400  diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
5401  property_note_select = /* unavailable */ 1;
5402  available_here_select_kind = /* unavailable */ 0;
5403  break;
5404 
5405  case Sema::AD_Partial:
5406  diag = diag::warn_partial_availability;
5407  diag_message = diag::warn_partial_message;
5408  diag_fwdclass_message = diag::warn_partial_fwdclass_message;
5409  property_note_select = /* partial */ 2;
5410  available_here_select_kind = /* partial */ 3;
5411  break;
5412  }
5413 
5414  if (!Message.empty()) {
5415  S.Diag(Loc, diag_message) << D << Message;
5416  if (ObjCProperty)
5417  S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
5418  << ObjCProperty->getDeclName() << property_note_select;
5419  } else if (!UnknownObjCClass) {
5420  S.Diag(Loc, diag) << D;
5421  if (ObjCProperty)
5422  S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
5423  << ObjCProperty->getDeclName() << property_note_select;
5424  } else {
5425  S.Diag(Loc, diag_fwdclass_message) << D;
5426  S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
5427  }
5428 
5429  S.Diag(D->getLocation(), diag::note_availability_specified_here)
5430  << D << available_here_select_kind;
5431  if (K == Sema::AD_Partial)
5432  S.Diag(Loc, diag::note_partial_availability_silence) << D;
5433 }
5434 
5436  Decl *Ctx) {
5437  assert(DD.Kind == DelayedDiagnostic::Deprecation ||
5442  DD.Triggered = true;
5444  S, AD, Ctx, DD.getDeprecationDecl(), DD.getDeprecationMessage(), DD.Loc,
5445  DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
5446 }
5447 
5452 
5453  // When delaying diagnostics to run in the context of a parsed
5454  // declaration, we only want to actually emit anything if parsing
5455  // succeeds.
5456  if (!decl) return;
5457 
5458  // We emit all the active diagnostics in this pool or any of its
5459  // parents. In general, we'll get one pool for the decl spec
5460  // and a child pool for each declarator; in a decl group like:
5461  // deprecated_typedef foo, *bar, baz();
5462  // only the declarator pops will be passed decls. This is correct;
5463  // we really do need to consider delayed diagnostics from the decl spec
5464  // for each of the different declarations.
5465  const DelayedDiagnosticPool *pool = &poppedPool;
5466  do {
5468  i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
5469  // This const_cast is a bit lame. Really, Triggered should be mutable.
5470  DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
5471  if (diag.Triggered)
5472  continue;
5473 
5474  switch (diag.Kind) {
5477  // Don't bother giving deprecation/unavailable diagnostics if
5478  // the decl is invalid.
5479  if (!decl->isInvalidDecl())
5480  handleDelayedAvailabilityCheck(*this, diag, decl);
5481  break;
5482 
5484  HandleDelayedAccessCheck(diag, decl);
5485  break;
5486 
5488  handleDelayedForbiddenType(*this, diag, decl);
5489  break;
5490  }
5491  }
5492  } while ((pool = pool->getParent()));
5493 }
5494 
5495 /// Given a set of delayed diagnostics, re-emit them as if they had
5496 /// been delayed in the current context instead of in the given pool.
5497 /// Essentially, this just moves them to the current pool.
5500  assert(curPool && "re-emitting in undelayed context not supported");
5501  curPool->steal(pool);
5502 }
5503 
5505  NamedDecl *D, StringRef Message,
5506  SourceLocation Loc,
5507  const ObjCInterfaceDecl *UnknownObjCClass,
5508  const ObjCPropertyDecl *ObjCProperty,
5509  bool ObjCPropertyAccess) {
5510  // Delay if we're currently parsing a declaration.
5513  AD, Loc, D, UnknownObjCClass, ObjCProperty, Message,
5514  ObjCPropertyAccess));
5515  return;
5516  }
5517 
5518  Decl *Ctx = cast<Decl>(getCurLexicalContext());
5519  DoEmitAvailabilityWarning(*this, AD, Ctx, D, Message, Loc, UnknownObjCClass,
5520  ObjCProperty, ObjCPropertyAccess);
5521 }
static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getFlags() const
Definition: Scope.h:207
bool CheckNoReturnAttr(const AttributeList &attr)
static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D, const AttributeList &Attr)
Defines the clang::ASTContext interface.
static bool hasFunctionProto(const Decl *D)
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1366
static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, const AttributeList &Attr)
Check if passed in Decl is a pointer type. Note that this function may produce an error message...
static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const AttributeList &Attr, SmallVectorImpl< Expr * > &Args)
bool isVariadic() const
Definition: Type.h:3228
static void handleAssertSharedLockAttr(Sema &S, Decl *D, const AttributeList &Attr)
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
ExtVectorDeclsType ExtVectorDecls
Definition: Sema.h:443
ExprResult PerformContextuallyConvertToBool(Expr *From)
static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A)
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:215
bool isInvalid() const
Definition: Ownership.h:159
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1429
bool isCharType() const
Definition: Type.cpp:1633
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:1769
DeclContext * getCurLexicalContext() const
Definition: Sema.h:8990
bool isMemberPointerType() const
Definition: Type.h:5256
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:252
static void handleAcquiredAfterAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition: DeclBase.h:602
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
static bool isDeclUnavailable(Decl *D)
IdentifierInfo * getIdentifier() const
Definition: Decl.h:163
static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &Attr, unsigned Num, unsigned Diag, Compare Comp)
const LangOptions & getLangOpts() const
Definition: Sema.h:1019
static QualType getFunctionOrMethodResultType(const Decl *D)
bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const
unsigned getSemanticSpelling() const
If the parsed attribute has a semantic equivalent, and it would have a semantic Spelling enumeration ...
static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAcquireCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr)
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
Defines the SourceManager interface.
static void handleObjCIndependentClass(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAttrWithMessage(Sema &S, Decl *D, const AttributeList &Attr)
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:163
QualType getUnderlyingType() const
Definition: Decl.h:2616
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1088
SourceRange getRange() const
static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleObjCRuntimeName(Sema &S, Decl *D, const AttributeList &Attr)
static void handleSetTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr)
const AvailabilityChange & getAvailabilityDeprecated() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2500
static bool checkUInt32Argument(Sema &S, const AttributeList &Attr, const Expr *Expr, uint32_t &Val, unsigned Idx=UINT_MAX)
If Expr is a valid integer constant, get the value of the integer expression and return success or fa...
Defines the C++ template declaration subclasses.
bool isVoidPointerType() const
Definition: Type.cpp:384
IdentifierInfo * Ident
Definition: AttributeList.h:52
bool hasDefinition() const
Definition: DeclCXX.h:680
static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr)
PtrTy get() const
Definition: Ownership.h:163
static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D, const AttributeList &Attr)
const ObjCObjectType * getObjectType() const
Definition: Type.h:4820
static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isBooleanType() const
Definition: Type.h:5489
A container of type source information.
Definition: Decl.h:60
static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr)
bool isBlockPointerType() const
Definition: Type.h:5238
static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr)
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
Definition: Sema.cpp:536
bool hasCustomParsing() const
static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType *RT)
OptimizeNoneAttr * mergeOptimizeNoneAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
bool isValidPointerAttrType(QualType T, bool RefOkay=false)
static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr)
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1572
static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const AttributeList &Attr, Expr *&Arg)
field_iterator field_begin() const
Definition: Decl.cpp:3629
bool isUsedAsTypeAttr() const
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1701
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1592
static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL)
static void handleReturnTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isArgIdent(unsigned Arg) const
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1334
bool isObjCRetainableType() const
Definition: Type.cpp:3542
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isUnionType() const
Definition: Type.cpp:390
FormatAttr * mergeFormatAttr(Decl *D, SourceRange Range, IdentifierInfo *Format, int FormatIdx, int FirstArg, unsigned AttrSpellingListIndex)
bool isVoidType() const
Definition: Type.h:5426
SourceLocation Loc
Definition: AttributeList.h:51
static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D, const AttributeList &Attr, SmallVectorImpl< Expr * > &Args, int Sidx=0, bool ParamIdxOk=false)
Checks that all attribute arguments, starting from Sidx, resolve to a capability object.
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const AttributeList &Attr, bool IncludeCXX11Attributes)
static void handleMSP430InterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclarationName getName() const
getName - Returns the embedded declaration name.
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:564
SourceLocation getUnavailableLoc() const
static void DoEmitAvailabilityWarning(Sema &S, Sema::AvailabilityDiagnostic K, Decl *Ctx, const NamedDecl *D, StringRef Message, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess)
static void handleAssumeAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasAttr() const
Definition: DeclBase.h:487
static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr)
AttributeList * getList() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:89
static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const AttributeList &Attr)
The results of name lookup within a DeclContext. This is either a single result (with no stable stora...
Definition: DeclBase.h:1034
static bool checkTypedefTypeForCapability(QualType Ty)
static void handleObjCOwnershipAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isReferenceType() const
Definition: Type.h:5241
QualType getReturnType() const
Definition: Decl.h:1997
bool isCompleteDefinition() const
Definition: Decl.h:2838
bool isAnyPointerType() const
Definition: Type.h:5235
static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleDeclspecThreadAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleCallableWhenAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isFileID() const
static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y, bool BeforeIsOkay)
Check whether the two versions match.
static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A)
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:258
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:675
static void handleLocksExcludedAttr(Sema &S, Decl *D, const AttributeList &Attr)
TagKind getTagKind() const
Definition: Decl.h:2897
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1871
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:362
static void handleTransparentUnionAttr(Sema &S, Decl *D, const AttributeList &Attr)
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:449
static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasVariadicArg() const
bool existsInTarget(const llvm::Triple &T) const
static void handleAssertExclusiveLockAttr(Sema &S, Decl *D, const AttributeList &Attr)
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:101
static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleARMInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
void redelayDiagnostics(sema::DelayedDiagnosticPool &pool)
Describes a module or submodule.
Definition: Basic/Module.h:49
IdentifierTable & Idents
Definition: ASTContext.h:439
virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const
Gets the default calling convention for the given target and declaration context. ...
static void handleMSInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool attrNonNullArgCheck(Sema &S, QualType T, const AttributeList &Attr, SourceRange AttrParmRange, SourceRange TypeRange, bool isReturnValue=false)
T * getAttr() const
Definition: DeclBase.h:484
void AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, Expr *OE, unsigned SpellingListIndex)
static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D, const AttributeList &Attr)
static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D, const AttributeList &attr)
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:518
TypeVisibilityAttr * mergeTypeVisibilityAttr(Decl *D, SourceRange Range, TypeVisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
static bool isIntOrBool(Expr *Exp)
Check if the passed-in expression is of type int or bool.
std::string getAsString() const
Retrieve a string representation of the version number.
MinSizeAttr * mergeMinSizeAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:1947
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=ParsedType(), bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:241
static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:856
QualType getReturnType() const
Definition: Type.h:2952
static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:6746
void PopParsingDeclaration(ParsingDeclState state, Decl *decl)
field_range fields() const
Definition: Decl.h:3349
static void handleAlignValueAttr(Sema &S, Decl *D, const AttributeList &Attr)
const ArrayType * getAsArrayType(QualType T) const
const DelayedDiagnosticPool * getParent() const
QualType getForbiddenTypeOperand() const
bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC, const FunctionDecl *FD=nullptr)
bool hasParsedType() const
bool isValueDependent() const
Definition: Expr.h:146
RecordDecl * getDecl() const
Definition: Type.h:3527
void steal(DelayedDiagnosticPool &pool)
Steal the diagnostics from the given pool.
ObjCInterfaceDecl * getInterface() const
Definition: Type.h:4758
static void handleObjCDesignatedInitializer(Sema &S, Decl *D, const AttributeList &Attr)
std::string getNameAsString() const
Definition: Decl.h:183
Expr * IgnoreParenCasts() LLVM_READONLY
Definition: Expr.cpp:2439
static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D, const AttributeList &Attr)
Represents information about a change in availability for an entity, which is part of the encoding of...
Definition: AttributeList.h:35
bool getLayoutCompatible() const
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1731
bool isIncompleteType(NamedDecl **Def=nullptr) const
Def If non-NULL, and the type refers to some kind of declaration that can be completed (such as a C s...
Definition: Type.cpp:1869
Preprocessor & PP
Definition: Sema.h:294
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1785
bool isInvalid() const
#define UINT_MAX
Definition: limits.h:72
Represents an ObjC class declaration.
Definition: DeclObjC.h:851
static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isExtVectorType() const
Definition: Type.h:5301
void setInvalid(bool b=true) const
static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this attribute.
VersionTuple Version
The version number at which the change occurred.
Definition: AttributeList.h:40
QualType getType() const
Definition: Decl.h:538
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1683
const LangOptions & LangOpts
Definition: Sema.h:293
void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, bool IncludeCXX11Attributes=true)
static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr)
static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx)
void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex, bool IsPackExpansion)
AddAlignedAttr - Adds an aligned attribute to a particular declaration.
field_iterator field_end() const
Definition: Decl.h:3352
IdentifierInfo * getAlias() const
Definition: Weak.h:34
static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr)
AnnotatingParser & P
bool isUnion() const
Definition: Decl.h:2906
static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool canBeWeakImported(bool &IsDefinition) const
Determines whether this symbol can be weak-imported, e.g., whether it would be well-formed to add the...
Definition: DeclBase.cpp:485
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:258
static bool isDeclDeprecated(Decl *D)
Kind getKind() const
static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:442
const AvailabilityChange & getAvailabilityIntroduced() const
static void handleCFAuditedTransferAttr(Sema &S, Decl *D, const AttributeList &Attr)
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1620
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1592
Captures information about a #pragma weak directive.
Definition: Weak.h:25
static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr)
QualType getPointeeType() const
Definition: Type.cpp:414
bool isFunctionPointerType() const
Definition: Type.h:5250
void AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E, unsigned SpellingListIndex)
static void handlePtGuardedVarAttr(Sema &S, Decl *D, const AttributeList &Attr)
Exposes information about the current target.
static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType type)
static DelayedDiagnostic makeAvailability(Sema::AvailabilityDiagnostic AD, SourceLocation Loc, const NamedDecl *D, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, StringRef Msg, bool ObjCPropertyAccess)
static bool isCFStringType(QualType T, ASTContext &Ctx)
static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleObjCRequiresSuperAttr(Sema &S, Decl *D, const AttributeList &attr)
void popWithoutEmitting(DelayedDiagnosticsState state)
Definition: Sema.h:580
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:133
static bool checkLaunchBoundsArgument(Sema &S, Expr *E, const CUDALaunchBoundsAttr &Attr, const unsigned Idx)
MSInheritanceAttr::Spelling calculateInheritanceModel() const
Calculate what the inheritance model would be for this class.
static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr)
StringRef getName() const
Return the actual identifier string.
SmallVector< Decl *, 2 > WeakTopLevelDecl
Definition: Sema.h:673
DLLImportAttr * mergeDLLImportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr)
static bool hasDeclarator(const Decl *D)
static void handleTestTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool isCapabilityExpr(Sema &S, const Expr *Ex)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
virtual std::string isValidSectionSpecifier(StringRef SR) const
An optional hook that targets can implement to perform semantic checking on attribute((section("foo")...
void setInvalidDecl(bool Invalid=true)
Definition: DeclBase.cpp:96
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:812
static void handleCFUnknownTransferAttr(Sema &S, Decl *D, const AttributeList &Attr)
Defines the clang::Preprocessor interface.
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
Definition: SemaExpr.cpp:11869
static bool typeHasCapability(Sema &S, QualType Ty)
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:1968
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
Definition: Sema.h:656
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclContext * getDeclContext()
Definition: DeclBase.h:381
void CheckAlignasUnderalignment(Decl *D)
bool isFloatingType() const
Definition: Type.cpp:1760
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool isObjCIdType() const
Definition: Type.h:5328
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr)
void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx)
MSInheritanceAttr * mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase, unsigned AttrSpellingListIndex, MSInheritanceAttr::Spelling SemanticSpelling)
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:303
bool isDependentType() const
Definition: Type.h:1727
virtual bool hasProtectedVisibility() const
Does this target support "protected" visibility?
const ParsedType & getTypeArg() const
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1174
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool isNSStringType(QualType T, ASTContext &Ctx)
SmallVector< ActiveTemplateInstantiation, 16 > ActiveTemplateInstantiations
List of active template instantiations.
Definition: Sema.h:6518
DeclarationName getDeclName() const
Definition: Decl.h:189
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1202
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:50
static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getForbiddenTypeDiagnostic() const
static void handlePtGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr)
RecordDecl * getDefinition() const
Definition: Decl.h:3339
static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag, Decl *decl)
Handle a delayed forbidden-type diagnostic.
void setDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:226
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:204
static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr)
AttrVec & getAttrs()
Definition: DeclBase.h:431
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:85
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType. Returns the relevant RecordType, null if it does not exit.
static bool checkAttrMutualExclusion(Sema &S, Decl *D, const AttributeList &Attr)
Diagnose mutually exclusive attributes when present on a given declaration. Returns true if diagnosed...
void addAttr(Attr *A)
Definition: DeclBase.h:437
static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr, unsigned Num)
Check if the attribute has exactly as many args as Num. May output an error.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:365
static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.h:1367
static bool isFunctionOrMethodOrBlock(const Decl *D)
Return true if the given decl has function type (function or function-typed variable) or an Objective...
CanQualType OverloadTy
Definition: ASTContext.h:832
There is no lifetime qualification on this type.
Definition: Type.h:130
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. This may omit quali...
Definition: Decl.cpp:2819
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:1722
static bool checkRecordTypeForCapability(Sema &S, QualType Ty)
static bool isValidSubjectOfNSAttribute(Sema &S, QualType type)
unsigned getAttributeSpellingListIndex() const
Get an index into the attribute spelling list defined in Attr.td. This index is used by an attribute ...
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
The "struct" keyword.
Definition: Type.h:4130
Kind
static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const AttributeList &Attr, SmallVectorImpl< Expr * > &Args)
static FormatAttrKind getFormatAttrKind(StringRef Format)
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5476
const ParsedType & getMatchingCType() const
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2299
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
unsigned getNumParams() const
Definition: Decl.cpp:2651
void NoteAllOverloadCandidates(Expr *E, QualType DestType=QualType())
static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D, const AttributeList &Attr)
static bool isForbiddenTypeAllowed(Sema &S, Decl *decl)
Is the given declaration allowed to use a forbidden type?
SourceLocation getEllipsisLoc() const
DLLExportAttr * mergeDLLExportAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex)
void setUsed(bool Used=true)
Definition: Weak.h:36
bool isComplexType() const
Definition: Type.cpp:396
bool isBuiltinType() const
isBuiltinType - returns true if the type is a builtin type.
Definition: Type.h:5286
bool isValid() const
Return true if this is a valid SourceLocation object.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2694
bool isValid() const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ASTContext & getASTContext() const
Definition: Sema.h:1026
const ObjCInterfaceDecl * getUnknownObjCClass() const
bool getMustBeNull() const
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:685
AvailabilityDiagnostic
Definition: Sema.h:3476
const NamedDecl * getDeprecationDecl() const
static void handleLockReturnedAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAvailabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1717
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition: Sema.h:561
static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D, const AttributeList &Attr)
static T * mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range, typename T::VisibilityType value, unsigned attrSpellingListIndex)
static void handleAlwaysInlineAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr)
void push_back(const T &LocalValue)
static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleNSReturnsRetainedAttr(Sema &S, Decl *D, const AttributeList &Attr)
StringRef getDeprecationMessage() const
static unsigned getNumAttributeArgs(const AttributeList &Attr)
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:880
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:2424
unsigned getForbiddenTypeArgument() const
QualType getReturnType() const
Definition: DeclObjC.h:330
SourceLocation getBegin() const
const T * castAs() const
Definition: Type.h:5586
bool isTypeDependent() const
Definition: Expr.h:166
bool isArgExpr(unsigned Arg) const
lookup_result lookup(DeclarationName Name) const
Definition: DeclBase.cpp:1339
static void handleObjCBridgeMutableAttr(Sema &S, Scope *Sc, Decl *D, const AttributeList &Attr)
static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD, Decl *Ctx)
IdentifierInfo * getScopeName() const
static void handleOptimizeNoneAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isAscii() const
Definition: Expr.h:1564
bool isVectorType() const
Definition: Type.h:5298
IdentifierLoc * getArgAsIdent(unsigned Arg) const
static void handleParamTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2024
QualType getRealTypeForBitwidth(unsigned DestWidth) const
Assigning into this object requires a lifetime extension.
Definition: Type.h:147
static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD, const AttributeList &Attr)
static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasScope() const
static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const AttributeList &Attr)
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
QualType getPointeeType() const
Definition: Type.h:2139
unsigned getMinArgs() const
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
SourceLocation getLocation() const
Definition: Weak.h:35
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2576
QualType getType() const
Definition: Expr.h:125
static void handleObjCBridgeAttr(Sema &S, Scope *Sc, Decl *D, const AttributeList &Attr)
bool checkStringLiteralArgumentAttr(const AttributeList &Attr, unsigned ArgNum, StringRef &Str, SourceLocation *ArgLocation=nullptr)
Check if the argument ArgNum of Attr is a ASCII string literal. If not emit an error and return false...
bool diagnoseLangOpts(class Sema &S) const
void checkUnusedDeclAttributes(Declarator &D)
static void handleReturnsNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr)
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:10213
const AvailabilityChange & getAvailabilityObsoleted() const
static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const AttributeList &Attr)
void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1639
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
Definition: VersionTuple.h:64
void ProcessPragmaWeak(Scope *S, Decl *D)
bool isInvalidDecl() const
Definition: DeclBase.h:498
NamedDecl * DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, SourceLocation Loc)
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceAttr::Spelling SemanticSpelling)
static void handleObjCBridgeRelatedAttr(Sema &S, Scope *Sc, Decl *D, const AttributeList &Attr)
SectionAttr * mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name, unsigned AttrSpellingListIndex)
Expr * getArgAsExpr(unsigned Arg) const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
unsigned short getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
StringRef getString() const
Definition: Expr.h:1521
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible. Will return null if...
Definition: DeclBase.cpp:742
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool hasAttrs() const
Definition: DeclBase.h:427
VisibilityAttr * mergeVisibilityAttr(Decl *D, SourceRange Range, VisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
static void handleIBOutletCollection(Sema &S, Decl *D, const AttributeList &Attr)
static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr, bool isTypeVisibility)
NamedDecl * getCurFunctionOrMethodDecl()
Definition: Sema.cpp:931
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Definition: Sanitizers.cpp:20
QualType getNonReferenceType() const
Definition: Type.h:5182
const Expr * getMessageExpr() const
static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted)
bool isObjCObjectType() const
Definition: Type.h:5307
bool isPackExpansion() const
static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr)
IdentifierInfo * getName() const
const T * getAs() const
Definition: Type.h:5555
static void handleSimpleAttribute(Sema &S, Decl *D, const AttributeList &Attr)
Applies the given attribute to the Decl without performing any additional semantic checking...
void add(const sema::DelayedDiagnostic &diag)
Adds a delayed diagnostic.
bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const AttributeList *AttrList)
bool getUsed()
Definition: Weak.h:37
static bool isFunctionOrMethod(const Decl *D)
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1626
static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleReleaseCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getMaxArgs() const
static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isFunctionType() const
Definition: Type.h:5229
DeclContext * getRedeclContext()
Definition: DeclBase.cpp:1466
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1505
SourceLocation getLoc() const
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:78
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2305
bool isTypeAttr() const
void checkTargetAttr(SourceLocation LiteralLoc, StringRef Str)
SourceManager & getSourceManager()
Definition: ASTContext.h:494
bool isTLSSupported() const
Whether the target supports thread-local storage.
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
static void handleRequiresCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1080
static void handleInitPriorityAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool CheckRegparmAttr(const AttributeList &attr, unsigned &value)
const ObjCPropertyDecl * getObjCProperty() const
bool isCXX11Attribute() const
X
Definition: SemaDecl.cpp:11429
static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &Attr, unsigned Num)
Check if the attribute has at most as many args as Num. May output an error.
Reading or writing from this object requires a barrier call.
Definition: Type.h:144
static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D, const AttributeList &Attr)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
static bool isInstanceMethod(const Decl *D)
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition: Type.cpp:3575
void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD)
virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const
Determines whether a given calling convention is valid for the target. A calling convention can eithe...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:285
Compatible - the types are compatible according to the standard.
Definition: Sema.h:8142
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
static unsigned getFunctionOrMethodNumParams(const Decl *D)
bool isObjCObjectPointerType() const
Definition: Type.h:5304
static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr)
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:470
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:307
void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads, Expr *MinBlocks, unsigned SpellingListIndex)
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:115
static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr)
static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D)
static void handleAssertCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &Attr)
static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr, unsigned Num)
Check if the attribute has at least as many args as Num. May output an error.
Defines the clang::TargetInfo interface.
static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl, const AttributeList &Attr)
FormatAttrKind
bool checkSectionName(SourceLocation LiteralLoc, StringRef Str)
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx)
static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr)
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool Override, unsigned AttrSpellingListIndex)
Attribute merging methods. Return true if a new attribute was added.
bool isDeclspecAttribute() const
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:52
A collection of diagnostics which were delayed.
static bool isValidSubjectOfCFAttribute(Sema &S, QualType type)
const DeclaratorChunk & getTypeObject(unsigned i) const
Definition: DeclSpec.h:1951
static bool checkLockFunAttrCommon(Sema &S, Decl *D, const AttributeList &Attr, SmallVectorImpl< Expr * > &Args)
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
AttributeList * getNext() const
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:372
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:230
ASTContext & Context
Definition: Sema.h:295
AlwaysInlineAttr * mergeAlwaysInlineAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
static void handleTLSModelAttr(Sema &S, Decl *D, const AttributeList &Attr)
void dropAttr()
Definition: DeclBase.h:459
bool isSignedIntegerType() const
Definition: Type.cpp:1683
static bool checkFunctionOrMethodParameterIndex(Sema &S, const Decl *D, const AttributeList &Attr, unsigned AttrArgNum, const Expr *IdxExpr, uint64_t &Idx)
Check if IdxExpr is a valid parameter index for a function or instance method D. May output an error...
static bool isFunctionOrMethodVariadic(const Decl *D)
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:1681
void EmitAvailabilityWarning(AvailabilityDiagnostic AD, NamedDecl *D, StringRef Message, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess)
AttributeDeclKind
bool isIntegralType(ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1602
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
static void handleWorkGroupSize(Sema &S, Decl *D, const AttributeList &Attr)
Attr - This represents one attribute.
Definition: Attr.h:44
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:735
bool isIntegerType() const
Definition: Type.h:5448
bool hasLocalStorage() const
Definition: Decl.h:887
SmallVectorImpl< DelayedDiagnostic >::const_iterator pool_iterator
bool isDeprecated(std::string *Message=nullptr) const
Determine whether this declaration is marked 'deprecated'.
Definition: DeclBase.h:593
const DeclSpec & getDeclSpec() const
Definition: DeclSpec.h:1676
bool isPointerType() const
Definition: Type.h:5232
static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
static LLVM_READONLY bool isHexDigit(unsigned char c)
Return true if this character is an ASCII hex digit: [0-9a-fA-F].
Definition: CharInfo.h:124
const AttributeList * getAttributes() const
Definition: DeclSpec.h:2125