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