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