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   const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
3306   // Diagnostic is emitted elsewhere: here we store the (valid) Attr
3307   // in the Decl node for syntactic reasoning, e.g., pretty-printing.
3308   CallingConv CC;
3309   if (S.CheckCallingConvAttr(Attr, CC, FD))
3310     return;
3311
3312   if (!isa<ObjCMethodDecl>(D)) {
3313     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3314       << Attr.getName() << ExpectedFunctionOrMethod;
3315     return;
3316   }
3317
3318   switch (Attr.getKind()) {
3319   case AttributeList::AT_FastCall:
3320     D->addAttr(::new (S.Context)
3321                FastCallAttr(Attr.getRange(), S.Context,
3322                             Attr.getAttributeSpellingListIndex()));
3323     return;
3324   case AttributeList::AT_StdCall:
3325     D->addAttr(::new (S.Context)
3326                StdCallAttr(Attr.getRange(), S.Context,
3327                            Attr.getAttributeSpellingListIndex()));
3328     return;
3329   case AttributeList::AT_ThisCall:
3330     D->addAttr(::new (S.Context)
3331                ThisCallAttr(Attr.getRange(), S.Context,
3332                             Attr.getAttributeSpellingListIndex()));
3333     return;
3334   case AttributeList::AT_CDecl:
3335     D->addAttr(::new (S.Context)
3336                CDeclAttr(Attr.getRange(), S.Context,
3337                          Attr.getAttributeSpellingListIndex()));
3338     return;
3339   case AttributeList::AT_Pascal:
3340     D->addAttr(::new (S.Context)
3341                PascalAttr(Attr.getRange(), S.Context,
3342                           Attr.getAttributeSpellingListIndex()));
3343     return;
3344   case AttributeList::AT_VectorCall:
3345     D->addAttr(::new (S.Context)
3346                VectorCallAttr(Attr.getRange(), S.Context,
3347                               Attr.getAttributeSpellingListIndex()));
3348     return;
3349   case AttributeList::AT_MSABI:
3350     D->addAttr(::new (S.Context)
3351                MSABIAttr(Attr.getRange(), S.Context,
3352                          Attr.getAttributeSpellingListIndex()));
3353     return;
3354   case AttributeList::AT_SysVABI:
3355     D->addAttr(::new (S.Context)
3356                SysVABIAttr(Attr.getRange(), S.Context,
3357                            Attr.getAttributeSpellingListIndex()));
3358     return;
3359   case AttributeList::AT_Pcs: {
3360     PcsAttr::PCSType PCS;
3361     switch (CC) {
3362     case CC_AAPCS:
3363       PCS = PcsAttr::AAPCS;
3364       break;
3365     case CC_AAPCS_VFP:
3366       PCS = PcsAttr::AAPCS_VFP;
3367       break;
3368     default:
3369       llvm_unreachable("unexpected calling convention in pcs attribute");
3370     }
3371
3372     D->addAttr(::new (S.Context)
3373                PcsAttr(Attr.getRange(), S.Context, PCS,
3374                        Attr.getAttributeSpellingListIndex()));
3375     return;
3376   }
3377   case AttributeList::AT_IntelOclBicc:
3378     D->addAttr(::new (S.Context)
3379                IntelOclBiccAttr(Attr.getRange(), S.Context,
3380                                 Attr.getAttributeSpellingListIndex()));
3381     return;
3382
3383   default:
3384     llvm_unreachable("unexpected attribute kind");
3385   }
3386 }
3387
3388 bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
3389                                 const FunctionDecl *FD) {
3390   if (attr.isInvalid())
3391     return true;
3392
3393   unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0;
3394   if (!checkAttributeNumArgs(*this, attr, ReqArgs)) {
3395     attr.setInvalid();
3396     return true;
3397   }
3398
3399   // TODO: diagnose uses of these conventions on the wrong target.
3400   switch (attr.getKind()) {
3401   case AttributeList::AT_CDecl: CC = CC_C; break;
3402   case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
3403   case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
3404   case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
3405   case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
3406   case AttributeList::AT_VectorCall: CC = CC_X86VectorCall; break;
3407   case AttributeList::AT_MSABI:
3408     CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
3409                                                              CC_X86_64Win64;
3410     break;
3411   case AttributeList::AT_SysVABI:
3412     CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
3413                                                              CC_C;
3414     break;
3415   case AttributeList::AT_Pcs: {
3416     StringRef StrRef;
3417     if (!checkStringLiteralArgumentAttr(attr, 0, StrRef)) {
3418       attr.setInvalid();
3419       return true;
3420     }
3421     if (StrRef == "aapcs") {
3422       CC = CC_AAPCS;
3423       break;
3424     } else if (StrRef == "aapcs-vfp") {
3425       CC = CC_AAPCS_VFP;
3426       break;
3427     }
3428
3429     attr.setInvalid();
3430     Diag(attr.getLoc(), diag::err_invalid_pcs);
3431     return true;
3432   }
3433   case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
3434   default: llvm_unreachable("unexpected attribute kind");
3435   }
3436
3437   const TargetInfo &TI = Context.getTargetInfo();
3438   TargetInfo::CallingConvCheckResult A = TI.checkCallingConvention(CC);
3439   if (A != TargetInfo::CCCR_OK) {
3440     if (A == TargetInfo::CCCR_Warning)
3441       Diag(attr.getLoc(), diag::warn_cconv_ignored) << attr.getName();
3442
3443     // This convention is not valid for the target. Use the default function or
3444     // method calling convention.
3445     TargetInfo::CallingConvMethodType MT = TargetInfo::CCMT_Unknown;
3446     if (FD)
3447       MT = FD->isCXXInstanceMember() ? TargetInfo::CCMT_Member :
3448                                     TargetInfo::CCMT_NonMember;
3449     CC = TI.getDefaultCallingConv(MT);
3450   }
3451
3452   return false;
3453 }
3454
3455 /// Checks a regparm attribute, returning true if it is ill-formed and
3456 /// otherwise setting numParams to the appropriate value.
3457 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3458   if (Attr.isInvalid())
3459     return true;
3460
3461   if (!checkAttributeNumArgs(*this, Attr, 1)) {
3462     Attr.setInvalid();
3463     return true;
3464   }
3465
3466   uint32_t NP;
3467   Expr *NumParamsExpr = Attr.getArgAsExpr(0);
3468   if (!checkUInt32Argument(*this, Attr, NumParamsExpr, NP)) {
3469     Attr.setInvalid();
3470     return true;
3471   }
3472
3473   if (Context.getTargetInfo().getRegParmMax() == 0) {
3474     Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
3475       << NumParamsExpr->getSourceRange();
3476     Attr.setInvalid();
3477     return true;
3478   }
3479
3480   numParams = NP;
3481   if (numParams > Context.getTargetInfo().getRegParmMax()) {
3482     Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
3483       << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
3484     Attr.setInvalid();
3485     return true;
3486   }
3487
3488   return false;
3489 }
3490
3491 // Checks whether an argument of launch_bounds attribute is acceptable
3492 // May output an error.
3493 static bool checkLaunchBoundsArgument(Sema &S, Expr *E,
3494                                       const CUDALaunchBoundsAttr &Attr,
3495                                       const unsigned Idx) {
3496
3497   if (S.DiagnoseUnexpandedParameterPack(E))
3498     return false;
3499
3500   // Accept template arguments for now as they depend on something else.
3501   // We'll get to check them when they eventually get instantiated.
3502   if (E->isValueDependent())
3503     return true;
3504
3505   llvm::APSInt I(64);
3506   if (!E->isIntegerConstantExpr(I, S.Context)) {
3507     S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
3508         << &Attr << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
3509     return false;
3510   }
3511   // Make sure we can fit it in 32 bits.
3512   if (!I.isIntN(32)) {
3513     S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
3514                                                      << 32 << /* Unsigned */ 1;
3515     return false;
3516   }
3517   if (I < 0)
3518     S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
3519         << &Attr << Idx << E->getSourceRange();
3520
3521   return true;
3522 }
3523
3524 void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
3525                                Expr *MinBlocks, unsigned SpellingListIndex) {
3526   CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
3527                                SpellingListIndex);
3528
3529   if (!checkLaunchBoundsArgument(*this, MaxThreads, TmpAttr, 0))
3530     return;
3531
3532   if (MinBlocks && !checkLaunchBoundsArgument(*this, MinBlocks, TmpAttr, 1))
3533     return;
3534
3535   D->addAttr(::new (Context) CUDALaunchBoundsAttr(
3536       AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
3537 }
3538
3539 static void handleLaunchBoundsAttr(Sema &S, Decl *D,
3540                                    const AttributeList &Attr) {
3541   if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
3542       !checkAttributeAtMostNumArgs(S, Attr, 2))
3543     return;
3544
3545   S.AddLaunchBoundsAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
3546                         Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr,
3547                         Attr.getAttributeSpellingListIndex());
3548 }
3549
3550 static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
3551                                           const AttributeList &Attr) {
3552   if (!Attr.isArgIdent(0)) {
3553     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3554       << Attr.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
3555     return;
3556   }
3557
3558   if (!checkAttributeNumArgs(S, Attr, 3))
3559     return;
3560
3561   IdentifierInfo *ArgumentKind = Attr.getArgAsIdent(0)->Ident;
3562
3563   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
3564     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3565       << Attr.getName() << ExpectedFunctionOrMethod;
3566     return;
3567   }
3568
3569   uint64_t ArgumentIdx;
3570   if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 2, Attr.getArgAsExpr(1),
3571                                            ArgumentIdx))
3572     return;
3573
3574   uint64_t TypeTagIdx;
3575   if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 3, Attr.getArgAsExpr(2),
3576                                            TypeTagIdx))
3577     return;
3578
3579   bool IsPointer = (Attr.getName()->getName() == "pointer_with_type_tag");
3580   if (IsPointer) {
3581     // Ensure that buffer has a pointer type.
3582     QualType BufferTy = getFunctionOrMethodParamType(D, ArgumentIdx);
3583     if (!BufferTy->isPointerType()) {
3584       S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
3585         << Attr.getName();
3586     }
3587   }
3588
3589   D->addAttr(::new (S.Context)
3590              ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
3591                                      ArgumentIdx, TypeTagIdx, IsPointer,
3592                                      Attr.getAttributeSpellingListIndex()));
3593 }
3594
3595 static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
3596                                          const AttributeList &Attr) {
3597   if (!Attr.isArgIdent(0)) {
3598     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3599       << Attr.getName() << 1 << AANT_ArgumentIdentifier;
3600     return;
3601   }
3602
3603   if (!checkAttributeNumArgs(S, Attr, 1))
3604     return;
3605
3606   if (!isa<VarDecl>(D)) {
3607     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3608       << Attr.getName() << ExpectedVariable;
3609     return;
3610   }
3611
3612   IdentifierInfo *PointerKind = Attr.getArgAsIdent(0)->Ident;
3613   TypeSourceInfo *MatchingCTypeLoc = nullptr;
3614   S.GetTypeFromParser(Attr.getMatchingCType(), &MatchingCTypeLoc);
3615   assert(MatchingCTypeLoc && "no type source info for attribute argument");
3616
3617   D->addAttr(::new (S.Context)
3618              TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
3619                                     MatchingCTypeLoc,
3620                                     Attr.getLayoutCompatible(),
3621                                     Attr.getMustBeNull(),
3622                                     Attr.getAttributeSpellingListIndex()));
3623 }
3624
3625 //===----------------------------------------------------------------------===//
3626 // Checker-specific attribute handlers.
3627 //===----------------------------------------------------------------------===//
3628
3629 static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType type) {
3630   return type->isDependentType() ||
3631          type->isObjCRetainableType();
3632 }
3633
3634 static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
3635   return type->isDependentType() ||
3636          type->isObjCObjectPointerType() ||
3637          S.Context.isObjCNSObjectType(type);
3638 }
3639 static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
3640   return type->isDependentType() ||
3641          type->isPointerType() ||
3642          isValidSubjectOfNSAttribute(S, type);
3643 }
3644
3645 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3646   ParmVarDecl *param = cast<ParmVarDecl>(D);
3647   bool typeOK, cf;
3648
3649   if (Attr.getKind() == AttributeList::AT_NSConsumed) {
3650     typeOK = isValidSubjectOfNSAttribute(S, param->getType());
3651     cf = false;
3652   } else {
3653     typeOK = isValidSubjectOfCFAttribute(S, param->getType());
3654     cf = true;
3655   }
3656
3657   if (!typeOK) {
3658     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3659       << Attr.getRange() << Attr.getName() << cf;
3660     return;
3661   }
3662
3663   if (cf)
3664     param->addAttr(::new (S.Context)
3665                    CFConsumedAttr(Attr.getRange(), S.Context,
3666                                   Attr.getAttributeSpellingListIndex()));
3667   else
3668     param->addAttr(::new (S.Context)
3669                    NSConsumedAttr(Attr.getRange(), S.Context,
3670                                   Attr.getAttributeSpellingListIndex()));
3671 }
3672
3673 static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
3674                                         const AttributeList &Attr) {
3675
3676   QualType returnType;
3677
3678   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
3679     returnType = MD->getReturnType();
3680   else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
3681            (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
3682     return; // ignore: was handled as a type attribute
3683   else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
3684     returnType = PD->getType();
3685   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
3686     returnType = FD->getReturnType();
3687   else {
3688     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3689         << Attr.getRange() << Attr.getName()
3690         << ExpectedFunctionOrMethod;
3691     return;
3692   }
3693
3694   bool typeOK;
3695   bool cf;
3696   switch (Attr.getKind()) {
3697   default: llvm_unreachable("invalid ownership attribute");
3698   case AttributeList::AT_NSReturnsRetained:
3699     typeOK = isValidSubjectOfNSReturnsRetainedAttribute(returnType);
3700     cf = false;
3701     break;
3702
3703   case AttributeList::AT_NSReturnsAutoreleased:
3704   case AttributeList::AT_NSReturnsNotRetained:
3705     typeOK = isValidSubjectOfNSAttribute(S, returnType);
3706     cf = false;
3707     break;
3708
3709   case AttributeList::AT_CFReturnsRetained:
3710   case AttributeList::AT_CFReturnsNotRetained:
3711     typeOK = isValidSubjectOfCFAttribute(S, returnType);
3712     cf = true;
3713     break;
3714   }
3715
3716   if (!typeOK) {
3717     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3718       << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
3719     return;
3720   }
3721
3722   switch (Attr.getKind()) {
3723     default:
3724       llvm_unreachable("invalid ownership attribute");
3725     case AttributeList::AT_NSReturnsAutoreleased:
3726       D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
3727           Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3728       return;
3729     case AttributeList::AT_CFReturnsNotRetained:
3730       D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
3731           Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3732       return;
3733     case AttributeList::AT_NSReturnsNotRetained:
3734       D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
3735           Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3736       return;
3737     case AttributeList::AT_CFReturnsRetained:
3738       D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
3739           Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3740       return;
3741     case AttributeList::AT_NSReturnsRetained:
3742       D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
3743           Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
3744       return;
3745   };
3746 }
3747
3748 static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
3749                                               const AttributeList &attr) {
3750   const int EP_ObjCMethod = 1;
3751   const int EP_ObjCProperty = 2;
3752
3753   SourceLocation loc = attr.getLoc();
3754   QualType resultType;
3755   if (isa<ObjCMethodDecl>(D))
3756     resultType = cast<ObjCMethodDecl>(D)->getReturnType();
3757   else
3758     resultType = cast<ObjCPropertyDecl>(D)->getType();
3759
3760   if (!resultType->isReferenceType() &&
3761       (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
3762     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3763       << SourceRange(loc)
3764     << attr.getName()
3765     << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
3766     << /*non-retainable pointer*/ 2;
3767
3768     // Drop the attribute.
3769     return;
3770   }
3771
3772   D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
3773       attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
3774 }
3775
3776 static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
3777                                         const AttributeList &attr) {
3778   ObjCMethodDecl *method = cast<ObjCMethodDecl>(D);
3779
3780   DeclContext *DC = method->getDeclContext();
3781   if (const ObjCProtocolDecl *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
3782     S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
3783     << attr.getName() << 0;
3784     S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
3785     return;
3786   }
3787   if (method->getMethodFamily() == OMF_dealloc) {
3788     S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
3789     << attr.getName() << 1;
3790     return;
3791   }
3792
3793   method->addAttr(::new (S.Context)
3794                   ObjCRequiresSuperAttr(attr.getRange(), S.Context,
3795                                         attr.getAttributeSpellingListIndex()));
3796 }
3797
3798 static void handleCFAuditedTransferAttr(Sema &S, Decl *D,
3799                                         const AttributeList &Attr) {
3800   if (checkAttrMutualExclusion<CFUnknownTransferAttr>(S, D, Attr))
3801     return;
3802
3803   D->addAttr(::new (S.Context)
3804              CFAuditedTransferAttr(Attr.getRange(), S.Context,
3805                                    Attr.getAttributeSpellingListIndex()));
3806 }
3807
3808 static void handleCFUnknownTransferAttr(Sema &S, Decl *D,
3809                                         const AttributeList &Attr) {
3810   if (checkAttrMutualExclusion<CFAuditedTransferAttr>(S, D, Attr))
3811     return;
3812
3813   D->addAttr(::new (S.Context)
3814              CFUnknownTransferAttr(Attr.getRange(), S.Context,
3815              Attr.getAttributeSpellingListIndex()));
3816 }
3817
3818 static void handleObjCBridgeAttr(Sema &S, Scope *Sc, Decl *D,
3819                                 const AttributeList &Attr) {
3820   IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3821
3822   if (!Parm) {
3823     S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3824     return;
3825   }
3826
3827   // Typedefs only allow objc_bridge(id) and have some additional checking.
3828   if (auto TD = dyn_cast<TypedefNameDecl>(D)) {
3829     if (!Parm->Ident->isStr("id")) {
3830       S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_id)
3831         << Attr.getName();
3832       return;
3833     }
3834
3835     // Only allow 'cv void *'.
3836     QualType T = TD->getUnderlyingType();
3837     if (!T->isVoidPointerType()) {
3838       S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
3839       return;
3840     }
3841   }
3842
3843   D->addAttr(::new (S.Context)
3844              ObjCBridgeAttr(Attr.getRange(), S.Context, Parm->Ident,
3845                            Attr.getAttributeSpellingListIndex()));
3846 }
3847
3848 static void handleObjCBridgeMutableAttr(Sema &S, Scope *Sc, Decl *D,
3849                                         const AttributeList &Attr) {
3850   IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
3851
3852   if (!Parm) {
3853     S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3854     return;
3855   }
3856
3857   D->addAttr(::new (S.Context)
3858              ObjCBridgeMutableAttr(Attr.getRange(), S.Context, Parm->Ident,
3859                             Attr.getAttributeSpellingListIndex()));
3860 }
3861
3862 static void handleObjCBridgeRelatedAttr(Sema &S, Scope *Sc, Decl *D,
3863                                  const AttributeList &Attr) {
3864   IdentifierInfo *RelatedClass =
3865     Attr.isArgIdent(0) ? Attr.getArgAsIdent(0)->Ident : nullptr;
3866   if (!RelatedClass) {
3867     S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
3868     return;
3869   }
3870   IdentifierInfo *ClassMethod =
3871     Attr.getArgAsIdent(1) ? Attr.getArgAsIdent(1)->Ident : nullptr;
3872   IdentifierInfo *InstanceMethod =
3873     Attr.getArgAsIdent(2) ? Attr.getArgAsIdent(2)->Ident : nullptr;
3874   D->addAttr(::new (S.Context)
3875              ObjCBridgeRelatedAttr(Attr.getRange(), S.Context, RelatedClass,
3876                                    ClassMethod, InstanceMethod,
3877                                    Attr.getAttributeSpellingListIndex()));
3878 }
3879
3880 static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
3881                                             const AttributeList &Attr) {
3882   ObjCInterfaceDecl *IFace;
3883   if (ObjCCategoryDecl *CatDecl =
3884           dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
3885     IFace = CatDecl->getClassInterface();
3886   else
3887     IFace = cast<ObjCInterfaceDecl>(D->getDeclContext());
3888
3889   if (!IFace)
3890     return;
3891
3892   IFace->setHasDesignatedInitializers();
3893   D->addAttr(::new (S.Context)
3894                   ObjCDesignatedInitializerAttr(Attr.getRange(), S.Context,
3895                                          Attr.getAttributeSpellingListIndex()));
3896 }
3897
3898 static void handleObjCRuntimeName(Sema &S, Decl *D,
3899                                   const AttributeList &Attr) {
3900   StringRef MetaDataName;
3901   if (!S.checkStringLiteralArgumentAttr(Attr, 0, MetaDataName))
3902     return;
3903   D->addAttr(::new (S.Context)
3904              ObjCRuntimeNameAttr(Attr.getRange(), S.Context,
3905                                  MetaDataName,
3906                                  Attr.getAttributeSpellingListIndex()));
3907 }
3908
3909 static void handleObjCOwnershipAttr(Sema &S, Decl *D,
3910                                     const AttributeList &Attr) {
3911   if (hasDeclarator(D)) return;
3912
3913   S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3914     << Attr.getRange() << Attr.getName() << ExpectedVariable;
3915 }
3916
3917 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
3918                                           const AttributeList &Attr) {
3919   ValueDecl *vd = cast<ValueDecl>(D);
3920   QualType type = vd->getType();
3921
3922   if (!type->isDependentType() &&
3923       !type->isObjCLifetimeType()) {
3924     S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
3925       << type;
3926     return;
3927   }
3928
3929   Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
3930
3931   // If we have no lifetime yet, check the lifetime we're presumably
3932   // going to infer.
3933   if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
3934     lifetime = type->getObjCARCImplicitLifetime();
3935
3936   switch (lifetime) {
3937   case Qualifiers::OCL_None:
3938     assert(type->isDependentType() &&
3939            "didn't infer lifetime for non-dependent type?");
3940     break;
3941
3942   case Qualifiers::OCL_Weak:   // meaningful
3943   case Qualifiers::OCL_Strong: // meaningful
3944     break;
3945
3946   case Qualifiers::OCL_ExplicitNone:
3947   case Qualifiers::OCL_Autoreleasing:
3948     S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
3949       << (lifetime == Qualifiers::OCL_Autoreleasing);
3950     break;
3951   }
3952
3953   D->addAttr(::new (S.Context)
3954              ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
3955                                      Attr.getAttributeSpellingListIndex()));
3956 }
3957
3958 //===----------------------------------------------------------------------===//
3959 // Microsoft specific attribute handlers.
3960 //===----------------------------------------------------------------------===//
3961
3962 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3963   if (!S.LangOpts.CPlusPlus) {
3964     S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
3965       << Attr.getName() << AttributeLangSupport::C;
3966     return;
3967   }
3968
3969   if (!isa<CXXRecordDecl>(D)) {
3970     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3971       << Attr.getName() << ExpectedClass;
3972     return;
3973   }
3974
3975   StringRef StrRef;
3976   SourceLocation LiteralLoc;
3977   if (!S.checkStringLiteralArgumentAttr(Attr, 0, StrRef, &LiteralLoc))
3978     return;
3979
3980   // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
3981   // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
3982   if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
3983     StrRef = StrRef.drop_front().drop_back();
3984
3985   // Validate GUID length.
3986   if (StrRef.size() != 36) {
3987     S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
3988     return;
3989   }
3990
3991   for (unsigned i = 0; i < 36; ++i) {
3992     if (i == 8 || i == 13 || i == 18 || i == 23) {
3993       if (StrRef[i] != '-') {
3994         S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
3995         return;
3996       }
3997     } else if (!isHexDigit(StrRef[i])) {
3998       S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
3999       return;
4000     }
4001   }
4002
4003   D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context, StrRef,
4004                                         Attr.getAttributeSpellingListIndex()));
4005 }
4006
4007 static void handleMSInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4008   if (!S.LangOpts.CPlusPlus) {
4009     S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
4010       << Attr.getName() << AttributeLangSupport::C;
4011     return;
4012   }
4013   MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
4014       D, Attr.getRange(), /*BestCase=*/true,
4015       Attr.getAttributeSpellingListIndex(),
4016       (MSInheritanceAttr::Spelling)Attr.getSemanticSpelling());
4017   if (IA)
4018     D->addAttr(IA);
4019 }
4020
4021 static void handleDeclspecThreadAttr(Sema &S, Decl *D,
4022                                      const AttributeList &Attr) {
4023   VarDecl *VD = cast<VarDecl>(D);
4024   if (!S.Context.getTargetInfo().isTLSSupported()) {
4025     S.Diag(Attr.getLoc(), diag::err_thread_unsupported);
4026     return;
4027   }
4028   if (VD->getTSCSpec() != TSCS_unspecified) {
4029     S.Diag(Attr.getLoc(), diag::err_declspec_thread_on_thread_variable);
4030     return;
4031   }
4032   if (VD->hasLocalStorage()) {
4033     S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
4034     return;
4035   }
4036   VD->addAttr(::new (S.Context) ThreadAttr(
4037       Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4038 }
4039
4040 static void handleARMInterruptAttr(Sema &S, Decl *D,
4041                                    const AttributeList &Attr) {
4042   // Check the attribute arguments.
4043   if (Attr.getNumArgs() > 1) {
4044     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
4045       << Attr.getName() << 1;
4046     return;
4047   }
4048
4049   StringRef Str;
4050   SourceLocation ArgLoc;
4051
4052   if (Attr.getNumArgs() == 0)
4053     Str = "";
4054   else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
4055     return;
4056
4057   ARMInterruptAttr::InterruptType Kind;
4058   if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
4059     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
4060       << Attr.getName() << Str << ArgLoc;
4061     return;
4062   }
4063
4064   unsigned Index = Attr.getAttributeSpellingListIndex();
4065   D->addAttr(::new (S.Context)
4066              ARMInterruptAttr(Attr.getLoc(), S.Context, Kind, Index));
4067 }
4068
4069 static void handleMSP430InterruptAttr(Sema &S, Decl *D,
4070                                       const AttributeList &Attr) {
4071   if (!checkAttributeNumArgs(S, Attr, 1))
4072     return;
4073
4074   if (!Attr.isArgExpr(0)) {
4075     S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
4076       << AANT_ArgumentIntegerConstant;
4077     return;
4078   }
4079
4080   // FIXME: Check for decl - it should be void ()(void).
4081
4082   Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4083   llvm::APSInt NumParams(32);
4084   if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
4085     S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
4086       << Attr.getName() << AANT_ArgumentIntegerConstant
4087       << NumParamsExpr->getSourceRange();
4088     return;
4089   }
4090
4091   unsigned Num = NumParams.getLimitedValue(255);
4092   if ((Num & 1) || Num > 30) {
4093     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
4094       << Attr.getName() << (int)NumParams.getSExtValue()
4095       << NumParamsExpr->getSourceRange();
4096     return;
4097   }
4098
4099   D->addAttr(::new (S.Context)
4100               MSP430InterruptAttr(Attr.getLoc(), S.Context, Num,
4101                                   Attr.getAttributeSpellingListIndex()));
4102   D->addAttr(UsedAttr::CreateImplicit(S.Context));
4103 }
4104
4105 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4106   // Dispatch the interrupt attribute based on the current target.
4107   if (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::msp430)
4108     handleMSP430InterruptAttr(S, D, Attr);
4109   else
4110     handleARMInterruptAttr(S, D, Attr);
4111 }
4112
4113 static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D,
4114                                     const AttributeList &Attr) {
4115   uint32_t NumRegs;
4116   Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4117   if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4118     return;
4119
4120   D->addAttr(::new (S.Context)
4121              AMDGPUNumVGPRAttr(Attr.getLoc(), S.Context,
4122                                NumRegs,
4123                                Attr.getAttributeSpellingListIndex()));
4124 }
4125
4126 static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D,
4127                                     const AttributeList &Attr) {
4128   uint32_t NumRegs;
4129   Expr *NumRegsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
4130   if (!checkUInt32Argument(S, Attr, NumRegsExpr, NumRegs))
4131     return;
4132
4133   D->addAttr(::new (S.Context)
4134              AMDGPUNumSGPRAttr(Attr.getLoc(), S.Context,
4135                                NumRegs,
4136                                Attr.getAttributeSpellingListIndex()));
4137 }
4138
4139 static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
4140                                               const AttributeList& Attr) {
4141   // If we try to apply it to a function pointer, don't warn, but don't
4142   // do anything, either. It doesn't matter anyway, because there's nothing
4143   // special about calling a force_align_arg_pointer function.
4144   ValueDecl *VD = dyn_cast<ValueDecl>(D);
4145   if (VD && VD->getType()->isFunctionPointerType())
4146     return;
4147   // Also don't warn on function pointer typedefs.
4148   TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
4149   if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
4150     TD->getUnderlyingType()->isFunctionType()))
4151     return;
4152   // Attribute can only be applied to function types.
4153   if (!isa<FunctionDecl>(D)) {
4154     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4155       << Attr.getName() << /* function */0;
4156     return;
4157   }
4158
4159   D->addAttr(::new (S.Context)
4160               X86ForceAlignArgPointerAttr(Attr.getRange(), S.Context,
4161                                         Attr.getAttributeSpellingListIndex()));
4162 }
4163
4164 DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
4165                                         unsigned AttrSpellingListIndex) {
4166   if (D->hasAttr<DLLExportAttr>()) {
4167     Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
4168     return nullptr;
4169   }
4170
4171   if (D->hasAttr<DLLImportAttr>())
4172     return nullptr;
4173
4174   return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
4175 }
4176
4177 DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
4178                                         unsigned AttrSpellingListIndex) {
4179   if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
4180     Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
4181     D->dropAttr<DLLImportAttr>();
4182   }
4183
4184   if (D->hasAttr<DLLExportAttr>())
4185     return nullptr;
4186
4187   return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
4188 }
4189
4190 static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A) {
4191   if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
4192       S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
4193     S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
4194         << A.getName();
4195     return;
4196   }
4197
4198   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
4199     if (FD->isInlined() && A.getKind() == AttributeList::AT_DLLImport &&
4200         !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
4201       // MinGW doesn't allow dllimport on inline functions.
4202       S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
4203           << A.getName();
4204       return;
4205     }
4206   }
4207
4208   unsigned Index = A.getAttributeSpellingListIndex();
4209   Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
4210                       ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
4211                       : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
4212   if (NewAttr)
4213     D->addAttr(NewAttr);
4214 }
4215
4216 MSInheritanceAttr *
4217 Sema::mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
4218                              unsigned AttrSpellingListIndex,
4219                              MSInheritanceAttr::Spelling SemanticSpelling) {
4220   if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
4221     if (IA->getSemanticSpelling() == SemanticSpelling)
4222       return nullptr;
4223     Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
4224         << 1 /*previous declaration*/;
4225     Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
4226     D->dropAttr<MSInheritanceAttr>();
4227   }
4228
4229   CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
4230   if (RD->hasDefinition()) {
4231     if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
4232                                            SemanticSpelling)) {
4233       return nullptr;
4234     }
4235   } else {
4236     if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
4237       Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
4238           << 1 /*partial specialization*/;
4239       return nullptr;
4240     }
4241     if (RD->getDescribedClassTemplate()) {
4242       Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
4243           << 0 /*primary template*/;
4244       return nullptr;
4245     }
4246   }
4247
4248   return ::new (Context)
4249       MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
4250 }
4251
4252 static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4253   // The capability attributes take a single string parameter for the name of
4254   // the capability they represent. The lockable attribute does not take any
4255   // parameters. However, semantically, both attributes represent the same
4256   // concept, and so they use the same semantic attribute. Eventually, the
4257   // lockable attribute will be removed.
4258   //
4259   // For backward compatibility, any capability which has no specified string
4260   // literal will be considered a "mutex."
4261   StringRef N("mutex");
4262   SourceLocation LiteralLoc;
4263   if (Attr.getKind() == AttributeList::AT_Capability &&
4264       !S.checkStringLiteralArgumentAttr(Attr, 0, N, &LiteralLoc))
4265     return;
4266
4267   // Currently, there are only two names allowed for a capability: role and
4268   // mutex (case insensitive). Diagnose other capability names.
4269   if (!N.equals_lower("mutex") && !N.equals_lower("role"))
4270     S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
4271
4272   D->addAttr(::new (S.Context) CapabilityAttr(Attr.getRange(), S.Context, N,
4273                                         Attr.getAttributeSpellingListIndex()));
4274 }
4275
4276 static void handleAssertCapabilityAttr(Sema &S, Decl *D,
4277                                        const AttributeList &Attr) {
4278   D->addAttr(::new (S.Context) AssertCapabilityAttr(Attr.getRange(), S.Context,
4279                                                     Attr.getArgAsExpr(0),
4280                                         Attr.getAttributeSpellingListIndex()));
4281 }
4282
4283 static void handleAcquireCapabilityAttr(Sema &S, Decl *D,
4284                                         const AttributeList &Attr) {
4285   SmallVector<Expr*, 1> Args;
4286   if (!checkLockFunAttrCommon(S, D, Attr, Args))
4287     return;
4288
4289   D->addAttr(::new (S.Context) AcquireCapabilityAttr(Attr.getRange(),
4290                                                      S.Context,
4291                                                      Args.data(), Args.size(),
4292                                         Attr.getAttributeSpellingListIndex()));
4293 }
4294
4295 static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D,
4296                                            const AttributeList &Attr) {
4297   SmallVector<Expr*, 2> Args;
4298   if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
4299     return;
4300
4301   D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(Attr.getRange(),
4302                                                         S.Context,
4303                                                         Attr.getArgAsExpr(0),
4304                                                         Args.data(),
4305                                                         Args.size(),
4306                                         Attr.getAttributeSpellingListIndex()));
4307 }
4308
4309 static void handleReleaseCapabilityAttr(Sema &S, Decl *D,
4310                                         const AttributeList &Attr) {
4311   // Check that all arguments are lockable objects.
4312   SmallVector<Expr *, 1> Args;
4313   checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, true);
4314
4315   D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
4316       Attr.getRange(), S.Context, Args.data(), Args.size(),
4317       Attr.getAttributeSpellingListIndex()));
4318 }
4319
4320 static void handleRequiresCapabilityAttr(Sema &S, Decl *D,
4321                                          const AttributeList &Attr) {
4322   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4323     return;
4324
4325   // check that all arguments are lockable objects
4326   SmallVector<Expr*, 1> Args;
4327   checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
4328   if (Args.empty())
4329     return;
4330
4331   RequiresCapabilityAttr *RCA = ::new (S.Context)
4332     RequiresCapabilityAttr(Attr.getRange(), S.Context, Args.data(),
4333                            Args.size(), Attr.getAttributeSpellingListIndex());
4334
4335   D->addAttr(RCA);
4336 }
4337
4338 static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4339   if (auto *NSD = dyn_cast<NamespaceDecl>(D)) {
4340     if (NSD->isAnonymousNamespace()) {
4341       S.Diag(Attr.getLoc(), diag::warn_deprecated_anonymous_namespace);
4342       // Do not want to attach the attribute to the namespace because that will
4343       // cause confusing diagnostic reports for uses of declarations within the
4344       // namespace.
4345       return;
4346     }
4347   }
4348
4349   if (!S.getLangOpts().CPlusPlus14)
4350     if (Attr.isCXX11Attribute() &&
4351         !(Attr.hasScope() && Attr.getScopeName()->isStr("gnu")))
4352       S.Diag(Attr.getLoc(), diag::ext_deprecated_attr_is_a_cxx14_extension);
4353
4354   handleAttrWithMessage<DeprecatedAttr>(S, D, Attr);
4355 }
4356
4357 static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4358   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4359     return;
4360
4361   std::vector<std::string> Sanitizers;
4362
4363   for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
4364     StringRef SanitizerName;
4365     SourceLocation LiteralLoc;
4366
4367     if (!S.checkStringLiteralArgumentAttr(Attr, I, SanitizerName, &LiteralLoc))
4368       return;
4369
4370     if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 0)
4371       S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
4372
4373     Sanitizers.push_back(SanitizerName);
4374   }
4375
4376   D->addAttr(::new (S.Context) NoSanitizeAttr(
4377       Attr.getRange(), S.Context, Sanitizers.data(), Sanitizers.size(),
4378       Attr.getAttributeSpellingListIndex()));
4379 }
4380
4381 static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
4382                                          const AttributeList &Attr) {
4383   std::string SanitizerName =
4384       llvm::StringSwitch<std::string>(Attr.getName()->getName())
4385           .Case("no_address_safety_analysis", "address")
4386           .Case("no_sanitize_address", "address")
4387           .Case("no_sanitize_thread", "thread")
4388           .Case("no_sanitize_memory", "memory");
4389   D->addAttr(::new (S.Context)
4390                  NoSanitizeAttr(Attr.getRange(), S.Context, &SanitizerName, 1,
4391                                 Attr.getAttributeSpellingListIndex()));
4392 }
4393
4394 /// Handles semantic checking for features that are common to all attributes,
4395 /// such as checking whether a parameter was properly specified, or the correct
4396 /// number of arguments were passed, etc.
4397 static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D,
4398                                           const AttributeList &Attr) {
4399   // Several attributes carry different semantics than the parsing requires, so
4400   // those are opted out of the common handling.
4401   //
4402   // We also bail on unknown and ignored attributes because those are handled
4403   // as part of the target-specific handling logic.
4404   if (Attr.hasCustomParsing() ||
4405       Attr.getKind() == AttributeList::UnknownAttribute)
4406     return false;
4407
4408   // Check whether the attribute requires specific language extensions to be
4409   // enabled.
4410   if (!Attr.diagnoseLangOpts(S))
4411     return true;
4412
4413   if (Attr.getMinArgs() == Attr.getMaxArgs()) {
4414     // If there are no optional arguments, then checking for the argument count
4415     // is trivial.
4416     if (!checkAttributeNumArgs(S, Attr, Attr.getMinArgs()))
4417       return true;
4418   } else {
4419     // There are optional arguments, so checking is slightly more involved.
4420     if (Attr.getMinArgs() &&
4421         !checkAttributeAtLeastNumArgs(S, Attr, Attr.getMinArgs()))
4422       return true;
4423     else if (!Attr.hasVariadicArg() && Attr.getMaxArgs() &&
4424              !checkAttributeAtMostNumArgs(S, Attr, Attr.getMaxArgs()))
4425       return true;
4426   }
4427
4428   // Check whether the attribute appertains to the given subject.
4429   if (!Attr.diagnoseAppertainsTo(S, D))
4430     return true;
4431
4432   return false;
4433 }
4434
4435 //===----------------------------------------------------------------------===//
4436 // Top Level Sema Entry Points
4437 //===----------------------------------------------------------------------===//
4438
4439 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
4440 /// the attribute applies to decls.  If the attribute is a type attribute, just
4441 /// silently ignore it if a GNU attribute.
4442 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
4443                                  const AttributeList &Attr,
4444                                  bool IncludeCXX11Attributes) {
4445   if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
4446     return;
4447
4448   // Ignore C++11 attributes on declarator chunks: they appertain to the type
4449   // instead.
4450   if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
4451     return;
4452
4453   // Unknown attributes are automatically warned on. Target-specific attributes
4454   // which do not apply to the current target architecture are treated as
4455   // though they were unknown attributes.
4456   if (Attr.getKind() == AttributeList::UnknownAttribute ||
4457       !Attr.existsInTarget(S.Context.getTargetInfo().getTriple())) {
4458     S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute()
4459                               ? diag::warn_unhandled_ms_attribute_ignored
4460                               : diag::warn_unknown_attribute_ignored)
4461         << Attr.getName();
4462     return;
4463   }
4464
4465   if (handleCommonAttributeFeatures(S, scope, D, Attr))
4466     return;
4467
4468   switch (Attr.getKind()) {
4469   default:
4470     // Type attributes are handled elsewhere; silently move on.
4471     assert(Attr.isTypeAttr() && "Non-type attribute not handled");
4472     break;
4473   case AttributeList::AT_Interrupt:
4474     handleInterruptAttr(S, D, Attr);
4475     break;
4476   case AttributeList::AT_X86ForceAlignArgPointer:
4477     handleX86ForceAlignArgPointerAttr(S, D, Attr);
4478     break;
4479   case AttributeList::AT_DLLExport:
4480   case AttributeList::AT_DLLImport:
4481     handleDLLAttr(S, D, Attr);
4482     break;
4483   case AttributeList::AT_Mips16:
4484     handleSimpleAttribute<Mips16Attr>(S, D, Attr);
4485     break;
4486   case AttributeList::AT_NoMips16:
4487     handleSimpleAttribute<NoMips16Attr>(S, D, Attr);
4488     break;
4489   case AttributeList::AT_AMDGPUNumVGPR:
4490     handleAMDGPUNumVGPRAttr(S, D, Attr);
4491     break;
4492   case AttributeList::AT_AMDGPUNumSGPR:
4493     handleAMDGPUNumSGPRAttr(S, D, Attr);
4494     break;
4495   case AttributeList::AT_IBAction:
4496     handleSimpleAttribute<IBActionAttr>(S, D, Attr);
4497     break;
4498   case AttributeList::AT_IBOutlet:
4499     handleIBOutlet(S, D, Attr);
4500     break;
4501   case AttributeList::AT_IBOutletCollection:
4502     handleIBOutletCollection(S, D, Attr);
4503     break;
4504   case AttributeList::AT_Alias:
4505     handleAliasAttr(S, D, Attr);
4506     break;
4507   case AttributeList::AT_Aligned:
4508     handleAlignedAttr(S, D, Attr);
4509     break;
4510   case AttributeList::AT_AlignValue:
4511     handleAlignValueAttr(S, D, Attr);
4512     break;
4513   case AttributeList::AT_AlwaysInline:
4514     handleAlwaysInlineAttr(S, D, Attr);
4515     break;
4516   case AttributeList::AT_AnalyzerNoReturn:
4517     handleAnalyzerNoReturnAttr(S, D, Attr);
4518     break;
4519   case AttributeList::AT_TLSModel:
4520     handleTLSModelAttr(S, D, Attr);
4521     break;
4522   case AttributeList::AT_Annotate:
4523     handleAnnotateAttr(S, D, Attr);
4524     break;
4525   case AttributeList::AT_Availability:
4526     handleAvailabilityAttr(S, D, Attr);
4527     break;
4528   case AttributeList::AT_CarriesDependency:
4529     handleDependencyAttr(S, scope, D, Attr);
4530     break;
4531   case AttributeList::AT_Common:
4532     handleCommonAttr(S, D, Attr);
4533     break;
4534   case AttributeList::AT_CUDAConstant:
4535     handleSimpleAttribute<CUDAConstantAttr>(S, D, Attr);
4536     break;
4537   case AttributeList::AT_Constructor:
4538     handleConstructorAttr(S, D, Attr);
4539     break;
4540   case AttributeList::AT_CXX11NoReturn:
4541     handleSimpleAttribute<CXX11NoReturnAttr>(S, D, Attr);
4542     break;
4543   case AttributeList::AT_Deprecated:
4544     handleDeprecatedAttr(S, D, Attr);
4545     break;
4546   case AttributeList::AT_Destructor:
4547     handleDestructorAttr(S, D, Attr);
4548     break;
4549   case AttributeList::AT_EnableIf:
4550     handleEnableIfAttr(S, D, Attr);
4551     break;
4552   case AttributeList::AT_ExtVectorType:
4553     handleExtVectorTypeAttr(S, scope, D, Attr);
4554     break;
4555   case AttributeList::AT_MinSize:
4556     handleMinSizeAttr(S, D, Attr);
4557     break;
4558   case AttributeList::AT_OptimizeNone:
4559     handleOptimizeNoneAttr(S, D, Attr);
4560     break;
4561   case AttributeList::AT_FlagEnum:
4562     handleSimpleAttribute<FlagEnumAttr>(S, D, Attr);
4563     break;
4564   case AttributeList::AT_Flatten:
4565     handleSimpleAttribute<FlattenAttr>(S, D, Attr);
4566     break;
4567   case AttributeList::AT_Format:
4568     handleFormatAttr(S, D, Attr);
4569     break;
4570   case AttributeList::AT_FormatArg:
4571     handleFormatArgAttr(S, D, Attr);
4572     break;
4573   case AttributeList::AT_CUDAGlobal:
4574     handleGlobalAttr(S, D, Attr);
4575     break;
4576   case AttributeList::AT_CUDADevice:
4577     handleSimpleAttribute<CUDADeviceAttr>(S, D, Attr);
4578     break;
4579   case AttributeList::AT_CUDAHost:
4580     handleSimpleAttribute<CUDAHostAttr>(S, D, Attr);
4581     break;
4582   case AttributeList::AT_GNUInline:
4583     handleGNUInlineAttr(S, D, Attr);
4584     break;
4585   case AttributeList::AT_CUDALaunchBounds:
4586     handleLaunchBoundsAttr(S, D, Attr);
4587     break;
4588   case AttributeList::AT_Restrict:
4589     handleRestrictAttr(S, D, Attr);
4590     break;
4591   case AttributeList::AT_MayAlias:
4592     handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
4593     break;
4594   case AttributeList::AT_Mode:
4595     handleModeAttr(S, D, Attr);
4596     break;
4597   case AttributeList::AT_NoCommon:
4598     handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
4599     break;
4600   case AttributeList::AT_NoSplitStack:
4601     handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
4602     break;
4603   case AttributeList::AT_NonNull:
4604     if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D))
4605       handleNonNullAttrParameter(S, PVD, Attr);
4606     else
4607       handleNonNullAttr(S, D, Attr);
4608     break;
4609   case AttributeList::AT_ReturnsNonNull:
4610     handleReturnsNonNullAttr(S, D, Attr);
4611     break;
4612   case AttributeList::AT_AssumeAligned:
4613     handleAssumeAlignedAttr(S, D, Attr);
4614     break;
4615   case AttributeList::AT_Overloadable:
4616     handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
4617     break;
4618   case AttributeList::AT_Ownership:
4619     handleOwnershipAttr(S, D, Attr);
4620     break;
4621   case AttributeList::AT_Cold:
4622     handleColdAttr(S, D, Attr);
4623     break;
4624   case AttributeList::AT_Hot:
4625     handleHotAttr(S, D, Attr);
4626     break;
4627   case AttributeList::AT_Naked:
4628     handleSimpleAttribute<NakedAttr>(S, D, Attr);
4629     break;
4630   case AttributeList::AT_NoReturn:
4631     handleNoReturnAttr(S, D, Attr);
4632     break;
4633   case AttributeList::AT_NoThrow:
4634     handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
4635     break;
4636   case AttributeList::AT_CUDAShared:
4637     handleSimpleAttribute<CUDASharedAttr>(S, D, Attr);
4638     break;
4639   case AttributeList::AT_VecReturn:
4640     handleVecReturnAttr(S, D, Attr);
4641     break;
4642
4643   case AttributeList::AT_ObjCOwnership:
4644     handleObjCOwnershipAttr(S, D, Attr);
4645     break;
4646   case AttributeList::AT_ObjCPreciseLifetime:
4647     handleObjCPreciseLifetimeAttr(S, D, Attr);
4648     break;
4649
4650   case AttributeList::AT_ObjCReturnsInnerPointer:
4651     handleObjCReturnsInnerPointerAttr(S, D, Attr);
4652     break;
4653
4654   case AttributeList::AT_ObjCRequiresSuper:
4655     handleObjCRequiresSuperAttr(S, D, Attr);
4656     break;
4657
4658   case AttributeList::AT_ObjCBridge:
4659     handleObjCBridgeAttr(S, scope, D, Attr);
4660     break;
4661
4662   case AttributeList::AT_ObjCBridgeMutable:
4663     handleObjCBridgeMutableAttr(S, scope, D, Attr);
4664     break;
4665
4666   case AttributeList::AT_ObjCBridgeRelated:
4667     handleObjCBridgeRelatedAttr(S, scope, D, Attr);
4668     break;
4669
4670   case AttributeList::AT_ObjCDesignatedInitializer:
4671     handleObjCDesignatedInitializer(S, D, Attr);
4672     break;
4673
4674   case AttributeList::AT_ObjCRuntimeName:
4675     handleObjCRuntimeName(S, D, Attr);
4676     break;
4677
4678   case AttributeList::AT_CFAuditedTransfer:
4679     handleCFAuditedTransferAttr(S, D, Attr);
4680     break;
4681   case AttributeList::AT_CFUnknownTransfer:
4682     handleCFUnknownTransferAttr(S, D, Attr);
4683     break;
4684
4685   case AttributeList::AT_CFConsumed:
4686   case AttributeList::AT_NSConsumed:
4687     handleNSConsumedAttr(S, D, Attr);
4688     break;
4689   case AttributeList::AT_NSConsumesSelf:
4690     handleSimpleAttribute<NSConsumesSelfAttr>(S, D, Attr);
4691     break;
4692
4693   case AttributeList::AT_NSReturnsAutoreleased:
4694   case AttributeList::AT_NSReturnsNotRetained:
4695   case AttributeList::AT_CFReturnsNotRetained:
4696   case AttributeList::AT_NSReturnsRetained:
4697   case AttributeList::AT_CFReturnsRetained:
4698     handleNSReturnsRetainedAttr(S, D, Attr);
4699     break;
4700   case AttributeList::AT_WorkGroupSizeHint:
4701     handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, Attr);
4702     break;
4703   case AttributeList::AT_ReqdWorkGroupSize:
4704     handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, Attr);
4705     break;
4706   case AttributeList::AT_VecTypeHint:
4707     handleVecTypeHint(S, D, Attr);
4708     break;
4709
4710   case AttributeList::AT_InitPriority:
4711     handleInitPriorityAttr(S, D, Attr);
4712     break;
4713
4714   case AttributeList::AT_Packed:
4715     handlePackedAttr(S, D, Attr);
4716     break;
4717   case AttributeList::AT_Section:
4718     handleSectionAttr(S, D, Attr);
4719     break;
4720   case AttributeList::AT_Unavailable:
4721     handleAttrWithMessage<UnavailableAttr>(S, D, Attr);
4722     break;
4723   case AttributeList::AT_ArcWeakrefUnavailable:
4724     handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, Attr);
4725     break;
4726   case AttributeList::AT_ObjCRootClass:
4727     handleSimpleAttribute<ObjCRootClassAttr>(S, D, Attr);
4728     break;
4729   case AttributeList::AT_ObjCExplicitProtocolImpl:
4730     handleObjCSuppresProtocolAttr(S, D, Attr);
4731     break;
4732   case AttributeList::AT_ObjCRequiresPropertyDefs:
4733     handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, Attr);
4734     break;
4735   case AttributeList::AT_Unused:
4736     handleSimpleAttribute<UnusedAttr>(S, D, Attr);
4737     break;
4738   case AttributeList::AT_ReturnsTwice:
4739     handleSimpleAttribute<ReturnsTwiceAttr>(S, D, Attr);
4740     break;
4741   case AttributeList::AT_Used:
4742     handleUsedAttr(S, D, Attr);
4743     break;
4744   case AttributeList::AT_Visibility:
4745     handleVisibilityAttr(S, D, Attr, false);
4746     break;
4747   case AttributeList::AT_TypeVisibility:
4748     handleVisibilityAttr(S, D, Attr, true);
4749     break;
4750   case AttributeList::AT_WarnUnused:
4751     handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
4752     break;
4753   case AttributeList::AT_WarnUnusedResult:
4754     handleWarnUnusedResult(S, D, Attr);
4755     break;
4756   case AttributeList::AT_Weak:
4757     handleSimpleAttribute<WeakAttr>(S, D, Attr);
4758     break;
4759   case AttributeList::AT_WeakRef:
4760     handleWeakRefAttr(S, D, Attr);
4761     break;
4762   case AttributeList::AT_WeakImport:
4763     handleWeakImportAttr(S, D, Attr);
4764     break;
4765   case AttributeList::AT_TransparentUnion:
4766     handleTransparentUnionAttr(S, D, Attr);
4767     break;
4768   case AttributeList::AT_ObjCException:
4769     handleSimpleAttribute<ObjCExceptionAttr>(S, D, Attr);
4770     break;
4771   case AttributeList::AT_ObjCMethodFamily:
4772     handleObjCMethodFamilyAttr(S, D, Attr);
4773     break;
4774   case AttributeList::AT_ObjCNSObject:
4775     handleObjCNSObject(S, D, Attr);
4776     break;
4777   case AttributeList::AT_ObjCIndependentClass:
4778     handleObjCIndependentClass(S, D, Attr);
4779     break;
4780   case AttributeList::AT_Blocks:
4781     handleBlocksAttr(S, D, Attr);
4782     break;
4783   case AttributeList::AT_Sentinel:
4784     handleSentinelAttr(S, D, Attr);
4785     break;
4786   case AttributeList::AT_Const:
4787     handleSimpleAttribute<ConstAttr>(S, D, Attr);
4788     break;
4789   case AttributeList::AT_Pure:
4790     handleSimpleAttribute<PureAttr>(S, D, Attr);
4791     break;
4792   case AttributeList::AT_Cleanup:
4793     handleCleanupAttr(S, D, Attr);
4794     break;
4795   case AttributeList::AT_NoDebug:
4796     handleNoDebugAttr(S, D, Attr);
4797     break;
4798   case AttributeList::AT_NoDuplicate:
4799     handleSimpleAttribute<NoDuplicateAttr>(S, D, Attr);
4800     break;
4801   case AttributeList::AT_NoInline:
4802     handleSimpleAttribute<NoInlineAttr>(S, D, Attr);
4803     break;
4804   case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg.
4805     handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, Attr);
4806     break;
4807   case AttributeList::AT_StdCall:
4808   case AttributeList::AT_CDecl:
4809   case AttributeList::AT_FastCall:
4810   case AttributeList::AT_ThisCall:
4811   case AttributeList::AT_Pascal:
4812   case AttributeList::AT_VectorCall:
4813   case AttributeList::AT_MSABI:
4814   case AttributeList::AT_SysVABI:
4815   case AttributeList::AT_Pcs:
4816   case AttributeList::AT_IntelOclBicc:
4817     handleCallConvAttr(S, D, Attr);
4818     break;
4819   case AttributeList::AT_OpenCLKernel:
4820     handleSimpleAttribute<OpenCLKernelAttr>(S, D, Attr);
4821     break;
4822   case AttributeList::AT_OpenCLImageAccess:
4823     handleSimpleAttribute<OpenCLImageAccessAttr>(S, D, Attr);
4824     break;
4825
4826   // Microsoft attributes:
4827   case AttributeList::AT_MSNoVTable:
4828     handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
4829     break;
4830   case AttributeList::AT_MSStruct:
4831     handleSimpleAttribute<MSStructAttr>(S, D, Attr);
4832     break;
4833   case AttributeList::AT_Uuid:
4834     handleUuidAttr(S, D, Attr);
4835     break;
4836   case AttributeList::AT_MSInheritance:
4837     handleMSInheritanceAttr(S, D, Attr);
4838     break;
4839   case AttributeList::AT_SelectAny:
4840     handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
4841     break;
4842   case AttributeList::AT_Thread:
4843     handleDeclspecThreadAttr(S, D, Attr);
4844     break;
4845
4846   // Thread safety attributes:
4847   case AttributeList::AT_AssertExclusiveLock:
4848     handleAssertExclusiveLockAttr(S, D, Attr);
4849     break;
4850   case AttributeList::AT_AssertSharedLock:
4851     handleAssertSharedLockAttr(S, D, Attr);
4852     break;
4853   case AttributeList::AT_GuardedVar:
4854     handleSimpleAttribute<GuardedVarAttr>(S, D, Attr);
4855     break;
4856   case AttributeList::AT_PtGuardedVar:
4857     handlePtGuardedVarAttr(S, D, Attr);
4858     break;
4859   case AttributeList::AT_ScopedLockable:
4860     handleSimpleAttribute<ScopedLockableAttr>(S, D, Attr);
4861     break;
4862   case AttributeList::AT_NoSanitize:
4863     handleNoSanitizeAttr(S, D, Attr);
4864     break;
4865   case AttributeList::AT_NoSanitizeSpecific:
4866     handleNoSanitizeSpecificAttr(S, D, Attr);
4867     break;
4868   case AttributeList::AT_NoThreadSafetyAnalysis:
4869     handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, Attr);
4870     break;
4871   case AttributeList::AT_GuardedBy:
4872     handleGuardedByAttr(S, D, Attr);
4873     break;
4874   case AttributeList::AT_PtGuardedBy:
4875     handlePtGuardedByAttr(S, D, Attr);
4876     break;
4877   case AttributeList::AT_ExclusiveTrylockFunction:
4878     handleExclusiveTrylockFunctionAttr(S, D, Attr);
4879     break;
4880   case AttributeList::AT_LockReturned:
4881     handleLockReturnedAttr(S, D, Attr);
4882     break;
4883   case AttributeList::AT_LocksExcluded:
4884     handleLocksExcludedAttr(S, D, Attr);
4885     break;
4886   case AttributeList::AT_SharedTrylockFunction:
4887     handleSharedTrylockFunctionAttr(S, D, Attr);
4888     break;
4889   case AttributeList::AT_AcquiredBefore:
4890     handleAcquiredBeforeAttr(S, D, Attr);
4891     break;
4892   case AttributeList::AT_AcquiredAfter:
4893     handleAcquiredAfterAttr(S, D, Attr);
4894     break;
4895
4896   // Capability analysis attributes.
4897   case AttributeList::AT_Capability:
4898   case AttributeList::AT_Lockable:
4899     handleCapabilityAttr(S, D, Attr);
4900     break;
4901   case AttributeList::AT_RequiresCapability:
4902     handleRequiresCapabilityAttr(S, D, Attr);
4903     break;
4904
4905   case AttributeList::AT_AssertCapability:
4906     handleAssertCapabilityAttr(S, D, Attr);
4907     break;
4908   case AttributeList::AT_AcquireCapability:
4909     handleAcquireCapabilityAttr(S, D, Attr);
4910     break;
4911   case AttributeList::AT_ReleaseCapability:
4912     handleReleaseCapabilityAttr(S, D, Attr);
4913     break;
4914   case AttributeList::AT_TryAcquireCapability:
4915     handleTryAcquireCapabilityAttr(S, D, Attr);
4916     break;
4917
4918   // Consumed analysis attributes.
4919   case AttributeList::AT_Consumable:
4920     handleConsumableAttr(S, D, Attr);
4921     break;
4922   case AttributeList::AT_ConsumableAutoCast:
4923     handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, Attr);
4924     break;
4925   case AttributeList::AT_ConsumableSetOnRead:
4926     handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, Attr);
4927     break;
4928   case AttributeList::AT_CallableWhen:
4929     handleCallableWhenAttr(S, D, Attr);
4930     break;
4931   case AttributeList::AT_ParamTypestate:
4932     handleParamTypestateAttr(S, D, Attr);
4933     break;
4934   case AttributeList::AT_ReturnTypestate:
4935     handleReturnTypestateAttr(S, D, Attr);
4936     break;
4937   case AttributeList::AT_SetTypestate:
4938     handleSetTypestateAttr(S, D, Attr);
4939     break;
4940   case AttributeList::AT_TestTypestate:
4941     handleTestTypestateAttr(S, D, Attr);
4942     break;
4943
4944   // Type safety attributes.
4945   case AttributeList::AT_ArgumentWithTypeTag:
4946     handleArgumentWithTypeTagAttr(S, D, Attr);
4947     break;
4948   case AttributeList::AT_TypeTagForDatatype:
4949     handleTypeTagForDatatypeAttr(S, D, Attr);
4950     break;
4951   }
4952 }
4953
4954 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
4955 /// attribute list to the specified decl, ignoring any type attributes.
4956 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
4957                                     const AttributeList *AttrList,
4958                                     bool IncludeCXX11Attributes) {
4959   for (const AttributeList* l = AttrList; l; l = l->getNext())
4960     ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes);
4961
4962   // FIXME: We should be able to handle these cases in TableGen.
4963   // GCC accepts
4964   // static int a9 __attribute__((weakref));
4965   // but that looks really pointless. We reject it.
4966   if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
4967     Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias)
4968       << cast<NamedDecl>(D);
4969     D->dropAttr<WeakRefAttr>();
4970     return;
4971   }
4972
4973   // FIXME: We should be able to handle this in TableGen as well. It would be
4974   // good to have a way to specify "these attributes must appear as a group",
4975   // for these. Additionally, it would be good to have a way to specify "these
4976   // attribute must never appear as a group" for attributes like cold and hot.
4977   if (!D->hasAttr<OpenCLKernelAttr>()) {
4978     // These attributes cannot be applied to a non-kernel function.
4979     if (Attr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
4980       // FIXME: This emits a different error message than
4981       // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
4982       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
4983       D->setInvalidDecl();
4984     } else if (Attr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
4985       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
4986       D->setInvalidDecl();
4987     } else if (Attr *A = D->getAttr<VecTypeHintAttr>()) {
4988       Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
4989       D->setInvalidDecl();
4990     } else if (Attr *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
4991       Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
4992         << A << ExpectedKernelFunction;
4993       D->setInvalidDecl();
4994     } else if (Attr *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
4995       Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
4996         << A << ExpectedKernelFunction;
4997       D->setInvalidDecl();
4998     }
4999   }
5000 }
5001
5002 // Annotation attributes are the only attributes allowed after an access
5003 // specifier.
5004 bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
5005                                           const AttributeList *AttrList) {
5006   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
5007     if (l->getKind() == AttributeList::AT_Annotate) {
5008       ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute());
5009     } else {
5010       Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
5011       return true;
5012     }
5013   }
5014
5015   return false;
5016 }
5017
5018 /// checkUnusedDeclAttributes - Check a list of attributes to see if it
5019 /// contains any decl attributes that we should warn about.
5020 static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
5021   for ( ; A; A = A->getNext()) {
5022     // Only warn if the attribute is an unignored, non-type attribute.
5023     if (A->isUsedAsTypeAttr() || A->isInvalid()) continue;
5024     if (A->getKind() == AttributeList::IgnoredAttribute) continue;
5025
5026     if (A->getKind() == AttributeList::UnknownAttribute) {
5027       S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
5028         << A->getName() << A->getRange();
5029     } else {
5030       S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
5031         << A->getName() << A->getRange();
5032     }
5033   }
5034 }
5035
5036 /// checkUnusedDeclAttributes - Given a declarator which is not being
5037 /// used to build a declaration, complain about any decl attributes
5038 /// which might be lying around on it.
5039 void Sema::checkUnusedDeclAttributes(Declarator &D) {
5040   ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
5041   ::checkUnusedDeclAttributes(*this, D.getAttributes());
5042   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
5043     ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
5044 }
5045
5046 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
5047 /// \#pragma weak needs a non-definition decl and source may not have one.
5048 NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
5049                                       SourceLocation Loc) {
5050   assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
5051   NamedDecl *NewD = nullptr;
5052   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
5053     FunctionDecl *NewFD;
5054     // FIXME: Missing call to CheckFunctionDeclaration().
5055     // FIXME: Mangling?
5056     // FIXME: Is the qualifier info correct?
5057     // FIXME: Is the DeclContext correct?
5058     NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
5059                                  Loc, Loc, DeclarationName(II),
5060                                  FD->getType(), FD->getTypeSourceInfo(),
5061                                  SC_None, false/*isInlineSpecified*/,
5062                                  FD->hasPrototype(),
5063                                  false/*isConstexprSpecified*/);
5064     NewD = NewFD;
5065
5066     if (FD->getQualifier())
5067       NewFD->setQualifierInfo(FD->getQualifierLoc());
5068
5069     // Fake up parameter variables; they are declared as if this were
5070     // a typedef.
5071     QualType FDTy = FD->getType();
5072     if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
5073       SmallVector<ParmVarDecl*, 16> Params;
5074       for (const auto &AI : FT->param_types()) {
5075         ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI);
5076         Param->setScopeInfo(0, Params.size());
5077         Params.push_back(Param);
5078       }
5079       NewFD->setParams(Params);
5080     }
5081   } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
5082     NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
5083                            VD->getInnerLocStart(), VD->getLocation(), II,
5084                            VD->getType(), VD->getTypeSourceInfo(),
5085                            VD->getStorageClass());
5086     if (VD->getQualifier()) {
5087       VarDecl *NewVD = cast<VarDecl>(NewD);
5088       NewVD->setQualifierInfo(VD->getQualifierLoc());
5089     }
5090   }
5091   return NewD;
5092 }
5093
5094 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
5095 /// applied to it, possibly with an alias.
5096 void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
5097   if (W.getUsed()) return; // only do this once
5098   W.setUsed(true);
5099   if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
5100     IdentifierInfo *NDId = ND->getIdentifier();
5101     NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
5102     NewD->addAttr(AliasAttr::CreateImplicit(Context, NDId->getName(),
5103                                             W.getLocation()));
5104     NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
5105     WeakTopLevelDecl.push_back(NewD);
5106     // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
5107     // to insert Decl at TU scope, sorry.
5108     DeclContext *SavedContext = CurContext;
5109     CurContext = Context.getTranslationUnitDecl();
5110     NewD->setDeclContext(CurContext);
5111     NewD->setLexicalDeclContext(CurContext);
5112     PushOnScopeChains(NewD, S);
5113     CurContext = SavedContext;
5114   } else { // just add weak to existing
5115     ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
5116   }
5117 }
5118
5119 void Sema::ProcessPragmaWeak(Scope *S, Decl *D) {
5120   // It's valid to "forward-declare" #pragma weak, in which case we
5121   // have to do this.
5122   LoadExternalWeakUndeclaredIdentifiers();
5123   if (!WeakUndeclaredIdentifiers.empty()) {
5124     NamedDecl *ND = nullptr;
5125     if (VarDecl *VD = dyn_cast<VarDecl>(D))
5126       if (VD->isExternC())
5127         ND = VD;
5128     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
5129       if (FD->isExternC())
5130         ND = FD;
5131     if (ND) {
5132       if (IdentifierInfo *Id = ND->getIdentifier()) {
5133         auto I = WeakUndeclaredIdentifiers.find(Id);
5134         if (I != WeakUndeclaredIdentifiers.end()) {
5135           WeakInfo W = I->second;
5136           DeclApplyPragmaWeak(S, ND, W);
5137           WeakUndeclaredIdentifiers[Id] = W;
5138         }
5139       }
5140     }
5141   }
5142 }
5143
5144 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
5145 /// it, apply them to D.  This is a bit tricky because PD can have attributes
5146 /// specified in many different places, and we need to find and apply them all.
5147 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
5148   // Apply decl attributes from the DeclSpec if present.
5149   if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
5150     ProcessDeclAttributeList(S, D, Attrs);
5151
5152   // Walk the declarator structure, applying decl attributes that were in a type
5153   // position to the decl itself.  This handles cases like:
5154   //   int *__attr__(x)** D;
5155   // when X is a decl attribute.
5156   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
5157     if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
5158       ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false);
5159
5160   // Finally, apply any attributes on the decl itself.
5161   if (const AttributeList *Attrs = PD.getAttributes())
5162     ProcessDeclAttributeList(S, D, Attrs);
5163 }
5164
5165 /// Is the given declaration allowed to use a forbidden type?
5166 static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
5167   // Private ivars are always okay.  Unfortunately, people don't
5168   // always properly make their ivars private, even in system headers.
5169   // Plus we need to make fields okay, too.
5170   // Function declarations in sys headers will be marked unavailable.
5171   if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
5172       !isa<FunctionDecl>(decl))
5173     return false;
5174
5175   // Require it to be declared in a system header.
5176   return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
5177 }
5178
5179 /// Handle a delayed forbidden-type diagnostic.
5180 static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
5181                                        Decl *decl) {
5182   if (decl && isForbiddenTypeAllowed(S, decl)) {
5183     decl->addAttr(UnavailableAttr::CreateImplicit(S.Context,
5184                         "this system declaration uses an unsupported type",
5185                         diag.Loc));
5186     return;
5187   }
5188   if (S.getLangOpts().ObjCAutoRefCount)
5189     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
5190       // FIXME: we may want to suppress diagnostics for all
5191       // kind of forbidden type messages on unavailable functions.
5192       if (FD->hasAttr<UnavailableAttr>() &&
5193           diag.getForbiddenTypeDiagnostic() ==
5194           diag::err_arc_array_param_no_ownership) {
5195         diag.Triggered = true;
5196         return;
5197       }
5198     }
5199
5200   S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
5201     << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
5202   diag.Triggered = true;
5203 }
5204
5205
5206 static bool isDeclDeprecated(Decl *D) {
5207   do {
5208     if (D->isDeprecated())
5209       return true;
5210     // A category implicitly has the availability of the interface.
5211     if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
5212       if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
5213         return Interface->isDeprecated();
5214   } while ((D = cast_or_null<Decl>(D->getDeclContext())));
5215   return false;
5216 }
5217
5218 static bool isDeclUnavailable(Decl *D) {
5219   do {
5220     if (D->isUnavailable())
5221       return true;
5222     // A category implicitly has the availability of the interface.
5223     if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
5224       if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
5225         return Interface->isUnavailable();
5226   } while ((D = cast_or_null<Decl>(D->getDeclContext())));
5227   return false;
5228 }
5229
5230 static void DoEmitAvailabilityWarning(Sema &S, Sema::AvailabilityDiagnostic K,
5231                                       Decl *Ctx, const NamedDecl *D,
5232                                       StringRef Message, SourceLocation Loc,
5233                                       const ObjCInterfaceDecl *UnknownObjCClass,
5234                                       const ObjCPropertyDecl *ObjCProperty,
5235                                       bool ObjCPropertyAccess) {
5236   // Diagnostics for deprecated or unavailable.
5237   unsigned diag, diag_message, diag_fwdclass_message;
5238
5239   // Matches 'diag::note_property_attribute' options.
5240   unsigned property_note_select;
5241
5242   // Matches diag::note_availability_specified_here.
5243   unsigned available_here_select_kind;
5244
5245   // Don't warn if our current context is deprecated or unavailable.
5246   switch (K) {
5247   case Sema::AD_Deprecation:
5248     if (isDeclDeprecated(Ctx) || isDeclUnavailable(Ctx))
5249       return;
5250     diag = !ObjCPropertyAccess ? diag::warn_deprecated
5251                                : diag::warn_property_method_deprecated;
5252     diag_message = diag::warn_deprecated_message;
5253     diag_fwdclass_message = diag::warn_deprecated_fwdclass_message;
5254     property_note_select = /* deprecated */ 0;
5255     available_here_select_kind = /* deprecated */ 2;
5256     break;
5257
5258   case Sema::AD_Unavailable:
5259     if (isDeclUnavailable(Ctx))
5260       return;
5261     diag = !ObjCPropertyAccess ? diag::err_unavailable
5262                                : diag::err_property_method_unavailable;
5263     diag_message = diag::err_unavailable_message;
5264     diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
5265     property_note_select = /* unavailable */ 1;
5266     available_here_select_kind = /* unavailable */ 0;
5267     break;
5268
5269   case Sema::AD_Partial:
5270     diag = diag::warn_partial_availability;
5271     diag_message = diag::warn_partial_message;
5272     diag_fwdclass_message = diag::warn_partial_fwdclass_message;
5273     property_note_select = /* partial */ 2;
5274     available_here_select_kind = /* partial */ 3;
5275     break;
5276   }
5277
5278   if (!Message.empty()) {
5279     S.Diag(Loc, diag_message) << D << Message;
5280     if (ObjCProperty)
5281       S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
5282           << ObjCProperty->getDeclName() << property_note_select;
5283   } else if (!UnknownObjCClass) {
5284     S.Diag(Loc, diag) << D;
5285     if (ObjCProperty)
5286       S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
5287           << ObjCProperty->getDeclName() << property_note_select;
5288   } else {
5289     S.Diag(Loc, diag_fwdclass_message) << D;
5290     S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
5291   }
5292
5293   S.Diag(D->getLocation(), diag::note_availability_specified_here)
5294       << D << available_here_select_kind;
5295   if (K == Sema::AD_Partial)
5296     S.Diag(Loc, diag::note_partial_availability_silence) << D;
5297 }
5298
5299 static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD,
5300                                            Decl *Ctx) {
5301   assert(DD.Kind == DelayedDiagnostic::Deprecation ||
5302          DD.Kind == DelayedDiagnostic::Unavailable);
5303   Sema::AvailabilityDiagnostic AD = DD.Kind == DelayedDiagnostic::Deprecation
5304                                         ? Sema::AD_Deprecation
5305                                         : Sema::AD_Unavailable;
5306   DD.Triggered = true;
5307   DoEmitAvailabilityWarning(
5308       S, AD, Ctx, DD.getDeprecationDecl(), DD.getDeprecationMessage(), DD.Loc,
5309       DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
5310 }
5311
5312 void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
5313   assert(DelayedDiagnostics.getCurrentPool());
5314   DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
5315   DelayedDiagnostics.popWithoutEmitting(state);
5316
5317   // When delaying diagnostics to run in the context of a parsed
5318   // declaration, we only want to actually emit anything if parsing
5319   // succeeds.
5320   if (!decl) return;
5321
5322   // We emit all the active diagnostics in this pool or any of its
5323   // parents.  In general, we'll get one pool for the decl spec
5324   // and a child pool for each declarator; in a decl group like:
5325   //   deprecated_typedef foo, *bar, baz();
5326   // only the declarator pops will be passed decls.  This is correct;
5327   // we really do need to consider delayed diagnostics from the decl spec
5328   // for each of the different declarations.
5329   const DelayedDiagnosticPool *pool = &poppedPool;
5330   do {
5331     for (DelayedDiagnosticPool::pool_iterator
5332            i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
5333       // This const_cast is a bit lame.  Really, Triggered should be mutable.
5334       DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
5335       if (diag.Triggered)
5336         continue;
5337
5338       switch (diag.Kind) {
5339       case DelayedDiagnostic::Deprecation:
5340       case DelayedDiagnostic::Unavailable:
5341         // Don't bother giving deprecation/unavailable diagnostics if
5342         // the decl is invalid.
5343         if (!decl->isInvalidDecl())
5344           handleDelayedAvailabilityCheck(*this, diag, decl);
5345         break;
5346
5347       case DelayedDiagnostic::Access:
5348         HandleDelayedAccessCheck(diag, decl);
5349         break;
5350
5351       case DelayedDiagnostic::ForbiddenType:
5352         handleDelayedForbiddenType(*this, diag, decl);
5353         break;
5354       }
5355     }
5356   } while ((pool = pool->getParent()));
5357 }
5358
5359 /// Given a set of delayed diagnostics, re-emit them as if they had
5360 /// been delayed in the current context instead of in the given pool.
5361 /// Essentially, this just moves them to the current pool.
5362 void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
5363   DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
5364   assert(curPool && "re-emitting in undelayed context not supported");
5365   curPool->steal(pool);
5366 }
5367
5368 void Sema::EmitAvailabilityWarning(AvailabilityDiagnostic AD,
5369                                    NamedDecl *D, StringRef Message,
5370                                    SourceLocation Loc,
5371                                    const ObjCInterfaceDecl *UnknownObjCClass,
5372                                    const ObjCPropertyDecl  *ObjCProperty,
5373                                    bool ObjCPropertyAccess) {
5374   // Delay if we're currently parsing a declaration.
5375   if (DelayedDiagnostics.shouldDelayDiagnostics() && AD != AD_Partial) {
5376     DelayedDiagnostics.add(DelayedDiagnostic::makeAvailability(
5377         AD, Loc, D, UnknownObjCClass, ObjCProperty, Message,
5378         ObjCPropertyAccess));
5379     return;
5380   }
5381
5382   Decl *Ctx = cast<Decl>(getCurLexicalContext());
5383   DoEmitAvailabilityWarning(*this, AD, Ctx, D, Message, Loc, UnknownObjCClass,
5384                             ObjCProperty, ObjCPropertyAccess);
5385 }