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