clang  9.0.0svn
SemaDeclAttr.cpp
Go to the documentation of this file.
1 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements decl-related attribute processing.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/ASTConsumer.h"
14 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/Mangle.h"
24 #include "clang/Basic/CharInfo.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Sema/DeclSpec.h"
31 #include "clang/Sema/Lookup.h"
32 #include "clang/Sema/Scope.h"
33 #include "clang/Sema/ScopeInfo.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/Support/MathExtras.h"
38 
39 using namespace clang;
40 using namespace sema;
41 
43  enum LANG {
44  C,
45  Cpp,
47  };
48 } // end namespace AttributeLangSupport
49 
50 //===----------------------------------------------------------------------===//
51 // Helper functions
52 //===----------------------------------------------------------------------===//
53 
54 /// isFunctionOrMethod - Return true if the given decl has function
55 /// type (function or function-typed variable) or an Objective-C
56 /// method.
57 static bool isFunctionOrMethod(const Decl *D) {
58  return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
59 }
60 
61 /// Return true if the given decl has function type (function or
62 /// function-typed variable) or an Objective-C method or a block.
63 static bool isFunctionOrMethodOrBlock(const Decl *D) {
64  return isFunctionOrMethod(D) || isa<BlockDecl>(D);
65 }
66 
67 /// Return true if the given decl has a declarator that should have
68 /// been processed by Sema::GetTypeForDeclarator.
69 static bool hasDeclarator(const Decl *D) {
70  // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
71  return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
72  isa<ObjCPropertyDecl>(D);
73 }
74 
75 /// hasFunctionProto - Return true if the given decl has a argument
76 /// information. This decl should have already passed
77 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
78 static bool hasFunctionProto(const Decl *D) {
79  if (const FunctionType *FnTy = D->getFunctionType())
80  return isa<FunctionProtoType>(FnTy);
81  return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
82 }
83 
84 /// getFunctionOrMethodNumParams - Return number of function or method
85 /// parameters. It is an error to call this on a K&R function (use
86 /// hasFunctionProto first).
87 static unsigned getFunctionOrMethodNumParams(const Decl *D) {
88  if (const FunctionType *FnTy = D->getFunctionType())
89  return cast<FunctionProtoType>(FnTy)->getNumParams();
90  if (const auto *BD = dyn_cast<BlockDecl>(D))
91  return BD->getNumParams();
92  return cast<ObjCMethodDecl>(D)->param_size();
93 }
94 
95 static const ParmVarDecl *getFunctionOrMethodParam(const Decl *D,
96  unsigned Idx) {
97  if (const auto *FD = dyn_cast<FunctionDecl>(D))
98  return FD->getParamDecl(Idx);
99  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
100  return MD->getParamDecl(Idx);
101  if (const auto *BD = dyn_cast<BlockDecl>(D))
102  return BD->getParamDecl(Idx);
103  return nullptr;
104 }
105 
106 static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
107  if (const FunctionType *FnTy = D->getFunctionType())
108  return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
109  if (const auto *BD = dyn_cast<BlockDecl>(D))
110  return BD->getParamDecl(Idx)->getType();
111 
112  return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
113 }
114 
115 static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
116  if (auto *PVD = getFunctionOrMethodParam(D, Idx))
117  return PVD->getSourceRange();
118  return SourceRange();
119 }
120 
122  if (const FunctionType *FnTy = D->getFunctionType())
123  return FnTy->getReturnType();
124  return cast<ObjCMethodDecl>(D)->getReturnType();
125 }
126 
128  if (const auto *FD = dyn_cast<FunctionDecl>(D))
129  return FD->getReturnTypeSourceRange();
130  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
131  return MD->getReturnTypeSourceRange();
132  return SourceRange();
133 }
134 
135 static bool isFunctionOrMethodVariadic(const Decl *D) {
136  if (const FunctionType *FnTy = D->getFunctionType())
137  return cast<FunctionProtoType>(FnTy)->isVariadic();
138  if (const auto *BD = dyn_cast<BlockDecl>(D))
139  return BD->isVariadic();
140  return cast<ObjCMethodDecl>(D)->isVariadic();
141 }
142 
143 static bool isInstanceMethod(const Decl *D) {
144  if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D))
145  return MethodDecl->isInstance();
146  return false;
147 }
148 
149 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
150  const auto *PT = T->getAs<ObjCObjectPointerType>();
151  if (!PT)
152  return false;
153 
154  ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
155  if (!Cls)
156  return false;
157 
158  IdentifierInfo* ClsName = Cls->getIdentifier();
159 
160  // FIXME: Should we walk the chain of classes?
161  return ClsName == &Ctx.Idents.get("NSString") ||
162  ClsName == &Ctx.Idents.get("NSMutableString");
163 }
164 
165 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
166  const auto *PT = T->getAs<PointerType>();
167  if (!PT)
168  return false;
169 
170  const auto *RT = PT->getPointeeType()->getAs<RecordType>();
171  if (!RT)
172  return false;
173 
174  const RecordDecl *RD = RT->getDecl();
175  if (RD->getTagKind() != TTK_Struct)
176  return false;
177 
178  return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
179 }
180 
181 static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
182  // FIXME: Include the type in the argument list.
183  return AL.getNumArgs() + AL.hasParsedType();
184 }
185 
186 template <typename Compare>
187 static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
188  unsigned Num, unsigned Diag,
189  Compare Comp) {
190  if (Comp(getNumAttributeArgs(AL), Num)) {
191  S.Diag(AL.getLoc(), Diag) << AL << Num;
192  return false;
193  }
194 
195  return true;
196 }
197 
198 /// Check if the attribute has exactly as many args as Num. May
199 /// output an error.
200 static bool checkAttributeNumArgs(Sema &S, const ParsedAttr &AL, unsigned Num) {
201  return checkAttributeNumArgsImpl(S, AL, Num,
202  diag::err_attribute_wrong_number_arguments,
203  std::not_equal_to<unsigned>());
204 }
205 
206 /// Check if the attribute has at least as many args as Num. May
207 /// output an error.
208 static bool checkAttributeAtLeastNumArgs(Sema &S, const ParsedAttr &AL,
209  unsigned Num) {
210  return checkAttributeNumArgsImpl(S, AL, Num,
211  diag::err_attribute_too_few_arguments,
212  std::less<unsigned>());
213 }
214 
215 /// Check if the attribute has at most as many args as Num. May
216 /// output an error.
217 static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
218  unsigned Num) {
219  return checkAttributeNumArgsImpl(S, AL, Num,
220  diag::err_attribute_too_many_arguments,
221  std::greater<unsigned>());
222 }
223 
224 /// A helper function to provide Attribute Location for the Attr types
225 /// AND the ParsedAttr.
226 template <typename AttrInfo>
227 static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
229 getAttrLoc(const AttrInfo &AL) {
230  return AL.getLocation();
231 }
232 static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
233 
234 /// If Expr is a valid integer constant, get the value of the integer
235 /// expression and return success or failure. May output an error.
236 ///
237 /// Negative argument is implicitly converted to unsigned, unless
238 /// \p StrictlyUnsigned is true.
239 template <typename AttrInfo>
240 static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
241  uint32_t &Val, unsigned Idx = UINT_MAX,
242  bool StrictlyUnsigned = false) {
243  llvm::APSInt I(32);
244  if (Expr->isTypeDependent() || Expr->isValueDependent() ||
245  !Expr->isIntegerConstantExpr(I, S.Context)) {
246  if (Idx != UINT_MAX)
247  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
248  << &AI << Idx << AANT_ArgumentIntegerConstant
249  << Expr->getSourceRange();
250  else
251  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type)
252  << &AI << AANT_ArgumentIntegerConstant << Expr->getSourceRange();
253  return false;
254  }
255 
256  if (!I.isIntN(32)) {
257  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
258  << I.toString(10, false) << 32 << /* Unsigned */ 1;
259  return false;
260  }
261 
262  if (StrictlyUnsigned && I.isSigned() && I.isNegative()) {
263  S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer)
264  << &AI << /*non-negative*/ 1;
265  return false;
266  }
267 
268  Val = (uint32_t)I.getZExtValue();
269  return true;
270 }
271 
272 /// Wrapper around checkUInt32Argument, with an extra check to be sure
273 /// that the result will fit into a regular (signed) int. All args have the same
274 /// purpose as they do in checkUInt32Argument.
275 template <typename AttrInfo>
276 static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
277  int &Val, unsigned Idx = UINT_MAX) {
278  uint32_t UVal;
279  if (!checkUInt32Argument(S, AI, Expr, UVal, Idx))
280  return false;
281 
282  if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
283  llvm::APSInt I(32); // for toString
284  I = UVal;
285  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
286  << I.toString(10, false) << 32 << /* Unsigned */ 0;
287  return false;
288  }
289 
290  Val = UVal;
291  return true;
292 }
293 
294 /// Diagnose mutually exclusive attributes when present on a given
295 /// declaration. Returns true if diagnosed.
296 template <typename AttrTy>
297 static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {
298  if (const auto *A = D->getAttr<AttrTy>()) {
299  S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A;
300  S.Diag(A->getLocation(), diag::note_conflicting_attribute);
301  return true;
302  }
303  return false;
304 }
305 
306 template <typename AttrTy>
307 static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {
308  if (const auto *A = D->getAttr<AttrTy>()) {
309  S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible) << &AL
310  << A;
311  S.Diag(A->getLocation(), diag::note_conflicting_attribute);
312  return true;
313  }
314  return false;
315 }
316 
317 /// Check if IdxExpr is a valid parameter index for a function or
318 /// instance method D. May output an error.
319 ///
320 /// \returns true if IdxExpr is a valid index.
321 template <typename AttrInfo>
323  Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum,
324  const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
325  assert(isFunctionOrMethodOrBlock(D));
326 
327  // In C++ the implicit 'this' function parameter also counts.
328  // Parameters are counted from one.
329  bool HP = hasFunctionProto(D);
330  bool HasImplicitThisParam = isInstanceMethod(D);
331  bool IV = HP && isFunctionOrMethodVariadic(D);
332  unsigned NumParams =
333  (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
334 
335  llvm::APSInt IdxInt;
336  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
337  !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
338  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
339  << &AI << AttrArgNum << AANT_ArgumentIntegerConstant
340  << IdxExpr->getSourceRange();
341  return false;
342  }
343 
344  unsigned IdxSource = IdxInt.getLimitedValue(UINT_MAX);
345  if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
346  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
347  << &AI << AttrArgNum << IdxExpr->getSourceRange();
348  return false;
349  }
350  if (HasImplicitThisParam && !CanIndexImplicitThis) {
351  if (IdxSource == 1) {
352  S.Diag(getAttrLoc(AI), diag::err_attribute_invalid_implicit_this_argument)
353  << &AI << IdxExpr->getSourceRange();
354  return false;
355  }
356  }
357 
358  Idx = ParamIdx(IdxSource, D);
359  return true;
360 }
361 
362 /// Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
363 /// If not emit an error and return false. If the argument is an identifier it
364 /// will emit an error with a fixit hint and treat it as if it was a string
365 /// literal.
366 bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
367  StringRef &Str,
368  SourceLocation *ArgLocation) {
369  // Look for identifiers. If we have one emit a hint to fix it to a literal.
370  if (AL.isArgIdent(ArgNum)) {
371  IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum);
372  Diag(Loc->Loc, diag::err_attribute_argument_type)
373  << AL << AANT_ArgumentString
374  << FixItHint::CreateInsertion(Loc->Loc, "\"")
375  << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
376  Str = Loc->Ident->getName();
377  if (ArgLocation)
378  *ArgLocation = Loc->Loc;
379  return true;
380  }
381 
382  // Now check for an actual string literal.
383  Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
384  const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
385  if (ArgLocation)
386  *ArgLocation = ArgExpr->getBeginLoc();
387 
388  if (!Literal || !Literal->isAscii()) {
389  Diag(ArgExpr->getBeginLoc(), diag::err_attribute_argument_type)
390  << AL << AANT_ArgumentString;
391  return false;
392  }
393 
394  Str = Literal->getString();
395  return true;
396 }
397 
398 /// Applies the given attribute to the Decl without performing any
399 /// additional semantic checking.
400 template <typename AttrType>
402  unsigned SpellingIndex) {
403  D->addAttr(::new (S.Context) AttrType(SR, S.Context, SpellingIndex));
404 }
405 
406 template <typename AttrType>
407 static void handleSimpleAttribute(Sema &S, Decl *D, const ParsedAttr &AL) {
408  handleSimpleAttribute<AttrType>(S, D, AL.getRange(),
410 }
411 
412 
413 template <typename... DiagnosticArgs>
414 static const Sema::SemaDiagnosticBuilder&
416  return Bldr;
417 }
418 
419 template <typename T, typename... DiagnosticArgs>
420 static const Sema::SemaDiagnosticBuilder&
422  DiagnosticArgs &&... ExtraArgs) {
423  return appendDiagnostics(Bldr << std::forward<T>(ExtraArg),
424  std::forward<DiagnosticArgs>(ExtraArgs)...);
425 }
426 
427 /// Add an attribute {@code AttrType} to declaration {@code D}, provided that
428 /// {@code PassesCheck} is true.
429 /// Otherwise, emit diagnostic {@code DiagID}, passing in all parameters
430 /// specified in {@code ExtraArgs}.
431 template <typename AttrType, typename... DiagnosticArgs>
432 static void
433 handleSimpleAttributeOrDiagnose(Sema &S, Decl *D, SourceRange SR,
434  unsigned SpellingIndex,
435  bool PassesCheck,
436  unsigned DiagID, DiagnosticArgs&&... ExtraArgs) {
437  if (!PassesCheck) {
438  Sema::SemaDiagnosticBuilder DB = S.Diag(D->getBeginLoc(), DiagID);
439  appendDiagnostics(DB, std::forward<DiagnosticArgs>(ExtraArgs)...);
440  return;
441  }
442  handleSimpleAttribute<AttrType>(S, D, SR, SpellingIndex);
443 }
444 
445 template <typename AttrType, typename... DiagnosticArgs>
446 static void
447 handleSimpleAttributeOrDiagnose(Sema &S, Decl *D, const ParsedAttr &AL,
448  bool PassesCheck,
449  unsigned DiagID,
450  DiagnosticArgs&&... ExtraArgs) {
451  return handleSimpleAttributeOrDiagnose<AttrType>(
452  S, D, AL.getRange(), AL.getAttributeSpellingListIndex(), PassesCheck,
453  DiagID, std::forward<DiagnosticArgs>(ExtraArgs)...);
454 }
455 
456 template <typename AttrType>
457 static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
458  const ParsedAttr &AL) {
459  handleSimpleAttribute<AttrType>(S, D, AL);
460 }
461 
462 /// Applies the given attribute to the Decl so long as the Decl doesn't
463 /// already have one of the given incompatible attributes.
464 template <typename AttrType, typename IncompatibleAttrType,
465  typename... IncompatibleAttrTypes>
466 static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
467  const ParsedAttr &AL) {
468  if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, AL))
469  return;
470  handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
471  AL);
472 }
473 
474 /// Check if the passed-in expression is of type int or bool.
475 static bool isIntOrBool(Expr *Exp) {
476  QualType QT = Exp->getType();
477  return QT->isBooleanType() || QT->isIntegerType();
478 }
479 
480 
481 // Check to see if the type is a smart pointer of some kind. We assume
482 // it's a smart pointer if it defines both operator-> and operator*.
483 static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
484  auto IsOverloadedOperatorPresent = [&S](const RecordDecl *Record,
486  DeclContextLookupResult Result =
488  return !Result.empty();
489  };
490 
491  const RecordDecl *Record = RT->getDecl();
492  bool foundStarOperator = IsOverloadedOperatorPresent(Record, OO_Star);
493  bool foundArrowOperator = IsOverloadedOperatorPresent(Record, OO_Arrow);
494  if (foundStarOperator && foundArrowOperator)
495  return true;
496 
497  const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record);
498  if (!CXXRecord)
499  return false;
500 
501  for (auto BaseSpecifier : CXXRecord->bases()) {
502  if (!foundStarOperator)
503  foundStarOperator = IsOverloadedOperatorPresent(
504  BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);
505  if (!foundArrowOperator)
506  foundArrowOperator = IsOverloadedOperatorPresent(
507  BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);
508  }
509 
510  if (foundStarOperator && foundArrowOperator)
511  return true;
512 
513  return false;
514 }
515 
516 /// Check if passed in Decl is a pointer type.
517 /// Note that this function may produce an error message.
518 /// \return true if the Decl is a pointer type; false otherwise
519 static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
520  const ParsedAttr &AL) {
521  const auto *VD = cast<ValueDecl>(D);
522  QualType QT = VD->getType();
523  if (QT->isAnyPointerType())
524  return true;
525 
526  if (const auto *RT = QT->getAs<RecordType>()) {
527  // If it's an incomplete type, it could be a smart pointer; skip it.
528  // (We don't want to force template instantiation if we can avoid it,
529  // since that would alter the order in which templates are instantiated.)
530  if (RT->isIncompleteType())
531  return true;
532 
533  if (threadSafetyCheckIsSmartPointer(S, RT))
534  return true;
535  }
536 
537  S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;
538  return false;
539 }
540 
541 /// Checks that the passed in QualType either is of RecordType or points
542 /// to RecordType. Returns the relevant RecordType, null if it does not exit.
543 static const RecordType *getRecordType(QualType QT) {
544  if (const auto *RT = QT->getAs<RecordType>())
545  return RT;
546 
547  // Now check if we point to record type.
548  if (const auto *PT = QT->getAs<PointerType>())
549  return PT->getPointeeType()->getAs<RecordType>();
550 
551  return nullptr;
552 }
553 
554 template <typename AttrType>
555 static bool checkRecordDeclForAttr(const RecordDecl *RD) {
556  // Check if the record itself has the attribute.
557  if (RD->hasAttr<AttrType>())
558  return true;
559 
560  // Else check if any base classes have the attribute.
561  if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
562  CXXBasePaths BPaths(false, false);
563  if (CRD->lookupInBases(
564  [](const CXXBaseSpecifier *BS, CXXBasePath &) {
565  const auto &Ty = *BS->getType();
566  // If it's type-dependent, we assume it could have the attribute.
567  if (Ty.isDependentType())
568  return true;
569  return Ty.getAs<RecordType>()->getDecl()->hasAttr<AttrType>();
570  },
571  BPaths, true))
572  return true;
573  }
574  return false;
575 }
576 
577 static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
578  const RecordType *RT = getRecordType(Ty);
579 
580  if (!RT)
581  return false;
582 
583  // Don't check for the capability if the class hasn't been defined yet.
584  if (RT->isIncompleteType())
585  return true;
586 
587  // Allow smart pointers to be used as capability objects.
588  // FIXME -- Check the type that the smart pointer points to.
589  if (threadSafetyCheckIsSmartPointer(S, RT))
590  return true;
591 
592  return checkRecordDeclForAttr<CapabilityAttr>(RT->getDecl());
593 }
594 
595 static bool checkTypedefTypeForCapability(QualType Ty) {
596  const auto *TD = Ty->getAs<TypedefType>();
597  if (!TD)
598  return false;
599 
600  TypedefNameDecl *TN = TD->getDecl();
601  if (!TN)
602  return false;
603 
604  return TN->hasAttr<CapabilityAttr>();
605 }
606 
607 static bool typeHasCapability(Sema &S, QualType Ty) {
608  if (checkTypedefTypeForCapability(Ty))
609  return true;
610 
611  if (checkRecordTypeForCapability(S, Ty))
612  return true;
613 
614  return false;
615 }
616 
617 static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
618  // Capability expressions are simple expressions involving the boolean logic
619  // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
620  // a DeclRefExpr is found, its type should be checked to determine whether it
621  // is a capability or not.
622 
623  if (const auto *E = dyn_cast<CastExpr>(Ex))
624  return isCapabilityExpr(S, E->getSubExpr());
625  else if (const auto *E = dyn_cast<ParenExpr>(Ex))
626  return isCapabilityExpr(S, E->getSubExpr());
627  else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
628  if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf ||
629  E->getOpcode() == UO_Deref)
630  return isCapabilityExpr(S, E->getSubExpr());
631  return false;
632  } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
633  if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
634  return isCapabilityExpr(S, E->getLHS()) &&
635  isCapabilityExpr(S, E->getRHS());
636  return false;
637  }
638 
639  return typeHasCapability(S, Ex->getType());
640 }
641 
642 /// Checks that all attribute arguments, starting from Sidx, resolve to
643 /// a capability object.
644 /// \param Sidx The attribute argument index to start checking with.
645 /// \param ParamIdxOk Whether an argument can be indexing into a function
646 /// parameter list.
647 static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
648  const ParsedAttr &AL,
650  unsigned Sidx = 0,
651  bool ParamIdxOk = false) {
652  if (Sidx == AL.getNumArgs()) {
653  // If we don't have any capability arguments, the attribute implicitly
654  // refers to 'this'. So we need to make sure that 'this' exists, i.e. we're
655  // a non-static method, and that the class is a (scoped) capability.
656  const auto *MD = dyn_cast<const CXXMethodDecl>(D);
657  if (MD && !MD->isStatic()) {
658  const CXXRecordDecl *RD = MD->getParent();
659  // FIXME -- need to check this again on template instantiation
660  if (!checkRecordDeclForAttr<CapabilityAttr>(RD) &&
661  !checkRecordDeclForAttr<ScopedLockableAttr>(RD))
662  S.Diag(AL.getLoc(),
663  diag::warn_thread_attribute_not_on_capability_member)
664  << AL << MD->getParent();
665  } else {
666  S.Diag(AL.getLoc(), diag::warn_thread_attribute_not_on_non_static_member)
667  << AL;
668  }
669  }
670 
671  for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) {
672  Expr *ArgExp = AL.getArgAsExpr(Idx);
673 
674  if (ArgExp->isTypeDependent()) {
675  // FIXME -- need to check this again on template instantiation
676  Args.push_back(ArgExp);
677  continue;
678  }
679 
680  if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
681  if (StrLit->getLength() == 0 ||
682  (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
683  // Pass empty strings to the analyzer without warnings.
684  // Treat "*" as the universal lock.
685  Args.push_back(ArgExp);
686  continue;
687  }
688 
689  // We allow constant strings to be used as a placeholder for expressions
690  // that are not valid C++ syntax, but warn that they are ignored.
691  S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL;
692  Args.push_back(ArgExp);
693  continue;
694  }
695 
696  QualType ArgTy = ArgExp->getType();
697 
698  // A pointer to member expression of the form &MyClass::mu is treated
699  // specially -- we need to look at the type of the member.
700  if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
701  if (UOp->getOpcode() == UO_AddrOf)
702  if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
703  if (DRE->getDecl()->isCXXInstanceMember())
704  ArgTy = DRE->getDecl()->getType();
705 
706  // First see if we can just cast to record type, or pointer to record type.
707  const RecordType *RT = getRecordType(ArgTy);
708 
709  // Now check if we index into a record type function param.
710  if(!RT && ParamIdxOk) {
711  const auto *FD = dyn_cast<FunctionDecl>(D);
712  const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
713  if(FD && IL) {
714  unsigned int NumParams = FD->getNumParams();
715  llvm::APInt ArgValue = IL->getValue();
716  uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
717  uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
718  if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
719  S.Diag(AL.getLoc(),
720  diag::err_attribute_argument_out_of_bounds_extra_info)
721  << AL << Idx + 1 << NumParams;
722  continue;
723  }
724  ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
725  }
726  }
727 
728  // If the type does not have a capability, see if the components of the
729  // expression have capabilities. This allows for writing C code where the
730  // capability may be on the type, and the expression is a capability
731  // boolean logic expression. Eg) requires_capability(A || B && !C)
732  if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
733  S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
734  << AL << ArgTy;
735 
736  Args.push_back(ArgExp);
737  }
738 }
739 
740 //===----------------------------------------------------------------------===//
741 // Attribute Implementations
742 //===----------------------------------------------------------------------===//
743 
744 static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
745  if (!threadSafetyCheckIsPointer(S, D, AL))
746  return;
747 
748  D->addAttr(::new (S.Context)
749  PtGuardedVarAttr(AL.getRange(), S.Context,
751 }
752 
753 static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
754  Expr *&Arg) {
756  // check that all arguments are lockable objects
757  checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
758  unsigned Size = Args.size();
759  if (Size != 1)
760  return false;
761 
762  Arg = Args[0];
763 
764  return true;
765 }
766 
767 static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
768  Expr *Arg = nullptr;
769  if (!checkGuardedByAttrCommon(S, D, AL, Arg))
770  return;
771 
772  D->addAttr(::new (S.Context) GuardedByAttr(
773  AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
774 }
775 
776 static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
777  Expr *Arg = nullptr;
778  if (!checkGuardedByAttrCommon(S, D, AL, Arg))
779  return;
780 
781  if (!threadSafetyCheckIsPointer(S, D, AL))
782  return;
783 
784  D->addAttr(::new (S.Context) PtGuardedByAttr(
785  AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
786 }
787 
788 static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
789  SmallVectorImpl<Expr *> &Args) {
790  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
791  return false;
792 
793  // Check that this attribute only applies to lockable types.
794  QualType QT = cast<ValueDecl>(D)->getType();
795  if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
796  S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL;
797  return false;
798  }
799 
800  // Check that all arguments are lockable objects.
801  checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
802  if (Args.empty())
803  return false;
804 
805  return true;
806 }
807 
808 static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
810  if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
811  return;
812 
813  Expr **StartArg = &Args[0];
814  D->addAttr(::new (S.Context) AcquiredAfterAttr(
815  AL.getRange(), S.Context, StartArg, Args.size(),
817 }
818 
819 static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
821  if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
822  return;
823 
824  Expr **StartArg = &Args[0];
825  D->addAttr(::new (S.Context) AcquiredBeforeAttr(
826  AL.getRange(), S.Context, StartArg, Args.size(),
828 }
829 
830 static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
831  SmallVectorImpl<Expr *> &Args) {
832  // zero or more arguments ok
833  // check that all arguments are lockable objects
834  checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true);
835 
836  return true;
837 }
838 
839 static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
841  if (!checkLockFunAttrCommon(S, D, AL, Args))
842  return;
843 
844  unsigned Size = Args.size();
845  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
846  D->addAttr(::new (S.Context)
847  AssertSharedLockAttr(AL.getRange(), S.Context, StartArg, Size,
849 }
850 
851 static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
852  const ParsedAttr &AL) {
854  if (!checkLockFunAttrCommon(S, D, AL, Args))
855  return;
856 
857  unsigned Size = Args.size();
858  Expr **StartArg = Size == 0 ? nullptr : &Args[0];
859  D->addAttr(::new (S.Context) AssertExclusiveLockAttr(
860  AL.getRange(), S.Context, StartArg, Size,
862 }
863 
864 /// Checks to be sure that the given parameter number is in bounds, and
865 /// is an integral type. Will emit appropriate diagnostics if this returns
866 /// false.
867 ///
868 /// AttrArgNo is used to actually retrieve the argument, so it's base-0.
869 template <typename AttrInfo>
870 static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
871  const AttrInfo &AI, unsigned AttrArgNo) {
872  assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument");
873  Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
874  ParamIdx Idx;
875  if (!checkFunctionOrMethodParameterIndex(S, FD, AI, AttrArgNo + 1, AttrArg,
876  Idx))
877  return false;
878 
879  const ParmVarDecl *Param = FD->getParamDecl(Idx.getASTIndex());
880  if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
881  SourceLocation SrcLoc = AttrArg->getBeginLoc();
882  S.Diag(SrcLoc, diag::err_attribute_integers_only)
883  << AI << Param->getSourceRange();
884  return false;
885  }
886  return true;
887 }
888 
889 static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
890  if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
891  !checkAttributeAtMostNumArgs(S, AL, 2))
892  return;
893 
894  const auto *FD = cast<FunctionDecl>(D);
895  if (!FD->getReturnType()->isPointerType()) {
896  S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;
897  return;
898  }
899 
900  const Expr *SizeExpr = AL.getArgAsExpr(0);
901  int SizeArgNoVal;
902  // Parameter indices are 1-indexed, hence Index=1
903  if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Index=*/1))
904  return;
905  if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/0))
906  return;
907  ParamIdx SizeArgNo(SizeArgNoVal, D);
908 
909  ParamIdx NumberArgNo;
910  if (AL.getNumArgs() == 2) {
911  const Expr *NumberExpr = AL.getArgAsExpr(1);
912  int Val;
913  // Parameter indices are 1-based, hence Index=2
914  if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Index=*/2))
915  return;
916  if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/1))
917  return;
918  NumberArgNo = ParamIdx(Val, D);
919  }
920 
921  D->addAttr(::new (S.Context)
922  AllocSizeAttr(AL.getRange(), S.Context, SizeArgNo, NumberArgNo,
924 }
925 
926 static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
927  SmallVectorImpl<Expr *> &Args) {
928  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
929  return false;
930 
931  if (!isIntOrBool(AL.getArgAsExpr(0))) {
932  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
933  << AL << 1 << AANT_ArgumentIntOrBool;
934  return false;
935  }
936 
937  // check that all arguments are lockable objects
938  checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1);
939 
940  return true;
941 }
942 
943 static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
944  const ParsedAttr &AL) {
946  if (!checkTryLockFunAttrCommon(S, D, AL, Args))
947  return;
948 
949  D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(
950  AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(), Args.size(),
952 }
953 
954 static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
955  const ParsedAttr &AL) {
957  if (!checkTryLockFunAttrCommon(S, D, AL, Args))
958  return;
959 
960  D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
961  AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(),
962  Args.size(), AL.getAttributeSpellingListIndex()));
963 }
964 
965 static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
966  // check that the argument is lockable object
968  checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
969  unsigned Size = Args.size();
970  if (Size == 0)
971  return;
972 
973  D->addAttr(::new (S.Context)
974  LockReturnedAttr(AL.getRange(), S.Context, Args[0],
976 }
977 
978 static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
979  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
980  return;
981 
982  // check that all arguments are lockable objects
984  checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
985  unsigned Size = Args.size();
986  if (Size == 0)
987  return;
988  Expr **StartArg = &Args[0];
989 
990  D->addAttr(::new (S.Context)
991  LocksExcludedAttr(AL.getRange(), S.Context, StartArg, Size,
993 }
994 
995 static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
996  Expr *&Cond, StringRef &Msg) {
997  Cond = AL.getArgAsExpr(0);
998  if (!Cond->isTypeDependent()) {
999  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
1000  if (Converted.isInvalid())
1001  return false;
1002  Cond = Converted.get();
1003  }
1004 
1005  if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg))
1006  return false;
1007 
1008  if (Msg.empty())
1009  Msg = "<no message provided>";
1010 
1012  if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
1013  !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
1014  Diags)) {
1015  S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr) << AL;
1016  for (const PartialDiagnosticAt &PDiag : Diags)
1017  S.Diag(PDiag.first, PDiag.second);
1018  return false;
1019  }
1020  return true;
1021 }
1022 
1023 static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1024  S.Diag(AL.getLoc(), diag::ext_clang_enable_if);
1025 
1026  Expr *Cond;
1027  StringRef Msg;
1028  if (checkFunctionConditionAttr(S, D, AL, Cond, Msg))
1029  D->addAttr(::new (S.Context)
1030  EnableIfAttr(AL.getRange(), S.Context, Cond, Msg,
1032 }
1033 
1034 namespace {
1035 /// Determines if a given Expr references any of the given function's
1036 /// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
1037 class ArgumentDependenceChecker
1038  : public RecursiveASTVisitor<ArgumentDependenceChecker> {
1039 #ifndef NDEBUG
1040  const CXXRecordDecl *ClassType;
1041 #endif
1042  llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
1043  bool Result;
1044 
1045 public:
1046  ArgumentDependenceChecker(const FunctionDecl *FD) {
1047 #ifndef NDEBUG
1048  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1049  ClassType = MD->getParent();
1050  else
1051  ClassType = nullptr;
1052 #endif
1053  Parms.insert(FD->param_begin(), FD->param_end());
1054  }
1055 
1056  bool referencesArgs(Expr *E) {
1057  Result = false;
1058  TraverseStmt(E);
1059  return Result;
1060  }
1061 
1062  bool VisitCXXThisExpr(CXXThisExpr *E) {
1063  assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&
1064  "`this` doesn't refer to the enclosing class?");
1065  Result = true;
1066  return false;
1067  }
1068 
1069  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
1070  if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
1071  if (Parms.count(PVD)) {
1072  Result = true;
1073  return false;
1074  }
1075  return true;
1076  }
1077 };
1078 }
1079 
1080 static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1081  S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);
1082 
1083  Expr *Cond;
1084  StringRef Msg;
1085  if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg))
1086  return;
1087 
1088  StringRef DiagTypeStr;
1089  if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr))
1090  return;
1091 
1092  DiagnoseIfAttr::DiagnosticType DiagType;
1093  if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
1094  S.Diag(AL.getArgAsExpr(2)->getBeginLoc(),
1095  diag::err_diagnose_if_invalid_diagnostic_type);
1096  return;
1097  }
1098 
1099  bool ArgDependent = false;
1100  if (const auto *FD = dyn_cast<FunctionDecl>(D))
1101  ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
1102  D->addAttr(::new (S.Context) DiagnoseIfAttr(
1103  AL.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent,
1104  cast<NamedDecl>(D), AL.getAttributeSpellingListIndex()));
1105 }
1106 
1107 static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1108  if (D->hasAttr<PassObjectSizeAttr>()) {
1109  S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL;
1110  return;
1111  }
1112 
1113  Expr *E = AL.getArgAsExpr(0);
1114  uint32_t Type;
1115  if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1))
1116  return;
1117 
1118  // pass_object_size's argument is passed in as the second argument of
1119  // __builtin_object_size. So, it has the same constraints as that second
1120  // argument; namely, it must be in the range [0, 3].
1121  if (Type > 3) {
1122  S.Diag(E->getBeginLoc(), diag::err_attribute_argument_out_of_range)
1123  << AL << 0 << 3 << E->getSourceRange();
1124  return;
1125  }
1126 
1127  // pass_object_size is only supported on constant pointer parameters; as a
1128  // kindness to users, we allow the parameter to be non-const for declarations.
1129  // At this point, we have no clue if `D` belongs to a function declaration or
1130  // definition, so we defer the constness check until later.
1131  if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1132  S.Diag(D->getBeginLoc(), diag::err_attribute_pointers_only) << AL << 1;
1133  return;
1134  }
1135 
1136  D->addAttr(::new (S.Context) PassObjectSizeAttr(
1137  AL.getRange(), S.Context, (int)Type, AL.getAttributeSpellingListIndex()));
1138 }
1139 
1140 static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1141  ConsumableAttr::ConsumedState DefaultState;
1142 
1143  if (AL.isArgIdent(0)) {
1144  IdentifierLoc *IL = AL.getArgAsIdent(0);
1145  if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1146  DefaultState)) {
1147  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1148  << IL->Ident;
1149  return;
1150  }
1151  } else {
1152  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1153  << AL << AANT_ArgumentIdentifier;
1154  return;
1155  }
1156 
1157  D->addAttr(::new (S.Context)
1158  ConsumableAttr(AL.getRange(), S.Context, DefaultState,
1160 }
1161 
1162 static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
1163  const ParsedAttr &AL) {
1164  QualType ThisType = MD->getThisType()->getPointeeType();
1165 
1166  if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1167  if (!RD->hasAttr<ConsumableAttr>()) {
1168  S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) <<
1169  RD->getNameAsString();
1170 
1171  return false;
1172  }
1173  }
1174 
1175  return true;
1176 }
1177 
1178 static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1179  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1180  return;
1181 
1182  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1183  return;
1184 
1186  for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
1187  CallableWhenAttr::ConsumedState CallableState;
1188 
1189  StringRef StateString;
1190  SourceLocation Loc;
1191  if (AL.isArgIdent(ArgIndex)) {
1192  IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
1193  StateString = Ident->Ident->getName();
1194  Loc = Ident->Loc;
1195  } else {
1196  if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc))
1197  return;
1198  }
1199 
1200  if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1201  CallableState)) {
1202  S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString;
1203  return;
1204  }
1205 
1206  States.push_back(CallableState);
1207  }
1208 
1209  D->addAttr(::new (S.Context)
1210  CallableWhenAttr(AL.getRange(), S.Context, States.data(),
1211  States.size(), AL.getAttributeSpellingListIndex()));
1212 }
1213 
1214 static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1216 
1217  if (AL.isArgIdent(0)) {
1218  IdentifierLoc *Ident = AL.getArgAsIdent(0);
1219  StringRef StateString = Ident->Ident->getName();
1220 
1221  if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1222  ParamState)) {
1223  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1224  << AL << StateString;
1225  return;
1226  }
1227  } else {
1228  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1229  << AL << AANT_ArgumentIdentifier;
1230  return;
1231  }
1232 
1233  // FIXME: This check is currently being done in the analysis. It can be
1234  // enabled here only after the parser propagates attributes at
1235  // template specialization definition, not declaration.
1236  //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1237  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1238  //
1239  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1240  // S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1241  // ReturnType.getAsString();
1242  // return;
1243  //}
1244 
1245  D->addAttr(::new (S.Context)
1246  ParamTypestateAttr(AL.getRange(), S.Context, ParamState,
1248 }
1249 
1250 static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1252 
1253  if (AL.isArgIdent(0)) {
1254  IdentifierLoc *IL = AL.getArgAsIdent(0);
1255  if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1256  ReturnState)) {
1257  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1258  << IL->Ident;
1259  return;
1260  }
1261  } else {
1262  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1263  << AL << AANT_ArgumentIdentifier;
1264  return;
1265  }
1266 
1267  // FIXME: This check is currently being done in the analysis. It can be
1268  // enabled here only after the parser propagates attributes at
1269  // template specialization definition, not declaration.
1270  //QualType ReturnType;
1271  //
1272  //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1273  // ReturnType = Param->getType();
1274  //
1275  //} else if (const CXXConstructorDecl *Constructor =
1276  // dyn_cast<CXXConstructorDecl>(D)) {
1277  // ReturnType = Constructor->getThisType()->getPointeeType();
1278  //
1279  //} else {
1280  //
1281  // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1282  //}
1283  //
1284  //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1285  //
1286  //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1287  // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1288  // ReturnType.getAsString();
1289  // return;
1290  //}
1291 
1292  D->addAttr(::new (S.Context)
1293  ReturnTypestateAttr(AL.getRange(), S.Context, ReturnState,
1295 }
1296 
1297 static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1298  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1299  return;
1300 
1302  if (AL.isArgIdent(0)) {
1303  IdentifierLoc *Ident = AL.getArgAsIdent(0);
1304  StringRef Param = Ident->Ident->getName();
1305  if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1306  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1307  << Param;
1308  return;
1309  }
1310  } else {
1311  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1312  << AL << AANT_ArgumentIdentifier;
1313  return;
1314  }
1315 
1316  D->addAttr(::new (S.Context)
1317  SetTypestateAttr(AL.getRange(), S.Context, NewState,
1319 }
1320 
1321 static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1322  if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1323  return;
1324 
1326  if (AL.isArgIdent(0)) {
1327  IdentifierLoc *Ident = AL.getArgAsIdent(0);
1328  StringRef Param = Ident->Ident->getName();
1329  if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1330  S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1331  << Param;
1332  return;
1333  }
1334  } else {
1335  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1336  << AL << AANT_ArgumentIdentifier;
1337  return;
1338  }
1339 
1340  D->addAttr(::new (S.Context)
1341  TestTypestateAttr(AL.getRange(), S.Context, TestState,
1343 }
1344 
1345 static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1346  // Remember this typedef decl, we will need it later for diagnostics.
1347  S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1348 }
1349 
1350 static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1351  if (auto *TD = dyn_cast<TagDecl>(D))
1352  TD->addAttr(::new (S.Context) PackedAttr(AL.getRange(), S.Context,
1354  else if (auto *FD = dyn_cast<FieldDecl>(D)) {
1355  bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
1356  !FD->getType()->isIncompleteType() &&
1357  FD->isBitField() &&
1358  S.Context.getTypeAlign(FD->getType()) <= 8);
1359 
1360  if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
1361  if (BitfieldByteAligned)
1362  // The PS4 target needs to maintain ABI backwards compatibility.
1363  S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1364  << AL << FD->getType();
1365  else
1366  FD->addAttr(::new (S.Context) PackedAttr(
1368  } else {
1369  // Report warning about changed offset in the newer compiler versions.
1370  if (BitfieldByteAligned)
1371  S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);
1372 
1373  FD->addAttr(::new (S.Context) PackedAttr(
1375  }
1376 
1377  } else
1378  S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
1379 }
1380 
1381 static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
1382  // The IBOutlet/IBOutletCollection attributes only apply to instance
1383  // variables or properties of Objective-C classes. The outlet must also
1384  // have an object reference type.
1385  if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {
1386  if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1387  S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1388  << AL << VD->getType() << 0;
1389  return false;
1390  }
1391  }
1392  else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1393  if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1394  S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1395  << AL << PD->getType() << 1;
1396  return false;
1397  }
1398  }
1399  else {
1400  S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL;
1401  return false;
1402  }
1403 
1404  return true;
1405 }
1406 
1407 static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
1408  if (!checkIBOutletCommon(S, D, AL))
1409  return;
1410 
1411  D->addAttr(::new (S.Context)
1412  IBOutletAttr(AL.getRange(), S.Context,
1414 }
1415 
1416 static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {
1417 
1418  // The iboutletcollection attribute can have zero or one arguments.
1419  if (AL.getNumArgs() > 1) {
1420  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1421  return;
1422  }
1423 
1424  if (!checkIBOutletCommon(S, D, AL))
1425  return;
1426 
1427  ParsedType PT;
1428 
1429  if (AL.hasParsedType())
1430  PT = AL.getTypeArg();
1431  else {
1432  PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(),
1434  if (!PT) {
1435  S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1436  return;
1437  }
1438  }
1439 
1440  TypeSourceInfo *QTLoc = nullptr;
1441  QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1442  if (!QTLoc)
1443  QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc());
1444 
1445  // Diagnose use of non-object type in iboutletcollection attribute.
1446  // FIXME. Gnu attribute extension ignores use of builtin types in
1447  // attributes. So, __attribute__((iboutletcollection(char))) will be
1448  // treated as __attribute__((iboutletcollection())).
1449  if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1450  S.Diag(AL.getLoc(),
1451  QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1452  : diag::err_iboutletcollection_type) << QT;
1453  return;
1454  }
1455 
1456  D->addAttr(::new (S.Context)
1457  IBOutletCollectionAttr(AL.getRange(), S.Context, QTLoc,
1459 }
1460 
1461 bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) {
1462  if (RefOkay) {
1463  if (T->isReferenceType())
1464  return true;
1465  } else {
1466  T = T.getNonReferenceType();
1467  }
1468 
1469  // The nonnull attribute, and other similar attributes, can be applied to a
1470  // transparent union that contains a pointer type.
1471  if (const RecordType *UT = T->getAsUnionType()) {
1472  if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1473  RecordDecl *UD = UT->getDecl();
1474  for (const auto *I : UD->fields()) {
1475  QualType QT = I->getType();
1476  if (QT->isAnyPointerType() || QT->isBlockPointerType())
1477  return true;
1478  }
1479  }
1480  }
1481 
1482  return T->isAnyPointerType() || T->isBlockPointerType();
1483 }
1484 
1485 static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
1486  SourceRange AttrParmRange,
1487  SourceRange TypeRange,
1488  bool isReturnValue = false) {
1489  if (!S.isValidPointerAttrType(T)) {
1490  if (isReturnValue)
1491  S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1492  << AL << AttrParmRange << TypeRange;
1493  else
1494  S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1495  << AL << AttrParmRange << TypeRange << 0;
1496  return false;
1497  }
1498  return true;
1499 }
1500 
1501 static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1502  SmallVector<ParamIdx, 8> NonNullArgs;
1503  for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
1504  Expr *Ex = AL.getArgAsExpr(I);
1505  ParamIdx Idx;
1506  if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx))
1507  return;
1508 
1509  // Is the function argument a pointer type?
1510  if (Idx.getASTIndex() < getFunctionOrMethodNumParams(D) &&
1511  !attrNonNullArgCheck(
1512  S, getFunctionOrMethodParamType(D, Idx.getASTIndex()), AL,
1513  Ex->getSourceRange(),
1515  continue;
1516 
1517  NonNullArgs.push_back(Idx);
1518  }
1519 
1520  // If no arguments were specified to __attribute__((nonnull)) then all pointer
1521  // arguments have a nonnull attribute; warn if there aren't any. Skip this
1522  // check if the attribute came from a macro expansion or a template
1523  // instantiation.
1524  if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
1525  !S.inTemplateInstantiation()) {
1526  bool AnyPointers = isFunctionOrMethodVariadic(D);
1527  for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1528  I != E && !AnyPointers; ++I) {
1530  if (T->isDependentType() || S.isValidPointerAttrType(T))
1531  AnyPointers = true;
1532  }
1533 
1534  if (!AnyPointers)
1535  S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1536  }
1537 
1538  ParamIdx *Start = NonNullArgs.data();
1539  unsigned Size = NonNullArgs.size();
1540  llvm::array_pod_sort(Start, Start + Size);
1541  D->addAttr(::new (S.Context)
1542  NonNullAttr(AL.getRange(), S.Context, Start, Size,
1544 }
1545 
1546 static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
1547  const ParsedAttr &AL) {
1548  if (AL.getNumArgs() > 0) {
1549  if (D->getFunctionType()) {
1550  handleNonNullAttr(S, D, AL);
1551  } else {
1552  S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1553  << D->getSourceRange();
1554  }
1555  return;
1556  }
1557 
1558  // Is the argument a pointer type?
1559  if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(),
1560  D->getSourceRange()))
1561  return;
1562 
1563  D->addAttr(::new (S.Context)
1564  NonNullAttr(AL.getRange(), S.Context, nullptr, 0,
1566 }
1567 
1568 static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1569  QualType ResultType = getFunctionOrMethodResultType(D);
1571  if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
1572  /* isReturnValue */ true))
1573  return;
1574 
1575  D->addAttr(::new (S.Context)
1576  ReturnsNonNullAttr(AL.getRange(), S.Context,
1578 }
1579 
1580 static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1581  if (D->isInvalidDecl())
1582  return;
1583 
1584  // noescape only applies to pointer types.
1585  QualType T = cast<ParmVarDecl>(D)->getType();
1586  if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
1587  S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1588  << AL << AL.getRange() << 0;
1589  return;
1590  }
1591 
1592  D->addAttr(::new (S.Context) NoEscapeAttr(
1594 }
1595 
1596 static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1597  Expr *E = AL.getArgAsExpr(0),
1598  *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
1599  S.AddAssumeAlignedAttr(AL.getRange(), D, E, OE,
1601 }
1602 
1603 static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1604  S.AddAllocAlignAttr(AL.getRange(), D, AL.getArgAsExpr(0),
1606 }
1607 
1608 void Sema::AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
1609  Expr *OE, unsigned SpellingListIndex) {
1610  QualType ResultType = getFunctionOrMethodResultType(D);
1612 
1613  AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1614  SourceLocation AttrLoc = AttrRange.getBegin();
1615 
1616  if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1617  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1618  << &TmpAttr << AttrRange << SR;
1619  return;
1620  }
1621 
1622  if (!E->isValueDependent()) {
1623  llvm::APSInt I(64);
1624  if (!E->isIntegerConstantExpr(I, Context)) {
1625  if (OE)
1626  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1627  << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1628  << E->getSourceRange();
1629  else
1630  Diag(AttrLoc, diag::err_attribute_argument_type)
1631  << &TmpAttr << AANT_ArgumentIntegerConstant
1632  << E->getSourceRange();
1633  return;
1634  }
1635 
1636  if (!I.isPowerOf2()) {
1637  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1638  << E->getSourceRange();
1639  return;
1640  }
1641  }
1642 
1643  if (OE) {
1644  if (!OE->isValueDependent()) {
1645  llvm::APSInt I(64);
1646  if (!OE->isIntegerConstantExpr(I, Context)) {
1647  Diag(AttrLoc, diag::err_attribute_argument_n_type)
1648  << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1649  << OE->getSourceRange();
1650  return;
1651  }
1652  }
1653  }
1654 
1655  D->addAttr(::new (Context)
1656  AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1657 }
1658 
1659 void Sema::AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
1660  unsigned SpellingListIndex) {
1661  QualType ResultType = getFunctionOrMethodResultType(D);
1662 
1663  AllocAlignAttr TmpAttr(AttrRange, Context, ParamIdx(), SpellingListIndex);
1664  SourceLocation AttrLoc = AttrRange.getBegin();
1665 
1666  if (!ResultType->isDependentType() &&
1667  !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1668  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1669  << &TmpAttr << AttrRange << getFunctionOrMethodResultSourceRange(D);
1670  return;
1671  }
1672 
1673  ParamIdx Idx;
1674  const auto *FuncDecl = cast<FunctionDecl>(D);
1675  if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1676  /*AttrArgNo=*/1, ParamExpr, Idx))
1677  return;
1678 
1680  if (!Ty->isDependentType() && !Ty->isIntegralType(Context)) {
1681  Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only)
1682  << &TmpAttr
1683  << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
1684  return;
1685  }
1686 
1687  D->addAttr(::new (Context)
1688  AllocAlignAttr(AttrRange, Context, Idx, SpellingListIndex));
1689 }
1690 
1691 /// Normalize the attribute, __foo__ becomes foo.
1692 /// Returns true if normalization was applied.
1693 static bool normalizeName(StringRef &AttrName) {
1694  if (AttrName.size() > 4 && AttrName.startswith("__") &&
1695  AttrName.endswith("__")) {
1696  AttrName = AttrName.drop_front(2).drop_back(2);
1697  return true;
1698  }
1699  return false;
1700 }
1701 
1702 static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1703  // This attribute must be applied to a function declaration. The first
1704  // argument to the attribute must be an identifier, the name of the resource,
1705  // for example: malloc. The following arguments must be argument indexes, the
1706  // arguments must be of integer type for Returns, otherwise of pointer type.
1707  // The difference between Holds and Takes is that a pointer may still be used
1708  // after being held. free() should be __attribute((ownership_takes)), whereas
1709  // a list append function may well be __attribute((ownership_holds)).
1710 
1711  if (!AL.isArgIdent(0)) {
1712  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1713  << AL << 1 << AANT_ArgumentIdentifier;
1714  return;
1715  }
1716 
1717  // Figure out our Kind.
1718  OwnershipAttr::OwnershipKind K =
1719  OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1720  AL.getAttributeSpellingListIndex()).getOwnKind();
1721 
1722  // Check arguments.
1723  switch (K) {
1724  case OwnershipAttr::Takes:
1725  case OwnershipAttr::Holds:
1726  if (AL.getNumArgs() < 2) {
1727  S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments) << AL << 2;
1728  return;
1729  }
1730  break;
1731  case OwnershipAttr::Returns:
1732  if (AL.getNumArgs() > 2) {
1733  S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
1734  return;
1735  }
1736  break;
1737  }
1738 
1740 
1741  StringRef ModuleName = Module->getName();
1742  if (normalizeName(ModuleName)) {
1743  Module = &S.PP.getIdentifierTable().get(ModuleName);
1744  }
1745 
1746  SmallVector<ParamIdx, 8> OwnershipArgs;
1747  for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1748  Expr *Ex = AL.getArgAsExpr(i);
1749  ParamIdx Idx;
1750  if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1751  return;
1752 
1753  // Is the function argument a pointer type?
1755  int Err = -1; // No error
1756  switch (K) {
1757  case OwnershipAttr::Takes:
1758  case OwnershipAttr::Holds:
1759  if (!T->isAnyPointerType() && !T->isBlockPointerType())
1760  Err = 0;
1761  break;
1762  case OwnershipAttr::Returns:
1763  if (!T->isIntegerType())
1764  Err = 1;
1765  break;
1766  }
1767  if (-1 != Err) {
1768  S.Diag(AL.getLoc(), diag::err_ownership_type) << AL << Err
1769  << Ex->getSourceRange();
1770  return;
1771  }
1772 
1773  // Check we don't have a conflict with another ownership attribute.
1774  for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1775  // Cannot have two ownership attributes of different kinds for the same
1776  // index.
1777  if (I->getOwnKind() != K && I->args_end() !=
1778  std::find(I->args_begin(), I->args_end(), Idx)) {
1779  S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << I;
1780  return;
1781  } else if (K == OwnershipAttr::Returns &&
1782  I->getOwnKind() == OwnershipAttr::Returns) {
1783  // A returns attribute conflicts with any other returns attribute using
1784  // a different index.
1785  if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1786  S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1787  << I->args_begin()->getSourceIndex();
1788  if (I->args_size())
1789  S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1790  << Idx.getSourceIndex() << Ex->getSourceRange();
1791  return;
1792  }
1793  }
1794  }
1795  OwnershipArgs.push_back(Idx);
1796  }
1797 
1798  ParamIdx *Start = OwnershipArgs.data();
1799  unsigned Size = OwnershipArgs.size();
1800  llvm::array_pod_sort(Start, Start + Size);
1801  D->addAttr(::new (S.Context)
1802  OwnershipAttr(AL.getLoc(), S.Context, Module, Start, Size,
1804 }
1805 
1806 static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1807  // Check the attribute arguments.
1808  if (AL.getNumArgs() > 1) {
1809  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1810  return;
1811  }
1812 
1813  // gcc rejects
1814  // class c {
1815  // static int a __attribute__((weakref ("v2")));
1816  // static int b() __attribute__((weakref ("f3")));
1817  // };
1818  // and ignores the attributes of
1819  // void f(void) {
1820  // static int a __attribute__((weakref ("v2")));
1821  // }
1822  // we reject them
1823  const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1824  if (!Ctx->isFileContext()) {
1825  S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context)
1826  << cast<NamedDecl>(D);
1827  return;
1828  }
1829 
1830  // The GCC manual says
1831  //
1832  // At present, a declaration to which `weakref' is attached can only
1833  // be `static'.
1834  //
1835  // It also says
1836  //
1837  // Without a TARGET,
1838  // given as an argument to `weakref' or to `alias', `weakref' is
1839  // equivalent to `weak'.
1840  //
1841  // gcc 4.4.1 will accept
1842  // int a7 __attribute__((weakref));
1843  // as
1844  // int a7 __attribute__((weak));
1845  // This looks like a bug in gcc. We reject that for now. We should revisit
1846  // it if this behaviour is actually used.
1847 
1848  // GCC rejects
1849  // static ((alias ("y"), weakref)).
1850  // Should we? How to check that weakref is before or after alias?
1851 
1852  // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1853  // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1854  // StringRef parameter it was given anyway.
1855  StringRef Str;
1856  if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str))
1857  // GCC will accept anything as the argument of weakref. Should we
1858  // check for an existing decl?
1859  D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,
1861 
1862  D->addAttr(::new (S.Context)
1863  WeakRefAttr(AL.getRange(), S.Context,
1865 }
1866 
1867 static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1868  StringRef Str;
1869  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1870  return;
1871 
1872  // Aliases should be on declarations, not definitions.
1873  const auto *FD = cast<FunctionDecl>(D);
1874  if (FD->isThisDeclarationADefinition()) {
1875  S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;
1876  return;
1877  }
1878 
1879  D->addAttr(::new (S.Context) IFuncAttr(AL.getRange(), S.Context, Str,
1881 }
1882 
1883 static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1884  StringRef Str;
1885  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1886  return;
1887 
1888  if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1889  S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);
1890  return;
1891  }
1892  if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
1893  S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);
1894  }
1895 
1896  // Aliases should be on declarations, not definitions.
1897  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
1898  if (FD->isThisDeclarationADefinition()) {
1899  S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;
1900  return;
1901  }
1902  } else {
1903  const auto *VD = cast<VarDecl>(D);
1904  if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1905  S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;
1906  return;
1907  }
1908  }
1909 
1910  // Mark target used to prevent unneeded-internal-declaration warnings.
1911  if (!S.LangOpts.CPlusPlus) {
1912  // FIXME: demangle Str for C++, as the attribute refers to the mangled
1913  // linkage name, not the pre-mangled identifier.
1914  const DeclarationNameInfo target(&S.Context.Idents.get(Str), AL.getLoc());
1915  LookupResult LR(S, target, Sema::LookupOrdinaryName);
1917  for (NamedDecl *ND : LR)
1918  ND->markUsed(S.Context);
1919  }
1920 
1921  D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,
1923 }
1924 
1925 static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1926  StringRef Model;
1927  SourceLocation LiteralLoc;
1928  // Check that it is a string.
1929  if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc))
1930  return;
1931 
1932  // Check that the value.
1933  if (Model != "global-dynamic" && Model != "local-dynamic"
1934  && Model != "initial-exec" && Model != "local-exec") {
1935  S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1936  return;
1937  }
1938 
1939  D->addAttr(::new (S.Context)
1940  TLSModelAttr(AL.getRange(), S.Context, Model,
1942 }
1943 
1944 static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1945  QualType ResultType = getFunctionOrMethodResultType(D);
1946  if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1947  D->addAttr(::new (S.Context) RestrictAttr(
1949  return;
1950  }
1951 
1952  S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1954 }
1955 
1956 static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1957  FunctionDecl *FD = cast<FunctionDecl>(D);
1958 
1959  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
1960  if (MD->getParent()->isLambda()) {
1961  S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL;
1962  return;
1963  }
1964  }
1965 
1966  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1967  return;
1968 
1970  for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {
1971  if (!AL.isArgIdent(ArgNo)) {
1972  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1973  << AL << AANT_ArgumentIdentifier;
1974  return;
1975  }
1976 
1977  IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo);
1978  StringRef CPUName = CPUArg->Ident->getName().trim();
1979 
1981  S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value)
1982  << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch);
1983  return;
1984  }
1985 
1986  const TargetInfo &Target = S.Context.getTargetInfo();
1987  if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) {
1988  return Target.CPUSpecificManglingCharacter(CPUName) ==
1989  Target.CPUSpecificManglingCharacter(Cur->getName());
1990  })) {
1991  S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);
1992  return;
1993  }
1994  CPUs.push_back(CPUArg->Ident);
1995  }
1996 
1997  FD->setIsMultiVersion(true);
1998  if (AL.getKind() == ParsedAttr::AT_CPUSpecific)
1999  D->addAttr(::new (S.Context) CPUSpecificAttr(
2000  AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
2002  else
2003  D->addAttr(::new (S.Context) CPUDispatchAttr(
2004  AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
2006 }
2007 
2008 static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2009  if (S.LangOpts.CPlusPlus) {
2010  S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
2011  << AL << AttributeLangSupport::Cpp;
2012  return;
2013  }
2014 
2015  if (CommonAttr *CA = S.mergeCommonAttr(D, AL))
2016  D->addAttr(CA);
2017 }
2018 
2019 static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2020  if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, AL))
2021  return;
2022 
2023  if (AL.isDeclspecAttribute()) {
2024  const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
2025  const auto &Arch = Triple.getArch();
2026  if (Arch != llvm::Triple::x86 &&
2027  (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
2028  S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch)
2029  << AL << Triple.getArchName();
2030  return;
2031  }
2032  }
2033 
2034  D->addAttr(::new (S.Context) NakedAttr(AL.getRange(), S.Context,
2036 }
2037 
2038 static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2039  if (hasDeclarator(D)) return;
2040 
2041  if (!isa<ObjCMethodDecl>(D)) {
2042  S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
2043  << Attrs << ExpectedFunctionOrMethod;
2044  return;
2045  }
2046 
2047  D->addAttr(::new (S.Context) NoReturnAttr(
2048  Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
2049 }
2050 
2051 static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2052  if (!S.getLangOpts().CFProtectionBranch)
2053  S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
2054  else
2055  handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
2056 }
2057 
2058 bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
2059  if (!checkAttributeNumArgs(*this, Attrs, 0)) {
2060  Attrs.setInvalid();
2061  return true;
2062  }
2063 
2064  return false;
2065 }
2066 
2067 bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
2068  // Check whether the attribute is valid on the current target.
2069  if (!AL.existsInTarget(Context.getTargetInfo())) {
2070  Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL;
2071  AL.setInvalid();
2072  return true;
2073  }
2074 
2075  return false;
2076 }
2077 
2078 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2079 
2080  // The checking path for 'noreturn' and 'analyzer_noreturn' are different
2081  // because 'analyzer_noreturn' does not impact the type.
2082  if (!isFunctionOrMethodOrBlock(D)) {
2083  ValueDecl *VD = dyn_cast<ValueDecl>(D);
2084  if (!VD || (!VD->getType()->isBlockPointerType() &&
2085  !VD->getType()->isFunctionPointerType())) {
2086  S.Diag(AL.getLoc(), AL.isCXX11Attribute()
2087  ? diag::err_attribute_wrong_decl_type
2088  : diag::warn_attribute_wrong_decl_type)
2090  return;
2091  }
2092  }
2093 
2094  D->addAttr(::new (S.Context)
2095  AnalyzerNoReturnAttr(AL.getRange(), S.Context,
2097 }
2098 
2099 // PS3 PPU-specific.
2100 static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2101  /*
2102  Returning a Vector Class in Registers
2103 
2104  According to the PPU ABI specifications, a class with a single member of
2105  vector type is returned in memory when used as the return value of a
2106  function.
2107  This results in inefficient code when implementing vector classes. To return
2108  the value in a single vector register, add the vecreturn attribute to the
2109  class definition. This attribute is also applicable to struct types.
2110 
2111  Example:
2112 
2113  struct Vector
2114  {
2115  __vector float xyzw;
2116  } __attribute__((vecreturn));
2117 
2118  Vector Add(Vector lhs, Vector rhs)
2119  {
2120  Vector result;
2121  result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2122  return result; // This will be returned in a register
2123  }
2124  */
2125  if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2126  S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
2127  return;
2128  }
2129 
2130  const auto *R = cast<RecordDecl>(D);
2131  int count = 0;
2132 
2133  if (!isa<CXXRecordDecl>(R)) {
2134  S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2135  return;
2136  }
2137 
2138  if (!cast<CXXRecordDecl>(R)->isPOD()) {
2139  S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2140  return;
2141  }
2142 
2143  for (const auto *I : R->fields()) {
2144  if ((count == 1) || !I->getType()->isVectorType()) {
2145  S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2146  return;
2147  }
2148  count++;
2149  }
2150 
2151  D->addAttr(::new (S.Context) VecReturnAttr(
2153 }
2154 
2155 static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
2156  const ParsedAttr &AL) {
2157  if (isa<ParmVarDecl>(D)) {
2158  // [[carries_dependency]] can only be applied to a parameter if it is a
2159  // parameter of a function declaration or lambda.
2161  S.Diag(AL.getLoc(),
2162  diag::err_carries_dependency_param_not_function_decl);
2163  return;
2164  }
2165  }
2166 
2167  D->addAttr(::new (S.Context) CarriesDependencyAttr(
2168  AL.getRange(), S.Context,
2170 }
2171 
2172 static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2173  bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();
2174 
2175  // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2176  // about using it as an extension.
2177  if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr)
2178  S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
2179 
2180  D->addAttr(::new (S.Context) UnusedAttr(
2182 }
2183 
2184 static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2185  uint32_t priority = ConstructorAttr::DefaultPriority;
2186  if (AL.getNumArgs() &&
2187  !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2188  return;
2189 
2190  D->addAttr(::new (S.Context)
2191  ConstructorAttr(AL.getRange(), S.Context, priority,
2193 }
2194 
2195 static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2196  uint32_t priority = DestructorAttr::DefaultPriority;
2197  if (AL.getNumArgs() &&
2198  !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2199  return;
2200 
2201  D->addAttr(::new (S.Context)
2202  DestructorAttr(AL.getRange(), S.Context, priority,
2204 }
2205 
2206 template <typename AttrTy>
2207 static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
2208  // Handle the case where the attribute has a text message.
2209  StringRef Str;
2210  if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
2211  return;
2212 
2213  D->addAttr(::new (S.Context) AttrTy(AL.getRange(), S.Context, Str,
2215 }
2216 
2217 static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
2218  const ParsedAttr &AL) {
2219  if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2220  S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2221  << AL << AL.getRange();
2222  return;
2223  }
2224 
2225  D->addAttr(::new (S.Context)
2226  ObjCExplicitProtocolImplAttr(AL.getRange(), S.Context,
2228 }
2229 
2230 static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
2231  IdentifierInfo *Platform,
2232  VersionTuple Introduced,
2233  VersionTuple Deprecated,
2234  VersionTuple Obsoleted) {
2235  StringRef PlatformName
2236  = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2237  if (PlatformName.empty())
2238  PlatformName = Platform->getName();
2239 
2240  // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2241  // of these steps are needed).
2242  if (!Introduced.empty() && !Deprecated.empty() &&
2243  !(Introduced <= Deprecated)) {
2244  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2245  << 1 << PlatformName << Deprecated.getAsString()
2246  << 0 << Introduced.getAsString();
2247  return true;
2248  }
2249 
2250  if (!Introduced.empty() && !Obsoleted.empty() &&
2251  !(Introduced <= Obsoleted)) {
2252  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2253  << 2 << PlatformName << Obsoleted.getAsString()
2254  << 0 << Introduced.getAsString();
2255  return true;
2256  }
2257 
2258  if (!Deprecated.empty() && !Obsoleted.empty() &&
2259  !(Deprecated <= Obsoleted)) {
2260  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2261  << 2 << PlatformName << Obsoleted.getAsString()
2262  << 1 << Deprecated.getAsString();
2263  return true;
2264  }
2265 
2266  return false;
2267 }
2268 
2269 /// Check whether the two versions match.
2270 ///
2271 /// If either version tuple is empty, then they are assumed to match. If
2272 /// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2273 static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2274  bool BeforeIsOkay) {
2275  if (X.empty() || Y.empty())
2276  return true;
2277 
2278  if (X == Y)
2279  return true;
2280 
2281  if (BeforeIsOkay && X < Y)
2282  return true;
2283 
2284  return false;
2285 }
2286 
2287 AvailabilityAttr *Sema::mergeAvailabilityAttr(
2288  NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, bool Implicit,
2289  VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted,
2290  bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement,
2291  AvailabilityMergeKind AMK, int Priority, unsigned AttrSpellingListIndex) {
2292  VersionTuple MergedIntroduced = Introduced;
2293  VersionTuple MergedDeprecated = Deprecated;
2294  VersionTuple MergedObsoleted = Obsoleted;
2295  bool FoundAny = false;
2296  bool OverrideOrImpl = false;
2297  switch (AMK) {
2298  case AMK_None:
2299  case AMK_Redeclaration:
2300  OverrideOrImpl = false;
2301  break;
2302 
2303  case AMK_Override:
2304  case AMK_ProtocolImplementation:
2305  OverrideOrImpl = true;
2306  break;
2307  }
2308 
2309  if (D->hasAttrs()) {
2310  AttrVec &Attrs = D->getAttrs();
2311  for (unsigned i = 0, e = Attrs.size(); i != e;) {
2312  const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2313  if (!OldAA) {
2314  ++i;
2315  continue;
2316  }
2317 
2318  IdentifierInfo *OldPlatform = OldAA->getPlatform();
2319  if (OldPlatform != Platform) {
2320  ++i;
2321  continue;
2322  }
2323 
2324  // If there is an existing availability attribute for this platform that
2325  // has a lower priority use the existing one and discard the new
2326  // attribute.
2327  if (OldAA->getPriority() < Priority)
2328  return nullptr;
2329 
2330  // If there is an existing attribute for this platform that has a higher
2331  // priority than the new attribute then erase the old one and continue
2332  // processing the attributes.
2333  if (OldAA->getPriority() > Priority) {
2334  Attrs.erase(Attrs.begin() + i);
2335  --e;
2336  continue;
2337  }
2338 
2339  FoundAny = true;
2340  VersionTuple OldIntroduced = OldAA->getIntroduced();
2341  VersionTuple OldDeprecated = OldAA->getDeprecated();
2342  VersionTuple OldObsoleted = OldAA->getObsoleted();
2343  bool OldIsUnavailable = OldAA->getUnavailable();
2344 
2345  if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2346  !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2347  !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2348  !(OldIsUnavailable == IsUnavailable ||
2349  (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2350  if (OverrideOrImpl) {
2351  int Which = -1;
2352  VersionTuple FirstVersion;
2353  VersionTuple SecondVersion;
2354  if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2355  Which = 0;
2356  FirstVersion = OldIntroduced;
2357  SecondVersion = Introduced;
2358  } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2359  Which = 1;
2360  FirstVersion = Deprecated;
2361  SecondVersion = OldDeprecated;
2362  } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2363  Which = 2;
2364  FirstVersion = Obsoleted;
2365  SecondVersion = OldObsoleted;
2366  }
2367 
2368  if (Which == -1) {
2369  Diag(OldAA->getLocation(),
2370  diag::warn_mismatched_availability_override_unavail)
2371  << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2372  << (AMK == AMK_Override);
2373  } else {
2374  Diag(OldAA->getLocation(),
2375  diag::warn_mismatched_availability_override)
2376  << Which
2377  << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2378  << FirstVersion.getAsString() << SecondVersion.getAsString()
2379  << (AMK == AMK_Override);
2380  }
2381  if (AMK == AMK_Override)
2382  Diag(Range.getBegin(), diag::note_overridden_method);
2383  else
2384  Diag(Range.getBegin(), diag::note_protocol_method);
2385  } else {
2386  Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2387  Diag(Range.getBegin(), diag::note_previous_attribute);
2388  }
2389 
2390  Attrs.erase(Attrs.begin() + i);
2391  --e;
2392  continue;
2393  }
2394 
2395  VersionTuple MergedIntroduced2 = MergedIntroduced;
2396  VersionTuple MergedDeprecated2 = MergedDeprecated;
2397  VersionTuple MergedObsoleted2 = MergedObsoleted;
2398 
2399  if (MergedIntroduced2.empty())
2400  MergedIntroduced2 = OldIntroduced;
2401  if (MergedDeprecated2.empty())
2402  MergedDeprecated2 = OldDeprecated;
2403  if (MergedObsoleted2.empty())
2404  MergedObsoleted2 = OldObsoleted;
2405 
2406  if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2407  MergedIntroduced2, MergedDeprecated2,
2408  MergedObsoleted2)) {
2409  Attrs.erase(Attrs.begin() + i);
2410  --e;
2411  continue;
2412  }
2413 
2414  MergedIntroduced = MergedIntroduced2;
2415  MergedDeprecated = MergedDeprecated2;
2416  MergedObsoleted = MergedObsoleted2;
2417  ++i;
2418  }
2419  }
2420 
2421  if (FoundAny &&
2422  MergedIntroduced == Introduced &&
2423  MergedDeprecated == Deprecated &&
2424  MergedObsoleted == Obsoleted)
2425  return nullptr;
2426 
2427  // Only create a new attribute if !OverrideOrImpl, but we want to do
2428  // the checking.
2429  if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2430  MergedDeprecated, MergedObsoleted) &&
2431  !OverrideOrImpl) {
2432  auto *Avail = ::new (Context)
2433  AvailabilityAttr(Range, Context, Platform, Introduced, Deprecated,
2434  Obsoleted, IsUnavailable, Message, IsStrict,
2435  Replacement, Priority, AttrSpellingListIndex);
2436  Avail->setImplicit(Implicit);
2437  return Avail;
2438  }
2439  return nullptr;
2440 }
2441 
2442 static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2443  if (!checkAttributeNumArgs(S, AL, 1))
2444  return;
2445  IdentifierLoc *Platform = AL.getArgAsIdent(0);
2446  unsigned Index = AL.getAttributeSpellingListIndex();
2447 
2448  IdentifierInfo *II = Platform->Ident;
2449  if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2450  S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2451  << Platform->Ident;
2452 
2453  auto *ND = dyn_cast<NamedDecl>(D);
2454  if (!ND) // We warned about this already, so just return.
2455  return;
2456 
2460  bool IsUnavailable = AL.getUnavailableLoc().isValid();
2461  bool IsStrict = AL.getStrictLoc().isValid();
2462  StringRef Str;
2463  if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getMessageExpr()))
2464  Str = SE->getString();
2465  StringRef Replacement;
2466  if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getReplacementExpr()))
2467  Replacement = SE->getString();
2468 
2469  if (II->isStr("swift")) {
2470  if (Introduced.isValid() || Obsoleted.isValid() ||
2471  (!IsUnavailable && !Deprecated.isValid())) {
2472  S.Diag(AL.getLoc(),
2473  diag::warn_availability_swift_unavailable_deprecated_only);
2474  return;
2475  }
2476  }
2477 
2478  int PriorityModifier = AL.isPragmaClangAttribute()
2481  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2482  ND, AL.getRange(), II, false /*Implicit*/, Introduced.Version,
2483  Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict,
2484  Replacement, Sema::AMK_None, PriorityModifier, Index);
2485  if (NewAttr)
2486  D->addAttr(NewAttr);
2487 
2488  // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2489  // matches before the start of the watchOS platform.
2490  if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2491  IdentifierInfo *NewII = nullptr;
2492  if (II->getName() == "ios")
2493  NewII = &S.Context.Idents.get("watchos");
2494  else if (II->getName() == "ios_app_extension")
2495  NewII = &S.Context.Idents.get("watchos_app_extension");
2496 
2497  if (NewII) {
2498  auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
2499  if (Version.empty())
2500  return Version;
2501  auto Major = Version.getMajor();
2502  auto NewMajor = Major >= 9 ? Major - 7 : 0;
2503  if (NewMajor >= 2) {
2504  if (Version.getMinor().hasValue()) {
2505  if (Version.getSubminor().hasValue())
2506  return VersionTuple(NewMajor, Version.getMinor().getValue(),
2507  Version.getSubminor().getValue());
2508  else
2509  return VersionTuple(NewMajor, Version.getMinor().getValue());
2510  }
2511  return VersionTuple(NewMajor);
2512  }
2513 
2514  return VersionTuple(2, 0);
2515  };
2516 
2517  auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2518  auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2519  auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2520 
2521  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2522  ND, AL.getRange(), NewII, true /*Implicit*/, NewIntroduced,
2523  NewDeprecated, NewObsoleted, IsUnavailable, Str, IsStrict,
2524  Replacement, Sema::AMK_None,
2525  PriorityModifier + Sema::AP_InferredFromOtherPlatform, Index);
2526  if (NewAttr)
2527  D->addAttr(NewAttr);
2528  }
2529  } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2530  // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2531  // matches before the start of the tvOS platform.
2532  IdentifierInfo *NewII = nullptr;
2533  if (II->getName() == "ios")
2534  NewII = &S.Context.Idents.get("tvos");
2535  else if (II->getName() == "ios_app_extension")
2536  NewII = &S.Context.Idents.get("tvos_app_extension");
2537 
2538  if (NewII) {
2539  AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2540  ND, AL.getRange(), NewII, true /*Implicit*/, Introduced.Version,
2541  Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict,
2542  Replacement, Sema::AMK_None,
2543  PriorityModifier + Sema::AP_InferredFromOtherPlatform, Index);
2544  if (NewAttr)
2545  D->addAttr(NewAttr);
2546  }
2547  }
2548 }
2549 
2550 static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
2551  const ParsedAttr &AL) {
2552  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
2553  return;
2554  assert(checkAttributeAtMostNumArgs(S, AL, 3) &&
2555  "Invalid number of arguments in an external_source_symbol attribute");
2556 
2557  StringRef Language;
2558  if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(0)))
2559  Language = SE->getString();
2560  StringRef DefinedIn;
2561  if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(1)))
2562  DefinedIn = SE->getString();
2563  bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr;
2564 
2565  D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2566  AL.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
2568 }
2569 
2570 template <class T>
2571 static T *mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range,
2572  typename T::VisibilityType value,
2573  unsigned attrSpellingListIndex) {
2574  T *existingAttr = D->getAttr<T>();
2575  if (existingAttr) {
2576  typename T::VisibilityType existingValue = existingAttr->getVisibility();
2577  if (existingValue == value)
2578  return nullptr;
2579  S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2580  S.Diag(range.getBegin(), diag::note_previous_attribute);
2581  D->dropAttr<T>();
2582  }
2583  return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
2584 }
2585 
2586 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2587  VisibilityAttr::VisibilityType Vis,
2588  unsigned AttrSpellingListIndex) {
2589  return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2590  AttrSpellingListIndex);
2591 }
2592 
2593 TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2594  TypeVisibilityAttr::VisibilityType Vis,
2595  unsigned AttrSpellingListIndex) {
2596  return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2597  AttrSpellingListIndex);
2598 }
2599 
2600 static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
2601  bool isTypeVisibility) {
2602  // Visibility attributes don't mean anything on a typedef.
2603  if (isa<TypedefNameDecl>(D)) {
2604  S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
2605  return;
2606  }
2607 
2608  // 'type_visibility' can only go on a type or namespace.
2609  if (isTypeVisibility &&
2610  !(isa<TagDecl>(D) ||
2611  isa<ObjCInterfaceDecl>(D) ||
2612  isa<NamespaceDecl>(D))) {
2613  S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2614  << AL << ExpectedTypeOrNamespace;
2615  return;
2616  }
2617 
2618  // Check that the argument is a string literal.
2619  StringRef TypeStr;
2620  SourceLocation LiteralLoc;
2621  if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
2622  return;
2623 
2624  VisibilityAttr::VisibilityType type;
2625  if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2626  S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL
2627  << TypeStr;
2628  return;
2629  }
2630 
2631  // Complain about attempts to use protected visibility on targets
2632  // (like Darwin) that don't support it.
2633  if (type == VisibilityAttr::Protected &&
2635  S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
2636  type = VisibilityAttr::Default;
2637  }
2638 
2639  unsigned Index = AL.getAttributeSpellingListIndex();
2640  Attr *newAttr;
2641  if (isTypeVisibility) {
2642  newAttr = S.mergeTypeVisibilityAttr(D, AL.getRange(),
2643  (TypeVisibilityAttr::VisibilityType) type,
2644  Index);
2645  } else {
2646  newAttr = S.mergeVisibilityAttr(D, AL.getRange(), type, Index);
2647  }
2648  if (newAttr)
2649  D->addAttr(newAttr);
2650 }
2651 
2652 static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2653  const auto *M = cast<ObjCMethodDecl>(D);
2654  if (!AL.isArgIdent(0)) {
2655  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2656  << AL << 1 << AANT_ArgumentIdentifier;
2657  return;
2658  }
2659 
2660  IdentifierLoc *IL = AL.getArgAsIdent(0);
2661  ObjCMethodFamilyAttr::FamilyKind F;
2662  if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2663  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;
2664  return;
2665  }
2666 
2667  if (F == ObjCMethodFamilyAttr::OMF_init &&
2668  !M->getReturnType()->isObjCObjectPointerType()) {
2669  S.Diag(M->getLocation(), diag::err_init_method_bad_return_type)
2670  << M->getReturnType();
2671  // Ignore the attribute.
2672  return;
2673  }
2674 
2675  D->addAttr(new (S.Context) ObjCMethodFamilyAttr(
2676  AL.getRange(), S.Context, F, AL.getAttributeSpellingListIndex()));
2677 }
2678 
2679 static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
2680  if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2681  QualType T = TD->getUnderlyingType();
2682  if (!T->isCARCBridgableType()) {
2683  S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2684  return;
2685  }
2686  }
2687  else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2688  QualType T = PD->getType();
2689  if (!T->isCARCBridgableType()) {
2690  S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2691  return;
2692  }
2693  }
2694  else {
2695  // It is okay to include this attribute on properties, e.g.:
2696  //
2697  // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2698  //
2699  // In this case it follows tradition and suppresses an error in the above
2700  // case.
2701  S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2702  }
2703  D->addAttr(::new (S.Context)
2704  ObjCNSObjectAttr(AL.getRange(), S.Context,
2706 }
2707 
2708 static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
2709  if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2710  QualType T = TD->getUnderlyingType();
2711  if (!T->isObjCObjectPointerType()) {
2712  S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2713  return;
2714  }
2715  } else {
2716  S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2717  return;
2718  }
2719  D->addAttr(::new (S.Context)
2720  ObjCIndependentClassAttr(AL.getRange(), S.Context,
2722 }
2723 
2724 static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2725  if (!AL.isArgIdent(0)) {
2726  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2727  << AL << 1 << AANT_ArgumentIdentifier;
2728  return;
2729  }
2730 
2731  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
2732  BlocksAttr::BlockType type;
2733  if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2734  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
2735  return;
2736  }
2737 
2738  D->addAttr(::new (S.Context)
2739  BlocksAttr(AL.getRange(), S.Context, type,
2741 }
2742 
2743 static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2744  unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2745  if (AL.getNumArgs() > 0) {
2746  Expr *E = AL.getArgAsExpr(0);
2747  llvm::APSInt Idx(32);
2748  if (E->isTypeDependent() || E->isValueDependent() ||
2749  !E->isIntegerConstantExpr(Idx, S.Context)) {
2750  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2751  << AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange();
2752  return;
2753  }
2754 
2755  if (Idx.isSigned() && Idx.isNegative()) {
2756  S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2757  << E->getSourceRange();
2758  return;
2759  }
2760 
2761  sentinel = Idx.getZExtValue();
2762  }
2763 
2764  unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2765  if (AL.getNumArgs() > 1) {
2766  Expr *E = AL.getArgAsExpr(1);
2767  llvm::APSInt Idx(32);
2768  if (E->isTypeDependent() || E->isValueDependent() ||
2769  !E->isIntegerConstantExpr(Idx, S.Context)) {
2770  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2771  << AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange();
2772  return;
2773  }
2774  nullPos = Idx.getZExtValue();
2775 
2776  if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2777  // FIXME: This error message could be improved, it would be nice
2778  // to say what the bounds actually are.
2779  S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2780  << E->getSourceRange();
2781  return;
2782  }
2783  }
2784 
2785  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2786  const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2787  if (isa<FunctionNoProtoType>(FT)) {
2788  S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2789  return;
2790  }
2791 
2792  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2793  S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2794  return;
2795  }
2796  } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
2797  if (!MD->isVariadic()) {
2798  S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2799  return;
2800  }
2801  } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
2802  if (!BD->isVariadic()) {
2803  S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2804  return;
2805  }
2806  } else if (const auto *V = dyn_cast<VarDecl>(D)) {
2807  QualType Ty = V->getType();
2808  if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2809  const FunctionType *FT = Ty->isFunctionPointerType()
2810  ? D->getFunctionType()
2811  : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2812  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2813  int m = Ty->isFunctionPointerType() ? 0 : 1;
2814  S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2815  return;
2816  }
2817  } else {
2818  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2820  return;
2821  }
2822  } else {
2823  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2825  return;
2826  }
2827  D->addAttr(::new (S.Context)
2828  SentinelAttr(AL.getRange(), S.Context, sentinel, nullPos,
2830 }
2831 
2832 static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
2833  if (D->getFunctionType() &&
2835  S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
2836  return;
2837  }
2838  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
2839  if (MD->getReturnType()->isVoidType()) {
2840  S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
2841  return;
2842  }
2843 
2844  // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2845  // about using it as an extension.
2846  if (!S.getLangOpts().CPlusPlus17 && AL.isCXX11Attribute() &&
2847  !AL.getScopeName())
2848  S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
2849 
2850  D->addAttr(::new (S.Context)
2851  WarnUnusedResultAttr(AL.getRange(), S.Context,
2853 }
2854 
2855 static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2856  // weak_import only applies to variable & function declarations.
2857  bool isDef = false;
2858  if (!D->canBeWeakImported(isDef)) {
2859  if (isDef)
2860  S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
2861  << "weak_import";
2862  else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2863  (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2864  (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2865  // Nothing to warn about here.
2866  } else
2867  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2868  << AL << ExpectedVariableOrFunction;
2869 
2870  return;
2871  }
2872 
2873  D->addAttr(::new (S.Context)
2874  WeakImportAttr(AL.getRange(), S.Context,
2876 }
2877 
2878 // Handles reqd_work_group_size and work_group_size_hint.
2879 template <typename WorkGroupAttr>
2880 static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2881  uint32_t WGSize[3];
2882  for (unsigned i = 0; i < 3; ++i) {
2883  const Expr *E = AL.getArgAsExpr(i);
2884  if (!checkUInt32Argument(S, AL, E, WGSize[i], i,
2885  /*StrictlyUnsigned=*/true))
2886  return;
2887  if (WGSize[i] == 0) {
2888  S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2889  << AL << E->getSourceRange();
2890  return;
2891  }
2892  }
2893 
2894  WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2895  if (Existing && !(Existing->getXDim() == WGSize[0] &&
2896  Existing->getYDim() == WGSize[1] &&
2897  Existing->getZDim() == WGSize[2]))
2898  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2899 
2900  D->addAttr(::new (S.Context) WorkGroupAttr(AL.getRange(), S.Context,
2901  WGSize[0], WGSize[1], WGSize[2],
2903 }
2904 
2905 // Handles intel_reqd_sub_group_size.
2906 static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2907  uint32_t SGSize;
2908  const Expr *E = AL.getArgAsExpr(0);
2909  if (!checkUInt32Argument(S, AL, E, SGSize))
2910  return;
2911  if (SGSize == 0) {
2912  S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2913  << AL << E->getSourceRange();
2914  return;
2915  }
2916 
2917  OpenCLIntelReqdSubGroupSizeAttr *Existing =
2918  D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
2919  if (Existing && Existing->getSubGroupSize() != SGSize)
2920  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2921 
2922  D->addAttr(::new (S.Context) OpenCLIntelReqdSubGroupSizeAttr(
2923  AL.getRange(), S.Context, SGSize,
2925 }
2926 
2927 static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
2928  if (!AL.hasParsedType()) {
2929  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
2930  return;
2931  }
2932 
2933  TypeSourceInfo *ParmTSI = nullptr;
2934  QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI);
2935  assert(ParmTSI && "no type source info for attribute argument");
2936 
2937  if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2938  (ParmType->isBooleanType() ||
2939  !ParmType->isIntegralType(S.getASTContext()))) {
2940  S.Diag(AL.getLoc(), diag::err_attribute_argument_vec_type_hint)
2941  << ParmType;
2942  return;
2943  }
2944 
2945  if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2946  if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2947  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2948  return;
2949  }
2950  }
2951 
2952  D->addAttr(::new (S.Context) VecTypeHintAttr(AL.getLoc(), S.Context,
2953  ParmTSI,
2955 }
2956 
2957 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2958  StringRef Name,
2959  unsigned AttrSpellingListIndex) {
2960  // Explicit or partial specializations do not inherit
2961  // the section attribute from the primary template.
2962  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2963  if (AttrSpellingListIndex == SectionAttr::Declspec_allocate &&
2965  return nullptr;
2966  }
2967  if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2968  if (ExistingAttr->getName() == Name)
2969  return nullptr;
2970  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2971  << 1 /*section*/;
2972  Diag(Range.getBegin(), diag::note_previous_attribute);
2973  return nullptr;
2974  }
2975  return ::new (Context) SectionAttr(Range, Context, Name,
2976  AttrSpellingListIndex);
2977 }
2978 
2979 bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2980  std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2981  if (!Error.empty()) {
2982  Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
2983  << 1 /*'section'*/;
2984  return false;
2985  }
2986  return true;
2987 }
2988 
2989 static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2990  // Make sure that there is a string literal as the sections's single
2991  // argument.
2992  StringRef Str;
2993  SourceLocation LiteralLoc;
2994  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
2995  return;
2996 
2997  if (!S.checkSectionName(LiteralLoc, Str))
2998  return;
2999 
3000  // If the target wants to validate the section specifier, make it happen.
3001  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
3002  if (!Error.empty()) {
3003  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
3004  << Error;
3005  return;
3006  }
3007 
3008  unsigned Index = AL.getAttributeSpellingListIndex();
3009  SectionAttr *NewAttr = S.mergeSectionAttr(D, AL.getRange(), Str, Index);
3010  if (NewAttr)
3011  D->addAttr(NewAttr);
3012 }
3013 
3014 static bool checkCodeSegName(Sema&S, SourceLocation LiteralLoc, StringRef CodeSegName) {
3015  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
3016  if (!Error.empty()) {
3017  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
3018  << 0 /*'code-seg'*/;
3019  return false;
3020  }
3021  return true;
3022 }
3023 
3024 CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, SourceRange Range,
3025  StringRef Name,
3026  unsigned AttrSpellingListIndex) {
3027  // Explicit or partial specializations do not inherit
3028  // the code_seg attribute from the primary template.
3029  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3031  return nullptr;
3032  }
3033  if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3034  if (ExistingAttr->getName() == Name)
3035  return nullptr;
3036  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
3037  << 0 /*codeseg*/;
3038  Diag(Range.getBegin(), diag::note_previous_attribute);
3039  return nullptr;
3040  }
3041  return ::new (Context) CodeSegAttr(Range, Context, Name,
3042  AttrSpellingListIndex);
3043 }
3044 
3045 static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3046  StringRef Str;
3047  SourceLocation LiteralLoc;
3048  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
3049  return;
3050  if (!checkCodeSegName(S, LiteralLoc, Str))
3051  return;
3052  if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3053  if (!ExistingAttr->isImplicit()) {
3054  S.Diag(AL.getLoc(),
3055  ExistingAttr->getName() == Str
3056  ? diag::warn_duplicate_codeseg_attribute
3057  : diag::err_conflicting_codeseg_attribute);
3058  return;
3059  }
3060  D->dropAttr<CodeSegAttr>();
3061  }
3062  if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL.getRange(), Str,
3064  D->addAttr(CSA);
3065 }
3066 
3067 // Check for things we'd like to warn about. Multiversioning issues are
3068 // handled later in the process, once we know how many exist.
3069 bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3070  enum FirstParam { Unsupported, Duplicate };
3071  enum SecondParam { None, Architecture };
3072  for (auto Str : {"tune=", "fpmath="})
3073  if (AttrStr.find(Str) != StringRef::npos)
3074  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3075  << Unsupported << None << Str;
3076 
3077  TargetAttr::ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);
3078 
3079  if (!ParsedAttrs.Architecture.empty() &&
3080  !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
3081  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3082  << Unsupported << Architecture << ParsedAttrs.Architecture;
3083 
3084  if (ParsedAttrs.DuplicateArchitecture)
3085  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3086  << Duplicate << None << "arch=";
3087 
3088  for (const auto &Feature : ParsedAttrs.Features) {
3089  auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
3090  if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
3091  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3092  << Unsupported << None << CurFeature;
3093  }
3094 
3095  return false;
3096 }
3097 
3098 static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3099  StringRef Str;
3100  SourceLocation LiteralLoc;
3101  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
3102  S.checkTargetAttr(LiteralLoc, Str))
3103  return;
3104 
3105  unsigned Index = AL.getAttributeSpellingListIndex();
3106  TargetAttr *NewAttr =
3107  ::new (S.Context) TargetAttr(AL.getRange(), S.Context, Str, Index);
3108  D->addAttr(NewAttr);
3109 }
3110 
3111 static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3112  Expr *E = AL.getArgAsExpr(0);
3113  uint32_t VecWidth;
3114  if (!checkUInt32Argument(S, AL, E, VecWidth)) {
3115  AL.setInvalid();
3116  return;
3117  }
3118 
3119  MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>();
3120  if (Existing && Existing->getVectorWidth() != VecWidth) {
3121  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3122  return;
3123  }
3124 
3125  D->addAttr(::new (S.Context)
3126  MinVectorWidthAttr(AL.getRange(), S.Context, VecWidth,
3128 }
3129 
3130 static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3131  Expr *E = AL.getArgAsExpr(0);
3132  SourceLocation Loc = E->getExprLoc();
3133  FunctionDecl *FD = nullptr;
3135 
3136  // gcc only allows for simple identifiers. Since we support more than gcc, we
3137  // will warn the user.
3138  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
3139  if (DRE->hasQualifier())
3140  S.Diag(Loc, diag::warn_cleanup_ext);
3141  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3142  NI = DRE->getNameInfo();
3143  if (!FD) {
3144  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3145  << NI.getName();
3146  return;
3147  }
3148  } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3149  if (ULE->hasExplicitTemplateArgs())
3150  S.Diag(Loc, diag::warn_cleanup_ext);
3152  NI = ULE->getNameInfo();
3153  if (!FD) {
3154  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3155  << NI.getName();
3156  if (ULE->getType() == S.Context.OverloadTy)
3158  return;
3159  }
3160  } else {
3161  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3162  return;
3163  }
3164 
3165  if (FD->getNumParams() != 1) {
3166  S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3167  << NI.getName();
3168  return;
3169  }
3170 
3171  // We're currently more strict than GCC about what function types we accept.
3172  // If this ever proves to be a problem it should be easy to fix.
3173  QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
3174  QualType ParamTy = FD->getParamDecl(0)->getType();
3176  ParamTy, Ty) != Sema::Compatible) {
3177  S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3178  << NI.getName() << ParamTy << Ty;
3179  return;
3180  }
3181 
3182  D->addAttr(::new (S.Context)
3183  CleanupAttr(AL.getRange(), S.Context, FD,
3185 }
3186 
3187 static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
3188  const ParsedAttr &AL) {
3189  if (!AL.isArgIdent(0)) {
3190  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3191  << AL << 0 << AANT_ArgumentIdentifier;
3192  return;
3193  }
3194 
3195  EnumExtensibilityAttr::Kind ExtensibilityKind;
3196  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3197  if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3198  ExtensibilityKind)) {
3199  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
3200  return;
3201  }
3202 
3203  D->addAttr(::new (S.Context) EnumExtensibilityAttr(
3204  AL.getRange(), S.Context, ExtensibilityKind,
3206 }
3207 
3208 /// Handle __attribute__((format_arg((idx)))) attribute based on
3209 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3210 static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3211  Expr *IdxExpr = AL.getArgAsExpr(0);
3212  ParamIdx Idx;
3213  if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
3214  return;
3215 
3216  // Make sure the format string is really a string.
3218 
3219  bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3220  if (NotNSStringTy &&
3221  !isCFStringType(Ty, S.Context) &&
3222  (!Ty->isPointerType() ||
3223  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3224  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3225  << "a string type" << IdxExpr->getSourceRange()
3227  return;
3228  }
3230  if (!isNSStringType(Ty, S.Context) &&
3231  !isCFStringType(Ty, S.Context) &&
3232  (!Ty->isPointerType() ||
3233  !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3234  S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
3235  << (NotNSStringTy ? "string type" : "NSString")
3236  << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3237  return;
3238  }
3239 
3240  D->addAttr(::new (S.Context) FormatArgAttr(
3241  AL.getRange(), S.Context, Idx, AL.getAttributeSpellingListIndex()));
3242 }
3243 
3244 enum FormatAttrKind {
3245  CFStringFormat,
3246  NSStringFormat,
3247  StrftimeFormat,
3248  SupportedFormat,
3249  IgnoredFormat,
3250  InvalidFormat
3251 };
3252 
3253 /// getFormatAttrKind - Map from format attribute names to supported format
3254 /// types.
3255 static FormatAttrKind getFormatAttrKind(StringRef Format) {
3256  return llvm::StringSwitch<FormatAttrKind>(Format)
3257  // Check for formats that get handled specially.
3258  .Case("NSString", NSStringFormat)
3259  .Case("CFString", CFStringFormat)
3260  .Case("strftime", StrftimeFormat)
3261 
3262  // Otherwise, check for supported formats.
3263  .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3264  .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3265  .Case("kprintf", SupportedFormat) // OpenBSD.
3266  .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3267  .Case("os_trace", SupportedFormat)
3268  .Case("os_log", SupportedFormat)
3269 
3270  .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3271  .Default(InvalidFormat);
3272 }
3273 
3274 /// Handle __attribute__((init_priority(priority))) attributes based on
3275 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3276 static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3277  if (!S.getLangOpts().CPlusPlus) {
3278  S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
3279  return;
3280  }
3281 
3282  if (S.getCurFunctionOrMethodDecl()) {
3283  S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3284  AL.setInvalid();
3285  return;
3286  }
3287  QualType T = cast<VarDecl>(D)->getType();
3288  if (S.Context.getAsArrayType(T))
3289  T = S.Context.getBaseElementType(T);
3290  if (!T->getAs<RecordType>()) {
3291  S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3292  AL.setInvalid();
3293  return;
3294  }
3295 
3296  Expr *E = AL.getArgAsExpr(0);
3297  uint32_t prioritynum;
3298  if (!checkUInt32Argument(S, AL, E, prioritynum)) {
3299  AL.setInvalid();
3300  return;
3301  }
3302 
3303  if (prioritynum < 101 || prioritynum > 65535) {
3304  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
3305  << E->getSourceRange() << AL << 101 << 65535;
3306  AL.setInvalid();
3307  return;
3308  }
3309  D->addAttr(::new (S.Context)
3310  InitPriorityAttr(AL.getRange(), S.Context, prioritynum,
3312 }
3313 
3314 FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range,
3315  IdentifierInfo *Format, int FormatIdx,
3316  int FirstArg,
3317  unsigned AttrSpellingListIndex) {
3318  // Check whether we already have an equivalent format attribute.
3319  for (auto *F : D->specific_attrs<FormatAttr>()) {
3320  if (F->getType() == Format &&
3321  F->getFormatIdx() == FormatIdx &&
3322  F->getFirstArg() == FirstArg) {
3323  // If we don't have a valid location for this attribute, adopt the
3324  // location.
3325  if (F->getLocation().isInvalid())
3326  F->setRange(Range);
3327  return nullptr;
3328  }
3329  }
3330 
3331  return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
3332  FirstArg, AttrSpellingListIndex);
3333 }
3334 
3335 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3336 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3337 static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3338  if (!AL.isArgIdent(0)) {
3339  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3340  << AL << 1 << AANT_ArgumentIdentifier;
3341  return;
3342  }
3343 
3344  // In C++ the implicit 'this' function parameter also counts, and they are
3345  // counted from one.
3346  bool HasImplicitThisParam = isInstanceMethod(D);
3347  unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3348 
3349  IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3350  StringRef Format = II->getName();
3351 
3352  if (normalizeName(Format)) {
3353  // If we've modified the string name, we need a new identifier for it.
3354  II = &S.Context.Idents.get(Format);
3355  }
3356 
3357  // Check for supported formats.
3358  FormatAttrKind Kind = getFormatAttrKind(Format);
3359 
3360  if (Kind == IgnoredFormat)
3361  return;
3362 
3363  if (Kind == InvalidFormat) {
3364  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
3365  << AL << II->getName();
3366  return;
3367  }
3368 
3369  // checks for the 2nd argument
3370  Expr *IdxExpr = AL.getArgAsExpr(1);
3371  uint32_t Idx;
3372  if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
3373  return;
3374 
3375  if (Idx < 1 || Idx > NumArgs) {
3376  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3377  << AL << 2 << IdxExpr->getSourceRange();
3378  return;
3379  }
3380 
3381  // FIXME: Do we need to bounds check?
3382  unsigned ArgIdx = Idx - 1;
3383 
3384  if (HasImplicitThisParam) {
3385  if (ArgIdx == 0) {
3386  S.Diag(AL.getLoc(),
3387  diag::err_format_attribute_implicit_this_format_string)
3388  << IdxExpr->getSourceRange();
3389  return;
3390  }
3391  ArgIdx--;
3392  }
3393 
3394  // make sure the format string is really a string
3395  QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
3396 
3397  if (Kind == CFStringFormat) {
3398  if (!isCFStringType(Ty, S.Context)) {
3399  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3400  << "a CFString" << IdxExpr->getSourceRange()
3401  << getFunctionOrMethodParamRange(D, ArgIdx);
3402  return;
3403  }
3404  } else if (Kind == NSStringFormat) {
3405  // FIXME: do we need to check if the type is NSString*? What are the
3406  // semantics?
3407  if (!isNSStringType(Ty, S.Context)) {
3408  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3409  << "an NSString" << IdxExpr->getSourceRange()
3410  << getFunctionOrMethodParamRange(D, ArgIdx);
3411  return;
3412  }
3413  } else if (!Ty->isPointerType() ||
3414  !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
3415  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3416  << "a string type" << IdxExpr->getSourceRange()
3417  << getFunctionOrMethodParamRange(D, ArgIdx);
3418  return;
3419  }
3420 
3421  // check the 3rd argument
3422  Expr *FirstArgExpr = AL.getArgAsExpr(2);
3423  uint32_t FirstArg;
3424  if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
3425  return;
3426 
3427  // check if the function is variadic if the 3rd argument non-zero
3428  if (FirstArg != 0) {
3429  if (isFunctionOrMethodVariadic(D)) {
3430  ++NumArgs; // +1 for ...
3431  } else {
3432  S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
3433  return;
3434  }
3435  }
3436 
3437  // strftime requires FirstArg to be 0 because it doesn't read from any
3438  // variable the input is just the current time + the format string.
3439  if (Kind == StrftimeFormat) {
3440  if (FirstArg != 0) {
3441  S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter)
3442  << FirstArgExpr->getSourceRange();
3443  return;
3444  }
3445  // if 0 it disables parameter checking (to use with e.g. va_list)
3446  } else if (FirstArg != 0 && FirstArg != NumArgs) {
3447  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3448  << AL << 3 << FirstArgExpr->getSourceRange();
3449  return;
3450  }
3451 
3452  FormatAttr *NewAttr = S.mergeFormatAttr(D, AL.getRange(), II,
3453  Idx, FirstArg,
3455  if (NewAttr)
3456  D->addAttr(NewAttr);
3457 }
3458 
3459 /// Handle __attribute__((callback(CalleeIdx, PayloadIdx0, ...))) attributes.
3460 static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3461  // The index that identifies the callback callee is mandatory.
3462  if (AL.getNumArgs() == 0) {
3463  S.Diag(AL.getLoc(), diag::err_callback_attribute_no_callee)
3464  << AL.getRange();
3465  return;
3466  }
3467 
3468  bool HasImplicitThisParam = isInstanceMethod(D);
3469  int32_t NumArgs = getFunctionOrMethodNumParams(D);
3470 
3471  FunctionDecl *FD = D->getAsFunction();
3472  assert(FD && "Expected a function declaration!");
3473 
3474  llvm::StringMap<int> NameIdxMapping;
3475  NameIdxMapping["__"] = -1;
3476 
3477  NameIdxMapping["this"] = 0;
3478 
3479  int Idx = 1;
3480  for (const ParmVarDecl *PVD : FD->parameters())
3481  NameIdxMapping[PVD->getName()] = Idx++;
3482 
3483  auto UnknownName = NameIdxMapping.end();
3484 
3485  SmallVector<int, 8> EncodingIndices;
3486  for (unsigned I = 0, E = AL.getNumArgs(); I < E; ++I) {
3487  SourceRange SR;
3488  int32_t ArgIdx;
3489 
3490  if (AL.isArgIdent(I)) {
3491  IdentifierLoc *IdLoc = AL.getArgAsIdent(I);
3492  auto It = NameIdxMapping.find(IdLoc->Ident->getName());
3493  if (It == UnknownName) {
3494  S.Diag(AL.getLoc(), diag::err_callback_attribute_argument_unknown)
3495  << IdLoc->Ident << IdLoc->Loc;
3496  return;
3497  }
3498 
3499  SR = SourceRange(IdLoc->Loc);
3500  ArgIdx = It->second;
3501  } else if (AL.isArgExpr(I)) {
3502  Expr *IdxExpr = AL.getArgAsExpr(I);
3503 
3504  // If the expression is not parseable as an int32_t we have a problem.
3505  if (!checkUInt32Argument(S, AL, IdxExpr, (uint32_t &)ArgIdx, I + 1,
3506  false)) {
3507  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3508  << AL << (I + 1) << IdxExpr->getSourceRange();
3509  return;
3510  }
3511 
3512  // Check oob, excluding the special values, 0 and -1.
3513  if (ArgIdx < -1 || ArgIdx > NumArgs) {
3514  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3515  << AL << (I + 1) << IdxExpr->getSourceRange();
3516  return;
3517  }
3518 
3519  SR = IdxExpr->getSourceRange();
3520  } else {
3521  llvm_unreachable("Unexpected ParsedAttr argument type!");
3522  }
3523 
3524  if (ArgIdx == 0 && !HasImplicitThisParam) {
3525  S.Diag(AL.getLoc(), diag::err_callback_implicit_this_not_available)
3526  << (I + 1) << SR;
3527  return;
3528  }
3529 
3530  // Adjust for the case we do not have an implicit "this" parameter. In this
3531  // case we decrease all positive values by 1 to get LLVM argument indices.
3532  if (!HasImplicitThisParam && ArgIdx > 0)
3533  ArgIdx -= 1;
3534 
3535  EncodingIndices.push_back(ArgIdx);
3536  }
3537 
3538  int CalleeIdx = EncodingIndices.front();
3539  // Check if the callee index is proper, thus not "this" and not "unknown".
3540  // This means the "CalleeIdx" has to be non-negative if "HasImplicitThisParam"
3541  // is false and positive if "HasImplicitThisParam" is true.
3542  if (CalleeIdx < (int)HasImplicitThisParam) {
3543  S.Diag(AL.getLoc(), diag::err_callback_attribute_invalid_callee)
3544  << AL.getRange();
3545  return;
3546  }
3547 
3548  // Get the callee type, note the index adjustment as the AST doesn't contain
3549  // the this type (which the callee cannot reference anyway!).
3550  const Type *CalleeType =
3551  getFunctionOrMethodParamType(D, CalleeIdx - HasImplicitThisParam)
3552  .getTypePtr();
3553  if (!CalleeType || !CalleeType->isFunctionPointerType()) {
3554  S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
3555  << AL.getRange();
3556  return;
3557  }
3558 
3559  const Type *CalleeFnType =
3561 
3562  // TODO: Check the type of the callee arguments.
3563 
3564  const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);
3565  if (!CalleeFnProtoType) {
3566  S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
3567  << AL.getRange();
3568  return;
3569  }
3570 
3571  if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {
3572  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
3573  << AL << (unsigned)(EncodingIndices.size() - 1);
3574  return;
3575  }
3576 
3577  if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {
3578  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
3579  << AL << (unsigned)(EncodingIndices.size() - 1);
3580  return;
3581  }
3582 
3583  if (CalleeFnProtoType->isVariadic()) {
3584  S.Diag(AL.getLoc(), diag::err_callback_callee_is_variadic) << AL.getRange();
3585  return;
3586  }
3587 
3588  // Do not allow multiple callback attributes.
3589  if (D->hasAttr<CallbackAttr>()) {
3590  S.Diag(AL.getLoc(), diag::err_callback_attribute_multiple) << AL.getRange();
3591  return;
3592  }
3593 
3594  D->addAttr(::new (S.Context) CallbackAttr(
3595  AL.getRange(), S.Context, EncodingIndices.data(), EncodingIndices.size(),
3597 }
3598 
3599 static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3600  // Try to find the underlying union declaration.
3601  RecordDecl *RD = nullptr;
3602  const auto *TD = dyn_cast<TypedefNameDecl>(D);
3603  if (TD && TD->getUnderlyingType()->isUnionType())
3604  RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3605  else
3606  RD = dyn_cast<RecordDecl>(D);
3607 
3608  if (!RD || !RD->isUnion()) {
3609  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL
3610  << ExpectedUnion;
3611  return;
3612  }
3613 
3614  if (!RD->isCompleteDefinition()) {
3615  if (!RD->isBeingDefined())
3616  S.Diag(AL.getLoc(),
3617  diag::warn_transparent_union_attribute_not_definition);
3618  return;
3619  }
3620 
3622  FieldEnd = RD->field_end();
3623  if (Field == FieldEnd) {
3624  S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3625  return;
3626  }
3627 
3628  FieldDecl *FirstField = *Field;
3629  QualType FirstType = FirstField->getType();
3630  if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3631  S.Diag(FirstField->getLocation(),
3632  diag::warn_transparent_union_attribute_floating)
3633  << FirstType->isVectorType() << FirstType;
3634  return;
3635  }
3636 
3637  if (FirstType->isIncompleteType())
3638  return;
3639  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3640  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3641  for (; Field != FieldEnd; ++Field) {
3642  QualType FieldType = Field->getType();
3643  if (FieldType->isIncompleteType())
3644  return;
3645  // FIXME: this isn't fully correct; we also need to test whether the
3646  // members of the union would all have the same calling convention as the
3647  // first member of the union. Checking just the size and alignment isn't
3648  // sufficient (consider structs passed on the stack instead of in registers
3649  // as an example).
3650  if (S.Context.getTypeSize(FieldType) != FirstSize ||
3651  S.Context.getTypeAlign(FieldType) > FirstAlign) {
3652  // Warn if we drop the attribute.
3653  bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3654  unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3655  : S.Context.getTypeAlign(FieldType);
3656  S.Diag(Field->getLocation(),
3657  diag::warn_transparent_union_attribute_field_size_align)
3658  << isSize << Field->getDeclName() << FieldBits;
3659  unsigned FirstBits = isSize? FirstSize : FirstAlign;
3660  S.Diag(FirstField->getLocation(),
3661  diag::note_transparent_union_first_field_size_align)
3662  << isSize << FirstBits;
3663  return;
3664  }
3665  }
3666 
3667  RD->addAttr(::new (S.Context)
3668  TransparentUnionAttr(AL.getRange(), S.Context,
3670 }
3671 
3672 static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3673  // Make sure that there is a string literal as the annotation's single
3674  // argument.
3675  StringRef Str;
3676  if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
3677  return;
3678 
3679  // Don't duplicate annotations that are already set.
3680  for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
3681  if (I->getAnnotation() == Str)
3682  return;
3683  }
3684 
3685  D->addAttr(::new (S.Context)
3686  AnnotateAttr(AL.getRange(), S.Context, Str,
3688 }
3689 
3690 static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3691  S.AddAlignValueAttr(AL.getRange(), D, AL.getArgAsExpr(0),
3693 }
3694 
3695 void Sema::AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
3696  unsigned SpellingListIndex) {
3697  AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
3698  SourceLocation AttrLoc = AttrRange.getBegin();
3699 
3700  QualType T;
3701  if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
3702  T = TD->getUnderlyingType();
3703  else if (const auto *VD = dyn_cast<ValueDecl>(D))
3704  T = VD->getType();
3705  else
3706  llvm_unreachable("Unknown decl type for align_value");
3707 
3708  if (!T->isDependentType() && !T->isAnyPointerType() &&
3709  !T->isReferenceType() && !T->isMemberPointerType()) {
3710  Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3711  << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
3712  return;
3713  }
3714 
3715  if (!E->isValueDependent()) {
3716  llvm::APSInt Alignment;
3717  ExprResult ICE
3718  = VerifyIntegerConstantExpression(E, &Alignment,
3719  diag::err_align_value_attribute_argument_not_int,
3720  /*AllowFold*/ false);
3721  if (ICE.isInvalid())
3722  return;
3723 
3724  if (!Alignment.isPowerOf2()) {
3725  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3726  << E->getSourceRange();
3727  return;
3728  }
3729 
3730  D->addAttr(::new (Context)
3731  AlignValueAttr(AttrRange, Context, ICE.get(),
3732  SpellingListIndex));
3733  return;
3734  }
3735 
3736  // Save dependent expressions in the AST to be instantiated.
3737  D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
3738 }
3739 
3740 static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3741  // check the attribute arguments.
3742  if (AL.getNumArgs() > 1) {
3743  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
3744  return;
3745  }
3746 
3747  if (AL.getNumArgs() == 0) {
3748  D->addAttr(::new (S.Context) AlignedAttr(AL.getRange(), S.Context,
3749  true, nullptr, AL.getAttributeSpellingListIndex()));
3750  return;
3751  }
3752 
3753  Expr *E = AL.getArgAsExpr(0);
3755  S.Diag(AL.getEllipsisLoc(),
3756  diag::err_pack_expansion_without_parameter_packs);
3757  return;
3758  }
3759 
3761  return;
3762 
3764  AL.isPackExpansion());
3765 }
3766 
3767 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3768  unsigned SpellingListIndex, bool IsPackExpansion) {
3769  AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3770  SourceLocation AttrLoc = AttrRange.getBegin();
3771 
3772  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3773  if (TmpAttr.isAlignas()) {
3774  // C++11 [dcl.align]p1:
3775  // An alignment-specifier may be applied to a variable or to a class
3776  // data member, but it shall not be applied to a bit-field, a function
3777  // parameter, the formal parameter of a catch clause, or a variable
3778  // declared with the register storage class specifier. An
3779  // alignment-specifier may also be applied to the declaration of a class
3780  // or enumeration type.
3781  // C11 6.7.5/2:
3782  // An alignment attribute shall not be specified in a declaration of
3783  // a typedef, or a bit-field, or a function, or a parameter, or an
3784  // object declared with the register storage-class specifier.
3785  int DiagKind = -1;
3786  if (isa<ParmVarDecl>(D)) {
3787  DiagKind = 0;
3788  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
3789  if (VD->getStorageClass() == SC_Register)
3790  DiagKind = 1;
3791  if (VD->isExceptionVariable())
3792  DiagKind = 2;
3793  } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
3794  if (FD->isBitField())
3795  DiagKind = 3;
3796  } else if (!isa<TagDecl>(D)) {
3797  Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
3798  << (TmpAttr.isC11() ? ExpectedVariableOrField
3800  return;
3801  }
3802  if (DiagKind != -1) {
3803  Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3804  << &TmpAttr << DiagKind;
3805  return;
3806  }
3807  }
3808 
3809  if (E->isValueDependent()) {
3810  // We can't support a dependent alignment on a non-dependent type,
3811  // because we have no way to model that a type is "alignment-dependent"
3812  // but not dependent in any other way.
3813  if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
3814  if (!TND->getUnderlyingType()->isDependentType()) {
3815  Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
3816  << E->getSourceRange();
3817  return;
3818  }
3819  }
3820 
3821  // Save dependent expressions in the AST to be instantiated.
3822  AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
3823  AA->setPackExpansion(IsPackExpansion);
3824  D->addAttr(AA);
3825  return;
3826  }
3827 
3828  // FIXME: Cache the number on the AL object?
3829  llvm::APSInt Alignment;
3830  ExprResult ICE
3831  = VerifyIntegerConstantExpression(E, &Alignment,
3832  diag::err_aligned_attribute_argument_not_int,
3833  /*AllowFold*/ false);
3834  if (ICE.isInvalid())
3835  return;
3836 
3837  uint64_t AlignVal = Alignment.getZExtValue();
3838 
3839  // C++11 [dcl.align]p2:
3840  // -- if the constant expression evaluates to zero, the alignment
3841  // specifier shall have no effect
3842  // C11 6.7.5p6:
3843  // An alignment specification of zero has no effect.
3844  if (!(TmpAttr.isAlignas() && !Alignment)) {
3845  if (!llvm::isPowerOf2_64(AlignVal)) {
3846  Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3847  << E->getSourceRange();
3848  return;
3849  }
3850  }
3851 
3852  // Alignment calculations can wrap around if it's greater than 2**28.
3853  unsigned MaxValidAlignment =
3854  Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192
3855  : 268435456;
3856  if (AlignVal > MaxValidAlignment) {
3857  Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3858  << E->getSourceRange();
3859  return;
3860  }
3861 
3862  if (Context.getTargetInfo().isTLSSupported()) {
3863  unsigned MaxTLSAlign =
3864  Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign())
3865  .getQuantity();
3866  const auto *VD = dyn_cast<VarDecl>(D);
3867  if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
3868  VD->getTLSKind() != VarDecl::TLS_None) {
3869  Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3870  << (unsigned)AlignVal << VD << MaxTLSAlign;
3871  return;
3872  }
3873  }
3874 
3875  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3876  ICE.get(), SpellingListIndex);
3877  AA->setPackExpansion(IsPackExpansion);
3878  D->addAttr(AA);
3879 }
3880 
3881 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3882  unsigned SpellingListIndex, bool IsPackExpansion) {
3883  // FIXME: Cache the number on the AL object if non-dependent?
3884  // FIXME: Perform checking of type validity
3885  AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3886  SpellingListIndex);
3887  AA->setPackExpansion(IsPackExpansion);
3888  D->addAttr(AA);
3889 }
3890 
3892  assert(D->hasAttrs() && "no attributes on decl");
3893 
3894  QualType UnderlyingTy, DiagTy;
3895  if (const auto *VD = dyn_cast<ValueDecl>(D)) {
3896  UnderlyingTy = DiagTy = VD->getType();
3897  } else {
3898  UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3899  if (const auto *ED = dyn_cast<EnumDecl>(D))
3900  UnderlyingTy = ED->getIntegerType();
3901  }
3902  if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3903  return;
3904 
3905  // C++11 [dcl.align]p5, C11 6.7.5/4:
3906  // The combined effect of all alignment attributes in a declaration shall
3907  // not specify an alignment that is less strict than the alignment that
3908  // would otherwise be required for the entity being declared.
3909  AlignedAttr *AlignasAttr = nullptr;
3910  unsigned Align = 0;
3911  for (auto *I : D->specific_attrs<AlignedAttr>()) {
3912  if (I->isAlignmentDependent())
3913  return;
3914  if (I->isAlignas())
3915  AlignasAttr = I;
3916  Align = std::max(Align, I->getAlignment(Context));
3917  }
3918 
3919  if (AlignasAttr && Align) {
3920  CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3921  CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3922  if (NaturalAlign > RequestedAlign)
3923  Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3924  << DiagTy << (unsigned)NaturalAlign.getQuantity();
3925  }
3926 }
3927 
3929  CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3930  MSInheritanceAttr::Spelling SemanticSpelling) {
3931  assert(RD->hasDefinition() && "RD has no definition!");
3932 
3933  // We may not have seen base specifiers or any virtual methods yet. We will
3934  // have to wait until the record is defined to catch any mismatches.
3935  if (!RD->getDefinition()->isCompleteDefinition())
3936  return false;
3937 
3938  // The unspecified model never matches what a definition could need.
3939  if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3940  return false;
3941 
3942  if (BestCase) {
3943  if (RD->calculateInheritanceModel() == SemanticSpelling)
3944  return false;
3945  } else {
3946  if (RD->calculateInheritanceModel() <= SemanticSpelling)
3947  return false;
3948  }
3949 
3950  Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3951  << 0 /*definition*/;
3952  Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3953  << RD->getNameAsString();
3954  return true;
3955 }
3956 
3957 /// parseModeAttrArg - Parses attribute mode string and returns parsed type
3958 /// attribute.
3959 static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
3960  bool &IntegerMode, bool &ComplexMode) {
3961  IntegerMode = true;
3962  ComplexMode = false;
3963  switch (Str.size()) {
3964  case 2:
3965  switch (Str[0]) {
3966  case 'Q':
3967  DestWidth = 8;
3968  break;
3969  case 'H':
3970  DestWidth = 16;
3971  break;
3972  case 'S':
3973  DestWidth = 32;
3974  break;
3975  case 'D':
3976  DestWidth = 64;
3977  break;
3978  case 'X':
3979  DestWidth = 96;
3980  break;
3981  case 'T':
3982  DestWidth = 128;
3983  break;
3984  }
3985  if (Str[1] == 'F') {
3986  IntegerMode = false;
3987  } else if (Str[1] == 'C') {
3988  IntegerMode = false;
3989  ComplexMode = true;
3990  } else if (Str[1] != 'I') {
3991  DestWidth = 0;
3992  }
3993  break;
3994  case 4:
3995  // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3996  // pointer on PIC16 and other embedded platforms.
3997  if (Str == "word")
3998  DestWidth = S.Context.getTargetInfo().getRegisterWidth();
3999  else if (Str == "byte")
4000  DestWidth = S.Context.getTargetInfo().getCharWidth();
4001  break;
4002  case 7:
4003  if (Str == "pointer")
4004  DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
4005  break;
4006  case 11:
4007  if (Str == "unwind_word")
4008  DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
4009  break;
4010  }
4011 }
4012 
4013 /// handleModeAttr - This attribute modifies the width of a decl with primitive
4014 /// type.
4015 ///
4016 /// Despite what would be logical, the mode attribute is a decl attribute, not a
4017 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
4018 /// HImode, not an intermediate pointer.
4019 static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4020  // This attribute isn't documented, but glibc uses it. It changes
4021  // the width of an int or unsigned int to the specified size.
4022  if (!AL.isArgIdent(0)) {
4023  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
4024  << AL << AANT_ArgumentIdentifier;
4025  return;
4026  }
4027 
4028  IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident;
4029 
4030  S.AddModeAttr(AL.getRange(), D, Name, AL.getAttributeSpellingListIndex());
4031 }
4032 
4033 void Sema::AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
4034  unsigned SpellingListIndex, bool InInstantiation) {
4035  StringRef Str = Name->getName();
4036  normalizeName(Str);
4037  SourceLocation AttrLoc = AttrRange.getBegin();
4038 
4039  unsigned DestWidth = 0;
4040  bool IntegerMode = true;
4041  bool ComplexMode = false;
4042  llvm::APInt VectorSize(64, 0);
4043  if (Str.size() >= 4 && Str[0] == 'V') {
4044  // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
4045  size_t StrSize = Str.size();
4046  size_t VectorStringLength = 0;
4047  while ((VectorStringLength + 1) < StrSize &&
4048  isdigit(Str[VectorStringLength + 1]))
4049  ++VectorStringLength;
4050  if (VectorStringLength &&
4051  !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
4052  VectorSize.isPowerOf2()) {
4053  parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
4054  IntegerMode, ComplexMode);
4055  // Avoid duplicate warning from template instantiation.
4056  if (!InInstantiation)
4057  Diag(AttrLoc, diag::warn_vector_mode_deprecated);
4058  } else {
4059  VectorSize = 0;
4060  }
4061  }
4062 
4063  if (!VectorSize)
4064  parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
4065 
4066  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
4067  // and friends, at least with glibc.
4068  // FIXME: Make sure floating-point mappings are accurate
4069  // FIXME: Support XF and TF types
4070  if (!DestWidth) {
4071  Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
4072  return;
4073  }
4074 
4075  QualType OldTy;
4076  if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
4077  OldTy = TD->getUnderlyingType();
4078  else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
4079  // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
4080  // Try to get type from enum declaration, default to int.
4081  OldTy = ED->getIntegerType();
4082  if (OldTy.isNull())
4083  OldTy = Context.IntTy;
4084  } else
4085  OldTy = cast<ValueDecl>(D)->getType();
4086 
4087  if (OldTy->isDependentType()) {
4088  D->addAttr(::new (Context)
4089  ModeAttr(AttrRange, Context, Name, SpellingListIndex));
4090  return;
4091  }
4092 
4093  // Base type can also be a vector type (see PR17453).
4094  // Distinguish between base type and base element type.
4095  QualType OldElemTy = OldTy;
4096  if (const auto *VT = OldTy->getAs<VectorType>())
4097  OldElemTy = VT->getElementType();
4098 
4099  // GCC allows 'mode' attribute on enumeration types (even incomplete), except
4100  // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
4101  // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
4102  if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
4103  VectorSize.getBoolValue()) {
4104  Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
4105  return;
4106  }
4107  bool IntegralOrAnyEnumType =
4108  OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
4109 
4110  if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
4111  !IntegralOrAnyEnumType)
4112  Diag(AttrLoc, diag::err_mode_not_primitive);
4113  else if (IntegerMode) {
4114  if (!IntegralOrAnyEnumType)
4115  Diag(AttrLoc, diag::err_mode_wrong_type);
4116  } else if (ComplexMode) {
4117  if (!OldElemTy->isComplexType())
4118  Diag(AttrLoc, diag::err_mode_wrong_type);
4119  } else {
4120  if (!OldElemTy->isFloatingType())
4121  Diag(AttrLoc, diag::err_mode_wrong_type);
4122  }
4123 
4124  QualType NewElemTy;
4125 
4126  if (IntegerMode)
4127  NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
4128  OldElemTy->isSignedIntegerType());
4129  else
4130  NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
4131 
4132  if (NewElemTy.isNull()) {
4133  Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
4134  return;
4135  }
4136 
4137  if (ComplexMode) {
4138  NewElemTy = Context.getComplexType(NewElemTy);
4139  }
4140 
4141  QualType NewTy = NewElemTy;
4142  if (VectorSize.getBoolValue()) {
4143  NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
4145  } else if (const auto *OldVT = OldTy->getAs<VectorType>()) {
4146  // Complex machine mode does not support base vector types.
4147  if (ComplexMode) {
4148  Diag(AttrLoc, diag::err_complex_mode_vector_type);
4149  return;
4150  }
4151  unsigned NumElements = Context.getTypeSize(OldElemTy) *
4152  OldVT->getNumElements() /
4153  Context.getTypeSize(NewElemTy);
4154  NewTy =
4155  Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
4156  }
4157 
4158  if (NewTy.isNull()) {
4159  Diag(AttrLoc, diag::err_mode_wrong_type);
4160  return;
4161  }
4162 
4163  // Install the new type.
4164  if (auto *TD = dyn_cast<TypedefNameDecl>(D))
4165  TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
4166  else if (auto *ED = dyn_cast<EnumDecl>(D))
4167  ED->setIntegerType(NewTy);
4168  else
4169  cast<ValueDecl>(D)->setType(NewTy);
4170 
4171  D->addAttr(::new (Context)
4172  ModeAttr(AttrRange, Context, Name, SpellingListIndex));
4173 }
4174 
4175 static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4176  D->addAttr(::new (S.Context)
4177  NoDebugAttr(AL.getRange(), S.Context,
4179 }
4180 
4181 AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
4182  IdentifierInfo *Ident,
4183  unsigned AttrSpellingListIndex) {
4184  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4185  Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
4186  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4187  return nullptr;
4188  }
4189 
4190  if (D->hasAttr<AlwaysInlineAttr>())
4191  return nullptr;
4192 
4193  return ::new (Context) AlwaysInlineAttr(Range, Context,
4194  AttrSpellingListIndex);
4195 }
4196 
4197 CommonAttr *Sema::mergeCommonAttr(Decl *D, const ParsedAttr &AL) {
4198  if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
4199  return nullptr;
4200 
4201  return ::new (Context)
4202  CommonAttr(AL.getRange(), Context, AL.getAttributeSpellingListIndex());
4203 }
4204 
4205 CommonAttr *Sema::mergeCommonAttr(Decl *D, const CommonAttr &AL) {
4206  if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
4207  return nullptr;
4208 
4209  return ::new (Context)
4210  CommonAttr(AL.getRange(), Context, AL.getSpellingListIndex());
4211 }
4212 
4213 InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D,
4214  const ParsedAttr &AL) {
4215  if (const auto *VD = dyn_cast<VarDecl>(D)) {
4216  // Attribute applies to Var but not any subclass of it (like ParmVar,
4217  // ImplicitParm or VarTemplateSpecialization).
4218  if (VD->getKind() != Decl::Var) {
4219  Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4220  << AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
4222  return nullptr;
4223  }
4224  // Attribute does not apply to non-static local variables.
4225  if (VD->hasLocalStorage()) {
4226  Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4227  return nullptr;
4228  }
4229  }
4230 
4231  if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
4232  return nullptr;
4233 
4234  return ::new (Context) InternalLinkageAttr(
4235  AL.getRange(), Context, AL.getAttributeSpellingListIndex());
4236 }
4237 InternalLinkageAttr *
4238 Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {
4239  if (const auto *VD = dyn_cast<VarDecl>(D)) {
4240  // Attribute applies to Var but not any subclass of it (like ParmVar,
4241  // ImplicitParm or VarTemplateSpecialization).
4242  if (VD->getKind() != Decl::Var) {
4243  Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type)
4244  << &AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
4246  return nullptr;
4247  }
4248  // Attribute does not apply to non-static local variables.
4249  if (VD->hasLocalStorage()) {
4250  Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4251  return nullptr;
4252  }
4253  }
4254 
4255  if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
4256  return nullptr;
4257 
4258  return ::new (Context)
4259  InternalLinkageAttr(AL.getRange(), Context, AL.getSpellingListIndex());
4260 }
4261 
4262 MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
4263  unsigned AttrSpellingListIndex) {
4264  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4265  Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
4266  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4267  return nullptr;
4268  }
4269 
4270  if (D->hasAttr<MinSizeAttr>())
4271  return nullptr;
4272 
4273  return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
4274 }
4275 
4276 NoSpeculativeLoadHardeningAttr *Sema::mergeNoSpeculativeLoadHardeningAttr(
4277  Decl *D, const NoSpeculativeLoadHardeningAttr &AL) {
4278  if (checkAttrMutualExclusion<SpeculativeLoadHardeningAttr>(*this, D, AL))
4279  return nullptr;
4280 
4281  return ::new (Context) NoSpeculativeLoadHardeningAttr(
4282  AL.getRange(), Context, AL.getSpellingListIndex());
4283 }
4284 
4285 OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
4286  unsigned AttrSpellingListIndex) {
4287  if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
4288  Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4289  Diag(Range.getBegin(), diag::note_conflicting_attribute);
4290  D->dropAttr<AlwaysInlineAttr>();
4291  }
4292  if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
4293  Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4294  Diag(Range.getBegin(), diag::note_conflicting_attribute);
4295  D->dropAttr<MinSizeAttr>();
4296  }
4297 
4298  if (D->hasAttr<OptimizeNoneAttr>())
4299  return nullptr;
4300 
4301  return ::new (Context) OptimizeNoneAttr(Range, Context,
4302  AttrSpellingListIndex);
4303 }
4304 
4305 SpeculativeLoadHardeningAttr *Sema::mergeSpeculativeLoadHardeningAttr(
4306  Decl *D, const SpeculativeLoadHardeningAttr &AL) {
4307  if (checkAttrMutualExclusion<NoSpeculativeLoadHardeningAttr>(*this, D, AL))
4308  return nullptr;
4309 
4310  return ::new (Context) SpeculativeLoadHardeningAttr(
4311  AL.getRange(), Context, AL.getSpellingListIndex());
4312 }
4313 
4314 static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4315  if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, AL))
4316  return;
4317 
4318  if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
4319  D, AL.getRange(), AL.getName(),
4321  D->addAttr(Inline);
4322 }
4323 
4324 static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4325  if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
4326  D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4327  D->addAttr(MinSize);
4328 }
4329 
4330 static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4331  if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
4332  D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4333  D->addAttr(Optnone);
4334 }
4335 
4336 static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4337  if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL))
4338  return;
4339  const auto *VD = cast<VarDecl>(D);
4340  if (!VD->hasGlobalStorage()) {
4341  S.Diag(AL.getLoc(), diag::err_cuda_nonglobal_constant);
4342  return;
4343  }
4344  D->addAttr(::new (S.Context) CUDAConstantAttr(
4346 }
4347 
4348 static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4349  if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL))
4350  return;
4351  const auto *VD = cast<VarDecl>(D);
4352  // extern __shared__ is only allowed on arrays with no length (e.g.
4353  // "int x[]").
4354  if (!S.getLangOpts().GPURelocatableDeviceCode && VD->hasExternalStorage() &&
4355  !isa<IncompleteArrayType>(VD->getType())) {
4356  S.Diag(AL.getLoc(), diag::err_cuda_extern_shared) << VD;
4357  return;
4358  }
4359  if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
4360  S.CUDADiagIfHostCode(AL.getLoc(), diag::err_cuda_host_shared)
4361  << S.CurrentCUDATarget())
4362  return;
4363  D->addAttr(::new (S.Context) CUDASharedAttr(
4365 }
4366 
4367 static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4368  if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, AL) ||
4369  checkAttrMutualExclusion<CUDAHostAttr>(S, D, AL)) {
4370  return;
4371  }
4372  const auto *FD = cast<FunctionDecl>(D);
4373  if (!FD->getReturnType()->isVoidType()) {
4374  SourceRange RTRange = FD->getReturnTypeSourceRange();
4375  S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
4376  << FD->getType()
4377  << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
4378  : FixItHint());
4379  return;
4380  }
4381  if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4382  if (Method->isInstance()) {
4383  S.Diag(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method)
4384  << Method;
4385  return;
4386  }
4387  S.Diag(Method->getBeginLoc(), diag::warn_kern_is_method) << Method;
4388  }
4389  // Only warn for "inline" when compiling for host, to cut down on noise.
4390  if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
4391  S.Diag(FD->getBeginLoc(), diag::warn_kern_is_inline) << FD;
4392 
4393  D->addAttr(::new (S.Context)
4394  CUDAGlobalAttr(AL.getRange(), S.Context,
4396 }
4397 
4398 static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4399  const auto *Fn = cast<FunctionDecl>(D);
4400  if (!Fn->isInlineSpecified()) {
4401  S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4402  return;
4403  }
4404 
4405  D->addAttr(::new (S.Context)
4406  GNUInlineAttr(AL.getRange(), S.Context,
4408 }
4409 
4410 static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4411  if (hasDeclarator(D)) return;
4412 
4413  // Diagnostic is emitted elsewhere: here we store the (valid) AL
4414  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
4415  CallingConv CC;
4416  if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr))
4417  return;
4418 
4419  if (!isa<ObjCMethodDecl>(D)) {
4420  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4421  << AL << ExpectedFunctionOrMethod;
4422  return;
4423  }
4424 
4425  switch (AL.getKind()) {
4426  case ParsedAttr::AT_FastCall:
4427  D->addAttr(::new (S.Context)
4428  FastCallAttr(AL.getRange(), S.Context,
4430  return;
4431  case ParsedAttr::AT_StdCall:
4432  D->addAttr(::new (S.Context)
4433  StdCallAttr(AL.getRange(), S.Context,
4435  return;
4436  case ParsedAttr::AT_ThisCall:
4437  D->addAttr(::new (S.Context)
4438  ThisCallAttr(AL.getRange(), S.Context,
4440  return;
4441  case ParsedAttr::AT_CDecl:
4442  D->addAttr(::new (S.Context)
4443  CDeclAttr(AL.getRange(), S.Context,
4445  return;
4446  case ParsedAttr::AT_Pascal:
4447  D->addAttr(::new (S.Context)
4448  PascalAttr(AL.getRange(), S.Context,
4450  return;
4451  case ParsedAttr::AT_SwiftCall:
4452  D->addAttr(::new (S.Context)
4453  SwiftCallAttr(AL.getRange(), S.Context,
4455  return;
4456  case ParsedAttr::AT_VectorCall:
4457  D->addAttr(::new (S.Context)
4458  VectorCallAttr(AL.getRange(), S.Context,
4460  return;
4461  case ParsedAttr::AT_MSABI:
4462  D->addAttr(::new (S.Context)
4463  MSABIAttr(AL.getRange(), S.Context,
4465  return;
4466  case ParsedAttr::AT_SysVABI:
4467  D->addAttr(::new (S.Context)
4468  SysVABIAttr(AL.getRange(), S.Context,
4470  return;
4471  case ParsedAttr::AT_RegCall:
4472  D->addAttr(::new (S.Context) RegCallAttr(
4474  return;
4475  case ParsedAttr::AT_Pcs: {
4476  PcsAttr::PCSType PCS;
4477  switch (CC) {
4478  case CC_AAPCS:
4479  PCS = PcsAttr::AAPCS;
4480  break;
4481  case CC_AAPCS_VFP:
4482  PCS = PcsAttr::AAPCS_VFP;
4483  break;
4484  default:
4485  llvm_unreachable("unexpected calling convention in pcs attribute");
4486  }
4487 
4488  D->addAttr(::new (S.Context)
4489  PcsAttr(AL.getRange(), S.Context, PCS,
4491  return;
4492  }
4493  case ParsedAttr::AT_AArch64VectorPcs:
4494  D->addAttr(::new(S.Context)
4495  AArch64VectorPcsAttr(AL.getRange(), S.Context,
4497  return;
4498  case ParsedAttr::AT_IntelOclBicc:
4499  D->addAttr(::new (S.Context)
4500  IntelOclBiccAttr(AL.getRange(), S.Context,
4502  return;
4503  case ParsedAttr::AT_PreserveMost:
4504  D->addAttr(::new (S.Context) PreserveMostAttr(
4506  return;
4507  case ParsedAttr::AT_PreserveAll:
4508  D->addAttr(::new (S.Context) PreserveAllAttr(
4510  return;
4511  default:
4512  llvm_unreachable("unexpected attribute kind");
4513  }
4514 }
4515 
4516 static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4517  if (!checkAttributeAtLeastNumArgs(S, AL, 1))
4518  return;
4519 
4520  std::vector<StringRef> DiagnosticIdentifiers;
4521  for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
4522  StringRef RuleName;
4523 
4524  if (!S.checkStringLiteralArgumentAttr(AL, I, RuleName, nullptr))
4525  return;
4526 
4527  // FIXME: Warn if the rule name is unknown. This is tricky because only
4528  // clang-tidy knows about available rules.
4529  DiagnosticIdentifiers.push_back(RuleName);
4530  }
4531  D->addAttr(::new (S.Context) SuppressAttr(
4532  AL.getRange(), S.Context, DiagnosticIdentifiers.data(),
4533  DiagnosticIdentifiers.size(), AL.getAttributeSpellingListIndex()));
4534 }
4535 
4536 bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
4537  const FunctionDecl *FD) {
4538  if (Attrs.isInvalid())
4539  return true;
4540 
4541  if (Attrs.hasProcessingCache()) {
4542  CC = (CallingConv) Attrs.getProcessingCache();
4543  return false;
4544  }
4545 
4546  unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
4547  if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
4548  Attrs.setInvalid();
4549  return true;
4550  }
4551 
4552  // TODO: diagnose uses of these conventions on the wrong target.
4553  switch (Attrs.getKind()) {
4554  case ParsedAttr::AT_CDecl:
4555  CC = CC_C;
4556  break;
4557  case ParsedAttr::AT_FastCall:
4558  CC = CC_X86FastCall;
4559  break;
4560  case ParsedAttr::AT_StdCall:
4561  CC = CC_X86StdCall;
4562  break;
4563  case ParsedAttr::AT_ThisCall:
4564  CC = CC_X86ThisCall;
4565  break;
4566  case ParsedAttr::AT_Pascal:
4567  CC = CC_X86Pascal;
4568  break;
4569  case ParsedAttr::AT_SwiftCall:
4570  CC = CC_Swift;
4571  break;
4572  case ParsedAttr::AT_VectorCall:
4573  CC = CC_X86VectorCall;
4574  break;
4575  case ParsedAttr::AT_AArch64VectorPcs:
4576  CC = CC_AArch64VectorCall;
4577  break;
4578  case ParsedAttr::AT_RegCall:
4579  CC = CC_X86RegCall;
4580  break;
4581  case ParsedAttr::AT_MSABI:
4582  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
4583  CC_Win64;
4584  break;
4585  case ParsedAttr::AT_SysVABI:
4586  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
4587  CC_C;
4588  break;
4589  case ParsedAttr::AT_Pcs: {
4590  StringRef StrRef;
4591  if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
4592  Attrs.setInvalid();
4593  return true;
4594  }
4595  if (StrRef == "aapcs") {
4596  CC = CC_AAPCS;
4597  break;
4598  } else if (StrRef == "aapcs-vfp") {
4599  CC = CC_AAPCS_VFP;
4600  break;
4601  }
4602 
4603  Attrs.setInvalid();
4604  Diag(Attrs.getLoc(), diag::err_invalid_pcs);
4605  return true;
4606  }
4607  case ParsedAttr::AT_IntelOclBicc:
4608  CC = CC_IntelOclBicc;
4609  break;
4610  case ParsedAttr::AT_PreserveMost:
4611  CC = CC_PreserveMost;
4612  break;
4613  case ParsedAttr::AT_PreserveAll:
4614  CC = CC_PreserveAll;
4615  break;
4616  default: llvm_unreachable("unexpected attribute kind");
4617  }
4618 
4620  const TargetInfo &TI = Context.getTargetInfo();
4621  // CUDA functions may have host and/or device attributes which indicate
4622  // their targeted execution environment, therefore the calling convention
4623  // of functions in CUDA should be checked against the target deduced based
4624  // on their host/device attributes.
4625  if (LangOpts.CUDA) {
4626  auto *Aux = Context.getAuxTargetInfo();
4627  auto CudaTarget = IdentifyCUDATarget(FD);
4628  bool CheckHost = false, CheckDevice = false;
4629  switch (CudaTarget) {
4630  case CFT_HostDevice:
4631  CheckHost = true;
4632  CheckDevice = true;
4633  break;
4634  case CFT_Host:
4635  CheckHost = true;
4636  break;
4637  case CFT_Device:
4638  case CFT_Global:
4639  CheckDevice = true;
4640  break;
4641  case CFT_InvalidTarget:
4642  llvm_unreachable("unexpected cuda target");
4643  }
4644  auto *HostTI = LangOpts.CUDAIsDevice ? Aux : &TI;
4645  auto *DeviceTI = LangOpts.CUDAIsDevice ? &TI : Aux;
4646  if (CheckHost && HostTI)
4647  A = HostTI->checkCallingConvention(CC);
4648  if (A == TargetInfo::CCCR_OK && CheckDevice && DeviceTI)
4649  A = DeviceTI->checkCallingConvention(CC);
4650  } else {
4651  A = TI.checkCallingConvention(CC);
4652  }
4653  if (A != TargetInfo::CCCR_OK) {
4654  if (A == TargetInfo::CCCR_Warning)
4655  Diag(Attrs.getLoc(), diag::warn_cconv_ignored)
4656  << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;
4657 
4658  // This convention is not valid for the target. Use the default function or
4659  // method calling convention.
4660  bool IsCXXMethod = false, IsVariadic = false;
4661  if (FD) {
4662  IsCXXMethod = FD->isCXXInstanceMember();
4663  IsVariadic = FD->isVariadic();
4664  }
4665  CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
4666  }
4667 
4668  Attrs.setProcessingCache((unsigned) CC);
4669  return false;
4670 }
4671 
4672 /// Pointer-like types in the default address space.
4673 static bool isValidSwiftContextType(QualType Ty) {
4674  if (!Ty->hasPointerRepresentation())
4675  return Ty->isDependentType();
4677 }
4678 
4679 /// Pointers and references in the default address space.
4680 static bool isValidSwiftIndirectResultType(QualType Ty) {
4681  if (const auto *PtrType = Ty->getAs<PointerType>()) {
4682  Ty = PtrType->getPointeeType();
4683  } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4684  Ty = RefType->getPointeeType();
4685  } else {
4686  return Ty->isDependentType();
4687  }
4688  return Ty.getAddressSpace() == LangAS::Default;
4689 }
4690 
4691 /// Pointers and references to pointers in the default address space.
4692 static bool isValidSwiftErrorResultType(QualType Ty) {
4693  if (const auto *PtrType = Ty->getAs<PointerType>()) {
4694  Ty = PtrType->getPointeeType();
4695  } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4696  Ty = RefType->getPointeeType();
4697  } else {
4698  return Ty->isDependentType();
4699  }
4700  if (!Ty.getQualifiers().empty())
4701  return false;
4702  return isValidSwiftContextType(Ty);
4703 }
4704 
4705 static void handleParameterABIAttr(Sema &S, Decl *D, const ParsedAttr &Attrs,
4706  ParameterABI Abi) {
4707  S.AddParameterABIAttr(Attrs.getRange(), D, Abi,
4709 }
4710 
4712  unsigned spellingIndex) {
4713 
4714  QualType type = cast<ParmVarDecl>(D)->getType();
4715 
4716  if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
4717  if (existingAttr->getABI() != abi) {
4718  Diag(range.getBegin(), diag::err_attributes_are_not_compatible)
4719  << getParameterABISpelling(abi) << existingAttr;
4720  Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
4721  return;
4722  }
4723  }
4724 
4725  switch (abi) {
4727  llvm_unreachable("explicit attribute for ordinary parameter ABI?");
4728 
4730  if (!isValidSwiftContextType(type)) {
4731  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4732  << getParameterABISpelling(abi)
4733  << /*pointer to pointer */ 0 << type;
4734  }
4735  D->addAttr(::new (Context)
4736  SwiftContextAttr(range, Context, spellingIndex));
4737  return;
4738 
4740  if (!isValidSwiftErrorResultType(type)) {
4741  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4742  << getParameterABISpelling(abi)
4743  << /*pointer to pointer */ 1 << type;
4744  }
4745  D->addAttr(::new (Context)
4746  SwiftErrorResultAttr(range, Context, spellingIndex));
4747  return;
4748 
4750  if (!isValidSwiftIndirectResultType(type)) {
4751  Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4752  << getParameterABISpelling(abi)
4753  << /*pointer*/ 0 << type;
4754  }
4755  D->addAttr(::new (Context)
4756  SwiftIndirectResultAttr(range, Context, spellingIndex));
4757  return;
4758  }
4759  llvm_unreachable("bad parameter ABI attribute");
4760 }
4761 
4762 /// Checks a regparm attribute, returning true if it is ill-formed and
4763 /// otherwise setting numParams to the appropriate value.
4764 bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) {
4765  if (AL.isInvalid())
4766  return true;
4767 
4768  if (!checkAttributeNumArgs(*this, AL, 1)) {
4769  AL.setInvalid();
4770  return true;
4771  }
4772 
4773  uint32_t NP;
4774  Expr *NumParamsExpr = AL.getArgAsExpr(0);
4775  if (!checkUInt32Argument(*this, AL, NumParamsExpr, NP)) {
4776  AL.setInvalid();
4777  return true;
4778  }
4779 
4780  if (Context.getTargetInfo().getRegParmMax() == 0) {
4781  Diag(AL.getLoc(), diag::err_attribute_regparm_wrong_platform)
4782  << NumParamsExpr->getSourceRange();
4783  AL.setInvalid();
4784  return true;
4785  }
4786 
4787  numParams = NP;
4788  if (numParams > Context.getTargetInfo().getRegParmMax()) {
4789  Diag(AL.getLoc(), diag::err_attribute_regparm_invalid_number)
4790  << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4791  AL.setInvalid();
4792  return true;
4793  }
4794 
4795  return false;
4796 }
4797 
4798 // Checks whether an argument of launch_bounds attribute is
4799 // acceptable, performs implicit conversion to Rvalue, and returns
4800 // non-nullptr Expr result on success. Otherwise, it returns nullptr
4801 // and may output an error.
4802 static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4803  const CUDALaunchBoundsAttr &AL,
4804  const unsigned Idx) {
4806  return nullptr;
4807 
4808  // Accept template arguments for now as they depend on something else.
4809  // We'll get to check them when they eventually get instantiated.
4810  if (E->isValueDependent())
4811  return E;
4812 
4813  llvm::APSInt I(64);
4814  if (!E->isIntegerConstantExpr(I, S.Context)) {
4815  S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
4816  << &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
4817  return nullptr;
4818  }
4819  // Make sure we can fit it in 32 bits.
4820  if (!I.isIntN(32)) {
4821  S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
4822  << 32 << /* Unsigned */ 1;
4823  return nullptr;
4824  }
4825  if (I < 0)
4826  S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
4827  << &AL << Idx << E->getSourceRange();
4828 
4829  // We may need to perform implicit conversion of the argument.
4831  S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
4832  ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
4833  assert(!ValArg.isInvalid() &&
4834  "Unexpected PerformCopyInitialization() failure.");
4835 
4836  return ValArg.getAs<Expr>();
4837 }
4838 
4839 void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
4840  Expr *MinBlocks, unsigned SpellingListIndex) {
4841  CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
4842  SpellingListIndex);
4843  MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
4844  if (MaxThreads == nullptr)
4845  return;
4846 
4847  if (MinBlocks) {
4848  MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
4849  if (MinBlocks == nullptr)
4850  return;
4851  }
4852 
4853  D->addAttr(::new (Context) CUDALaunchBoundsAttr(
4854  AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
4855 }
4856 
4857 static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4858  if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
4859  !checkAttributeAtMostNumArgs(S, AL, 2))
4860  return;
4861 
4862  S.AddLaunchBoundsAttr(AL.getRange(), D, AL.getArgAsExpr(0),
4863  AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr,
4865 }
4866 
4867 static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
4868  const ParsedAttr &AL) {
4869  if (!AL.isArgIdent(0)) {
4870  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4871  << AL << /* arg num = */ 1 << AANT_ArgumentIdentifier;
4872  return;
4873  }
4874 
4875  ParamIdx ArgumentIdx;
4876  if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, AL.getArgAsExpr(1),
4877  ArgumentIdx))
4878  return;
4879 
4880  ParamIdx TypeTagIdx;
4881  if (!checkFunctionOrMethodParameterIndex(S, D, AL, 3, AL.getArgAsExpr(2),
4882  TypeTagIdx))
4883  return;
4884 
4885  bool IsPointer = AL.getName()->getName() == "pointer_with_type_tag";
4886  if (IsPointer) {
4887  // Ensure that buffer has a pointer type.
4888  unsigned ArgumentIdxAST = ArgumentIdx.getASTIndex();
4889  if (ArgumentIdxAST >= getFunctionOrMethodNumParams(D) ||
4890  !getFunctionOrMethodParamType(D, ArgumentIdxAST)->isPointerType())
4891  S.Diag(AL.getLoc(), diag::err_attribute_pointers_only) << AL << 0;
4892  }
4893 
4894  D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(
4895  AL.getRange(), S.Context, AL.getArgAsIdent(0)->Ident, ArgumentIdx,
4896  TypeTagIdx, IsPointer, AL.getAttributeSpellingListIndex()));
4897 }
4898 
4899 static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
4900  const ParsedAttr &AL) {
4901  if (!AL.isArgIdent(0)) {
4902  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4903  << AL << 1 << AANT_ArgumentIdentifier;
4904  return;
4905  }
4906 
4907  if (!checkAttributeNumArgs(S, AL, 1))
4908  return;
4909 
4910  if (!isa<VarDecl>(D)) {
4911  S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type)
4912  << AL << ExpectedVariable;
4913  return;
4914  }
4915 
4916  IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident;
4917  TypeSourceInfo *MatchingCTypeLoc = nullptr;
4918  S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc);
4919  assert(MatchingCTypeLoc && "no type source info for attribute argument");
4920 
4921  D->addAttr(::new (S.Context)
4922  TypeTagForDatatypeAttr(AL.getRange(), S.Context, PointerKind,
4923  MatchingCTypeLoc,
4924  AL.getLayoutCompatible(),
4925  AL.getMustBeNull(),
4927 }
4928 
4929 static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4930  ParamIdx ArgCount;
4931 
4932  if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0),
4933  ArgCount,
4934  true /* CanIndexImplicitThis */))
4935  return;
4936 
4937  // ArgCount isn't a parameter index [0;n), it's a count [1;n]
4938  D->addAttr(::new (S.Context) XRayLogArgsAttr(
4939  AL.getRange(), S.Context, ArgCount.getSourceIndex(),
4941 }
4942 
4943 //===----------------------------------------------------------------------===//
4944 // Checker-specific attribute handlers.
4945 //===----------------------------------------------------------------------===//
4946 static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) {
4947  return QT->isDependentType() || QT->isObjCRetainableType();
4948 }
4949 
4950 static bool isValidSubjectOfNSAttribute(QualType QT) {
4951  return QT->isDependentType() || QT->isObjCObjectPointerType() ||
4952  QT->isObjCNSObjectType();
4953 }
4954 
4955 static bool isValidSubjectOfCFAttribute(QualType QT) {
4956  return QT->isDependentType() || QT->isPointerType() ||
4957  isValidSubjectOfNSAttribute(QT);
4958 }
4959 
4960 static bool isValidSubjectOfOSAttribute(QualType QT) {
4961  if (QT->isDependentType())
4962  return true;
4963  QualType PT = QT->getPointeeType();
4964  return !PT.isNull() && PT->getAsCXXRecordDecl() != nullptr;
4965 }
4966 
4967 void Sema::AddXConsumedAttr(Decl *D, SourceRange SR, unsigned SpellingIndex,
4968  RetainOwnershipKind K,
4969  bool IsTemplateInstantiation) {
4970  ValueDecl *VD = cast<ValueDecl>(D);
4971  switch (K) {
4972  case RetainOwnershipKind::OS:
4973  handleSimpleAttributeOrDiagnose<OSConsumedAttr>(
4974  *this, VD, SR, SpellingIndex, isValidSubjectOfOSAttribute(VD->getType()),
4975  diag::warn_ns_attribute_wrong_parameter_type,
4976  /*ExtraArgs=*/SR, "os_consumed", /*pointers*/ 1);
4977  return;
4978  case RetainOwnershipKind::NS:
4979  handleSimpleAttributeOrDiagnose<NSConsumedAttr>(
4980  *this, VD, SR, SpellingIndex, isValidSubjectOfNSAttribute(VD->getType()),
4981 
4982  // These attributes are normally just advisory, but in ARC, ns_consumed
4983  // is significant. Allow non-dependent code to contain inappropriate
4984  // attributes even in ARC, but require template instantiations to be
4985  // set up correctly.
4986  ((IsTemplateInstantiation && getLangOpts().ObjCAutoRefCount)
4987  ? diag::err_ns_attribute_wrong_parameter_type
4988  : diag::warn_ns_attribute_wrong_parameter_type),
4989  /*ExtraArgs=*/SR, "ns_consumed", /*objc pointers*/ 0);
4990  return;
4991  case RetainOwnershipKind::CF:
4992  handleSimpleAttributeOrDiagnose<CFConsumedAttr>(
4993  *this, VD, SR, SpellingIndex,
4994  isValidSubjectOfCFAttribute(VD->getType()),
4995  diag::warn_ns_attribute_wrong_parameter_type,
4996  /*ExtraArgs=*/SR, "cf_consumed", /*pointers*/1);
4997  return;
4998  }
4999 }
5000 
5002 parsedAttrToRetainOwnershipKind(const ParsedAttr &AL) {
5003  switch (AL.getKind()) {
5004  case ParsedAttr::AT_CFConsumed:
5005  case ParsedAttr::AT_CFReturnsRetained:
5006  case ParsedAttr::AT_CFReturnsNotRetained:
5008  case ParsedAttr::AT_OSConsumesThis:
5009  case ParsedAttr::AT_OSConsumed:
5010  case ParsedAttr::AT_OSReturnsRetained:
5011  case ParsedAttr::AT_OSReturnsNotRetained:
5012  case ParsedAttr::AT_OSReturnsRetainedOnZero:
5013  case ParsedAttr::AT_OSReturnsRetainedOnNonZero:
5015  case ParsedAttr::AT_NSConsumesSelf:
5016  case ParsedAttr::AT_NSConsumed:
5017  case ParsedAttr::AT_NSReturnsRetained:
5018  case ParsedAttr::AT_NSReturnsNotRetained:
5019  case ParsedAttr::AT_NSReturnsAutoreleased:
5021  default:
5022  llvm_unreachable("Wrong argument supplied");
5023  }
5024 }
5025 
5027  if (isValidSubjectOfNSReturnsRetainedAttribute(QT))
5028  return false;
5029 
5030  Diag(Loc, diag::warn_ns_attribute_wrong_return_type)
5031  << "'ns_returns_retained'" << 0 << 0;
5032  return true;
5033 }
5034 
5035 /// \return whether the parameter is a pointer to OSObject pointer.
5036 static bool isValidOSObjectOutParameter(const Decl *D) {
5037  const auto *PVD = dyn_cast<ParmVarDecl>(D);
5038  if (!PVD)
5039  return false;
5040  QualType QT = PVD->getType();
5041  QualType PT = QT->getPointeeType();
5042  return !PT.isNull() && isValidSubjectOfOSAttribute(PT);
5043 }
5044 
5045 static void handleXReturnsXRetainedAttr(Sema &S, Decl *D,
5046  const ParsedAttr &AL) {
5047  QualType ReturnType;
5048  Sema::RetainOwnershipKind K = parsedAttrToRetainOwnershipKind(AL);
5049 
5050  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
5051  ReturnType = MD->getReturnType();
5052  } else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
5053  (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) {
5054  return; // ignore: was handled as a type attribute
5055  } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
5056  ReturnType = PD->getType();
5057  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
5058  ReturnType = FD->getReturnType();
5059  } else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {
5060  // Attributes on parameters are used for out-parameters,
5061  // passed as pointers-to-pointers.
5062  unsigned DiagID = K == Sema::RetainOwnershipKind::CF
5063  ? /*pointer-to-CF-pointer*/2
5064  : /*pointer-to-OSObject-pointer*/3;
5065  ReturnType = Param->getType()->getPointeeType();
5066  if (ReturnType.isNull()) {
5067  S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
5068  << AL << DiagID << AL.getRange();
5069  return;
5070  }
5071  } else if (AL.isUsedAsTypeAttr()) {
5072  return;
5073  } else {
5074  AttributeDeclKind ExpectedDeclKind;
5075  switch (AL.getKind()) {
5076  default: llvm_unreachable("invalid ownership attribute");
5077  case ParsedAttr::AT_NSReturnsRetained:
5078  case ParsedAttr::AT_NSReturnsAutoreleased:
5079  case ParsedAttr::AT_NSReturnsNotRetained:
5080  ExpectedDeclKind = ExpectedFunctionOrMethod;
5081  break;
5082 
5083  case ParsedAttr::AT_OSReturnsRetained:
5084  case ParsedAttr::AT_OSReturnsNotRetained:
5085  case ParsedAttr::AT_CFReturnsRetained:
5086  case ParsedAttr::AT_CFReturnsNotRetained:
5087  ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
5088  break;
5089  }
5090  S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type)
5091  << AL.getRange() << AL << ExpectedDeclKind;
5092  return;
5093  }
5094 
5095  bool TypeOK;
5096  bool Cf;
5097  unsigned ParmDiagID = 2; // Pointer-to-CF-pointer
5098  switch (AL.getKind()) {
5099  default: llvm_unreachable("invalid ownership attribute");
5100  case ParsedAttr::AT_NSReturnsRetained:
5101  TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType);
5102  Cf = false;
5103  break;
5104 
5105  case ParsedAttr::AT_NSReturnsAutoreleased:
5106  case ParsedAttr::AT_NSReturnsNotRetained:
5107  TypeOK = isValidSubjectOfNSAttribute(ReturnType);
5108  Cf = false;
5109  break;
5110 
5111  case ParsedAttr::AT_CFReturnsRetained:
5112  case ParsedAttr::AT_CFReturnsNotRetained:
5113  TypeOK = isValidSubjectOfCFAttribute(ReturnType);
5114  Cf = true;
5115  break;
5116 
5117  case ParsedAttr::AT_OSReturnsRetained:
5118  case ParsedAttr::AT_OSReturnsNotRetained:
5119  TypeOK = isValidSubjectOfOSAttribute(ReturnType);
5120  Cf = true;
5121  ParmDiagID = 3; // Pointer-to-OSObject-pointer
5122  break;
5123  }
5124 
5125  if (!TypeOK) {
5126  if (AL.isUsedAsTypeAttr())
5127  return;
5128 
5129  if (isa<ParmVarDecl>(D)) {
5130  S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
5131  << AL << ParmDiagID << AL.getRange();
5132  } else {
5133  // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
5134  enum : unsigned {
5135  Function,
5136  Method,
5137  Property
5138  } SubjectKind = Function;
5139  if (isa<ObjCMethodDecl>(D))
5140  SubjectKind = Method;
5141  else if (isa<ObjCPropertyDecl>(D))
5142  SubjectKind = Property;
5143  S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
5144  << AL << SubjectKind << Cf << AL.getRange();
5145  }
5146  return;
5147  }
5148 
5149  switch (AL.getKind()) {
5150  default:
5151  llvm_unreachable("invalid ownership attribute");
5152  case ParsedAttr::AT_NSReturnsAutoreleased:
5153  handleSimpleAttribute<NSReturnsAutoreleasedAttr>(S, D, AL);
5154  return;
5155  case ParsedAttr::AT_CFReturnsNotRetained:
5156  handleSimpleAttribute<CFReturnsNotRetainedAttr>(S, D, AL);
5157  return;
5158  case ParsedAttr::AT_NSReturnsNotRetained:
5159  handleSimpleAttribute<NSReturnsNotRetainedAttr>(S, D, AL);
5160  return;
5161  case ParsedAttr::AT_CFReturnsRetained:
5162  handleSimpleAttribute<CFReturnsRetainedAttr>(S, D, AL);
5163  return;
5164  case ParsedAttr::AT_NSReturnsRetained:
5165  handleSimpleAttribute<NSReturnsRetainedAttr>(S, D, AL);
5166  return;
5167  case ParsedAttr::AT_OSReturnsRetained:
5168  handleSimpleAttribute<OSReturnsRetainedAttr>(S, D, AL);
5169  return;
5170  case ParsedAttr::AT_OSReturnsNotRetained:
5171  handleSimpleAttribute<OSReturnsNotRetainedAttr>(S, D, AL);
5172  return;
5173  };
5174 }
5175 
5176 static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
5177  const ParsedAttr &Attrs) {
5178  const int EP_ObjCMethod = 1;
5179  const int EP_ObjCProperty = 2;
5180 
5181  SourceLocation loc = Attrs.getLoc();
5182  QualType resultType;
5183  if (isa<ObjCMethodDecl>(D))
5184  resultType = cast<ObjCMethodDecl>(D)->getReturnType();
5185  else
5186  resultType = cast<ObjCPropertyDecl>(D)->getType();
5187 
5188  if (!resultType->isReferenceType() &&
5189  (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
5190  S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
5191  << SourceRange(loc) << Attrs
5192  << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
5193  << /*non-retainable pointer*/ 2;
5194 
5195  // Drop the attribute.
5196  return;
5197  }
5198 
5199  D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
5200  Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
5201 }
5202 
5203 static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
5204  const ParsedAttr &Attrs) {
5205  const auto *Method = cast<ObjCMethodDecl>(D);
5206 
5207  const DeclContext *DC = Method->getDeclContext();
5208  if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
5209  S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
5210  << 0;
5211  S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
5212  return;
5213  }
5214  if (Method->getMethodFamily() == OMF_dealloc) {
5215  S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
5216  << 1;
5217  return;
5218  }
5219 
5220  D->addAttr(::new (S.Context) ObjCRequiresSuperAttr(
5221  Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
5222 }
5223 
5224 static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5225  IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
5226 
5227  if (!Parm) {
5228  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5229  return;
5230  }
5231 
5232  // Typedefs only allow objc_bridge(id) and have some additional checking.
5233  if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
5234  if (!Parm->Ident->isStr("id")) {
5235  S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_id) << AL;
5236  return;
5237  }
5238 
5239  // Only allow 'cv void *'.
5240  QualType T = TD->getUnderlyingType();
5241  if (!T->isVoidPointerType()) {
5242  S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
5243  return;
5244  }
5245  }
5246 
5247  D->addAttr(::new (S.Context)
5248  ObjCBridgeAttr(AL.getRange(), S.Context, Parm->Ident,
5250 }
5251 
5252 static void handleObjCBridgeMutableAttr(Sema &S, Decl *D,
5253  const ParsedAttr &AL) {
5254  IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
5255 
5256  if (!Parm) {
5257  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5258  return;
5259  }
5260 
5261  D->addAttr(::new (S.Context)
5262  ObjCBridgeMutableAttr(AL.getRange(), S.Context, Parm->Ident,
5264 }
5265 
5266 static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D,
5267  const ParsedAttr &AL) {
5268  IdentifierInfo *RelatedClass =
5269  AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr;
5270  if (!RelatedClass) {
5271  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5272  return;
5273  }
5274  IdentifierInfo *ClassMethod =
5275  AL.getArgAsIdent(1) ? AL.getArgAsIdent(1)->Ident : nullptr;
5276  IdentifierInfo *InstanceMethod =
5277  AL.getArgAsIdent(2) ? AL.getArgAsIdent(2)->Ident : nullptr;
5278  D->addAttr(::new (S.Context)
5279  ObjCBridgeRelatedAttr(AL.getRange(), S.Context, RelatedClass,
5280  ClassMethod, InstanceMethod,
5282 }
5283 
5284 static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
5285  const ParsedAttr &AL) {
5286  DeclContext *Ctx = D->getDeclContext();
5287 
5288  // This attribute can only be applied to methods in interfaces or class
5289  // extensions.
5290  if (!isa<ObjCInterfaceDecl>(Ctx) &&
5291  !(isa<ObjCCategoryDecl>(Ctx) &&
5292  cast<ObjCCategoryDecl>(Ctx)->IsClassExtension())) {
5293  S.Diag(D->getLocation(), diag::err_designated_init_attr_non_init);
5294  return;
5295  }
5296 
5297  ObjCInterfaceDecl *IFace;
5298  if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(Ctx))
5299  IFace = CatDecl->getClassInterface();
5300  else
5301  IFace = cast<ObjCInterfaceDecl>(Ctx);
5302 
5303  if (!IFace)
5304  return;
5305 
5307  D->addAttr(::new (S.Context)
5308  ObjCDesignatedInitializerAttr(AL.getRange(), S.Context,
5310 }
5311 
5312 static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) {
5313  StringRef MetaDataName;
5314  if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName))
5315  return;
5316  D->addAttr(::new (S.Context)
5317  ObjCRuntimeNameAttr(AL.getRange(), S.Context,
5318  MetaDataName,
5320 }
5321 
5322 // When a user wants to use objc_boxable with a union or struct
5323 // but they don't have access to the declaration (legacy/third-party code)
5324 // then they can 'enable' this feature with a typedef:
5325 // typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
5326 static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) {
5327  bool notify = false;
5328 
5329  auto *RD = dyn_cast<RecordDecl>(D);
5330  if (RD && RD->getDefinition()) {
5331  RD = RD->getDefinition();
5332  notify = true;
5333  }
5334 
5335  if (RD) {
5336  ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
5337  ObjCBoxableAttr(AL.getRange(), S.Context,
5339  RD->addAttr(BoxableAttr);
5340  if (notify) {
5341  // we need to notify ASTReader/ASTWriter about
5342  // modification of existing declaration
5344  L->AddedAttributeToRecord(BoxableAttr, RD);
5345  }
5346  }
5347 }
5348 
5349 static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5350  if (hasDeclarator(D)) return;
5351 
5352  S.Diag(D->getBeginLoc(), diag::err_attribute_wrong_decl_type)
5353  << AL.getRange() << AL << ExpectedVariable;
5354 }
5355 
5356 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
5357  const ParsedAttr &AL) {
5358  const auto *VD = cast<ValueDecl>(D);
5359  QualType QT = VD->getType();
5360 
5361  if (!QT->isDependentType() &&
5362  !QT->isObjCLifetimeType()) {
5363  S.Diag(AL.getLoc(), diag::err_objc_precise_lifetime_bad_type)
5364  << QT;
5365  return;
5366  }
5367 
5368  Qualifiers::ObjCLifetime Lifetime = QT.getObjCLifetime();
5369 
5370  // If we have no lifetime yet, check the lifetime we're presumably
5371  // going to infer.
5372  if (Lifetime == Qualifiers::OCL_None && !QT->isDependentType())
5373  Lifetime = QT->getObjCARCImplicitLifetime();
5374 
5375  switch (Lifetime) {
5376  case Qualifiers::OCL_None:
5377  assert(QT->isDependentType() &&
5378  "didn't infer lifetime for non-dependent type?");
5379  break;
5380 
5381  case Qualifiers::OCL_Weak: // meaningful
5382  case Qualifiers::OCL_Strong: // meaningful
5383  break;
5384 
5387  S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
5388  << (Lifetime == Qualifiers::OCL_Autoreleasing);
5389  break;
5390  }
5391 
5392  D->addAttr(::new (S.Context)
5393  ObjCPreciseLifetimeAttr(AL.getRange(), S.Context,
5395 }
5396 
5397 //===----------------------------------------------------------------------===//
5398 // Microsoft specific attribute handlers.
5399 //===----------------------------------------------------------------------===//
5400 
5401 UuidAttr *Sema::mergeUuidAttr(Decl *D, SourceRange Range,
5402  unsigned AttrSpellingListIndex, StringRef Uuid) {
5403  if (const auto *UA = D->getAttr<UuidAttr>()) {
5404  if (UA->getGuid().equals_lower(Uuid))
5405  return nullptr;
5406  Diag(UA->getLocation(), diag::err_mismatched_uuid);
5407  Diag(Range.getBegin(), diag::note_previous_uuid);
5408  D->dropAttr<UuidAttr>();
5409  }
5410 
5411  return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
5412 }
5413 
5414 static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5415  if (!S.LangOpts.CPlusPlus) {
5416  S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5417  << AL << AttributeLangSupport::C;
5418  return;
5419  }
5420 
5421  StringRef StrRef;
5422  SourceLocation LiteralLoc;
5423  if (!S.checkStringLiteralArgumentAttr(AL, 0, StrRef, &LiteralLoc))
5424  return;
5425 
5426  // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
5427  // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
5428  if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
5429  StrRef = StrRef.drop_front().drop_back();
5430 
5431  // Validate GUID length.
5432  if (StrRef.size() != 36) {
5433  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5434  return;
5435  }
5436 
5437  for (unsigned i = 0; i < 36; ++i) {
5438  if (i == 8 || i == 13 || i == 18 || i == 23) {
5439  if (StrRef[i] != '-') {
5440  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5441  return;
5442  }
5443  } else if (!isHexDigit(StrRef[i])) {
5444  S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5445  return;
5446  }
5447  }
5448 
5449  // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's
5450  // the only thing in the [] list, the [] too), and add an insertion of
5451  // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas
5452  // separating attributes nor of the [ and the ] are in the AST.
5453  // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc"
5454  // on cfe-dev.
5455  if (AL.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.
5456  S.Diag(AL.getLoc(), diag::warn_atl_uuid_deprecated);
5457 
5458  UuidAttr *UA = S.mergeUuidAttr(D, AL.getRange(),
5459  AL.getAttributeSpellingListIndex(), StrRef);
5460  if (UA)
5461  D->addAttr(UA);
5462 }
5463 
5464 static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5465  if (!S.LangOpts.CPlusPlus) {
5466  S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5467  << AL << AttributeLangSupport::C;
5468  return;
5469  }
5470  MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
5471  D, AL.getRange(), /*BestCase=*/true,
5473  (MSInheritanceAttr::Spelling)AL.getSemanticSpelling());
5474  if (IA) {
5475  D->addAttr(IA);
5476  S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
5477  }
5478 }
5479 
5480 static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5481  const auto *VD = cast<VarDecl>(D);
5482  if (!S.Context.getTargetInfo().isTLSSupported()) {
5483  S.Diag(AL.getLoc(), diag::err_thread_unsupported);
5484  return;
5485  }
5486  if (VD->getTSCSpec() != TSCS_unspecified) {
5487  S.Diag(AL.getLoc(), diag::err_declspec_thread_on_thread_variable);
5488  return;
5489  }
5490  if (VD->hasLocalStorage()) {
5491  S.Diag(AL.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
5492  return;
5493  }
5494  D->addAttr(::new (S.Context) ThreadAttr(AL.getRange(), S.Context,
5496 }
5497 
5498 static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5500  for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
5501  StringRef Tag;
5502  if (!S.checkStringLiteralArgumentAttr(AL, I, Tag))
5503  return;
5504  Tags.push_back(Tag);
5505  }
5506 
5507  if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
5508  if (!NS->isInline()) {
5509  S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5510  return;
5511  }
5512  if (NS->isAnonymousNamespace()) {
5513  S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5514  return;
5515  }
5516  if (AL.getNumArgs() == 0)
5517  Tags.push_back(NS->getName());
5518  } else if (!checkAttributeAtLeastNumArgs(S, AL, 1))
5519  return;
5520 
5521  // Store tags sorted and without duplicates.
5522  llvm::sort(Tags);
5523  Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5524 
5525  D->addAttr(::new (S.Context)
5526  AbiTagAttr(AL.getRange(), S.Context, Tags.data(), Tags.size(),
5528 }
5529 
5530 static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5531  // Check the attribute arguments.
5532  if (AL.getNumArgs() > 1) {
5533  S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
5534  return;
5535  }
5536 
5537  StringRef Str;
5538  SourceLocation ArgLoc;
5539 
5540  if (AL.getNumArgs() == 0)
5541  Str = "";
5542  else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5543  retu