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