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 "TargetAttributesSema.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/CXXInheritance.h"
  18 #include "clang/AST/DeclCXX.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/DeclObjC.h"
  21 #include "clang/AST/Expr.h"
  22 #include "clang/Basic/SourceManager.h"
  23 #include "clang/Basic/TargetInfo.h"
  24 #include "clang/Sema/DeclSpec.h"
  25 #include "clang/Sema/DelayedDiagnostic.h"
  26 #include "clang/Sema/Lookup.h"
  27 #include "llvm/ADT/StringExtras.h"
  28 using namespace clang;
  29 using namespace sema;
  30
  31 /// These constants match the enumerated choices of
  32 /// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
  33 enum AttributeDeclKind {
  34   ExpectedFunction,
  35   ExpectedUnion,
  36   ExpectedVariableOrFunction,
  37   ExpectedFunctionOrMethod,
  38   ExpectedParameter,
  39   ExpectedFunctionMethodOrBlock,
  40   ExpectedFunctionMethodOrParameter,
  41   ExpectedClass,
  42   ExpectedVariable,
  43   ExpectedMethod,
  44   ExpectedVariableFunctionOrLabel,
  45   ExpectedFieldOrGlobalVar,
  46   ExpectedStruct,
  47   ExpectedTLSVar
  48 };
  49
  50 //===----------------------------------------------------------------------===//
  51 //  Helper functions
  52 //===----------------------------------------------------------------------===//
  53
  54 static const FunctionType *getFunctionType(const Decl *D,
  55                                            bool blocksToo = true) {
  56   QualType Ty;
  57   if (const ValueDecl *decl = dyn_cast<ValueDecl>(D))
  58     Ty = decl->getType();
  59   else if (const FieldDecl *decl = dyn_cast<FieldDecl>(D))
  60     Ty = decl->getType();
  61   else if (const TypedefNameDecl* decl = dyn_cast<TypedefNameDecl>(D))
  62     Ty = decl->getUnderlyingType();
  63   else
  64     return 0;
  65
  66   if (Ty->isFunctionPointerType())
  67     Ty = Ty->getAs<PointerType>()->getPointeeType();
  68   else if (blocksToo && Ty->isBlockPointerType())
  69     Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
  70
  71   return Ty->getAs<FunctionType>();
  72 }
  73
  74 // FIXME: We should provide an abstraction around a method or function
  75 // to provide the following bits of information.
  76
  77 /// isFunction - Return true if the given decl has function
  78 /// type (function or function-typed variable).
  79 static bool isFunction(const Decl *D) {
  80   return getFunctionType(D, false) != NULL;
  81 }
  82
  83 /// isFunctionOrMethod - Return true if the given decl has function
  84 /// type (function or function-typed variable) or an Objective-C
  85 /// method.
  86 static bool isFunctionOrMethod(const Decl *D) {
  87   return isFunction(D) || isa<ObjCMethodDecl>(D);
  88 }
  89
  90 /// isFunctionOrMethodOrBlock - Return true if the given decl has function
  91 /// type (function or function-typed variable) or an Objective-C
  92 /// method or a block.
  93 static bool isFunctionOrMethodOrBlock(const Decl *D) {
  94   if (isFunctionOrMethod(D))
  95     return true;
  96   // check for block is more involved.
  97   if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
  98     QualType Ty = V->getType();
  99     return Ty->isBlockPointerType();
 100   }
 101   return isa<BlockDecl>(D);
 102 }
 103
 104 /// Return true if the given decl has a declarator that should have
 105 /// been processed by Sema::GetTypeForDeclarator.
 106 static bool hasDeclarator(const Decl *D) {
 107   // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
 108   return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
 109          isa<ObjCPropertyDecl>(D);
 110 }
 111
 112 /// hasFunctionProto - Return true if the given decl has a argument
 113 /// information. This decl should have already passed
 114 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
 115 static bool hasFunctionProto(const Decl *D) {
 116   if (const FunctionType *FnTy = getFunctionType(D))
 117     return isa<FunctionProtoType>(FnTy);
 118   else {
 119     assert(isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D));
 120     return true;
 121   }
 122 }
 123
 124 /// getFunctionOrMethodNumArgs - Return number of function or method
 125 /// arguments. It is an error to call this on a K&R function (use
 126 /// hasFunctionProto first).
 127 static unsigned getFunctionOrMethodNumArgs(const Decl *D) {
 128   if (const FunctionType *FnTy = getFunctionType(D))
 129     return cast<FunctionProtoType>(FnTy)->getNumArgs();
 130   if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 131     return BD->getNumParams();
 132   return cast<ObjCMethodDecl>(D)->param_size();
 133 }
 134
 135 static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) {
 136   if (const FunctionType *FnTy = getFunctionType(D))
 137     return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
 138   if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 139     return BD->getParamDecl(Idx)->getType();
 140
 141   return cast<ObjCMethodDecl>(D)->param_begin()[Idx]->getType();
 142 }
 143
 144 static QualType getFunctionOrMethodResultType(const Decl *D) {
 145   if (const FunctionType *FnTy = getFunctionType(D))
 146     return cast<FunctionProtoType>(FnTy)->getResultType();
 147   return cast<ObjCMethodDecl>(D)->getResultType();
 148 }
 149
 150 static bool isFunctionOrMethodVariadic(const Decl *D) {
 151   if (const FunctionType *FnTy = getFunctionType(D)) {
 152     const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
 153     return proto->isVariadic();
 154   } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 155     return BD->isVariadic();
 156   else {
 157     return cast<ObjCMethodDecl>(D)->isVariadic();
 158   }
 159 }
 160
 161 static bool isInstanceMethod(const Decl *D) {
 162   if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
 163     return MethodDecl->isInstance();
 164   return false;
 165 }
 166
 167 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
 168   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
 169   if (!PT)
 170     return false;
 171
 172   ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
 173   if (!Cls)
 174     return false;
 175
 176   IdentifierInfo* ClsName = Cls->getIdentifier();
 177
 178   // FIXME: Should we walk the chain of classes?
 179   return ClsName == &Ctx.Idents.get("NSString") ||
 180          ClsName == &Ctx.Idents.get("NSMutableString");
 181 }
 182
 183 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
 184   const PointerType *PT = T->getAs<PointerType>();
 185   if (!PT)
 186     return false;
 187
 188   const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
 189   if (!RT)
 190     return false;
 191
 192   const RecordDecl *RD = RT->getDecl();
 193   if (RD->getTagKind() != TTK_Struct)
 194     return false;
 195
 196   return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
 197 }
 198
 199 /// \brief Check if the attribute has exactly as many args as Num. May
 200 /// output an error.
 201 static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
 202                                   unsigned int Num) {
 203   if (Attr.getNumArgs() != Num) {
 204     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num;
 205     return false;
 206   }
 207
 208   return true;
 209 }
 210
 211
 212 /// \brief Check if the attribute has at least as many args as Num. May
 213 /// output an error.
 214 static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr,
 215                                   unsigned int Num) {
 216   if (Attr.getNumArgs() < Num) {
 217     S.Diag(Attr.getLoc(), diag::err_attribute_too_few_arguments) << Num;
 218     return false;
 219   }
 220
 221   return true;
 222 }
 223
 224 /// \brief Check if IdxExpr is a valid argument index for a function or
 225 /// instance method D.  May output an error.
 226 ///
 227 /// \returns true if IdxExpr is a valid index.
 228 static bool checkFunctionOrMethodArgumentIndex(Sema &S, const Decl *D,
 229                                                StringRef AttrName,
 230                                                SourceLocation AttrLoc,
 231                                                unsigned AttrArgNum,
 232                                                const Expr *IdxExpr,
 233                                                uint64_t &Idx)
 234 {
 235   assert(isFunctionOrMethod(D) && hasFunctionProto(D));
 236
 237   // In C++ the implicit 'this' function parameter also counts.
 238   // Parameters are counted from one.
 239   const bool HasImplicitThisParam = isInstanceMethod(D);
 240   const unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
 241   const unsigned FirstIdx = 1;
 242
 243   llvm::APSInt IdxInt;
 244   if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
 245       !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
 246     S.Diag(AttrLoc, diag::err_attribute_argument_n_not_int)
 247       << AttrName << AttrArgNum << IdxExpr->getSourceRange();
 248     return false;
 249   }
 250
 251   Idx = IdxInt.getLimitedValue();
 252   if (Idx < FirstIdx || (!isFunctionOrMethodVariadic(D) && Idx > NumArgs)) {
 253     S.Diag(AttrLoc, diag::err_attribute_argument_out_of_bounds)
 254       << AttrName << AttrArgNum << IdxExpr->getSourceRange();
 255     return false;
 256   }
 257   Idx--; // Convert to zero-based.
 258   if (HasImplicitThisParam) {
 259     if (Idx == 0) {
 260       S.Diag(AttrLoc,
 261              diag::err_attribute_invalid_implicit_this_argument)
 262         << AttrName << IdxExpr->getSourceRange();
 263       return false;
 264     }
 265     --Idx;
 266   }
 267
 268   return true;
 269 }
 270
 271 ///
 272 /// \brief Check if passed in Decl is a field or potentially shared global var
 273 /// \return true if the Decl is a field or potentially shared global variable
 274 ///
 275 static bool mayBeSharedVariable(const Decl *D) {
 276   if (isa<FieldDecl>(D))
 277     return true;
 278   if (const VarDecl *vd = dyn_cast<VarDecl>(D))
 279     return (vd->hasGlobalStorage() && !(vd->isThreadSpecified()));
 280
 281   return false;
 282 }
 283
 284 /// \brief Check if the passed-in expression is of type int or bool.
 285 static bool isIntOrBool(Expr *Exp) {
 286   QualType QT = Exp->getType();
 287   return QT->isBooleanType() || QT->isIntegerType();
 288 }
 289
 290
 291 // Check to see if the type is a smart pointer of some kind.  We assume
 292 // it's a smart pointer if it defines both operator-> and operator*.
 293 static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
 294   DeclContextLookupConstResult Res1 = RT->getDecl()->lookup(
 295     S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
 296   if (Res1.first == Res1.second)
 297     return false;
 298
 299   DeclContextLookupConstResult Res2 = RT->getDecl()->lookup(
 300     S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
 301   if (Res2.first == Res2.second)
 302     return false;
 303
 304   return true;
 305 }
 306
 307 /// \brief Check if passed in Decl is a pointer type.
 308 /// Note that this function may produce an error message.
 309 /// \return true if the Decl is a pointer type; false otherwise
 310 static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
 311                                        const AttributeList &Attr) {
 312   if (const ValueDecl *vd = dyn_cast<ValueDecl>(D)) {
 313     QualType QT = vd->getType();
 314     if (QT->isAnyPointerType())
 315       return true;
 316
 317     if (const RecordType *RT = QT->getAs<RecordType>()) {
 318       // If it's an incomplete type, it could be a smart pointer; skip it.
 319       // (We don't want to force template instantiation if we can avoid it,
 320       // since that would alter the order in which templates are instantiated.)
 321       if (RT->isIncompleteType())
 322         return true;
 323
 324       if (threadSafetyCheckIsSmartPointer(S, RT))
 325         return true;
 326     }
 327
 328     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
 329       << Attr.getName()->getName() << QT;
 330   } else {
 331     S.Diag(Attr.getLoc(), diag::err_attribute_can_be_applied_only_to_value_decl)
 332       << Attr.getName();
 333   }
 334   return false;
 335 }
 336
 337 /// \brief Checks that the passed in QualType either is of RecordType or points
 338 /// to RecordType. Returns the relevant RecordType, null if it does not exit.
 339 static const RecordType *getRecordType(QualType QT) {
 340   if (const RecordType *RT = QT->getAs<RecordType>())
 341     return RT;
 342
 343   // Now check if we point to record type.
 344   if (const PointerType *PT = QT->getAs<PointerType>())
 345     return PT->getPointeeType()->getAs<RecordType>();
 346
 347   return 0;
 348 }
 349
 350
 351 static bool checkBaseClassIsLockableCallback(const CXXBaseSpecifier *Specifier,
 352                                              CXXBasePath &Path, void *Unused) {
 353   const RecordType *RT = Specifier->getType()->getAs<RecordType>();
 354   if (RT->getDecl()->getAttr<LockableAttr>())
 355     return true;
 356   return false;
 357 }
 358
 359
 360 /// \brief Thread Safety Analysis: Checks that the passed in RecordType
 361 /// resolves to a lockable object.
 362 static void checkForLockableRecord(Sema &S, Decl *D, const AttributeList &Attr,
 363                                    QualType Ty) {
 364   const RecordType *RT = getRecordType(Ty);
 365
 366   // Warn if could not get record type for this argument.
 367   if (!RT) {
 368     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_class)
 369       << Attr.getName() << Ty.getAsString();
 370     return;
 371   }
 372
 373   // Don't check for lockable if the class hasn't been defined yet.
 374   if (RT->isIncompleteType())
 375     return;
 376
 377   // Allow smart pointers to be used as lockable objects.
 378   // FIXME -- Check the type that the smart pointer points to.
 379   if (threadSafetyCheckIsSmartPointer(S, RT))
 380     return;
 381
 382   // Check if the type is lockable.
 383   RecordDecl *RD = RT->getDecl();
 384   if (RD->getAttr<LockableAttr>())
 385     return;
 386
 387   // Else check if any base classes are lockable.
 388   if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
 389     CXXBasePaths BPaths(false, false);
 390     if (CRD->lookupInBases(checkBaseClassIsLockableCallback, 0, BPaths))
 391       return;
 392   }
 393
 394   S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
 395     << Attr.getName() << Ty.getAsString();
 396 }
 397
 398 /// \brief Thread Safety Analysis: Checks that all attribute arguments, starting
 399 /// from Sidx, resolve to a lockable object.
 400 /// \param Sidx The attribute argument index to start checking with.
 401 /// \param ParamIdxOk Whether an argument can be indexing into a function
 402 /// parameter list.
 403 static void checkAttrArgsAreLockableObjs(Sema &S, Decl *D,
 404                                          const AttributeList &Attr,
 405                                          SmallVectorImpl<Expr*> &Args,
 406                                          int Sidx = 0,
 407                                          bool ParamIdxOk = false) {
 408   for(unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
 409     Expr *ArgExp = Attr.getArg(Idx);
 410
 411     if (ArgExp->isTypeDependent()) {
 412       // FIXME -- need to check this again on template instantiation
 413       Args.push_back(ArgExp);
 414       continue;
 415     }
 416
 417     if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
 418       // Ignore empty strings without warnings
 419       if (StrLit->getLength() == 0)
 420         continue;
 421
 422       // We allow constant strings to be used as a placeholder for expressions
 423       // that are not valid C++ syntax, but warn that they are ignored.
 424       S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
 425         Attr.getName();
 426       continue;
 427     }
 428
 429     QualType ArgTy = ArgExp->getType();
 430
 431     // A pointer to member expression of the form  &MyClass::mu is treated
 432     // specially -- we need to look at the type of the member.
 433     if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp))
 434       if (UOp->getOpcode() == UO_AddrOf)
 435         if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
 436           if (DRE->getDecl()->isCXXInstanceMember())
 437             ArgTy = DRE->getDecl()->getType();
 438
 439     // First see if we can just cast to record type, or point to record type.
 440     const RecordType *RT = getRecordType(ArgTy);
 441
 442     // Now check if we index into a record type function param.
 443     if(!RT && ParamIdxOk) {
 444       FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
 445       IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp);
 446       if(FD && IL) {
 447         unsigned int NumParams = FD->getNumParams();
 448         llvm::APInt ArgValue = IL->getValue();
 449         uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
 450         uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
 451         if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
 452           S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
 453             << Attr.getName() << Idx + 1 << NumParams;
 454           continue;
 455         }
 456         ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
 457       }
 458     }
 459
 460     checkForLockableRecord(S, D, Attr, ArgTy);
 461
 462     Args.push_back(ArgExp);
 463   }
 464 }
 465
 466 //===----------------------------------------------------------------------===//
 467 // Attribute Implementations
 468 //===----------------------------------------------------------------------===//
 469
 470 // FIXME: All this manual attribute parsing code is gross. At the
 471 // least add some helper functions to check most argument patterns (#
 472 // and types of args).
 473
 474 enum ThreadAttributeDeclKind {
 475   ThreadExpectedFieldOrGlobalVar,
 476   ThreadExpectedFunctionOrMethod,
 477   ThreadExpectedClassOrStruct
 478 };
 479
 480 static bool checkGuardedVarAttrCommon(Sema &S, Decl *D,
 481                                       const AttributeList &Attr) {
 482   assert(!Attr.isInvalid());
 483
 484   if (!checkAttributeNumArgs(S, Attr, 0))
 485     return false;
 486
 487   // D must be either a member field or global (potentially shared) variable.
 488   if (!mayBeSharedVariable(D)) {
 489     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 490       << Attr.getName() << ThreadExpectedFieldOrGlobalVar;
 491     return false;
 492   }
 493
 494   return true;
 495 }
 496
 497 static void handleGuardedVarAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 498   if (!checkGuardedVarAttrCommon(S, D, Attr))
 499     return;
 500
 501   D->addAttr(::new (S.Context) GuardedVarAttr(Attr.getRange(), S.Context));
 502 }
 503
 504 static void handlePtGuardedVarAttr(Sema &S, Decl *D,
 505                            const AttributeList &Attr) {
 506   if (!checkGuardedVarAttrCommon(S, D, Attr))
 507     return;
 508
 509   if (!threadSafetyCheckIsPointer(S, D, Attr))
 510     return;
 511
 512   D->addAttr(::new (S.Context) PtGuardedVarAttr(Attr.getRange(), S.Context));
 513 }
 514
 515 static bool checkGuardedByAttrCommon(Sema &S, Decl *D,
 516                                      const AttributeList &Attr,
 517                                      Expr* &Arg) {
 518   assert(!Attr.isInvalid());
 519
 520   if (!checkAttributeNumArgs(S, Attr, 1))
 521     return false;
 522
 523   // D must be either a member field or global (potentially shared) variable.
 524   if (!mayBeSharedVariable(D)) {
 525     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 526       << Attr.getName() << ThreadExpectedFieldOrGlobalVar;
 527     return false;
 528   }
 529
 530   SmallVector<Expr*, 1> Args;
 531   // check that all arguments are lockable objects
 532   checkAttrArgsAreLockableObjs(S, D, Attr, Args);
 533   unsigned Size = Args.size();
 534   if (Size != 1)
 535     return false;
 536
 537   Arg = Args[0];
 538
 539   return true;
 540 }
 541
 542 static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 543   Expr *Arg = 0;
 544   if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
 545     return;
 546
 547   D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg));
 548 }
 549
 550 static void handlePtGuardedByAttr(Sema &S, Decl *D,
 551                                   const AttributeList &Attr) {
 552   Expr *Arg = 0;
 553   if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
 554     return;
 555
 556   if (!threadSafetyCheckIsPointer(S, D, Attr))
 557     return;
 558
 559   D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
 560                                                S.Context, Arg));
 561 }
 562
 563 static bool checkLockableAttrCommon(Sema &S, Decl *D,
 564                                     const AttributeList &Attr) {
 565   assert(!Attr.isInvalid());
 566
 567   if (!checkAttributeNumArgs(S, Attr, 0))
 568     return false;
 569
 570   // FIXME: Lockable structs for C code.
 571   if (!isa<CXXRecordDecl>(D)) {
 572     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 573       << Attr.getName() << ThreadExpectedClassOrStruct;
 574     return false;
 575   }
 576
 577   return true;
 578 }
 579
 580 static void handleLockableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 581   if (!checkLockableAttrCommon(S, D, Attr))
 582     return;
 583
 584   D->addAttr(::new (S.Context) LockableAttr(Attr.getRange(), S.Context));
 585 }
 586
 587 static void handleScopedLockableAttr(Sema &S, Decl *D,
 588                              const AttributeList &Attr) {
 589   if (!checkLockableAttrCommon(S, D, Attr))
 590     return;
 591
 592   D->addAttr(::new (S.Context) ScopedLockableAttr(Attr.getRange(), S.Context));
 593 }
 594
 595 static void handleNoThreadSafetyAttr(Sema &S, Decl *D,
 596                                      const AttributeList &Attr) {
 597   assert(!Attr.isInvalid());
 598
 599   if (!checkAttributeNumArgs(S, Attr, 0))
 600     return;
 601
 602   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 603     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 604       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 605     return;
 606   }
 607
 608   D->addAttr(::new (S.Context) NoThreadSafetyAnalysisAttr(Attr.getRange(),
 609                                                           S.Context));
 610 }
 611
 612 static void handleNoAddressSafetyAttr(Sema &S, Decl *D,
 613                                       const AttributeList &Attr) {
 614   assert(!Attr.isInvalid());
 615
 616   if (!checkAttributeNumArgs(S, Attr, 0))
 617     return;
 618
 619   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 620     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 621       << Attr.getName() << ExpectedFunctionOrMethod;
 622     return;
 623   }
 624
 625   D->addAttr(::new (S.Context) NoAddressSafetyAnalysisAttr(Attr.getRange(),
 626                                                            S.Context));
 627 }
 628
 629 static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D,
 630                                         const AttributeList &Attr,
 631                                         SmallVector<Expr*, 1> &Args) {
 632   assert(!Attr.isInvalid());
 633
 634   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
 635     return false;
 636
 637   // D must be either a member field or global (potentially shared) variable.
 638   ValueDecl *VD = dyn_cast<ValueDecl>(D);
 639   if (!VD || !mayBeSharedVariable(D)) {
 640     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 641       << Attr.getName() << ThreadExpectedFieldOrGlobalVar;
 642     return false;
 643   }
 644
 645   // Check that this attribute only applies to lockable types.
 646   QualType QT = VD->getType();
 647   if (!QT->isDependentType()) {
 648     const RecordType *RT = getRecordType(QT);
 649     if (!RT || !RT->getDecl()->getAttr<LockableAttr>()) {
 650       S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
 651         << Attr.getName();
 652       return false;
 653     }
 654   }
 655
 656   // Check that all arguments are lockable objects.
 657   checkAttrArgsAreLockableObjs(S, D, Attr, Args);
 658   if (Args.size() == 0)
 659     return false;
 660
 661   return true;
 662 }
 663
 664 static void handleAcquiredAfterAttr(Sema &S, Decl *D,
 665                                     const AttributeList &Attr) {
 666   SmallVector<Expr*, 1> Args;
 667   if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
 668     return;
 669
 670   Expr **StartArg = &Args[0];
 671   D->addAttr(::new (S.Context) AcquiredAfterAttr(Attr.getRange(), S.Context,
 672                                                  StartArg, Args.size()));
 673 }
 674
 675 static void handleAcquiredBeforeAttr(Sema &S, Decl *D,
 676                                      const AttributeList &Attr) {
 677   SmallVector<Expr*, 1> Args;
 678   if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
 679     return;
 680
 681   Expr **StartArg = &Args[0];
 682   D->addAttr(::new (S.Context) AcquiredBeforeAttr(Attr.getRange(), S.Context,
 683                                                   StartArg, Args.size()));
 684 }
 685
 686 static bool checkLockFunAttrCommon(Sema &S, Decl *D,
 687                                    const AttributeList &Attr,
 688                                    SmallVector<Expr*, 1> &Args) {
 689   assert(!Attr.isInvalid());
 690
 691   // zero or more arguments ok
 692
 693   // check that the attribute is applied to a function
 694   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 695     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 696       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 697     return false;
 698   }
 699
 700   // check that all arguments are lockable objects
 701   checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
 702
 703   return true;
 704 }
 705
 706 static void handleSharedLockFunctionAttr(Sema &S, Decl *D,
 707                                          const AttributeList &Attr) {
 708   SmallVector<Expr*, 1> Args;
 709   if (!checkLockFunAttrCommon(S, D, Attr, Args))
 710     return;
 711
 712   unsigned Size = Args.size();
 713   Expr **StartArg = Size == 0 ? 0 : &Args[0];
 714   D->addAttr(::new (S.Context) SharedLockFunctionAttr(Attr.getRange(),
 715                                                       S.Context,
 716                                                       StartArg, Size));
 717 }
 718
 719 static void handleExclusiveLockFunctionAttr(Sema &S, Decl *D,
 720                                             const AttributeList &Attr) {
 721   SmallVector<Expr*, 1> Args;
 722   if (!checkLockFunAttrCommon(S, D, Attr, Args))
 723     return;
 724
 725   unsigned Size = Args.size();
 726   Expr **StartArg = Size == 0 ? 0 : &Args[0];
 727   D->addAttr(::new (S.Context) ExclusiveLockFunctionAttr(Attr.getRange(),
 728                                                          S.Context,
 729                                                          StartArg, Size));
 730 }
 731
 732 static bool checkTryLockFunAttrCommon(Sema &S, Decl *D,
 733                                       const AttributeList &Attr,
 734                                       SmallVector<Expr*, 2> &Args) {
 735   assert(!Attr.isInvalid());
 736
 737   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
 738     return false;
 739
 740   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 741     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 742       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 743     return false;
 744   }
 745
 746   if (!isIntOrBool(Attr.getArg(0))) {
 747     S.Diag(Attr.getLoc(), diag::err_attribute_first_argument_not_int_or_bool)
 748       << Attr.getName();
 749     return false;
 750   }
 751
 752   // check that all arguments are lockable objects
 753   checkAttrArgsAreLockableObjs(S, D, Attr, Args, 1);
 754
 755   return true;
 756 }
 757
 758 static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
 759                                             const AttributeList &Attr) {
 760   SmallVector<Expr*, 2> Args;
 761   if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
 762     return;
 763
 764   unsigned Size = Args.size();
 765   Expr **StartArg = Size == 0 ? 0 : &Args[0];
 766   D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(Attr.getRange(),
 767                                                          S.Context,
 768                                                          Attr.getArg(0),
 769                                                          StartArg, Size));
 770 }
 771
 772 static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
 773                                                const AttributeList &Attr) {
 774   SmallVector<Expr*, 2> Args;
 775   if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
 776     return;
 777
 778   unsigned Size = Args.size();
 779   Expr **StartArg = Size == 0 ? 0 : &Args[0];
 780   D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(Attr.getRange(),
 781                                                             S.Context,
 782                                                             Attr.getArg(0),
 783                                                             StartArg, Size));
 784 }
 785
 786 static bool checkLocksRequiredCommon(Sema &S, Decl *D,
 787                                      const AttributeList &Attr,
 788                                      SmallVector<Expr*, 1> &Args) {
 789   assert(!Attr.isInvalid());
 790
 791   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
 792     return false;
 793
 794   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 795     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 796       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 797     return false;
 798   }
 799
 800   // check that all arguments are lockable objects
 801   checkAttrArgsAreLockableObjs(S, D, Attr, Args);
 802   if (Args.size() == 0)
 803     return false;
 804
 805   return true;
 806 }
 807
 808 static void handleExclusiveLocksRequiredAttr(Sema &S, Decl *D,
 809                                              const AttributeList &Attr) {
 810   SmallVector<Expr*, 1> Args;
 811   if (!checkLocksRequiredCommon(S, D, Attr, Args))
 812     return;
 813
 814   Expr **StartArg = &Args[0];
 815   D->addAttr(::new (S.Context) ExclusiveLocksRequiredAttr(Attr.getRange(),
 816                                                           S.Context,
 817                                                           StartArg,
 818                                                           Args.size()));
 819 }
 820
 821 static void handleSharedLocksRequiredAttr(Sema &S, Decl *D,
 822                                           const AttributeList &Attr) {
 823   SmallVector<Expr*, 1> Args;
 824   if (!checkLocksRequiredCommon(S, D, Attr, Args))
 825     return;
 826
 827   Expr **StartArg = &Args[0];
 828   D->addAttr(::new (S.Context) SharedLocksRequiredAttr(Attr.getRange(),
 829                                                        S.Context,
 830                                                        StartArg,
 831                                                        Args.size()));
 832 }
 833
 834 static void handleUnlockFunAttr(Sema &S, Decl *D,
 835                                 const AttributeList &Attr) {
 836   assert(!Attr.isInvalid());
 837
 838   // zero or more arguments ok
 839
 840   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 841     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 842       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 843     return;
 844   }
 845
 846   // check that all arguments are lockable objects
 847   SmallVector<Expr*, 1> Args;
 848   checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
 849   unsigned Size = Args.size();
 850   Expr **StartArg = Size == 0 ? 0 : &Args[0];
 851
 852   D->addAttr(::new (S.Context) UnlockFunctionAttr(Attr.getRange(), S.Context,
 853                                                   StartArg, Size));
 854 }
 855
 856 static void handleLockReturnedAttr(Sema &S, Decl *D,
 857                                    const AttributeList &Attr) {
 858   assert(!Attr.isInvalid());
 859
 860   if (!checkAttributeNumArgs(S, Attr, 1))
 861     return;
 862   Expr *Arg = Attr.getArg(0);
 863
 864   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 865     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 866       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 867     return;
 868   }
 869
 870   if (Arg->isTypeDependent())
 871     return;
 872
 873   // check that the argument is lockable object
 874   SmallVector<Expr*, 1> Args;
 875   checkAttrArgsAreLockableObjs(S, D, Attr, Args);
 876   unsigned Size = Args.size();
 877   if (Size == 0)
 878     return;
 879
 880   D->addAttr(::new (S.Context) LockReturnedAttr(Attr.getRange(), S.Context,
 881                                                 Args[0]));
 882 }
 883
 884 static void handleLocksExcludedAttr(Sema &S, Decl *D,
 885                                     const AttributeList &Attr) {
 886   assert(!Attr.isInvalid());
 887
 888   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
 889     return;
 890
 891   if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
 892     S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type)
 893       << Attr.getName() << ThreadExpectedFunctionOrMethod;
 894     return;
 895   }
 896
 897   // check that all arguments are lockable objects
 898   SmallVector<Expr*, 1> Args;
 899   checkAttrArgsAreLockableObjs(S, D, Attr, Args);
 900   unsigned Size = Args.size();
 901   if (Size == 0)
 902     return;
 903   Expr **StartArg = &Args[0];
 904
 905   D->addAttr(::new (S.Context) LocksExcludedAttr(Attr.getRange(), S.Context,
 906                                                  StartArg, Size));
 907 }
 908
 909
 910 static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
 911                                     const AttributeList &Attr) {
 912   TypedefNameDecl *tDecl = dyn_cast<TypedefNameDecl>(D);
 913   if (tDecl == 0) {
 914     S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
 915     return;
 916   }
 917
 918   QualType curType = tDecl->getUnderlyingType();
 919
 920   Expr *sizeExpr;
 921
 922   // Special case where the argument is a template id.
 923   if (Attr.getParameterName()) {
 924     CXXScopeSpec SS;
 925     SourceLocation TemplateKWLoc;
 926     UnqualifiedId id;
 927     id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
 928
 929     ExprResult Size = S.ActOnIdExpression(scope, SS, TemplateKWLoc, id,
 930                                           false, false);
 931     if (Size.isInvalid())
 932       return;
 933
 934     sizeExpr = Size.get();
 935   } else {
 936     // check the attribute arguments.
 937     if (!checkAttributeNumArgs(S, Attr, 1))
 938       return;
 939
 940     sizeExpr = Attr.getArg(0);
 941   }
 942
 943   // Instantiate/Install the vector type, and let Sema build the type for us.
 944   // This will run the reguired checks.
 945   QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc());
 946   if (!T.isNull()) {
 947     // FIXME: preserve the old source info.
 948     tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
 949
 950     // Remember this typedef decl, we will need it later for diagnostics.
 951     S.ExtVectorDecls.push_back(tDecl);
 952   }
 953 }
 954
 955 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 956   // check the attribute arguments.
 957   if (!checkAttributeNumArgs(S, Attr, 0))
 958     return;
 959
 960   if (TagDecl *TD = dyn_cast<TagDecl>(D))
 961     TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context));
 962   else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
 963     // If the alignment is less than or equal to 8 bits, the packed attribute
 964     // has no effect.
 965     if (!FD->getType()->isIncompleteType() &&
 966         S.Context.getTypeAlign(FD->getType()) <= 8)
 967       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
 968         << Attr.getName() << FD->getType();
 969     else
 970       FD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context));
 971   } else
 972     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
 973 }
 974
 975 static void handleMsStructAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 976   if (TagDecl *TD = dyn_cast<TagDecl>(D))
 977     TD->addAttr(::new (S.Context) MsStructAttr(Attr.getRange(), S.Context));
 978   else
 979     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
 980 }
 981
 982 static void handleIBAction(Sema &S, Decl *D, const AttributeList &Attr) {
 983   // check the attribute arguments.
 984   if (!checkAttributeNumArgs(S, Attr, 0))
 985     return;
 986
 987   // The IBAction attributes only apply to instance methods.
 988   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
 989     if (MD->isInstanceMethod()) {
 990       D->addAttr(::new (S.Context) IBActionAttr(Attr.getRange(), S.Context));
 991       return;
 992     }
 993
 994   S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName();
 995 }
 996
 997 static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
 998   // The IBOutlet/IBOutletCollection attributes only apply to instance
 999   // variables or properties of Objective-C classes.  The outlet must also
