clang  5.0.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 
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/Mangle.h"
25 #include "clang/Basic/CharInfo.h"
27 #include "clang/Basic/TargetInfo.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/DeclSpec.h"
32 #include "clang/Sema/Lookup.h"
33 #include "clang/Sema/Scope.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/Support/MathExtras.h"
38 
39 using namespace clang;
40 using namespace sema;
41 
42 namespace AttributeLangSupport {
43  enum LANG {
44  C,
45  Cpp,
47  };
48 } // end namespace AttributeLangSupport
49 
50 //===----------------------------------------------------------------------===//
51 // Helper functions
52 //===----------------------------------------------------------------------===//
53 
54 /// isFunctionOrMethod - Return true if the given decl has function
55 /// type (function or function-typed variable) or an Objective-C
56 /// method.
57 static bool isFunctionOrMethod(const Decl *D) {
58  return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
59 }
60 
61 /// \brief Return true if the given decl has function type (function or
62 /// function-typed variable) or an Objective-C method or a block.
63 static bool isFunctionOrMethodOrBlock(const Decl *D) {
64  return isFunctionOrMethod(D) || isa<BlockDecl>(D);
65 }
66 
67 /// Return true if the given decl has a declarator that should have
68 /// been processed by Sema::GetTypeForDeclarator.
69 static bool hasDeclarator(const Decl *D) {
70  // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
71  return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
72  isa<ObjCPropertyDecl>(D);
73 }
74 
75 /// hasFunctionProto - Return true if the given decl has a argument
76 /// information. This decl should have already passed
77 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
78 static bool hasFunctionProto(const Decl *D) {
79  if (const FunctionType *FnTy = D->getFunctionType())
80  return isa<FunctionProtoType>(FnTy);
81  return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
82 }
83 
84 /// getFunctionOrMethodNumParams - Return number of function or method
85 /// parameters. It is an error to call this on a K&R function (use
86 /// hasFunctionProto first).
87 static unsigned getFunctionOrMethodNumParams(const Decl *D) {
88  if (const FunctionType *FnTy = D->getFunctionType())
89  return cast<FunctionProtoType>(FnTy)->getNumParams();
90  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
91  return BD->getNumParams();
92  return cast<ObjCMethodDecl>(D)->param_size();
93 }
94 
95 static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
96  if (const FunctionType *FnTy = D->getFunctionType())
97  return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
98  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
99  return BD->getParamDecl(Idx)->getType();
100 
101  return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
102 }
103 
104 static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
105  if (const auto *FD = dyn_cast<FunctionDecl>(D))
106  return FD->getParamDecl(Idx)->getSourceRange();
107  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
108  return MD->parameters()[Idx]->getSourceRange();
109  if (const auto *BD = dyn_cast<BlockDecl>(D))
110  return BD->getParamDecl(Idx)->getSourceRange();
111  return SourceRange();
112 }
113 
115  if (const FunctionType *FnTy = D->getFunctionType())
116  return cast<FunctionType>(FnTy)->getReturnType();
117  return cast<ObjCMethodDecl>(D)->getReturnType();
118 }
119 
121  if (const auto *FD = dyn_cast<FunctionDecl>(D))
122  return FD->getReturnTypeSourceRange();
123  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
124  return MD->getReturnTypeSourceRange();
125  return SourceRange();
126 }
127 
128 static bool isFunctionOrMethodVariadic(const Decl *D) {
129  if (const FunctionType *FnTy = D->getFunctionType()) {
130  const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
131  return proto->isVariadic();
132  }
133  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
134  return BD->isVariadic();
135 
136  return cast<ObjCMethodDecl>(D)->isVariadic();
137 }
138 
139 static bool isInstanceMethod(const Decl *D) {
140  if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
141  return MethodDecl->isInstance();
142  return false;
143 }
144 
145 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
147  if (!PT)
148  return false;
149 
151  if (!Cls)
152  return false;
153 
154  IdentifierInfo* ClsName = Cls->getIdentifier();
155 
156  // FIXME: Should we walk the chain of classes?
157  return ClsName == &Ctx.Idents.get("NSString") ||
158  ClsName == &Ctx.Idents.get("NSMutableString");
159 }
160 
161 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
162  const PointerType *PT = T->getAs<PointerType>();
163  if (!PT)
164  return false;
165 
166  const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
167  if (!RT)
168  return false;
169 
170  const RecordDecl *RD = RT->getDecl();
171  if (RD->getTagKind() != TTK_Struct)
172  return false;
173 
174  return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
175 }
176 
177 static unsigned getNumAttributeArgs(const AttributeList &Attr) {
178  // FIXME: Include the type in the argument list.
179  return Attr.getNumArgs() + Attr.hasParsedType();
180 }
181 
182 template <typename Compare>
184  unsigned Num, unsigned Diag,
185  Compare Comp) {
186  if (Comp(getNumAttributeArgs(Attr), Num)) {
187  S.Diag(Attr.getLoc(), Diag) << Attr.getName() << Num;
188  return false;
189  }
190 
191  return true;
192 }
193 
194 /// \brief Check if the attribute has exactly as many args as Num. May
195 /// output an error.
197  unsigned Num) {
198  return checkAttributeNumArgsImpl(S, Attr, Num,
199  diag::err_attribute_wrong_number_arguments,
200  std::not_equal_to<unsigned>());
201 }
202 
203 /// \brief Check if the attribute has at least as many args as Num. May
204 /// output an error.
206  unsigned Num) {
207  return checkAttributeNumArgsImpl(S, Attr, Num,
208  diag::err_attribute_too_few_arguments,
209  std::less<unsigned>());
210 }
211 
212 /// \brief Check if the attribute has at most as many args as Num. May
213 /// output an error.
215  unsigned Num) {
216  return checkAttributeNumArgsImpl(S, Attr, Num,
217  diag::err_attribute_too_many_arguments,
218  std::greater<unsigned>());
219 }
220 
221 /// \brief A helper function to provide Attribute Location for the Attr types
222 /// AND the AttributeList.
223 template <typename AttrInfo>
224 static typename std::enable_if<std::is_base_of<clang::Attr, AttrInfo>::value,
226 getAttrLoc(const AttrInfo &Attr) {
227  return Attr.getLocation();
228 }
230  return Attr.getLoc();
231 }
232 
233 /// \brief A helper function to provide Attribute Name for the Attr types
234 /// AND the AttributeList.
235 template <typename AttrInfo>
236 static typename std::enable_if<std::is_base_of<clang::Attr, AttrInfo>::value,
237  const AttrInfo *>::type
238 getAttrName(const AttrInfo &Attr) {
239  return &Attr;
240 }
242  return Attr.getName();
243 }
244 
245 /// \brief If Expr is a valid integer constant, get the value of the integer
246 /// expression and return success or failure. May output an error.
247 template<typename AttrInfo>
248 static bool checkUInt32Argument(Sema &S, const AttrInfo& Attr, const Expr *Expr,
249  uint32_t &Val, unsigned Idx = UINT_MAX) {
250  llvm::APSInt I(32);
251  if (Expr->isTypeDependent() || Expr->isValueDependent() ||
252  !Expr->isIntegerConstantExpr(I, S.Context)) {
253  if (Idx != UINT_MAX)
254  S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_n_type)
255  << getAttrName(Attr) << Idx << AANT_ArgumentIntegerConstant
256  << Expr->getSourceRange();
257  else
258  S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_type)
260  << Expr->getSourceRange();
261  return false;
262  }
263 
264  if (!I.isIntN(32)) {
265  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
266  << I.toString(10, false) << 32 << /* Unsigned */ 1;
267  return false;
268  }
269 
270  Val = (uint32_t)I.getZExtValue();
271  return true;
272 }
273 
274 /// \brief Wrapper around checkUInt32Argument, with an extra check to be sure
275 /// that the result will fit into a regular (signed) int. All args have the same
276 /// purpose as they do in checkUInt32Argument.
277 template<typename AttrInfo>
278 static bool checkPositiveIntArgument(Sema &S, const AttrInfo& Attr, const Expr *Expr,
279  int &Val, unsigned Idx = UINT_MAX) {
280  uint32_t UVal;
281  if (!checkUInt32Argument(S, Attr, Expr, UVal, Idx))
282  return false;
283 
284  if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
285  llvm::APSInt I(32); // for toString
286  I = UVal;
287  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
288  << I.toString(10, false) << 32 << /* Unsigned */ 0;
289  return false;
290  }
291 
292  Val = UVal;
293  return true;
294 }
295 
296 /// \brief Diagnose mutually exclusive attributes when present on a given
297 /// declaration. Returns true if diagnosed.
298 template <typename AttrTy>
300  IdentifierInfo *Ident) {
301  if (AttrTy *A = D->getAttr<AttrTy>()) {
302  S.Diag(Range.getBegin(), diag::err_attributes_are_not_compatible) << Ident
303  << A;
304  S.Diag(A->getLocation(), diag::note_conflicting_attribute);
305  return true;
306  }
307  return false;
308 }
309 
310 /// \brief Check if IdxExpr is a valid parameter index for a function or
311 /// instance method D. May output an error.
312 ///
313 /// \returns true if IdxExpr is a valid index.
314 template <typename AttrInfo>
316  Sema &S, const Decl *D, const AttrInfo &Attr, unsigned AttrArgNum,
317  const Expr *IdxExpr, uint64_t &Idx, bool AllowImplicitThis = false) {
318  assert(isFunctionOrMethodOrBlock(D));
319 
320  // In C++ the implicit 'this' function parameter also counts.
321  // Parameters are counted from one.
322  bool HP = hasFunctionProto(D);
323  bool HasImplicitThisParam = isInstanceMethod(D);
324  bool IV = HP && isFunctionOrMethodVariadic(D);
325  unsigned NumParams =
326  (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
327 
328  llvm::APSInt IdxInt;
329  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
330  !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
331  S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_n_type)
332  << getAttrName(Attr) << AttrArgNum << AANT_ArgumentIntegerConstant
333  << IdxExpr->getSourceRange();
334  return false;
335  }
336 
337  Idx = IdxInt.getLimitedValue();
338  if (Idx < 1 || (!IV && Idx > NumParams)) {
339  S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_out_of_bounds)
340  << getAttrName(Attr) << AttrArgNum << IdxExpr->getSourceRange();
341  return false;
342  }
343  Idx--; // Convert to zero-based.
344  if (HasImplicitThisParam && !AllowImplicitThis) {
345  if (Idx == 0) {
346  S.Diag(getAttrLoc(Attr),
347  diag::err_attribute_invalid_implicit_this_argument)
348  << getAttrName(Attr) << IdxExpr->getSourceRange();
349  return false;
350  }
351  --Idx;
352  }
353 
354  return true;
355 }
356 
357 /// \brief Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
358 /// If not emit an error and return false. If the argument is an identifier it
359 /// will emit an error with a fixit hint and treat it as if it was a string
360 /// literal.
362  unsigned ArgNum, StringRef &Str,
363  SourceLocation *ArgLocation) {
364  // Look for identifiers. If we have one emit a hint to fix it to a literal.
365  if (Attr.isArgIdent(ArgNum)) {
366  IdentifierLoc *Loc = Attr.getArgAsIdent(ArgNum);
367  Diag(Loc->Loc, diag::err_attribute_argument_type)
368  << Attr.getName() << AANT_ArgumentString
369  << FixItHint::CreateInsertion(Loc->Loc, "\"")
370  << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
371  Str = Loc->Ident->getName();
372  if (ArgLocation)
373  *ArgLocation = Loc->Loc;
374  return true;
375  }
376 
377  // Now check for an actual string literal.
378  Expr *ArgExpr = Attr.getArgAsExpr(ArgNum);
379  StringLiteral *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
380  if (ArgLocation)
381  *ArgLocation = ArgExpr->getLocStart();
382 
383  if (!Literal || !Literal->isAscii()) {
384  Diag(ArgExpr->getLocStart(), diag::err_attribute_argument_type)
385  << Attr.getName() << AANT_ArgumentString;
386  return false;
387  }
388 
389  Str = Literal->getString();
390  return true;
391 }
392 
393 /// \brief Applies the given attribute to the Decl without performing any
394 /// additional semantic checking.
395 template <typename AttrType>
396 static void handleSimpleAttribute(Sema &S, Decl *D,
397  const AttributeList &Attr) {
398  D->addAttr(::new (S.Context) AttrType(Attr.getRange(), S.Context,
400 }
401 
402 template <typename AttrType>
404  const AttributeList &Attr) {
405  handleSimpleAttribute<AttrType>(S, D, Attr);
406 }
407 
408 /// \brief Applies the given attribute to the Decl so long as the Decl doesn't
409 /// already have one of the given incompatible attributes.
410 template <typename AttrType, typename IncompatibleAttrType,
411  typename... IncompatibleAttrTypes>
413  const AttributeList &Attr) {
414  if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, Attr.getRange(),
415  Attr.getName()))
416  return;
417  handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
418  Attr);
419 }
420 
421 /// \brief Check if the passed-in expression is of type int or bool.
422 static bool isIntOrBool(Expr *Exp) {
423  QualType QT = Exp->getType();
424  return QT->isBooleanType() || QT->isIntegerType();
425 }
426 
427 
428 // Check to see if the type is a smart pointer of some kind. We assume
429 // it's a smart pointer if it defines both operator-> and operator*.
431  DeclContextLookupResult Res1 = RT->getDecl()->lookup(
433  if (Res1.empty())
434  return false;
435 
436  DeclContextLookupResult Res2 = RT->getDecl()->lookup(
438  if (Res2.empty())
439  return false;
440 
441  return true;
442 }
443 
444 /// \brief Check if passed in Decl is a pointer type.
445 /// Note that this function may produce an error message.
446 /// \return true if the Decl is a pointer type; false otherwise
447 static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
448  const AttributeList &Attr) {
449  const ValueDecl *vd = cast<ValueDecl>(D);
450  QualType QT = vd->getType();
451  if (QT->isAnyPointerType())
452  return true;
453 
454  if (const RecordType *RT = QT->getAs<RecordType>()) {
455  // If it's an incomplete type, it could be a smart pointer; skip it.
456  // (We don't want to force template instantiation if we can avoid it,
457  // since that would alter the order in which templates are instantiated.)
458  if (RT->isIncompleteType())
459  return true;
460 
462  return true;
463  }
464 
465  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
466  << Attr.getName() << QT;
467  return false;
468 }
469 
470 /// \brief Checks that the passed in QualType either is of RecordType or points
471 /// to RecordType. Returns the relevant RecordType, null if it does not exit.
472 static const RecordType *getRecordType(QualType QT) {
473  if (const RecordType *RT = QT->getAs<RecordType>())
474  return RT;
475 
476  // Now check if we point to record type.
477  if (const PointerType *PT = QT->getAs<PointerType>())
478  return PT->getPointeeType()->getAs<RecordType>();
479 
480  return nullptr;
481 }
482 
484  const RecordType *RT = getRecordType(Ty);
485 
486  if (!RT)
487  return false;
488 
489  // Don't check for the capability if the class hasn't been defined yet.
490  if (RT->isIncompleteType())
491  return true;
492 
493  // Allow smart pointers to be used as capability objects.
494  // FIXME -- Check the type that the smart pointer points to.
496  return true;
497 
498  // Check if the record itself has a capability.
499  RecordDecl *RD = RT->getDecl();
500  if (RD->hasAttr<CapabilityAttr>())
501  return true;
502 
503  // Else check if any base classes have a capability.
504  if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
505  CXXBasePaths BPaths(false, false);
506  if (CRD->lookupInBases([](const CXXBaseSpecifier *BS, CXXBasePath &) {
507  const auto *Type = BS->getType()->getAs<RecordType>();
508  return Type->getDecl()->hasAttr<CapabilityAttr>();
509  }, BPaths))
510  return true;
511  }
512  return false;
513 }
514 
516  const auto *TD = Ty->getAs<TypedefType>();
517  if (!TD)
518  return false;
519 
520  TypedefNameDecl *TN = TD->getDecl();
521  if (!TN)
522  return false;
523 
524  return TN->hasAttr<CapabilityAttr>();
525 }
526 
527 static bool typeHasCapability(Sema &S, QualType Ty) {
529  return true;
530 
531  if (checkRecordTypeForCapability(S, Ty))
532  return true;
533 
534  return false;
535 }
536 
537 static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
538  // Capability expressions are simple expressions involving the boolean logic
539  // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
540  // a DeclRefExpr is found, its type should be checked to determine whether it
541  // is a capability or not.
542 
543  if (const auto *E = dyn_cast<DeclRefExpr>(Ex))
544  return typeHasCapability(S, E->getType());
545  else if (const auto *E = dyn_cast<CastExpr>(Ex))
546  return isCapabilityExpr(S, E->getSubExpr());
547  else if (const auto *E = dyn_cast<ParenExpr>(Ex))
548  return isCapabilityExpr(S, E->getSubExpr());
549  else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
550  if (E->getOpcode() == UO_LNot)
551  return isCapabilityExpr(S, E->getSubExpr());
552  return false;
553  } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
554  if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
555  return isCapabilityExpr(S, E->getLHS()) &&
556  isCapabilityExpr(S, E->getRHS());
557  return false;
558  }
559 
560  return false;
561 }
562 
563 /// \brief Checks that all attribute arguments, starting from Sidx, resolve to
564 /// a capability object.
565 /// \param Sidx The attribute argument index to start checking with.
566 /// \param ParamIdxOk Whether an argument can be indexing into a function
567 /// parameter list.
569  const AttributeList &Attr,
571  int Sidx = 0,
572  bool ParamIdxOk = false) {
573  for (unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
574  Expr *ArgExp = Attr.getArgAsExpr(Idx);
575 
576  if (ArgExp->isTypeDependent()) {
577  // FIXME -- need to check this again on template instantiation
578  Args.push_back(ArgExp);
579  continue;
580  }
581 
582  if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
583  if (StrLit->getLength() == 0 ||
584  (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
585  // Pass empty strings to the analyzer without warnings.
586  // Treat "*" as the universal lock.
587  Args.push_back(ArgExp);
588  continue;
589  }
590 
591  // We allow constant strings to be used as a placeholder for expressions
592  // that are not valid C++ syntax, but warn that they are ignored.
593  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
594  Attr.getName();
595  Args.push_back(ArgExp);
596  continue;
597  }
598 
599  QualType ArgTy = ArgExp->getType();
600 
601  // A pointer to member expression of the form &MyClass::mu is treated
602  // specially -- we need to look at the type of the member.
603  if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp))
604  if (UOp->getOpcode() == UO_AddrOf)
605  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
606  if (DRE->getDecl()->isCXXInstanceMember())
607  ArgTy = DRE->getDecl()->getType();
608 
609  // First see if we can just cast to record type, or pointer to record type.
610  const RecordType *RT = getRecordType(ArgTy);
611 
612  // Now check if we index into a record type function param.
613  if(!RT && ParamIdxOk) {
614  FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
615  IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp);
616  if(FD && IL) {
617  unsigned int NumParams = FD->getNumParams();
618  llvm::APInt ArgValue = IL->getValue();
619  uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
620  uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
621  if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
622  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
623  << Attr.getName() << Idx + 1 << NumParams;
624  continue;
625  }
626  ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
627  }
628  }
629 
630  // If the type does not have a capability, see if the components of the
631  // expression have capabilities. This allows for writing C code where the
632  // capability may be on the type, and the expression is a capability
633  // boolean logic expression. Eg) requires_capability(A || B && !C)
634  if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
635  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
636  << Attr.getName() << ArgTy;
637 
638  Args.push_back(ArgExp);
639  }
640 }
641 
642 //===----------------------------------------------------------------------===//
643 // Attribute Implementations
644 //===----------------------------------------------------------------------===//
645 
647  const AttributeList &Attr) {
648  if (!threadSafetyCheckIsPointer(S, D, Attr))
649  return;
650 
651  D->addAttr(::new (S.Context)
652  PtGuardedVarAttr(Attr.getRange(), S.Context,
654 }
655 
657  const AttributeList &Attr,
658  Expr* &Arg) {
660  // check that all arguments are lockable objects
661  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
662  unsigned Size = Args.size();
663  if (Size != 1)
664  return false;
665 
666  Arg = Args[0];
667 
668  return true;
669 }
670 
671 static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) {
672  Expr *Arg = nullptr;
673  if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
674  return;
675 
676  D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg,
678 }
679 
680 static void handlePtGuardedByAttr(Sema &S, Decl *D,
681  const AttributeList &Attr) {
682  Expr *Arg = nullptr;
683  if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
684  return;
685 
686  if (!threadSafetyCheckIsPointer(S, D, Attr))
687  return;
688 
689  D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
690  S.Context, Arg,
692 }
693 
695  const AttributeList &Attr,
696  SmallVectorImpl<Expr *> &Args) {
697  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
698  return false;
699 
700  // Check that this attribute only applies to lockable types.
701  QualType QT = cast<ValueDecl>(D)->getType();
702  if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
703  S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
704  << Attr.getName();
705  return false;
706  }
707 
708  // Check that all arguments are lockable objects.
709  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
710  if (Args.empty())
711  return false;
712 
713  return true;
714 }
715 
717  const AttributeList &Attr) {
719  if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
720  return;
721 
722  Expr **StartArg = &Args[0];
723  D->addAttr(::new (S.Context)
724  AcquiredAfterAttr(Attr.getRange(), S.Context,
725  StartArg, Args.size(),
727 }
728 
730  const AttributeList &Attr) {
732  if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
733  return;
734 
735  Expr **StartArg = &Args[0];
736  D->addAttr(::new (S.Context)
737  AcquiredBeforeAttr(Attr.getRange(), S.Context,
738  StartArg, Args.size(),
740 }
741 
743  const AttributeList &Attr,
744  SmallVectorImpl<Expr *> &Args) {
745  // zero or more arguments ok
746  // check that all arguments are lockable objects
747  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
748 
749  return true;
750 }
751 
753  const AttributeList &Attr) {
755  if (!checkLockFunAttrCommon(S, D, Attr, Args))
756  return;
757 
758  unsigned Size = Args.size();
759  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
760  D->addAttr(::new (S.Context)
761  AssertSharedLockAttr(Attr.getRange(), S.Context, StartArg, Size,
763 }
764 
766  const AttributeList &Attr) {
768  if (!checkLockFunAttrCommon(S, D, Attr, Args))
769  return;
770 
771  unsigned Size = Args.size();
772  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
773  D->addAttr(::new (S.Context)
774  AssertExclusiveLockAttr(Attr.getRange(), S.Context,
775  StartArg, Size,
777 }
778 
779 /// \brief Checks to be sure that the given parameter number is in bounds, and is
780 /// an integral type. Will emit appropriate diagnostics if this returns
781 /// false.
782 ///
783 /// FuncParamNo is expected to be from the user, so is base-1. AttrArgNo is used
784 /// to actually retrieve the argument, so it's base-0.
785 template <typename AttrInfo>
786 static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
787  const AttrInfo &Attr, Expr *AttrArg,
788  unsigned FuncParamNo, unsigned AttrArgNo,
789  bool AllowDependentType = false) {
790  uint64_t Idx;
791  if (!checkFunctionOrMethodParameterIndex(S, FD, Attr, FuncParamNo, AttrArg,
792  Idx))
793  return false;
794 
795  const ParmVarDecl *Param = FD->getParamDecl(Idx);
796  if (AllowDependentType && Param->getType()->isDependentType())
797  return true;
798  if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
799  SourceLocation SrcLoc = AttrArg->getLocStart();
800  S.Diag(SrcLoc, diag::err_attribute_integers_only)
801  << getAttrName(Attr) << Param->getSourceRange();
802  return false;
803  }
804  return true;
805 }
806 
807 /// \brief Checks to be sure that the given parameter number is in bounds, and is
808 /// an integral type. Will emit appropriate diagnostics if this returns false.
809 ///
810 /// FuncParamNo is expected to be from the user, so is base-1. AttrArgNo is used
811 /// to actually retrieve the argument, so it's base-0.
812 static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
813  const AttributeList &Attr,
814  unsigned FuncParamNo, unsigned AttrArgNo,
815  bool AllowDependentType = false) {
816  assert(Attr.isArgExpr(AttrArgNo) && "Expected expression argument");
817  return checkParamIsIntegerType(S, FD, Attr, Attr.getArgAsExpr(AttrArgNo),
818  FuncParamNo, AttrArgNo, AllowDependentType);
819 }
820 
821 static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
822  if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
823  !checkAttributeAtMostNumArgs(S, Attr, 2))
824  return;
825 
826  const auto *FD = cast<FunctionDecl>(D);
827  if (!FD->getReturnType()->isPointerType()) {
828  S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
829  << Attr.getName();
830  return;
831  }
832 
833  const Expr *SizeExpr = Attr.getArgAsExpr(0);
834  int SizeArgNo;
835  // Parameter indices are 1-indexed, hence Index=1
836  if (!checkPositiveIntArgument(S, Attr, SizeExpr, SizeArgNo, /*Index=*/1))
837  return;
838 
839  if (!checkParamIsIntegerType(S, FD, Attr, SizeArgNo, /*AttrArgNo=*/0))
840  return;
841 
842  // Args are 1-indexed, so 0 implies that the arg was not present
843  int NumberArgNo = 0;
844  if (Attr.getNumArgs() == 2) {
845  const Expr *NumberExpr = Attr.getArgAsExpr(1);
846  // Parameter indices are 1-based, hence Index=2
847  if (!checkPositiveIntArgument(S, Attr, NumberExpr, NumberArgNo,
848  /*Index=*/2))
849  return;
850 
851  if (!checkParamIsIntegerType(S, FD, Attr, NumberArgNo, /*AttrArgNo=*/1))
852  return;
853  }
854 
855  D->addAttr(::new (S.Context) AllocSizeAttr(
856  Attr.getRange(), S.Context, SizeArgNo, NumberArgNo,
858 }
859 
861  const AttributeList &Attr,
862  SmallVectorImpl<Expr *> &Args) {
863  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
864  return false;
865 
866  if (!isIntOrBool(Attr.getArgAsExpr(0))) {
867  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
868  << Attr.getName() << 1 << AANT_ArgumentIntOrBool;
869  return false;
870  }
871 
872  // check that all arguments are lockable objects
873  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 1);
874 
875  return true;
876 }
877 
879  const AttributeList &Attr) {
881  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
882  return;
883 
884  D->addAttr(::new (S.Context)
885  SharedTrylockFunctionAttr(Attr.getRange(), S.Context,
886  Attr.getArgAsExpr(0),
887  Args.data(), Args.size(),
889 }
890 
892  const AttributeList &Attr) {
894  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
895  return;
896 
897  D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
898  Attr.getRange(), S.Context, Attr.getArgAsExpr(0), Args.data(),
899  Args.size(), Attr.getAttributeSpellingListIndex()));
900 }
901 
903  const AttributeList &Attr) {
904  // check that the argument is lockable object
906  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
907  unsigned Size = Args.size();
908  if (Size == 0)
909  return;
910 
911  D->addAttr(::new (S.Context)
912  LockReturnedAttr(Attr.getRange(), S.Context, Args[0],
914 }
915 
917  const AttributeList &Attr) {
918  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
919  return;
920 
921  // check that all arguments are lockable objects
923  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
924  unsigned Size = Args.size();
925  if (Size == 0)
926  return;
927  Expr **StartArg = &Args[0];
928 
929  D->addAttr(::new (S.Context)
930  LocksExcludedAttr(Attr.getRange(), S.Context, StartArg, Size,
932 }
933 
935  const AttributeList &Attr,
936  Expr *&Cond, StringRef &Msg) {
937  Cond = Attr.getArgAsExpr(0);
938  if (!Cond->isTypeDependent()) {
939  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
940  if (Converted.isInvalid())
941  return false;
942  Cond = Converted.get();
943  }
944 
945  if (!S.checkStringLiteralArgumentAttr(Attr, 1, Msg))
946  return false;
947 
948  if (Msg.empty())
949  Msg = "<no message provided>";
950 
952  if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
953  !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
954  Diags)) {
955  S.Diag(Attr.getLoc(), diag::err_attr_cond_never_constant_expr)
956  << Attr.getName();
957  for (const PartialDiagnosticAt &PDiag : Diags)
958  S.Diag(PDiag.first, PDiag.second);
959  return false;
960  }
961  return true;
962 }
963 
964 static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
965  S.Diag(Attr.getLoc(), diag::ext_clang_enable_if);
966 
967  Expr *Cond;
968  StringRef Msg;
969  if (checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
970  D->addAttr(::new (S.Context)
971  EnableIfAttr(Attr.getRange(), S.Context, Cond, Msg,
973 }
974 
975 namespace {
976 /// Determines if a given Expr references any of the given function's
977 /// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
978 class ArgumentDependenceChecker
979  : public RecursiveASTVisitor<ArgumentDependenceChecker> {
980 #ifndef NDEBUG
981  const CXXRecordDecl *ClassType;
982 #endif
983  llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
984  bool Result;
985 
986 public:
987  ArgumentDependenceChecker(const FunctionDecl *FD) {
988 #ifndef NDEBUG
989  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
990  ClassType = MD->getParent();
991  else
992  ClassType = nullptr;
993 #endif
994  Parms.insert(FD->param_begin(), FD->param_end());
995  }
996 
997  bool referencesArgs(Expr *E) {
998  Result = false;
999  TraverseStmt(E);
1000  return Result;
1001  }
1002 
1003  bool VisitCXXThisExpr(CXXThisExpr *E) {
1004  assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&
1005  "`this` doesn't refer to the enclosing class?");
1006  Result = true;
1007  return false;
1008  }
1009 
1010  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
1011  if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
1012  if (Parms.count(PVD)) {
1013  Result = true;
1014  return false;
1015  }
1016  return true;
1017  }
1018 };
1019 }
1020 
1021 static void handleDiagnoseIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1022  S.Diag(Attr.getLoc(), diag::ext_clang_diagnose_if);
1023 
1024  Expr *Cond;
1025  StringRef Msg;
1026  if (!checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
1027  return;
1028 
1029  StringRef DiagTypeStr;
1030  if (!S.checkStringLiteralArgumentAttr(Attr, 2, DiagTypeStr))
1031  return;
1032 
1033  DiagnoseIfAttr::DiagnosticType DiagType;
1034  if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
1035  S.Diag(Attr.getArgAsExpr(2)->getLocStart(),
1036  diag::err_diagnose_if_invalid_diagnostic_type);
1037  return;
1038  }
1039 
1040  bool ArgDependent = false;
1041  if (const auto *FD = dyn_cast<FunctionDecl>(D))
1042  ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
1043  D->addAttr(::new (S.Context) DiagnoseIfAttr(
1044  Attr.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D),
1046 }
1047 
1049  const AttributeList &Attr) {
1050  if (D->hasAttr<PassObjectSizeAttr>()) {
1051  S.Diag(D->getLocStart(), diag::err_attribute_only_once_per_parameter)
1052  << Attr.getName();
1053  return;
1054  }
1055 
1056  Expr *E = Attr.getArgAsExpr(0);
1057  uint32_t Type;
1058  if (!checkUInt32Argument(S, Attr, E, Type, /*Idx=*/1))
1059  return;
1060 
1061  // pass_object_size's argument is passed in as the second argument of
1062  // __builtin_object_size. So, it has the same constraints as that second
1063  // argument; namely, it must be in the range [0, 3].
1064  if (Type > 3) {
1065  S.Diag(E->getLocStart(), diag::err_attribute_argument_outof_range)
1066  << Attr.getName() << 0 << 3 << E->getSourceRange();
1067  return;
1068  }
1069 
1070  // pass_object_size is only supported on constant pointer parameters; as a
1071  // kindness to users, we allow the parameter to be non-const for declarations.
1072  // At this point, we have no clue if `D` belongs to a function declaration or
1073  // definition, so we defer the constness check until later.
1074  if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1075  S.Diag(D->getLocStart(), diag::err_attribute_pointers_only)
1076  << Attr.getName() << 1;
1077  return;
1078  }
1079 
1080  D->addAttr(::new (S.Context)
1081  PassObjectSizeAttr(Attr.getRange(), S.Context, (int)Type,
1083 }
1084 
1085 static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1086  ConsumableAttr::ConsumedState DefaultState;
1087 
1088  if (Attr.isArgIdent(0)) {
1089  IdentifierLoc *IL = Attr.getArgAsIdent(0);
1090  if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1091  DefaultState)) {
1092  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1093  << Attr.getName() << IL->Ident;
1094  return;
1095  }
1096  } else {
1097  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
1098  << Attr.getName() << AANT_ArgumentIdentifier;
1099  return;
1100  }
1101 
1102  D->addAttr(::new (S.Context)
1103  ConsumableAttr(Attr.getRange(), S.Context, DefaultState,
1105 }
1106 
1108  const AttributeList &Attr) {
1109  ASTContext &CurrContext = S.getASTContext();
1110  QualType ThisType = MD->getThisType(CurrContext)->getPointeeType();
1111 
1112  if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1113  if (!RD->hasAttr<ConsumableAttr>()) {
1114  S.Diag(Attr.getLoc(), diag::warn_attr_on_unconsumable_class) <<
1115  RD->getNameAsString();
1116 
1117  return false;
1118  }
1119  }
1120 
1121  return true;
1122 }
1123 
1125  const AttributeList &Attr) {
1126  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
1127  return;
1128 
1129  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1130  return;
1131 
1133  for (unsigned ArgIndex = 0; ArgIndex < Attr.getNumArgs(); ++ArgIndex) {
1134  CallableWhenAttr::ConsumedState CallableState;
1135 
1136  StringRef StateString;
1137  SourceLocation Loc;
1138  if (Attr.isArgIdent(ArgIndex)) {
1139  IdentifierLoc *Ident = Attr.getArgAsIdent(ArgIndex);
1140  StateString = Ident->Ident->getName();
1141  Loc = Ident->Loc;
1142  } else {
1143  if (!S.checkStringLiteralArgumentAttr(Attr, ArgIndex, StateString, &Loc))
1144  return;
1145  }
1146 
1147  if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1148  CallableState)) {
1149  S.Diag(Loc, diag::warn_attribute_type_not_supported)
1150  << Attr.getName() << StateString;
1151  return;
1152  }
1153 
1154  States.push_back(CallableState);
1155  }
1156 
1157  D->addAttr(::new (S.Context)
1158  CallableWhenAttr(Attr.getRange(), S.Context, States.data(),
1159  States.size(), Attr.getAttributeSpellingListIndex()));
1160 }
1161 
1163  const AttributeList &Attr) {
1165 
1166  if (Attr.isArgIdent(0)) {
1167  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1168  StringRef StateString = Ident->Ident->getName();
1169 
1170  if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1171  ParamState)) {
1172  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1173  << Attr.getName() << StateString;
1174  return;
1175  }
1176  } else {
1177  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1178  Attr.getName() << AANT_ArgumentIdentifier;
1179  return;
1180  }
1181 
1182  // FIXME: This check is currently being done in the analysis. It can be
1183  // enabled here only after the parser propagates attributes at
1184  // template specialization definition, not declaration.
1185  //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1186  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1187  //
1188  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1189  // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1190  // ReturnType.getAsString();
1191  // return;
1192  //}
1193 
1194  D->addAttr(::new (S.Context)
1195  ParamTypestateAttr(Attr.getRange(), S.Context, ParamState,
1197 }
1198 
1200  const AttributeList &Attr) {
1202 
1203  if (Attr.isArgIdent(0)) {
1204  IdentifierLoc *IL = Attr.getArgAsIdent(0);
1205  if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1206  ReturnState)) {
1207  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1208  << Attr.getName() << IL->Ident;
1209  return;
1210  }
1211  } else {
1212  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1213  Attr.getName() << AANT_ArgumentIdentifier;
1214  return;
1215  }
1216 
1217  // FIXME: This check is currently being done in the analysis. It can be
1218  // enabled here only after the parser propagates attributes at
1219  // template specialization definition, not declaration.
1220  //QualType ReturnType;
1221  //
1222  //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1223  // ReturnType = Param->getType();
1224  //
1225  //} else if (const CXXConstructorDecl *Constructor =
1226  // dyn_cast<CXXConstructorDecl>(D)) {
1227  // ReturnType = Constructor->getThisType(S.getASTContext())->getPointeeType();
1228  //
1229  //} else {
1230  //
1231  // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1232  //}
1233  //
1234  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1235  //
1236  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1237  // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1238  // ReturnType.getAsString();
1239  // return;
1240  //}
1241 
1242  D->addAttr(::new (S.Context)
1243  ReturnTypestateAttr(Attr.getRange(), S.Context, ReturnState,
1245 }
1246 
1248  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1249  return;
1250 
1252  if (Attr.isArgIdent(0)) {
1253  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1254  StringRef Param = Ident->Ident->getName();
1255  if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1256  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1257  << Attr.getName() << Param;
1258  return;
1259  }
1260  } else {
1261  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1262  Attr.getName() << AANT_ArgumentIdentifier;
1263  return;
1264  }
1265 
1266  D->addAttr(::new (S.Context)
1267  SetTypestateAttr(Attr.getRange(), S.Context, NewState,
1269 }
1270 
1272  const AttributeList &Attr) {
1273  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1274  return;
1275 
1277  if (Attr.isArgIdent(0)) {
1278  IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1279  StringRef Param = Ident->Ident->getName();
1280  if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1281  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1282  << Attr.getName() << Param;
1283  return;
1284  }
1285  } else {
1286  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1287  Attr.getName() << AANT_ArgumentIdentifier;
1288  return;
1289  }
1290 
1291  D->addAttr(::new (S.Context)
1292  TestTypestateAttr(Attr.getRange(), S.Context, TestState,
1294 }
1295 
1296 static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
1297  const AttributeList &Attr) {
1298  // Remember this typedef decl, we will need it later for diagnostics.
1299  S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1300 }
1301 
1302 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1303  if (TagDecl *TD = dyn_cast<TagDecl>(D))
1304  TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context,
1306  else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1307  // Report warning about changed offset in the newer compiler versions.
1308  if (!FD->getType()->isDependentType() &&
1309  !FD->getType()->isIncompleteType() && FD->isBitField() &&
1310  S.Context.getTypeAlign(FD->getType()) <= 8)
1311  S.Diag(Attr.getLoc(), diag::warn_attribute_packed_for_bitfield);
1312 
1313  FD->addAttr(::new (S.Context) PackedAttr(
1314  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1315  } else
1316  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1317 }
1318 
1319 static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
1320  // The IBOutlet/IBOutletCollection attributes only apply to instance
1321  // variables or properties of Objective-C classes. The outlet must also
1322  // have an object reference type.
1323  if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) {
1324  if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1325  S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1326  << Attr.getName() << VD->getType() << 0;
1327  return false;
1328  }
1329  }
1330  else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1331  if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1332  S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1333  << Attr.getName() << PD->getType() << 1;
1334  return false;
1335  }
1336  }
1337  else {
1338  S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
1339  return false;
1340  }
1341 
1342  return true;
1343 }
1344 
1345 static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
1346  if (!checkIBOutletCommon(S, D, Attr))
1347  return;
1348 
1349  D->addAttr(::new (S.Context)
1350  IBOutletAttr(Attr.getRange(), S.Context,
1352 }
1353 
1355  const AttributeList &Attr) {
1356 
1357  // The iboutletcollection attribute can have zero or one arguments.
1358  if (Attr.getNumArgs() > 1) {
1359  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1360  << Attr.getName() << 1;
1361  return;
1362  }
1363 
1364  if (!checkIBOutletCommon(S, D, Attr))
1365  return;
1366 
1367  ParsedType PT;
1368 
1369  if (Attr.hasParsedType())
1370  PT = Attr.getTypeArg();
1371  else {
1372  PT = S.getTypeName(S.Context.Idents.get("NSObject"), Attr.getLoc(),
1374  if (!PT) {
1375  S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1376  return;
1377  }
1378  }
1379 
1380  TypeSourceInfo *QTLoc = nullptr;
1381  QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1382  if (!QTLoc)
1383  QTLoc = S.Context.getTrivialTypeSourceInfo(QT, Attr.getLoc());
1384 
1385  // Diagnose use of non-object type in iboutletcollection attribute.
1386  // FIXME. Gnu attribute extension ignores use of builtin types in
1387  // attributes. So, __attribute__((iboutletcollection(char))) will be
1388  // treated as __attribute__((iboutletcollection())).
1389  if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1390  S.Diag(Attr.getLoc(),
1391  QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1392  : diag::err_iboutletcollection_type) << QT;
1393  return;
1394  }
1395 
1396  D->addAttr(::new (S.Context)
1397  IBOutletCollectionAttr(Attr.getRange(), S.Context, QTLoc,
1399 }
1400 
1402  if (RefOkay) {
1403  if (T->isReferenceType())
1404  return true;
1405  } else {
1406  T = T.getNonReferenceType();
1407  }
1408 
1409  // The nonnull attribute, and other similar attributes, can be applied to a
1410  // transparent union that contains a pointer type.
1411  if (const RecordType *UT = T->getAsUnionType()) {
1412  if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1413  RecordDecl *UD = UT->getDecl();
1414  for (const auto *I : UD->fields()) {
1415  QualType QT = I->getType();
1416  if (QT->isAnyPointerType() || QT->isBlockPointerType())
1417  return true;
1418  }
1419  }
1420  }
1421 
1422  return T->isAnyPointerType() || T->isBlockPointerType();
1423 }
1424 
1426  SourceRange AttrParmRange,
1427  SourceRange TypeRange,
1428  bool isReturnValue = false) {
1429  if (!S.isValidPointerAttrType(T)) {
1430  if (isReturnValue)
1431  S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1432  << Attr.getName() << AttrParmRange << TypeRange;
1433  else
1434  S.Diag(Attr.getLoc(), diag::warn_attribute_pointers_only)
1435  << Attr.getName() << AttrParmRange << TypeRange << 0;
1436  return false;
1437  }
1438  return true;
1439 }
1440 
1441 static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1442  SmallVector<unsigned, 8> NonNullArgs;
1443  for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
1444  Expr *Ex = Attr.getArgAsExpr(I);
1445  uint64_t Idx;
1446  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, I + 1, Ex, Idx))
1447  return;
1448 
1449  // Is the function argument a pointer type?
1450  if (Idx < getFunctionOrMethodNumParams(D) &&
1452  Ex->getSourceRange(),
1454  continue;
1455 
1456  NonNullArgs.push_back(Idx);
1457  }
1458 
1459  // If no arguments were specified to __attribute__((nonnull)) then all pointer
1460  // arguments have a nonnull attribute; warn if there aren't any. Skip this
1461  // check if the attribute came from a macro expansion or a template
1462  // instantiation.
1463  if (NonNullArgs.empty() && Attr.getLoc().isFileID() &&
1464  !S.inTemplateInstantiation()) {
1465  bool AnyPointers = isFunctionOrMethodVariadic(D);
1466  for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1467  I != E && !AnyPointers; ++I) {
1469  if (T->isDependentType() || S.isValidPointerAttrType(T))
1470  AnyPointers = true;
1471  }
1472 
1473  if (!AnyPointers)
1474  S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1475  }
1476 
1477  unsigned *Start = NonNullArgs.data();
1478  unsigned Size = NonNullArgs.size();
1479  llvm::array_pod_sort(Start, Start + Size);
1480  D->addAttr(::new (S.Context)
1481  NonNullAttr(Attr.getRange(), S.Context, Start, Size,
1483 }
1484 
1486  const AttributeList &Attr) {
1487  if (Attr.getNumArgs() > 0) {
1488  if (D->getFunctionType()) {
1489  handleNonNullAttr(S, D, Attr);
1490  } else {
1491  S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1492  << D->getSourceRange();
1493  }
1494  return;
1495  }
1496 
1497  // Is the argument a pointer type?
1498  if (!attrNonNullArgCheck(S, D->getType(), Attr, SourceRange(),
1499  D->getSourceRange()))
1500  return;
1501 
1502  D->addAttr(::new (S.Context)
1503  NonNullAttr(Attr.getRange(), S.Context, nullptr, 0,
1505 }
1506 
1508  const AttributeList &Attr) {
1509  QualType ResultType = getFunctionOrMethodResultType(D);
1511  if (!attrNonNullArgCheck(S, ResultType, Attr, SourceRange(), SR,
1512  /* isReturnValue */ true))
1513  return;
1514 
1515  D->addAttr(::new (S.Context)
1516  ReturnsNonNullAttr(Attr.getRange(), S.Context,
1518 }
1519 
1521  const AttributeList &Attr) {
1522  Expr *E = Attr.getArgAsExpr(0),
1523  *OE = Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr;
1524  S.AddAssumeAlignedAttr(Attr.getRange(), D, E, OE,
1526 }
1527 
1528 static void handleAllocAlignAttr(Sema &S, Decl *D,
1529  const AttributeList &Attr) {
1530  S.AddAllocAlignAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
1532 }
1533 
1535  Expr *OE, unsigned SpellingListIndex) {
1536  QualType ResultType = getFunctionOrMethodResultType(D);
1538 
1539  AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1540  SourceLocation AttrLoc = AttrRange.getBegin();
1541 
1542  if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1543  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1544  << &TmpAttr << AttrRange << SR;
1545  return;
1546  }
1547 
1548  if (!E->isValueDependent()) {
1549  llvm::APSInt I(64);
1550  if (!E->isIntegerConstantExpr(I, Context)) {
1551  if (OE)
1552  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1553  << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1554  << E->getSourceRange();
1555  else
1556  Diag(AttrLoc, diag::err_attribute_argument_type)
1557  << &TmpAttr << AANT_ArgumentIntegerConstant
1558  << E->getSourceRange();
1559  return;
1560  }
1561 
1562  if (!I.isPowerOf2()) {
1563  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1564  << E->getSourceRange();
1565  return;
1566  }
1567  }
1568 
1569  if (OE) {
1570  if (!OE->isValueDependent()) {
1571  llvm::APSInt I(64);
1572  if (!OE->isIntegerConstantExpr(I, Context)) {
1573  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1574  << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1575  << OE->getSourceRange();
1576  return;
1577  }
1578  }
1579  }
1580 
1581  D->addAttr(::new (Context)
1582  AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1583 }
1584 
1585 void Sema::AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
1586  unsigned SpellingListIndex) {
1587  QualType ResultType = getFunctionOrMethodResultType(D);
1588 
1589  AllocAlignAttr TmpAttr(AttrRange, Context, 0, SpellingListIndex);
1590  SourceLocation AttrLoc = AttrRange.getBegin();
1591 
1592  if (!ResultType->isDependentType() &&
1593  !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1594  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1595  << &TmpAttr << AttrRange << getFunctionOrMethodResultSourceRange(D);
1596  return;
1597  }
1598 
1599  uint64_t IndexVal;
1600  const auto *FuncDecl = cast<FunctionDecl>(D);
1601  if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1602  /*AttrArgNo=*/1, ParamExpr,
1603  IndexVal))
1604  return;
1605 
1606  QualType Ty = getFunctionOrMethodParamType(D, IndexVal);
1607  if (!Ty->isDependentType() && !Ty->isIntegralType(Context)) {
1608  Diag(ParamExpr->getLocStart(), diag::err_attribute_integers_only)
1609  << &TmpAttr << FuncDecl->getParamDecl(IndexVal)->getSourceRange();
1610  return;
1611  }
1612 
1613  // We cannot use the Idx returned from checkFunctionOrMethodParameterIndex
1614  // because that has corrected for the implicit this parameter, and is zero-
1615  // based. The attribute expects what the user wrote explicitly.
1616  llvm::APSInt Val;
1617  ParamExpr->EvaluateAsInt(Val, Context);
1618 
1619  D->addAttr(::new (Context) AllocAlignAttr(
1620  AttrRange, Context, Val.getZExtValue(), SpellingListIndex));
1621 }
1622 
1623 /// Normalize the attribute, __foo__ becomes foo.
1624 /// Returns true if normalization was applied.
1625 static bool normalizeName(StringRef &AttrName) {
1626  if (AttrName.size() > 4 && AttrName.startswith("__") &&
1627  AttrName.endswith("__")) {
1628  AttrName = AttrName.drop_front(2).drop_back(2);
1629  return true;
1630  }
1631  return false;
1632 }
1633 
1634 static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
1635  // This attribute must be applied to a function declaration. The first
1636  // argument to the attribute must be an identifier, the name of the resource,
1637  // for example: malloc. The following arguments must be argument indexes, the
1638  // arguments must be of integer type for Returns, otherwise of pointer type.
1639  // The difference between Holds and Takes is that a pointer may still be used
1640  // after being held. free() should be __attribute((ownership_takes)), whereas
1641  // a list append function may well be __attribute((ownership_holds)).
1642 
1643  if (!AL.isArgIdent(0)) {
1644  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1645  << AL.getName() << 1 << AANT_ArgumentIdentifier;
1646  return;
1647  }
1648 
1649  // Figure out our Kind.
1650  OwnershipAttr::OwnershipKind K =
1651  OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1652  AL.getAttributeSpellingListIndex()).getOwnKind();
1653 
1654  // Check arguments.
1655  switch (K) {
1656  case OwnershipAttr::Takes:
1657  case OwnershipAttr::Holds:
1658  if (AL.getNumArgs() < 2) {
1659  S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments)
1660  << AL.getName() << 2;
1661  return;
1662  }
1663  break;
1664  case OwnershipAttr::Returns:
1665  if (AL.getNumArgs() > 2) {
1666  S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
1667  << AL.getName() << 1;
1668  return;
1669  }
1670  break;
1671  }
1672 
1674 
1675  StringRef ModuleName = Module->getName();
1676  if (normalizeName(ModuleName)) {
1677  Module = &S.PP.getIdentifierTable().get(ModuleName);
1678  }
1679 
1680  SmallVector<unsigned, 8> OwnershipArgs;
1681  for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1682  Expr *Ex = AL.getArgAsExpr(i);
1683  uint64_t Idx;
1684  if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1685  return;
1686 
1687  // Is the function argument a pointer type?
1689  int Err = -1; // No error
1690  switch (K) {
1691  case OwnershipAttr::Takes:
1692  case OwnershipAttr::Holds:
1693  if (!T->isAnyPointerType() && !T->isBlockPointerType())
1694  Err = 0;
1695  break;
1696  case OwnershipAttr::Returns:
1697  if (!T->isIntegerType())
1698  Err = 1;
1699  break;
1700  }
1701  if (-1 != Err) {
1702  S.Diag(AL.getLoc(), diag::err_ownership_type) << AL.getName() << Err
1703  << Ex->getSourceRange();
1704  return;
1705  }
1706 
1707  // Check we don't have a conflict with another ownership attribute.
1708  for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1709  // Cannot have two ownership attributes of different kinds for the same
1710  // index.
1711  if (I->getOwnKind() != K && I->args_end() !=
1712  std::find(I->args_begin(), I->args_end(), Idx)) {
1713  S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1714  << AL.getName() << I;
1715  return;
1716  } else if (K == OwnershipAttr::Returns &&
1717  I->getOwnKind() == OwnershipAttr::Returns) {
1718  // A returns attribute conflicts with any other returns attribute using
1719  // a different index. Note, diagnostic reporting is 1-based, but stored
1720  // argument indexes are 0-based.
1721  if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1722  S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1723  << *(I->args_begin()) + 1;
1724  if (I->args_size())
1725  S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1726  << (unsigned)Idx + 1 << Ex->getSourceRange();
1727  return;
1728  }
1729  }
1730  }
1731  OwnershipArgs.push_back(Idx);
1732  }
1733 
1734  unsigned* start = OwnershipArgs.data();
1735  unsigned size = OwnershipArgs.size();
1736  llvm::array_pod_sort(start, start + size);
1737 
1738  D->addAttr(::new (S.Context)
1739  OwnershipAttr(AL.getLoc(), S.Context, Module, start, size,
1741 }
1742 
1743 static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1744  // Check the attribute arguments.
1745  if (Attr.getNumArgs() > 1) {
1746  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1747  << Attr.getName() << 1;
1748  return;
1749  }
1750 
1751  NamedDecl *nd = cast<NamedDecl>(D);
1752 
1753  // gcc rejects
1754  // class c {
1755  // static int a __attribute__((weakref ("v2")));
1756  // static int b() __attribute__((weakref ("f3")));
1757  // };
1758  // and ignores the attributes of
1759  // void f(void) {
1760  // static int a __attribute__((weakref ("v2")));
1761  // }
1762  // we reject them
1763  const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1764  if (!Ctx->isFileContext()) {
1765  S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context)
1766  << nd;
1767  return;
1768  }
1769 
1770  // The GCC manual says
1771  //
1772  // At present, a declaration to which `weakref' is attached can only
1773  // be `static'.
1774  //
1775  // It also says
1776  //
1777  // Without a TARGET,
1778  // given as an argument to `weakref' or to `alias', `weakref' is
1779  // equivalent to `weak'.
1780  //
1781  // gcc 4.4.1 will accept
1782  // int a7 __attribute__((weakref));
1783  // as
1784  // int a7 __attribute__((weak));
1785  // This looks like a bug in gcc. We reject that for now. We should revisit
1786  // it if this behaviour is actually used.
1787 
1788  // GCC rejects
1789  // static ((alias ("y"), weakref)).
1790  // Should we? How to check that weakref is before or after alias?
1791 
1792  // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1793  // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1794  // StringRef parameter it was given anyway.
1795  StringRef Str;
1796  if (Attr.getNumArgs() && S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1797  // GCC will accept anything as the argument of weakref. Should we
1798  // check for an existing decl?
1799  D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1801 
1802  D->addAttr(::new (S.Context)
1803  WeakRefAttr(Attr.getRange(), S.Context,
1805 }
1806 
1807 static void handleIFuncAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1808  StringRef Str;
1809  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1810  return;
1811 
1812  // Aliases should be on declarations, not definitions.
1813  const auto *FD = cast<FunctionDecl>(D);
1814  if (FD->isThisDeclarationADefinition()) {
1815  S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD << 1;
1816  return;
1817  }
1818  // FIXME: it should be handled as a target specific attribute.
1819  if (S.Context.getTargetInfo().getTriple().getObjectFormat() !=
1820  llvm::Triple::ELF) {
1821  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1822  return;
1823  }
1824 
1825  D->addAttr(::new (S.Context) IFuncAttr(Attr.getRange(), S.Context, Str,
1827 }
1828 
1829 static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1830  StringRef Str;
1831  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1832  return;
1833 
1834  if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1835  S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1836  return;
1837  }
1838  if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
1839  S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_nvptx);
1840  }
1841 
1842  // Aliases should be on declarations, not definitions.
1843  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
1844  if (FD->isThisDeclarationADefinition()) {
1845  S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD << 0;
1846  return;
1847  }
1848  } else {
1849  const auto *VD = cast<VarDecl>(D);
1850  if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1851  S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << VD << 0;
1852  return;
1853  }
1854  }
1855 
1856  // FIXME: check if target symbol exists in current file
1857 
1858  D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1860 }
1861 
1862 static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1863  if (checkAttrMutualExclusion<HotAttr>(S, D, Attr.getRange(), Attr.getName()))
1864  return;
1865 
1866  D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context,
1868 }
1869 
1870 static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1871  if (checkAttrMutualExclusion<ColdAttr>(S, D, Attr.getRange(), Attr.getName()))
1872  return;
1873 
1874  D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context,
1876 }
1877 
1878 static void handleTLSModelAttr(Sema &S, Decl *D,
1879  const AttributeList &Attr) {
1880  StringRef Model;
1881  SourceLocation LiteralLoc;
1882  // Check that it is a string.
1883  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Model, &LiteralLoc))
1884  return;
1885 
1886  // Check that the value.
1887  if (Model != "global-dynamic" && Model != "local-dynamic"
1888  && Model != "initial-exec" && Model != "local-exec") {
1889  S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1890  return;
1891  }
1892 
1893  D->addAttr(::new (S.Context)
1894  TLSModelAttr(Attr.getRange(), S.Context, Model,
1896 }
1897 
1898 static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1899  QualType ResultType = getFunctionOrMethodResultType(D);
1900  if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1901  D->addAttr(::new (S.Context) RestrictAttr(
1902  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1903  return;
1904  }
1905 
1906  S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1908 }
1909 
1910 static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1911  if (S.LangOpts.CPlusPlus) {
1912  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
1913  << Attr.getName() << AttributeLangSupport::Cpp;
1914  return;
1915  }
1916 
1917  if (CommonAttr *CA = S.mergeCommonAttr(D, Attr.getRange(), Attr.getName(),
1919  D->addAttr(CA);
1920 }
1921 
1922 static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1923  if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, Attr.getRange(),
1924  Attr.getName()))
1925  return;
1926 
1927  if (Attr.isDeclspecAttribute()) {
1928  const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
1929  const auto &Arch = Triple.getArch();
1930  if (Arch != llvm::Triple::x86 &&
1931  (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
1932  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_on_arch)
1933  << Attr.getName() << Triple.getArchName();
1934  return;
1935  }
1936  }
1937 
1938  D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context,
1940 }
1941 
1942 static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
1943  if (hasDeclarator(D)) return;
1944 
1945  if (S.CheckNoReturnAttr(attr))
1946  return;
1947 
1948  if (!isa<ObjCMethodDecl>(D)) {
1949  S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1950  << attr.getName() << ExpectedFunctionOrMethod;
1951  return;
1952  }
1953 
1954  D->addAttr(::new (S.Context) NoReturnAttr(
1955  attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
1956 }
1957 
1959  const AttributeList &Attr) {
1960  if (S.CheckNoCallerSavedRegsAttr(Attr))
1961  return;
1962 
1963  D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(
1964  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1965 }
1966 
1968  if (!checkAttributeNumArgs(*this, attr, 0)) {
1969  attr.setInvalid();
1970  return true;
1971  }
1972 
1973  return false;
1974 }
1975 
1977  // Check whether the attribute is valid on the current target.
1978  if (!Attr.existsInTarget(Context.getTargetInfo())) {
1979  Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored) << Attr.getName();
1980  Attr.setInvalid();
1981  return true;
1982  }
1983 
1984  if (!checkAttributeNumArgs(*this, Attr, 0)) {
1985  Attr.setInvalid();
1986  return true;
1987  }
1988 
1989  return false;
1990 }
1991 
1993  const AttributeList &Attr) {
1994 
1995  // The checking path for 'noreturn' and 'analyzer_noreturn' are different
1996  // because 'analyzer_noreturn' does not impact the type.
1997  if (!isFunctionOrMethodOrBlock(D)) {
1998  ValueDecl *VD = dyn_cast<ValueDecl>(D);
1999  if (!VD || (!VD->getType()->isBlockPointerType() &&
2000  !VD->getType()->isFunctionPointerType())) {
2001  S.Diag(Attr.getLoc(),
2002  Attr.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
2003  : diag::warn_attribute_wrong_decl_type)
2005  return;
2006  }
2007  }
2008 
2009  D->addAttr(::new (S.Context)
2010  AnalyzerNoReturnAttr(Attr.getRange(), S.Context,
2012 }
2013 
2014 // PS3 PPU-specific.
2015 static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2016 /*
2017  Returning a Vector Class in Registers
2018 
2019  According to the PPU ABI specifications, a class with a single member of
2020  vector type is returned in memory when used as the return value of a function.
2021  This results in inefficient code when implementing vector classes. To return
2022  the value in a single vector register, add the vecreturn attribute to the
2023  class definition. This attribute is also applicable to struct types.
2024 
2025  Example:
2026 
2027  struct Vector
2028  {
2029  __vector float xyzw;
2030  } __attribute__((vecreturn));
2031 
2032  Vector Add(Vector lhs, Vector rhs)
2033  {
2034  Vector result;
2035  result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2036  return result; // This will be returned in a register
2037  }
2038 */
2039  if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2040  S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << A;
2041  return;
2042  }
2043 
2044  RecordDecl *record = cast<RecordDecl>(D);
2045  int count = 0;
2046 
2047  if (!isa<CXXRecordDecl>(record)) {
2048  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2049  return;
2050  }
2051 
2052  if (!cast<CXXRecordDecl>(record)->isPOD()) {
2053  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2054  return;
2055  }
2056 
2057  for (const auto *I : record->fields()) {
2058  if ((count == 1) || !I->getType()->isVectorType()) {
2059  S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2060  return;
2061  }
2062  count++;
2063  }
2064 
2065  D->addAttr(::new (S.Context)
2066  VecReturnAttr(Attr.getRange(), S.Context,
2068 }
2069 
2071  const AttributeList &Attr) {
2072  if (isa<ParmVarDecl>(D)) {
2073  // [[carries_dependency]] can only be applied to a parameter if it is a
2074  // parameter of a function declaration or lambda.
2076  S.Diag(Attr.getLoc(),
2077  diag::err_carries_dependency_param_not_function_decl);
2078  return;
2079  }
2080  }
2081 
2082  D->addAttr(::new (S.Context) CarriesDependencyAttr(
2083  Attr.getRange(), S.Context,
2085 }
2086 
2088  const AttributeList &Attr) {
2089  if (checkAttrMutualExclusion<AlwaysInlineAttr>(S, D, Attr.getRange(),
2090  Attr.getName()))
2091  return;
2092 
2093  D->addAttr(::new (S.Context) NotTailCalledAttr(
2094  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2095 }
2096 
2098  const AttributeList &Attr) {
2099  if (checkAttrMutualExclusion<NakedAttr>(S, D, Attr.getRange(),
2100  Attr.getName()))
2101  return;
2102 
2103  D->addAttr(::new (S.Context) DisableTailCallsAttr(
2104  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2105 }
2106 
2107 static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2108  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2109  if (VD->hasLocalStorage()) {
2110  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2111  return;
2112  }
2113  } else if (!isFunctionOrMethod(D)) {
2114  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2115  << Attr.getName() << ExpectedVariableOrFunction;
2116  return;
2117  }
2118 
2119  D->addAttr(::new (S.Context)
2120  UsedAttr(Attr.getRange(), S.Context,
2122 }
2123 
2124 static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2125  bool IsCXX1zAttr = Attr.isCXX11Attribute() && !Attr.getScopeName();
2126 
2127  if (IsCXX1zAttr && isa<VarDecl>(D)) {
2128  // The C++1z spelling of this attribute cannot be applied to a static data
2129  // member per [dcl.attr.unused]p2.
2130  if (cast<VarDecl>(D)->isStaticDataMember()) {
2131  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2132  << Attr.getName() << ExpectedForMaybeUnused;
2133  return;
2134  }
2135  }
2136 
2137  // If this is spelled as the standard C++1z attribute, but not in C++1z, warn
2138  // about using it as an extension.
2139  if (!S.getLangOpts().CPlusPlus1z && IsCXX1zAttr)
2140  S.Diag(Attr.getLoc(), diag::ext_cxx1z_attr) << Attr.getName();
2141 
2142  D->addAttr(::new (S.Context) UnusedAttr(
2143  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2144 }
2145 
2146 static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2147  uint32_t priority = ConstructorAttr::DefaultPriority;
2148  if (Attr.getNumArgs() &&
2149  !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
2150  return;
2151 
2152  D->addAttr(::new (S.Context)
2153  ConstructorAttr(Attr.getRange(), S.Context, priority,
2155 }
2156 
2157 static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2158  uint32_t priority = DestructorAttr::DefaultPriority;
2159  if (Attr.getNumArgs() &&
2160  !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
2161  return;
2162 
2163  D->addAttr(::new (S.Context)
2164  DestructorAttr(Attr.getRange(), S.Context, priority,
2166 }
2167 
2168 template <typename AttrTy>
2170  const AttributeList &Attr) {
2171  // Handle the case where the attribute has a text message.
2172  StringRef Str;
2173  if (Attr.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
2174  return;
2175 
2176  D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str,
2178 }
2179 
2181  const AttributeList &Attr) {
2182  if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2183  S.Diag(Attr.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2184  << Attr.getName() << Attr.getRange();
2185  return;
2186  }
2187 
2188  D->addAttr(::new (S.Context)
2189  ObjCExplicitProtocolImplAttr(Attr.getRange(), S.Context,
2191 }
2192 
2194  IdentifierInfo *Platform,
2195  VersionTuple Introduced,
2196  VersionTuple Deprecated,
2197  VersionTuple Obsoleted) {
2198  StringRef PlatformName
2199  = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2200  if (PlatformName.empty())
2201  PlatformName = Platform->getName();
2202 
2203  // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2204  // of these steps are needed).
2205  if (!Introduced.empty() && !Deprecated.empty() &&
2206  !(Introduced <= Deprecated)) {
2207  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2208  << 1 << PlatformName << Deprecated.getAsString()
2209  << 0 << Introduced.getAsString();
2210  return true;
2211  }
2212 
2213  if (!Introduced.empty() && !Obsoleted.empty() &&
2214  !(Introduced <= Obsoleted)) {
2215  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2216  << 2 << PlatformName << Obsoleted.getAsString()
2217  << 0 << Introduced.getAsString();
2218  return true;
2219  }
2220 
2221  if (!Deprecated.empty() && !Obsoleted.empty() &&
2222  !(Deprecated <= Obsoleted)) {
2223  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2224  << 2 << PlatformName << Obsoleted.getAsString()
2225  << 1 << Deprecated.getAsString();
2226  return true;
2227  }
2228 
2229  return false;
2230 }
2231 
2232 /// \brief Check whether the two versions match.
2233 ///
2234 /// If either version tuple is empty, then they are assumed to match. If
2235 /// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2236 static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2237  bool BeforeIsOkay) {
2238  if (X.empty() || Y.empty())
2239  return true;
2240 
2241  if (X == Y)
2242  return true;
2243 
2244  if (BeforeIsOkay && X < Y)
2245  return true;
2246 
2247  return false;
2248 }
2249 
2251  IdentifierInfo *Platform,
2252  bool Implicit,
2253  VersionTuple Introduced,
2254  VersionTuple Deprecated,
2255  VersionTuple Obsoleted,
2256  bool IsUnavailable,
2257  StringRef Message,
2258  bool IsStrict,
2259  StringRef Replacement,
2261  unsigned AttrSpellingListIndex) {
2262  VersionTuple MergedIntroduced = Introduced;
2263  VersionTuple MergedDeprecated = Deprecated;
2264  VersionTuple MergedObsoleted = Obsoleted;
2265  bool FoundAny = false;
2266  bool OverrideOrImpl = false;
2267  switch (AMK) {
2268  case AMK_None:
2269  case AMK_Redeclaration:
2270  OverrideOrImpl = false;
2271  break;
2272 
2273  case AMK_Override:
2275  OverrideOrImpl = true;
2276  break;
2277  }
2278 
2279  if (D->hasAttrs()) {
2280  AttrVec &Attrs = D->getAttrs();
2281  for (unsigned i = 0, e = Attrs.size(); i != e;) {
2282  const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2283  if (!OldAA) {
2284  ++i;
2285  continue;
2286  }
2287 
2288  IdentifierInfo *OldPlatform = OldAA->getPlatform();
2289  if (OldPlatform != Platform) {
2290  ++i;
2291  continue;
2292  }
2293 
2294  // If there is an existing availability attribute for this platform that
2295  // is explicit and the new one is implicit use the explicit one and
2296  // discard the new implicit attribute.
2297  if (!OldAA->isImplicit() && Implicit) {
2298  return nullptr;
2299  }
2300 
2301  // If there is an existing attribute for this platform that is implicit
2302  // and the new attribute is explicit then erase the old one and
2303  // continue processing the attributes.
2304  if (!Implicit && OldAA->isImplicit()) {
2305  Attrs.erase(Attrs.begin() + i);
2306  --e;
2307  continue;
2308  }
2309 
2310  FoundAny = true;
2311  VersionTuple OldIntroduced = OldAA->getIntroduced();
2312  VersionTuple OldDeprecated = OldAA->getDeprecated();
2313  VersionTuple OldObsoleted = OldAA->getObsoleted();
2314  bool OldIsUnavailable = OldAA->getUnavailable();
2315 
2316  if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2317  !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2318  !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2319  !(OldIsUnavailable == IsUnavailable ||
2320  (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2321  if (OverrideOrImpl) {
2322  int Which = -1;
2323  VersionTuple FirstVersion;
2324  VersionTuple SecondVersion;
2325  if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2326  Which = 0;
2327  FirstVersion = OldIntroduced;
2328  SecondVersion = Introduced;
2329  } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2330  Which = 1;
2331  FirstVersion = Deprecated;
2332  SecondVersion = OldDeprecated;
2333  } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2334  Which = 2;
2335  FirstVersion = Obsoleted;
2336  SecondVersion = OldObsoleted;
2337  }
2338 
2339  if (Which == -1) {
2340  Diag(OldAA->getLocation(),
2341  diag::warn_mismatched_availability_override_unavail)
2342  << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2343  << (AMK == AMK_Override);
2344  } else {
2345  Diag(OldAA->getLocation(),
2346  diag::warn_mismatched_availability_override)
2347  << Which
2348  << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2349  << FirstVersion.getAsString() << SecondVersion.getAsString()
2350  << (AMK == AMK_Override);
2351  }
2352  if (AMK == AMK_Override)
2353  Diag(Range.getBegin(), diag::note_overridden_method);
2354  else
2355  Diag(Range.getBegin(), diag::note_protocol_method);
2356  } else {
2357  Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2358  Diag(Range.getBegin(), diag::note_previous_attribute);
2359  }
2360 
2361  Attrs.erase(Attrs.begin() + i);
2362  --e;
2363  continue;
2364  }
2365 
2366  VersionTuple MergedIntroduced2 = MergedIntroduced;
2367  VersionTuple MergedDeprecated2 = MergedDeprecated;
2368  VersionTuple MergedObsoleted2 = MergedObsoleted;
2369 
2370  if (MergedIntroduced2.empty())
2371  MergedIntroduced2 = OldIntroduced;
2372  if (MergedDeprecated2.empty())
2373  MergedDeprecated2 = OldDeprecated;
2374  if (MergedObsoleted2.empty())
2375  MergedObsoleted2 = OldObsoleted;
2376 
2377  if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2378  MergedIntroduced2, MergedDeprecated2,
2379  MergedObsoleted2)) {
2380  Attrs.erase(Attrs.begin() + i);
2381  --e;
2382  continue;
2383  }
2384 
2385  MergedIntroduced = MergedIntroduced2;
2386  MergedDeprecated = MergedDeprecated2;
2387  MergedObsoleted = MergedObsoleted2;
2388  ++i;
2389  }
2390  }
2391 
2392  if (FoundAny &&
2393  MergedIntroduced == Introduced &&
2394  MergedDeprecated == Deprecated &&
2395  MergedObsoleted == Obsoleted)
2396  return nullptr;
2397 
2398  // Only create a new attribute if !OverrideOrImpl, but we want to do
2399  // the checking.
2400  if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2401  MergedDeprecated, MergedObsoleted) &&
2402  !OverrideOrImpl) {
2403  auto *Avail = ::new (Context) AvailabilityAttr(Range, Context, Platform,
2404  Introduced, Deprecated,
2405  Obsoleted, IsUnavailable, Message,
2406  IsStrict, Replacement,
2407  AttrSpellingListIndex);
2408  Avail->setImplicit(Implicit);
2409  return Avail;
2410  }
2411  return nullptr;
2412 }
2413 
2415  const AttributeList &Attr) {
2416  if (!checkAttributeNumArgs(S, Attr, 1))
2417  return;
2418  IdentifierLoc *Platform = Attr.getArgAsIdent(0);
2419  unsigned Index = Attr.getAttributeSpellingListIndex();
2420 
2421  IdentifierInfo *II = Platform->Ident;
2422  if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2423  S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2424  << Platform->Ident;
2425 
2426  NamedDecl *ND = dyn_cast<NamedDecl>(D);
2427  if (!ND) // We warned about this already, so just return.
2428  return;
2429 
2430  AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
2431  AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
2432  AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
2433  bool IsUnavailable = Attr.getUnavailableLoc().isValid();
2434  bool IsStrict = Attr.getStrictLoc().isValid();
2435  StringRef Str;
2436  if (const StringLiteral *SE =
2437  dyn_cast_or_null<StringLiteral>(Attr.getMessageExpr()))
2438  Str = SE->getString();
2439  StringRef Replacement;
2440  if (const StringLiteral *SE =
2441  dyn_cast_or_null<StringLiteral>(Attr.getReplacementExpr()))
2442  Replacement = SE->getString();
2443 
2444  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND, Attr.getRange(), II,
2445  false/*Implicit*/,
2446  Introduced.Version,
2447  Deprecated.Version,
2448  Obsoleted.Version,
2449  IsUnavailable, Str,
2450  IsStrict, Replacement,
2452  Index);
2453  if (NewAttr)
2454  D->addAttr(NewAttr);
2455 
2456  // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2457  // matches before the start of the watchOS platform.
2458  if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2459  IdentifierInfo *NewII = nullptr;
2460  if (II->getName() == "ios")
2461  NewII = &S.Context.Idents.get("watchos");
2462  else if (II->getName() == "ios_app_extension")
2463  NewII = &S.Context.Idents.get("watchos_app_extension");
2464 
2465  if (NewII) {
2466  auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
2467  if (Version.empty())
2468  return Version;
2469  auto Major = Version.getMajor();
2470  auto NewMajor = Major >= 9 ? Major - 7 : 0;
2471  if (NewMajor >= 2) {
2472  if (Version.getMinor().hasValue()) {
2473  if (Version.getSubminor().hasValue())
2474  return VersionTuple(NewMajor, Version.getMinor().getValue(),
2475  Version.getSubminor().getValue());
2476  else
2477  return VersionTuple(NewMajor, Version.getMinor().getValue());
2478  }
2479  }
2480 
2481  return VersionTuple(2, 0);
2482  };
2483 
2484  auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2485  auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2486  auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2487 
2488  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2489  Attr.getRange(),
2490  NewII,
2491  true/*Implicit*/,
2492  NewIntroduced,
2493  NewDeprecated,
2494  NewObsoleted,
2495  IsUnavailable, Str,
2496  IsStrict,
2497  Replacement,
2499  Index);
2500  if (NewAttr)
2501  D->addAttr(NewAttr);
2502  }
2503  } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2504  // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2505  // matches before the start of the tvOS platform.
2506  IdentifierInfo *NewII = nullptr;
2507  if (II->getName() == "ios")
2508  NewII = &S.Context.Idents.get("tvos");
2509  else if (II->getName() == "ios_app_extension")
2510  NewII = &S.Context.Idents.get("tvos_app_extension");
2511 
2512  if (NewII) {
2513  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2514  Attr.getRange(),
2515  NewII,
2516  true/*Implicit*/,
2517  Introduced.Version,
2518  Deprecated.Version,
2519  Obsoleted.Version,
2520  IsUnavailable, Str,
2521  IsStrict,
2522  Replacement,
2524  Index);
2525  if (NewAttr)
2526  D->addAttr(NewAttr);
2527  }
2528  }
2529 }
2530 
2532  const AttributeList &Attr) {
2533  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
2534  return;
2535  assert(checkAttributeAtMostNumArgs(S, Attr, 3) &&
2536  "Invalid number of arguments in an external_source_symbol attribute");
2537 
2538  StringRef Language;
2539  if (const auto *SE = dyn_cast_or_null<StringLiteral>(Attr.getArgAsExpr(0)))
2540  Language = SE->getString();
2541  StringRef DefinedIn;
2542  if (const auto *SE = dyn_cast_or_null<StringLiteral>(Attr.getArgAsExpr(1)))
2543  DefinedIn = SE->getString();
2544  bool IsGeneratedDeclaration = Attr.getArgAsIdent(2) != nullptr;
2545 
2546  D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2547  Attr.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
2549 }
2550 
2551 template <class T>
2553  typename T::VisibilityType value,
2554  unsigned attrSpellingListIndex) {
2555  T *existingAttr = D->getAttr<T>();
2556  if (existingAttr) {
2557  typename T::VisibilityType existingValue = existingAttr->getVisibility();
2558  if (existingValue == value)
2559  return nullptr;
2560  S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2561  S.Diag(range.getBegin(), diag::note_previous_attribute);
2562  D->dropAttr<T>();
2563  }
2564  return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
2565 }
2566 
2567 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2568  VisibilityAttr::VisibilityType Vis,
2569  unsigned AttrSpellingListIndex) {
2570  return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2571  AttrSpellingListIndex);
2572 }
2573 
2574 TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2575  TypeVisibilityAttr::VisibilityType Vis,
2576  unsigned AttrSpellingListIndex) {
2577  return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2578  AttrSpellingListIndex);
2579 }
2580 
2582  bool isTypeVisibility) {
2583  // Visibility attributes don't mean anything on a typedef.
2584  if (isa<TypedefNameDecl>(D)) {
2585  S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
2586  << Attr.getName();
2587  return;
2588  }
2589 
2590  // 'type_visibility' can only go on a type or namespace.
2591  if (isTypeVisibility &&
2592  !(isa<TagDecl>(D) ||
2593  isa<ObjCInterfaceDecl>(D) ||
2594  isa<NamespaceDecl>(D))) {
2595  S.Diag(Attr.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2596  << Attr.getName() << ExpectedTypeOrNamespace;
2597  return;
2598  }
2599 
2600  // Check that the argument is a string literal.
2601  StringRef TypeStr;
2602  SourceLocation LiteralLoc;
2603  if (!S.checkStringLiteralArgumentAttr(Attr, 0, TypeStr, &LiteralLoc))
2604  return;
2605 
2606  VisibilityAttr::VisibilityType type;
2607  if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2608  S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
2609  << Attr.getName() << TypeStr;
2610  return;
2611  }
2612 
2613  // Complain about attempts to use protected visibility on targets
2614  // (like Darwin) that don't support it.
2615  if (type == VisibilityAttr::Protected &&
2617  S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
2618  type = VisibilityAttr::Default;
2619  }
2620 
2621  unsigned Index = Attr.getAttributeSpellingListIndex();
2622  clang::Attr *newAttr;
2623  if (isTypeVisibility) {
2624  newAttr = S.mergeTypeVisibilityAttr(D, Attr.getRange(),
2625  (TypeVisibilityAttr::VisibilityType) type,
2626  Index);
2627  } else {
2628  newAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type, Index);
2629  }
2630  if (newAttr)
2631  D->addAttr(newAttr);
2632 }
2633 
2635  const AttributeList &Attr) {
2636  ObjCMethodDecl *method = cast<ObjCMethodDecl>(decl);
2637  if (!Attr.isArgIdent(0)) {
2638  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2639  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2640  return;
2641  }
2642 
2643  IdentifierLoc *IL = Attr.getArgAsIdent(0);
2644  ObjCMethodFamilyAttr::FamilyKind F;
2645  if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2646  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << Attr.getName()
2647  << IL->Ident;
2648  return;
2649  }
2650 
2651  if (F == ObjCMethodFamilyAttr::OMF_init &&
2652  !method->getReturnType()->isObjCObjectPointerType()) {
2653  S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
2654  << method->getReturnType();
2655  // Ignore the attribute.
2656  return;
2657  }
2658 
2659  method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
2660  S.Context, F,
2662 }
2663 
2664 static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
2665  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2666  QualType T = TD->getUnderlyingType();
2667  if (!T->isCARCBridgableType()) {
2668  S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2669  return;
2670  }
2671  }
2672  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2673  QualType T = PD->getType();
2674  if (!T->isCARCBridgableType()) {
2675  S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2676  return;
2677  }
2678  }
2679  else {
2680  // It is okay to include this attribute on properties, e.g.:
2681  //
2682  // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2683  //
2684  // In this case it follows tradition and suppresses an error in the above
2685  // case.
2686  S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2687  }
2688  D->addAttr(::new (S.Context)
2689  ObjCNSObjectAttr(Attr.getRange(), S.Context,
2691 }
2692 
2694  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2695  QualType T = TD->getUnderlyingType();
2696  if (!T->isObjCObjectPointerType()) {
2697  S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2698  return;
2699  }
2700  } else {
2701  S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2702  return;
2703  }
2704  D->addAttr(::new (S.Context)
2705  ObjCIndependentClassAttr(Attr.getRange(), S.Context,
2707 }
2708 
2709 static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2710  if (!Attr.isArgIdent(0)) {
2711  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2712  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2713  return;
2714  }
2715 
2716  IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2717  BlocksAttr::BlockType type;
2718  if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2719  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2720  << Attr.getName() << II;
2721  return;
2722  }
2723 
2724  D->addAttr(::new (S.Context)
2725  BlocksAttr(Attr.getRange(), S.Context, type,
2727 }
2728 
2729 static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2730  unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2731  if (Attr.getNumArgs() > 0) {
2732  Expr *E = Attr.getArgAsExpr(0);
2733  llvm::APSInt Idx(32);
2734  if (E->isTypeDependent() || E->isValueDependent() ||
2735  !E->isIntegerConstantExpr(Idx, S.Context)) {
2736  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2737  << Attr.getName() << 1 << AANT_ArgumentIntegerConstant
2738  << E->getSourceRange();
2739  return;
2740  }
2741 
2742  if (Idx.isSigned() && Idx.isNegative()) {
2743  S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2744  << E->getSourceRange();
2745  return;
2746  }
2747 
2748  sentinel = Idx.getZExtValue();
2749  }
2750 
2751  unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2752  if (Attr.getNumArgs() > 1) {
2753  Expr *E = Attr.getArgAsExpr(1);
2754  llvm::APSInt Idx(32);
2755  if (E->isTypeDependent() || E->isValueDependent() ||
2756  !E->isIntegerConstantExpr(Idx, S.Context)) {
2757  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2758  << Attr.getName() << 2 << AANT_ArgumentIntegerConstant
2759  << E->getSourceRange();
2760  return;
2761  }
2762  nullPos = Idx.getZExtValue();
2763 
2764  if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2765  // FIXME: This error message could be improved, it would be nice
2766  // to say what the bounds actually are.
2767  S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2768  << E->getSourceRange();
2769  return;
2770  }
2771  }
2772 
2773  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2774  const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2775  if (isa<FunctionNoProtoType>(FT)) {
2776  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2777  return;
2778  }
2779 
2780  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2781  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2782  return;
2783  }
2784  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
2785  if (!MD->isVariadic()) {
2786  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2787  return;
2788  }
2789  } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
2790  if (!BD->isVariadic()) {
2791  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2792  return;
2793  }
2794  } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
2795  QualType Ty = V->getType();
2796  if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2797  const FunctionType *FT = Ty->isFunctionPointerType()
2798  ? D->getFunctionType()
2799  : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2800  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2801  int m = Ty->isFunctionPointerType() ? 0 : 1;
2802  S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2803  return;
2804  }
2805  } else {
2806  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2808  return;
2809  }
2810  } else {
2811  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2813  return;
2814  }
2815  D->addAttr(::new (S.Context)
2816  SentinelAttr(Attr.getRange(), S.Context, sentinel, nullPos,
2818 }
2819 
2821  if (D->getFunctionType() &&
2823  S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2824  << Attr.getName() << 0;
2825  return;
2826  }
2827  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2828  if (MD->getReturnType()->isVoidType()) {
2829  S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2830  << Attr.getName() << 1;
2831  return;
2832  }
2833 
2834  // If this is spelled as the standard C++1z attribute, but not in C++1z, warn
2835  // about using it as an extension.
2836  if (!S.getLangOpts().CPlusPlus1z && Attr.isCXX11Attribute() &&
2837  !Attr.getScopeName())
2838  S.Diag(Attr.getLoc(), diag::ext_cxx1z_attr) << Attr.getName();
2839 
2840  D->addAttr(::new (S.Context)
2841  WarnUnusedResultAttr(Attr.getRange(), S.Context,
2843 }
2844 
2845 static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2846  // weak_import only applies to variable & function declarations.
2847  bool isDef = false;
2848  if (!D->canBeWeakImported(isDef)) {
2849  if (isDef)
2850  S.Diag(Attr.getLoc(), diag::warn_attribute_invalid_on_definition)
2851  << "weak_import";
2852  else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2853  (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2854  (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2855  // Nothing to warn about here.
2856  } else
2857  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2858  << Attr.getName() << ExpectedVariableOrFunction;
2859 
2860  return;
2861  }
2862 
2863  D->addAttr(::new (S.Context)
2864  WeakImportAttr(Attr.getRange(), S.Context,
2866 }
2867 
2868 // Handles reqd_work_group_size and work_group_size_hint.
2869 template <typename WorkGroupAttr>
2870 static void handleWorkGroupSize(Sema &S, Decl *D,
2871  const AttributeList &Attr) {
2872  uint32_t WGSize[3];
2873  for (unsigned i = 0; i < 3; ++i) {
2874  const Expr *E = Attr.getArgAsExpr(i);
2875  if (!checkUInt32Argument(S, Attr, E, WGSize[i], i))
2876  return;
2877  if (WGSize[i] == 0) {
2878  S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2879  << Attr.getName() << E->getSourceRange();
2880  return;
2881  }
2882  }
2883 
2884  WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2885  if (Existing && !(Existing->getXDim() == WGSize[0] &&
2886  Existing->getYDim() == WGSize[1] &&
2887  Existing->getZDim() == WGSize[2]))
2888  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2889 
2890  D->addAttr(::new (S.Context) WorkGroupAttr(Attr.getRange(), S.Context,
2891  WGSize[0], WGSize[1], WGSize[2],
2893 }
2894 
2895 // Handles intel_reqd_sub_group_size.
2896 static void handleSubGroupSize(Sema &S, Decl *D, const AttributeList &Attr) {
2897  uint32_t SGSize;
2898  const Expr *E = Attr.getArgAsExpr(0);
2899  if (!checkUInt32Argument(S, Attr, E, SGSize))
2900  return;
2901  if (SGSize == 0) {
2902  S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2903  << Attr.getName() << E->getSourceRange();
2904  return;
2905  }
2906 
2907  OpenCLIntelReqdSubGroupSizeAttr *Existing =
2908  D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
2909  if (Existing && Existing->getSubGroupSize() != SGSize)
2910  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2911 
2912  D->addAttr(::new (S.Context) OpenCLIntelReqdSubGroupSizeAttr(
2913  Attr.getRange(), S.Context, SGSize,
2915 }
2916 
2917 static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &Attr) {
2918  if (!Attr.hasParsedType()) {
2919  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2920  << Attr.getName() << 1;
2921  return;
2922  }
2923 
2924  TypeSourceInfo *ParmTSI = nullptr;
2925  QualType ParmType = S.GetTypeFromParser(Attr.getTypeArg(), &ParmTSI);
2926  assert(ParmTSI && "no type source info for attribute argument");
2927 
2928  if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2929  (ParmType->isBooleanType() ||
2930  !ParmType->isIntegralType(S.getASTContext()))) {
2931  S.Diag(Attr.getLoc(), diag::err_attribute_argument_vec_type_hint)
2932  << ParmType;
2933  return;
2934  }
2935 
2936  if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2937  if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2938  S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2939  return;
2940  }
2941  }
2942 
2943  D->addAttr(::new (S.Context) VecTypeHintAttr(Attr.getLoc(), S.Context,
2944  ParmTSI,
2946 }
2947 
2948 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2949  StringRef Name,
2950  unsigned AttrSpellingListIndex) {
2951  if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2952  if (ExistingAttr->getName() == Name)
2953  return nullptr;
2954  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
2955  Diag(Range.getBegin(), diag::note_previous_attribute);
2956  return nullptr;
2957  }
2958  return ::new (Context) SectionAttr(Range, Context, Name,
2959  AttrSpellingListIndex);
2960 }
2961 
2962 bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2963  std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2964  if (!Error.empty()) {
2965  Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error;
2966  return false;
2967  }
2968  return true;
2969 }
2970 
2971 static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2972  // Make sure that there is a string literal as the sections's single
2973  // argument.
2974  StringRef Str;
2975  SourceLocation LiteralLoc;
2976  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
2977  return;
2978 
2979  if (!S.checkSectionName(LiteralLoc, Str))
2980  return;
2981 
2982  // If the target wants to validate the section specifier, make it happen.
2983  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
2984  if (!Error.empty()) {
2985  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
2986  << Error;
2987  return;
2988  }
2989 
2990  unsigned Index = Attr.getAttributeSpellingListIndex();
2991  SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(), Str, Index);
2992  if (NewAttr)
2993  D->addAttr(NewAttr);
2994 }
2995 
2996 // Check for things we'd like to warn about, no errors or validation for now.
2997 // TODO: Validation should use a backend target library that specifies
2998 // the allowable subtarget features and cpus. We could use something like a
2999 // TargetCodeGenInfo hook here to do validation.
3000 void Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3001  for (auto Str : {"tune=", "fpmath="})
3002  if (AttrStr.find(Str) != StringRef::npos)
3003  Diag(LiteralLoc, diag::warn_unsupported_target_attribute) << Str;
3004 }
3005 
3006 static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3007  StringRef Str;
3008  SourceLocation LiteralLoc;
3009  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
3010  return;
3011  S.checkTargetAttr(LiteralLoc, Str);
3012  unsigned Index = Attr.getAttributeSpellingListIndex();
3013  TargetAttr *NewAttr =
3014  ::new (S.Context) TargetAttr(Attr.getRange(), S.Context, Str, Index);
3015  D->addAttr(NewAttr);
3016 }
3017 
3018 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3019  VarDecl *VD = cast<VarDecl>(D);
3020  if (!VD->hasLocalStorage()) {
3021  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3022  return;
3023  }
3024 
3025  Expr *E = Attr.getArgAsExpr(0);
3026  SourceLocation Loc = E->getExprLoc();
3027  FunctionDecl *FD = nullptr;
3029 
3030  // gcc only allows for simple identifiers. Since we support more than gcc, we
3031  // will warn the user.
3032  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3033  if (DRE->hasQualifier())
3034  S.Diag(Loc, diag::warn_cleanup_ext);
3035  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3036  NI = DRE->getNameInfo();
3037  if (!FD) {
3038  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3039  << NI.getName();
3040  return;
3041  }
3042  } else if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3043  if (ULE->hasExplicitTemplateArgs())
3044  S.Diag(Loc, diag::warn_cleanup_ext);
3046  NI = ULE->getNameInfo();
3047  if (!FD) {
3048  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3049  << NI.getName();
3050  if (ULE->getType() == S.Context.OverloadTy)
3052  return;
3053  }
3054  } else {
3055  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3056  return;
3057  }
3058 
3059  if (FD->getNumParams() != 1) {
3060  S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3061  << NI.getName();
3062  return;
3063  }
3064 
3065  // We're currently more strict than GCC about what function types we accept.
3066  // If this ever proves to be a problem it should be easy to fix.
3067  QualType Ty = S.Context.getPointerType(VD->getType());
3068  QualType ParamTy = FD->getParamDecl(0)->getType();
3070  ParamTy, Ty) != Sema::Compatible) {
3071  S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3072  << NI.getName() << ParamTy << Ty;
3073  return;
3074  }
3075 
3076  D->addAttr(::new (S.Context)
3077  CleanupAttr(Attr.getRange(), S.Context, FD,
3079 }
3080 
3082  const AttributeList &Attr) {
3083  if (!Attr.isArgIdent(0)) {
3084  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3085  << Attr.getName() << 0 << AANT_ArgumentIdentifier;
3086  return;
3087  }
3088 
3089  EnumExtensibilityAttr::Kind ExtensibilityKind;
3090  IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
3091  if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3092  ExtensibilityKind)) {
3093  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
3094  << Attr.getName() << II;
3095  return;
3096  }
3097 
3098  D->addAttr(::new (S.Context) EnumExtensibilityAttr(
3099  Attr.getRange(), S.Context, ExtensibilityKind,
3101 }
3102 
3103 /// Handle __attribute__((format_arg((idx)))) attribute based on
3104 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3105 static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3106  Expr *IdxExpr = Attr.getArgAsExpr(0);
3107  uint64_t Idx;
3108  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, IdxExpr, Idx))
3109  return;
3110 
3111  // Make sure the format string is really a string.
3113 
3114  bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3115  if (NotNSStringTy &&
3116  !isCFStringType(Ty, S.Context) &&
3117  (!Ty->isPointerType() ||
3118  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3119  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3120  << "a string type" << IdxExpr->getSourceRange()
3122  return;
3123  }
3125  if (!isNSStringType(Ty, S.Context) &&
3126  !isCFStringType(Ty, S.Context) &&
3127  (!Ty->isPointerType() ||
3128  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3129  S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
3130  << (NotNSStringTy ? "string type" : "NSString")
3131  << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3132  return;
3133  }
3134 
3135  // We cannot use the Idx returned from checkFunctionOrMethodParameterIndex
3136  // because that has corrected for the implicit this parameter, and is zero-
3137  // based. The attribute expects what the user wrote explicitly.
3138  llvm::APSInt Val;
3139  IdxExpr->EvaluateAsInt(Val, S.Context);
3140 
3141  D->addAttr(::new (S.Context)
3142  FormatArgAttr(Attr.getRange(), S.Context, Val.getZExtValue(),
3144 }
3145 
3153 };
3154 
3155 /// getFormatAttrKind - Map from format attribute names to supported format
3156 /// types.
3157 static FormatAttrKind getFormatAttrKind(StringRef Format) {
3158  return llvm::StringSwitch<FormatAttrKind>(Format)
3159  // Check for formats that get handled specially.
3160  .Case("NSString", NSStringFormat)
3161  .Case("CFString", CFStringFormat)
3162  .Case("strftime", StrftimeFormat)
3163 
3164  // Otherwise, check for supported formats.
3165  .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3166  .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3167  .Case("kprintf", SupportedFormat) // OpenBSD.
3168  .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3169  .Case("os_trace", SupportedFormat)
3170  .Case("os_log", SupportedFormat)
3171 
3172  .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3173  .Default(InvalidFormat);
3174 }
3175 
3176 /// Handle __attribute__((init_priority(priority))) attributes based on
3177 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3179  const AttributeList &Attr) {
3180  if (!S.getLangOpts().CPlusPlus) {
3181  S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3182  return;
3183  }
3184 
3185  if (S.getCurFunctionOrMethodDecl()) {
3186  S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
3187  Attr.setInvalid();
3188  return;
3189  }
3190  QualType T = cast<VarDecl>(D)->getType();
3191  if (S.Context.getAsArrayType(T))
3192  T = S.Context.getBaseElementType(T);
3193  if (!T->getAs<RecordType>()) {
3194  S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
3195  Attr.setInvalid();
3196  return;
3197  }
3198 
3199  Expr *E = Attr.getArgAsExpr(0);
3200  uint32_t prioritynum;
3201  if (!checkUInt32Argument(S, Attr, E, prioritynum)) {
3202  Attr.setInvalid();
3203  return;
3204  }
3205 
3206  if (prioritynum < 101 || prioritynum > 65535) {
3207  S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
3208  << E->getSourceRange() << Attr.getName() << 101 << 65535;
3209  Attr.setInvalid();
3210  return;
3211  }
3212  D->addAttr(::new (S.Context)
3213  InitPriorityAttr(Attr.getRange(), S.Context, prioritynum,
3215 }
3216 
3218  IdentifierInfo *Format, int FormatIdx,
3219  int FirstArg,
3220  unsigned AttrSpellingListIndex) {
3221  // Check whether we already have an equivalent format attribute.
3222  for (auto *F : D->specific_attrs<FormatAttr>()) {
3223  if (F->getType() == Format &&
3224  F->getFormatIdx() == FormatIdx &&
3225  F->getFirstArg() == FirstArg) {
3226  // If we don't have a valid location for this attribute, adopt the
3227  // location.
3228  if (F->getLocation().isInvalid())
3229  F->setRange(Range);
3230  return nullptr;
3231  }
3232  }
3233 
3234  return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
3235  FirstArg, AttrSpellingListIndex);
3236 }
3237 
3238 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3239 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3240 static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3241  if (!Attr.isArgIdent(0)) {
3242  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3243  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
3244  return;
3245  }
3246 
3247  // In C++ the implicit 'this' function parameter also counts, and they are
3248  // counted from one.
3249  bool HasImplicitThisParam = isInstanceMethod(D);
3250  unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3251 
3252  IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
3253  StringRef Format = II->getName();
3254 
3255  if (normalizeName(Format)) {
3256  // If we've modified the string name, we need a new identifier for it.
3257  II = &S.Context.Idents.get(Format);
3258  }
3259 
3260  // Check for supported formats.
3262 
3263  if (Kind == IgnoredFormat)
3264  return;
3265 
3266  if (Kind == InvalidFormat) {
3267  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
3268  << Attr.getName() << II->getName();
3269  return;
3270  }
3271 
3272  // checks for the 2nd argument
3273  Expr *IdxExpr = Attr.getArgAsExpr(1);
3274  uint32_t Idx;
3275  if (!checkUInt32Argument(S, Attr, IdxExpr, Idx, 2))
3276  return;
3277 
3278  if (Idx < 1 || Idx > NumArgs) {
3279  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
3280  << Attr.getName() << 2 << IdxExpr->getSourceRange();
3281  return;
3282  }
3283 
3284  // FIXME: Do we need to bounds check?
3285  unsigned ArgIdx = Idx - 1;
3286 
3287  if (HasImplicitThisParam) {
3288  if (ArgIdx == 0) {
3289  S.Diag(Attr.getLoc(),
3290  diag::err_format_attribute_implicit_this_format_string)
3291  << IdxExpr->getSourceRange();
3292  return;
3293  }
3294  ArgIdx--;
3295  }
3296 
3297  // make sure the format string is really a string
3298  QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
3299 
3300  if (Kind == CFStringFormat) {
3301  if (!isCFStringType(Ty, S.Context)) {
3302  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3303  << "a CFString" << IdxExpr->getSourceRange()
3304  << getFunctionOrMethodParamRange(D, ArgIdx);
3305  return;
3306  }
3307  } else if (Kind == NSStringFormat) {
3308  // FIXME: do we need to check if the type is NSString*? What are the
3309  // semantics?
3310  if (!isNSStringType(Ty, S.Context)) {
3311  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3312  << "an NSString" << IdxExpr->getSourceRange()
3313  << getFunctionOrMethodParamRange(D, ArgIdx);
3314  return;
3315  }
3316  } else if (!Ty->isPointerType() ||
3317  !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
3318  S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3319  << "a string type" << IdxExpr->getSourceRange()
3320  << getFunctionOrMethodParamRange(D, ArgIdx);
3321  return;
3322  }
3323 
3324  // check the 3rd argument
3325  Expr *FirstArgExpr = Attr.getArgAsExpr(2);
3326  uint32_t FirstArg;
3327  if (!checkUInt32Argument(S, Attr, FirstArgExpr, FirstArg, 3))
3328  return;
3329 
3330  // check if the function is variadic if the 3rd argument non-zero
3331  if (FirstArg != 0) {
3332  if (isFunctionOrMethodVariadic(D)) {
3333  ++NumArgs; // +1 for ...
3334  } else {
3335  S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
3336  return;
3337  }
3338  }
3339 
3340  // strftime requires FirstArg to be 0 because it doesn't read from any
3341  // variable the input is just the current time + the format string.
3342  if (Kind == StrftimeFormat) {
3343  if (FirstArg != 0) {
3344  S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
3345  << FirstArgExpr->getSourceRange();
3346  return;
3347  }
3348  // if 0 it disables parameter checking (to use with e.g. va_list)
3349  } else if (FirstArg != 0 && FirstArg != NumArgs) {
3350  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
3351  << Attr.getName() << 3 << FirstArgExpr->getSourceRange();
3352  return;
3353  }
3354 
3355  FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), II,
3356  Idx, FirstArg,
3358  if (NewAttr)
3359  D->addAttr(NewAttr);
3360 }
3361 
3363  const AttributeList &Attr) {
3364  // Try to find the underlying union declaration.
3365  RecordDecl *RD = nullptr;
3366  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
3367  if (TD && TD->getUnderlyingType()->isUnionType())
3368  RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3369  else
3370  RD = dyn_cast<RecordDecl>(D);
3371 
3372  if (!RD || !RD->isUnion()) {
3373  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3374  << Attr.getName() << ExpectedUnion;
3375  return;
3376  }
3377 
3378  if (!RD->isCompleteDefinition()) {
3379  if (!RD->isBeingDefined())
3380  S.Diag(Attr.getLoc(),
3381  diag::warn_transparent_union_attribute_not_definition);
3382  return;
3383  }
3384 
3386  FieldEnd = RD->field_end();
3387  if (Field == FieldEnd) {
3388  S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3389  return;
3390  }
3391 
3392  FieldDecl *FirstField = *Field;
3393  QualType FirstType = FirstField->getType();
3394  if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3395  S.Diag(FirstField->getLocation(),
3396  diag::warn_transparent_union_attribute_floating)
3397  << FirstType->isVectorType() << FirstType;
3398  return;
3399  }
3400 
3401  if (FirstType->isIncompleteType())
3402  return;
3403  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3404  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3405  for (; Field != FieldEnd; ++Field) {
3406  QualType FieldType = Field->getType();
3407  if (FieldType->isIncompleteType())
3408  return;
3409  // FIXME: this isn't fully correct; we also need to test whether the
3410  // members of the union would all have the same calling convention as the
3411  // first member of the union. Checking just the size and alignment isn't
3412  // sufficient (consider structs passed on the stack instead of in registers
3413  // as an example).
3414  if (S.Context.getTypeSize(FieldType) != FirstSize ||
3415  S.Context.getTypeAlign(FieldType) > FirstAlign) {
3416  // Warn if we drop the attribute.
3417  bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3418  unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3419  : S.Context.getTypeAlign(FieldType);
3420  S.Diag(Field->getLocation(),
3421  diag::warn_transparent_union_attribute_field_size_align)
3422  << isSize << Field->getDeclName() << FieldBits;
3423  unsigned FirstBits = isSize? FirstSize : FirstAlign;
3424  S.Diag(FirstField->getLocation(),
3425  diag::note_transparent_union_first_field_size_align)
3426  << isSize << FirstBits;
3427  return;
3428  }
3429  }
3430 
3431  RD->addAttr(::new (S.Context)
3432  TransparentUnionAttr(Attr.getRange(), S.Context,
3434 }
3435 
3436 static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3437  // Make sure that there is a string literal as the annotation's single
3438  // argument.
3439  StringRef Str;
3440  if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
3441  return;
3442 
3443  // Don't duplicate annotations that are already set.
3444  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
3445  if (I->getAnnotation() == Str)
3446  return;
3447  }
3448 
3449  D->addAttr(::new (S.Context)
3450  AnnotateAttr(Attr.getRange(), S.Context, Str,
3452 }
3453 
3454 static void handleAlignValueAttr(Sema &S, Decl *D,
3455  const AttributeList &Attr) {
3456  S.AddAlignValueAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
3458 }
3459 
3461  unsigned SpellingListIndex) {
3462  AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
3463  SourceLocation AttrLoc = AttrRange.getBegin();
3464 
3465  QualType T;
3466  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3467  T = TD->getUnderlyingType();
3468  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3469  T = VD->getType();
3470  else
3471  llvm_unreachable("Unknown decl type for align_value");
3472 
3473  if (!T->isDependentType() && !T->isAnyPointerType() &&
3474  !T->isReferenceType() && !T->isMemberPointerType()) {
3475  Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3476  << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
3477  return;
3478  }
3479 
3480  if (!E->isValueDependent()) {
3481  llvm::APSInt Alignment;
3482  ExprResult ICE
3483  = VerifyIntegerConstantExpression(E, &Alignment,
3484  diag::err_align_value_attribute_argument_not_int,
3485  /*AllowFold*/ false);
3486  if (ICE.isInvalid())
3487  return;
3488 
3489  if (!Alignment.isPowerOf2()) {
3490  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3491  << E->getSourceRange();
3492  return;
3493  }
3494 
3495  D->addAttr(::new (Context)
3496  AlignValueAttr(AttrRange, Context, ICE.get(),
3497  SpellingListIndex));
3498  return;
3499  }
3500 
3501  // Save dependent expressions in the AST to be instantiated.
3502  D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
3503 }
3504 
3505 static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3506  // check the attribute arguments.
3507  if (Attr.getNumArgs() > 1) {
3508  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
3509  << Attr.getName() << 1;
3510  return;
3511  }
3512 
3513  if (Attr.getNumArgs() == 0) {
3514  D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
3515  true, nullptr, Attr.getAttributeSpellingListIndex()));
3516  return;
3517  }
3518 
3519  Expr *E = Attr.getArgAsExpr(0);
3520  if (Attr.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
3521  S.Diag(Attr.getEllipsisLoc(),
3522  diag::err_pack_expansion_without_parameter_packs);
3523  return;
3524  }
3525 
3527  return;
3528 
3529  if (E->isValueDependent()) {
3530  if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
3531  if (!TND->getUnderlyingType()->isDependentType()) {
3532  S.Diag(Attr.getLoc(), diag::err_alignment_dependent_typedef_name)
3533  << E->getSourceRange();
3534  return;
3535  }
3536  }
3537  }
3538 
3540  Attr.isPackExpansion());
3541 }
3542 
3544  unsigned SpellingListIndex, bool IsPackExpansion) {
3545  AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3546  SourceLocation AttrLoc = AttrRange.getBegin();
3547 
3548  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3549  if (TmpAttr.isAlignas()) {
3550  // C++11 [dcl.align]p1:
3551  // An alignment-specifier may be applied to a variable or to a class
3552  // data member, but it shall not be applied to a bit-field, a function
3553  // parameter, the formal parameter of a catch clause, or a variable
3554  // declared with the register storage class specifier. An
3555  // alignment-specifier may also be applied to the declaration of a class
3556  // or enumeration type.
3557  // C11 6.7.5/2:
3558  // An alignment attribute shall not be specified in a declaration of
3559  // a typedef, or a bit-field, or a function, or a parameter, or an
3560  // object declared with the register storage-class specifier.
3561  int DiagKind = -1;
3562  if (isa<ParmVarDecl>(D)) {
3563  DiagKind = 0;
3564  } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
3565  if (VD->getStorageClass() == SC_Register)
3566  DiagKind = 1;
3567  if (VD->isExceptionVariable())
3568  DiagKind = 2;
3569  } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
3570  if (FD->isBitField())
3571  DiagKind = 3;
3572  } else if (!isa<TagDecl>(D)) {
3573  Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
3574  << (TmpAttr.isC11() ? ExpectedVariableOrField
3576  return;
3577  }
3578  if (DiagKind != -1) {
3579  Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3580  << &TmpAttr << DiagKind;
3581  return;
3582  }
3583  }
3584 
3585  if (E->isTypeDependent() || E->isValueDependent()) {
3586  // Save dependent expressions in the AST to be instantiated.
3587  AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
3588  AA->setPackExpansion(IsPackExpansion);
3589  D->addAttr(AA);
3590  return;
3591  }
3592 
3593  // FIXME: Cache the number on the Attr object?
3594  llvm::APSInt Alignment;
3595  ExprResult ICE
3596  = VerifyIntegerConstantExpression(E, &Alignment,
3597  diag::err_aligned_attribute_argument_not_int,
3598  /*AllowFold*/ false);
3599  if (ICE.isInvalid())
3600  return;
3601 
3602  uint64_t AlignVal = Alignment.getZExtValue();
3603 
3604  // C++11 [dcl.align]p2:
3605  // -- if the constant expression evaluates to zero, the alignment
3606  // specifier shall have no effect
3607  // C11 6.7.5p6:
3608  // An alignment specification of zero has no effect.
3609  if (!(TmpAttr.isAlignas() && !Alignment)) {
3610  if (!llvm::isPowerOf2_64(AlignVal)) {
3611  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3612  << E->getSourceRange();
3613  return;
3614  }
3615  }
3616 
3617  // Alignment calculations can wrap around if it's greater than 2**28.
3618  unsigned MaxValidAlignment =
3619  Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192
3620  : 268435456;
3621  if (AlignVal > MaxValidAlignment) {
3622  Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3623  << E->getSourceRange();
3624  return;
3625  }
3626 
3628  unsigned MaxTLSAlign =
3630  .getQuantity();
3631  auto *VD = dyn_cast<VarDecl>(D);
3632  if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
3633  VD->getTLSKind() != VarDecl::TLS_None) {
3634  Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3635  << (unsigned)AlignVal << VD << MaxTLSAlign;
3636  return;
3637  }
3638  }
3639 
3640  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3641  ICE.get(), SpellingListIndex);
3642  AA->setPackExpansion(IsPackExpansion);
3643  D->addAttr(AA);
3644 }
3645 
3647  unsigned SpellingListIndex, bool IsPackExpansion) {
3648  // FIXME: Cache the number on the Attr object if non-dependent?
3649  // FIXME: Perform checking of type validity
3650  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3651  SpellingListIndex);
3652  AA->setPackExpansion(IsPackExpansion);
3653  D->addAttr(AA);
3654 }
3655 
3657  assert(D->hasAttrs() && "no attributes on decl");
3658 
3659  QualType UnderlyingTy, DiagTy;
3660  if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
3661  UnderlyingTy = DiagTy = VD->getType();
3662  } else {
3663  UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3664  if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
3665  UnderlyingTy = ED->getIntegerType();
3666  }
3667  if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3668  return;
3669 
3670  // C++11 [dcl.align]p5, C11 6.7.5/4:
3671  // The combined effect of all alignment attributes in a declaration shall
3672  // not specify an alignment that is less strict than the alignment that
3673  // would otherwise be required for the entity being declared.
3674  AlignedAttr *AlignasAttr = nullptr;
3675  unsigned Align = 0;
3676  for (auto *I : D->specific_attrs<AlignedAttr>()) {
3677  if (I->isAlignmentDependent())
3678  return;
3679  if (I->isAlignas())
3680  AlignasAttr = I;
3681  Align = std::max(Align, I->getAlignment(Context));
3682  }
3683 
3684  if (AlignasAttr && Align) {
3685  CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3686  CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3687  if (NaturalAlign > RequestedAlign)
3688  Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3689  << DiagTy << (unsigned)NaturalAlign.getQuantity();
3690  }
3691 }
3692 
3694  CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3695  MSInheritanceAttr::Spelling SemanticSpelling) {
3696  assert(RD->hasDefinition() && "RD has no definition!");
3697 
3698  // We may not have seen base specifiers or any virtual methods yet. We will
3699  // have to wait until the record is defined to catch any mismatches.
3700  if (!RD->getDefinition()->isCompleteDefinition())
3701  return false;
3702 
3703  // The unspecified model never matches what a definition could need.
3704  if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3705  return false;
3706 
3707  if (BestCase) {
3708  if (RD->calculateInheritanceModel() == SemanticSpelling)
3709  return false;
3710  } else {
3711  if (RD->calculateInheritanceModel() <= SemanticSpelling)
3712  return false;
3713  }
3714 
3715  Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3716  << 0 /*definition*/;
3717  Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3718  << RD->getNameAsString();
3719  return true;
3720 }
3721 
3722 /// parseModeAttrArg - Parses attribute mode string and returns parsed type
3723 /// attribute.
3724 static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
3725  bool &IntegerMode, bool &ComplexMode) {
3726  IntegerMode = true;
3727  ComplexMode = false;
3728  switch (Str.size()) {
3729  case 2:
3730  switch (Str[0]) {
3731  case 'Q':
3732  DestWidth = 8;
3733  break;
3734  case 'H':
3735  DestWidth = 16;
3736  break;
3737  case 'S':
3738  DestWidth = 32;
3739  break;
3740  case 'D':
3741  DestWidth = 64;
3742  break;
3743  case 'X':
3744  DestWidth = 96;
3745  break;
3746  case 'T':
3747  DestWidth = 128;
3748  break;
3749  }
3750  if (Str[1] == 'F') {
3751  IntegerMode = false;
3752  } else if (Str[1] == 'C') {
3753  IntegerMode = false;
3754  ComplexMode = true;
3755  } else if (Str[1] != 'I') {
3756  DestWidth = 0;
3757  }
3758  break;
3759  case 4:
3760  // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3761  // pointer on PIC16 and other embedded platforms.
3762  if (Str == "word")
3763  DestWidth = S.Context.getTargetInfo().getRegisterWidth();
3764  else if (Str == "byte")
3765  DestWidth = S.Context.getTargetInfo().getCharWidth();
3766  break;
3767  case 7:
3768  if (Str == "pointer")
3769  DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3770  break;
3771  case 11:
3772  if (Str == "unwind_word")
3773  DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
3774  break;
3775  }
3776 }
3777 
3778 /// handleModeAttr - This attribute modifies the width of a decl with primitive
3779 /// type.
3780 ///
3781 /// Despite what would be logical, the mode attribute is a decl attribute, not a
3782 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3783 /// HImode, not an intermediate pointer.
3784 static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3785  // This attribute isn't documented, but glibc uses it. It changes
3786  // the width of an int or unsigned int to the specified size.
3787  if (!Attr.isArgIdent(0)) {
3788  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
3790  return;
3791  }
3792 
3793  IdentifierInfo *Name = Attr.getArgAsIdent(0)->Ident;
3794 
3796 }
3797 
3799  unsigned SpellingListIndex, bool InInstantiation) {
3800  StringRef Str = Name->getName();
3801  normalizeName(Str);
3802  SourceLocation AttrLoc = AttrRange.getBegin();
3803 
3804  unsigned DestWidth = 0;
3805  bool IntegerMode = true;
3806  bool ComplexMode = false;
3807  llvm::APInt VectorSize(64, 0);
3808  if (Str.size() >= 4 && Str[0] == 'V') {
3809  // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
3810  size_t StrSize = Str.size();
3811  size_t VectorStringLength = 0;
3812  while ((VectorStringLength + 1) < StrSize &&
3813  isdigit(Str[VectorStringLength + 1]))
3814  ++VectorStringLength;
3815  if (VectorStringLength &&
3816  !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
3817  VectorSize.isPowerOf2()) {
3818  parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
3819  IntegerMode, ComplexMode);
3820  // Avoid duplicate warning from template instantiation.
3821  if (!InInstantiation)
3822  Diag(AttrLoc, diag::warn_vector_mode_deprecated);
3823  } else {
3824  VectorSize = 0;
3825  }
3826  }
3827 
3828  if (!VectorSize)
3829  parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
3830 
3831  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3832  // and friends, at least with glibc.
3833  // FIXME: Make sure floating-point mappings are accurate
3834  // FIXME: Support XF and TF types
3835  if (!DestWidth) {
3836  Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
3837  return;
3838  }
3839 
3840  QualType OldTy;
3841  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3842  OldTy = TD->getUnderlyingType();
3843  else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
3844  // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
3845  // Try to get type from enum declaration, default to int.
3846  OldTy = ED->getIntegerType();
3847  if (OldTy.isNull())
3848  OldTy = Context.IntTy;
3849  } else
3850  OldTy = cast<ValueDecl>(D)->getType();
3851 
3852  if (OldTy->isDependentType()) {
3853  D->addAttr(::new (Context)
3854  ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3855  return;
3856  }
3857 
3858  // Base type can also be a vector type (see PR17453).
3859  // Distinguish between base type and base element type.
3860  QualType OldElemTy = OldTy;
3861  if (const VectorType *VT = OldTy->getAs<VectorType>())
3862  OldElemTy = VT->getElementType();
3863 
3864  // GCC allows 'mode' attribute on enumeration types (even incomplete), except
3865  // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
3866  // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
3867  if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
3868  VectorSize.getBoolValue()) {
3869  Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
3870  return;
3871  }
3872  bool IntegralOrAnyEnumType =
3873  OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
3874 
3875  if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
3876  !IntegralOrAnyEnumType)
3877  Diag(AttrLoc, diag::err_mode_not_primitive);
3878  else if (IntegerMode) {
3879  if (!IntegralOrAnyEnumType)
3880  Diag(AttrLoc, diag::err_mode_wrong_type);
3881  } else if (ComplexMode) {
3882  if (!OldElemTy->isComplexType())
3883  Diag(AttrLoc, diag::err_mode_wrong_type);
3884  } else {
3885  if (!OldElemTy->isFloatingType())
3886  Diag(AttrLoc, diag::err_mode_wrong_type);
3887  }
3888 
3889  QualType NewElemTy;
3890 
3891  if (IntegerMode)
3892  NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
3893  OldElemTy->isSignedIntegerType());
3894  else
3895  NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
3896 
3897  if (NewElemTy.isNull()) {
3898  Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
3899  return;
3900  }
3901 
3902  if (ComplexMode) {
3903  NewElemTy = Context.getComplexType(NewElemTy);
3904  }
3905 
3906  QualType NewTy = NewElemTy;
3907  if (VectorSize.getBoolValue()) {
3908  NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
3910  } else if (const VectorType *OldVT = OldTy->getAs<VectorType>()) {
3911  // Complex machine mode does not support base vector types.
3912  if (ComplexMode) {
3913  Diag(AttrLoc, diag::err_complex_mode_vector_type);
3914  return;
3915  }
3916  unsigned NumElements = Context.getTypeSize(OldElemTy) *
3917  OldVT->getNumElements() /
3918  Context.getTypeSize(NewElemTy);
3919  NewTy =
3920  Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
3921  }
3922 
3923  if (NewTy.isNull()) {
3924  Diag(AttrLoc, diag::err_mode_wrong_type);
3925  return;
3926  }
3927 
3928  // Install the new type.
3929  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3930  TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
3931  else if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
3932  ED->setIntegerType(NewTy);
3933  else
3934  cast<ValueDecl>(D)->setType(NewTy);
3935 
3936  D->addAttr(::new (Context)
3937  ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3938 }
3939 
3940 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3941  D->addAttr(::new (S.Context)
3942  NoDebugAttr(Attr.getRange(), S.Context,
3944 }
3945 
3946 AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
3947  IdentifierInfo *Ident,
3948  unsigned AttrSpellingListIndex) {
3949  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
3950  Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
3951  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
3952  return nullptr;
3953  }
3954 
3955  if (D->hasAttr<AlwaysInlineAttr>())
3956  return nullptr;
3957 
3958  return ::new (Context) AlwaysInlineAttr(Range, Context,
3959  AttrSpellingListIndex);
3960 }
3961 
3963  IdentifierInfo *Ident,
3964  unsigned AttrSpellingListIndex) {
3965  if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, Range, Ident))
3966  return nullptr;
3967 
3968  return ::new (Context) CommonAttr(Range, Context, AttrSpellingListIndex);
3969 }
3970 
3971 InternalLinkageAttr *
3973  IdentifierInfo *Ident,
3974  unsigned AttrSpellingListIndex) {
3975  if (auto VD = dyn_cast<VarDecl>(D)) {
3976  // Attribute applies to Var but not any subclass of it (like ParmVar,
3977  // ImplicitParm or VarTemplateSpecialization).
3978  if (VD->getKind() != Decl::Var) {
3979  Diag(Range.getBegin(), diag::warn_attribute_wrong_decl_type)
3980  << Ident << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
3982  return nullptr;
3983  }
3984  // Attribute does not apply to non-static local variables.
3985  if (VD->hasLocalStorage()) {
3986  Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
3987  return nullptr;
3988  }
3989  }
3990 
3991  if (checkAttrMutualExclusion<CommonAttr>(*this, D, Range, Ident))
3992  return nullptr;
3993 
3994  return ::new (Context)
3995  InternalLinkageAttr(Range, Context, AttrSpellingListIndex);
3996 }
3997 
3998 MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
3999  unsigned AttrSpellingListIndex) {
4000  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4001  Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
4002  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4003  return nullptr;
4004  }
4005 
4006  if (D->hasAttr<MinSizeAttr>())
4007  return nullptr;
4008 
4009  return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
4010 }
4011 
4012 OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
4013  unsigned AttrSpellingListIndex) {
4014  if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
4015  Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4016  Diag(Range.getBegin(), diag::note_conflicting_attribute);
4017  D->dropAttr<AlwaysInlineAttr>();
4018  }
4019  if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
4020  Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4021  Diag(Range.getBegin(), diag::note_conflicting_attribute);
4022  D->dropAttr<MinSizeAttr>();
4023  }
4024 
4025  if (D->hasAttr<OptimizeNoneAttr>())
4026  return nullptr;
4027 
4028  return ::new (Context) OptimizeNoneAttr(Range, Context,
4029  AttrSpellingListIndex);
4030 }
4031 
4033  const AttributeList &Attr) {
4034  if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, Attr.getRange(),
4035  Attr.getName()))
4036  return;
4037 
4038  if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
4039  D, Attr.getRange(), Attr.getName(),
4041  D->addAttr(Inline);
4042 }
4043 
4044 static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4045  if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
4046  D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
4047  D->addAttr(MinSize);
4048 }
4049 
4051  const AttributeList &Attr) {
4052  if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
4053  D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
4054  D->addAttr(Optnone);
4055 }
4056 
4057 static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4058  if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, Attr.getRange(),
4059  Attr.getName()))
4060  return;
4061  auto *VD = cast<VarDecl>(D);
4062  if (!VD->hasGlobalStorage()) {
4063  S.Diag(Attr.getLoc(), diag::err_cuda_nonglobal_constant);
4064  return;
4065  }
4066  D->addAttr(::new (S.Context) CUDAConstantAttr(
4067  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4068 }
4069 
4070 static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4071  if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, Attr.getRange(),
4072  Attr.getName()))
4073  return;
4074  auto *VD = cast<VarDecl>(D);
4075  // extern __shared__ is only allowed on arrays with no length (e.g.
4076  // "int x[]").
4077  if (VD->hasExternalStorage() && !isa<IncompleteArrayType>(VD->getType())) {
4078  S.Diag(Attr.getLoc(), diag::err_cuda_extern_shared) << VD;
4079  return;
4080  }
4081  if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
4082  S.CUDADiagIfHostCode(Attr.getLoc(), diag::err_cuda_host_shared)
4083  << S.CurrentCUDATarget())
4084  return;
4085  D->addAttr(::new (S.Context) CUDASharedAttr(
4086  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4087 }
4088 
4089 static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4090  if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, Attr.getRange(),
4091  Attr.getName()) ||
4092  checkAttrMutualExclusion<CUDAHostAttr>(S, D, Attr.getRange(),
4093  Attr.getName())) {
4094  return;
4095  }
4096  FunctionDecl *FD = cast<FunctionDecl>(D);
4097  if (!FD->getReturnType()->isVoidType()) {
4098  SourceRange RTRange = FD->getReturnTypeSourceRange();
4099  S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
4100  << FD->getType()
4101  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
4102  : FixItHint());
4103  return;
4104  }
4105  if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4106  if (Method->isInstance()) {
4107  S.Diag(Method->getLocStart(), diag::err_kern_is_nonstatic_method)
4108  << Method;
4109  return;
4110  }
4111  S.Diag(Method->getLocStart(), diag::warn_kern_is_method) << Method;
4112  }
4113  // Only warn for "inline" when compiling for host, to cut down on noise.
4114  if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
4115  S.Diag(FD->getLocStart(), diag::warn_kern_is_inline) << FD;
4116 
4117  D->addAttr(::new (S.Context)
4118  CUDAGlobalAttr(Attr.getRange(), S.Context,
4120 }
4121 
4122 static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4123  FunctionDecl *Fn = cast<FunctionDecl>(D);
4124  if (!Fn->isInlineSpecified()) {
4125  S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4126  return;
4127  }
4128 
4129  D->addAttr(::new (S.Context)
4130  GNUInlineAttr(Attr.getRange(), S.Context,
4132 }
4133 
4134 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4135  if (hasDeclarator(D)) return;
4136 
4137  // Diagnostic is emitted elsewhere: here we store the (valid) Attr
4138  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
4139  CallingConv CC;
4140  if (S.CheckCallingConvAttr(Attr, CC, /*FD*/nullptr))
4141  return;
4142 
4143  if (!isa<ObjCMethodDecl>(D)) {
4144  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4145  << Attr.getName() << ExpectedFunctionOrMethod;
4146  return;
4147  }
4148 
4149  switch (Attr.getKind()) {
4150  case AttributeList::AT_FastCall:
4151  D->addAttr(::new (S.Context)
4152  FastCallAttr(Attr.getRange(), S.Context,
4154  return;
4155  case AttributeList::AT_StdCall:
4156  D->addAttr(::new (S.Context)
4157  StdCallAttr(Attr.getRange(), S.Context,
4159  return;
4160  case AttributeList::AT_ThisCall:
4161  D->addAttr(::new (S.Context)
4162  ThisCallAttr(Attr.getRange(), S.Context,
4164  return;
4165  case AttributeList::AT_CDecl:
4166  D->addAttr(::new (S.Context)
4167  CDeclAttr(Attr.getRange(), S.Context,
4169  return;
4170  case AttributeList::AT_Pascal:
4171  D->addAttr(::new (S.Context)
4172  PascalAttr(Attr.getRange(), S.Context,
4174  return;
4175  case AttributeList::AT_SwiftCall:
4176  D->addAttr(::new (S.Context)
4177  SwiftCallAttr(Attr.getRange(), S.Context,
4179  return;
4180  case AttributeList::AT_VectorCall:
4181  D->addAttr(::new (S.Context)
4182  VectorCallAttr(Attr.getRange(), S.Context,
4184  return;
4185  case AttributeList::AT_MSABI:
4186  D->addAttr(::new (S.Context)
4187  MSABIAttr(Attr.getRange(), S.Context,
4189  return;
4190  case AttributeList::AT_SysVABI:
4191  D->addAttr(::new (S.Context)
4192  SysVABIAttr(Attr.getRange(), S.Context,
4194  return;
4195  case AttributeList::AT_RegCall:
4196  D->addAttr(::new (S.Context) RegCallAttr(
4197  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4198  return;
4199  case AttributeList::AT_Pcs: {
4200  PcsAttr::PCSType PCS;
4201  switch (CC) {
4202  case CC_AAPCS:
4203  PCS = PcsAttr::AAPCS;
4204  break;
4205  case CC_AAPCS_VFP:
4206  PCS = PcsAttr::AAPCS_VFP;
4207  break;
4208  default:
4209  llvm_unreachable("unexpected calling convention in pcs attribute");
4210  }
4211 
4212  D->addAttr(::new (S.Context)
4213  PcsAttr(Attr.getRange(), S.Context, PCS,
4215  return;
4216  }
4217  case AttributeList::AT_IntelOclBicc:
4218  D->addAttr(::new (S.Context)
4219  IntelOclBiccAttr(Attr.getRange(), S.Context,
4221  return;
4222  case AttributeList::AT_PreserveMost:
4223  D->addAttr(::new (S.Context) PreserveMostAttr(
4224  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4225  return;
4226  case AttributeList::AT_PreserveAll:
4227  D->addAttr(::new (S.Context) PreserveAllAttr(
4228  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4229  return;
4230  default:
4231  llvm_unreachable("unexpected attribute kind");
4232  }
4233 }
4234 
4235 static void handleSuppressAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4236  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4237  return;
4238 
4239  std::vector<StringRef> DiagnosticIdentifiers;
4240  for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
4241  StringRef RuleName;
4242 
4243  if (!S.checkStringLiteralArgumentAttr(Attr, I, RuleName, nullptr))
4244  return;
4245 
4246  // FIXME: Warn if the rule name is unknown. This is tricky because only
4247  // clang-tidy knows about available rules.
4248  DiagnosticIdentifiers.push_back(RuleName);
4249  }
4250  D->addAttr(::new (S.Context) SuppressAttr(
4251  Attr.getRange(), S.Context, DiagnosticIdentifiers.data(),
4252  DiagnosticIdentifiers.size(), Attr.getAttributeSpellingListIndex()));
4253 }
4254 
4256  const FunctionDecl *FD) {
4257  if (attr.isInvalid())
4258  return true;
4259 
4260  if (attr.hasProcessingCache()) {
4261  CC = (CallingConv) attr.getProcessingCache();
4262  return false;
4263  }
4264 
4265  unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0;
4266  if (!checkAttributeNumArgs(*this, attr, ReqArgs)) {
4267  attr.setInvalid();
4268  return true;
4269  }
4270 
4271  // TODO: diagnose uses of these conventions on the wrong target.
4272  switch (attr.getKind()) {
4273  case AttributeList::AT_CDecl: CC = CC_C; break;
4274  case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
4275  case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
4276  case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
4277  case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
4278  case AttributeList::AT_SwiftCall: CC = CC_Swift; break;
4279  case AttributeList::AT_VectorCall: CC = CC_X86VectorCall; break;
4280  case AttributeList::AT_RegCall: CC = CC_X86RegCall; break;
4281  case AttributeList::AT_MSABI:
4282  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
4283  CC_Win64;
4284  break;
4285  case AttributeList::AT_SysVABI:
4286  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
4287  CC_C;
4288  break;
4289  case AttributeList::AT_Pcs: {
4290  StringRef StrRef;
4291  if (!checkStringLiteralArgumentAttr(attr, 0, StrRef)) {
4292  attr.setInvalid();
4293  return true;
4294  }
4295  if (StrRef == "aapcs") {
4296  CC = CC_AAPCS;
4297  break;
4298  } else if (StrRef == "aapcs-vfp") {
4299  CC = CC_AAPCS_VFP;
4300  break;
4301  }
4302 
4303  attr.setInvalid();
4304  Diag(attr.getLoc(), diag::err_invalid_pcs);
4305  return true;
4306  }
4307  case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
4308  case AttributeList::AT_PreserveMost: CC = CC_PreserveMost; break;
4309  case AttributeList::AT_PreserveAll: CC = CC_PreserveAll; break;
4310  default: llvm_unreachable("unexpected attribute kind");
4311  }
4312 
4313  const TargetInfo &TI = Context.getTargetInfo();
4315  if (A != TargetInfo::CCCR_OK) {
4316  if (A == TargetInfo::CCCR_Warning)
4317  Diag(attr.getLoc(), diag::warn_cconv_ignored) << attr.getName();
4318 
4319  // This convention is not valid for the target. Use the default function or
4320  // method calling convention.
4321  bool IsCXXMethod = false, IsVariadic = false;
4322  if (FD) {
4323  IsCXXMethod = FD->isCXXInstanceMember();
4324  IsVariadic = FD->isVariadic();
4325  }
4326  CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
4327  }
4328 
4329  attr.setProcessingCache((unsigned) CC);
4330  return false;
4331 }
4332 
4333 /// Pointer-like types in the default address space.
4335  if (!type->hasPointerRepresentation())
4336  return type->isDependentType();
4337  return type->getPointeeType().getAddressSpace() == 0;
4338 }
4339 
4340 /// Pointers and references in the default address space.
4342  if (auto ptrType = type->getAs<PointerType>()) {
4343  type = ptrType->getPointeeType();
4344  } else if (auto refType = type->getAs<ReferenceType>()) {
4345  type = refType->getPointeeType();
4346  } else {
4347  return type->isDependentType();
4348  }
4349  return type.getAddressSpace() == 0;
4350 }
4351 
4352 /// Pointers and references to pointers in the default address space.
4354  if (auto ptrType = type->getAs<PointerType>()) {
4355  type = ptrType->getPointeeType();
4356  } else if (auto refType = type->getAs<ReferenceType>()) {
4357  type = refType->getPointeeType();
4358  } else {
4359  return type->isDependentType();
4360  }
4361  if (!type.getQualifiers().empty())
4362  return false;
4363  return isValidSwiftContextType(type);
4364 }
4365 
4366 static void handleParameterABIAttr(Sema &S, Decl *D, const AttributeList &attr,
4367  ParameterABI abi) {
4368  S.AddParameterABIAttr(attr.getRange(), D, abi,
4370 }
4371 
4373  unsigned spellingIndex) {
4374 
4375  QualType type = cast<ParmVarDecl>(D)->getType();
4376 
4377  if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
4378  if (existingAttr->getABI() != abi) {
4379  Diag(range.getBegin(), diag::err_attributes_are_not_compatible)
4380  << getParameterABISpelling(abi) << existingAttr;
4381  Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
4382  return;
4383  }
4384  }
4385 
4386  switch (abi) {
4388  llvm_unreachable("explicit attribute for ordinary parameter ABI?");
4389 
4391  if (!isValidSwiftContextType(type)) {
4392  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4393  << getParameterABISpelling(abi)
4394  << /*pointer to pointer */ 0 << type;
4395  }
4396  D->addAttr(::new (Context)
4397  SwiftContextAttr(range, Context, spellingIndex));
4398  return;
4399 
4401  if (!isValidSwiftErrorResultType(type)) {
4402  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4403  << getParameterABISpelling(abi)
4404  << /*pointer to pointer */ 1 << type;
4405  }
4406  D->addAttr(::new (Context)
4407  SwiftErrorResultAttr(range, Context, spellingIndex));
4408  return;
4409 
4411  if (!isValidSwiftIndirectResultType(type)) {
4412  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4413  << getParameterABISpelling(abi)
4414  << /*pointer*/ 0 << type;
4415  }
4416  D->addAttr(::new (Context)
4417  SwiftIndirectResultAttr(range, Context, spellingIndex));
4418  return;
4419  }
4420  llvm_unreachable("bad parameter ABI attribute");
4421 }
4422 
4423 /// Checks a regparm attribute, returning true if it is ill-formed and
4424 /// otherwise setting numParams to the appropriate value.
4425 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
4426  if (Attr.isInvalid())
4427  return true;
4428 
4429  if (!checkAttributeNumArgs(*this, Attr, 1)) {
4430  Attr.setInvalid();
4431  return true;
4432  }
4433 
4434  uint32_t NP;
4435  Expr *NumParamsExpr = Attr.getArgAsExpr(0);
4436  if (!checkUInt32Argument(*this, Attr, NumParamsExpr, NP)) {
4437  Attr.setInvalid();
4438  return true;
4439  }
4440 
4441  if (Context.getTargetInfo().getRegParmMax() == 0) {
4442  Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
4443  << NumParamsExpr->getSourceRange();
4444  Attr.setInvalid();
4445  return true;
4446  }
4447 
4448  numParams = NP;
4449  if (numParams > Context.getTargetInfo().getRegParmMax()) {
4450  Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
4451  << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4452  Attr.setInvalid();
4453  return true;
4454  }
4455 
4456  return false;
4457 }
4458 
4459 // Checks whether an argument of launch_bounds attribute is
4460 // acceptable, performs implicit conversion to Rvalue, and returns
4461 // non-nullptr Expr result on success. Otherwise, it returns nullptr
4462 // and may output an error.
4464  const CUDALaunchBoundsAttr &Attr,
4465  const unsigned Idx) {
4467  return nullptr;
4468 
4469  // Accept template arguments for now as they depend on something else.
4470  // We'll get to check them when they eventually get instantiated.
4471  if (E->isValueDependent())
4472  return E;
4473 
4474  llvm::APSInt I(64);
4475  if (!E->isIntegerConstantExpr(I, S.Context)) {
4476  S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
4477  << &Attr << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
4478  return nullptr;
4479  }
4480  // Make sure we can fit it in 32 bits.
4481  if (!I.isIntN(32)) {
4482  S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
4483  << 32 << /* Unsigned */ 1;
4484  return nullptr;
4485  }
4486  if (I < 0)
4487  S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
4488  << &Attr << Idx << E->getSourceRange();
4489 
4490  // We may need to perform implicit conversion of the argument.
4492  S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
4493  ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
4494  assert(!ValArg.isInvalid() &&
4495  "Unexpected PerformCopyInitialization() failure.");
4496 
4497  return ValArg.getAs<Expr>();
4498 }
4499 
4500 void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
4501  Expr *MinBlocks, unsigned SpellingListIndex) {
4502  CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
4503  SpellingListIndex);
4504  MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
4505  if (MaxThreads == nullptr)
4506  return;
4507 
4508  if (MinBlocks) {
4509  MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
4510  if (MinBlocks == nullptr)
4511  return;
4512  }
4513 
4514  D->addAttr(::new (Context) CUDALaunchBoundsAttr(
4515  AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
4516 }
4517 
4519  const AttributeList &Attr) {
4520  if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
4521  !checkAttributeAtMostNumArgs(S, Attr, 2))
4522  return;
4523 
4524  S.AddLaunchBoundsAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
4525  Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr,
4527 }
4528 
4530  const AttributeList &Attr) {
4531  if (!Attr.isArgIdent(0)) {
4532  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
4533  << Attr.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
4534  return;
4535  }
4536 
4537  if (!checkAttributeNumArgs(S, Attr, 3))
4538  return;
4539 
4540  IdentifierInfo *ArgumentKind = Attr.getArgAsIdent(0)->Ident;
4541 
4542  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
4543  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
4544  << Attr.getName() << ExpectedFunctionOrMethod;
4545  return;
4546  }
4547 
4548  uint64_t ArgumentIdx;
4549  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 2, Attr.getArgAsExpr(1),
4550  ArgumentIdx))
4551  return;
4552 
4553  uint64_t TypeTagIdx;
4554  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 3, Attr.getArgAsExpr(2),
4555  TypeTagIdx))
4556  return;
4557 
4558  bool IsPointer = (Attr.getName()->getName() == "pointer_with_type_tag");
4559  if (IsPointer) {
4560  // Ensure that buffer has a pointer type.
4561  QualType BufferTy = getFunctionOrMethodParamType(D, ArgumentIdx);
4562  if (!BufferTy->isPointerType()) {
4563  S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
4564  << Attr.getName() << 0;
4565  }
4566  }
4567 
4568  D->addAttr(::new (S.Context)
4569  ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
4570  ArgumentIdx, TypeTagIdx, IsPointer,
4572 }
4573 
4575  const AttributeList &Attr) {
4576  if (!Attr.isArgIdent(0)) {
4577  S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
4578  << Attr.getName() << 1 << AANT_ArgumentIdentifier;
4579  return;
4580  }
4581 
4582  if (!checkAttributeNumArgs(S, Attr, 1))
4583  return;
4584 
4585  if (!isa<VarDecl>(D)) {
4586  S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
4587  << Attr.getName() << ExpectedVariable;
4588  return;
4589  }
4590 
4591  IdentifierInfo *PointerKind = Attr.getArgAsIdent(0)->Ident;
4592  TypeSourceInfo *MatchingCTypeLoc = nullptr;
4593  S.GetTypeFromParser(Attr.getMatchingCType(), &MatchingCTypeLoc);
4594  assert(MatchingCTypeLoc && "no type source info for attribute argument");
4595 
4596  D->addAttr(::new (S.Context)
4597  TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
4598  MatchingCTypeLoc,
4599  Attr.getLayoutCompatible(),
4600  Attr.getMustBeNull(),
4602 }
4603 
4605  const AttributeList &Attr) {
4606  uint64_t ArgCount;
4607 
4608  if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, Attr.getArgAsExpr(0),
4609  ArgCount,
4610  true /* AllowImplicitThis*/))
4611  return;
4612 
4613  // ArgCount isn't a parameter index [0;n), it's a count [1;n] - hence + 1.
4614  D->addAttr(::new (S.Context)
4615  XRayLogArgsAttr(Attr.getRange(), S.Context, ++ArgCount,
4617 }
4618 
4619 //===----------------------------------------------------------------------===//
4620 // Checker-specific attribute handlers.
4621 //===----------------------------------------------------------------------===//
4622 
4624  return type->isDependentType() ||
4625  type->isObjCRetainableType();
4626 }
4627 
4629  return type->isDependentType() ||
4630  type->isObjCObjectPointerType() ||
4631  S.Context.isObjCNSObjectType(type);
4632 }
4633 
4635  return type->isDependentType() ||
4636  type->isPointerType() ||
4637  isValidSubjectOfNSAttribute(S, type);
4638 }
4639 
4640 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4642  Attr.getKind() == AttributeList::AT_NSConsumed,
4643  /*template instantiation*/ false);
4644 }
4645 
4647  unsigned spellingIndex, bool isNSConsumed,
4648  bool isTemplateInstantiation) {
4649  ParmVarDecl *param = cast<ParmVarDecl>(D);
4650  bool typeOK;
4651 
4652  if (isNSConsumed) {
4653  typeOK = isValidSubjectOfNSAttribute(*this, param->getType());
4654  } else {
4655  typeOK = isValidSubjectOfCFAttribute(*this, param->getType());
4656  }
4657 
4658  if (!typeOK) {
4659  // These attributes are normally just advisory, but in ARC, ns_consumed
4660  // is significant. Allow non-dependent code to contain inappropriate
4661  // attributes even in ARC, but require template instantiations to be
4662  // set up correctly.
4663  Diag(D->getLocStart(),
4664  (isTemplateInstantiation && isNSConsumed &&
4665  getLangOpts().ObjCAutoRefCount
4666  ? diag::err_ns_attribute_wrong_parameter_type
4667  : diag::warn_ns_attribute_wrong_parameter_type))
4668  << attrRange
4669  << (isNSConsumed ? "ns_consumed" : "cf_consumed")
4670  << (isNSConsumed ? /*objc pointers*/ 0 : /*cf pointers*/ 1);
4671  return;
4672  }
4673 
4674  if (isNSConsumed)
4675  param->addAttr(::new (Context)
4676  NSConsumedAttr(attrRange, Context, spellingIndex));
4677  else
4678  param->addAttr(::new (Context)
4679  CFConsumedAttr(attrRange, Context, spellingIndex));
4680 }
4681 
4683  QualType type) {
4685  return false;
4686 
4687  Diag(loc, diag::warn_ns_attribute_wrong_return_type)
4688  << "'ns_returns_retained'" << 0 << 0;
4689  return true;
4690 }
4691 
4693  const AttributeList &Attr) {
4694  QualType returnType;
4695 
4696  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
4697  returnType = MD->getReturnType();
4698  else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
4699  (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
4700  return; // ignore: was handled as a type attribute
4701  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
4702  returnType = PD->getType();
4703  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
4704  returnType = FD->getReturnType();
4705  else if (auto *Param = dyn_cast<ParmVarDecl>(D)) {
4706  returnType = Param->getType()->getPointeeType();
4707  if (returnType.isNull()) {
4708  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4709  << Attr.getName() << /*pointer-to-CF*/2
4710  << Attr.getRange();
4711  return;
4712  }
4713  } else if (Attr.isUsedAsTypeAttr()) {
4714  return;
4715  } else {
4716  AttributeDeclKind ExpectedDeclKind;
4717  switch (Attr.getKind()) {
4718  default: llvm_unreachable("invalid ownership attribute");
4719  case AttributeList::AT_NSReturnsRetained:
4720  case AttributeList::AT_NSReturnsAutoreleased:
4721  case AttributeList::AT_NSReturnsNotRetained:
4722  ExpectedDeclKind = ExpectedFunctionOrMethod;
4723  break;
4724 
4725  case AttributeList::AT_CFReturnsRetained:
4726  case AttributeList::AT_CFReturnsNotRetained:
4727  ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
4728  break;
4729  }
4730  S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4731  << Attr.getRange() << Attr.getName() << ExpectedDeclKind;
4732  return;
4733  }
4734 
4735  bool typeOK;
4736  bool cf;
4737  switch (Attr.getKind()) {
4738  default: llvm_unreachable("invalid ownership attribute");
4739  case AttributeList::AT_NSReturnsRetained:
4740  typeOK = isValidSubjectOfNSReturnsRetainedAttribute(returnType);
4741  cf = false;
4742  break;
4743 
4744  case AttributeList::AT_NSReturnsAutoreleased:
4745  case AttributeList::AT_NSReturnsNotRetained:
4746  typeOK = isValidSubjectOfNSAttribute(S, returnType);
4747  cf = false;
4748  break;
4749 
4750  case AttributeList::AT_CFReturnsRetained:
4751  case AttributeList::AT_CFReturnsNotRetained:
4752  typeOK = isValidSubjectOfCFAttribute(S, returnType);
4753  cf = true;
4754  break;
4755  }
4756 
4757  if (!typeOK) {
4758  if (Attr.isUsedAsTypeAttr())
4759  return;
4760 
4761  if (isa<ParmVarDecl>(D)) {
4762  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4763  << Attr.getName() << /*pointer-to-CF*/2
4764  << Attr.getRange();
4765  } else {
4766  // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
4767  enum : unsigned {
4768  Function,
4769  Method,
4770  Property
4771  } SubjectKind = Function;
4772  if (isa<ObjCMethodDecl>(D))
4773  SubjectKind = Method;
4774  else if (isa<ObjCPropertyDecl>(D))
4775  SubjectKind = Property;
4776  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4777  << Attr.getName() << SubjectKind << cf
4778  << Attr.getRange();
4779  }
4780  return;
4781  }
4782 
4783  switch (Attr.getKind()) {
4784  default:
4785  llvm_unreachable("invalid ownership attribute");
4786  case AttributeList::AT_NSReturnsAutoreleased:
4787  D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
4788  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4789  return;
4790  case AttributeList::AT_CFReturnsNotRetained:
4791  D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
4792  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4793  return;
4794  case AttributeList::AT_NSReturnsNotRetained:
4795  D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
4796  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4797  return;
4798  case AttributeList::AT_CFReturnsRetained:
4799  D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
4800  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4801  return;
4802  case AttributeList::AT_NSReturnsRetained:
4803  D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
4804  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4805  return;
4806  };
4807 }
4808 
4810  const AttributeList &attr) {
4811  const int EP_ObjCMethod = 1;
4812  const int EP_ObjCProperty = 2;
4813 
4814  SourceLocation loc = attr.getLoc();
4815  QualType resultType;
4816  if (isa<ObjCMethodDecl>(D))
4817  resultType = cast<ObjCMethodDecl>(D)->getReturnType();
4818  else
4819  resultType = cast<ObjCPropertyDecl>(D)->getType();
4820 
4821  if (!resultType->isReferenceType() &&
4822  (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
4823  S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4824  << SourceRange(loc)
4825  << attr.getName()
4826  << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
4827  << /*non-retainable pointer*/ 2;
4828 
4829  // Drop the attribute.
4830  return;
4831  }
4832 
4833  D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
4834  attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
4835 }
4836 
4838  const AttributeList &attr) {
4839  ObjCMethodDecl *method = cast<ObjCMethodDecl>(D);
4840 
4841  DeclContext *DC = method->getDeclContext();
4842  if (const ObjCProtocolDecl *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
4843  S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4844  << attr.getName() << 0;
4845  S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
4846  return;
4847  }
4848  if (method->getMethodFamily() == OMF_dealloc) {
4849  S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4850  << attr.getName() << 1;
4851  return;
4852  }
4853 
4854  method->addAttr(::new (S.Context)
4855  ObjCRequiresSuperAttr(attr.getRange(), S.Context,
4857 }
4858 
4860  const AttributeList &Attr) {
4861  if (checkAttrMutualExclusion<CFUnknownTransferAttr>(S, D, Attr.getRange(),
4862  Attr.getName()))
4863  return;
4864 
4865  D->addAttr(::new (S.Context)
4866  CFAuditedTransferAttr(Attr.getRange(), S.Context,
4868 }
4869 
4871  const AttributeList &Attr) {
4872  if (checkAttrMutualExclusion<CFAuditedTransferAttr>(S, D, Attr.getRange(),
4873  Attr.getName()))
4874  return;
4875 
4876  D->addAttr(::new (S.Context)
4877  CFUnknownTransferAttr(Attr.getRange(), S.Context,
4879 }
4880 
4881 static void handleObjCBridgeAttr(Sema &S, Scope *Sc, Decl *D,
4882  const AttributeList &Attr) {
4883  IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
4884 
4885  if (!Parm) {
4886  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4887  return;
4888  }
4889 
4890  // Typedefs only allow objc_bridge(id) and have some additional checking.
4891  if (auto TD = dyn_cast<TypedefNameDecl>(D)) {
4892  if (!Parm->Ident->isStr("id")) {
4893  S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_id)
4894  << Attr.getName();
4895  return;
4896  }
4897 
4898  // Only allow 'cv void *'.
4899  QualType T = TD->getUnderlyingType();
4900  if (!T->isVoidPointerType()) {
4901  S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
4902  return;
4903  }
4904  }
4905 
4906  D->addAttr(::new (S.Context)
4907  ObjCBridgeAttr(Attr.getRange(), S.Context, Parm->Ident,
4909 }
4910 
4912  const AttributeList &Attr) {
4913  IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
4914 
4915  if (!Parm) {
4916  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4917  return;
4918  }
4919 
4920  D->addAttr(::new (S.Context)
4921  ObjCBridgeMutableAttr(Attr.getRange(), S.Context, Parm->Ident,
4923 }
4924 
4926  const AttributeList &Attr) {
4927  IdentifierInfo *RelatedClass =
4928  Attr.isArgIdent(0) ? Attr.getArgAsIdent(0)->Ident : nullptr;
4929  if (!RelatedClass) {
4930  S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4931  return;
4932  }
4933  IdentifierInfo *ClassMethod =
4934  Attr.getArgAsIdent(1) ? Attr.getArgAsIdent(1)->Ident : nullptr;
4935  IdentifierInfo *InstanceMethod =
4936  Attr.getArgAsIdent(2) ? Attr.getArgAsIdent(2)->Ident : nullptr;
4937  D->addAttr(::new (S.Context)
4938  ObjCBridgeRelatedAttr(Attr.getRange(), S.Context, RelatedClass,
4939  ClassMethod, InstanceMethod,
4941 }
4942 
4944  const AttributeList &Attr) {
4945  ObjCInterfaceDecl *IFace;
4946  if (ObjCCategoryDecl *CatDecl =
4947  dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
4948  IFace = CatDecl->getClassInterface();
4949  else
4950  IFace = cast<ObjCInterfaceDecl>(D->getDeclContext());
4951 
4952  if (!IFace)
4953  return;
4954 
4956  D->addAttr(::new (S.Context)
4957  ObjCDesignatedInitializerAttr(Attr.getRange(), S.Context,
4959 }
4960 
4962  const AttributeList &Attr) {
4963  StringRef MetaDataName;
4964  if (!S.checkStringLiteralArgumentAttr(Attr, 0, MetaDataName))
4965  return;
4966  D->addAttr(::new (S.Context)
4967  ObjCRuntimeNameAttr(Attr.getRange(), S.Context,
4968  MetaDataName,
4970 }
4971 
4972 // When a user wants to use objc_boxable with a union or struct
4973 // but they don't have access to the declaration (legacy/third-party code)
4974 // then they can 'enable' this feature with a typedef:
4975 // typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
4976 static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr) {
4977  bool notify = false;
4978 
4979  RecordDecl *RD = dyn_cast<RecordDecl>(D);
4980  if (RD && RD->getDefinition()) {
4981  RD = RD->getDefinition();
4982  notify = true;
4983  }
4984 
4985  if (RD) {
4986  ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
4987  ObjCBoxableAttr(Attr.getRange(), S.Context,
4989  RD->addAttr(BoxableAttr);
4990  if (notify) {
4991  // we need to notify ASTReader/ASTWriter about
4992  // modification of existing declaration
4994  L->AddedAttributeToRecord(BoxableAttr, RD);
4995  }
4996  }
4997 }
4998 
5000  const AttributeList &Attr) {
5001  if (hasDeclarator(D)) return;
5002 
5003  S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
5004  << Attr.getRange() << Attr.getName() << ExpectedVariable;
5005 }
5006 
5008  const AttributeList &Attr) {
5009  ValueDecl *vd = cast<ValueDecl>(D);
5010  QualType type = vd->getType();
5011 
5012  if (!type->isDependentType() &&
5013  !type->isObjCLifetimeType()) {
5014  S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
5015  << type;
5016  return;
5017  }
5018 
5019  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5020 
5021  // If we have no lifetime yet, check the lifetime we're presumably
5022  // going to infer.
5023  if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
5024  lifetime = type->getObjCARCImplicitLifetime();
5025 
5026  switch (lifetime) {
5027  case Qualifiers::OCL_None:
5028  assert(type->isDependentType() &&
5029  "didn't infer lifetime for non-dependent type?");
5030  break;
5031 
5032  case Qualifiers::OCL_Weak: // meaningful
5033  case Qualifiers::OCL_Strong: // meaningful
5034  break;
5035 
5038  S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
5039  << (lifetime == Qualifiers::OCL_Autoreleasing);
5040  break;
5041  }
5042 
5043  D->addAttr(::new (S.Context)
5044  ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
5046 }
5047 
5048 //===----------------------------------------------------------------------===//
5049 // Microsoft specific attribute handlers.
5050 //===----------------------------------------------------------------------===//
5051 
5053  unsigned AttrSpellingListIndex, StringRef Uuid) {
5054  if (const auto *UA = D->getAttr<UuidAttr>()) {
5055  if (UA->getGuid().equals_lower(Uuid))
5056  return nullptr;
5057  Diag(UA->getLocation(), diag::err_mismatched_uuid);
5058  Diag(Range.getBegin(), diag::note_previous_uuid);
5059  D->dropAttr<UuidAttr>();
5060  }
5061 
5062  return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
5063 }
5064 
5065 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5066  if (!S.LangOpts.CPlusPlus) {
5067  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
5068  << Attr.getName() << AttributeLangSupport::C;
5069  return;
5070  }
5071 
5072  StringRef StrRef;
5073  SourceLocation LiteralLoc;
5074  if (!S.checkStringLiteralArgumentAttr(Attr, 0, StrRef, &LiteralLoc))
5075  return;
5076 
5077  // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
5078  // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
5079  if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
5080  StrRef = StrRef.drop_front().drop_back();
5081 
5082  // Validate GUID length.
5083  if (StrRef.size() != 36) {
5084  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5085  return;
5086  }
5087 
5088  for (unsigned i = 0; i < 36; ++i) {
5089  if (i == 8 || i == 13 || i == 18 || i == 23) {
5090  if (StrRef[i] != '-') {
5091  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5092  return;
5093  }
5094  } else if (!isHexDigit(StrRef[i])) {
5095  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5096  return;
5097  }
5098  }
5099 
5100  // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's
5101  // the only thing in the [] list, the [] too), and add an insertion of
5102  // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas
5103  // separating attributes nor of the [ and the ] are in the AST.
5104  // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc"
5105  // on cfe-dev.
5106  if (Attr.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.
5107  S.Diag(Attr.getLoc(), diag::warn_atl_uuid_deprecated);
5108 
5109  UuidAttr *UA = S.mergeUuidAttr(D, Attr.getRange(),
5110  Attr.getAttributeSpellingListIndex(), StrRef);
5111  if (UA)
5112  D->addAttr(UA);
5113 }
5114 
5116  if (!S.LangOpts.CPlusPlus) {
5117  S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
5118  << Attr.getName() << AttributeLangSupport::C;
5119  return;
5120  }
5121  MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
5122  D, Attr.getRange(), /*BestCase=*/true,
5124  (MSInheritanceAttr::Spelling)Attr.getSemanticSpelling());
5125  if (IA) {
5126  D->addAttr(IA);
5127  S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
5128  }
5129 }
5130 
5132  const AttributeList &Attr) {
5133  VarDecl *VD = cast<VarDecl>(D);
5134  if (!S.Context.getTargetInfo().isTLSSupported()) {
5135  S.Diag(Attr.getLoc(), diag::err_thread_unsupported);
5136  return;
5137  }
5138  if (VD->getTSCSpec() != TSCS_unspecified) {
5139  S.Diag(Attr.getLoc(), diag::err_declspec_thread_on_thread_variable);
5140  return;
5141  }
5142  if (VD->hasLocalStorage()) {
5143  S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
5144  return;
5145  }
5146  VD->addAttr(::new (S.Context) ThreadAttr(
5147  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
5148 }
5149 
5150 static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5152  for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
5153  StringRef Tag;
5154  if (!S.checkStringLiteralArgumentAttr(Attr, I, Tag))
5155  return;
5156  Tags.push_back(Tag);
5157  }
5158 
5159  if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
5160  if (!NS->isInline()) {
5161  S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5162  return;
5163  }
5164  if (NS->isAnonymousNamespace()) {
5165  S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5166  return;
5167  }
5168  if (Attr.getNumArgs() == 0)
5169  Tags.push_back(NS->getName());
5170  } else if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5171  return;
5172 
5173  // Store tags sorted and without duplicates.
5174  std::sort(Tags.begin(), Tags.end());
5175  Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5176 
5177  D->addAttr(::new (S.Context)
5178  AbiTagAttr(Attr.getRange(), S.Context, Tags.data(), Tags.size(),
5180 }
5181 
5183  const AttributeList &Attr) {
5184  // Check the attribute arguments.
5185  if (Attr.getNumArgs() > 1) {
5186  S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
5187  << Attr.getName() << 1;
5188  return;
5189  }
5190 
5191  StringRef Str;
5192  SourceLocation ArgLoc;
5193 
5194  if (Attr.getNumArgs() == 0)
5195  Str = "";
5196  else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
5197  return;
5198 
5199  ARMInterruptAttr::InterruptType Kind;
5200  if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5201  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
5202  << Attr.getName() << Str << ArgLoc;
5203  return;
5204  }
5205 
5206  unsigned Index = Attr.getAttributeSpellingListIndex();
5207  D->addAttr(::new (S.Context)
5208  ARMInterruptAttr(Attr.getLoc(), S.Context, Kind, Index));
5209 }
5210 
5212  const AttributeList &Attr) {
5213  if (!checkAttributeNumArgs(S, Attr, 1))
5214  return;
5215 
5216  if (!Attr.isArgExpr(0)) {
5217  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
5219  return;
5220  }
5221 
5222  // FIXME: Check for decl - it should be void ()(void).
5223 
5224  Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
5225  llvm::APSInt NumParams(32);
5226  if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
5227  S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
5229  << NumParamsExpr->getSourceRange();
5230  return;
5231  }
5232 
5233  unsigned Num = NumParams.getLimitedValue(255);
5234  if ((Num & 1) || Num > 30) {
5235  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
5236  << Attr.getName() << (int)NumParams.getSExtValue()
5237  << NumParamsExpr->getSourceRange();
5238  return;
5239  }
5240 
5241  D->addAttr(::new (S.Context)
5242  MSP430InterruptAttr(Attr.getLoc(), S.Context, Num,
5244  D->addAttr(UsedAttr::CreateImplicit(S.Context));
5245 }
5246 
5248  const AttributeList &Attr) {
5249  // Only one optional argument permitted.
5250  if (Attr.getNumArgs() > 1) {
5251  S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
5252  << Attr.getName() << 1;
5253  return;
5254  }
5255 
5256  StringRef Str;
5257  SourceLocation ArgLoc;
5258 
5259  if (Attr.getNumArgs() == 0)
5260  Str = "";
5261  else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
5262  return;
5263 
5264  // Semantic checks for a function with the 'interrupt' attribute for MIPS:
5265  // a) Must be a function.
5266  // b) Must have no parameters.
5267  // c) Must have the 'void' return type.
5268  // d) Cannot have the 'mips16' attribute, as that instruction set
5269  // lacks the 'eret' instruction.
5270  // e) The attribute itself must either have no argument or one of the
5271  // valid interrupt types, see [MipsInterruptDocs].
5272 
5273  if (!isFunctionOrMethod(D)) {
5274  S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5275  << "'interrupt'" << ExpectedFunctionOrMethod;
5276  return;
5277  }
5278 
5279  if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5280  S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5281  << 0;
5282  return;
5283  }
5284 
5286  S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5287  << 1;
5288  return;
5289  }
5290 
5291  if (checkAttrMutualExclusion<Mips16Attr>(S, D, Attr.getRange(),
5292  Attr.getName()))
5293  return;
5294 
5295  MipsInterruptAttr::InterruptType Kind;
5296  if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5297  S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
5298  << Attr.getName() << "'" + std::string(Str) + "'";
5299  return;
5300  }
5301 
5302  D->addAttr(::new (S.Context) MipsInterruptAttr(
5303  Attr.getLoc(), S.Context, Kind, Attr.getAttributeSpellingListIndex()));
5304 }
5305 
5307  const AttributeList &Attr) {
5308  // Semantic checks for a function with the 'interrupt' attribute.
5309  // a) Must be a function.
5310  // b) Must have the 'void' return type.
5311  // c) Must take 1 or 2 arguments.
5312  // d) The 1st argument must be a pointer.
5313  // e) The 2nd argument (if any) must be an unsigned integer.
5314  if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) ||
5316  cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {
5317  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
5319  return;
5320  }
5321  // Interrupt handler must have void return type.
5322  if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5324  diag::err_anyx86_interrupt_attribute)
5325  << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5326  ? 0
5327  : 1)
5328  << 0;
5329  return;
5330  }
5331  // Interrupt handler must have 1 or 2 parameters.
5332  unsigned NumParams = getFunctionOrMethodNumParams(D);
5333  if (NumParams < 1 || NumParams > 2) {
5334  S.Diag(D->getLocStart(), diag::err_anyx86_interrupt_attribute)
5335  << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5336  ? 0
5337  : 1)
5338  << 1;
5339  return;
5340  }
5341  // The first argument must be a pointer.
5343  S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(),
5344  diag::err_anyx86_interrupt_attribute)
5345  << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5346  ? 0
5347  : 1)
5348  << 2;
5349  return;
5350  }
5351  // The second argument, if present, must be an unsigned integer.
5352  unsigned TypeSize =
5353  S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86_64
5354  ? 64
5355  : 32;
5356  if (NumParams == 2 &&
5357  (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
5358  S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
5359  S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
5360  diag::err_anyx86_interrupt_attribute)
5361  << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5362  ? 0
5363  : 1)
5364  << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
5365  return;
5366  }
5367  D->addAttr(::new (S.Context) AnyX86InterruptAttr(
5368  Attr.getLoc(), S.Context, Attr.getAttributeSpellingListIndex()));
5369  D->addAttr(UsedAttr::CreateImplicit(S.Context));
5370 }
5371 
5373  if (!isFunctionOrMethod(D)) {
5374  S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5375  << "'interrupt'" << ExpectedFunction;
5376  return;
5377  }
5378 
5379  if (!checkAttributeNumArgs(S, Attr, 0))
5380  return;
5381 
5382  handleSimpleAttribute<AVRInterruptAttr>(S, D, Attr);
5383 }
5384 
5385 static void handleAVRSignalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5386  if (!isFunctionOrMethod(D)) {
5387  S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5388  << "'signal'" << ExpectedFunction;
5389  return;
5390  }
5391 
5392  if (!checkAttributeNumArgs(S, Attr, 0))
5393  return;
5394 
5395  handleSimpleAttribute<AVRSignalAttr>(S, D, Attr);
5396 }
5397 
5398 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5399  // Dispatch the interrupt attribute based on the current target.
5400  switch (S.Context.getTargetInfo().getTriple().getArch()) {
5401  case llvm::Triple::msp430:
5402  handleMSP430InterruptAttr(S, D, Attr);
5403  break;
5404  case llvm::Triple::mipsel:
5405  case llvm::Triple::mips:
5406  handleMipsInterruptAttr(S, D, Attr);
5407  break;
5408  case llvm::Triple::x86:
5409  case llvm::Triple::x86_64:
5410  handleAnyX86InterruptAttr(S, D, Attr);
5411  break;
5412  case llvm::Triple::avr:
5413  handleAVRInterruptAttr(S, D, Attr);
5414  break;
5415  default:
5416  handleARMInterruptAttr(S, D, Attr);
5417  break;
5418  }
5419 }
5420 
5422  const AttributeList &Attr) {
5423  uint32_t Min = 0;
5424  Expr *MinExpr = Attr.getArgAsExpr(0);
5425  if (!checkUInt32Argument(S, Attr, MinExpr, Min))
5426  return;
5427 
5428  uint32_t Max = 0;
5429  Expr *MaxExpr = Attr.getArgAsExpr(1);
5430  if (!checkUInt32Argument(S, Attr, MaxExpr, Max))
5431  return;
5432 
5433  if (Min == 0 && Max != 0) {
5434  S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5435  << Attr.getName() << 0;
5436  return;
5437  }
5438  if (Min > Max) {
5439  S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5440  << Attr.getName() << 1;
5441  return;
5442  }
5443 
5444  D->addAttr(::new (S.Context)
5445  AMDGPUFlatWorkGroupSizeAttr(Attr.getLoc(), S.Context, Min, Max,
5447 }
5448 
5450  const AttributeList &Attr) {
5451  uint32_t Min = 0;
5452  Expr *MinExpr = Attr.getArgAsExpr(0);
5453  if (!checkUInt32Argument(S, Attr, MinExpr, Min))
5454  return;
5455 
5456  uint32_t Max = 0;
5457  if (Attr.getNumArgs() == 2) {
5458  Expr *MaxExpr = Attr.getArgAsExpr(1);
5459  if (!checkUInt32Argument(S, Attr, MaxExpr, Max))
5460  return;
5461  }
5462 
5463  if (Min == 0 && Max != 0) {
5464  S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5465  << Attr.getName() << 0;
5466  return;
5467  }
5468  if (Max != 0 && Min > Max) {
5469  S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5470  << Attr.getName() << 1;
5471  return;
5472  }
5473 
5474  D->addAttr(::new (S.Context)
5475  AMDGPUWavesPerEUAttr(Attr.getLoc(), S.Context, Min, Max,
5477 }
5478 
5480  const AttributeList &Attr) {
5481  uint32_t NumSGPR = 0;
5482  Expr *NumSGPRExpr = Attr.getArgAsExpr(0);
5483  if (!checkUInt32Argument(S, Attr, NumSGPRExpr, NumSGPR))
5484  return;
5485 
5486  D->addAttr(::new (S.Context)
5487  AMDGPUNumSGPRAttr(Attr.getLoc(), S.Context, NumSGPR,
5489 }
5490 
5492  const AttributeList &Attr) {
5493  uint32_t NumVGPR = 0;
5494  Expr *NumVGPRExpr = Attr.getArgAsExpr(0);
5495  if (!checkUInt32Argument(S, Attr, NumVGPRExpr, NumVGPR))
5496  return;
5497 
5498  D->addAttr(::new (S.Context)
5499  AMDGPUNumVGPRAttr(Attr.getLoc(), S.Context, NumVGPR,
5501 }
5502 
5504  const AttributeList& Attr) {
5505  // If we try to apply it to a function pointer, don't warn, but don't
5506  // do anything, either. It doesn't matter anyway, because there's nothing
5507  // special about calling a force_align_arg_pointer function.
5508  ValueDecl *VD = dyn_cast<ValueDecl>(D);
5509  if (VD && VD->getType()->isFunctionPointerType())
5510  return;
5511  // Also don't warn on function pointer typedefs.
5512  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
5513  if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
5515  return;
5516  // Attribute can only be applied to function types.
5517  if (!isa<FunctionDecl>(D)) {
5518  S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
5519  << Attr.getName() << /* function */0;
5520  return;
5521  }
5522 
5523  D->addAttr(::new (S.Context)
5524  X86ForceAlignArgPointerAttr(Attr.getRange(), S.Context,
5526 }
5527 
5528 static void handleLayoutVersion(Sema &S, Decl *D, const AttributeList &Attr) {
5529  uint32_t Version;
5530  Expr *VersionExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
5531  if (!checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), Version))
5532  return;
5533 
5534  // TODO: Investigate what happens with the next major version of MSVC.
5535  if (Version != LangOptions::MSVC2015) {
5536  S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
5537  << Attr.getName() << Version << VersionExpr->getSourceRange();
5538  return;
5539  }
5540 
5541  D->addAttr(::new (S.Context)
5542  LayoutVersionAttr(Attr.getRange(), S.Context, Version,
5544 }
5545 
5546 DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
5547  unsigned AttrSpellingListIndex) {
5548  if (D->hasAttr<DLLExportAttr>()) {
5549  Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
5550  return nullptr;
5551  }
5552 
5553  if (D->hasAttr<DLLImportAttr>())
5554  return nullptr;
5555 
5556  return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
5557 }
5558 
5559 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
5560  unsigned AttrSpellingListIndex) {
5561  if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
5562  Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
5563  D->dropAttr<DLLImportAttr>();
5564  }
5565 
5566  if (D->hasAttr<DLLExportAttr>())
5567  return nullptr;
5568 
5569  return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
5570 }
5571 
5572 static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A) {
5573  if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
5575  S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
5576  << A.getName();
5577  return;
5578  }
5579 
5580  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
5581  if (FD->isInlined() && A.getKind() == AttributeList::AT_DLLImport &&
5583  // MinGW doesn't allow dllimport on inline functions.
5584  S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
5585  << A.getName();
5586  return;
5587  }
5588  }
5589 
5590  if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {
5592  MD->getParent()->isLambda()) {
5593  S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A.getName();
5594  return;
5595  }
5596  }
5597 
5598  unsigned Index = A.getAttributeSpellingListIndex();
5599  Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
5600  ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
5601  : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
5602  if (NewAttr)
5603  D->addAttr(NewAttr);
5604 }
5605 
5606 MSInheritanceAttr *
5608  unsigned AttrSpellingListIndex,
5609  MSInheritanceAttr::Spelling SemanticSpelling) {
5610  if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
5611  if (IA->getSemanticSpelling() == SemanticSpelling)
5612  return nullptr;
5613  Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
5614  << 1 /*previous declaration*/;
5615  Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
5616  D->dropAttr<MSInheritanceAttr>();
5617  }
5618 
5619  CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
5620  if (RD->hasDefinition()) {
5621  if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
5622  SemanticSpelling)) {
5623  return nullptr;
5624  }
5625  } else {
5626  if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
5627  Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5628  << 1 /*partial specialization*/;
5629  return nullptr;
5630  }
5631  if (RD->getDescribedClassTemplate()) {
5632  Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5633  << 0 /*primary template*/;
5634  return nullptr;
5635  }
5636  }
5637 
5638  return ::new (Context)
5639  MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
5640 }
5641 
5642 static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5643  // The capability attributes take a single string parameter for the name of
5644  // the capability they represent. The lockable attribute does not take any
5645  // parameters. However, semantically, both attributes represent the same
5646  // concept, and so they use the same semantic attribute. Eventually, the
5647  // lockable attribute will be removed.
5648  //
5649  // For backward compatibility, any capability which has no specified string
5650  // literal will be considered a "mutex."
5651  StringRef N("mutex");
5652  SourceLocation LiteralLoc;
5653  if (Attr.getKind() == AttributeList::AT_Capability &&
5654  !S.checkStringLiteralArgumentAttr(Attr, 0, N, &LiteralLoc))
5655  return;
5656 
5657  // Currently, there are only two names allowed for a capability: role and
5658  // mutex (case insensitive). Diagnose other capability names.
5659  if (!N.equals_lower("mutex") && !N.equals_lower("role"))
5660  S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
5661 
5662  D->addAttr(::new (S.Context) CapabilityAttr(Attr.getRange(), S.Context, N,
5664 }
5665 
5667  const AttributeList &Attr) {
5668  D->addAttr(::new (S.Context) AssertCapabilityAttr(Attr.getRange(), S.Context,
5669  Attr.getArgAsExpr(0),
5671 }
5672 
5674  const AttributeList &Attr) {
5675  SmallVector<Expr*, 1> Args;
5676  if (!checkLockFunAttrCommon(S, D, Attr, Args))
5677  return;
5678 
5679  D->addAttr(::new (S.Context) AcquireCapabilityAttr(Attr.getRange(),
5680  S.Context,
5681  Args.data(), Args.size(),
5683 }
5684 
5686  const AttributeList &Attr) {
5687  SmallVector<Expr*, 2> Args;
5688  if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
5689  return;
5690 
5691  D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(Attr.getRange(),
5692  S.Context,
5693  Attr.getArgAsExpr(0),
5694  Args.data(),
5695  Args.size(),
5697 }
5698 
5700  const AttributeList &Attr) {
5701  // Check that all arguments are lockable objects.
5703  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, true);
5704 
5705  D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
5706  Attr.getRange(), S.Context, Args.data(), Args.size(),
5708 }
5709 
5711  const AttributeList &Attr) {
5712  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5713  return;
5714 
5715  // check that all arguments are lockable objects
5716  SmallVector<Expr*, 1> Args;
5717  checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
5718  if (Args.empty())
5719  return;
5720 
5721  RequiresCapabilityAttr *RCA = ::new (S.Context)
5722  RequiresCapabilityAttr(Attr.getRange(), S.Context, Args.data(),
5723  Args.size(), Attr.getAttributeSpellingListIndex());
5724 
5725  D->addAttr(RCA);
5726 }
5727 
5728 static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5729  if (auto *NSD = dyn_cast<NamespaceDecl>(D)) {
5730  if (NSD->isAnonymousNamespace()) {
5731  S.Diag(Attr.getLoc(), diag::warn_deprecated_anonymous_namespace);
5732  // Do not want to attach the attribute to the namespace because that will
5733  // cause confusing diagnostic reports for uses of declarations within the
5734  // namespace.
5735  return;
5736  }
5737  }
5738 
5739  // Handle the cases where the attribute has a text message.
5740  StringRef Str, Replacement;
5741  if (Attr.isArgExpr(0) && Attr.getArgAsExpr(0) &&
5742  !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
5743  return;
5744 
5745  // Only support a single optional message for Declspec and CXX11.
5746  if (Attr.isDeclspecAttribute() || Attr.isCXX11Attribute())
5747  checkAttributeAtMostNumArgs(S, Attr, 1);
5748  else if (Attr.isArgExpr(1) && Attr.getArgAsExpr(1) &&
5749  !S.checkStringLiteralArgumentAttr(Attr, 1, Replacement))
5750  return;
5751 
5752  if (!S.getLangOpts().CPlusPlus14)
5753  if (Attr.isCXX11Attribute() &&
5754  !(Attr.hasScope() && Attr.getScopeName()->isStr("gnu")))
5755  S.Diag(Attr.getLoc(), diag::ext_cxx14_attr) << Attr.getName();
5756 
5757  D->addAttr(::new (S.Context)
5758  DeprecatedAttr(Attr.getRange(), S.Context, Str, Replacement,
5760 }
5761 
5762 static bool isGlobalVar(const Decl *D) {
5763  if (const auto *S = dyn_cast<VarDecl>(D))
5764  return S->hasGlobalStorage();
5765  return false;
5766 }
5767 
5768 static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5769  if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5770  return;
5771 
5772  std::vector<StringRef> Sanitizers;
5773 
5774  for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
5775  StringRef SanitizerName;
5776  SourceLocation LiteralLoc;
5777 
5778  if (!S.checkStringLiteralArgumentAttr(Attr, I, SanitizerName, &LiteralLoc))
5779  return;
5780 
5781  if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 0)
5782  S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
5783  else if (isGlobalVar(D) && SanitizerName != "address")
5784  S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5785  << Attr.getName() << ExpectedFunctionOrMethod;
5786  Sanitizers.push_back(SanitizerName);
5787  }
5788 
5789  D->addAttr(::new (S.Context) NoSanitizeAttr(
5790  Attr.getRange(), S.Context, Sanitizers.data(), Sanitizers.size(),
5792 }
5793 
5795  const AttributeList &Attr) {
5796  StringRef AttrName = Attr.getName()->getName();
5797  normalizeName(AttrName);
5798  StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
5799  .Case("no_address_safety_analysis", "address")
5800  .Case("no_sanitize_address", "address")
5801  .Case("no_sanitize_thread", "thread")
5802  .Case("no_sanitize_memory", "memory");
5803  if (isGlobalVar(D) && SanitizerName != "address")
5804  S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5805  << Attr.getName() << ExpectedFunction;
5806  D->addAttr(::new (S.Context)
5807  NoSanitizeAttr(Attr.getRange(), S.Context, &SanitizerName, 1,
5809 }
5810 
5812  const AttributeList &Attr) {
5813  if (InternalLinkageAttr *Internal =
5814  S.mergeInternalLinkageAttr(D, Attr.getRange(), Attr.getName(),
5816  D->addAttr(Internal);
5817 }
5818 
5819 static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5820  if (S.LangOpts.OpenCLVersion != 200)
5821  S.Diag(Attr.getLoc(), diag::err_attribute_requires_opencl_version)
5822  << Attr.getName() << "2.0" << 0;
5823  else
5824  S.Diag(Attr.getLoc(), diag::warn_opencl_attr_deprecated_ignored)
5825  << Attr.getName() << "2.0";
5826 }
5827 
5828 /// Handles semantic checking for features that are common to all attributes,
5829 /// such as checking whether a parameter was properly specified, or the correct
5830 /// number of arguments were passed, etc.
5831 static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D,
5832  const AttributeList &Attr) {
5833  // Several attributes carry different semantics than the parsing requires, so
5834  // those are opted out of the common argument checks.
5835  //
5836  // We also bail on unknown and ignored attributes because those are handled
5837  // as part of the target-specific handling logic.
5839  return false;
5840  // Check whether the attribute requires specific language extensions to be
5841  // enabled.
5842  if (!Attr.diagnoseLangOpts(S))
5843  return true;
5844  // Check whether the attribute appertains to the given subject.
5845  if (!Attr.diagnoseAppertainsTo(S, D))
5846  return true;
5847  if (Attr.hasCustomParsing())
5848  return false;
5849 
5850  if (Attr.getMinArgs() == Attr.getMaxArgs()) {
5851  // If there are no optional arguments, then checking for the argument count
5852  // is trivial.
5853  if (!checkAttributeNumArgs(S, Attr, Attr.getMinArgs()))
5854  return true;
5855  } else {
5856  // There are optional arguments, so checking is slightly more involved.
5857  if (Attr.getMinArgs() &&
5858  !checkAttributeAtLeastNumArgs(S, Attr, Attr.getMinArgs()))
5859  return true;
5860  else if (!Attr.hasVariadicArg() && Attr.getMaxArgs() &&
5861  !checkAttributeAtMostNumArgs(S, Attr, Attr.getMaxArgs()))
5862  return true;
5863  }
5864 
5865  return false;
5866 }
5867 
5869  const AttributeList &Attr) {
5870  if (D->isInvalidDecl())
5871  return;
5872 
5873  // Check if there is only one access qualifier.
5874  if (D->hasAttr<OpenCLAccessAttr>()) {
5875  S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers)
5876  << D->getSourceRange();
5877  D->setInvalidDecl(true);
5878  return;
5879  }
5880 
5881  // OpenCL v2.0 s6.6 - read_write can be used for image types to specify that an
5882  // image object can be read and written.
5883  // OpenCL v2.0 s6.13.6 - A kernel cannot read from and write to the same pipe
5884  // object. Using the read_write (or __read_write) qualifier with the pipe
5885  // qualifier is a compilation error.
5886  if (const ParmVarDecl *PDecl = dyn_cast<ParmVarDecl>(D)) {
5887  const Type *DeclTy = PDecl->getType().getCanonicalType().getTypePtr();
5888  if (Attr.getName()->getName().find("read_write") != StringRef::npos) {
5889  if (S.getLangOpts().OpenCLVersion < 200 || DeclTy->isPipeType()) {
5890  S.Diag(Attr.getLoc(), diag::err_opencl_invalid_read_write)
5891  << Attr.getName() << PDecl->getType() << DeclTy->isImageType();
5892  D->setInvalidDecl(true);
5893  return;
5894  }
5895  }
5896  }
5897 
5898  D->addAttr(::new (S.Context) OpenCLAccessAttr(
5899  Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
5900 }
5901 
5902 //===----------------------------------------------------------------------===//
5903 // Top Level Sema Entry Points
5904 //===----------------------------------------------------------------------===//
5905 
5906 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
5907 /// the attribute applies to decls. If the attribute is a type attribute, just
5908 /// silently ignore it if a GNU attribute.
5909 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
5910  const AttributeList &Attr,
5911  bool IncludeCXX11Attributes) {
5912  if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
5913  return;
5914 
5915  // Ignore C++11 attributes on declarator chunks: they appertain to the type
5916  // instead.
5917  if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
5918  return;
5919 
5920  // Unknown attributes are automatically warned on. Target-specific attributes
5921  // which do not apply to the current target architecture are treated as
5922  // though they were unknown attributes.
5923  if (Attr.getKind() == AttributeList::UnknownAttribute ||
5924  !Attr.existsInTarget(S.Context.getTargetInfo())) {
5925  S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute()
5926  ? diag::warn_unhandled_ms_attribute_ignored
5927  : diag::warn_unknown_attribute_ignored)
5928  << Attr.getName();
5929  return;
5930  }
5931 
5932  if (handleCommonAttributeFeatures(S, scope, D, Attr))
5933  return;
5934 
5935  switch (Attr.getKind()) {
5936  default:
5937  if (!Attr.isStmtAttr()) {
5938  // Type attributes are handled elsewhere; silently move on.
5939  assert(Attr.isTypeAttr() && "Non-type attribute not handled");
5940  break;
5941  }
5942  S.Diag(Attr.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
5943  << Attr.getName() << D->getLocation();
5944  break;
5945  case AttributeList::AT_Interrupt:
5946  handleInterruptAttr(S, D, Attr);
5947  break;
5948  case AttributeList::AT_X86ForceAlignArgPointer:
5950  break;
5951  case AttributeList::AT_DLLExport:
5952  case AttributeList::AT_DLLImport:
5953  handleDLLAttr(S, D, Attr);
5954  break;
5955  case AttributeList::AT_Mips16:
5956  handleSimpleAttributeWithExclusions<Mips16Attr, MicroMipsAttr,
5957  MipsInterruptAttr>(S, D, Attr);
5958  break;
5959  case AttributeList::AT_NoMips16:
5960  handleSimpleAttribute<NoMips16Attr>(S, D, Attr);
5961  break;
5962  case AttributeList::AT_MicroMips:
5963  handleSimpleAttributeWithExclusions<MicroMipsAttr, Mips16Attr>(S, D, Attr);
5964  break;
5965  case AttributeList::AT_NoMicroMips:
5966  handleSimpleAttribute<NoMicroMipsAttr>(S, D, Attr);
5967  break;
5968  case AttributeList::AT_AMDGPUFlatWorkGroupSize:
5970  break;
5971  case AttributeList::AT_AMDGPUWavesPerEU:
5972  handleAMDGPUWavesPerEUAttr(S, D, Attr);
5973  break;
5974  case AttributeList::AT_AMDGPUNumSGPR:
5975  handleAMDGPUNumSGPRAttr(S, D, Attr);
5976  break;
5977  case AttributeList::AT_AMDGPUNumVGPR:
5978  handleAMDGPUNumVGPRAttr(S, D, Attr);
5979  break;
5980  case AttributeList::AT_AVRSignal:
5981  handleAVRSignalAttr(S, D, Attr);
5982  break;
5983  case AttributeList::AT_IBAction:
5984  handleSimpleAttribute<IBActionAttr>(S, D, Attr);
5985  break;
5986  case AttributeList::AT_IBOutlet:
5987  handleIBOutlet(S, D, Attr);
5988  break;
5989  case AttributeList::AT_IBOutletCollection:
5990  handleIBOutletCollection(S, D, Attr);
5991  break;
5992  case AttributeList::AT_IFunc:
5993  handleIFuncAttr(S, D, Attr);
5994  break;
5995  case AttributeList::AT_Alias:
5996  handleAliasAttr(S, D, Attr);
5997  break;
5998  case AttributeList::AT_Aligned:
5999  handleAlignedAttr(S, D, Attr);
6000  break;
6001  case AttributeList::AT_AlignValue:
6002  handleAlignValueAttr(S, D, Attr);
6003  break;
6004  case AttributeList::AT_AllocSize:
6005  handleAllocSizeAttr(S, D, Attr);
6006  break;
6007  case AttributeList::AT_AlwaysInline:
6008  handleAlwaysInlineAttr(S, D, Attr);
6009  break;
6010  case AttributeList::AT_AnalyzerNoReturn:
6011  handleAnalyzerNoReturnAttr(S, D, Attr);
6012  break;
6013  case AttributeList::AT_TLSModel:
6014  handleTLSModelAttr(S, D, Attr);
6015  break;
6016  case AttributeList::AT_Annotate:
6017  handleAnnotateAttr(S, D, Attr);
6018  break;
6019  case AttributeList::AT_Availability:
6020  handleAvailabilityAttr(S, D, Attr);
6021  break;
6022  case AttributeList::AT_CarriesDependency:
6023  handleDependencyAttr(S, scope, D, Attr);
6024  break;
6025  case AttributeList::AT_Common:
6026  handleCommonAttr(S, D, Attr);
6027  break;
6028  case AttributeList::AT_CUDAConstant:
6029  handleConstantAttr(S, D, Attr);
6030  break;
6031  case AttributeList::AT_PassObjectSize:
6032  handlePassObjectSizeAttr(S, D, Attr);
6033  break;
6034  case AttributeList::AT_Constructor:
6035  handleConstructorAttr(S, D, Attr);
6036  break;
6037  case AttributeList::AT_CXX11NoReturn:
6038  handleSimpleAttribute<CXX11NoReturnAttr>(S, D, Attr);
6039  break;
6040  case AttributeList::AT_Deprecated:
6041  handleDeprecatedAttr(S, D, Attr);
6042  break;
6043  case AttributeList::AT_Destructor:
6044  handleDestructorAttr(S, D, Attr);
6045  break;
6046  case AttributeList::AT_EnableIf:
6047  handleEnableIfAttr(S, D, Attr);
6048  break;
6049  case AttributeList::AT_DiagnoseIf:
6050  handleDiagnoseIfAttr(S, D, Attr);
6051  break;
6052  case AttributeList::AT_ExtVectorType:
6053  handleExtVectorTypeAttr(S, scope, D, Attr);
6054  break;
6055  case AttributeList::AT_ExternalSourceSymbol:
6056  handleExternalSourceSymbolAttr(S, D, Attr);
6057  break;
6058  case AttributeList::AT_MinSize:
6059  handleMinSizeAttr(S, D, Attr);
6060  break;
6061  case AttributeList::AT_OptimizeNone:
6062  handleOptimizeNoneAttr(S, D, Attr);
6063  break;
6064  case AttributeList::AT_FlagEnum:
6065  handleSimpleAttribute<FlagEnumAttr>(S, D, Attr);
6066  break;
6067  case AttributeList::AT_EnumExtensibility:
6068  handleEnumExtensibilityAttr(S, D, Attr);
6069  break;
6070  case AttributeList::AT_Flatten:
6071  handleSimpleAttribute<FlattenAttr>(S, D, Attr);
6072  break;
6073  case AttributeList::AT_Format:
6074  handleFormatAttr(S, D, Attr);
6075  break;
6076  case AttributeList::AT_FormatArg:
6077  handleFormatArgAttr(S, D, Attr);
6078  break;
6079  case AttributeList::AT_CUDAGlobal:
6080  handleGlobalAttr(S, D, Attr);
6081  break;
6082  case AttributeList::AT_CUDADevice:
6083  handleSimpleAttributeWithExclusions<CUDADeviceAttr, CUDAGlobalAttr>(S, D,
6084  Attr);
6085  break;
6086  case AttributeList::AT_CUDAHost:
6087  handleSimpleAttributeWithExclusions<CUDAHostAttr, CUDAGlobalAttr>(S, D,
6088  Attr);
6089  break;
6090  case AttributeList::AT_GNUInline:
6091  handleGNUInlineAttr(S, D, Attr);
6092  break;
6093  case AttributeList::AT_CUDALaunchBounds:
6094  handleLaunchBoundsAttr(S, D, Attr);
6095  break;
6096  case AttributeList::AT_Restrict:
6097  handleRestrictAttr(S, D, Attr);
6098  break;
6099  case AttributeList::AT_MayAlias:
6100  handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
6101  break;
6102  case AttributeList::AT_Mode:
6103  handleModeAttr(S, D, Attr);
6104  break;
6105  case AttributeList::AT_NoAlias:
6106  handleSimpleAttribute<NoAliasAttr>(S, D, Attr);
6107  break;
6108  case AttributeList::AT_NoCommon:
6109  handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
6110  break;
6111  case AttributeList::AT_NoSplitStack:
6112  handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
6113  break;
6114  case AttributeList::AT_NonNull:
6115  if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D))
6116  handleNonNullAttrParameter(S, PVD, Attr);
6117  else
6118  handleNonNullAttr(S, D, Attr);
6119  break;
6120  case AttributeList::AT_ReturnsNonNull:
6121  handleReturnsNonNullAttr(S, D, Attr);
6122  break;
6123  case AttributeList::AT_AssumeAligned:
6124  handleAssumeAlignedAttr(S, D, Attr);
6125  break;
6126  case AttributeList::AT_AllocAlign:
6127  handleAllocAlignAttr(S, D, Attr);
6128  break;
6129  case AttributeList::AT_Overloadable:
6130  handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
6131  break;
6132  case AttributeList::AT_Ownership:
6133  handleOwnershipAttr(S, D, Attr);
6134  break;
6135  case AttributeList::AT_Cold:
6136  handleColdAttr(S, D, Attr);
6137  break;
6138  case AttributeList::AT_Hot:
6139  handleHotAttr(S, D, Attr);
6140  break;
6141  case AttributeList::AT_Naked:
6142  handleNakedAttr(S, D, Attr);
6143  break;
6144  case AttributeList::AT_NoReturn:
6145  handleNoReturnAttr(S, D, Attr);
6146  break;
6147  case AttributeList::AT_NoThrow:
6148  handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
6149  break;
6150  case AttributeList::AT_CUDAShared:
6151  handleSharedAttr(S, D, Attr);
6152  break;
6153  case AttributeList::AT_VecReturn:
6154  handleVecReturnAttr(S, D, Attr);
6155  break;
6156  case AttributeList::AT_ObjCOwnership:
6157  handleObjCOwnershipAttr(S, D, Attr);
6158  break;
6159  case AttributeList::AT_ObjCPreciseLifetime:
6160  handleObjCPreciseLifetimeAttr(S, D, Attr);
6161  break;
6162  case AttributeList::AT_ObjCReturnsInnerPointer:
6164  break;
6165  case AttributeList::AT_ObjCRequiresSuper:
6166  handleObjCRequiresSuperAttr(S, D, Attr);
6167  break;
6168  case AttributeList::AT_ObjCBridge:
6169  handleObjCBridgeAttr(S, scope, D, Attr);
6170  break;
6171  case AttributeList::AT_ObjCBridgeMutable:
6172  handleObjCBridgeMutableAttr(S, scope, D, Attr);
6173  break;
6174  case AttributeList::AT_ObjCBridgeRelated:
6175  handleObjCBridgeRelatedAttr(S, scope, D, Attr);
6176  break;
6177  case AttributeList::AT_ObjCDesignatedInitializer:
6178  handleObjCDesignatedInitializer(S, D, Attr);
6179  break;
6180  case AttributeList::AT_ObjCRuntimeName:
6181  handleObjCRuntimeName(S, D, Attr);
6182  break;
6183  case AttributeList::AT_ObjCRuntimeVisible:
6184  handleSimpleAttribute<ObjCRuntimeVisibleAttr>(S, D, Attr);
6185  break;
6186  case AttributeList::AT_ObjCBoxable:
6187  handleObjCBoxable(S, D, Attr);
6188  break;
6189  case AttributeList::AT_CFAuditedTransfer:
6190  handleCFAuditedTransferAttr(S, D, Attr);
6191  break;
6192  case AttributeList::AT_CFUnknownTransfer:
6193  handleCFUnknownTransferAttr(S, D, Attr);
6194  break;
6195  case AttributeList::AT_CFConsumed:
6196  case AttributeList::AT_NSConsumed:
6197  handleNSConsumedAttr(S, D, Attr);
6198  break;
6199  case AttributeList::AT_NSConsumesSelf:
6200  handleSimpleAttribute<NSConsumesSelfAttr>(S, D, Attr);
6201  break;
6202  case AttributeList::AT_NSReturnsAutoreleased:
6203  case AttributeList::AT_NSReturnsNotRetained:
6204  case AttributeList::AT_CFReturnsNotRetained:
6205  case AttributeList::AT_NSReturnsRetained:
6206  case AttributeList::AT_CFReturnsRetained:
6207  handleNSReturnsRetainedAttr(S, D, Attr);
6208  break;
6209  case AttributeList::AT_WorkGroupSizeHint:
6210  handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, Attr);
6211  break;
6212  case AttributeList::AT_ReqdWorkGroupSize:
6213  handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, Attr);
6214  break;
6215  case AttributeList::AT_OpenCLIntelReqdSubGroupSize:
6216  handleSubGroupSize(S, D, Attr);
6217  break;
6218  case AttributeList::AT_VecTypeHint:
6219  handleVecTypeHint(S, D, Attr);
6220  break;
6221  case AttributeList::AT_RequireConstantInit:
6222  handleSimpleAttribute<RequireConstantInitAttr>(S, D, Attr);
6223  break;
6224  case AttributeList::AT_InitPriority:
6225  handleInitPriorityAttr(S, D, Attr);
6226  break;
6227  case AttributeList::AT_Packed:
6228  handlePackedAttr(S, D, Attr);
6229  break;
6230  case AttributeList::AT_Section:
6231  handleSectionAttr(S, D, Attr);
6232  break;
6233  case AttributeList::AT_Target:
6234  handleTargetAttr(S, D, Attr);
6235  break;
6236  case AttributeList::AT_Unavailable:
6237  handleAttrWithMessage<UnavailableAttr>(S, D, Attr);
6238  break;
6239  case AttributeList::AT_ArcWeakrefUnavailable:
6240  handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, Attr);
6241  break;
6242  case AttributeList::AT_ObjCRootClass:
6243  handleSimpleAttribute<ObjCRootClassAttr>(S, D, Attr);
6244  break;
6245  case AttributeList::AT_ObjCSubclassingRestricted:
6246  handleSimpleAttribute<ObjCSubclassingRestrictedAttr>(S, D, Attr);
6247  break;
6248  case AttributeList::AT_ObjCExplicitProtocolImpl:
6249  handleObjCSuppresProtocolAttr(S, D, Attr);
6250  break;
6251  case AttributeList::AT_ObjCRequiresPropertyDefs:
6252  handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, Attr);
6253  break;
6254  case AttributeList::AT_Unused:
6255  handleUnusedAttr(S, D, Attr);
6256  break;
6257  case AttributeList::AT_ReturnsTwice:
6258  handleSimpleAttribute<ReturnsTwiceAttr>(S, D, Attr);
6259  break;
6260  case AttributeList::AT_NotTailCalled:
6261  handleNotTailCalledAttr(S, D, Attr);
6262  break;
6263  case AttributeList::AT_DisableTailCalls:
6264  handleDisableTailCallsAttr(S, D, Attr);
6265  break;
6266  case AttributeList::AT_Used:
6267  handleUsedAttr(S, D, Attr);
6268  break;
6269  case AttributeList::AT_Visibility:
6270  handleVisibilityAttr(S, D, Attr, false);
6271  break;
6272  case AttributeList::AT_TypeVisibility:
6273  handleVisibilityAttr(S, D, Attr, true);
6274  break;
6275  case AttributeList::AT_WarnUnused:
6276  handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
6277  break;
6278  case AttributeList::AT_WarnUnusedResult:
6279  handleWarnUnusedResult(S, D, Attr);
6280  break;
6281  case AttributeList::AT_Weak:
6282  handleSimpleAttribute<WeakAttr>(S, D, Attr);
6283  break;
6284  case AttributeList::AT_WeakRef:
6285  handleWeakRefAttr(S, D, Attr);
6286  break;
6287  case AttributeList::AT_WeakImport:
6288  handleWeakImportAttr(S, D, Attr);
6289  break;
6290  case AttributeList::AT_TransparentUnion:
6291  handleTransparentUnionAttr(S, D, Attr);
6292  break;
6293  case AttributeList::AT_ObjCException:
6294  handleSimpleAttribute<ObjCExceptionAttr>(S, D, Attr);
6295  break;
6296  case AttributeList::AT_ObjCMethodFamily:
6297  handleObjCMethodFamilyAttr(S, D, Attr);
6298  break;
6299  case AttributeList::AT_ObjCNSObject:
6300  handleObjCNSObject(S, D, Attr);
6301  break;
6302  case AttributeList::AT_ObjCIndependentClass:
6303  handleObjCIndependentClass(S, D, Attr);
6304  break;
6305  case AttributeList::AT_Blocks:
6306  handleBlocksAttr(S, D, Attr);
6307  break;
6308  case AttributeList::AT_Sentinel:
6309  handleSentinelAttr(S, D, Attr);
6310  break;
6311  case AttributeList::AT_Const:
6312  handleSimpleAttribute<ConstAttr>(S, D, Attr);
6313  break;
6314  case AttributeList::AT_Pure:
6315  handleSimpleAttribute<PureAttr>(S, D, Attr);
6316  break;
6317  case AttributeList::AT_Cleanup:
6318  handleCleanupAttr(S, D, Attr);
6319  break;
6320  case AttributeList::AT_NoDebug:
6321  handleNoDebugAttr(S, D, Attr);
6322  break;
6323  case AttributeList::AT_NoDuplicate:
6324  handleSimpleAttribute<NoDuplicateAttr>(S, D, Attr);
6325  break;
6326  case AttributeList::AT_Convergent:
6327  handleSimpleAttribute<ConvergentAttr>(S, D, Attr);
6328  break;
6329  case AttributeList::AT_NoInline:
6330  handleSimpleAttribute<NoInlineAttr>(S, D, Attr);
6331  break;
6332  case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg.
6333  handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, Attr);
6334  break;
6335  case AttributeList::AT_StdCall:
6336  case AttributeList::AT_CDecl:
6337  case AttributeList::AT_FastCall:
6338  case AttributeList::AT_ThisCall:
6339  case AttributeList::AT_Pascal:
6340  case AttributeList::AT_RegCall:
6341  case AttributeList::AT_SwiftCall:
6342  case AttributeList::AT_VectorCall:
6343  case AttributeList::AT_MSABI:
6344  case AttributeList::AT_SysVABI:
6345  case AttributeList::AT_Pcs:
6346  case AttributeList::AT_IntelOclBicc:
6347  case AttributeList::AT_PreserveMost:
6348  case AttributeList::AT_PreserveAll:
6349  handleCallConvAttr(S, D, Attr);
6350  break;
6351  case AttributeList::AT_Suppress:
6352  handleSuppressAttr(S, D, Attr);
6353  break;
6354  case AttributeList::AT_OpenCLKernel:
6355  handleSimpleAttribute<OpenCLKernelAttr>(S, D, Attr);
6356  break;
6357  case AttributeList::AT_OpenCLAccess:
6358  handleOpenCLAccessAttr(S, D, Attr);
6359  break;
6360  case AttributeList::AT_OpenCLNoSVM:
6361  handleOpenCLNoSVMAttr(S, D, Attr);
6362  break;
6363  case AttributeList::AT_SwiftContext:
6365  break;
6366  case AttributeList::AT_SwiftErrorResult:
6368  break;
6369  case AttributeList::AT_SwiftIndirectResult:
6371  break;
6372  case AttributeList::AT_InternalLinkage:
6373  handleInternalLinkageAttr(S, D, Attr);
6374  break;
6375  case AttributeList::AT_LTOVisibilityPublic:
6376  handleSimpleAttribute<LTOVisibilityPublicAttr>(S, D, Attr);
6377  break;
6378 
6379  // Microsoft attributes:
6380  case AttributeList::AT_EmptyBases:
6381  handleSimpleAttribute<EmptyBasesAttr>(S, D, Attr);
6382  break;
6383  case AttributeList::AT_LayoutVersion:
6384  handleLayoutVersion(S, D, Attr);
6385  break;
6386  case AttributeList::AT_MSNoVTable:
6387  handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
6388  break;
6389  case AttributeList::AT_MSStruct:
6390  handleSimpleAttribute<MSStructAttr>(S, D, Attr);
6391  break;
6392  case AttributeList::AT_Uuid:
6393  handleUuidAttr(S, D, Attr);
6394  break;
6395  case AttributeList::AT_MSInheritance:
6396  handleMSInheritanceAttr(S, D, Attr);
6397  break;
6398  case AttributeList::AT_SelectAny:
6399  handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
6400  break;
6401  case AttributeList::AT_Thread:
6402  handleDeclspecThreadAttr(S, D, Attr);
6403  break;
6404 
6405  case AttributeList::AT_AbiTag:
6406  handleAbiTagAttr(S, D, Attr);
6407  break;
6408 
6409  // Thread safety attributes:
6410  case AttributeList::AT_AssertExclusiveLock:
6411  handleAssertExclusiveLockAttr(S, D, Attr);
6412  break;
6413  case AttributeList::AT_AssertSharedLock:
6414  handleAssertSharedLockAttr(S, D, Attr);
6415  break;
6416  case AttributeList::AT_GuardedVar:
6417  handleSimpleAttribute<GuardedVarAttr>(S, D, Attr);
6418  break;
6419  case AttributeList::AT_PtGuardedVar:
6420  handlePtGuardedVarAttr(S, D, Attr);
6421  break;
6422  case AttributeList::AT_ScopedLockable:
6423  handleSimpleAttribute<ScopedLockableAttr>(S, D, Attr);
6424  break;
6425  case AttributeList::AT_NoSanitize:
6426  handleNoSanitizeAttr(S, D, Attr);
6427  break;
6428  case AttributeList::AT_NoSanitizeSpecific:
6429  handleNoSanitizeSpecificAttr(S, D, Attr);
6430  break;
6431  case AttributeList::AT_NoThreadSafetyAnalysis:
6432  handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, Attr);
6433  break;
6434  case AttributeList::AT_GuardedBy:
6435  handleGuardedByAttr(S, D, Attr);
6436  break;
6437  case AttributeList::AT_PtGuardedBy:
6438  handlePtGuardedByAttr(S, D, Attr);
6439  break;
6440  case AttributeList::AT_ExclusiveTrylockFunction:
6442  break;
6443  case AttributeList::AT_LockReturned:
6444  handleLockReturnedAttr(S, D, Attr);
6445  break;
6446  case AttributeList::AT_LocksExcluded:
6447  handleLocksExcludedAttr(S, D, Attr);
6448  break;
6449  case AttributeList::AT_SharedTrylockFunction:
6450  handleSharedTrylockFunctionAttr(S, D, Attr);
6451  break;
6452  case AttributeList::AT_AcquiredBefore:
6453  handleAcquiredBeforeAttr(S, D, Attr);
6454  break;
6455  case AttributeList::AT_AcquiredAfter:
6456  handleAcquiredAfterAttr(S, D, Attr);
6457  break;
6458 
6459  // Capability analysis attributes.
6460  case AttributeList::AT_Capability:
6461  case AttributeList::AT_Lockable:
6462  handleCapabilityAttr(S, D, Attr);
6463  break;
6464  case AttributeList::AT_RequiresCapability:
6465  handleRequiresCapabilityAttr(S, D, Attr);
6466  break;
6467 
6468  case AttributeList::AT_AssertCapability:
6469  handleAssertCapabilityAttr(S, D, Attr);
6470  break;
6471  case AttributeList::AT_AcquireCapability:
6472  handleAcquireCapabilityAttr(S, D, Attr);
6473  break;
6474  case AttributeList::AT_ReleaseCapability:
6475  handleReleaseCapabilityAttr(S, D, Attr);
6476  break;
6477  case AttributeList::AT_TryAcquireCapability:
6478  handleTryAcquireCapabilityAttr(S, D, Attr);
6479  break;
6480 
6481  // Consumed analysis attributes.
6482  case AttributeList::AT_Consumable:
6483  handleConsumableAttr(S, D, Attr);
6484  break;
6485  case AttributeList::AT_ConsumableAutoCast:
6486  handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, Attr);
6487  break;
6488  case AttributeList::AT_ConsumableSetOnRead:
6489  handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, Attr);
6490  break;
6491  case AttributeList::AT_CallableWhen:
6492  handleCallableWhenAttr(S, D, Attr);
6493  break;
6494  case AttributeList::AT_ParamTypestate:
6495  handleParamTypestateAttr(S, D, Attr);
6496  break;
6497  case AttributeList::AT_ReturnTypestate:
6498  handleReturnTypestateAttr(S, D, Attr);
6499  break;
6500  case AttributeList::AT_SetTypestate:
6501  handleSetTypestateAttr(S, D, Attr);
6502  break;
6503  case AttributeList::AT_TestTypestate:
6504  handleTestTypestateAttr(S, D, Attr);
6505  break;
6506 
6507  // Type safety attributes.
6508  case AttributeList::AT_ArgumentWithTypeTag:
6509  handleArgumentWithTypeTagAttr(S, D, Attr);
6510  break;
6511  case AttributeList::AT_TypeTagForDatatype:
6512  handleTypeTagForDatatypeAttr(S, D, Attr);
6513  break;
6514  case AttributeList::AT_AnyX86NoCallerSavedRegisters:
6515  handleNoCallerSavedRegsAttr(S, D, Attr);
6516  break;
6517  case AttributeList::AT_RenderScriptKernel:
6518  handleSimpleAttribute<RenderScriptKernelAttr>(S, D, Attr);
6519  break;
6520  // XRay attributes.
6521  case AttributeList::AT_XRayInstrument:
6522  handleSimpleAttribute<XRayInstrumentAttr>(S, D, Attr);
6523  break;
6524  case AttributeList::AT_XRayLogArgs:
6525  handleXRayLogArgsAttr(S, D, Attr);
6526  break;
6527  }
6528 }
6529 
6530 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
6531 /// attribute list to the specified decl, ignoring any type attributes.
6533  const AttributeList *AttrList,
6534  bool IncludeCXX11Attributes) {
6535  for (const AttributeList* l = AttrList; l; l = l->getNext())
6536  ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes);
6537 
6538  // FIXME: We should be able to handle these cases in TableGen.
6539  // GCC accepts
6540  // static int a9 __attribute__((weakref));
6541  // but that looks really pointless. We reject it.
6542  if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
6543  Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias)
6544  << cast<NamedDecl>(D);
6545  D->dropAttr<WeakRefAttr>();
6546  return;
6547  }
6548 
6549  // FIXME: We should be able to handle this in TableGen as well. It would be
6550  // good to have a way to specify "these attributes must appear as a group",
6551  // for these. Additionally, it would be good to have a way to specify "these
6552  // attribute must never appear as a group" for attributes like cold and hot.
6553  if (!D->hasAttr<OpenCLKernelAttr>()) {
6554  // These attributes cannot be applied to a non-kernel function.
6555  if (Attr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
6556  // FIXME: This emits a different error message than
6557  // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
6558  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6559  D->setInvalidDecl();
6560  } else if (Attr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
6561  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6562  D->setInvalidDecl();
6563  } else if (Attr *A = D->getAttr<VecTypeHintAttr>()) {
6564  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6565  D->setInvalidDecl();
6566  } else if (Attr *A = D->getAttr<AMDGPUFlatWorkGroupSizeAttr>()) {
6567  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6568  << A << ExpectedKernelFunction;
6569  D->setInvalidDecl();
6570  } else if (Attr *A = D->getAttr<AMDGPUWavesPerEUAttr>()) {
6571  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6572  << A << ExpectedKernelFunction;
6573  D->setInvalidDecl();
6574  } else if (Attr *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
6575  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6576  << A << ExpectedKernelFunction;
6577  D->setInvalidDecl();
6578  } else if (Attr *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
6579  Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6580  << A << ExpectedKernelFunction;
6581  D->setInvalidDecl();
6582  } else if (Attr *A = D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
6583  Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6584  D->setInvalidDecl();
6585  }
6586  }
6587 }
6588 
6589 // Helper for delayed processing TransparentUnion attribute.
6591  for (const AttributeList *Attr = AttrList; Attr; Attr = Attr->getNext())
6592  if (Attr->getKind() == AttributeList::AT_TransparentUnion) {
6593  handleTransparentUnionAttr(*this, D, *Attr);
6594  break;
6595  }
6596 }
6597 
6598 // Annotation attributes are the only attributes allowed after an access
6599 // specifier.
6601  const AttributeList *AttrList) {
6602  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6603  if (l->getKind() == AttributeList::AT_Annotate) {
6604  ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute());
6605  } else {
6606  Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
6607  return true;
6608  }
6609  }
6610 
6611  return false;
6612 }
6613 
6614 /// checkUnusedDeclAttributes - Check a list of attributes to see if it
6615 /// contains any decl attributes that we should warn about.
6617  for ( ; A; A = A->getNext()) {
6618  // Only warn if the attribute is an unignored, non-type attribute.
6619  if (A->isUsedAsTypeAttr() || A->isInvalid()) continue;
6620  if (A->getKind() == AttributeList::IgnoredAttribute) continue;
6621 
6623  S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
6624  << A->getName() << A->getRange();
6625  } else {
6626  S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
6627  << A->getName() << A->getRange();
6628  }
6629  }
6630 }
6631 
6632 /// checkUnusedDeclAttributes - Given a declarator which is not being
6633 /// used to build a declaration, complain about any decl attributes
6634 /// which might be lying around on it.
6638  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
6640 }
6641 
6642 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
6643 /// \#pragma weak needs a non-definition decl and source may not have one.
6645  SourceLocation Loc) {
6646  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
6647  NamedDecl *NewD = nullptr;
6648  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
6649  FunctionDecl *NewFD;
6650  // FIXME: Missing call to CheckFunctionDeclaration().
6651  // FIXME: Mangling?
6652  // FIXME: Is the qualifier info correct?
6653  // FIXME: Is the DeclContext correct?
6654  NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
6655  Loc, Loc, DeclarationName(II),
6656  FD->getType(), FD->getTypeSourceInfo(),
6657  SC_None, false/*isInlineSpecified*/,
6658  FD->hasPrototype(),
6659  false/*isConstexprSpecified*/);
6660  NewD = NewFD;
6661 
6662  if (FD->getQualifier())
6663  NewFD->setQualifierInfo(FD->getQualifierLoc());
6664 
6665  // Fake up parameter variables; they are declared as if this were
6666  // a typedef.
6667  QualType FDTy = FD->getType();
6668  if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
6670  for (const auto &AI : FT->param_types()) {
6671  ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI);
6672  Param->setScopeInfo(0, Params.size());
6673  Params.push_back(Param);
6674  }
6675  NewFD->setParams(Params);
6676  }
6677  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
6678  NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
6679  VD->getInnerLocStart(), VD->getLocation(), II,
6680  VD->getType(), VD->getTypeSourceInfo(),
6681  VD->getStorageClass());
6682  if (VD->getQualifier()) {
6683  VarDecl *NewVD = cast<VarDecl>(NewD);
6684  NewVD->setQualifierInfo(VD->getQualifierLoc());
6685  }
6686  }
6687  return NewD;
6688 }
6689 
6690 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
6691 /// applied to it, possibly with an alias.
6693  if (W.getUsed()) return; // only do this once
6694  W.setUsed(true);
6695  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
6696  IdentifierInfo *NDId = ND->getIdentifier();
6697  NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
6698  NewD->addAttr(AliasAttr::CreateImplicit(Context, NDId->getName(),
6699  W.getLocation()));
6700  NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6701  WeakTopLevelDecl.push_back(NewD);
6702  // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
6703  // to insert Decl at TU scope, sorry.
6704  DeclContext *SavedContext = CurContext;
6706  NewD->setDeclContext(CurContext);
6708  PushOnScopeChains(NewD, S);
6709  CurContext = SavedContext;
6710  } else { // just add weak to existing
6711  ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6712  }
6713 }
6714 
6716  // It's valid to "forward-declare" #pragma weak, in which case we
6717  // have to do this.
6719  if (!WeakUndeclaredIdentifiers.empty()) {
6720  NamedDecl *ND = nullptr;
6721  if (VarDecl *VD = dyn_cast<VarDecl>(D))
6722  if (VD->isExternC())
6723  ND = VD;
6724  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
6725  if (FD->isExternC())
6726  ND = FD;
6727  if (ND) {
6728  if (IdentifierInfo *Id = ND->getIdentifier()) {
6729  auto I = WeakUndeclaredIdentifiers.find(Id);
6730  if (I != WeakUndeclaredIdentifiers.end()) {
6731  WeakInfo W = I->second;
6732  DeclApplyPragmaWeak(S, ND, W);
6733  WeakUndeclaredIdentifiers[Id] = W;
6734  }
6735  }
6736  }
6737  }
6738 }
6739 
6740 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
6741 /// it, apply them to D. This is a bit tricky because PD can have attributes
6742 /// specified in many different places, and we need to find and apply them all.
6744  // Apply decl attributes from the DeclSpec if present.
6745  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
6746  ProcessDeclAttributeList(S, D, Attrs);
6747 
6748  // Walk the declarator structure, applying decl attributes that were in a type
6749  // position to the decl itself. This handles cases like:
6750  // int *__attr__(x)** D;
6751  // when X is a decl attribute.
6752  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
6753  if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
6754  ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false);
6755 
6756  // Finally, apply any attributes on the decl itself.
6757  if (const AttributeList *Attrs = PD.getAttributes())
6758  ProcessDeclAttributeList(S, D, Attrs);
6759 
6760  // Apply additional attributes specified by '#pragma clang attribute'.
6761  AddPragmaAttributes(S, D);
6762 }
6763 
6764 /// Is the given declaration allowed to use a forbidden type?
6765 /// If so, it'll still be annotated with an attribute that makes it
6766 /// illegal to actually use.
6768  const DelayedDiagnostic &diag,
6769  UnavailableAttr::ImplicitReason &reason) {
6770  // Private ivars are always okay. Unfortunately, people don't
6771  // always properly make their ivars private, even in system headers.
6772  // Plus we need to make fields okay, too.
6773  if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
6774  !isa<FunctionDecl>(decl))
6775  return false;
6776 
6777  // Silently accept unsupported uses of __weak in both user and system
6778  // declarations when it's been disabled, for ease of integration with
6779  // -fno-objc-arc files. We do have to take some care against attempts
6780  // to define such things; for now, we've only done that for ivars
6781  // and properties.
6782  if ((isa<ObjCIvarDecl>(decl) || isa<ObjCPropertyDecl>(decl))) {
6783  if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled ||
6784  diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {
6785  reason = UnavailableAttr::IR_ForbiddenWeak;
6786  return true;
6787  }
6788  }
6789 
6790  // Allow all sorts of things in system headers.
6792  // Currently, all the failures dealt with this way are due to ARC
6793  // restrictions.
6794  reason = UnavailableAttr::IR_ARCForbiddenType;
6795  return true;
6796  }
6797 
6798  return false;
6799 }
6800 
6801 /// Handle a delayed forbidden-type diagnostic.
6803  Decl *decl) {
6804  auto reason = UnavailableAttr::IR_None;
6805  if (decl && isForbiddenTypeAllowed(S, decl, diag, reason)) {
6806  assert(reason && "didn't set reason?");
6807  decl->addAttr(UnavailableAttr::CreateImplicit(S.Context, "", reason,
6808  diag.Loc));
6809  return;
6810  }
6811  if (S.getLangOpts().ObjCAutoRefCount)
6812  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
6813  // FIXME: we may want to suppress diagnostics for all
6814  // kind of forbidden type messages on unavailable functions.
6815  if (FD->hasAttr<UnavailableAttr>() &&
6816  diag.getForbiddenTypeDiagnostic() ==
6817  diag::err_arc_array_param_no_ownership) {
6818  diag.Triggered = true;
6819  return;
6820  }
6821  }
6822 
6823  S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
6825  diag.Triggered = true;
6826 }
6827 
6828 static const AvailabilityAttr *getAttrForPlatform(ASTContext &Context,
6829  const Decl *D) {
6830  // Check each AvailabilityAttr to find the one for this platform.
6831  for (const auto *A : D->attrs()) {
6832  if (const auto *Avail = dyn_cast<AvailabilityAttr>(A)) {
6833  // FIXME: this is copied from CheckAvailability. We should try to
6834  // de-duplicate.
6835 
6836  // Check if this is an App Extension "platform", and if so chop off
6837  // the suffix for matching with the actual platform.
6838  StringRef ActualPlatform = Avail->getPlatform()->getName();
6839  StringRef RealizedPlatform = ActualPlatform;
6840  if (Context.getLangOpts().AppExt) {
6841  size_t suffix = RealizedPlatform.rfind("_app_extension");
6842  if (suffix != StringRef::npos)
6843  RealizedPlatform = RealizedPlatform.slice(0, suffix);
6844  }
6845 
6846  StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
6847 
6848  // Match the platform name.
6849  if (RealizedPlatform == TargetPlatform)
6850  return Avail;
6851  }
6852  }
6853  return nullptr;
6854 }
6855 
6856 /// The diagnostic we should emit for \c D, and the declaration that
6857 /// originated it, or \c AR_Available.
6858 ///
6859 /// \param D The declaration to check.
6860 /// \param Message If non-null, this will be populated with the message from
6861 /// the availability attribute that is selected.
6862 static std::pair<AvailabilityResult, const NamedDecl *>
6863 ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message) {
6865 
6866  // For typedefs, if the typedef declaration appears available look
6867  // to the underlying type to see if it is more restrictive.
6868  while (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
6869  if (Result == AR_Available) {
6870  if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
6871  D = TT->getDecl();
6872  Result = D->getAvailability(Message);
6873  continue;
6874  }
6875  }
6876  break;
6877  }
6878 
6879  // Forward class declarations get their attributes from their definition.
6880  if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
6881  if (IDecl->getDefinition()) {
6882  D = IDecl->getDefinition();
6883  Result = D->getAvailability(Message);
6884  }
6885  }
6886 
6887  if (const auto *ECD = dyn_cast<EnumConstantDecl>(D))
6888  if (Result == AR_Available) {
6889  const DeclContext *DC = ECD->getDeclContext();
6890  if (const auto *TheEnumDecl = dyn_cast<EnumDecl>(DC)) {
6891  Result = TheEnumDecl->getAvailability(Message);
6892  D = TheEnumDecl;
6893  }
6894  }
6895 
6896  return {Result, D};
6897 }
6898 
6899 
6900 /// \brief whether we should emit a diagnostic for \c K and \c DeclVersion in
6901 /// the context of \c Ctx. For example, we should emit an unavailable diagnostic
6902 /// in a deprecated context, but not the other way around.
6904  VersionTuple DeclVersion,
6905  Decl *Ctx) {
6906  assert(K != AR_Available && "Expected an unavailable declaration here!");
6907 
6908  // Checks if we should emit the availability diagnostic in the context of C.
6909  auto CheckContext = [&](const Decl *C) {
6910  if (K == AR_NotYetIntroduced) {
6911  if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, C))
6912  if (AA->getIntroduced() >= DeclVersion)
6913  return true;
6914  } else if (K == AR_Deprecated)
6915  if (C->isDeprecated())
6916  return true;
6917 
6918  if (C->isUnavailable())
6919  return true;
6920  return false;
6921  };
6922 
6923  // FIXME: This is a temporary workaround! Some existing Apple headers depends
6924  // on nested declarations in an @interface having the availability of the
6925  // interface when they really shouldn't: they are members of the enclosing
6926  // context, and can referenced from there.
6927  if (S.OriginalLexicalContext && cast<Decl>(S.OriginalLexicalContext) != Ctx) {
6928  auto *OrigCtx = cast<Decl>(S.OriginalLexicalContext);
6929  if (CheckContext(OrigCtx))
6930  return false;
6931 
6932  // An implementation implicitly has the availability of the interface.
6933  if (auto *CatOrImpl = dyn_cast<ObjCImplDecl>(OrigCtx)) {
6934  if (const ObjCInterfaceDecl *Interface = CatOrImpl->getClassInterface())
6935  if (CheckContext(Interface))
6936  return false;
6937  }
6938  // A category implicitly has the availability of the interface.
6939  else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(OrigCtx))
6940  if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
6941  if (CheckContext(Interface))
6942  return false;
6943  }
6944 
6945  do {
6946  if (CheckContext(Ctx))
6947  return false;
6948 
6949  // An implementation implicitly has the availability of the interface.
6950  if (auto *CatOrImpl = dyn_cast<ObjCImplDecl>(Ctx)) {
6951  if (const ObjCInterfaceDecl *Interface = CatOrImpl->getClassInterface())
6952  if (CheckContext(Interface))
6953  return false;
6954  }
6955  // A category implicitly has the availability of the interface.
6956  else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(Ctx))
6957  if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
6958  if (CheckContext(Interface))
6959  return false;
6960  } while ((Ctx = cast_or_null<Decl>(Ctx->getDeclContext())));
6961 
6962  return true;
6963 }
6964 
6965 static bool
6967  const VersionTuple &DeploymentVersion,
6968  const VersionTuple &DeclVersion) {
6969  const auto &Triple = Context.getTargetInfo().getTriple();
6970  VersionTuple ForceAvailabilityFromVersion;
6971  switch (Triple.getOS()) {
6972  case llvm::Triple::IOS:
6973  case llvm::Triple::TvOS:
6974  ForceAvailabilityFromVersion = VersionTuple(/*Major=*/11);
6975  break;
6976  case llvm::Triple::WatchOS:
6977  ForceAvailabilityFromVersion = VersionTuple(/*Major=*/4);
6978  break;
6979  case llvm::Triple::Darwin:
6980  case llvm::Triple::MacOSX:
6981  ForceAvailabilityFromVersion = VersionTuple(/*Major=*/10, /*Minor=*/13);
6982  break;
6983  default:
6984  // New targets should always warn about availability.
6985  return Triple.getVendor() == llvm::Triple::Apple;
6986  }
6987  return DeploymentVersion >= ForceAvailabilityFromVersion ||
6988  DeclVersion >= ForceAvailabilityFromVersion;
6989 }
6990 
6992  for (Decl *Ctx = OrigCtx; Ctx;
6993  Ctx = cast_or_null<Decl>(Ctx->getDeclContext())) {
6994  if (isa<TagDecl>(Ctx) || isa<FunctionDecl>(Ctx) || isa<ObjCMethodDecl>(Ctx))
6995  return cast<NamedDecl>(Ctx);
6996  if (auto *CD = dyn_cast<ObjCContainerDecl>(Ctx)) {
6997  if (auto *Imp = dyn_cast<ObjCImplDecl>(Ctx))
6998  return Imp->getClassInterface();
6999  return CD;
7000  }
7001  }
7002 
7003  return dyn_cast<NamedDecl>(OrigCtx);
7004 }
7005 
7006 /// Actually emit an availability diagnostic for a reference to an unavailable
7007 /// decl.
7008 ///
7009 /// \param Ctx The context that the reference occurred in
7010 /// \param ReferringDecl The exact declaration that was referenced.
7011 /// \param OffendingDecl A related decl to \c ReferringDecl that has an
7012 /// availability attribute corrisponding to \c K attached to it. Note that this
7013 /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
7014 /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
7015 /// and OffendingDecl is the EnumDecl.
7017  Decl *Ctx, const NamedDecl *ReferringDecl,
7018  const NamedDecl *OffendingDecl,
7019  StringRef Message, SourceLocation Loc,
7020  const ObjCInterfaceDecl *UnknownObjCClass,
7021  const ObjCPropertyDecl *ObjCProperty,
7022  bool ObjCPropertyAccess) {
7023  // Diagnostics for deprecated or unavailable.
7024  unsigned diag, diag_message, diag_fwdclass_message;
7025  unsigned diag_available_here = diag::note_availability_specified_here;
7026  SourceLocation NoteLocation = OffendingDecl->getLocation();
7027 
7028  // Matches 'diag::note_property_attribute' options.
7029  unsigned property_note_select;
7030 
7031  // Matches diag::note_availability_specified_here.
7032  unsigned available_here_select_kind;
7033 
7034  VersionTuple DeclVersion;
7035  if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, OffendingDecl))
7036  DeclVersion = AA->getIntroduced();
7037 
7038  if (!ShouldDiagnoseAvailabilityInContext(S, K, DeclVersion, Ctx))
7039  return;
7040 
7041  switch (K) {
7042  case AR_Deprecated:
7043  diag = !ObjCPropertyAccess ? diag::warn_deprecated
7044  : diag::warn_property_method_deprecated;
7045  diag_message = diag::warn_deprecated_message;
7046  diag_fwdclass_message = diag::warn_deprecated_fwdclass_message;
7047  property_note_select = /* deprecated */ 0;
7048  available_here_select_kind = /* deprecated */ 2;
7049  if (const auto *attr = OffendingDecl->getAttr<DeprecatedAttr>())
7050  NoteLocation = attr->getLocation();
7051  break;
7052 
7053  case AR_Unavailable:
7054  diag = !ObjCPropertyAccess ? diag::err_unavailable
7055  : diag::err_property_method_unavailable;
7056  diag_message = diag::err_unavailable_message;
7057  diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
7058  property_note_select = /* unavailable */ 1;
7059  available_here_select_kind = /* unavailable */ 0;
7060 
7061  if (auto attr = OffendingDecl->getAttr<UnavailableAttr>()) {
7062  if (attr->isImplicit() && attr->getImplicitReason()) {
7063  // Most of these failures are due to extra restrictions in ARC;
7064  // reflect that in the primary diagnostic when applicable.
7065  auto flagARCError = [&] {
7066  if (S.getLangOpts().ObjCAutoRefCount &&
7068  OffendingDecl->getLocation()))
7069  diag = diag::err_unavailable_in_arc;
7070  };
7071 
7072  switch (attr->getImplicitReason()) {
7073  case UnavailableAttr::IR_None: break;
7074 
7075  case UnavailableAttr::IR_ARCForbiddenType:
7076  flagARCError();
7077  diag_available_here = diag::note_arc_forbidden_type;
7078  break;
7079 
7080  case UnavailableAttr::IR_ForbiddenWeak:
7081  if (S.getLangOpts().ObjCWeakRuntime)
7082  diag_available_here = diag::note_arc_weak_disabled;
7083  else
7084  diag_available_here = diag::note_arc_weak_no_runtime;
7085  break;
7086 
7087  case UnavailableAttr::IR_ARCForbiddenConversion:
7088  flagARCError();
7089  diag_available_here = diag::note_performs_forbidden_arc_conversion;
7090  break;
7091 
7092  case UnavailableAttr::IR_ARCInitReturnsUnrelated:
7093  flagARCError();
7094  diag_available_here = diag::note_arc_init_returns_unrelated;
7095  break;
7096 
7097  case UnavailableAttr::IR_ARCFieldWithOwnership:
7098  flagARCError();
7099  diag_available_here = diag::note_arc_field_with_ownership;
7100  break;
7101  }
7102  }
7103  }
7104  break;
7105 
7106  case AR_NotYetIntroduced: {
7107  // We would like to emit the diagnostic even if -Wunguarded-availability is
7108  // not specified for deployment targets >= to iOS 11 or equivalent or
7109  // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7110  // later.
7111  const AvailabilityAttr *AA =
7112  getAttrForPlatform(S.getASTContext(), OffendingDecl);
7113  VersionTuple Introduced = AA->getIntroduced();
7114  bool NewWarning = shouldDiagnoseAvailabilityByDefault(
7116  Introduced);
7117  diag = NewWarning ? diag::warn_partial_availability_new
7118  : diag::warn_partial_availability;
7119  diag_message = NewWarning ? diag::warn_partial_message_new
7120  : diag::warn_partial_message;
7121  diag_fwdclass_message = NewWarning ? diag::warn_partial_fwdclass_message_new
7122  : diag::warn_partial_fwdclass_message;
7123  property_note_select = /* partial */ 2;
7124  available_here_select_kind = /* partial */ 3;
7125  break;
7126  }
7127 
7128  case AR_Available:
7129  llvm_unreachable("Warning for availability of available declaration?");
7130  }
7131 
7132  CharSourceRange UseRange;
7133  StringRef Replacement;
7134  if (K == AR_Deprecated) {
7135  if (auto attr = OffendingDecl->getAttr<DeprecatedAttr>())
7136  Replacement = attr->getReplacement();
7137  if (auto attr = getAttrForPlatform(S.Context, OffendingDecl))
7138  Replacement = attr->getReplacement();
7139 
7140  if (!Replacement.empty())
7141  UseRange =
7143  }
7144 
7145  if (!Message.empty()) {
7146  S.Diag(Loc, diag_message) << ReferringDecl << Message
7147  << (UseRange.isValid() ?
7148  FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7149  if (ObjCProperty)
7150  S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7151  << ObjCProperty->getDeclName() << property_note_select;
7152  } else if (!UnknownObjCClass) {
7153  S.Diag(Loc, diag) << ReferringDecl
7154  << (UseRange.isValid() ?
7155  FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7156  if (ObjCProperty)
7157  S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7158  << ObjCProperty->getDeclName() << property_note_select;
7159  } else {
7160  S.Diag(Loc, diag_fwdclass_message) << ReferringDecl
7161  << (UseRange.isValid() ?
7162  FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7163  S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
7164  }
7165 
7166  // The declaration can have multiple availability attributes, we are looking
7167  // at one of them.
7168  const AvailabilityAttr *A = getAttrForPlatform(S.Context, OffendingDecl);
7169  if (A && A->isInherited()) {
7170  for (const Decl *Redecl = OffendingDecl->getMostRecentDecl(); Redecl;
7171  Redecl = Redecl->getPreviousDecl()) {
7172  const AvailabilityAttr *AForRedecl = getAttrForPlatform(S.Context,
7173  Redecl);
7174  if (AForRedecl && !AForRedecl->isInherited()) {
7175  // If D is a declaration with inherited attributes, the note should
7176  // point to the declaration with actual attributes.
7177  S.Diag(Redecl->getLocation(), diag_available_here) << OffendingDecl
7178  << available_here_select_kind;
7179  break;
7180  }
7181  }
7182  }
7183  else
7184  S.Diag(NoteLocation, diag_available_here)
7185  << OffendingDecl << available_here_select_kind;
7186 
7187  if (K == AR_NotYetIntroduced)
7188  if (const auto *Enclosing = findEnclosingDeclToAnnotate(Ctx)) {
7189  if (auto *TD = dyn_cast<TagDecl>(Enclosing))
7190  if (TD->getDeclName().isEmpty()) {
7191  S.Diag(TD->getLocation(), diag::note_partial_availability_silence)
7192  << /*Anonymous*/1 << TD->getKindName();
7193  return;
7194  }
7195  S.Diag(Enclosing->getLocation(), diag::note_partial_availability_silence)
7196  << /*Named*/0 << Enclosing;
7197  }
7198 }
7199 
7201  Decl *Ctx) {
7202  assert(DD.Kind == DelayedDiagnostic::Availability &&
7203  "Expected an availability diagnostic here");
7204 
7205  DD.Triggered = true;
7209  DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
7210 }
7211 
7216 
7217  // When delaying diagnostics to run in the context of a parsed
7218  // declaration, we only want to actually emit anything if parsing
7219  // succeeds.
7220  if (!decl) return;
7221 
7222  // We emit all the active diagnostics in this pool or any of its
7223  // parents. In general, we'll get one pool for the decl spec
7224  // and a child pool for each declarator; in a decl group like:
7225  // deprecated_typedef foo, *bar, baz();
7226  // only the declarator pops will be passed decls. This is correct;
7227  // we really do need to consider delayed diagnostics from the decl spec
7228  // for each of the different declarations.
7229  const DelayedDiagnosticPool *pool = &poppedPool;
7230  do {
7232  i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
7233  // This const_cast is a bit lame. Really, Triggered should be mutable.
7234  DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
7235  if (diag.Triggered)
7236  continue;
7237 
7238  switch (diag.Kind) {
7240  // Don't bother giving deprecation/unavailable diagnostics if
7241  // the decl is invalid.
7242  if (!decl->isInvalidDecl())
7243  handleDelayedAvailabilityCheck(*this, diag, decl);
7244  break;
7245 
7247  HandleDelayedAccessCheck(diag, decl);
7248  break;
7249 
7251  handleDelayedForbiddenType(*this, diag, decl);
7252  break;
7253  }
7254  }
7255  } while ((pool = pool->getParent()));
7256 }
7257 
7258 /// Given a set of delayed diagnostics, re-emit them as if they had
7259 /// been delayed in the current context instead of in the given pool.
7260 /// Essentially, this just moves them to the current pool.
7263  assert(curPool && "re-emitting in undelayed context not supported");
7264  curPool->steal(pool);
7265 }
7266 
7268  const NamedDecl *ReferringDecl,
7269  const NamedDecl *OffendingDecl,
7270  StringRef Message, SourceLocation Loc,
7271  const ObjCInterfaceDecl *UnknownObjCClass,
7272  const ObjCPropertyDecl *ObjCProperty,
7273  bool ObjCPropertyAccess) {
7274  // Delay if we're currently parsing a declaration.
7278  AR, Loc, ReferringDecl, OffendingDecl, UnknownObjCClass,
7279  ObjCProperty, Message, ObjCPropertyAccess));
7280  return;
7281  }
7282 
7283  Decl *Ctx = cast<Decl>(S.getCurLexicalContext());
7284  DoEmitAvailabilityWarning(S, AR, Ctx, ReferringDecl, OffendingDecl,
7285  Message, Loc, UnknownObjCClass, ObjCProperty,
7286  ObjCPropertyAccess);
7287 }
7288 
7289 namespace {
7290 
7291 /// Returns true if the given statement can be a body-like child of \p Parent.
7292 bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
7293  switch (Parent->getStmtClass()) {
7294  case Stmt::IfStmtClass:
7295  return cast<IfStmt>(Parent)->getThen() == S ||
7296  cast<IfStmt>(Parent)->getElse() == S;
7297  case Stmt::WhileStmtClass:
7298  return cast<WhileStmt>(Parent)->getBody() == S;
7299  case Stmt::DoStmtClass:
7300  return cast<DoStmt>(Parent)->getBody() == S;
7301  case Stmt::ForStmtClass:
7302  return cast<ForStmt>(Parent)->getBody() == S;
7303  case Stmt::CXXForRangeStmtClass:
7304  return cast<CXXForRangeStmt>(Parent)->getBody() == S;
7305  case Stmt::ObjCForCollectionStmtClass:
7306  return cast<ObjCForCollectionStmt>(Parent)->getBody() == S;
7307  case Stmt::CaseStmtClass:
7308  case Stmt::DefaultStmtClass:
7309  return cast<SwitchCase>(Parent)->getSubStmt() == S;
7310  default:
7311  return false;
7312  }
7313 }
7314 
7315 class StmtUSEFinder : public RecursiveASTVisitor<StmtUSEFinder> {
7316  const Stmt *Target;
7317 
7318 public:
7319  bool VisitStmt(Stmt *S) { return S != Target; }
7320 
7321  /// Returns true if the given statement is present in the given declaration.
7322  static bool isContained(const Stmt *Target, const Decl *D) {
7323  StmtUSEFinder Visitor;
7324  Visitor.Target = Target;
7325  return !Visitor.TraverseDecl(const_cast<Decl *>(D));
7326  }
7327 };
7328 
7329 /// Traverses the AST and finds the last statement that used a given
7330 /// declaration.
7331 class LastDeclUSEFinder : public RecursiveASTVisitor<LastDeclUSEFinder> {
7332  const Decl *D;
7333 
7334 public:
7335  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7336  if (DRE->getDecl() == D)
7337  return false;
7338  return true;
7339  }
7340 
7341  static const Stmt *findLastStmtThatUsesDecl(const Decl *D,
7342  const CompoundStmt *Scope) {
7343  LastDeclUSEFinder Visitor;
7344  Visitor.D = D;
7345  for (auto I = Scope->body_rbegin(), E = Scope->body_rend(); I != E; ++I) {
7346  const Stmt *S = *I;
7347  if (!Visitor.TraverseStmt(const_cast<Stmt *>(S)))
7348  return S;
7349  }
7350  return nullptr;
7351  }
7352 };
7353 
7354 /// \brief This class implements -Wunguarded-availability.
7355 ///
7356 /// This is done with a traversal of the AST of a function that makes reference
7357 /// to a partially available declaration. Whenever we encounter an \c if of the
7358 /// form: \c if(@available(...)), we use the version from the condition to visit
7359 /// the then statement.
7360 class DiagnoseUnguardedAvailability
7361  : public RecursiveASTVisitor<DiagnoseUnguardedAvailability> {
7363 
7364  Sema &SemaRef;
7365  Decl *Ctx;
7366 
7367  /// Stack of potentially nested 'if (@available(...))'s.
7368  SmallVector<VersionTuple, 8> AvailabilityStack;
7370 
7371  void DiagnoseDeclAvailability(NamedDecl *D, SourceRange Range);
7372 
7373 public:
7374  DiagnoseUnguardedAvailability(Sema &SemaRef, Decl *Ctx)
7375  : SemaRef(SemaRef), Ctx(Ctx) {
7376  AvailabilityStack.push_back(
7378  }
7379 
7380  bool TraverseDecl(Decl *D) {
7381  // Avoid visiting nested functions to prevent duplicate warnings.
7382  if (!D || isa<FunctionDecl>(D))
7383  return true;
7384  return Base::TraverseDecl(D);
7385  }
7386 
7387  bool TraverseStmt(Stmt *S) {
7388  if (!S)
7389  return true;
7390  StmtStack.push_back(S);
7391  bool Result = Base::TraverseStmt(S);
7392  StmtStack.pop_back();
7393  return Result;
7394  }
7395 
7396  void IssueDiagnostics(Stmt *S) { TraverseStmt(S); }
7397 
7398  bool TraverseIfStmt(IfStmt *If);
7399 
7400  bool TraverseLambdaExpr(LambdaExpr *E) { return true; }
7401 
7402  bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *PRE) {
7403  if (PRE->isClassReceiver())
7404  DiagnoseDeclAvailability(PRE->getClassReceiver(), PRE->getReceiverLocation());
7405  return true;
7406  }
7407 
7408  bool VisitObjCMessageExpr(ObjCMessageExpr *Msg) {
7409  if (ObjCMethodDecl *D = Msg->getMethodDecl())
7410  DiagnoseDeclAvailability(
7411  D, SourceRange(Msg->getSelectorStartLoc(), Msg->getLocEnd()));
7412  return true;
7413  }
7414 
7415  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7416  DiagnoseDeclAvailability(DRE->getDecl(),
7417  SourceRange(DRE->getLocStart(), DRE->getLocEnd()));
7418  return true;
7419  }
7420 
7421  bool VisitMemberExpr(MemberExpr *ME) {
7422  DiagnoseDeclAvailability(ME->getMemberDecl(),
7423  SourceRange(ME->getLocStart(), ME->getLocEnd()));
7424  return true;
7425  }
7426 
7427  bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
7428  SemaRef.Diag(E->getLocStart(), diag::warn_at_available_unchecked_use)
7429  << (!SemaRef.getLangOpts().ObjC1);
7430  return true;
7431  }
7432 
7433  bool VisitTypeLoc(TypeLoc Ty);
7434 };
7435 
7436 void DiagnoseUnguardedAvailability::DiagnoseDeclAvailability(
7437  NamedDecl *D, SourceRange Range) {
7438  AvailabilityResult Result;
7439  const NamedDecl *OffendingDecl;
7440  std::tie(Result, OffendingDecl) =
7442  if (Result != AR_Available) {
7443  // All other diagnostic kinds have already been handled in
7444  // DiagnoseAvailabilityOfDecl.
7445  if (Result != AR_NotYetIntroduced)
7446  return;
7447 
7448  const AvailabilityAttr *AA =
7449  getAttrForPlatform(SemaRef.getASTContext(), OffendingDecl);
7450  VersionTuple Introduced = AA->getIntroduced();
7451 
7452  if (AvailabilityStack.back() >= Introduced)
7453  return;
7454 
7455  // If the context of this function is less available than D, we should not
7456  // emit a diagnostic.
7457  if (!ShouldDiagnoseAvailabilityInContext(SemaRef, Result, Introduced, Ctx))
7458  return;
7459 
7460  // We would like to emit the diagnostic even if -Wunguarded-availability is
7461  // not specified for deployment targets >= to iOS 11 or equivalent or
7462  // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7463  // later.
7464  unsigned DiagKind =
7466  SemaRef.Context,
7467  SemaRef.Context.getTargetInfo().getPlatformMinVersion(), Introduced)
7468  ? diag::warn_unguarded_availability_new
7469  : diag::warn_unguarded_availability;
7470 
7471  SemaRef.Diag(Range.getBegin(), DiagKind)
7472  << Range << D
7473  << AvailabilityAttr::getPrettyPlatformName(
7475  << Introduced.getAsString();
7476 
7477  SemaRef.Diag(OffendingDecl->getLocation(),
7478  diag::note_availability_specified_here)
7479  << OffendingDecl << /* partial */ 3;
7480 
7481  auto FixitDiag =
7482  SemaRef.Diag(Range.getBegin(), diag::note_unguarded_available_silence)
7483  << Range << D
7484  << (SemaRef.getLangOpts().ObjC1 ? /*@available*/ 0
7485  : /*__builtin_available*/ 1);
7486 
7487  // Find the statement which should be enclosed in the if @available check.
7488  if (StmtStack.empty())
7489  return;
7490  const Stmt *StmtOfUse = StmtStack.back();
7491  const CompoundStmt *Scope = nullptr;
7492  for (const Stmt *S : llvm::reverse(StmtStack)) {
7493  if (const auto *CS = dyn_cast<CompoundStmt>(S)) {
7494  Scope = CS;
7495  break;
7496  }
7497  if (isBodyLikeChildStmt(StmtOfUse, S)) {
7498  // The declaration won't be seen outside of the statement, so we don't
7499  // have to wrap the uses of any declared variables in if (@available).
7500  // Therefore we can avoid setting Scope here.
7501  break;
7502  }
7503  StmtOfUse = S;
7504  }
7505  const Stmt *LastStmtOfUse = nullptr;
7506  if (isa<DeclStmt>(StmtOfUse) && Scope) {
7507  for (const Decl *D : cast<DeclStmt>(StmtOfUse)->decls()) {
7508  if (StmtUSEFinder::isContained(StmtStack.back(), D)) {
7509  LastStmtOfUse = LastDeclUSEFinder::findLastStmtThatUsesDecl(D, Scope);
7510  break;
7511  }
7512  }
7513  }
7514 
7515  const SourceManager &SM = SemaRef.getSourceManager();
7516  SourceLocation IfInsertionLoc =
7517  SM.getExpansionLoc(StmtOfUse->getLocStart());
7518  SourceLocation StmtEndLoc =
7519  SM.getExpansionRange(
7520  (LastStmtOfUse ? LastStmtOfUse : StmtOfUse)->getLocEnd())
7521  .second;
7522  if (SM.getFileID(IfInsertionLoc) != SM.getFileID(StmtEndLoc))
7523  return;
7524 
7525  StringRef Indentation = Lexer::getIndentationForLine(IfInsertionLoc, SM);
7526  const char *ExtraIndentation = " ";
7527  std::string FixItString;
7528  llvm::raw_string_ostream FixItOS(FixItString);
7529  FixItOS << "if (" << (SemaRef.getLangOpts().ObjC1 ? "@available"
7530  : "__builtin_available")
7531  << "("
7532  << AvailabilityAttr::getPlatformNameSourceSpelling(
7534  << " " << Introduced.getAsString() << ", *)) {\n"
7535  << Indentation << ExtraIndentation;
7536  FixitDiag << FixItHint::CreateInsertion(IfInsertionLoc, FixItOS.str());
7537  SourceLocation ElseInsertionLoc = Lexer::findLocationAfterToken(
7538  StmtEndLoc, tok::semi, SM, SemaRef.getLangOpts(),
7539  /*SkipTrailingWhitespaceAndNewLine=*/false);
7540  if (ElseInsertionLoc.isInvalid())
7541  ElseInsertionLoc =
7542  Lexer::getLocForEndOfToken(StmtEndLoc, 0, SM, SemaRef.getLangOpts());
7543  FixItOS.str().clear();
7544  FixItOS << "\n"
7545  << Indentation << "} else {\n"
7546  << Indentation << ExtraIndentation
7547  << "// Fallback on earlier versions\n"
7548  << Indentation << "}";
7549  FixitDiag << FixItHint::CreateInsertion(ElseInsertionLoc, FixItOS.str());
7550  }
7551 }
7552 
7553 bool DiagnoseUnguardedAvailability::VisitTypeLoc(TypeLoc Ty) {
7554  const Type *TyPtr = Ty.getTypePtr();
7555  SourceRange Range{Ty.getBeginLoc(), Ty.getEndLoc()};
7556 
7557  if (Range.isInvalid())
7558  return true;
7559 
7560  if (const TagType *TT = dyn_cast<TagType>(TyPtr)) {
7561  TagDecl *TD = TT->getDecl();
7562  DiagnoseDeclAvailability(TD, Range);
7563 
7564  } else if (const TypedefType *TD = dyn_cast<TypedefType>(TyPtr)) {
7565  TypedefNameDecl *D = TD->getDecl();
7566  DiagnoseDeclAvailability(D, Range);
7567 
7568  } else if (const auto *ObjCO = dyn_cast<ObjCObjectType>(TyPtr)) {
7569  if (NamedDecl *D = ObjCO->getInterface())
7570  DiagnoseDeclAvailability(D, Range);
7571  }
7572 
7573  return true;
7574 }
7575 
7576 bool DiagnoseUnguardedAvailability::TraverseIfStmt(IfStmt *If) {
7577  VersionTuple CondVersion;
7578  if (auto *E = dyn_cast<ObjCAvailabilityCheckExpr>(If->getCond())) {
7579  CondVersion = E->getVersion();
7580 
7581  // If we're using the '*' case here or if this check is redundant, then we
7582  // use the enclosing version to check both branches.
7583  if (CondVersion.empty() || CondVersion <= AvailabilityStack.back())
7584  return Base::TraverseStmt(If->getThen()) &&
7585  Base::TraverseStmt(If->getElse());
7586  } else {
7587  // This isn't an availability checking 'if', we can just continue.
7588  return Base::TraverseIfStmt(If);
7589  }
7590 
7591  AvailabilityStack.push_back(CondVersion);
7592  bool ShouldContinue = TraverseStmt(If->getThen());
7593  AvailabilityStack.pop_back();
7594 
7595  return ShouldContinue && TraverseStmt(If->getElse());
7596 }
7597 
7598 } // end anonymous namespace
7599 
7601  Stmt *Body = nullptr;
7602 
7603  if (auto *FD = D->getAsFunction()) {
7604  // FIXME: We only examine the pattern decl for availability violations now,
7605  // but we should also examine instantiated templates.
7606  if (FD->isTemplateInstantiation())
7607  return;
7608 
7609  Body = FD->getBody();
7610  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
7611  Body = MD->getBody();
7612  else if (auto *BD = dyn_cast<BlockDecl>(D))
7613  Body = BD->getBody();
7614 
7615  assert(Body && "Need a body here!");
7616 
7617  DiagnoseUnguardedAvailability(*this, D).IssueDiagnostics(Body);
7618 }
7619 
7621  const ObjCInterfaceDecl *UnknownObjCClass,
7622  bool ObjCPropertyAccess,
7623  bool AvoidPartialAvailabilityChecks) {
7624  std::string Message;
7626  const NamedDecl* OffendingDecl;
7627  // See if this declaration is unavailable, deprecated, or partial.
7628  std::tie(Result, OffendingDecl) = ShouldDiagnoseAvailabilityOfDecl(D, &Message);
7629  if (Result == AR_Available)
7630  return;
7631 
7632  if (Result == AR_NotYetIntroduced) {
7633  if (AvoidPartialAvailabilityChecks)
7634  return;
7635 
7636  // We need to know the @available context in the current function to
7637  // diagnose this use, let DiagnoseUnguardedAvailabilityViolations do that
7638  // when we're done parsing the current function.
7641  return;
7642  } else if (getCurBlock() || getCurLambda()) {
7644  return;
7645  }
7646  }
7647 
7648  const ObjCPropertyDecl *ObjCPDecl = nullptr;
7649  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
7650  if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
7651  AvailabilityResult PDeclResult = PD->getAvailability(nullptr);
7652  if (PDeclResult == Result)
7653  ObjCPDecl = PD;
7654  }
7655  }
7656 
7657  EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Message, Loc,
7658  UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);
7659 }
bool CheckNoCallerSavedRegsAttr(const AttributeList &attr)
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:539
static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:210
bool CheckNoReturnAttr(const AttributeList &attr)
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5605
static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D, const AttributeList &Attr)
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2474
static bool isGlobalVar(const Decl *D)
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:1467
static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, const AttributeList &Attr)
Check if passed in Decl is a pointer type.
StmtClass getStmtClass() const
Definition: Stmt.h:361
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:1618
bool isVariadic() const
Definition: Type.h:3442
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:525
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:2224
A (possibly-)qualified type.
Definition: Type.h:616
ASTConsumer & Consumer
Definition: Sema.h:306
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:213
bool isInvalid() const
Definition: Ownership.h:159
const AttributeList * getAttrs() const
If there are attributes applied to this declaratorchunk, return them.
Definition: DeclSpec.h:1524
bool isCharType() const
Definition: Type.cpp:1694
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:1830
DeclContext * getCurLexicalContext() const
Definition: Sema.h:10422
bool isMemberPointerType() const
Definition: Type.h:5736
QualType getType() const
Retrieves the type of the base class.
Definition: DeclCXX.h:258
static void handleAcquiredAfterAttr(Sema &S, Decl *D, const AttributeList &Attr)
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple()) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:562
static void handleAVRInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:632
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &Attr, unsigned Num, unsigned Diag, Compare Comp)
const LangOptions & getLangOpts() const
Definition: Sema.h:1166
static QualType getFunctionOrMethodResultType(const Decl *D)
bool diagnoseAppertainsTo(class Sema &S, const Decl *D) const
Stmt - This represents one statement.
Definition: Stmt.h:60
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2923
IfStmt - This represents an if/then/else.
Definition: Stmt.h:905
Merge availability attributes for an override, which requires an exact match or a weakening of constr...
Definition: Sema.h:2368
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:179
const NamedDecl * getAvailabilityOffendingDecl() const
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
QualType getUnderlyingType() const
Definition: Decl.h:2727
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1243
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
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:2655
const NamedDecl * getAvailabilityReferringDecl() const
Defines the C++ template declaration subclasses.
bool isVoidPointerType() const
Definition: Type.cpp:384
IdentifierInfo * Ident
Definition: AttributeList.h:75
static DelayedDiagnostic makeAvailability(AvailabilityResult AR, SourceLocation Loc, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, StringRef Msg, bool ObjCPropertyAccess)
DeclContext * OriginalLexicalContext
Generally null except when we temporarily switch decl contexts, like in.
Definition: Sema.h:321
static void handleAllocAlignAttr(Sema &S, Decl *D, const AttributeList &Attr)
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:922
bool hasDefinition() const
Definition: DeclCXX.h:702
static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getProcessingCache() const
static void handleSuppressAttr(Sema &S, Decl *D, const AttributeList &Attr)
PtrTy get() const
Definition: Ownership.h:163
The base class of the type hierarchy.
Definition: Type.h:1303
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:5260
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:45
unsigned getRegParmMax() const
Definition: TargetInfo.h:920
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:5969
A container of type source information.
Definition: Decl.h:62
const Stmt * getElse() const
Definition: Stmt.h:945
static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr)
bool isBlockPointerType() const
Definition: Type.h:5718
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:608
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 handleOpenCLNoSVMAttr(Sema &S, Decl *D, const AttributeList &Attr)
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:758
VersionTuple getPlatformMinVersion() const
Retrieve the minimum desired version of the platform, to which the program should be compiled...
Definition: TargetInfo.h:986
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1733
static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const AttributeList &Attr, Expr *&Arg)
static bool isValidSwiftErrorResultType(QualType type)
Pointers and references to pointers in the default address space.
field_iterator field_begin() const
Definition: Decl.cpp:3912
bool isUsedAsTypeAttr() const
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1924
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD, const AttrInfo &Attr, Expr *AttrArg, unsigned FuncParamNo, unsigned AttrArgNo, bool AllowDependentType=false)
Checks to be sure that the given parameter number is in bounds, and is an integral type...
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1845
static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL)
static void handleReturnTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr)
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Definition: DeclObjC.cpp:154
Not a TLS variable.
Definition: Decl.h:775
bool isImageType() const
Definition: Type.h:5853
ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS=nullptr, bool isClassName=false, bool HasTrailingDot=false, ParsedType ObjectType=nullptr, bool IsCtorOrDtorName=false, bool WantNontrivialTypeSourceInfo=false, bool IsClassTemplateDeductionContext=true, IdentifierInfo **CorrectedII=nullptr)
If the identifier refers to a type name within this scope, return the declaration of that type...
Definition: SemaDecl.cpp:273
bool isArgIdent(unsigned Arg) const
void AddParameterABIAttr(SourceRange AttrRange, Decl *D, ParameterABI ABI, unsigned SpellingListIndex)
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1434
bool isObjCRetainableType() const
Definition: Type.cpp:3751
Defines the clang::Expr interface and subclasses for C++ expressions.
const Expr * getReplacementExpr() const
bool isUnionType() const
Definition: Type.cpp:390
FormatAttr * mergeFormatAttr(Decl *D, SourceRange Range, IdentifierInfo *Format, int FormatIdx, int FirstArg, unsigned AttrSpellingListIndex)
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:697
bool isVoidType() const
Definition: Type.h:5906
SourceLocation Loc
Definition: AttributeList.h:74
UuidAttr * mergeUuidAttr(Decl *D, SourceRange Range, unsigned AttrSpellingListIndex, StringRef Uuid)
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...
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3354
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...
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2754
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.
static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:647
static StringRef getIndentationForLine(SourceLocation Loc, const SourceManager &SM)
Returns the leading whitespace for line that corresponds to the given location Loc.
Definition: Lexer.cpp:1035
SourceLocation getUnavailableLoc() const
static void handleAssumeAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasAttr() const
Definition: DeclBase.h:521
static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr)
AttributeList * getList() const
std::pair< SourceLocation, SourceLocation > getExpansionRange(SourceLocation Loc) const
Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const AttributeList &Attr)
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:696
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1146
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)
static void handleNoCallerSavedRegsAttr(Sema &S, Decl *D, const AttributeList &Attr)
void AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name, unsigned SpellingListIndex, bool InInstantiation=false)
AddModeAttr - Adds a mode attribute to a particular declaration.
static void handleOpenCLAccessAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isReferenceType() const
Definition: Type.h:5721
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1284
QualType getReturnType() const
Definition: Decl.h:2106
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2366
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2960
bool isAnyPointerType() const
Definition: Type.h:5715
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 isMicrosoftAttribute() const
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:281
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
Definition: Type.cpp:1533
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:695
static void handleLocksExcludedAttr(Sema &S, Decl *D, const AttributeList &Attr)
TagKind getTagKind() const
Definition: Decl.h:3019
static void handleSubGroupSize(Sema &S, Decl *D, const AttributeList &Attr)
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2103
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:397
static void handleTransparentUnionAttr(Sema &S, Decl *D, const AttributeList &Attr)
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:449
static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasVariadicArg() const
static void handleAssertExclusiveLockAttr(Sema &S, Decl *D, const AttributeList &Attr)
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:103
static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr)
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
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: Module.h:57
IdentifierTable & Idents
Definition: ASTContext.h:513
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:518
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:169
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)
This parameter (which must have pointer type) uses the special Swift context-pointer ABI treatment...
const Type * getTypePtr() const
Definition: TypeLoc.h:118
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:643
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)
const LangOptions & getLangOpts() const
Definition: ASTContext.h:659
unsigned getNumTypeObjects() const
Return the number of types applied to this declarator.
Definition: DeclSpec.h:2152
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool isStaticDataMember(const Decl *D)
Determine whether the given declaration is a static data member.
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:931
DeclarationNameInfo getNameInfo() const
Definition: Expr.h:1042
QualType getReturnType() const
Definition: Type.h:3065
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:7386
void PopParsingDeclaration(ParsingDeclState state, Decl *decl)
field_range fields() const
Definition: Decl.h:3483
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:148
RecordDecl * getDecl() const
Definition: Type.h:3793
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:5199
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:252
bool hasProcessingCache() const
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2399
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2555
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D, const AttributeList &Attr)
static bool shouldDiagnoseAvailabilityByDefault(const ASTContext &Context, const VersionTuple &DeploymentVersion, const VersionTuple &DeclVersion)
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:3240
Represents information about a change in availability for an entity, which is part of the encoding of...
Definition: AttributeList.h:36
bool getLayoutCompatible() const
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1985
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1930
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1519
Preprocessor & PP
Definition: Sema.h:304
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1858
bool isInvalid() const
#define UINT_MAX
Definition: limits.h:72
A class that does preordor or postorder depth-first traversal on the entire Clang AST and visits each...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1108
static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isExtVectorType() const
Definition: Type.h:5781
bool empty() const
Definition: Type.h:395
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:41
QualType getType() const
Definition: Decl.h:589
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:1780
const LangOptions & LangOpts
Definition: Sema.h:303
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)
This parameter (which must have pointer-to-pointer type) uses the special Swift error-result ABI trea...
static bool checkPositiveIntArgument(Sema &S, const AttrInfo &Attr, const Expr *Expr, int &Val, unsigned Idx=UINT_MAX)
Wrapper around checkUInt32Argument, with an extra check to be sure that the result will fit into a re...
virtual unsigned getUnwindWordWidth() const
Definition: TargetInfo.h:488
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:139
param_iterator param_begin()
Definition: Decl.h:2077
Represents the this expression in C++.
Definition: ExprCXX.h:888
field_iterator field_end() const
Definition: Decl.h:3486
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:1932
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:67
IdentifierInfo * getAlias() const
Definition: Weak.h:34
static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr)
SourceLocation getReceiverLocation() const
Definition: ExprObjC.h:691
bool isUnion() const
Definition: Decl.h:3028
bool isStmtAttr() const
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:623
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:269
Merge availability attributes for an implementation of a protocol requirement.
Definition: Sema.h:2371
SourceLocation getLocEnd() const LLVM_READONLY
Definition: ExprObjC.h:1345
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:575
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3129
Kind getKind() const
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:516
const AvailabilityChange & getAvailabilityIntroduced() const
static void handleCFAuditedTransferAttr(Sema &S, Decl *D, const AttributeList &Attr)
ASTContext * Context
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1701
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1674
Captures information about a #pragma weak directive.
Definition: Weak.h:25
static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr)
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.h:1297
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:414
bool isFunctionPointerType() const
Definition: Type.h:5730
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.
Definition: TargetInfo.h:54
static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType type)
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1251
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:663
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3557
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:580
Expr - This represents one expression.
Definition: Expr.h:105
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.
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Definition: Lexer.cpp:762
SmallVector< Decl *, 2 > WeakTopLevelDecl
WeakTopLevelDecl - Translation-unit scoped declarations generated by #pragma weak during processing o...
Definition: Sema.h:777
static bool checkFunctionConditionAttr(Sema &S, Decl *D, const AttributeList &Attr, Expr *&Cond, StringRef &Msg)
Represents a character-granular source range.
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 SourceLocation findLocationAfterToken(SourceLocation loc, tok::TokenKind TKind, const SourceManager &SM, const LangOptions &LangOpts, bool SkipTrailingWhitespaceAndNewLine)
Checks that the given token is the first token that occurs after the given location (this excludes co...
Definition: Lexer.cpp:1206
static bool isCapabilityExpr(Sema &S, const Expr *Ex)
This file defines the classes used to store parsed information about declaration-specifiers and decla...
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:455
virtual std::string isValidSectionSpecifier(StringRef SR) const
An optional hook that targets can implement to perform semantic checking on attribute((section("foo")...
Definition: TargetInfo.h:834
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:956
static void handleCFUnknownTransferAttr(Sema &S, Decl *D, const AttributeList &Attr)
void DiagnoseUnguardedAvailabilityViolations(Decl *FD)
Issue any -Wunguarded-availability warnings in FD.
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:13138
static bool typeHasCapability(Sema &S, QualType Ty)
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2088
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:760
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclContext * getDeclContext()
Definition: DeclBase.h:416
void CheckAlignasUnderalignment(Decl *D)
bool isFloatingType() const
Definition: Type.cpp:1821
static void handleParameterABIAttr(Sema &S, Decl *D, const AttributeList &attr, ParameterABI abi)
void setProcessingCache(unsigned value) const
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
virtual void AssignInheritanceModel(CXXRecordDecl *RD)
Callback invoked when an MSInheritanceAttr has been attached to a CXXRecordDecl.
Definition: ASTConsumer.h:108
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
static void handleIFuncAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isObjCIdType() const
Definition: Type.h:5808
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2156
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:337
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1797
virtual bool hasProtectedVisibility() const
Does this target support "protected" visibility?
Definition: TargetInfo.h:821
const ParsedType & getTypeArg() const
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1294
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...
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
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:1714
Represents a GCC generic vector type.
Definition: Type.h:2797
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
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:1344
Wraps an identifier and optional source location for the identifier.
Definition: AttributeList.h:73
InternalLinkageAttr * mergeInternalLinkageAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
ValueDecl * getDecl()
Definition: Expr.h:1038
static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr)
unsigned getForbiddenTypeDiagnostic() const
The diagnostic ID to emit.
The result type of a method or function.
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:3473
static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag, Decl *decl)
Handle a delayed forbidden-type diagnostic.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:166
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1511
const SourceManager & SM
Definition: Format.cpp:1293
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:661
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:264
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:232
static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr)
AttrVec & getAttrs()
Definition: DeclBase.h:466
static CharSourceRange getCharRange(SourceRange R)
bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type)
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:86
static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:206
static void handleMipsInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr)
void addAttr(Attr *A)
Definition: DeclBase.h:472
static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr, unsigned Num)
Check if the attribute has exactly as many args as Num.
Stmt * getBody(const FunctionDecl *&Definition) const
getBody - Retrieve the body (definition) of the function.
Definition: Decl.cpp:2597
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:400
static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
A parameter attribute which changes the argument-passing ABI rule for the parameter.
Definition: Attr.h:165
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:979
There is no lifetime qualification on this type.
Definition: Type.h:135
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3025
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:1945
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:4490
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:146
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:5956
const ParsedType & getMatchingCType() const
not a target-specific vector type
Definition: Type.h:2800
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2458
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:199
AvailabilityResult getAvailabilityResult() const
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
Definition: ScopeInfo.h:117
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:2878
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 ...
void DiagnoseAvailabilityOfDecl(NamedDecl *D, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks=false)
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3810
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:396
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition: Type.h:5766
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:2816
attr_range attrs() const
Definition: DeclBase.h:482
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:346
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:1173
const ObjCInterfaceDecl * getUnknownObjCClass() const
bool getMustBeNull() const
CommonAttr * mergeCommonAttr(Decl *D, SourceRange Range, IdentifierInfo *Ident, unsigned AttrSpellingListIndex)
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:733
reverse_body_iterator body_rend()
Definition: Stmt.h:635
static void handleLockReturnedAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAvailabilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
Definition: ASTContext.h:1112
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1903
bool shouldDelayDiagnostics()
Determines whether diagnostics should be delayed.
Definition: Sema.h:644
static std::enable_if< std::is_base_of< clang::Attr, AttrInfo >::value, SourceLocation >::type getAttrLoc(const AttrInfo &Attr)
A helper function to provide Attribute Location for the Attr types AND the AttributeList.
virtual unsigned getRegisterWidth() const
Return the "preferred" register width on this target.
Definition: TargetInfo.h:491
static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D, const AttributeList &Attr)
static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess)
Actually emit an availability diagnostic for a reference to an unavailable decl.
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)
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1663
static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr)
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2189
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:74
static void handleXRayLogArgsAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleNSReturnsRetainedAttr(Sema &S, Decl *D, const AttributeList &Attr)
CUDADiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a CUDADiagBuilder that emits the diagnostic if the current context is "used as host code"...
Definition: SemaCUDA.cpp:668
static unsigned getNumAttributeArgs(const AttributeList &Attr)
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:956
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:704
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
unsigned getForbiddenTypeArgument() const
QualType getReturnType() const
Definition: DeclObjC.h:330
SourceLocation getBegin() const
static void handleExternalSourceSymbolAttr(Sema &S, Decl *D, const AttributeList &Attr)
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6105
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:166
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:1507
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:1597
SourceLocation getSelectorStartLoc() const
Definition: ExprObjC.h:1313
bool isVectorType() const
Definition: Type.h:5778
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1293
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:2140
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:152
static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD, const AttributeList &Attr)
static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasScope() const
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:450
static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const AttributeList &Attr)
ParameterABI
Kinds of parameter ABI.
Definition: Specifiers.h:298
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
Definition: Sema.h:9894
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1357
QualType getPointeeType() const
Definition: Type.h:2238
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
attr::Kind getKind() const
Definition: Attr.h:84
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2682
static bool normalizeName(StringRef &AttrName)
Normalize the attribute, foo becomes foo.
QualType getType() const
Definition: Expr.h:127
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:8280
static void handleLayoutVersion(Sema &S, Decl *D, const AttributeList &Attr)
static bool isStaticOverloadedOperator(OverloadedOperatorKind OOK)
Returns true if the given operator is implicitly static in a record context.
Definition: DeclCXX.h:1934
static void EmitAvailabilityWarning(Sema &S, AvailabilityResult AR, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, SourceLocation Loc, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess)
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.
static std::enable_if< std::is_base_of< clang::Attr, AttrInfo >::value, const AttrInfo * >::type getAttrName(const AttrInfo &Attr)
A helper function to provide Attribute Name for the Attr types AND the AttributeList.
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:2362
static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr)
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:11750
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:1215
static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const AttributeList &Attr)
StringRef Name
Definition: USRFinder.cpp:123
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:2126
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero)...
Definition: VersionTuple.h:69
void ProcessPragmaWeak(Scope *S, Decl *D)
bool isInvalidDecl() const
Definition: DeclBase.h:532
NamedDecl * DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, SourceLocation Loc)
DeclClonePragmaWeak - clone existing decl (maybe definition), #pragma weak needs a non-definition dec...
unsigned getCharWidth() const
Definition: TargetInfo.h:331
bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, MSInheritanceAttr::Spelling SemanticSpelling)
bool isClassReceiver() const
Definition: ExprObjC.h:701
static void handleObjCBridgeRelatedAttr(Sema &S, Scope *Sc, Decl *D, const AttributeList &Attr)
SectionAttr * mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name, unsigned AttrSpellingListIndex)
A runtime availability query.
Definition: ExprObjC.h:1579
Expr * getArgAsExpr(unsigned Arg) const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr)
DeclarationName - The name of a declaration.
unsigned short getMaxTLSAlign() const
Return the maximum alignment (in bits) of a TLS variable.
Definition: TargetInfo.h:934
void AddNSConsumedAttr(SourceRange AttrRange, Decl *D, unsigned SpellingListIndex, bool isNSConsumed, bool isTemplateInstantiation)
StringRef getString() const
Definition: Expr.h:1554
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl's underlying type to extract a FunctionType when possible. ...
Definition: DeclBase.cpp:900
static void handleInternalLinkageAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1874
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:683
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:792
EnumDecl - Represents an enum.
Definition: Decl.h:3102
bool hasAttrs() const
Definition: DeclBase.h:462
VisibilityAttr * mergeVisibilityAttr(Decl *D, SourceRange Range, VisibilityAttr::VisibilityType Vis, unsigned AttrSpellingListIndex)
detail::InMemoryDirectory::const_iterator E
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7328
static void handleIBOutletCollection(Sema &S, Decl *D, const AttributeList &Attr)
void ProcessDeclAttributeDelayed(Decl *D, const AttributeList *AttrList)
static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr, bool isTypeVisibility)
static bool ShouldDiagnoseAvailabilityInContext(Sema &S, AvailabilityResult K, VersionTuple DeclVersion, Decl *Ctx)
whether we should emit a diagnostic for K and DeclVersion in the context of Ctx.
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:1049
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:1557
void AddPragmaAttributes(Scope *S, Decl *D)
Adds the attributes that have been specified using the '#pragma clang attribute push' directives to t...
Definition: SemaAttr.cpp:577
param_iterator param_end()
Definition: Decl.h:2078
const Stmt * getThen() const
Definition: Stmt.h:943
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:5662
const Expr * getMessageExpr() const
AvailabilityMergeKind
Describes the kind of merge to perform for availability attributes (including "deprecated", "unavailable", and "availability").
Definition: Sema.h:2360
Represents a pointer to an Objective C object.
Definition: Type.h:5220
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier, e.g., N::foo.
Definition: Expr.h:1053
static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted)
Pointer to a block type.
Definition: Type.h:2327
bool isObjCObjectType() const
Definition: Type.h:5787
bool isPackExpansion() const
static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAVRSignalAttr(Sema &S, Decl *D, const AttributeList &Attr)
static void handleAMDGPUWavesPerEUAttr(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:3784
static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr)
IdentifierInfo * getName() const
SourceManager & getSourceManager() const
Definition: Sema.h:1171
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
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)
static bool checkUInt32Argument(Sema &S, const AttrInfo &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...
bool getUsed()
Definition: Weak.h:37
SourceLocation getStrictLoc() const
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:1707
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:5709
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2360
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1634
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1548
llvm::StringRef getParameterABISpelling(ParameterABI kind)
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:90
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:158
const Expr * Replacement
Definition: AttributeList.h:59
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2468
bool isTypeAttr() const
void checkTargetAttr(SourceLocation LiteralLoc, StringRef Str)
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
SourceManager & getSourceManager()
Definition: ASTContext.h:616
bool isTLSSupported() const
Whether the target supports thread-local storage.
Definition: TargetInfo.h:926
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:307
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:1193
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:2365
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:13074
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:149
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).
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2378
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
static void handleEnumExtensibilityAttr(Sema &S, Decl *D, const AttributeList &Attr)
static bool isInstanceMethod(const Decl *D)
bool isCARCBridgableType() const
Determine whether the given type T is a "bridgeable" C type.
Definition: Type.cpp:3784
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.
Definition: TargetInfo.h:1016
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9248
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:861
static unsigned getFunctionOrMethodNumParams(const Decl *D)
getFunctionOrMethodNumParams - Return number of function or method parameters.
reverse_body_iterator body_rbegin()
Definition: Stmt.h:632
bool isObjCObjectPointerType() const
Definition: Type.h:5784
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:505
A diagnostic message which has been conditionally emitted pending the complete parsing of the current...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1866
CallingConv getDefaultCallingConvention(bool isVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
const Expr * getCond() const
Definition: Stmt.h:941
bool isPipeType() const
Definition: Type.h:5860
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:317
void AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads, Expr *MinBlocks, unsigned SpellingListIndex)
AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular declaration. ...
SourceLocation getLocStart() const
Definition: ExprObjC.h:1594
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:127
This class is used for builtin types like 'int'.
Definition: Type.h:2084
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)
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
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:1506
Defines the clang::TargetInfo interface.
void AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr, unsigned SpellingListIndex)
AddAllocAlignAttr - Adds an alloc_align attribute to a particular declaration.
static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl, const AttributeList &Attr)
static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr)
FormatAttrKind
static bool checkFunctionOrMethodParameterIndex(Sema &S, const Decl *D, const AttrInfo &Attr, unsigned AttrArgNum, const Expr *IdxExpr, uint64_t &Idx, bool AllowImplicitThis=false)
Check if IdxExpr is a valid parameter index for a function or instance method D.
CanQualType IntTy
Definition: ASTContext.h:971
bool checkSectionName(SourceLocation LiteralLoc, StringRef Str)
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition: Decl.h:689
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:953
NamedDecl * getMostRecentDecl()
Definition: Decl.h:391
static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx)
static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr)
static NamedDecl * findEnclosingDeclToAnnotate(Decl *OrigCtx)
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:64
static const AvailabilityAttr * getAttrForPlatform(ASTContext &Context, const Decl *D)
class clang::Sema::DelayedDiagnostics DelayedDiagnostics
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:2156
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
static Expr * makeLaunchBoundsArgExpr(Sema &S, Expr *E, const CUDALaunchBoundsAttr &Attr, const unsigned Idx)
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:268
ASTContext & Context
Definition: Sema.h:305
static std::pair< AvailabilityResult, const NamedDecl * > ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message)
The diagnostic we should emit for D, and the declaration that originated it, or AR_Available.
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:213
static void handleTLSModelAttr(Sema &S, Decl *D, const AttributeList &Attr)
void dropAttr()
Definition: DeclBase.h:494
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
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:1744
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1299
static bool isFunctionOrMethodVariadic(const Decl *D)
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:1904
Describes an entity that is being initialized.
void setHasDesignatedInitializers()
Indicate that this interface decl contains at least one initializer marked with the 'objc_designated_...
Definition: DeclObjC.cpp:1469
StringRef getAvailabilityMessage() const
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
StringRef getPlatformName() const
Retrieve the name of the platform as it is used in the availability attribute.
Definition: TargetInfo.h:982
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 isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:2971
This class handles loading and caching of source files into memory.
AvailabilityAttr * mergeAvailabilityAttr(NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, unsigned AttrSpellingListIndex)
Attribute merging methods. Return true if a new attribute was added.
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)
static bool isValidSwiftIndirectResultType(QualType type)
Pointers and references in the default address space.
const NamedDecl * Result
Definition: USRFinder.cpp:70
Attr - This represents one attribute.
Definition: Attr.h:43
ParsedAttributes & getAttributes()
Definition: DeclSpec.h:751
static void handleDiagnoseIfAttr(Sema &S, Decl *D, const AttributeList &Attr)
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition: Type.h:5991
This parameter (which must have pointer type) is a Swift indirect result parameter.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5928
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:963
SmallVectorImpl< DelayedDiagnostic >::const_iterator pool_iterator
static bool isValidSwiftContextType(QualType type)
Pointer-like types in the default address space.
const DeclSpec & getDeclSpec() const
getDeclSpec - Return the declaration-specifier that this declarator was declared with.
Definition: DeclSpec.h:1849
AttributeList - Represents a syntactic attribute.
Definition: AttributeList.h:95
static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D, const AttributeList &Attr)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5516
bool isPointerType() const
Definition: Type.h:5712
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:2343
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1497