contrib/llvm/tools/clang/lib/Sema/SemaDeclAttr.cpp

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