1000   // have an object reference type.
1001   if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) {
1002     if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1003       S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1004         << Attr.getName() << VD->getType() << 0;
1005       return false;
1006     }
1007   }
1008   else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1009     if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1010       S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1011         << Attr.getName() << PD->getType() << 1;
1012       return false;
1013     }
1014   }
1015   else {
1016     S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
1017     return false;
1018   }
1019
1020   return true;
1021 }
1022
1023 static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
1024   // check the attribute arguments.
1025   if (!checkAttributeNumArgs(S, Attr, 0))
1026     return;
1027
1028   if (!checkIBOutletCommon(S, D, Attr))
1029     return;
1030
1031   D->addAttr(::new (S.Context) IBOutletAttr(Attr.getRange(), S.Context));
1032 }
1033
1034 static void handleIBOutletCollection(Sema &S, Decl *D,
1035                                      const AttributeList &Attr) {
1036
1037   // The iboutletcollection attribute can have zero or one arguments.
1038   if (Attr.getParameterName() && Attr.getNumArgs() > 0) {
1039     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1040     return;
1041   }
1042
1043   if (!checkIBOutletCommon(S, D, Attr))
1044     return;
1045
1046   IdentifierInfo *II = Attr.getParameterName();
1047   if (!II)
1048     II = &S.Context.Idents.get("NSObject");
1049
1050   ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(),
1051                         S.getScopeForContext(D->getDeclContext()->getParent()));
1052   if (!TypeRep) {
1053     S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
1054     return;
1055   }
1056   QualType QT = TypeRep.get();
1057   // Diagnose use of non-object type in iboutletcollection attribute.
1058   // FIXME. Gnu attribute extension ignores use of builtin types in
1059   // attributes. So, __attribute__((iboutletcollection(char))) will be
1060   // treated as __attribute__((iboutletcollection())).
1061   if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1062     S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
1063     return;
1064   }
1065   D->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getRange(),S.Context,
1066                                                    QT, Attr.getParameterLoc()));
1067 }
1068
1069 static void possibleTransparentUnionPointerType(QualType &T) {
1070   if (const RecordType *UT = T->getAsUnionType())
1071     if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1072       RecordDecl *UD = UT->getDecl();
1073       for (RecordDecl::field_iterator it = UD->field_begin(),
1074            itend = UD->field_end(); it != itend; ++it) {
1075         QualType QT = it->getType();
1076         if (QT->isAnyPointerType() || QT->isBlockPointerType()) {
1077           T = QT;
1078           return;
1079         }
1080       }
1081     }
1082 }
1083
1084 static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1085   if (!isFunctionOrMethod(D)) {
1086     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1087     << "alloc_size" << ExpectedFunctionOrMethod;
1088     return;
1089   }
1090
1091   if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
1092     return;
1093
1094   // In C++ the implicit 'this' function parameter also counts, and they are
1095   // counted from one.
1096   bool HasImplicitThisParam = isInstanceMethod(D);
1097   unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1098
1099   SmallVector<unsigned, 8> SizeArgs;
1100
1101   for (AttributeList::arg_iterator I = Attr.arg_begin(),
1102        E = Attr.arg_end(); I!=E; ++I) {
1103     // The argument must be an integer constant expression.
1104     Expr *Ex = *I;
1105     llvm::APSInt ArgNum;
1106     if (Ex->isTypeDependent() || Ex->isValueDependent() ||
1107         !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
1108       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1109       << "alloc_size" << Ex->getSourceRange();
1110       return;
1111     }
1112
1113     uint64_t x = ArgNum.getZExtValue();
1114
1115     if (x < 1 || x > NumArgs) {
1116       S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1117       << "alloc_size" << I.getArgNum() << Ex->getSourceRange();
1118       return;
1119     }
1120
1121     --x;
1122     if (HasImplicitThisParam) {
1123       if (x == 0) {
1124         S.Diag(Attr.getLoc(),
1125                diag::err_attribute_invalid_implicit_this_argument)
1126         << "alloc_size" << Ex->getSourceRange();
1127         return;
1128       }
1129       --x;
1130     }
1131
1132     // check if the function argument is of an integer type
1133     QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
1134     if (!T->isIntegerType()) {
1135       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1136       << "alloc_size" << Ex->getSourceRange();
1137       return;
1138     }
1139
1140     SizeArgs.push_back(x);
1141   }
1142
1143   // check if the function returns a pointer
1144   if (!getFunctionType(D)->getResultType()->isAnyPointerType()) {
1145     S.Diag(Attr.getLoc(), diag::warn_ns_attribute_wrong_return_type)
1146     << "alloc_size" << 0 /*function*/<< 1 /*pointer*/ << D->getSourceRange();
1147   }
1148
1149   D->addAttr(::new (S.Context) AllocSizeAttr(Attr.getRange(), S.Context,
1150                                              SizeArgs.data(), SizeArgs.size()));
1151 }
1152
1153 static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1154   // GCC ignores the nonnull attribute on K&R style function prototypes, so we
1155   // ignore it as well
1156   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
1157     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1158       << Attr.getName() << ExpectedFunction;
1159     return;
1160   }
1161
1162   // In C++ the implicit 'this' function parameter also counts, and they are
1163   // counted from one.
1164   bool HasImplicitThisParam = isInstanceMethod(D);
1165   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1166
1167   // The nonnull attribute only applies to pointers.
1168   SmallVector<unsigned, 10> NonNullArgs;
1169
1170   for (AttributeList::arg_iterator I=Attr.arg_begin(),
1171                                    E=Attr.arg_end(); I!=E; ++I) {
1172
1173
1174     // The argument must be an integer constant expression.
1175     Expr *Ex = *I;
1176     llvm::APSInt ArgNum(32);
1177     if (Ex->isTypeDependent() || Ex->isValueDependent() ||
1178         !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
1179       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1180         << "nonnull" << Ex->getSourceRange();
1181       return;
1182     }
1183
1184     unsigned x = (unsigned) ArgNum.getZExtValue();
1185
1186     if (x < 1 || x > NumArgs) {
1187       S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1188        << "nonnull" << I.getArgNum() << Ex->getSourceRange();
1189       return;
1190     }
1191
1192     --x;
1193     if (HasImplicitThisParam) {
1194       if (x == 0) {
1195         S.Diag(Attr.getLoc(),
1196                diag::err_attribute_invalid_implicit_this_argument)
1197           << "nonnull" << Ex->getSourceRange();
1198         return;
1199       }
1200       --x;
1201     }
1202
1203     // Is the function argument a pointer type?
1204     QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
1205     possibleTransparentUnionPointerType(T);
1206
1207     if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
1208       // FIXME: Should also highlight argument in decl.
1209       S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only)
1210         << "nonnull" << Ex->getSourceRange();
1211       continue;
1212     }
1213
1214     NonNullArgs.push_back(x);
1215   }
1216
1217   // If no arguments were specified to __attribute__((nonnull)) then all pointer
1218   // arguments have a nonnull attribute.
1219   if (NonNullArgs.empty()) {
1220     for (unsigned I = 0, E = getFunctionOrMethodNumArgs(D); I != E; ++I) {
1221       QualType T = getFunctionOrMethodArgType(D, I).getNonReferenceType();
1222       possibleTransparentUnionPointerType(T);
1223       if (T->isAnyPointerType() || T->isBlockPointerType())
1224         NonNullArgs.push_back(I);
1225     }
1226
1227     // No pointer arguments?
1228     if (NonNullArgs.empty()) {
1229       // Warn the trivial case only if attribute is not coming from a
1230       // macro instantiation.
1231       if (Attr.getLoc().isFileID())
1232         S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1233       return;
1234     }
1235   }
1236
1237   unsigned* start = &NonNullArgs[0];
1238   unsigned size = NonNullArgs.size();
1239   llvm::array_pod_sort(start, start + size);
1240   D->addAttr(::new (S.Context) NonNullAttr(Attr.getRange(), S.Context, start,
1241                                            size));
1242 }
1243
1244 static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
1245   // This attribute must be applied to a function declaration.
1246   // The first argument to the attribute must be a string,
1247   // the name of the resource, for example "malloc".
1248   // The following arguments must be argument indexes, the arguments must be
1249   // of integer type for Returns, otherwise of pointer type.
1250   // The difference between Holds and Takes is that a pointer may still be used
1251   // after being held.  free() should be __attribute((ownership_takes)), whereas
1252   // a list append function may well be __attribute((ownership_holds)).
1253
1254   if (!AL.getParameterName()) {
1255     S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string)
1256         << AL.getName()->getName() << 1;
1257     return;
1258   }
1259   // Figure out our Kind, and check arguments while we're at it.
1260   OwnershipAttr::OwnershipKind K;
1261   switch (AL.getKind()) {
1262   case AttributeList::AT_ownership_takes:
1263     K = OwnershipAttr::Takes;
1264     if (AL.getNumArgs() < 1) {
1265       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1266       return;
1267     }
1268     break;
1269   case AttributeList::AT_ownership_holds:
1270     K = OwnershipAttr::Holds;
1271     if (AL.getNumArgs() < 1) {
1272       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1273       return;
1274     }
1275     break;
1276   case AttributeList::AT_ownership_returns:
1277     K = OwnershipAttr::Returns;
1278     if (AL.getNumArgs() > 1) {
1279       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
1280           << AL.getNumArgs() + 1;
1281       return;
1282     }
1283     break;
1284   default:
1285     // This should never happen given how we are called.
1286     llvm_unreachable("Unknown ownership attribute");
1287   }
1288
1289   if (!isFunction(D) || !hasFunctionProto(D)) {
1290     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
1291       << AL.getName() << ExpectedFunction;
1292     return;
1293   }
1294
1295   // In C++ the implicit 'this' function parameter also counts, and they are
1296   // counted from one.
1297   bool HasImplicitThisParam = isInstanceMethod(D);
1298   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1299
1300   StringRef Module = AL.getParameterName()->getName();
1301
1302   // Normalize the argument, __foo__ becomes foo.
1303   if (Module.startswith("__") && Module.endswith("__"))
1304     Module = Module.substr(2, Module.size() - 4);
1305
1306   SmallVector<unsigned, 10> OwnershipArgs;
1307
1308   for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E;
1309        ++I) {
1310
1311     Expr *IdxExpr = *I;
1312     llvm::APSInt ArgNum(32);
1313     if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
1314         || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
1315       S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int)
1316           << AL.getName()->getName() << IdxExpr->getSourceRange();
1317       continue;
1318     }
1319
1320     unsigned x = (unsigned) ArgNum.getZExtValue();
1321
1322     if (x > NumArgs || x < 1) {
1323       S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
1324           << AL.getName()->getName() << x << IdxExpr->getSourceRange();
1325       continue;
1326     }
1327     --x;
1328     if (HasImplicitThisParam) {
1329       if (x == 0) {
1330         S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
1331           << "ownership" << IdxExpr->getSourceRange();
1332         return;
1333       }
1334       --x;
1335     }
1336
1337     switch (K) {
1338     case OwnershipAttr::Takes:
1339     case OwnershipAttr::Holds: {
1340       // Is the function argument a pointer type?
1341       QualType T = getFunctionOrMethodArgType(D, x);
1342       if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
1343         // FIXME: Should also highlight argument in decl.
1344         S.Diag(AL.getLoc(), diag::err_ownership_type)
1345             << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds")
1346             << "pointer"
1347             << IdxExpr->getSourceRange();
1348         continue;
1349       }
1350       break;
1351     }
1352     case OwnershipAttr::Returns: {
1353       if (AL.getNumArgs() > 1) {
1354           // Is the function argument an integer type?
1355           Expr *IdxExpr = AL.getArg(0);
1356           llvm::APSInt ArgNum(32);
1357           if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
1358               || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
1359             S.Diag(AL.getLoc(), diag::err_ownership_type)
1360                 << "ownership_returns" << "integer"
1361                 << IdxExpr->getSourceRange();
1362             return;
1363           }
1364       }
1365       break;
1366     }
1367     } // switch
1368
1369     // Check we don't have a conflict with another ownership attribute.
1370     for (specific_attr_iterator<OwnershipAttr>
1371           i = D->specific_attr_begin<OwnershipAttr>(),
1372           e = D->specific_attr_end<OwnershipAttr>();
1373         i != e; ++i) {
1374       if ((*i)->getOwnKind() != K) {
1375         for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end();
1376              I!=E; ++I) {
1377           if (x == *I) {
1378             S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1379                 << AL.getName()->getName() << "ownership_*";
1380           }
1381         }
1382       }
1383     }
1384     OwnershipArgs.push_back(x);
1385   }
1386
1387   unsigned* start = OwnershipArgs.data();
1388   unsigned size = OwnershipArgs.size();
1389   llvm::array_pod_sort(start, start + size);
1390
1391   if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) {
1392     S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1393     return;
1394   }
1395
1396   D->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module,
1397                                              start, size));
1398 }
1399
1400 /// Whether this declaration has internal linkage for the purposes of
1401 /// things that want to complain about things not have internal linkage.
1402 static bool hasEffectivelyInternalLinkage(NamedDecl *D) {
1403   switch (D->getLinkage()) {
1404   case NoLinkage:
1405   case InternalLinkage:
1406     return true;
1407
1408   // Template instantiations that go from external to unique-external
1409   // shouldn't get diagnosed.
1410   case UniqueExternalLinkage:
1411     return true;
1412
1413   case ExternalLinkage:
1414     return false;
1415   }
1416   llvm_unreachable("unknown linkage kind!");
1417 }
1418
1419 static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1420   // Check the attribute arguments.
1421   if (Attr.getNumArgs() > 1) {
1422     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1423     return;
1424   }
1425
1426   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
1427     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1428       << Attr.getName() << ExpectedVariableOrFunction;
1429     return;
1430   }
1431
1432   NamedDecl *nd = cast<NamedDecl>(D);
1433
1434   // gcc rejects
1435   // class c {
1436   //   static int a __attribute__((weakref ("v2")));
1437   //   static int b() __attribute__((weakref ("f3")));
1438   // };
1439   // and ignores the attributes of
1440   // void f(void) {
1441   //   static int a __attribute__((weakref ("v2")));
1442   // }
1443   // we reject them
1444   const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1445   if (!Ctx->isFileContext()) {
1446     S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
1447         nd->getNameAsString();
1448     return;
1449   }
1450
1451   // The GCC manual says
1452   //
1453   // At present, a declaration to which `weakref' is attached can only
1454   // be `static'.
1455   //
1456   // It also says
1457   //
1458   // Without a TARGET,
1459   // given as an argument to `weakref' or to `alias', `weakref' is
1460   // equivalent to `weak'.
1461   //
1462   // gcc 4.4.1 will accept
1463   // int a7 __attribute__((weakref));
1464   // as
1465   // int a7 __attribute__((weak));
1466   // This looks like a bug in gcc. We reject that for now. We should revisit
1467   // it if this behaviour is actually used.
1468
1469   if (!hasEffectivelyInternalLinkage(nd)) {
1470     S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static);
1471     return;
1472   }
1473
1474   // GCC rejects
1475   // static ((alias ("y"), weakref)).
1476   // Should we? How to check that weakref is before or after alias?
1477
1478   if (Attr.getNumArgs() == 1) {
1479     Expr *Arg = Attr.getArg(0);
1480     Arg = Arg->IgnoreParenCasts();
1481     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1482
1483     if (!Str || !Str->isAscii()) {
1484       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1485           << "weakref" << 1;
1486       return;
1487     }
1488     // GCC will accept anything as the argument of weakref. Should we
1489     // check for an existing decl?
1490     D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context,
1491                                            Str->getString()));
1492   }
1493
1494   D->addAttr(::new (S.Context) WeakRefAttr(Attr.getRange(), S.Context));
1495 }
1496
1497 static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1498   // check the attribute arguments.
1499   if (Attr.getNumArgs() != 1) {
1500     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1501     return;
1502   }
1503
1504   Expr *Arg = Attr.getArg(0);
1505   Arg = Arg->IgnoreParenCasts();
1506   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1507
1508   if (!Str || !Str->isAscii()) {
1509     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1510       << "alias" << 1;
1511     return;
1512   }
1513
1514   if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1515     S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1516     return;
1517   }
1518
1519   // FIXME: check if target symbol exists in current file
1520
1521   D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context,
1522                                          Str->getString()));
1523 }
1524
1525 static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1526   // Check the attribute arguments.
1527   if (!checkAttributeNumArgs(S, Attr, 0))
1528     return;
1529
1530   if (!isa<FunctionDecl>(D)) {
1531     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1532       << Attr.getName() << ExpectedFunction;
1533     return;
1534   }
1535
1536   if (D->hasAttr<HotAttr>()) {
1537     S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
1538       << Attr.getName() << "hot";
1539     return;
1540   }
1541
1542   D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context));
1543 }
1544
1545 static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1546   // Check the attribute arguments.
1547   if (!checkAttributeNumArgs(S, Attr, 0))
1548     return;
1549
1550   if (!isa<FunctionDecl>(D)) {
1551     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1552       << Attr.getName() << ExpectedFunction;
1553     return;
1554   }
1555
1556   if (D->hasAttr<ColdAttr>()) {
1557     S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
1558       << Attr.getName() << "cold";
1559     return;
1560   }
1561
1562   D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context));
1563 }
1564
1565 static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1566   // Check the attribute arguments.
1567   if (!checkAttributeNumArgs(S, Attr, 0))
1568     return;
1569
1570   if (!isa<FunctionDecl>(D)) {
1571     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1572       << Attr.getName() << ExpectedFunction;
1573     return;
1574   }
1575
1576   D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context));
1577 }
1578
1579 static void handleAlwaysInlineAttr(Sema &S, Decl *D,
1580                                    const AttributeList &Attr) {
1581   // Check the attribute arguments.
1582   if (Attr.hasParameterOrArguments()) {
1583     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1584     return;
1585   }
1586
1587   if (!isa<FunctionDecl>(D)) {
1588     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1589       << Attr.getName() << ExpectedFunction;
1590     return;
1591   }
1592
1593   D->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getRange(), S.Context));
1594 }
1595
1596 static void handleTLSModelAttr(Sema &S, Decl *D,
1597                                const AttributeList &Attr) {
1598   // Check the attribute arguments.
1599   if (Attr.getNumArgs() != 1) {
1600     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1601     return;
1602   }
1603
1604   Expr *Arg = Attr.getArg(0);
1605   Arg = Arg->IgnoreParenCasts();
1606   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1607
1608   // Check that it is a string.
1609   if (!Str) {
1610     S.Diag(Attr.getLoc(), diag::err_attribute_not_string) << "tls_model";
1611     return;
1612   }
1613
1614   if (!isa<VarDecl>(D) || !cast<VarDecl>(D)->isThreadSpecified()) {
1615     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1616       << Attr.getName() << ExpectedTLSVar;
1617     return;
1618   }
1619
1620   // Check that the value.
1621   StringRef Model = Str->getString();
1622   if (Model != "global-dynamic" && Model != "local-dynamic"
1623       && Model != "initial-exec" && Model != "local-exec") {
1624     S.Diag(Attr.getLoc(), diag::err_attr_tlsmodel_arg);
1625     return;
1626   }
1627
1628   D->addAttr(::new (S.Context) TLSModelAttr(Attr.getRange(), S.Context,
1629                                             Model));
1630 }
1631
1632 static void handleMallocAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1633   // Check the attribute arguments.
1634   if (Attr.hasParameterOrArguments()) {
1635     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1636     return;
1637   }
1638
1639   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1640     QualType RetTy = FD->getResultType();
1641     if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
1642       D->addAttr(::new (S.Context) MallocAttr(Attr.getRange(), S.Context));
1643       return;
1644     }
1645   }
1646
1647   S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
1648 }
1649
1650 static void handleMayAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1651   // check the attribute arguments.
1652   if (!checkAttributeNumArgs(S, Attr, 0))
1653     return;
1654
1655   D->addAttr(::new (S.Context) MayAliasAttr(Attr.getRange(), S.Context));
1656 }
1657
1658 static void handleNoCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1659   assert(!Attr.isInvalid());
1660   if (isa<VarDecl>(D))
1661     D->addAttr(::new (S.Context) NoCommonAttr(Attr.getRange(), S.Context));
1662   else
1663     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1664       << Attr.getName() << ExpectedVariable;
1665 }
1666
1667 static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1668   assert(!Attr.isInvalid());
1669   if (isa<VarDecl>(D))
1670     D->addAttr(::new (S.Context) CommonAttr(Attr.getRange(), S.Context));
1671   else
1672     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1673       << Attr.getName() << ExpectedVariable;
1674 }
1675
1676 static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
1677   if (hasDeclarator(D)) return;
1678
1679   if (S.CheckNoReturnAttr(attr)) return;
1680
1681   if (!isa<ObjCMethodDecl>(D)) {
1682     S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1683       << attr.getName() << ExpectedFunctionOrMethod;
1684     return;
1685   }
1686
1687   D->addAttr(::new (S.Context) NoReturnAttr(attr.getRange(), S.Context));
1688 }
1689
1690 bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
1691   if (attr.hasParameterOrArguments()) {
1692     Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1693     attr.setInvalid();
1694     return true;
1695   }
1696
1697   return false;
1698 }
1699
1700 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
1701                                        const AttributeList &Attr) {
1702
1703   // The checking path for 'noreturn' and 'analyzer_noreturn' are different
1704   // because 'analyzer_noreturn' does not impact the type.
1705
1706   if(!checkAttributeNumArgs(S, Attr, 0))
1707       return;
1708
1709   if (!isFunctionOrMethod(D) && !isa<BlockDecl>(D)) {
1710     ValueDecl *VD = dyn_cast<ValueDecl>(D);
1711     if (VD == 0 || (!VD->getType()->isBlockPointerType()
1712                     && !VD->getType()->isFunctionPointerType())) {
1713       S.Diag(Attr.getLoc(),
1714              Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1715              : diag::warn_attribute_wrong_decl_type)
1716         << Attr.getName() << ExpectedFunctionMethodOrBlock;
1717       return;
1718     }
1719   }
1720
1721   D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getRange(), S.Context));
1722 }
1723
1724 // PS3 PPU-specific.
1725 static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1726 /*
1727   Returning a Vector Class in Registers
1728
1729   According to the PPU ABI specifications, a class with a single member of
1730   vector type is returned in memory when used as the return value of a function.
1731   This results in inefficient code when implementing vector classes. To return
1732   the value in a single vector register, add the vecreturn attribute to the
1733   class definition. This attribute is also applicable to struct types.
1734
1735   Example:
1736
1737   struct Vector
1738   {
1739     __vector float xyzw;
1740   } __attribute__((vecreturn));
1741
1742   Vector Add(Vector lhs, Vector rhs)
1743   {
1744     Vector result;
1745     result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
1746     return result; // This will be returned in a register
1747   }
1748 */
1749   if (!isa<RecordDecl>(D)) {
1750     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1751       << Attr.getName() << ExpectedClass;
1752     return;
1753   }
1754
1755   if (D->getAttr<VecReturnAttr>()) {
1756     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn";
1757     return;
1758   }
1759
1760   RecordDecl *record = cast<RecordDecl>(D);
1761   int count = 0;
1762
1763   if (!isa<CXXRecordDecl>(record)) {
1764     S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1765     return;
1766   }
1767
1768   if (!cast<CXXRecordDecl>(record)->isPOD()) {
1769     S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
1770     return;
1771   }
1772
1773   for (RecordDecl::field_iterator iter = record->field_begin();
1774        iter != record->field_end(); iter++) {
1775     if ((count == 1) || !iter->getType()->isVectorType()) {
1776       S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1777       return;
1778     }
1779     count++;
1780   }
1781
1782   D->addAttr(::new (S.Context) VecReturnAttr(Attr.getRange(), S.Context));
1783 }
1784
1785 static void handleDependencyAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1786   if (!isFunctionOrMethod(D) && !isa<ParmVarDecl>(D)) {
1787     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1788       << Attr.getName() << ExpectedFunctionMethodOrParameter;
1789     return;
1790   }
1791   // FIXME: Actually store the attribute on the declaration
1792 }
1793
1794 static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1795   // check the attribute arguments.
1796   if (Attr.hasParameterOrArguments()) {
1797     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1798     return;
1799   }
1800
1801   if (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isFunctionOrMethod(D) &&
1802       !isa<TypeDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D)) {
1803     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1804       << Attr.getName() << ExpectedVariableFunctionOrLabel;
1805     return;
1806   }
1807
1808   D->addAttr(::new (S.Context) UnusedAttr(Attr.getRange(), S.Context));
1809 }
1810
1811 static void handleReturnsTwiceAttr(Sema &S, Decl *D,
1812                                    const AttributeList &Attr) {
1813   // check the attribute arguments.
1814   if (Attr.hasParameterOrArguments()) {
1815     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1816     return;
1817   }
1818
1819   if (!isa<FunctionDecl>(D)) {
1820     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1821       << Attr.getName() << ExpectedFunction;
1822     return;
1823   }
1824
1825   D->addAttr(::new (S.Context) ReturnsTwiceAttr(Attr.getRange(), S.Context));
1826 }
1827
1828 static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1829   // check the attribute arguments.
1830   if (Attr.hasParameterOrArguments()) {
1831     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1832     return;
1833   }
1834
1835   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1836     if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
1837       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
1838       return;
1839     }
1840   } else if (!isFunctionOrMethod(D)) {
1841     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1842       << Attr.getName() << ExpectedVariableOrFunction;
1843     return;
1844   }
1845
1846   D->addAttr(::new (S.Context) UsedAttr(Attr.getRange(), S.Context));
1847 }
1848
1849 static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1850   // check the attribute arguments.
1851   if (Attr.getNumArgs() > 1) {
1852     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1853     return;
1854   }
1855
1856   int priority = 65535; // FIXME: Do not hardcode such constants.
1857   if (Attr.getNumArgs() > 0) {
1858     Expr *E = Attr.getArg(0);
1859     llvm::APSInt Idx(32);
1860     if (E->isTypeDependent() || E->isValueDependent() ||
1861         !E->isIntegerConstantExpr(Idx, S.Context)) {
1862       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1863         << "constructor" << 1 << E->getSourceRange();
1864       return;
1865     }
1866     priority = Idx.getZExtValue();
1867   }
1868
1869   if (!isa<FunctionDecl>(D)) {
1870     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1871       << Attr.getName() << ExpectedFunction;
1872     return;
1873   }
1874
1875   D->addAttr(::new (S.Context) ConstructorAttr(Attr.getRange(), S.Context,
1876                                                priority));
1877 }
1878
1879 static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1880   // check the attribute arguments.
1881   if (Attr.getNumArgs() > 1) {
1882     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1883     return;
1884   }
1885
1886   int priority = 65535; // FIXME: Do not hardcode such constants.
1887   if (Attr.getNumArgs() > 0) {
1888     Expr *E = Attr.getArg(0);
1889     llvm::APSInt Idx(32);
1890     if (E->isTypeDependent() || E->isValueDependent() ||
1891         !E->isIntegerConstantExpr(Idx, S.Context)) {
1892       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1893         << "destructor" << 1 << E->getSourceRange();
1894       return;
1895     }
1896     priority = Idx.getZExtValue();
1897   }
1898
1899   if (!isa<FunctionDecl>(D)) {
1900     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1901       << Attr.getName() << ExpectedFunction;
1902     return;
1903   }
1904
1905   D->addAttr(::new (S.Context) DestructorAttr(Attr.getRange(), S.Context,
1906                                               priority));
1907 }
1908
1909 template <typename AttrTy>
1910 static void handleAttrWithMessage(Sema &S, Decl *D, const AttributeList &Attr,
1911                                   const char *Name) {
1912   unsigned NumArgs = Attr.getNumArgs();
1913   if (NumArgs > 1) {
1914     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1915     return;
1916   }
1917
1918   // Handle the case where the attribute has a text message.
1919   StringRef Str;
1920   if (NumArgs == 1) {
1921     StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
1922     if (!SE) {
1923       S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string)
1924         << Name;
1925       return;
1926     }
1927     Str = SE->getString();
1928   }
1929
1930   D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str));
1931 }
1932
1933 static void handleArcWeakrefUnavailableAttr(Sema &S, Decl *D,
1934                                             const AttributeList &Attr) {
1935   unsigned NumArgs = Attr.getNumArgs();
1936   if (NumArgs > 0) {
1937     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1938     return;
1939   }
1940
1941   D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(
1942                                           Attr.getRange(), S.Context));
1943 }
1944
1945 static void handleObjCRootClassAttr(Sema &S, Decl *D,
1946                                     const AttributeList &Attr) {
1947   if (!isa<ObjCInterfaceDecl>(D)) {
1948     S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1949     return;
1950   }
1951
1952   unsigned NumArgs = Attr.getNumArgs();
1953   if (NumArgs > 0) {
1954     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1955     return;
1956   }
1957
1958   D->addAttr(::new (S.Context) ObjCRootClassAttr(Attr.getRange(), S.Context));
1959 }
1960
1961 static void handleObjCRequiresPropertyDefsAttr(Sema &S, Decl *D,
1962                                             const AttributeList &Attr) {
1963   if (!isa<ObjCInterfaceDecl>(D)) {
1964     S.Diag(Attr.getLoc(), diag::err_suppress_autosynthesis);
1965     return;
1966   }
1967
1968   unsigned NumArgs = Attr.getNumArgs();
1969   if (NumArgs > 0) {
1970     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1971     return;
1972   }
1973
1974   D->addAttr(::new (S.Context) ObjCRequiresPropertyDefsAttr(
1975                                  Attr.getRange(), S.Context));
1976 }
1977
1978 static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
1979                                   IdentifierInfo *Platform,
1980                                   VersionTuple Introduced,
1981                                   VersionTuple Deprecated,
1982                                   VersionTuple Obsoleted) {
1983   StringRef PlatformName
1984     = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1985   if (PlatformName.empty())
1986     PlatformName = Platform->getName();
1987
1988   // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
1989   // of these steps are needed).
1990   if (!Introduced.empty() && !Deprecated.empty() &&
1991       !(Introduced <= Deprecated)) {
1992     S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1993       << 1 << PlatformName << Deprecated.getAsString()
1994       << 0 << Introduced.getAsString();
1995     return true;
1996   }
1997
1998   if (!Introduced.empty() && !Obsoleted.empty() &&
1999       !(Introduced <= Obsoleted)) {
2000     S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2001       << 2 << PlatformName << Obsoleted.getAsString()
2002       << 0 << Introduced.getAsString();
2003     return true;
2004   }
2005
2006   if (!Deprecated.empty() && !Obsoleted.empty() &&
2007       !(Deprecated <= Obsoleted)) {
2008     S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2009       << 2 << PlatformName << Obsoleted.getAsString()
2010       << 1 << Deprecated.getAsString();
2011     return true;
2012   }
2013
2014   return false;
2015 }
2016
2017 AvailabilityAttr *Sema::mergeAvailabilityAttr(Decl *D, SourceRange Range,
2018                                               IdentifierInfo *Platform,
2019                                               VersionTuple Introduced,
2020                                               VersionTuple Deprecated,
2021                                               VersionTuple Obsoleted,
2022                                               bool IsUnavailable,
2023                                               StringRef Message) {
2024   VersionTuple MergedIntroduced = Introduced;
2025   VersionTuple MergedDeprecated = Deprecated;
2026   VersionTuple MergedObsoleted = Obsoleted;
2027   bool FoundAny = false;
2028
2029   if (D->hasAttrs()) {
2030     AttrVec &Attrs = D->getAttrs();
2031     for (unsigned i = 0, e = Attrs.size(); i != e;) {
2032       const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2033       if (!OldAA) {
2034         ++i;
2035         continue;
2036       }
2037
2038       IdentifierInfo *OldPlatform = OldAA->getPlatform();
2039       if (OldPlatform != Platform) {
2040         ++i;
2041         continue;
2042       }
2043
2044       FoundAny = true;
2045       VersionTuple OldIntroduced = OldAA->getIntroduced();
2046       VersionTuple OldDeprecated = OldAA->getDeprecated();
2047       VersionTuple OldObsoleted = OldAA->getObsoleted();
2048       bool OldIsUnavailable = OldAA->getUnavailable();
2049       StringRef OldMessage = OldAA->getMessage();
2050
2051       if ((!OldIntroduced.empty() && !Introduced.empty() &&
2052            OldIntroduced != Introduced) ||
2053           (!OldDeprecated.empty() && !Deprecated.empty() &&
2054            OldDeprecated != Deprecated) ||
2055           (!OldObsoleted.empty() && !Obsoleted.empty() &&
2056            OldObsoleted != Obsoleted) ||
2057           (OldIsUnavailable != IsUnavailable) ||
2058           (OldMessage != Message)) {
2059         Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2060         Diag(Range.getBegin(), diag::note_previous_attribute);
2061         Attrs.erase(Attrs.begin() + i);
2062         --e;
2063         continue;
2064       }
2065
2066       VersionTuple MergedIntroduced2 = MergedIntroduced;
2067       VersionTuple MergedDeprecated2 = MergedDeprecated;
2068       VersionTuple MergedObsoleted2 = MergedObsoleted;
2069
2070       if (MergedIntroduced2.empty())
2071         MergedIntroduced2 = OldIntroduced;
2072       if (MergedDeprecated2.empty())
2073         MergedDeprecated2 = OldDeprecated;
2074       if (MergedObsoleted2.empty())
2075         MergedObsoleted2 = OldObsoleted;
2076
2077       if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2078                                 MergedIntroduced2, MergedDeprecated2,
2079                                 MergedObsoleted2)) {
2080         Attrs.erase(Attrs.begin() + i);
2081         --e;
2082         continue;
2083       }
2084
2085       MergedIntroduced = MergedIntroduced2;
2086       MergedDeprecated = MergedDeprecated2;
2087       MergedObsoleted = MergedObsoleted2;
2088       ++i;
2089     }
2090   }
2091
2092   if (FoundAny &&
2093       MergedIntroduced == Introduced &&
2094       MergedDeprecated == Deprecated &&
2095       MergedObsoleted == Obsoleted)
2096     return NULL;
2097
2098   if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2099                              MergedDeprecated, MergedObsoleted)) {
2100     return ::new (Context) AvailabilityAttr(Range, Context, Platform,
2101                                             Introduced, Deprecated,
2102                                             Obsoleted, IsUnavailable, Message);
2103   }
2104   return NULL;
2105 }
2106
2107 static void handleAvailabilityAttr(Sema &S, Decl *D,
2108                                    const AttributeList &Attr) {
2109   IdentifierInfo *Platform = Attr.getParameterName();
2110   SourceLocation PlatformLoc = Attr.getParameterLoc();
2111
2112   if (AvailabilityAttr::getPrettyPlatformName(Platform->getName()).empty())
2113     S.Diag(PlatformLoc, diag::warn_availability_unknown_platform)
2114       << Platform;
2115
2116   AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
2117   AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
2118   AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
2119   bool IsUnavailable = Attr.getUnavailableLoc().isValid();
2120   StringRef Str;
2121   const StringLiteral *SE =
2122     dyn_cast_or_null<const StringLiteral>(Attr.getMessageExpr());
2123   if (SE)
2124     Str = SE->getString();
2125
2126   AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(D, Attr.getRange(),
2127                                                       Platform,
2128                                                       Introduced.Version,
2129                                                       Deprecated.Version,
2130                                                       Obsoleted.Version,
2131                                                       IsUnavailable, Str);
2132   if (NewAttr)
2133     D->addAttr(NewAttr);
2134 }
2135
2136 VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2137                                           VisibilityAttr::VisibilityType Vis) {
2138   if (isa<TypedefNameDecl>(D)) {
2139     Diag(Range.getBegin(), diag::warn_attribute_ignored) << "visibility";
2140     return NULL;
2141   }
2142   VisibilityAttr *ExistingAttr = D->getAttr<VisibilityAttr>();
2143   if (ExistingAttr) {
2144     VisibilityAttr::VisibilityType ExistingVis = ExistingAttr->getVisibility();
2145     if (ExistingVis == Vis)
2146       return NULL;
2147     Diag(ExistingAttr->getLocation(), diag::err_mismatched_visibility);
2148     Diag(Range.getBegin(), diag::note_previous_attribute);
2149     D->dropAttr<VisibilityAttr>();
2150   }
2151   return ::new (Context) VisibilityAttr(Range, Context, Vis);
2152 }
2153
2154 static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2155   // check the attribute arguments.
2156   if(!checkAttributeNumArgs(S, Attr, 1))
2157     return;
2158
2159   Expr *Arg = Attr.getArg(0);
2160   Arg = Arg->IgnoreParenCasts();
2161   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2162
2163   if (!Str || !Str->isAscii()) {
2164     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2165       << "visibility" << 1;
2166     return;
2167   }
2168
2169   StringRef TypeStr = Str->getString();
2170   VisibilityAttr::VisibilityType type;
2171
2172   if (TypeStr == "default")
2173     type = VisibilityAttr::Default;
2174   else if (TypeStr == "hidden")
2175     type = VisibilityAttr::Hidden;
2176   else if (TypeStr == "internal")
2177     type = VisibilityAttr::Hidden; // FIXME
2178   else if (TypeStr == "protected") {
2179     // Complain about attempts to use protected visibility on targets
2180     // (like Darwin) that don't support it.
2181     if (!S.Context.getTargetInfo().hasProtectedVisibility()) {
2182       S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
2183       type = VisibilityAttr::Default;
2184     } else {
2185       type = VisibilityAttr::Protected;
2186     }
2187   } else {
2188     S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
2189     return;
2190   }
2191
2192   VisibilityAttr *NewAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type);
2193   if (NewAttr)
2194     D->addAttr(NewAttr);
2195 }
2196
2197 static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
2198                                        const AttributeList &Attr) {
2199   ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl);
2200   if (!method) {
2201     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
2202       << ExpectedMethod;
2203     return;
2204   }
2205
2206   if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) {
2207     if (!Attr.getParameterName() && Attr.getNumArgs() == 1) {
2208       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2209         << "objc_method_family" << 1;
2210     } else {
2211       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2212     }
2213     Attr.setInvalid();
2214     return;
2215   }
2216
2217   StringRef param = Attr.getParameterName()->getName();
2218   ObjCMethodFamilyAttr::FamilyKind family;
2219   if (param == "none")
2220     family = ObjCMethodFamilyAttr::OMF_None;
2221   else if (param == "alloc")
2222     family = ObjCMethodFamilyAttr::OMF_alloc;
2223   else if (param == "copy")
2224     family = ObjCMethodFamilyAttr::OMF_copy;
2225   else if (param == "init")
2226     family = ObjCMethodFamilyAttr::OMF_init;
2227   else if (param == "mutableCopy")
2228     family = ObjCMethodFamilyAttr::OMF_mutableCopy;
2229   else if (param == "new")
2230     family = ObjCMethodFamilyAttr::OMF_new;
2231   else {
2232     // Just warn and ignore it.  This is future-proof against new
2233     // families being used in system headers.
2234     S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family);
2235     return;
2236   }
2237
2238   if (family == ObjCMethodFamilyAttr::OMF_init &&
2239       !method->getResultType()->isObjCObjectPointerType()) {
2240     S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
2241       << method->getResultType();
2242     // Ignore the attribute.
2243     return;
2244   }
2245
2246   method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
2247                                                        S.Context, family));
2248 }
2249
2250 static void handleObjCExceptionAttr(Sema &S, Decl *D,
2251                                     const AttributeList &Attr) {
2252   if (!checkAttributeNumArgs(S, Attr, 0))
2253     return;
2254
2255   ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
2256   if (OCI == 0) {
2257     S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
2258     return;
2259   }
2260
2261   D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getRange(), S.Context));
2262 }
2263
2264 static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
2265   if (Attr.getNumArgs() != 0) {
2266     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2267     return;
2268   }
2269   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2270     QualType T = TD->getUnderlyingType();
2271     if (!T->isPointerType() ||
2272         !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
2273       S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2274       return;
2275     }
2276   }
2277   else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2278     QualType T = PD->getType();
2279     if (!T->isPointerType() ||
2280         !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
2281       S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2282       return;
2283     }
2284   }
2285   else {
2286     // It is okay to include this attribute on properties, e.g.:
2287     //
2288     //  @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2289     //
2290     // In this case it follows tradition and suppresses an error in the above
2291     // case.
2292     S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2293   }
2294   D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getRange(), S.Context));
2295 }
2296
2297 static void
2298 handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2299   if (Attr.getNumArgs() != 0) {
2300     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2301     return;
2302   }
2303
2304   if (!isa<FunctionDecl>(D)) {
2305     S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
2306     return;
2307   }
2308
2309   D->addAttr(::new (S.Context) OverloadableAttr(Attr.getRange(), S.Context));
2310 }
2311
2312 static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2313   if (!Attr.getParameterName()) {
2314     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2315       << "blocks" << 1;
2316     return;
2317   }
2318
2319   if (Attr.getNumArgs() != 0) {
2320     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2321     return;
2322   }
2323
2324   BlocksAttr::BlockType type;
2325   if (Attr.getParameterName()->isStr("byref"))
2326     type = BlocksAttr::ByRef;
2327   else {
2328     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2329       << "blocks" << Attr.getParameterName();
2330     return;
2331   }
2332
2333   D->addAttr(::new (S.Context) BlocksAttr(Attr.getRange(), S.Context, type));
2334 }
2335
2336 static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2337   // check the attribute arguments.
2338   if (Attr.getNumArgs() > 2) {
2339     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
2340     return;
2341   }
2342
2343   unsigned sentinel = 0;
2344   if (Attr.getNumArgs() > 0) {
2345     Expr *E = Attr.getArg(0);
2346     llvm::APSInt Idx(32);
2347     if (E->isTypeDependent() || E->isValueDependent() ||
2348         !E->isIntegerConstantExpr(Idx, S.Context)) {
2349       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2350        << "sentinel" << 1 << E->getSourceRange();
2351       return;
2352     }
2353
2354     if (Idx.isSigned() && Idx.isNegative()) {
2355       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2356         << E->getSourceRange();
2357       return;
2358     }
2359
2360     sentinel = Idx.getZExtValue();
2361   }
2362
2363   unsigned nullPos = 0;
2364   if (Attr.getNumArgs() > 1) {
2365     Expr *E = Attr.getArg(1);
2366     llvm::APSInt Idx(32);
2367     if (E->isTypeDependent() || E->isValueDependent() ||
2368         !E->isIntegerConstantExpr(Idx, S.Context)) {
2369       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2370         << "sentinel" << 2 << E->getSourceRange();
2371       return;
2372     }
2373     nullPos = Idx.getZExtValue();
2374
2375     if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2376       // FIXME: This error message could be improved, it would be nice
2377       // to say what the bounds actually are.
2378       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2379         << E->getSourceRange();
2380       return;
2381     }
2382   }
2383
2384   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2385     const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2386     if (isa<FunctionNoProtoType>(FT)) {
2387       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2388       return;
2389     }
2390
2391     if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2392       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2393       return;
2394     }
2395   } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
2396     if (!MD->isVariadic()) {
2397       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2398       return;
2399     }
2400   } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
2401     if (!BD->isVariadic()) {
2402       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2403       return;
2404     }
2405   } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
2406     QualType Ty = V->getType();
2407     if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2408       const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D)
2409        : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2410       if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2411         int m = Ty->isFunctionPointerType() ? 0 : 1;
2412         S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2413         return;
2414       }
2415     } else {
2416       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2417         << Attr.getName() << ExpectedFunctionMethodOrBlock;
2418       return;
2419     }
2420   } else {
2421     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2422       << Attr.getName() << ExpectedFunctionMethodOrBlock;
2423     return;
2424   }
2425   D->addAttr(::new (S.Context) SentinelAttr(Attr.getRange(), S.Context, sentinel,
2426                                             nullPos));
2427 }
2428
2429 static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
2430   // check the attribute arguments.
2431   if (!checkAttributeNumArgs(S, Attr, 0))
2432     return;
2433
2434   if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
2435     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2436       << Attr.getName() << ExpectedFunctionOrMethod;
2437     return;
2438   }
2439
2440   if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
2441     S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2442       << Attr.getName() << 0;
2443     return;
2444   }
2445   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2446     if (MD->getResultType()->isVoidType()) {
2447       S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2448       << Attr.getName() << 1;
2449       return;
2450     }
2451
2452   D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getRange(), S.Context));
2453 }
2454
2455 static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2456   // check the attribute arguments.
2457   if (Attr.hasParameterOrArguments()) {
2458     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2459     return;
2460   }
2461
2462   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
2463     if (isa<CXXRecordDecl>(D)) {
2464       D->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
2465       return;
2466     }
2467     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2468       << Attr.getName() << ExpectedVariableOrFunction;
2469     return;
2470   }
2471
2472   NamedDecl *nd = cast<NamedDecl>(D);
2473
2474   // 'weak' only applies to declarations with external linkage.
2475   if (hasEffectivelyInternalLinkage(nd)) {
2476     S.Diag(Attr.getLoc(), diag::err_attribute_weak_static);
2477     return;
2478   }
2479
2480   nd->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
2481 }
2482
2483 static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2484   // check the attribute arguments.
2485   if (!checkAttributeNumArgs(S, Attr, 0))
2486     return;
2487
2488
2489   // weak_import only applies to variable & function declarations.
2490   bool isDef = false;
2491   if (!D->canBeWeakImported(isDef)) {
2492     if (isDef)
2493       S.Diag(Attr.getLoc(),
2494              diag::warn_attribute_weak_import_invalid_on_definition)
2495         << "weak_import" << 2 /*variable and function*/;
2496     else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2497              (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2498               (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2499       // Nothing to warn about here.
2500     } else
2501       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2502         << Attr.getName() << ExpectedVariableOrFunction;
2503
2504     return;
2505   }
2506
2507   D->addAttr(::new (S.Context) WeakImportAttr(Attr.getRange(), S.Context));
2508 }
2509
2510 // Handles reqd_work_group_size and work_group_size_hint.
2511 static void handleWorkGroupSize(Sema &S, Decl *D,
2512                                 const AttributeList &Attr) {
2513   assert(Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize
2514       || Attr.getKind() == AttributeList::AT_WorkGroupSizeHint);
2515
2516   // Attribute has 3 arguments.
2517   if (!checkAttributeNumArgs(S, Attr, 3)) return;
2518
2519   unsigned WGSize[3];
2520   for (unsigned i = 0; i < 3; ++i) {
2521     Expr *E = Attr.getArg(i);
2522     llvm::APSInt ArgNum(32);
2523     if (E->isTypeDependent() || E->isValueDependent() ||
2524         !E->isIntegerConstantExpr(ArgNum, S.Context)) {
2525       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2526         << Attr.getName()->getName() << E->getSourceRange();
2527       return;
2528     }
2529     WGSize[i] = (unsigned) ArgNum.getZExtValue();
2530   }
2531
2532   if (Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize
2533     && D->hasAttr<ReqdWorkGroupSizeAttr>()) {
2534       ReqdWorkGroupSizeAttr *A = D->getAttr<ReqdWorkGroupSizeAttr>();
2535       if (!(A->getXDim() == WGSize[0] &&
2536             A->getYDim() == WGSize[1] &&
2537             A->getZDim() == WGSize[2])) {
2538         S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) <<
2539           Attr.getName();
2540       }
2541   }
2542
2543   if (Attr.getKind() == AttributeList::AT_WorkGroupSizeHint
2544     && D->hasAttr<WorkGroupSizeHintAttr>()) {
2545       WorkGroupSizeHintAttr *A = D->getAttr<WorkGroupSizeHintAttr>();
2546       if (!(A->getXDim() == WGSize[0] &&
2547             A->getYDim() == WGSize[1] &&
2548             A->getZDim() == WGSize[2])) {
2549         S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) <<
2550           Attr.getName();
2551       }
2552   }
2553
2554   if (Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize)
2555     D->addAttr(::new (S.Context)
2556                  ReqdWorkGroupSizeAttr(Attr.getRange(), S.Context,
2557                                        WGSize[0], WGSize[1], WGSize[2]));
2558   else
2559     D->addAttr(::new (S.Context)
2560                  WorkGroupSizeHintAttr(Attr.getRange(), S.Context,
2561                                        WGSize[0], WGSize[1], WGSize[2]));
2562 }
2563
2564 SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2565                                     StringRef Name) {
2566   if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2567     if (ExistingAttr->getName() == Name)
2568       return NULL;
2569     Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
2570     Diag(Range.getBegin(), diag::note_previous_attribute);
2571     return NULL;
2572   }
2573   return ::new (Context) SectionAttr(Range, Context, Name);
2574 }
2575
2576 static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2577   // Attribute has no arguments.
2578   if (!checkAttributeNumArgs(S, Attr, 1))
2579     return;
2580
2581   // Make sure that there is a string literal as the sections's single
2582   // argument.
2583   Expr *ArgExpr = Attr.getArg(0);
2584   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
2585   if (!SE) {
2586     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
2587     return;
2588   }
2589
2590   // If the target wants to validate the section specifier, make it happen.
2591   std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(SE->getString());
2592   if (!Error.empty()) {
2593     S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
2594     << Error;
2595     return;
2596   }
2597
2598   // This attribute cannot be applied to local variables.
2599   if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
2600     S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
2601     return;
2602   }
2603   SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(),
2604                                             SE->getString());
2605   if (NewAttr)
2606     D->addAttr(NewAttr);
2607 }
2608
2609
2610 static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2611   // check the attribute arguments.
2612   if (Attr.hasParameterOrArguments()) {
2613     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2614     return;
2615   }
2616
2617   if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) {
2618     if (Existing->getLocation().isInvalid())
2619       Existing->setRange(Attr.getRange());
2620   } else {
2621     D->addAttr(::new (S.Context) NoThrowAttr(Attr.getRange(), S.Context));
2622   }
2623 }
2624
2625 static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2626   // check the attribute arguments.
2627   if (Attr.hasParameterOrArguments()) {
2628     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2629     return;
2630   }
2631
2632   if (ConstAttr *Existing = D->getAttr<ConstAttr>()) {
2633    if (Existing->getLocation().isInvalid())
2634      Existing->setRange(Attr.getRange());
2635   } else {
2636     D->addAttr(::new (S.Context) ConstAttr(Attr.getRange(), S.Context));
2637   }
2638 }
2639
2640 static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2641   // check the attribute arguments.
2642   if (!checkAttributeNumArgs(S, Attr, 0))
2643     return;
2644
2645   D->addAttr(::new (S.Context) PureAttr(Attr.getRange(), S.Context));
2646 }
2647
2648 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2649   if (!Attr.getParameterName()) {
2650     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2651     return;
2652   }
2653
2654   if (Attr.getNumArgs() != 0) {
2655     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2656     return;
2657   }
2658
2659   VarDecl *VD = dyn_cast<VarDecl>(D);
2660
2661   if (!VD || !VD->hasLocalStorage()) {
2662     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
2663     return;
2664   }
2665
2666   // Look up the function
2667   // FIXME: Lookup probably isn't looking in the right place
2668   NamedDecl *CleanupDecl
2669     = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
2670                          Attr.getParameterLoc(), Sema::LookupOrdinaryName);
2671   if (!CleanupDecl) {
2672     S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
2673       Attr.getParameterName();
2674     return;
2675   }
2676
2677   FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
2678   if (!FD) {
2679     S.Diag(Attr.getParameterLoc(),
2680            diag::err_attribute_cleanup_arg_not_function)
2681       << Attr.getParameterName();
2682     return;
2683   }
2684
2685   if (FD->getNumParams() != 1) {
2686     S.Diag(Attr.getParameterLoc(),
2687            diag::err_attribute_cleanup_func_must_take_one_arg)
2688       << Attr.getParameterName();
2689     return;
2690   }
2691
2692   // We're currently more strict than GCC about what function types we accept.
2693   // If this ever proves to be a problem it should be easy to fix.
2694   QualType Ty = S.Context.getPointerType(VD->getType());
2695   QualType ParamTy = FD->getParamDecl(0)->getType();
2696   if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
2697                                    ParamTy, Ty) != Sema::Compatible) {
2698     S.Diag(Attr.getParameterLoc(),
2699            diag::err_attribute_cleanup_func_arg_incompatible_type) <<
2700       Attr.getParameterName() << ParamTy << Ty;
2701     return;
2702   }
2703
2704   D->addAttr(::new (S.Context) CleanupAttr(Attr.getRange(), S.Context, FD));
2705   S.MarkFunctionReferenced(Attr.getParameterLoc(), FD);
2706 }
2707
2708 /// Handle __attribute__((format_arg((idx)))) attribute based on
2709 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2710 static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2711   if (!checkAttributeNumArgs(S, Attr, 1))
2712     return;
2713
2714   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
2715     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2716       << Attr.getName() << ExpectedFunction;
2717     return;
2718   }
2719
2720   // In C++ the implicit 'this' function parameter also counts, and they are
2721   // counted from one.
2722   bool HasImplicitThisParam = isInstanceMethod(D);
2723   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
2724   unsigned FirstIdx = 1;
2725
2726   // checks for the 2nd argument
2727   Expr *IdxExpr = Attr.getArg(0);
2728   llvm::APSInt Idx(32);
2729   if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2730       !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
2731     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2732     << "format" << 2 << IdxExpr->getSourceRange();
2733     return;
2734   }
2735
2736   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
2737     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2738     << "format" << 2 << IdxExpr->getSourceRange();
2739     return;
2740   }
2741
2742   unsigned ArgIdx = Idx.getZExtValue() - 1;
2743
2744   if (HasImplicitThisParam) {
2745     if (ArgIdx == 0) {
2746       S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
2747         << "format_arg" << IdxExpr->getSourceRange();
2748       return;
2749     }
2750     ArgIdx--;
2751   }
2752
2753   // make sure the format string is really a string
2754   QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
2755
2756   bool not_nsstring_type = !isNSStringType(Ty, S.Context);
2757   if (not_nsstring_type &&
2758       !isCFStringType(Ty, S.Context) &&
2759       (!Ty->isPointerType() ||
2760        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2761     // FIXME: Should highlight the actual expression that has the wrong type.
2762     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2763     << (not_nsstring_type ? "a string type" : "an NSString")
2764        << IdxExpr->getSourceRange();
2765     return;
2766   }
2767   Ty = getFunctionOrMethodResultType(D);
2768   if (!isNSStringType(Ty, S.Context) &&
2769       !isCFStringType(Ty, S.Context) &&
2770       (!Ty->isPointerType() ||
2771        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2772     // FIXME: Should highlight the actual expression that has the wrong type.
2773     S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
2774     << (not_nsstring_type ? "string type" : "NSString")
2775        << IdxExpr->getSourceRange();
2776     return;
2777   }
2778
2779   D->addAttr(::new (S.Context) FormatArgAttr(Attr.getRange(), S.Context,
2780                                              Idx.getZExtValue()));
2781 }
2782
2783 enum FormatAttrKind {
2784   CFStringFormat,
2785   NSStringFormat,
2786   StrftimeFormat,
2787   SupportedFormat,
2788   IgnoredFormat,
2789   InvalidFormat
2790 };
2791
2792 /// getFormatAttrKind - Map from format attribute names to supported format
2793 /// types.
2794 static FormatAttrKind getFormatAttrKind(StringRef Format) {
2795   return llvm::StringSwitch<FormatAttrKind>(Format)
2796     // Check for formats that get handled specially.
2797     .Case("NSString", NSStringFormat)
2798     .Case("CFString", CFStringFormat)
2799     .Case("strftime", StrftimeFormat)
2800
2801     // Otherwise, check for supported formats.
2802     .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
2803     .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
2804     .Case("kprintf", SupportedFormat) // OpenBSD.
2805
2806     .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
2807     .Default(InvalidFormat);
2808 }
2809
2810 /// Handle __attribute__((init_priority(priority))) attributes based on
2811 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
2812 static void handleInitPriorityAttr(Sema &S, Decl *D,
2813                                    const AttributeList &Attr) {
2814   if (!S.getLangOpts().CPlusPlus) {
2815     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2816     return;
2817   }
2818
2819   if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) {
2820     S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2821     Attr.setInvalid();
2822     return;
2823   }
2824   QualType T = dyn_cast<VarDecl>(D)->getType();
2825   if (S.Context.getAsArrayType(T))
2826     T = S.Context.getBaseElementType(T);
2827   if (!T->getAs<RecordType>()) {
2828     S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2829     Attr.setInvalid();
2830     return;
2831   }
2832
2833   if (Attr.getNumArgs() != 1) {
2834     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2835     Attr.setInvalid();
2836     return;
2837   }
2838   Expr *priorityExpr = Attr.getArg(0);
2839
2840   llvm::APSInt priority(32);
2841   if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
2842       !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
2843     S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2844     << "init_priority" << priorityExpr->getSourceRange();
2845     Attr.setInvalid();
2846     return;
2847   }
2848   unsigned prioritynum = priority.getZExtValue();
2849   if (prioritynum < 101 || prioritynum > 65535) {
2850     S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
2851     <<  priorityExpr->getSourceRange();
2852     Attr.setInvalid();
2853     return;
2854   }
2855   D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getRange(), S.Context,
2856                                                 prioritynum));
2857 }
2858
2859 FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range, StringRef Format,
2860                                   int FormatIdx, int FirstArg) {
2861   // Check whether we already have an equivalent format attribute.
2862   for (specific_attr_iterator<FormatAttr>
2863          i = D->specific_attr_begin<FormatAttr>(),
2864          e = D->specific_attr_end<FormatAttr>();
2865        i != e ; ++i) {
2866     FormatAttr *f = *i;
2867     if (f->getType() == Format &&
2868         f->getFormatIdx() == FormatIdx &&
2869         f->getFirstArg() == FirstArg) {
2870       // If we don't have a valid location for this attribute, adopt the
2871       // location.
2872       if (f->getLocation().isInvalid())
2873         f->setRange(Range);
2874       return NULL;
2875     }
2876   }
2877
2878   return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
2879                                     FirstArg);
2880 }
2881
2882 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
2883 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2884 static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2885
2886   if (!Attr.getParameterName()) {
2887     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2888       << "format" << 1;
2889     return;
2890   }
2891
2892   if (Attr.getNumArgs() != 2) {
2893     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
2894     return;
2895   }
2896
2897   if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) {
2898     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2899       << Attr.getName() << ExpectedFunction;
2900     return;
2901   }
2902
2903   // In C++ the implicit 'this' function parameter also counts, and they are
2904   // counted from one.
2905   bool HasImplicitThisParam = isInstanceMethod(D);
2906   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
2907   unsigned FirstIdx = 1;
2908
2909   StringRef Format = Attr.getParameterName()->getName();
2910
2911   // Normalize the argument, __foo__ becomes foo.
2912   if (Format.startswith("__") && Format.endswith("__"))
2913     Format = Format.substr(2, Format.size() - 4);
2914
2915   // Check for supported formats.
2916   FormatAttrKind Kind = getFormatAttrKind(Format);
2917
2918   if (Kind == IgnoredFormat)
2919     return;
2920
2921   if (Kind == InvalidFormat) {
2922     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2923       << "format" << Attr.getParameterName()->getName();
2924     return;
2925   }
2926
2927   // checks for the 2nd argument
2928   Expr *IdxExpr = Attr.getArg(0);
2929   llvm::APSInt Idx(32);
2930   if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2931       !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
2932     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2933       << "format" << 2 << IdxExpr->getSourceRange();
2934     return;
2935   }
2936
2937   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
2938     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2939       << "format" << 2 << IdxExpr->getSourceRange();
2940     return;
2941   }
2942
2943   // FIXME: Do we need to bounds check?
2944   unsigned ArgIdx = Idx.getZExtValue() - 1;
2945
2946   if (HasImplicitThisParam) {
2947     if (ArgIdx == 0) {
2948       S.Diag(Attr.getLoc(),
2949              diag::err_format_attribute_implicit_this_format_string)
2950         << IdxExpr->getSourceRange();
2951       return;
2952     }
2953     ArgIdx--;
2954   }
2955
2956   // make sure the format string is really a string
2957   QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
2958
2959   if (Kind == CFStringFormat) {
2960     if (!isCFStringType(Ty, S.Context)) {
2961       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2962         << "a CFString" << IdxExpr->getSourceRange();
2963       return;
2964     }
2965   } else if (Kind == NSStringFormat) {
2966     // FIXME: do we need to check if the type is NSString*?  What are the
2967     // semantics?
2968     if (!isNSStringType(Ty, S.Context)) {
2969       // FIXME: Should highlight the actual expression that has the wrong type.
2970       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2971         << "an NSString" << IdxExpr->getSourceRange();
2972       return;
2973     }
2974   } else if (!Ty->isPointerType() ||
2975              !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
2976     // FIXME: Should highlight the actual expression that has the wrong type.
2977     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2978       << "a string type" << IdxExpr->getSourceRange();
2979     return;
2980   }
2981
2982   // check the 3rd argument
2983   Expr *FirstArgExpr = Attr.getArg(1);
2984   llvm::APSInt FirstArg(32);
2985   if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
2986       !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
2987     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2988       << "format" << 3 << FirstArgExpr->getSourceRange();
2989     return;
2990   }
2991
2992   // check if the function is variadic if the 3rd argument non-zero
2993   if (FirstArg != 0) {
2994     if (isFunctionOrMethodVariadic(D)) {
2995       ++NumArgs; // +1 for ...
2996     } else {
2997       S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
2998       return;
2999     }
3000   }
3001
3002   // strftime requires FirstArg to be 0 because it doesn't read from any
3003   // variable the input is just the current time + the format string.
3004   if (Kind == StrftimeFormat) {
3005     if (FirstArg != 0) {
3006       S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
3007         << FirstArgExpr->getSourceRange();
3008       return;
3009     }
3010   // if 0 it disables parameter checking (to use with e.g. va_list)
3011   } else if (FirstArg != 0 && FirstArg != NumArgs) {
3012     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
3013       << "format" << 3 << FirstArgExpr->getSourceRange();
3014     return;
3015   }
3016
3017   FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), Format,
3018                                           Idx.getZExtValue(),
3019                                           FirstArg.getZExtValue());
3020   if (NewAttr)
3021     D->addAttr(NewAttr);
3022 }
3023
3024 static void handleTransparentUnionAttr(Sema &S, Decl *D,
3025                                        const AttributeList &Attr) {
3026   // check the attribute arguments.
3027   if (!checkAttributeNumArgs(S, Attr, 0))
3028     return;
3029
3030
3031   // Try to find the underlying union declaration.
3032   RecordDecl *RD = 0;
3033   TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
3034   if (TD && TD->getUnderlyingType()->isUnionType())
3035     RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3036   else
3037     RD = dyn_cast<RecordDecl>(D);
3038
3039   if (!RD || !RD->isUnion()) {
3040     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3041       << Attr.getName() << ExpectedUnion;
3042     return;
3043   }
3044
3045   if (!RD->isCompleteDefinition()) {
3046     S.Diag(Attr.getLoc(),
3047         diag::warn_transparent_union_attribute_not_definition);
3048     return;
3049   }
3050
3051   RecordDecl::field_iterator Field = RD->field_begin(),
3052                           FieldEnd = RD->field_end();
3053   if (Field == FieldEnd) {
3054     S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3055     return;
3056   }
3057
3058   FieldDecl *FirstField = *Field;
3059   QualType FirstType = FirstField->getType();
3060   if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3061     S.Diag(FirstField->getLocation(),
3062            diag::warn_transparent_union_attribute_floating)
3063       << FirstType->isVectorType() << FirstType;
3064     return;
3065   }
3066
3067   uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3068   uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3069   for (; Field != FieldEnd; ++Field) {
3070     QualType FieldType = Field->getType();
3071     if (S.Context.getTypeSize(FieldType) != FirstSize ||
3072         S.Context.getTypeAlign(FieldType) != FirstAlign) {
3073       // Warn if we drop the attribute.
3074       bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3075       unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3076                                  : S.Context.getTypeAlign(FieldType);
3077       S.Diag(Field->getLocation(),
3078           diag::warn_transparent_union_attribute_field_size_align)
3079         << isSize << Field->getDeclName() << FieldBits;
3080       unsigned FirstBits = isSize? FirstSize : FirstAlign;
3081       S.Diag(FirstField->getLocation(),
3082              diag::note_transparent_union_first_field_size_align)
3083         << isSize << FirstBits;
3084       return;
3085     }
3086   }
3087
3088   RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getRange(), S.Context));
3089 }
3090
3091 static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3092   // check the attribute arguments.
3093   if (!checkAttributeNumArgs(S, Attr, 1))
3094     return;
3095
3096   Expr *ArgExpr = Attr.getArg(0);
3097   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
3098
3099   // Make sure that there is a string literal as the annotation's single
3100   // argument.
3101   if (!SE) {
3102     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
3103     return;
3104   }
3105
3106   // Don't duplicate annotations that are already set.
3107   for (specific_attr_iterator<AnnotateAttr>
3108        i = D->specific_attr_begin<AnnotateAttr>(),
3109        e = D->specific_attr_end<AnnotateAttr>(); i != e; ++i) {
3110       if ((*i)->getAnnotation() == SE->getString())
3111           return;
3112   }
3113   D->addAttr(::new (S.Context) AnnotateAttr(Attr.getRange(), S.Context,
3114                                             SE->getString()));
3115 }
3116
3117 static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3118   // check the attribute arguments.
3119   if (Attr.getNumArgs() > 1) {
3120     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
3121     return;
3122   }
3123
3124   //FIXME: The C++0x version of this attribute has more limited applicabilty
3125   //       than GNU's, and should error out when it is used to specify a
3126   //       weaker alignment, rather than being silently ignored.
3127
3128   if (Attr.getNumArgs() == 0) {
3129     D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
3130                true, 0, Attr.isDeclspecAttribute()));
3131     return;
3132   }
3133
3134   S.AddAlignedAttr(Attr.getRange(), D, Attr.getArg(0),
3135                    Attr.isDeclspecAttribute());
3136 }
3137
3138 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3139                           bool isDeclSpec) {
3140   // FIXME: Handle pack-expansions here.
3141   if (DiagnoseUnexpandedParameterPack(E))
3142     return;
3143
3144   if (E->isTypeDependent() || E->isValueDependent()) {
3145     // Save dependent expressions in the AST to be instantiated.
3146     D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, E,
3147                                            isDeclSpec));
3148     return;
3149   }
3150
3151   SourceLocation AttrLoc = AttrRange.getBegin();
3152   // FIXME: Cache the number on the Attr object?
3153   llvm::APSInt Alignment(32);
3154   ExprResult ICE
3155     = VerifyIntegerConstantExpression(E, &Alignment,
3156         diag::err_aligned_attribute_argument_not_int,
3157         /*AllowFold*/ false);
3158   if (ICE.isInvalid())
3159     return;
3160   if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
3161     Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
3162       << E->getSourceRange();
3163     return;
3164   }
3165   if (isDeclSpec) {
3166     // We've already verified it's a power of 2, now let's make sure it's
3167     // 8192 or less.
3168     if (Alignment.getZExtValue() > 8192) {
3169       Diag(AttrLoc, diag::err_attribute_aligned_greater_than_8192)
3170         << E->getSourceRange();
3171       return;
3172     }
3173   }
3174
3175   D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, ICE.take(),
3176                                          isDeclSpec));
3177 }
3178
3179 void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3180                           bool isDeclSpec) {
3181   // FIXME: Cache the number on the Attr object if non-dependent?
3182   // FIXME: Perform checking of type validity
3183   D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3184                                          isDeclSpec));
3185   return;
3186 }
3187
3188 /// handleModeAttr - This attribute modifies the width of a decl with primitive
3189 /// type.
3190 ///
3191 /// Despite what would be logical, the mode attribute is a decl attribute, not a
3192 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3193 /// HImode, not an intermediate pointer.
3194 static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3195   // This attribute isn't documented, but glibc uses it.  It changes
3196   // the width of an int or unsigned int to the specified size.
3197
3198   // Check that there aren't any arguments
3199   if (!checkAttributeNumArgs(S, Attr, 0))
3200     return;
3201
3202
3203   IdentifierInfo *Name = Attr.getParameterName();
3204   if (!Name) {
3205     S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
3206     return;
3207   }
3208
3209   StringRef Str = Attr.getParameterName()->getName();
3210
3211   // Normalize the attribute name, __foo__ becomes foo.
3212   if (Str.startswith("__") && Str.endswith("__"))
3213     Str = Str.substr(2, Str.size() - 4);
3214
3215   unsigned DestWidth = 0;
3216   bool IntegerMode = true;
3217   bool ComplexMode = false;
3218   switch (Str.size()) {
3219   case 2:
3220     switch (Str[0]) {
3221     case 'Q': DestWidth = 8; break;
3222     case 'H': DestWidth = 16; break;
3223     case 'S': DestWidth = 32; break;
3224     case 'D': DestWidth = 64; break;
3225     case 'X': DestWidth = 96; break;
3226     case 'T': DestWidth = 128; break;
3227     }
3228     if (Str[1] == 'F') {
3229       IntegerMode = false;
3230     } else if (Str[1] == 'C') {
3231       IntegerMode = false;
3232       ComplexMode = true;
3233     } else if (Str[1] != 'I') {
3234       DestWidth = 0;
3235     }
3236     break;
3237   case 4:
3238     // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3239     // pointer on PIC16 and other embedded platforms.
3240     if (Str == "word")
3241       DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3242     else if (Str == "byte")
3243       DestWidth = S.Context.getTargetInfo().getCharWidth();
3244     break;
3245   case 7:
3246     if (Str == "pointer")
3247       DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3248     break;
3249   }
3250
3251   QualType OldTy;
3252   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3253     OldTy = TD->getUnderlyingType();
3254   else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3255     OldTy = VD->getType();
3256   else {
3257     S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
3258       << "mode" << Attr.getRange();
3259     return;
3260   }
3261
3262   if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
3263     S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
3264   else if (IntegerMode) {
3265     if (!OldTy->isIntegralOrEnumerationType())
3266       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3267   } else if (ComplexMode) {
3268     if (!OldTy->isComplexType())
3269       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3270   } else {
3271     if (!OldTy->isFloatingType())
3272       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3273   }
3274
3275   // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3276   // and friends, at least with glibc.
3277   // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
3278   // width on unusual platforms.
3279   // FIXME: Make sure floating-point mappings are accurate
3280   // FIXME: Support XF and TF types
3281   QualType NewTy;
3282   switch (DestWidth) {
3283   case 0:
3284     S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
3285     return;
3286   default:
3287     S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3288     return;
3289   case 8:
3290     if (!IntegerMode) {
3291       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3292       return;
3293     }
3294     if (OldTy->isSignedIntegerType())
3295       NewTy = S.Context.SignedCharTy;
3296     else
3297       NewTy = S.Context.UnsignedCharTy;
3298     break;
3299   case 16:
3300     if (!IntegerMode) {
3301       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3302       return;
3303     }
3304     if (OldTy->isSignedIntegerType())
3305       NewTy = S.Context.ShortTy;
3306     else
3307       NewTy = S.Context.UnsignedShortTy;
3308     break;
3309   case 32:
3310     if (!IntegerMode)
3311       NewTy = S.Context.FloatTy;
3312     else if (OldTy->isSignedIntegerType())
3313       NewTy = S.Context.IntTy;
3314     else
3315       NewTy = S.Context.UnsignedIntTy;
3316     break;
3317   case 64:
3318     if (!IntegerMode)
3319       NewTy = S.Context.DoubleTy;
3320     else if (OldTy->isSignedIntegerType())
3321       if (S.Context.getTargetInfo().getLongWidth() == 64)
3322         NewTy = S.Context.LongTy;
3323       else
3324         NewTy = S.Context.LongLongTy;
3325     else
3326       if (S.Context.getTargetInfo().getLongWidth() == 64)
3327         NewTy = S.Context.UnsignedLongTy;
3328       else
3329         NewTy = S.Context.UnsignedLongLongTy;
3330     break;
3331   case 96:
3332     NewTy = S.Context.LongDoubleTy;
3333     break;
3334   case 128:
3335     if (!IntegerMode) {
3336       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3337       return;
3338     }
3339     if (OldTy->isSignedIntegerType())
3340       NewTy = S.Context.Int128Ty;
3341     else
3342       NewTy = S.Context.UnsignedInt128Ty;
3343     break;
3344   }
3345
3346   if (ComplexMode) {
3347     NewTy = S.Context.getComplexType(NewTy);
3348   }
3349
3350   // Install the new type.
3351   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
3352     // FIXME: preserve existing source info.
3353     TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
3354   } else
3355     cast<ValueDecl>(D)->setType(NewTy);
3356 }
3357
3358 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3359   // check the attribute arguments.
3360   if (!checkAttributeNumArgs(S, Attr, 0))
3361     return;
3362
3363   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
3364     if (!VD->hasGlobalStorage())
3365       S.Diag(Attr.getLoc(),
3366              diag::warn_attribute_requires_functions_or_static_globals)
3367         << Attr.getName();
3368   } else if (!isFunctionOrMethod(D)) {
3369     S.Diag(Attr.getLoc(),
3370            diag::warn_attribute_requires_functions_or_static_globals)
3371       << Attr.getName();
3372     return;
3373   }
3374
3375   D->addAttr(::new (S.Context) NoDebugAttr(Attr.getRange(), S.Context));
3376 }
3377
3378 static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3379   // check the attribute arguments.
3380   if (!checkAttributeNumArgs(S, Attr, 0))
3381     return;
3382
3383
3384   if (!isa<FunctionDecl>(D)) {
3385     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3386       << Attr.getName() << ExpectedFunction;
3387     return;
3388   }
3389
3390   D->addAttr(::new (S.Context) NoInlineAttr(Attr.getRange(), S.Context));
3391 }
3392
3393 static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
3394                                            const AttributeList &Attr) {
3395   // check the attribute arguments.
3396   if (!checkAttributeNumArgs(S, Attr, 0))
3397     return;
3398
3399
3400   if (!isa<FunctionDecl>(D)) {
3401     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3402       << Attr.getName() << ExpectedFunction;
3403     return;
3404   }
3405
3406   D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getRange(),
3407                                                         S.Context));
3408 }
3409
3410 static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3411   if (S.LangOpts.CUDA) {
3412     // check the attribute arguments.
3413     if (Attr.hasParameterOrArguments()) {
3414       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3415       return;
3416     }
3417
3418     if (!isa<VarDecl>(D)) {
3419       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3420         << Attr.getName() << ExpectedVariable;
3421       return;
3422     }
3423
3424     D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getRange(), S.Context));
3425   } else {
3426     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
3427   }
3428 }
3429
3430 static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3431   if (S.LangOpts.CUDA) {
3432     // check the attribute arguments.
3433     if (Attr.getNumArgs() != 0) {
3434       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3435       return;
3436     }
3437
3438     if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
3439       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3440         << Attr.getName() << ExpectedVariableOrFunction;
3441       return;
3442     }
3443
3444     D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getRange(), S.Context));
3445   } else {
3446     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
3447   }
3448 }
3449
3450 static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3451   if (S.LangOpts.CUDA) {
3452     // check the attribute arguments.
3453     if (!checkAttributeNumArgs(S, Attr, 0))
3454       return;
3455
3456     if (!isa<FunctionDecl>(D)) {
3457       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3458         << Attr.getName() << ExpectedFunction;
3459       return;
3460     }
3461
3462     FunctionDecl *FD = cast<FunctionDecl>(D);
3463     if (!FD->getResultType()->isVoidType()) {
3464       TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
3465       if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
3466         S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3467           << FD->getType()
3468           << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
3469                                           "void");
3470       } else {
3471         S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3472           << FD->getType();
3473       }
3474       return;
3475     }
3476
3477     D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getRange(), S.Context));
3478   } else {
3479     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
3480   }
3481 }
3482
3483 static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3484   if (S.LangOpts.CUDA) {
3485     // check the attribute arguments.
3486     if (!checkAttributeNumArgs(S, Attr, 0))
3487       return;
3488
3489
3490     if (!isa<FunctionDecl>(D)) {
3491       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3492         << Attr.getName() << ExpectedFunction;
3493       return;
3494     }
3495
3496     D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getRange(), S.Context));
3497   } else {
3498     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
3499   }
3500 }
3501
3502 static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3503   if (S.LangOpts.CUDA) {
3504     // check the attribute arguments.
3505     if (!checkAttributeNumArgs(S, Attr, 0))
3506       return;
3507
3508
3509     if (!isa<VarDecl>(D)) {
3510       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3511         << Attr.getName() << ExpectedVariable;
3512       return;
3513     }
3514
3515     D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getRange(), S.Context));
3516   } else {
3517     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
3518   }
3519 }
3520
3521 static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3522   // check the attribute arguments.
3523   if (!checkAttributeNumArgs(S, Attr, 0))
3524     return;
3525
3526   FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
3527   if (Fn == 0) {
3528     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3529       << Attr.getName() << ExpectedFunction;
3530     return;
3531   }
3532
3533   if (!Fn->isInlineSpecified()) {
3534     S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
3535     return;
3536   }
3537
3538   D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getRange(), S.Context));
3539 }
3540
3541 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3542   if (hasDeclarator(D)) return;
3543
3544   // Diagnostic is emitted elsewhere: here we store the (valid) Attr
3545   // in the Decl node for syntactic reasoning, e.g., pretty-printing.
3546   CallingConv CC;
3547   if (S.CheckCallingConvAttr(Attr, CC))
3548     return;
3549
3550   if (!isa<ObjCMethodDecl>(D)) {
3551     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3552       << Attr.getName() << ExpectedFunctionOrMethod;
3553     return;
3554   }
3555
3556   switch (Attr.getKind()) {
3557   case AttributeList::AT_FastCall:
3558     D->addAttr(::new (S.Context) FastCallAttr(Attr.getRange(), S.Context));
3559     return;
3560   case AttributeList::AT_StdCall:
3561     D->addAttr(::new (S.Context) StdCallAttr(Attr.getRange(), S.Context));
3562     return;
3563   case AttributeList::AT_ThisCall:
3564     D->addAttr(::new (S.Context) ThisCallAttr(Attr.getRange(), S.Context));
3565     return;
3566   case AttributeList::AT_CDecl:
3567     D->addAttr(::new (S.Context) CDeclAttr(Attr.getRange(), S.Context));
3568     return;
3569   case AttributeList::AT_Pascal:
3570     D->addAttr(::new (S.Context) PascalAttr(Attr.getRange(), S.Context));
3571     return;
3572   case AttributeList::AT_Pcs: {
3573     PcsAttr::PCSType PCS;
3574     switch (CC) {
3575     case CC_AAPCS:
3576       PCS = PcsAttr::AAPCS;
3577       break;
3578     case CC_AAPCS_VFP:
3579       PCS = PcsAttr::AAPCS_VFP;
3580       break;
3581     default:
3582       llvm_unreachable("unexpected calling convention in pcs attribute");
3583     }
3584
3585     D->addAttr(::new (S.Context) PcsAttr(Attr.getRange(), S.Context, PCS));
3586   }
3587   default:
3588     llvm_unreachable("unexpected attribute kind");
3589   }
3590 }
3591
3592 static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
3593   assert(!Attr.isInvalid());
3594   D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getRange(), S.Context));
3595 }
3596
3597 bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
3598   if (attr.isInvalid())
3599     return true;
3600
3601   unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0;
3602   if (attr.getNumArgs() != ReqArgs || attr.getParameterName()) {
3603     Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << ReqArgs;
3604     attr.setInvalid();
3605     return true;
3606   }
3607
3608   // TODO: diagnose uses of these conventions on the wrong target. Or, better
3609   // move to TargetAttributesSema one day.
3610   switch (attr.getKind()) {
3611   case AttributeList::AT_CDecl: CC = CC_C; break;
3612   case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
3613   case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
3614   case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
3615   case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
3616   case AttributeList::AT_Pcs: {
3617     Expr *Arg = attr.getArg(0);
3618     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
3619     if (!Str || !Str->isAscii()) {
3620       Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
3621         << "pcs" << 1;
3622       attr.setInvalid();
3623       return true;
3624     }
3625
3626     StringRef StrRef = Str->getString();
3627     if (StrRef == "aapcs") {
3628       CC = CC_AAPCS;
3629       break;
3630     } else if (StrRef == "aapcs-vfp") {
3631       CC = CC_AAPCS_VFP;
3632       break;
3633     }
3634
3635     attr.setInvalid();
3636     Diag(attr.getLoc(), diag::err_invalid_pcs);
3637     return true;
3638   }
3639   default: llvm_unreachable("unexpected attribute kind");
3640   }
3641
3642   return false;
3643 }
3644
3645 static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3646   if (hasDeclarator(D)) return;
3647
3648   unsigned numParams;
3649   if (S.CheckRegparmAttr(Attr, numParams))
3650     return;
3651
3652   if (!isa<ObjCMethodDecl>(D)) {
3653     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3654       << Attr.getName() << ExpectedFunctionOrMethod;
3655     return;
3656   }
3657
3658   D->addAttr(::new (S.Context) RegparmAttr(Attr.getRange(), S.Context, numParams));
3659 }
3660
3661 /// Checks a regparm attribute, returning true if it is ill-formed and
3662 /// otherwise setting numParams to the appropriate value.
3663 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3664   if (Attr.isInvalid())
3665     return true;
3666
3667   if (Attr.getNumArgs() != 1) {
3668     Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
3669     Attr.setInvalid();
3670     return true;
3671   }
3672
3673   Expr *NumParamsExpr = Attr.getArg(0);
3674   llvm::APSInt NumParams(32);
3675   if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
3676       !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
3677     Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
3678       << "regparm" << NumParamsExpr->getSourceRange();
3679     Attr.setInvalid();
3680     return true;
3681   }
3682
3683   if (Context.getTargetInfo().getRegParmMax() == 0) {
3684     Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
3685       << NumParamsExpr->getSourceRange();
3686     Attr.setInvalid();
3687     return true;
3688   }
3689
3690   numParams = NumParams.getZExtValue();
3691   if (numParams > Context.getTargetInfo().getRegParmMax()) {
3692     Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
3693       << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
3694     Attr.setInvalid();
3695     return true;
3696   }
3697
3698   return false;
3699 }
3700
3701 static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
3702   if (S.LangOpts.CUDA) {
3703     // check the attribute arguments.
3704     if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
3705       // FIXME: 0 is not okay.
3706       S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
3707       return;
3708     }
3709
3710     if (!isFunctionOrMethod(D)) {
3711       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3712         << Attr.getName() << ExpectedFunctionOrMethod;
3713       return;
3714     }
3715
3716     Expr *MaxThreadsExpr = Attr.getArg(0);
3717     llvm::APSInt MaxThreads(32);
3718     if (MaxThreadsExpr->isTypeDependent() ||
3719         MaxThreadsExpr->isValueDependent() ||
3720         !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
3721       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3722         << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
3723       return;
3724     }
3725
3726     llvm::APSInt MinBlocks(32);
3727     if (Attr.getNumArgs() > 1) {
3728       Expr *MinBlocksExpr = Attr.getArg(1);
3729       if (MinBlocksExpr->isTypeDependent() ||
3730           MinBlocksExpr->isValueDependent() ||
3731           !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
3732         S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3733           << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
3734         return;
3735       }
3736     }
3737
3738     D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getRange(), S.Context,
3739                                                       MaxThreads.getZExtValue(),
3740                                                      MinBlocks.getZExtValue()));
3741   } else {
3742     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
3743   }
3744 }
3745
3746 static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
3747                                           const AttributeList &Attr) {
3748   StringRef AttrName = Attr.getName()->getName();
3749   if (!Attr.getParameterName()) {
3750     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier)
3751       << Attr.getName() << /* arg num = */ 1;
3752     return;
3753   }
3754
3755   if (Attr.getNumArgs() != 2) {
3756     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
3757       << /* required args = */ 3;
3758     return;
3759   }
3760
3761   IdentifierInfo *ArgumentKind = Attr.getParameterName();
3762
3763   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
3764     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
3765       << Attr.getName() << ExpectedFunctionOrMethod;
3766     return;
3767   }
3768
3769   uint64_t ArgumentIdx;
3770   if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName,
3771                                           Attr.getLoc(), 2,
3772                                           Attr.getArg(0), ArgumentIdx))
3773     return;
3774
3775   uint64_t TypeTagIdx;
3776   if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName,
3777                                           Attr.getLoc(), 3,
3778                                           Attr.getArg(1), TypeTagIdx))
3779     return;
3780
3781   bool IsPointer = (AttrName == "pointer_with_type_tag");
3782   if (IsPointer) {
3783     // Ensure that buffer has a pointer type.
3784     QualType BufferTy = getFunctionOrMethodArgType(D, ArgumentIdx);
3785     if (!BufferTy->isPointerType()) {
3786       S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
3787         << AttrName;
3788     }
3789   }
3790
3791   D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(Attr.getRange(),
3792                                                        S.Context,
3793                                                        ArgumentKind,
3794                                                        ArgumentIdx,
3795                                                        TypeTagIdx,
3796                                                        IsPointer));
3797 }
3798
3799 static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
3800                                          const AttributeList &Attr) {
3801   IdentifierInfo *PointerKind = Attr.getParameterName();
3802   if (!PointerKind) {
3803     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier)
3804       << "type_tag_for_datatype" << 1;
3805     return;
3806   }
3807
3808   QualType MatchingCType = S.GetTypeFromParser(Attr.getMatchingCType(), NULL);
3809
3810   D->addAttr(::new (S.Context) TypeTagForDatatypeAttr(
3811                                   Attr.getRange(),
3812                                   S.Context,
3813                                   PointerKind,
3814                                   MatchingCType,
3815                                   Attr.getLayoutCompatible(),
3816                                   Attr.getMustBeNull()));
3817 }
3818
3819 //===----------------------------------------------------------------------===//
3820 // Checker-specific attribute handlers.
3821 //===----------------------------------------------------------------------===//
3822
3823 static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
3824   return type->isDependentType() ||
3825          type->isObjCObjectPointerType() ||
3826          S.Context.isObjCNSObjectType(type);
3827 }
3828 static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
3829   return type->isDependentType() ||
3830          type->isPointerType() ||
3831          isValidSubjectOfNSAttribute(S, type);
3832 }
3833
3834 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3835   ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
3836   if (!param) {
3837     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3838       << Attr.getRange() << Attr.getName() << ExpectedParameter;
3839     return;
3840   }
3841
3842   bool typeOK, cf;
3843   if (Attr.getKind() == AttributeList::AT_NSConsumed) {
3844     typeOK = isValidSubjectOfNSAttribute(S, param->getType());
3845     cf = false;
3846   } else {
3847     typeOK = isValidSubjectOfCFAttribute(S, param->getType());
3848     cf = true;
3849   }
3850
3851   if (!typeOK) {
3852     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3853       << Attr.getRange() << Attr.getName() << cf;
3854     return;
3855   }
3856
3857   if (cf)
3858     param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getRange(), S.Context));
3859   else
3860     param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getRange(), S.Context));
3861 }
3862
3863 static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
3864                                      const AttributeList &Attr) {
3865   if (!isa<ObjCMethodDecl>(D)) {
3866     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3867       << Attr.getRange() << Attr.getName() << ExpectedMethod;
3868     return;
3869   }
3870
3871   D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getRange(), S.Context));
3872 }
3873
3874 static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
3875                                         const AttributeList &Attr) {
3876
3877   QualType returnType;
3878
3879   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
3880     returnType = MD->getResultType();
3881   else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
3882     returnType = PD->getType();
3883   else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
3884            (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
3885     return; // ignore: was handled as a type attribute
3886   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
3887     returnType = FD->getResultType();
3888   else {
3889     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3890         << Attr.getRange() << Attr.getName()
3891         << ExpectedFunctionOrMethod;
3892     return;
3893   }
3894
3895   bool typeOK;
3896   bool cf;
3897   switch (Attr.getKind()) {
3898   default: llvm_unreachable("invalid ownership attribute");
3899   case AttributeList::AT_NSReturnsAutoreleased:
3900   case AttributeList::AT_NSReturnsRetained:
3901   case AttributeList::AT_NSReturnsNotRetained:
3902     typeOK = isValidSubjectOfNSAttribute(S, returnType);
3903     cf = false;
3904     break;
3905
3906   case AttributeList::AT_CFReturnsRetained:
3907   case AttributeList::AT_CFReturnsNotRetained:
3908     typeOK = isValidSubjectOfCFAttribute(S, returnType);
3909     cf = true;
3910     break;
3911   }
3912
3913   if (!typeOK) {
3914     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3915       << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
3916     return;
3917   }
3918
3919   switch (Attr.getKind()) {
3920     default:
3921       llvm_unreachable("invalid ownership attribute");
3922     case AttributeList::AT_NSReturnsAutoreleased:
3923       D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getRange(),
3924                                                              S.Context));
3925       return;
3926     case AttributeList::AT_CFReturnsNotRetained:
3927       D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getRange(),
3928                                                             S.Context));
3929       return;
3930     case AttributeList::AT_NSReturnsNotRetained:
3931       D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getRange(),
3932                                                             S.Context));
3933       return;
3934     case AttributeList::AT_CFReturnsRetained:
3935       D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getRange(),
3936                                                          S.Context));
3937       return;
3938     case AttributeList::AT_NSReturnsRetained:
3939       D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getRange(),
3940                                                          S.Context));
3941       return;
3942   };
3943 }
3944
3945 static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
3946                                               const AttributeList &attr) {
3947   SourceLocation loc = attr.getLoc();
3948
3949   ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
3950
3951   if (!method) {
3952     S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3953       << SourceRange(loc, loc) << attr.getName() << ExpectedMethod;
3954     return;
3955   }
3956
3957   // Check that the method returns a normal pointer.
3958   QualType resultType = method->getResultType();
3959
3960   if (!resultType->isReferenceType() &&
3961       (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
3962     S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3963       << SourceRange(loc)
3964       << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2;
3965
3966     // Drop the attribute.
3967     return;
3968   }
3969
3970   method->addAttr(
3971     ::new (S.Context) ObjCReturnsInnerPointerAttr(attr.getRange(), S.Context));
3972 }
3973
3974 /// Handle cf_audited_transfer and cf_unknown_transfer.
3975 static void handleCFTransferAttr(Sema &S, Decl *D, const AttributeList &A) {
3976   if (!isa<FunctionDecl>(D)) {
3977     S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3978       << A.getRange() << A.getName() << ExpectedFunction;
3979     return;
3980   }
3981
3982   bool IsAudited = (A.getKind() == AttributeList::AT_CFAuditedTransfer);
3983
3984   // Check whether there's a conflicting attribute already present.
3985   Attr *Existing;
3986   if (IsAudited) {
3987     Existing = D->getAttr<CFUnknownTransferAttr>();
3988   } else {
3989     Existing = D->getAttr<CFAuditedTransferAttr>();
3990   }
3991   if (Existing) {
3992     S.Diag(D->getLocStart(), diag::err_attributes_are_not_compatible)
3993       << A.getName()
3994       << (IsAudited ? "cf_unknown_transfer" : "cf_audited_transfer")
3995       << A.getRange() << Existing->getRange();
3996     return;
3997   }
3998
3999   // All clear;  add the attribute.
4000   if (IsAudited) {
4001     D->addAttr(
4002       ::new (S.Context) CFAuditedTransferAttr(A.getRange(), S.Context));
4003   } else {
4004     D->addAttr(
4005       ::new (S.Context) CFUnknownTransferAttr(A.getRange(), S.Context));
4006   }
4007 }
4008
4009 static void handleNSBridgedAttr(Sema &S, Scope *Sc, Decl *D,
4010                                 const AttributeList &Attr) {
4011   RecordDecl *RD = dyn_cast<RecordDecl>(D);
4012   if (!RD || RD->isUnion()) {
4013     S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4014       << Attr.getRange() << Attr.getName() << ExpectedStruct;
4015   }
4016
4017   IdentifierInfo *ParmName = Attr.getParameterName();
4018
4019   // In Objective-C, verify that the type names an Objective-C type.
4020   // We don't want to check this outside of ObjC because people sometimes
4021   // do crazy C declarations of Objective-C types.
4022   if (ParmName && S.getLangOpts().ObjC1) {
4023     // Check for an existing type with this name.
4024     LookupResult R(S, DeclarationName(ParmName), Attr.getParameterLoc(),
4025                    Sema::LookupOrdinaryName);
4026     if (S.LookupName(R, Sc)) {
4027       NamedDecl *Target = R.getFoundDecl();
4028       if (Target && !isa<ObjCInterfaceDecl>(Target)) {
4029         S.Diag(D->getLocStart(), diag::err_ns_bridged_not_interface);
4030         S.Diag(Target->getLocStart(), diag::note_declared_at);
4031       }
4032     }
4033   }
4034
4035   D->addAttr(::new (S.Context) NSBridgedAttr(Attr.getRange(), S.Context,
4036                                              ParmName));
4037 }
4038
4039 static void handleObjCOwnershipAttr(Sema &S, Decl *D,
4040                                     const AttributeList &Attr) {
4041   if (hasDeclarator(D)) return;
4042
4043   S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4044     << Attr.getRange() << Attr.getName() << ExpectedVariable;
4045 }
4046
4047 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
4048                                           const AttributeList &Attr) {
4049   if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
4050     S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4051       << Attr.getRange() << Attr.getName() << ExpectedVariable;
4052     return;
4053   }
4054
4055   ValueDecl *vd = cast<ValueDecl>(D);
4056   QualType type = vd->getType();
4057
4058   if (!type->isDependentType() &&
4059       !type->isObjCLifetimeType()) {
4060     S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
4061       << type;
4062     return;
4063   }
4064
4065   Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
4066
4067   // If we have no lifetime yet, check the lifetime we're presumably
4068   // going to infer.
4069   if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
4070     lifetime = type->getObjCARCImplicitLifetime();
4071
4072   switch (lifetime) {
4073   case Qualifiers::OCL_None:
4074     assert(type->isDependentType() &&
4075            "didn't infer lifetime for non-dependent type?");
4076     break;
4077
4078   case Qualifiers::OCL_Weak:   // meaningful
4079   case Qualifiers::OCL_Strong: // meaningful
4080     break;
4081
4082   case Qualifiers::OCL_ExplicitNone:
4083   case Qualifiers::OCL_Autoreleasing:
4084     S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
4085       << (lifetime == Qualifiers::OCL_Autoreleasing);
4086     break;
4087   }
4088
4089   D->addAttr(::new (S.Context)
4090                  ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context));
4091 }
4092
4093 //===----------------------------------------------------------------------===//
4094 // Microsoft specific attribute handlers.
4095 //===----------------------------------------------------------------------===//
4096
4097 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4098   if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) {
4099     // check the attribute arguments.
4100     if (!checkAttributeNumArgs(S, Attr, 1))
4101       return;
4102
4103     Expr *Arg = Attr.getArg(0);
4104     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
4105     if (!Str || !Str->isAscii()) {
4106       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
4107         << "uuid" << 1;
4108       return;
4109     }
4110
4111     StringRef StrRef = Str->getString();
4112
4113     bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
4114                    StrRef.back() == '}';
4115
4116     // Validate GUID length.
4117     if (IsCurly && StrRef.size() != 38) {
4118       S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4119       return;
4120     }
4121     if (!IsCurly && StrRef.size() != 36) {
4122       S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4123       return;
4124     }
4125
4126     // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
4127     // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
4128     StringRef::iterator I = StrRef.begin();
4129     if (IsCurly) // Skip the optional '{'
4130        ++I;
4131
4132     for (int i = 0; i < 36; ++i) {
4133       if (i == 8 || i == 13 || i == 18 || i == 23) {
4134         if (*I != '-') {
4135           S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4136           return;
4137         }
4138       } else if (!isxdigit(*I)) {
4139         S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4140         return;
4141       }
4142       I++;
4143     }
4144
4145     D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context,
4146                                           Str->getString()));
4147   } else
4148     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
4149 }
4150
4151 static void handleInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4152   if (S.LangOpts.MicrosoftExt) {
4153     AttributeList::Kind Kind = Attr.getKind();
4154     if (Kind == AttributeList::AT_SingleInheritance)
4155       D->addAttr(
4156           ::new (S.Context) SingleInheritanceAttr(Attr.getRange(), S.Context));
4157     else if (Kind == AttributeList::AT_MultipleInheritance)
4158       D->addAttr(
4159           ::new (S.Context) MultipleInheritanceAttr(Attr.getRange(), S.Context));
4160     else if (Kind == AttributeList::AT_VirtualInheritance)
4161       D->addAttr(
4162           ::new (S.Context) VirtualInheritanceAttr(Attr.getRange(), S.Context));
4163   } else
4164     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4165 }
4166
4167 static void handlePortabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4168   if (S.LangOpts.MicrosoftExt) {
4169     AttributeList::Kind Kind = Attr.getKind();
4170     if (Kind == AttributeList::AT_Ptr32)
4171       D->addAttr(
4172           ::new (S.Context) Ptr32Attr(Attr.getRange(), S.Context));
4173     else if (Kind == AttributeList::AT_Ptr64)
4174       D->addAttr(
4175           ::new (S.Context) Ptr64Attr(Attr.getRange(), S.Context));
4176     else if (Kind == AttributeList::AT_Win64)
4177       D->addAttr(
4178           ::new (S.Context) Win64Attr(Attr.getRange(), S.Context));
4179   } else
4180     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4181 }
4182
4183 static void handleForceInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4184   if (S.LangOpts.MicrosoftExt)
4185     D->addAttr(::new (S.Context) ForceInlineAttr(Attr.getRange(), S.Context));
4186   else
4187     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4188 }
4189
4190 //===----------------------------------------------------------------------===//
4191 // Top Level Sema Entry Points
4192 //===----------------------------------------------------------------------===//
4193
4194 static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
4195                                           const AttributeList &Attr) {
4196   switch (Attr.getKind()) {
4197   case AttributeList::AT_CUDADevice:  handleDeviceAttr      (S, D, Attr); break;
4198   case AttributeList::AT_CUDAHost:    handleHostAttr        (S, D, Attr); break;
4199   case AttributeList::AT_Overloadable:handleOverloadableAttr(S, D, Attr); break;
4200   default:
4201     break;
4202   }
4203 }
4204
4205 static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
4206                                        const AttributeList &Attr) {
4207   switch (Attr.getKind()) {
4208     case AttributeList::AT_IBAction:          handleIBAction(S, D, Attr); break;
4209     case AttributeList::AT_IBOutlet:          handleIBOutlet(S, D, Attr); break;
4210     case AttributeList::AT_IBOutletCollection:
4211       handleIBOutletCollection(S, D, Attr); break;
4212   case AttributeList::AT_AddressSpace:
4213   case AttributeList::AT_OpenCLImageAccess:
4214   case AttributeList::AT_ObjCGC:
4215   case AttributeList::AT_VectorSize:
4216   case AttributeList::AT_NeonVectorType:
4217   case AttributeList::AT_NeonPolyVectorType:
4218     // Ignore these, these are type attributes, handled by
4219     // ProcessTypeAttributes.
4220     break;
4221   case AttributeList::AT_CUDADevice:
4222   case AttributeList::AT_CUDAHost:
4223   case AttributeList::AT_Overloadable:
4224     // Ignore, this is a non-inheritable attribute, handled
4225     // by ProcessNonInheritableDeclAttr.
4226     break;
4227   case AttributeList::AT_Alias:       handleAliasAttr       (S, D, Attr); break;
4228   case AttributeList::AT_Aligned:     handleAlignedAttr     (S, D, Attr); break;
4229   case AttributeList::AT_AllocSize:   handleAllocSizeAttr   (S, D, Attr); break;
4230   case AttributeList::AT_AlwaysInline:
4231     handleAlwaysInlineAttr  (S, D, Attr); break;
4232   case AttributeList::AT_AnalyzerNoReturn:
4233     handleAnalyzerNoReturnAttr  (S, D, Attr); break;
4234   case AttributeList::AT_TLSModel:    handleTLSModelAttr    (S, D, Attr); break;
4235   case AttributeList::AT_Annotate:    handleAnnotateAttr    (S, D, Attr); break;
4236   case AttributeList::AT_Availability:handleAvailabilityAttr(S, D, Attr); break;
4237   case AttributeList::AT_CarriesDependency:
4238                                       handleDependencyAttr  (S, D, Attr); break;
4239   case AttributeList::AT_Common:      handleCommonAttr      (S, D, Attr); break;
4240   case AttributeList::AT_CUDAConstant:handleConstantAttr    (S, D, Attr); break;
4241   case AttributeList::AT_Constructor: handleConstructorAttr (S, D, Attr); break;
4242   case AttributeList::AT_Deprecated:
4243     handleAttrWithMessage<DeprecatedAttr>(S, D, Attr, "deprecated");
4244     break;
4245   case AttributeList::AT_Destructor:  handleDestructorAttr  (S, D, Attr); break;
4246   case AttributeList::AT_ExtVectorType:
4247     handleExtVectorTypeAttr(S, scope, D, Attr);
4248     break;
4249   case AttributeList::AT_Format:      handleFormatAttr      (S, D, Attr); break;
4250   case AttributeList::AT_FormatArg:   handleFormatArgAttr   (S, D, Attr); break;
4251   case AttributeList::AT_CUDAGlobal:  handleGlobalAttr      (S, D, Attr); break;
4252   case AttributeList::AT_GNUInline:   handleGNUInlineAttr   (S, D, Attr); break;
4253   case AttributeList::AT_CUDALaunchBounds:
4254     handleLaunchBoundsAttr(S, D, Attr);
4255     break;
4256   case AttributeList::AT_Mode:        handleModeAttr        (S, D, Attr); break;
4257   case AttributeList::AT_Malloc:      handleMallocAttr      (S, D, Attr); break;
4258   case AttributeList::AT_MayAlias:    handleMayAliasAttr    (S, D, Attr); break;
4259   case AttributeList::AT_NoCommon:    handleNoCommonAttr    (S, D, Attr); break;
4260   case AttributeList::AT_NonNull:     handleNonNullAttr     (S, D, Attr); break;
4261   case AttributeList::AT_ownership_returns:
4262   case AttributeList::AT_ownership_takes:
4263   case AttributeList::AT_ownership_holds:
4264       handleOwnershipAttr     (S, D, Attr); break;
4265   case AttributeList::AT_Cold:        handleColdAttr        (S, D, Attr); break;
4266   case AttributeList::AT_Hot:         handleHotAttr         (S, D, Attr); break;
4267   case AttributeList::AT_Naked:       handleNakedAttr       (S, D, Attr); break;
4268   case AttributeList::AT_NoReturn:    handleNoReturnAttr    (S, D, Attr); break;
4269   case AttributeList::AT_NoThrow:     handleNothrowAttr     (S, D, Attr); break;
4270   case AttributeList::AT_CUDAShared:  handleSharedAttr      (S, D, Attr); break;
4271   case AttributeList::AT_VecReturn:   handleVecReturnAttr   (S, D, Attr); break;
4272
4273   case AttributeList::AT_ObjCOwnership:
4274     handleObjCOwnershipAttr(S, D, Attr); break;
4275   case AttributeList::AT_ObjCPreciseLifetime:
4276     handleObjCPreciseLifetimeAttr(S, D, Attr); break;
4277
4278   case AttributeList::AT_ObjCReturnsInnerPointer:
4279     handleObjCReturnsInnerPointerAttr(S, D, Attr); break;
4280
4281   case AttributeList::AT_NSBridged:
4282     handleNSBridgedAttr(S, scope, D, Attr); break;
4283
4284   case AttributeList::AT_CFAuditedTransfer:
4285   case AttributeList::AT_CFUnknownTransfer:
4286     handleCFTransferAttr(S, D, Attr); break;
4287
4288   // Checker-specific.
4289   case AttributeList::AT_CFConsumed:
4290   case AttributeList::AT_NSConsumed:  handleNSConsumedAttr  (S, D, Attr); break;
4291   case AttributeList::AT_NSConsumesSelf:
4292     handleNSConsumesSelfAttr(S, D, Attr); break;
4293
4294   case AttributeList::AT_NSReturnsAutoreleased:
4295   case AttributeList::AT_NSReturnsNotRetained:
4296   case AttributeList::AT_CFReturnsNotRetained:
4297   case AttributeList::AT_NSReturnsRetained:
4298   case AttributeList::AT_CFReturnsRetained:
4299     handleNSReturnsRetainedAttr(S, D, Attr); break;
4300
4301   case AttributeList::AT_WorkGroupSizeHint:
4302   case AttributeList::AT_ReqdWorkGroupSize:
4303     handleWorkGroupSize(S, D, Attr); break;
4304
4305   case AttributeList::AT_InitPriority:
4306       handleInitPriorityAttr(S, D, Attr); break;
4307
4308   case AttributeList::AT_Packed:      handlePackedAttr      (S, D, Attr); break;
4309   case AttributeList::AT_Section:     handleSectionAttr     (S, D, Attr); break;
4310   case AttributeList::AT_Unavailable:
4311     handleAttrWithMessage<UnavailableAttr>(S, D, Attr, "unavailable");
4312     break;
4313   case AttributeList::AT_ArcWeakrefUnavailable:
4314     handleArcWeakrefUnavailableAttr (S, D, Attr);
4315     break;
4316   case AttributeList::AT_ObjCRootClass:
4317     handleObjCRootClassAttr(S, D, Attr);
4318     break;
4319   case AttributeList::AT_ObjCRequiresPropertyDefs:
4320     handleObjCRequiresPropertyDefsAttr (S, D, Attr);
4321     break;
4322   case AttributeList::AT_Unused:      handleUnusedAttr      (S, D, Attr); break;
4323   case AttributeList::AT_ReturnsTwice:
4324     handleReturnsTwiceAttr(S, D, Attr);
4325     break;
4326   case AttributeList::AT_Used:        handleUsedAttr        (S, D, Attr); break;
4327   case AttributeList::AT_Visibility:  handleVisibilityAttr  (S, D, Attr); break;
4328   case AttributeList::AT_WarnUnusedResult: handleWarnUnusedResult(S, D, Attr);
4329     break;
4330   case AttributeList::AT_Weak:        handleWeakAttr        (S, D, Attr); break;
4331   case AttributeList::AT_WeakRef:     handleWeakRefAttr     (S, D, Attr); break;
4332   case AttributeList::AT_WeakImport:  handleWeakImportAttr  (S, D, Attr); break;
4333   case AttributeList::AT_TransparentUnion:
4334     handleTransparentUnionAttr(S, D, Attr);
4335     break;
4336   case AttributeList::AT_ObjCException:
4337     handleObjCExceptionAttr(S, D, Attr);
4338     break;
4339   case AttributeList::AT_ObjCMethodFamily:
4340     handleObjCMethodFamilyAttr(S, D, Attr);
4341     break;
4342   case AttributeList::AT_ObjCNSObject:handleObjCNSObject    (S, D, Attr); break;
4343   case AttributeList::AT_Blocks:      handleBlocksAttr      (S, D, Attr); break;
4344   case AttributeList::AT_Sentinel:    handleSentinelAttr    (S, D, Attr); break;
4345   case AttributeList::AT_Const:       handleConstAttr       (S, D, Attr); break;
4346   case AttributeList::AT_Pure:        handlePureAttr        (S, D, Attr); break;
4347   case AttributeList::AT_Cleanup:     handleCleanupAttr     (S, D, Attr); break;
4348   case AttributeList::AT_NoDebug:     handleNoDebugAttr     (S, D, Attr); break;
4349   case AttributeList::AT_NoInline:    handleNoInlineAttr    (S, D, Attr); break;
4350   case AttributeList::AT_Regparm:     handleRegparmAttr     (S, D, Attr); break;
4351   case AttributeList::IgnoredAttribute:
4352     // Just ignore
4353     break;
4354   case AttributeList::AT_NoInstrumentFunction:  // Interacts with -pg.
4355     handleNoInstrumentFunctionAttr(S, D, Attr);
4356     break;
4357   case AttributeList::AT_StdCall:
4358   case AttributeList::AT_CDecl:
4359   case AttributeList::AT_FastCall:
4360   case AttributeList::AT_ThisCall:
4361   case AttributeList::AT_Pascal:
4362   case AttributeList::AT_Pcs:
4363     handleCallConvAttr(S, D, Attr);
4364     break;
4365   case AttributeList::AT_OpenCLKernel:
4366     handleOpenCLKernelAttr(S, D, Attr);
4367     break;
4368
4369   // Microsoft attributes:
4370   case AttributeList::AT_MsStruct:
4371     handleMsStructAttr(S, D, Attr);
4372     break;
4373   case AttributeList::AT_Uuid:
4374     handleUuidAttr(S, D, Attr);
4375     break;
4376   case AttributeList::AT_SingleInheritance:
4377   case AttributeList::AT_MultipleInheritance:
4378   case AttributeList::AT_VirtualInheritance:
4379     handleInheritanceAttr(S, D, Attr);
4380     break;
4381   case AttributeList::AT_Win64:
4382   case AttributeList::AT_Ptr32:
4383   case AttributeList::AT_Ptr64:
4384     handlePortabilityAttr(S, D, Attr);
4385     break;
4386   case AttributeList::AT_ForceInline:
4387     handleForceInlineAttr(S, D, Attr);
4388     break;
4389
4390   // Thread safety attributes:
4391   case AttributeList::AT_GuardedVar:
4392     handleGuardedVarAttr(S, D, Attr);
4393     break;
4394   case AttributeList::AT_PtGuardedVar:
4395     handlePtGuardedVarAttr(S, D, Attr);
4396     break;
4397   case AttributeList::AT_ScopedLockable:
4398     handleScopedLockableAttr(S, D, Attr);
4399     break;
4400   case AttributeList::AT_NoAddressSafetyAnalysis:
4401     handleNoAddressSafetyAttr(S, D, Attr);
4402     break;
4403   case AttributeList::AT_NoThreadSafetyAnalysis:
4404     handleNoThreadSafetyAttr(S, D, Attr);
4405     break;
4406   case AttributeList::AT_Lockable:
4407     handleLockableAttr(S, D, Attr);
4408     break;
4409   case AttributeList::AT_GuardedBy:
4410     handleGuardedByAttr(S, D, Attr);
4411     break;
4412   case AttributeList::AT_PtGuardedBy:
4413     handlePtGuardedByAttr(S, D, Attr);
4414     break;
4415   case AttributeList::AT_ExclusiveLockFunction:
4416     handleExclusiveLockFunctionAttr(S, D, Attr);
4417     break;
4418   case AttributeList::AT_ExclusiveLocksRequired:
4419     handleExclusiveLocksRequiredAttr(S, D, Attr);
4420     break;
4421   case AttributeList::AT_ExclusiveTrylockFunction:
4422     handleExclusiveTrylockFunctionAttr(S, D, Attr);
4423     break;
4424   case AttributeList::AT_LockReturned:
4425     handleLockReturnedAttr(S, D, Attr);
4426     break;
4427   case AttributeList::AT_LocksExcluded:
4428     handleLocksExcludedAttr(S, D, Attr);
4429     break;
4430   case AttributeList::AT_SharedLockFunction:
4431     handleSharedLockFunctionAttr(S, D, Attr);
4432     break;
4433   case AttributeList::AT_SharedLocksRequired:
4434     handleSharedLocksRequiredAttr(S, D, Attr);
4435     break;
4436   case AttributeList::AT_SharedTrylockFunction:
4437     handleSharedTrylockFunctionAttr(S, D, Attr);
4438     break;
4439   case AttributeList::AT_UnlockFunction:
4440     handleUnlockFunAttr(S, D, Attr);
4441     break;
4442   case AttributeList::AT_AcquiredBefore:
4443     handleAcquiredBeforeAttr(S, D, Attr);
4444     break;
4445   case AttributeList::AT_AcquiredAfter:
4446     handleAcquiredAfterAttr(S, D, Attr);
4447     break;
4448
4449   // Type safety attributes.
4450   case AttributeList::AT_ArgumentWithTypeTag:
4451     handleArgumentWithTypeTagAttr(S, D, Attr);
4452     break;
4453   case AttributeList::AT_TypeTagForDatatype:
4454     handleTypeTagForDatatypeAttr(S, D, Attr);
4455     break;
4456
4457   default:
4458     // Ask target about the attribute.
4459     const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
4460     if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
4461       S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute() ?
4462              diag::warn_unhandled_ms_attribute_ignored :
4463              diag::warn_unknown_attribute_ignored) << Attr.getName();
4464     break;
4465   }
4466 }
4467
4468 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
4469 /// the attribute applies to decls.  If the attribute is a type attribute, just
4470 /// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
4471 /// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
4472 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
4473                                  const AttributeList &Attr,
4474                                  bool NonInheritable, bool Inheritable) {
4475   if (Attr.isInvalid())
4476     return;
4477
4478   // Type attributes are still treated as declaration attributes by
4479   // ParseMicrosoftTypeAttributes and ParseBorlandTypeAttributes.  We don't
4480   // want to process them, however, because we will simply warn about ignoring
4481   // them.  So instead, we will bail out early.
4482   if (Attr.isMSTypespecAttribute())
4483     return;
4484
4485   if (NonInheritable)
4486     ProcessNonInheritableDeclAttr(S, scope, D, Attr);
4487
4488   if (Inheritable)
4489     ProcessInheritableDeclAttr(S, scope, D, Attr);
4490 }
4491
4492 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
4493 /// attribute list to the specified decl, ignoring any type attributes.
4494 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
4495                                     const AttributeList *AttrList,
4496                                     bool NonInheritable, bool Inheritable) {
4497   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4498     ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable);
4499   }
4500
4501   // GCC accepts
4502   // static int a9 __attribute__((weakref));
4503   // but that looks really pointless. We reject it.
4504   if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
4505     Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
4506     dyn_cast<NamedDecl>(D)->getNameAsString();
4507     return;
4508   }
4509 }
4510
4511 // Annotation attributes are the only attributes allowed after an access
4512 // specifier.
4513 bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4514                                           const AttributeList *AttrList) {
4515   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4516     if (l->getKind() == AttributeList::AT_Annotate) {
4517       handleAnnotateAttr(*this, ASDecl, *l);
4518     } else {
4519       Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
4520       return true;
4521     }
4522   }
4523
4524   return false;
4525 }
4526
4527 /// checkUnusedDeclAttributes - Check a list of attributes to see if it
4528 /// contains any decl attributes that we should warn about.
4529 static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
4530   for ( ; A; A = A->getNext()) {
4531     // Only warn if the attribute is an unignored, non-type attribute.
4532     if (A->isUsedAsTypeAttr()) continue;
4533     if (A->getKind() == AttributeList::IgnoredAttribute) continue;
4534
4535     if (A->getKind() == AttributeList::UnknownAttribute) {
4536       S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
4537         << A->getName() << A->getRange();
4538     } else {
4539       S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
4540         << A->getName() << A->getRange();
4541     }
4542   }
4543 }
4544
4545 /// checkUnusedDeclAttributes - Given a declarator which is not being
4546 /// used to build a declaration, complain about any decl attributes
4547 /// which might be lying around on it.
4548 void Sema::checkUnusedDeclAttributes(Declarator &D) {
4549   ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
4550   ::checkUnusedDeclAttributes(*this, D.getAttributes());
4551   for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
4552     ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
4553 }
4554
4555 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
4556 /// \#pragma weak needs a non-definition decl and source may not have one.
4557 NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
4558                                       SourceLocation Loc) {
4559   assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
4560   NamedDecl *NewD = 0;
4561   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
4562     FunctionDecl *NewFD;
4563     // FIXME: Missing call to CheckFunctionDeclaration().
4564     // FIXME: Mangling?
4565     // FIXME: Is the qualifier info correct?
4566     // FIXME: Is the DeclContext correct?
4567     NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
4568                                  Loc, Loc, DeclarationName(II),
4569                                  FD->getType(), FD->getTypeSourceInfo(),
4570                                  SC_None, SC_None,
4571                                  false/*isInlineSpecified*/,
4572                                  FD->hasPrototype(),
4573                                  false/*isConstexprSpecified*/);
4574     NewD = NewFD;
4575
4576     if (FD->getQualifier())
4577       NewFD->setQualifierInfo(FD->getQualifierLoc());
4578
4579     // Fake up parameter variables; they are declared as if this were
4580     // a typedef.
4581     QualType FDTy = FD->getType();
4582     if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
4583       SmallVector<ParmVarDecl*, 16> Params;
4584       for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
4585            AE = FT->arg_type_end(); AI != AE; ++AI) {
4586         ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, *AI);
4587         Param->setScopeInfo(0, Params.size());
4588         Params.push_back(Param);
4589       }
4590       NewFD->setParams(Params);
4591     }
4592   } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
4593     NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
4594                            VD->getInnerLocStart(), VD->getLocation(), II,
4595                            VD->getType(), VD->getTypeSourceInfo(),
4596                            VD->getStorageClass(),
4597                            VD->getStorageClassAsWritten());
4598     if (VD->getQualifier()) {
4599       VarDecl *NewVD = cast<VarDecl>(NewD);
4600       NewVD->setQualifierInfo(VD->getQualifierLoc());
4601     }
4602   }
4603   return NewD;
4604 }
4605
4606 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
4607 /// applied to it, possibly with an alias.
4608 void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
4609   if (W.getUsed()) return; // only do this once
4610   W.setUsed(true);
4611   if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
4612     IdentifierInfo *NDId = ND->getIdentifier();
4613     NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
4614     NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
4615                                             NDId->getName()));
4616     NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
4617     WeakTopLevelDecl.push_back(NewD);
4618     // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
4619     // to insert Decl at TU scope, sorry.
4620     DeclContext *SavedContext = CurContext;
4621     CurContext = Context.getTranslationUnitDecl();
4622     PushOnScopeChains(NewD, S);
4623     CurContext = SavedContext;
4624   } else { // just add weak to existing
4625     ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
4626   }
4627 }
4628
4629 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
4630 /// it, apply them to D.  This is a bit tricky because PD can have attributes
4631 /// specified in many different places, and we need to find and apply them all.
4632 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
4633                                  bool NonInheritable, bool Inheritable) {
4634   // It's valid to "forward-declare" #pragma weak, in which case we
4635   // have to do this.
4636   if (Inheritable) {
4637     LoadExternalWeakUndeclaredIdentifiers();
4638     if (!WeakUndeclaredIdentifiers.empty()) {
4639       if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
4640         if (IdentifierInfo *Id = ND->getIdentifier()) {
4641           llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
4642             = WeakUndeclaredIdentifiers.find(Id);
4643           if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
4644             WeakInfo W = I->second;
4645             DeclApplyPragmaWeak(S, ND, W);
4646             WeakUndeclaredIdentifiers[Id] = W;
4647           }
4648         }
4649       }
4650     }
4651   }
4652
4653   // Apply decl attributes from the DeclSpec if present.
4654   if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
4655     ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
4656
4657   // Walk the declarator structure, applying decl attributes that were in a type
4658   // position to the decl itself.  This handles cases like:
4659   //   int *__attr__(x)** D;
4660   // when X is a decl attribute.
4661   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
4662     if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
4663       ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
4664
4665   // Finally, apply any attributes on the decl itself.
4666   if (const AttributeList *Attrs = PD.getAttributes())
4667     ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
4668 }
4669
4670 /// Is the given declaration allowed to use a forbidden type?
4671 static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
4672   // Private ivars are always okay.  Unfortunately, people don't
4673   // always properly make their ivars private, even in system headers.
4674   // Plus we need to make fields okay, too.
4675   // Function declarations in sys headers will be marked unavailable.
4676   if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
4677       !isa<FunctionDecl>(decl))
4678     return false;
4679
4680   // Require it to be declared in a system header.
4681   return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
4682 }
4683
4684 /// Handle a delayed forbidden-type diagnostic.
4685 static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
4686                                        Decl *decl) {
4687   if (decl && isForbiddenTypeAllowed(S, decl)) {
4688     decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
4689                         "this system declaration uses an unsupported type"));
4690     return;
4691   }
4692   if (S.getLangOpts().ObjCAutoRefCount)
4693     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
4694       // FIXME: we may want to suppress diagnostics for all
4695       // kind of forbidden type messages on unavailable functions.
4696       if (FD->hasAttr<UnavailableAttr>() &&
4697           diag.getForbiddenTypeDiagnostic() ==
4698           diag::err_arc_array_param_no_ownership) {
4699         diag.Triggered = true;
4700         return;
4701       }
4702     }
4703
4704   S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
4705     << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
4706   diag.Triggered = true;
4707 }
4708
4709 void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
4710   assert(DelayedDiagnostics.getCurrentPool());
4711   DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
4712   DelayedDiagnostics.popWithoutEmitting(state);
4713
4714   // When delaying diagnostics to run in the context of a parsed
4715   // declaration, we only want to actually emit anything if parsing
4716   // succeeds.
4717   if (!decl) return;
4718
4719   // We emit all the active diagnostics in this pool or any of its
4720   // parents.  In general, we'll get one pool for the decl spec
4721   // and a child pool for each declarator; in a decl group like:
4722   //   deprecated_typedef foo, *bar, baz();
4723   // only the declarator pops will be passed decls.  This is correct;
4724   // we really do need to consider delayed diagnostics from the decl spec
4725   // for each of the different declarations.
4726   const DelayedDiagnosticPool *pool = &poppedPool;
4727   do {
4728     for (DelayedDiagnosticPool::pool_iterator
4729            i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
4730       // This const_cast is a bit lame.  Really, Triggered should be mutable.
4731       DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
4732       if (diag.Triggered)
4733         continue;
4734
4735       switch (diag.Kind) {
4736       case DelayedDiagnostic::Deprecation:
4737         // Don't bother giving deprecation diagnostics if the decl is invalid.
4738         if (!decl->isInvalidDecl())
4739           HandleDelayedDeprecationCheck(diag, decl);
4740         break;
4741
4742       case DelayedDiagnostic::Access:
4743         HandleDelayedAccessCheck(diag, decl);
4744         break;
4745
4746       case DelayedDiagnostic::ForbiddenType:
4747         handleDelayedForbiddenType(*this, diag, decl);
4748         break;
4749       }
4750     }
4751   } while ((pool = pool->getParent()));
4752 }
4753
4754 /// Given a set of delayed diagnostics, re-emit them as if they had
4755 /// been delayed in the current context instead of in the given pool.
4756 /// Essentially, this just moves them to the current pool.
4757 void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
4758   DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
4759   assert(curPool && "re-emitting in undelayed context not supported");
4760   curPool->steal(pool);
4761 }
4762
4763 static bool isDeclDeprecated(Decl *D) {
4764   do {
4765     if (D->isDeprecated())
4766       return true;
4767     // A category implicitly has the availability of the interface.
4768     if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
4769       return CatD->getClassInterface()->isDeprecated();
4770   } while ((D = cast_or_null<Decl>(D->getDeclContext())));
4771   return false;
4772 }
4773
4774 static void
4775 DoEmitDeprecationWarning(Sema &S, const NamedDecl *D, StringRef Message,
4776                          SourceLocation Loc,
4777                          const ObjCInterfaceDecl *UnknownObjCClass) {
4778   DeclarationName Name = D->getDeclName();
4779   if (!Message.empty()) {
4780     S.Diag(Loc, diag::warn_deprecated_message) << Name << Message;
4781     S.Diag(D->getLocation(),
4782            isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
4783                                   : diag::note_previous_decl) << Name;
4784   } else if (!UnknownObjCClass) {
4785     S.Diag(Loc, diag::warn_deprecated) << D->getDeclName();
4786     S.Diag(D->getLocation(),
4787            isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
4788                                   : diag::note_previous_decl) << Name;
4789   } else {
4790     S.Diag(Loc, diag::warn_deprecated_fwdclass_message) << Name;
4791     S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
4792   }
4793 }
4794
4795 void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
4796                                          Decl *Ctx) {
4797   if (isDeclDeprecated(Ctx))
4798     return;
4799
4800   DD.Triggered = true;
4801   DoEmitDeprecationWarning(*this, DD.getDeprecationDecl(),
4802                            DD.getDeprecationMessage(), DD.Loc,
4803                            DD.getUnknownObjCClass());
4804 }
4805
4806 void Sema::EmitDeprecationWarning(NamedDecl *D, StringRef Message,
4807                                   SourceLocation Loc,
4808                                   const ObjCInterfaceDecl *UnknownObjCClass) {
4809   // Delay if we're currently parsing a declaration.
4810   if (DelayedDiagnostics.shouldDelayDiagnostics()) {
4811     DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D,
4812                                                               UnknownObjCClass,
4813                                                               Message));
4814     return;
4815   }
4816
4817   // Otherwise, don't warn if our current context is deprecated.
4818   if (isDeclDeprecated(cast<Decl>(getCurLexicalContext())))
4819     return;
4820   DoEmitDeprecationWarning(*this, D, Message, Loc, UnknownObjCClass);
4821 }