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