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