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

   1 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements decl-related attribute processing.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Sema/SemaInternal.h"
  15 #include "TargetAttributesSema.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/Basic/SourceManager.h"
  21 #include "clang/Basic/TargetInfo.h"
  22 #include "clang/Sema/DeclSpec.h"
  23 #include "clang/Sema/DelayedDiagnostic.h"
  24 #include "llvm/ADT/StringExtras.h"
  25 using namespace clang;
  26 using namespace sema;
  27
  28 /// These constants match the enumerated choices of
  29 /// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
  30 enum {
  31   ExpectedFunction,
  32   ExpectedUnion,
  33   ExpectedVariableOrFunction,
  34   ExpectedFunctionOrMethod,
  35   ExpectedParameter,
  36   ExpectedParameterOrMethod,
  37   ExpectedFunctionMethodOrBlock,
  38   ExpectedClassOrVirtualMethod,
  39   ExpectedFunctionMethodOrParameter,
  40   ExpectedClass,
  41   ExpectedVirtualMethod,
  42   ExpectedClassMember,
  43   ExpectedVariable,
  44   ExpectedMethod,
  45   ExpectedVariableFunctionOrLabel
  46 };
  47
  48 //===----------------------------------------------------------------------===//
  49 //  Helper functions
  50 //===----------------------------------------------------------------------===//
  51
  52 static const FunctionType *getFunctionType(const Decl *D,
  53                                            bool blocksToo = true) {
  54   QualType Ty;
  55   if (const ValueDecl *decl = dyn_cast<ValueDecl>(D))
  56     Ty = decl->getType();
  57   else if (const FieldDecl *decl = dyn_cast<FieldDecl>(D))
  58     Ty = decl->getType();
  59   else if (const TypedefNameDecl* decl = dyn_cast<TypedefNameDecl>(D))
  60     Ty = decl->getUnderlyingType();
  61   else
  62     return 0;
  63
  64   if (Ty->isFunctionPointerType())
  65     Ty = Ty->getAs<PointerType>()->getPointeeType();
  66   else if (blocksToo && Ty->isBlockPointerType())
  67     Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
  68
  69   return Ty->getAs<FunctionType>();
  70 }
  71
  72 // FIXME: We should provide an abstraction around a method or function
  73 // to provide the following bits of information.
  74
  75 /// isFunction - Return true if the given decl has function
  76 /// type (function or function-typed variable).
  77 static bool isFunction(const Decl *D) {
  78   return getFunctionType(D, false) != NULL;
  79 }
  80
  81 /// isFunctionOrMethod - Return true if the given decl has function
  82 /// type (function or function-typed variable) or an Objective-C
  83 /// method.
  84 static bool isFunctionOrMethod(const Decl *D) {
  85   return isFunction(D)|| isa<ObjCMethodDecl>(D);
  86 }
  87
  88 /// isFunctionOrMethodOrBlock - Return true if the given decl has function
  89 /// type (function or function-typed variable) or an Objective-C
  90 /// method or a block.
  91 static bool isFunctionOrMethodOrBlock(const Decl *D) {
  92   if (isFunctionOrMethod(D))
  93     return true;
  94   // check for block is more involved.
  95   if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
  96     QualType Ty = V->getType();
  97     return Ty->isBlockPointerType();
  98   }
  99   return isa<BlockDecl>(D);
 100 }
 101
 102 /// Return true if the given decl has a declarator that should have
 103 /// been processed by Sema::GetTypeForDeclarator.
 104 static bool hasDeclarator(const Decl *D) {
 105   // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
 106   return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
 107          isa<ObjCPropertyDecl>(D);
 108 }
 109
 110 /// hasFunctionProto - Return true if the given decl has a argument
 111 /// information. This decl should have already passed
 112 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
 113 static bool hasFunctionProto(const Decl *D) {
 114   if (const FunctionType *FnTy = getFunctionType(D))
 115     return isa<FunctionProtoType>(FnTy);
 116   else {
 117     assert(isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D));
 118     return true;
 119   }
 120 }
 121
 122 /// getFunctionOrMethodNumArgs - Return number of function or method
 123 /// arguments. It is an error to call this on a K&R function (use
 124 /// hasFunctionProto first).
 125 static unsigned getFunctionOrMethodNumArgs(const Decl *D) {
 126   if (const FunctionType *FnTy = getFunctionType(D))
 127     return cast<FunctionProtoType>(FnTy)->getNumArgs();
 128   if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 129     return BD->getNumParams();
 130   return cast<ObjCMethodDecl>(D)->param_size();
 131 }
 132
 133 static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) {
 134   if (const FunctionType *FnTy = getFunctionType(D))
 135     return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
 136   if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 137     return BD->getParamDecl(Idx)->getType();
 138
 139   return cast<ObjCMethodDecl>(D)->param_begin()[Idx]->getType();
 140 }
 141
 142 static QualType getFunctionOrMethodResultType(const Decl *D) {
 143   if (const FunctionType *FnTy = getFunctionType(D))
 144     return cast<FunctionProtoType>(FnTy)->getResultType();
 145   return cast<ObjCMethodDecl>(D)->getResultType();
 146 }
 147
 148 static bool isFunctionOrMethodVariadic(const Decl *D) {
 149   if (const FunctionType *FnTy = getFunctionType(D)) {
 150     const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
 151     return proto->isVariadic();
 152   } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
 153     return BD->isVariadic();
 154   else {
 155     return cast<ObjCMethodDecl>(D)->isVariadic();
 156   }
 157 }
 158
 159 static bool isInstanceMethod(const Decl *D) {
 160   if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
 161     return MethodDecl->isInstance();
 162   return false;
 163 }
 164
 165 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
 166   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
 167   if (!PT)
 168     return false;
 169
 170   ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
 171   if (!Cls)
 172     return false;
 173
 174   IdentifierInfo* ClsName = Cls->getIdentifier();
 175
 176   // FIXME: Should we walk the chain of classes?
 177   return ClsName == &Ctx.Idents.get("NSString") ||
 178          ClsName == &Ctx.Idents.get("NSMutableString");
 179 }
 180
 181 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
 182   const PointerType *PT = T->getAs<PointerType>();
 183   if (!PT)
 184     return false;
 185
 186   const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
 187   if (!RT)
 188     return false;
 189
 190   const RecordDecl *RD = RT->getDecl();
 191   if (RD->getTagKind() != TTK_Struct)
 192     return false;
 193
 194   return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
 195 }
 196
 197 static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
 198                                   unsigned int Num) {
 199   if (Attr.getNumArgs() != Num) {
 200     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num;
 201     return false;
 202   }
 203
 204   return true;
 205 }
 206
 207 //===----------------------------------------------------------------------===//
 208 // Attribute Implementations
 209 //===----------------------------------------------------------------------===//
 210
 211 // FIXME: All this manual attribute parsing code is gross. At the
 212 // least add some helper functions to check most argument patterns (#
 213 // and types of args).
 214
 215 static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
 216                                     const AttributeList &Attr) {
 217   TypedefNameDecl *tDecl = dyn_cast<TypedefNameDecl>(D);
 218   if (tDecl == 0) {
 219     S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
 220     return;
 221   }
 222
 223   QualType curType = tDecl->getUnderlyingType();
 224
 225   Expr *sizeExpr;
 226
 227   // Special case where the argument is a template id.
 228   if (Attr.getParameterName()) {
 229     CXXScopeSpec SS;
 230     UnqualifiedId id;
 231     id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
 232
 233     ExprResult Size = S.ActOnIdExpression(scope, SS, id, false, false);
 234     if (Size.isInvalid())
 235       return;
 236
 237     sizeExpr = Size.get();
 238   } else {
 239     // check the attribute arguments.
 240     if (!checkAttributeNumArgs(S, Attr, 1))
 241       return;
 242
 243     sizeExpr = Attr.getArg(0);
 244   }
 245
 246   // Instantiate/Install the vector type, and let Sema build the type for us.
 247   // This will run the reguired checks.
 248   QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc());
 249   if (!T.isNull()) {
 250     // FIXME: preserve the old source info.
 251     tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
 252
 253     // Remember this typedef decl, we will need it later for diagnostics.
 254     S.ExtVectorDecls.push_back(tDecl);
 255   }
 256 }
 257
 258 static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 259   // check the attribute arguments.
 260   if (!checkAttributeNumArgs(S, Attr, 0))
 261     return;
 262
 263   if (TagDecl *TD = dyn_cast<TagDecl>(D))
 264     TD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
 265   else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
 266     // If the alignment is less than or equal to 8 bits, the packed attribute
 267     // has no effect.
 268     if (!FD->getType()->isIncompleteType() &&
 269         S.Context.getTypeAlign(FD->getType()) <= 8)
 270       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
 271         << Attr.getName() << FD->getType();
 272     else
 273       FD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
 274   } else
 275     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
 276 }
 277
 278 static void handleMsStructAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 279   if (TagDecl *TD = dyn_cast<TagDecl>(D))
 280     TD->addAttr(::new (S.Context) MsStructAttr(Attr.getLoc(), S.Context));
 281   else
 282     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
 283 }
 284
 285 static void handleIBAction(Sema &S, Decl *D, const AttributeList &Attr) {
 286   // check the attribute arguments.
 287   if (!checkAttributeNumArgs(S, Attr, 0))
 288     return;
 289
 290   // The IBAction attributes only apply to instance methods.
 291   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
 292     if (MD->isInstanceMethod()) {
 293       D->addAttr(::new (S.Context) IBActionAttr(Attr.getLoc(), S.Context));
 294       return;
 295     }
 296
 297   S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName();
 298 }
 299
 300 static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
 301   // check the attribute arguments.
 302   if (!checkAttributeNumArgs(S, Attr, 0))
 303     return;
 304
 305   // The IBOutlet attributes only apply to instance variables of
 306   // Objective-C classes.
 307   if (isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D)) {
 308     D->addAttr(::new (S.Context) IBOutletAttr(Attr.getLoc(), S.Context));
 309     return;
 310   }
 311
 312   S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
 313 }
 314
 315 static void handleIBOutletCollection(Sema &S, Decl *D,
 316                                      const AttributeList &Attr) {
 317
 318   // The iboutletcollection attribute can have zero or one arguments.
 319   if (Attr.getParameterName() && Attr.getNumArgs() > 0) {
 320     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 321     return;
 322   }
 323
 324   // The IBOutletCollection attributes only apply to instance variables of
 325   // Objective-C classes.
 326   if (!(isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {
 327     S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
 328     return;
 329   }
 330   if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
 331     if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
 332       S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
 333         << VD->getType() << 0;
 334       return;
 335     }
 336   if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
 337     if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
 338       S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
 339         << PD->getType() << 1;
 340       return;
 341     }
 342
 343   IdentifierInfo *II = Attr.getParameterName();
 344   if (!II)
 345     II = &S.Context.Idents.get("id");
 346
 347   ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(),
 348                         S.getScopeForContext(D->getDeclContext()->getParent()));
 349   if (!TypeRep) {
 350     S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
 351     return;
 352   }
 353   QualType QT = TypeRep.get();
 354   // Diagnose use of non-object type in iboutletcollection attribute.
 355   // FIXME. Gnu attribute extension ignores use of builtin types in
 356   // attributes. So, __attribute__((iboutletcollection(char))) will be
 357   // treated as __attribute__((iboutletcollection())).
 358   if (!QT->isObjCIdType() && !QT->isObjCClassType() &&
 359       !QT->isObjCObjectType()) {
 360     S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
 361     return;
 362   }
 363   D->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getLoc(), S.Context,
 364                                                       QT));
 365 }
 366
 367 static void possibleTransparentUnionPointerType(QualType &T) {
 368   if (const RecordType *UT = T->getAsUnionType())
 369     if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
 370       RecordDecl *UD = UT->getDecl();
 371       for (RecordDecl::field_iterator it = UD->field_begin(),
 372            itend = UD->field_end(); it != itend; ++it) {
 373         QualType QT = it->getType();
 374         if (QT->isAnyPointerType() || QT->isBlockPointerType()) {
 375           T = QT;
 376           return;
 377         }
 378       }
 379     }
 380 }
 381
 382 static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 383   // GCC ignores the nonnull attribute on K&R style function prototypes, so we
 384   // ignore it as well
 385   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
 386     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 387       << Attr.getName() << ExpectedFunction;
 388     return;
 389   }
 390
 391   // In C++ the implicit 'this' function parameter also counts, and they are
 392   // counted from one.
 393   bool HasImplicitThisParam = isInstanceMethod(D);
 394   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
 395
 396   // The nonnull attribute only applies to pointers.
 397   llvm::SmallVector<unsigned, 10> NonNullArgs;
 398
 399   for (AttributeList::arg_iterator I=Attr.arg_begin(),
 400                                    E=Attr.arg_end(); I!=E; ++I) {
 401
 402
 403     // The argument must be an integer constant expression.
 404     Expr *Ex = *I;
 405     llvm::APSInt ArgNum(32);
 406     if (Ex->isTypeDependent() || Ex->isValueDependent() ||
 407         !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
 408       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
 409         << "nonnull" << Ex->getSourceRange();
 410       return;
 411     }
 412
 413     unsigned x = (unsigned) ArgNum.getZExtValue();
 414
 415     if (x < 1 || x > NumArgs) {
 416       S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
 417        << "nonnull" << I.getArgNum() << Ex->getSourceRange();
 418       return;
 419     }
 420
 421     --x;
 422     if (HasImplicitThisParam) {
 423       if (x == 0) {
 424         S.Diag(Attr.getLoc(),
 425                diag::err_attribute_invalid_implicit_this_argument)
 426           << "nonnull" << Ex->getSourceRange();
 427         return;
 428       }
 429       --x;
 430     }
 431
 432     // Is the function argument a pointer type?
 433     QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
 434     possibleTransparentUnionPointerType(T);
 435
 436     if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
 437       // FIXME: Should also highlight argument in decl.
 438       S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only)
 439         << "nonnull" << Ex->getSourceRange();
 440       continue;
 441     }
 442
 443     NonNullArgs.push_back(x);
 444   }
 445
 446   // If no arguments were specified to __attribute__((nonnull)) then all pointer
 447   // arguments have a nonnull attribute.
 448   if (NonNullArgs.empty()) {
 449     for (unsigned I = 0, E = getFunctionOrMethodNumArgs(D); I != E; ++I) {
 450       QualType T = getFunctionOrMethodArgType(D, I).getNonReferenceType();
 451       possibleTransparentUnionPointerType(T);
 452       if (T->isAnyPointerType() || T->isBlockPointerType())
 453         NonNullArgs.push_back(I);
 454     }
 455
 456     // No pointer arguments?
 457     if (NonNullArgs.empty()) {
 458       // Warn the trivial case only if attribute is not coming from a
 459       // macro instantiation.
 460       if (Attr.getLoc().isFileID())
 461         S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
 462       return;
 463     }
 464   }
 465
 466   unsigned* start = &NonNullArgs[0];
 467   unsigned size = NonNullArgs.size();
 468   llvm::array_pod_sort(start, start + size);
 469   D->addAttr(::new (S.Context) NonNullAttr(Attr.getLoc(), S.Context, start,
 470                                            size));
 471 }
 472
 473 static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
 474   // This attribute must be applied to a function declaration.
 475   // The first argument to the attribute must be a string,
 476   // the name of the resource, for example "malloc".
 477   // The following arguments must be argument indexes, the arguments must be
 478   // of integer type for Returns, otherwise of pointer type.
 479   // The difference between Holds and Takes is that a pointer may still be used
 480   // after being held.  free() should be __attribute((ownership_takes)), whereas
 481   // a list append function may well be __attribute((ownership_holds)).
 482
 483   if (!AL.getParameterName()) {
 484     S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string)
 485         << AL.getName()->getName() << 1;
 486     return;
 487   }
 488   // Figure out our Kind, and check arguments while we're at it.
 489   OwnershipAttr::OwnershipKind K;
 490   switch (AL.getKind()) {
 491   case AttributeList::AT_ownership_takes:
 492     K = OwnershipAttr::Takes;
 493     if (AL.getNumArgs() < 1) {
 494       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
 495       return;
 496     }
 497     break;
 498   case AttributeList::AT_ownership_holds:
 499     K = OwnershipAttr::Holds;
 500     if (AL.getNumArgs() < 1) {
 501       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
 502       return;
 503     }
 504     break;
 505   case AttributeList::AT_ownership_returns:
 506     K = OwnershipAttr::Returns;
 507     if (AL.getNumArgs() > 1) {
 508       S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
 509           << AL.getNumArgs() + 1;
 510       return;
 511     }
 512     break;
 513   default:
 514     // This should never happen given how we are called.
 515     llvm_unreachable("Unknown ownership attribute");
 516   }
 517
 518   if (!isFunction(D) || !hasFunctionProto(D)) {
 519     S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
 520       << AL.getName() << ExpectedFunction;
 521     return;
 522   }
 523
 524   // In C++ the implicit 'this' function parameter also counts, and they are
 525   // counted from one.
 526   bool HasImplicitThisParam = isInstanceMethod(D);
 527   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
 528
 529   llvm::StringRef Module = AL.getParameterName()->getName();
 530
 531   // Normalize the argument, __foo__ becomes foo.
 532   if (Module.startswith("__") && Module.endswith("__"))
 533     Module = Module.substr(2, Module.size() - 4);
 534
 535   llvm::SmallVector<unsigned, 10> OwnershipArgs;
 536
 537   for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E;
 538        ++I) {
 539
 540     Expr *IdxExpr = *I;
 541     llvm::APSInt ArgNum(32);
 542     if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
 543         || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
 544       S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int)
 545           << AL.getName()->getName() << IdxExpr->getSourceRange();
 546       continue;
 547     }
 548
 549     unsigned x = (unsigned) ArgNum.getZExtValue();
 550
 551     if (x > NumArgs || x < 1) {
 552       S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
 553           << AL.getName()->getName() << x << IdxExpr->getSourceRange();
 554       continue;
 555     }
 556     --x;
 557     if (HasImplicitThisParam) {
 558       if (x == 0) {
 559         S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
 560           << "ownership" << IdxExpr->getSourceRange();
 561         return;
 562       }
 563       --x;
 564     }
 565
 566     switch (K) {
 567     case OwnershipAttr::Takes:
 568     case OwnershipAttr::Holds: {
 569       // Is the function argument a pointer type?
 570       QualType T = getFunctionOrMethodArgType(D, x);
 571       if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
 572         // FIXME: Should also highlight argument in decl.
 573         S.Diag(AL.getLoc(), diag::err_ownership_type)
 574             << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds")
 575             << "pointer"
 576             << IdxExpr->getSourceRange();
 577         continue;
 578       }
 579       break;
 580     }
 581     case OwnershipAttr::Returns: {
 582       if (AL.getNumArgs() > 1) {
 583           // Is the function argument an integer type?
 584           Expr *IdxExpr = AL.getArg(0);
 585           llvm::APSInt ArgNum(32);
 586           if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
 587               || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
 588             S.Diag(AL.getLoc(), diag::err_ownership_type)
 589                 << "ownership_returns" << "integer"
 590                 << IdxExpr->getSourceRange();
 591             return;
 592           }
 593       }
 594       break;
 595     }
 596     default:
 597       llvm_unreachable("Unknown ownership attribute");
 598     } // switch
 599
 600     // Check we don't have a conflict with another ownership attribute.
 601     for (specific_attr_iterator<OwnershipAttr>
 602           i = D->specific_attr_begin<OwnershipAttr>(),
 603           e = D->specific_attr_end<OwnershipAttr>();
 604         i != e; ++i) {
 605       if ((*i)->getOwnKind() != K) {
 606         for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end();
 607              I!=E; ++I) {
 608           if (x == *I) {
 609             S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
 610                 << AL.getName()->getName() << "ownership_*";
 611           }
 612         }
 613       }
 614     }
 615     OwnershipArgs.push_back(x);
 616   }
 617
 618   unsigned* start = OwnershipArgs.data();
 619   unsigned size = OwnershipArgs.size();
 620   llvm::array_pod_sort(start, start + size);
 621
 622   if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) {
 623     S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
 624     return;
 625   }
 626
 627   D->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module,
 628                                              start, size));
 629 }
 630
 631 /// Whether this declaration has internal linkage for the purposes of
 632 /// things that want to complain about things not have internal linkage.
 633 static bool hasEffectivelyInternalLinkage(NamedDecl *D) {
 634   switch (D->getLinkage()) {
 635   case NoLinkage:
 636   case InternalLinkage:
 637     return true;
 638
 639   // Template instantiations that go from external to unique-external
 640   // shouldn't get diagnosed.
 641   case UniqueExternalLinkage:
 642     return true;
 643
 644   case ExternalLinkage:
 645     return false;
 646   }
 647   llvm_unreachable("unknown linkage kind!");
 648   return false;
 649 }
 650
 651 static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 652   // Check the attribute arguments.
 653   if (Attr.getNumArgs() > 1) {
 654     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 655     return;
 656   }
 657
 658   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
 659     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
 660       << Attr.getName() << ExpectedVariableOrFunction;
 661     return;
 662   }
 663
 664   NamedDecl *nd = cast<NamedDecl>(D);
 665
 666   // gcc rejects
 667   // class c {
 668   //   static int a __attribute__((weakref ("v2")));
 669   //   static int b() __attribute__((weakref ("f3")));
 670   // };
 671   // and ignores the attributes of
 672   // void f(void) {
 673   //   static int a __attribute__((weakref ("v2")));
 674   // }
 675   // we reject them
 676   const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
 677   if (!Ctx->isFileContext()) {
 678     S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
 679         nd->getNameAsString();
 680     return;
 681   }
 682
 683   // The GCC manual says
 684   //
 685   // At present, a declaration to which `weakref' is attached can only
 686   // be `static'.
 687   //
 688   // It also says
 689   //
 690   // Without a TARGET,
 691   // given as an argument to `weakref' or to `alias', `weakref' is
 692   // equivalent to `weak'.
 693   //
 694   // gcc 4.4.1 will accept
 695   // int a7 __attribute__((weakref));
 696   // as
 697   // int a7 __attribute__((weak));
 698   // This looks like a bug in gcc. We reject that for now. We should revisit
 699   // it if this behaviour is actually used.
 700
 701   if (!hasEffectivelyInternalLinkage(nd)) {
 702     S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static);
 703     return;
 704   }
 705
 706   // GCC rejects
 707   // static ((alias ("y"), weakref)).
 708   // Should we? How to check that weakref is before or after alias?
 709
 710   if (Attr.getNumArgs() == 1) {
 711     Expr *Arg = Attr.getArg(0);
 712     Arg = Arg->IgnoreParenCasts();
 713     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
 714
 715     if (Str == 0 || Str->isWide()) {
 716       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 717           << "weakref" << 1;
 718       return;
 719     }
 720     // GCC will accept anything as the argument of weakref. Should we
 721     // check for an existing decl?
 722     D->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
 723                                            Str->getString()));
 724   }
 725
 726   D->addAttr(::new (S.Context) WeakRefAttr(Attr.getLoc(), S.Context));
 727 }
 728
 729 static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 730   // check the attribute arguments.
 731   if (Attr.getNumArgs() != 1) {
 732     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 733     return;
 734   }
 735
 736   Expr *Arg = Attr.getArg(0);
 737   Arg = Arg->IgnoreParenCasts();
 738   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
 739
 740   if (Str == 0 || Str->isWide()) {
 741     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 742       << "alias" << 1;
 743     return;
 744   }
 745
 746   if (S.Context.Target.getTriple().isOSDarwin()) {
 747     S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
 748     return;
 749   }
 750
 751   // FIXME: check if target symbol exists in current file
 752
 753   D->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
 754                                          Str->getString()));
 755 }
 756
 757 static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 758   // Check the attribute arguments.
 759   if (!checkAttributeNumArgs(S, Attr, 0))
 760     return;
 761
 762   if (!isa<FunctionDecl>(D)) {
 763     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 764       << Attr.getName() << ExpectedFunction;
 765     return;
 766   }
 767
 768   D->addAttr(::new (S.Context) NakedAttr(Attr.getLoc(), S.Context));
 769 }
 770
 771 static void handleAlwaysInlineAttr(Sema &S, Decl *D,
 772                                    const AttributeList &Attr) {
 773   // Check the attribute arguments.
 774   if (Attr.hasParameterOrArguments()) {
 775     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 776     return;
 777   }
 778
 779   if (!isa<FunctionDecl>(D)) {
 780     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 781       << Attr.getName() << ExpectedFunction;
 782     return;
 783   }
 784
 785   D->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getLoc(), S.Context));
 786 }
 787
 788 static void handleMallocAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 789   // Check the attribute arguments.
 790   if (Attr.hasParameterOrArguments()) {
 791     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 792     return;
 793   }
 794
 795   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 796     QualType RetTy = FD->getResultType();
 797     if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
 798       D->addAttr(::new (S.Context) MallocAttr(Attr.getLoc(), S.Context));
 799       return;
 800     }
 801   }
 802
 803   S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
 804 }
 805
 806 static void handleMayAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 807   // check the attribute arguments.
 808   if (!checkAttributeNumArgs(S, Attr, 0))
 809     return;
 810
 811   D->addAttr(::new (S.Context) MayAliasAttr(Attr.getLoc(), S.Context));
 812 }
 813
 814 static void handleNoCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 815   assert(!Attr.isInvalid());
 816   if (isa<VarDecl>(D))
 817     D->addAttr(::new (S.Context) NoCommonAttr(Attr.getLoc(), S.Context));
 818   else
 819     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 820       << Attr.getName() << ExpectedVariable;
 821 }
 822
 823 static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 824   assert(!Attr.isInvalid());
 825   if (isa<VarDecl>(D))
 826     D->addAttr(::new (S.Context) CommonAttr(Attr.getLoc(), S.Context));
 827   else
 828     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 829       << Attr.getName() << ExpectedVariable;
 830 }
 831
 832 static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
 833   if (hasDeclarator(D)) return;
 834
 835   if (S.CheckNoReturnAttr(attr)) return;
 836
 837   if (!isa<ObjCMethodDecl>(D)) {
 838     S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 839       << attr.getName() << ExpectedFunctionOrMethod;
 840     return;
 841   }
 842
 843   D->addAttr(::new (S.Context) NoReturnAttr(attr.getLoc(), S.Context));
 844 }
 845
 846 bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
 847   if (attr.hasParameterOrArguments()) {
 848     Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 849     attr.setInvalid();
 850     return true;
 851   }
 852
 853   return false;
 854 }
 855
 856 static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
 857                                        const AttributeList &Attr) {
 858
 859   // The checking path for 'noreturn' and 'analyzer_noreturn' are different
 860   // because 'analyzer_noreturn' does not impact the type.
 861
 862   if(!checkAttributeNumArgs(S, Attr, 0))
 863       return;
 864
 865   if (!isFunctionOrMethod(D) && !isa<BlockDecl>(D)) {
 866     ValueDecl *VD = dyn_cast<ValueDecl>(D);
 867     if (VD == 0 || (!VD->getType()->isBlockPointerType()
 868                     && !VD->getType()->isFunctionPointerType())) {
 869       S.Diag(Attr.getLoc(),
 870              Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
 871              : diag::warn_attribute_wrong_decl_type)
 872         << Attr.getName() << ExpectedFunctionMethodOrBlock;
 873       return;
 874     }
 875   }
 876
 877   D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getLoc(), S.Context));
 878 }
 879
 880 // PS3 PPU-specific.
 881 static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 882 /*
 883   Returning a Vector Class in Registers
 884
 885   According to the PPU ABI specifications, a class with a single member of
 886   vector type is returned in memory when used as the return value of a function.
 887   This results in inefficient code when implementing vector classes. To return
 888   the value in a single vector register, add the vecreturn attribute to the
 889   class definition. This attribute is also applicable to struct types.
 890
 891   Example:
 892
 893   struct Vector
 894   {
 895     __vector float xyzw;
 896   } __attribute__((vecreturn));
 897
 898   Vector Add(Vector lhs, Vector rhs)
 899   {
 900     Vector result;
 901     result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
 902     return result; // This will be returned in a register
 903   }
 904 */
 905   if (!isa<RecordDecl>(D)) {
 906     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
 907       << Attr.getName() << ExpectedClass;
 908     return;
 909   }
 910
 911   if (D->getAttr<VecReturnAttr>()) {
 912     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn";
 913     return;
 914   }
 915
 916   RecordDecl *record = cast<RecordDecl>(D);
 917   int count = 0;
 918
 919   if (!isa<CXXRecordDecl>(record)) {
 920     S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
 921     return;
 922   }
 923
 924   if (!cast<CXXRecordDecl>(record)->isPOD()) {
 925     S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
 926     return;
 927   }
 928
 929   for (RecordDecl::field_iterator iter = record->field_begin();
 930        iter != record->field_end(); iter++) {
 931     if ((count == 1) || !iter->getType()->isVectorType()) {
 932       S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
 933       return;
 934     }
 935     count++;
 936   }
 937
 938   D->addAttr(::new (S.Context) VecReturnAttr(Attr.getLoc(), S.Context));
 939 }
 940
 941 static void handleDependencyAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 942   if (!isFunctionOrMethod(D) && !isa<ParmVarDecl>(D)) {
 943     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
 944       << Attr.getName() << ExpectedFunctionMethodOrParameter;
 945     return;
 946   }
 947   // FIXME: Actually store the attribute on the declaration
 948 }
 949
 950 static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 951   // check the attribute arguments.
 952   if (Attr.hasParameterOrArguments()) {
 953     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 954     return;
 955   }
 956
 957   if (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isFunctionOrMethod(D) &&
 958       !isa<TypeDecl>(D) && !isa<LabelDecl>(D)) {
 959     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 960       << Attr.getName() << ExpectedVariableFunctionOrLabel;
 961     return;
 962   }
 963
 964   D->addAttr(::new (S.Context) UnusedAttr(Attr.getLoc(), S.Context));
 965 }
 966
 967 static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 968   // check the attribute arguments.
 969   if (Attr.hasParameterOrArguments()) {
 970     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 971     return;
 972   }
 973
 974   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
 975     if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
 976       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
 977       return;
 978     }
 979   } else if (!isFunctionOrMethod(D)) {
 980     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 981       << Attr.getName() << ExpectedVariableOrFunction;
 982     return;
 983   }
 984
 985   D->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
 986 }
 987
 988 static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
 989   // check the attribute arguments.
 990   if (Attr.getNumArgs() > 1) {
 991     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
 992     return;
 993   }
 994
 995   int priority = 65535; // FIXME: Do not hardcode such constants.
 996   if (Attr.getNumArgs() > 0) {
 997     Expr *E = Attr.getArg(0);
 998     llvm::APSInt Idx(32);
 999     if (E->isTypeDependent() || E->isValueDependent() ||
1000         !E->isIntegerConstantExpr(Idx, S.Context)) {
1001       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1002         << "constructor" << 1 << E->getSourceRange();
1003       return;
1004     }
1005     priority = Idx.getZExtValue();
1006   }
1007
1008   if (!isa<FunctionDecl>(D)) {
1009     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1010       << Attr.getName() << ExpectedFunction;
1011     return;
1012   }
1013
1014   D->addAttr(::new (S.Context) ConstructorAttr(Attr.getLoc(), S.Context,
1015                                                priority));
1016 }
1017
1018 static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1019   // check the attribute arguments.
1020   if (Attr.getNumArgs() > 1) {
1021     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1022     return;
1023   }
1024
1025   int priority = 65535; // FIXME: Do not hardcode such constants.
1026   if (Attr.getNumArgs() > 0) {
1027     Expr *E = Attr.getArg(0);
1028     llvm::APSInt Idx(32);
1029     if (E->isTypeDependent() || E->isValueDependent() ||
1030         !E->isIntegerConstantExpr(Idx, S.Context)) {
1031       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1032         << "destructor" << 1 << E->getSourceRange();
1033       return;
1034     }
1035     priority = Idx.getZExtValue();
1036   }
1037
1038   if (!isa<FunctionDecl>(D)) {
1039     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1040       << Attr.getName() << ExpectedFunction;
1041     return;
1042   }
1043
1044   D->addAttr(::new (S.Context) DestructorAttr(Attr.getLoc(), S.Context,
1045                                               priority));
1046 }
1047
1048 static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1049   unsigned NumArgs = Attr.getNumArgs();
1050   if (NumArgs > 1) {
1051     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1052     return;
1053   }
1054
1055   // Handle the case where deprecated attribute has a text message.
1056   llvm::StringRef Str;
1057   if (NumArgs == 1) {
1058     StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
1059     if (!SE) {
1060       S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string)
1061         << "deprecated";
1062       return;
1063     }
1064     Str = SE->getString();
1065   }
1066
1067   D->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context, Str));
1068 }
1069
1070 static void handleUnavailableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1071   unsigned NumArgs = Attr.getNumArgs();
1072   if (NumArgs > 1) {
1073     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1074     return;
1075   }
1076
1077   // Handle the case where unavailable attribute has a text message.
1078   llvm::StringRef Str;
1079   if (NumArgs == 1) {
1080     StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
1081     if (!SE) {
1082       S.Diag(Attr.getArg(0)->getLocStart(),
1083              diag::err_attribute_not_string) << "unavailable";
1084       return;
1085     }
1086     Str = SE->getString();
1087   }
1088   D->addAttr(::new (S.Context) UnavailableAttr(Attr.getLoc(), S.Context, Str));
1089 }
1090
1091 static void handleArcWeakrefUnavailableAttr(Sema &S, Decl *D,
1092                                             const AttributeList &Attr) {
1093   unsigned NumArgs = Attr.getNumArgs();
1094   if (NumArgs > 0) {
1095     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1096     return;
1097   }
1098
1099   D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(
1100                                           Attr.getLoc(), S.Context));
1101 }
1102
1103 static void handleAvailabilityAttr(Sema &S, Decl *D,
1104                                    const AttributeList &Attr) {
1105   IdentifierInfo *Platform = Attr.getParameterName();
1106   SourceLocation PlatformLoc = Attr.getParameterLoc();
1107
1108   llvm::StringRef PlatformName
1109     = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1110   if (PlatformName.empty()) {
1111     S.Diag(PlatformLoc, diag::warn_availability_unknown_platform)
1112       << Platform;
1113
1114     PlatformName = Platform->getName();
1115   }
1116
1117   AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1118   AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1119   AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
1120   bool IsUnavailable = Attr.getUnavailableLoc().isValid();
1121
1122   // Ensure that Introduced < Deprecated < Obsoleted (although not all
1123   // of these steps are needed).
1124   if (Introduced.isValid() && Deprecated.isValid() &&
1125       !(Introduced.Version < Deprecated.Version)) {
1126     S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1127       << 1 << PlatformName << Deprecated.Version.getAsString()
1128       << 0 << Introduced.Version.getAsString();
1129     return;
1130   }
1131
1132   if (Introduced.isValid() && Obsoleted.isValid() &&
1133       !(Introduced.Version < Obsoleted.Version)) {
1134     S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1135       << 2 << PlatformName << Obsoleted.Version.getAsString()
1136       << 0 << Introduced.Version.getAsString();
1137     return;
1138   }
1139
1140   if (Deprecated.isValid() && Obsoleted.isValid() &&
1141       !(Deprecated.Version < Obsoleted.Version)) {
1142     S.Diag(Deprecated.KeywordLoc, diag::warn_availability_version_ordering)
1143       << 2 << PlatformName << Obsoleted.Version.getAsString()
1144       << 1 << Deprecated.Version.getAsString();
1145     return;
1146   }
1147
1148   D->addAttr(::new (S.Context) AvailabilityAttr(Attr.getLoc(), S.Context,
1149                                                 Platform,
1150                                                 Introduced.Version,
1151                                                 Deprecated.Version,
1152                                                 Obsoleted.Version,
1153                                                 IsUnavailable));
1154 }
1155
1156 static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1157   // check the attribute arguments.
1158   if(!checkAttributeNumArgs(S, Attr, 1))
1159     return;
1160
1161   Expr *Arg = Attr.getArg(0);
1162   Arg = Arg->IgnoreParenCasts();
1163   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1164
1165   if (Str == 0 || Str->isWide()) {
1166     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1167       << "visibility" << 1;
1168     return;
1169   }
1170
1171   llvm::StringRef TypeStr = Str->getString();
1172   VisibilityAttr::VisibilityType type;
1173
1174   if (TypeStr == "default")
1175     type = VisibilityAttr::Default;
1176   else if (TypeStr == "hidden")
1177     type = VisibilityAttr::Hidden;
1178   else if (TypeStr == "internal")
1179     type = VisibilityAttr::Hidden; // FIXME
1180   else if (TypeStr == "protected")
1181     type = VisibilityAttr::Protected;
1182   else {
1183     S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
1184     return;
1185   }
1186
1187   D->addAttr(::new (S.Context) VisibilityAttr(Attr.getLoc(), S.Context, type));
1188 }
1189
1190 static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
1191                                        const AttributeList &Attr) {
1192   ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl);
1193   if (!method) {
1194     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1195       << ExpectedMethod;
1196     return;
1197   }
1198
1199   if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) {
1200     if (!Attr.getParameterName() && Attr.getNumArgs() == 1) {
1201       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1202         << "objc_method_family" << 1;
1203     } else {
1204       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1205     }
1206     Attr.setInvalid();
1207     return;
1208   }
1209
1210   llvm::StringRef param = Attr.getParameterName()->getName();
1211   ObjCMethodFamilyAttr::FamilyKind family;
1212   if (param == "none")
1213     family = ObjCMethodFamilyAttr::OMF_None;
1214   else if (param == "alloc")
1215     family = ObjCMethodFamilyAttr::OMF_alloc;
1216   else if (param == "copy")
1217     family = ObjCMethodFamilyAttr::OMF_copy;
1218   else if (param == "init")
1219     family = ObjCMethodFamilyAttr::OMF_init;
1220   else if (param == "mutableCopy")
1221     family = ObjCMethodFamilyAttr::OMF_mutableCopy;
1222   else if (param == "new")
1223     family = ObjCMethodFamilyAttr::OMF_new;
1224   else {
1225     // Just warn and ignore it.  This is future-proof against new
1226     // families being used in system headers.
1227     S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family);
1228     return;
1229   }
1230
1231   if (family == ObjCMethodFamilyAttr::OMF_init &&
1232       !method->getResultType()->isObjCObjectPointerType()) {
1233     S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
1234       << method->getResultType();
1235     // Ignore the attribute.
1236     return;
1237   }
1238
1239   method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getLoc(),
1240                                                        S.Context, family));
1241 }
1242
1243 static void handleObjCExceptionAttr(Sema &S, Decl *D,
1244                                     const AttributeList &Attr) {
1245   if (!checkAttributeNumArgs(S, Attr, 0))
1246     return;
1247
1248   ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
1249   if (OCI == 0) {
1250     S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1251     return;
1252   }
1253
1254   D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getLoc(), S.Context));
1255 }
1256
1257 static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
1258   if (Attr.getNumArgs() != 0) {
1259     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1260     return;
1261   }
1262   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1263     QualType T = TD->getUnderlyingType();
1264     if (!T->isPointerType() ||
1265         !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
1266       S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
1267       return;
1268     }
1269   }
1270   D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getLoc(), S.Context));
1271 }
1272
1273 static void
1274 handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1275   if (Attr.getNumArgs() != 0) {
1276     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1277     return;
1278   }
1279
1280   if (!isa<FunctionDecl>(D)) {
1281     S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
1282     return;
1283   }
1284
1285   D->addAttr(::new (S.Context) OverloadableAttr(Attr.getLoc(), S.Context));
1286 }
1287
1288 static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1289   if (!Attr.getParameterName()) {
1290     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1291       << "blocks" << 1;
1292     return;
1293   }
1294
1295   if (Attr.getNumArgs() != 0) {
1296     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1297     return;
1298   }
1299
1300   BlocksAttr::BlockType type;
1301   if (Attr.getParameterName()->isStr("byref"))
1302     type = BlocksAttr::ByRef;
1303   else {
1304     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1305       << "blocks" << Attr.getParameterName();
1306     return;
1307   }
1308
1309   D->addAttr(::new (S.Context) BlocksAttr(Attr.getLoc(), S.Context, type));
1310 }
1311
1312 static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1313   // check the attribute arguments.
1314   if (Attr.getNumArgs() > 2) {
1315     S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
1316     return;
1317   }
1318
1319   int sentinel = 0;
1320   if (Attr.getNumArgs() > 0) {
1321     Expr *E = Attr.getArg(0);
1322     llvm::APSInt Idx(32);
1323     if (E->isTypeDependent() || E->isValueDependent() ||
1324         !E->isIntegerConstantExpr(Idx, S.Context)) {
1325       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1326        << "sentinel" << 1 << E->getSourceRange();
1327       return;
1328     }
1329     sentinel = Idx.getZExtValue();
1330
1331     if (sentinel < 0) {
1332       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
1333         << E->getSourceRange();
1334       return;
1335     }
1336   }
1337
1338   int nullPos = 0;
1339   if (Attr.getNumArgs() > 1) {
1340     Expr *E = Attr.getArg(1);
1341     llvm::APSInt Idx(32);
1342     if (E->isTypeDependent() || E->isValueDependent() ||
1343         !E->isIntegerConstantExpr(Idx, S.Context)) {
1344       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1345         << "sentinel" << 2 << E->getSourceRange();
1346       return;
1347     }
1348     nullPos = Idx.getZExtValue();
1349
1350     if (nullPos > 1 || nullPos < 0) {
1351       // FIXME: This error message could be improved, it would be nice
1352       // to say what the bounds actually are.
1353       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
1354         << E->getSourceRange();
1355       return;
1356     }
1357   }
1358
1359   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1360     const FunctionType *FT = FD->getType()->getAs<FunctionType>();
1361     assert(FT && "FunctionDecl has non-function type?");
1362
1363     if (isa<FunctionNoProtoType>(FT)) {
1364       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
1365       return;
1366     }
1367
1368     if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1369       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1370       return;
1371     }
1372   } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
1373     if (!MD->isVariadic()) {
1374       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1375       return;
1376     }
1377   } else if (isa<BlockDecl>(D)) {
1378     // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the
1379     // caller.
1380     ;
1381   } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
1382     QualType Ty = V->getType();
1383     if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
1384       const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D)
1385        : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
1386       if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1387         int m = Ty->isFunctionPointerType() ? 0 : 1;
1388         S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
1389         return;
1390       }
1391     } else {
1392       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1393         << Attr.getName() << ExpectedFunctionMethodOrBlock;
1394       return;
1395     }
1396   } else {
1397     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1398       << Attr.getName() << ExpectedFunctionMethodOrBlock;
1399     return;
1400   }
1401   D->addAttr(::new (S.Context) SentinelAttr(Attr.getLoc(), S.Context, sentinel,
1402                                             nullPos));
1403 }
1404
1405 static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
1406   // check the attribute arguments.
1407   if (!checkAttributeNumArgs(S, Attr, 0))
1408     return;
1409
1410   if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
1411     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1412       << Attr.getName() << ExpectedFunctionOrMethod;
1413     return;
1414   }
1415
1416   if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
1417     S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1418       << Attr.getName() << 0;
1419     return;
1420   }
1421   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
1422     if (MD->getResultType()->isVoidType()) {
1423       S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1424       << Attr.getName() << 1;
1425       return;
1426     }
1427
1428   D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getLoc(), S.Context));
1429 }
1430
1431 static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1432   // check the attribute arguments.
1433   if (Attr.hasParameterOrArguments()) {
1434     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1435     return;
1436   }
1437
1438   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
1439     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1440       << Attr.getName() << ExpectedVariableOrFunction;
1441     return;
1442   }
1443
1444   NamedDecl *nd = cast<NamedDecl>(D);
1445
1446   // 'weak' only applies to declarations with external linkage.
1447   if (hasEffectivelyInternalLinkage(nd)) {
1448     S.Diag(Attr.getLoc(), diag::err_attribute_weak_static);
1449     return;
1450   }
1451
1452   nd->addAttr(::new (S.Context) WeakAttr(Attr.getLoc(), S.Context));
1453 }
1454
1455 static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1456   // check the attribute arguments.
1457   if (!checkAttributeNumArgs(S, Attr, 0))
1458     return;
1459
1460
1461   // weak_import only applies to variable & function declarations.
1462   bool isDef = false;
1463   if (!D->canBeWeakImported(isDef)) {
1464     if (isDef)
1465       S.Diag(Attr.getLoc(),
1466              diag::warn_attribute_weak_import_invalid_on_definition)
1467         << "weak_import" << 2 /*variable and function*/;
1468     else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
1469              (S.Context.Target.getTriple().isOSDarwin() &&
1470               isa<ObjCInterfaceDecl>(D))) {
1471       // Nothing to warn about here.
1472     } else
1473       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1474         << Attr.getName() << ExpectedVariableOrFunction;
1475
1476     return;
1477   }
1478
1479   D->addAttr(::new (S.Context) WeakImportAttr(Attr.getLoc(), S.Context));
1480 }
1481
1482 static void handleReqdWorkGroupSize(Sema &S, Decl *D,
1483                                     const AttributeList &Attr) {
1484   // Attribute has 3 arguments.
1485   if (!checkAttributeNumArgs(S, Attr, 3))
1486     return;
1487
1488   unsigned WGSize[3];
1489   for (unsigned i = 0; i < 3; ++i) {
1490     Expr *E = Attr.getArg(i);
1491     llvm::APSInt ArgNum(32);
1492     if (E->isTypeDependent() || E->isValueDependent() ||
1493         !E->isIntegerConstantExpr(ArgNum, S.Context)) {
1494       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1495         << "reqd_work_group_size" << E->getSourceRange();
1496       return;
1497     }
1498     WGSize[i] = (unsigned) ArgNum.getZExtValue();
1499   }
1500   D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getLoc(), S.Context,
1501                                                      WGSize[0], WGSize[1],
1502                                                      WGSize[2]));
1503 }
1504
1505 static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1506   // Attribute has no arguments.
1507   if (!checkAttributeNumArgs(S, Attr, 1))
1508     return;
1509
1510   // Make sure that there is a string literal as the sections's single
1511   // argument.
1512   Expr *ArgExpr = Attr.getArg(0);
1513   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
1514   if (!SE) {
1515     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
1516     return;
1517   }
1518
1519   // If the target wants to validate the section specifier, make it happen.
1520   std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString());
1521   if (!Error.empty()) {
1522     S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
1523     << Error;
1524     return;
1525   }
1526
1527   // This attribute cannot be applied to local variables.
1528   if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
1529     S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
1530     return;
1531   }
1532
1533   D->addAttr(::new (S.Context) SectionAttr(Attr.getLoc(), S.Context,
1534                                            SE->getString()));
1535 }
1536
1537
1538 static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1539   // check the attribute arguments.
1540   if (Attr.hasParameterOrArguments()) {
1541     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1542     return;
1543   }
1544
1545   if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) {
1546     if (Existing->getLocation().isInvalid())
1547       Existing->setLocation(Attr.getLoc());
1548   } else {
1549     D->addAttr(::new (S.Context) NoThrowAttr(Attr.getLoc(), S.Context));
1550   }
1551 }
1552
1553 static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1554   // check the attribute arguments.
1555   if (Attr.hasParameterOrArguments()) {
1556     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1557     return;
1558   }
1559
1560   if (ConstAttr *Existing = D->getAttr<ConstAttr>()) {
1561    if (Existing->getLocation().isInvalid())
1562      Existing->setLocation(Attr.getLoc());
1563   } else {
1564     D->addAttr(::new (S.Context) ConstAttr(Attr.getLoc(), S.Context));
1565   }
1566 }
1567
1568 static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1569   // check the attribute arguments.
1570   if (!checkAttributeNumArgs(S, Attr, 0))
1571     return;
1572
1573   D->addAttr(::new (S.Context) PureAttr(Attr.getLoc(), S.Context));
1574 }
1575
1576 static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1577   if (!Attr.getParameterName()) {
1578     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1579     return;
1580   }
1581
1582   if (Attr.getNumArgs() != 0) {
1583     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1584     return;
1585   }
1586
1587   VarDecl *VD = dyn_cast<VarDecl>(D);
1588
1589   if (!VD || !VD->hasLocalStorage()) {
1590     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
1591     return;
1592   }
1593
1594   // Look up the function
1595   // FIXME: Lookup probably isn't looking in the right place
1596   NamedDecl *CleanupDecl
1597     = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
1598                          Attr.getParameterLoc(), Sema::LookupOrdinaryName);
1599   if (!CleanupDecl) {
1600     S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
1601       Attr.getParameterName();
1602     return;
1603   }
1604
1605   FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
1606   if (!FD) {
1607     S.Diag(Attr.getParameterLoc(),
1608            diag::err_attribute_cleanup_arg_not_function)
1609       << Attr.getParameterName();
1610     return;
1611   }
1612
1613   if (FD->getNumParams() != 1) {
1614     S.Diag(Attr.getParameterLoc(),
1615            diag::err_attribute_cleanup_func_must_take_one_arg)
1616       << Attr.getParameterName();
1617     return;
1618   }
1619
1620   // We're currently more strict than GCC about what function types we accept.
1621   // If this ever proves to be a problem it should be easy to fix.
1622   QualType Ty = S.Context.getPointerType(VD->getType());
1623   QualType ParamTy = FD->getParamDecl(0)->getType();
1624   if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
1625                                    ParamTy, Ty) != Sema::Compatible) {
1626     S.Diag(Attr.getParameterLoc(),
1627            diag::err_attribute_cleanup_func_arg_incompatible_type) <<
1628       Attr.getParameterName() << ParamTy << Ty;
1629     return;
1630   }
1631
1632   D->addAttr(::new (S.Context) CleanupAttr(Attr.getLoc(), S.Context, FD));
1633   S.MarkDeclarationReferenced(Attr.getParameterLoc(), FD);
1634 }
1635
1636 /// Handle __attribute__((format_arg((idx)))) attribute based on
1637 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1638 static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1639   if (!checkAttributeNumArgs(S, Attr, 1))
1640     return;
1641
1642   if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
1643     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1644       << Attr.getName() << ExpectedFunction;
1645     return;
1646   }
1647
1648   // In C++ the implicit 'this' function parameter also counts, and they are
1649   // counted from one.
1650   bool HasImplicitThisParam = isInstanceMethod(D);
1651   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1652   unsigned FirstIdx = 1;
1653
1654   // checks for the 2nd argument
1655   Expr *IdxExpr = Attr.getArg(0);
1656   llvm::APSInt Idx(32);
1657   if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1658       !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1659     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1660     << "format" << 2 << IdxExpr->getSourceRange();
1661     return;
1662   }
1663
1664   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1665     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1666     << "format" << 2 << IdxExpr->getSourceRange();
1667     return;
1668   }
1669
1670   unsigned ArgIdx = Idx.getZExtValue() - 1;
1671
1672   if (HasImplicitThisParam) {
1673     if (ArgIdx == 0) {
1674       S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
1675         << "format_arg" << IdxExpr->getSourceRange();
1676       return;
1677     }
1678     ArgIdx--;
1679   }
1680
1681   // make sure the format string is really a string
1682   QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
1683
1684   bool not_nsstring_type = !isNSStringType(Ty, S.Context);
1685   if (not_nsstring_type &&
1686       !isCFStringType(Ty, S.Context) &&
1687       (!Ty->isPointerType() ||
1688        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1689     // FIXME: Should highlight the actual expression that has the wrong type.
1690     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1691     << (not_nsstring_type ? "a string type" : "an NSString")
1692        << IdxExpr->getSourceRange();
1693     return;
1694   }
1695   Ty = getFunctionOrMethodResultType(D);
1696   if (!isNSStringType(Ty, S.Context) &&
1697       !isCFStringType(Ty, S.Context) &&
1698       (!Ty->isPointerType() ||
1699        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1700     // FIXME: Should highlight the actual expression that has the wrong type.
1701     S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
1702     << (not_nsstring_type ? "string type" : "NSString")
1703        << IdxExpr->getSourceRange();
1704     return;
1705   }
1706
1707   D->addAttr(::new (S.Context) FormatArgAttr(Attr.getLoc(), S.Context,
1708                                              Idx.getZExtValue()));
1709 }
1710
1711 enum FormatAttrKind {
1712   CFStringFormat,
1713   NSStringFormat,
1714   StrftimeFormat,
1715   SupportedFormat,
1716   IgnoredFormat,
1717   InvalidFormat
1718 };
1719
1720 /// getFormatAttrKind - Map from format attribute names to supported format
1721 /// types.
1722 static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) {
1723   // Check for formats that get handled specially.
1724   if (Format == "NSString")
1725     return NSStringFormat;
1726   if (Format == "CFString")
1727     return CFStringFormat;
1728   if (Format == "strftime")
1729     return StrftimeFormat;
1730
1731   // Otherwise, check for supported formats.
1732   if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
1733       Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
1734       Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
1735       Format == "zcmn_err" ||
1736       Format == "kprintf")  // OpenBSD.
1737     return SupportedFormat;
1738
1739   if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
1740       Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
1741     return IgnoredFormat;
1742
1743   return InvalidFormat;
1744 }
1745
1746 /// Handle __attribute__((init_priority(priority))) attributes based on
1747 /// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
1748 static void handleInitPriorityAttr(Sema &S, Decl *D,
1749                                    const AttributeList &Attr) {
1750   if (!S.getLangOptions().CPlusPlus) {
1751     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1752     return;
1753   }
1754
1755   if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) {
1756     S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1757     Attr.setInvalid();
1758     return;
1759   }
1760   QualType T = dyn_cast<VarDecl>(D)->getType();
1761   if (S.Context.getAsArrayType(T))
1762     T = S.Context.getBaseElementType(T);
1763   if (!T->getAs<RecordType>()) {
1764     S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1765     Attr.setInvalid();
1766     return;
1767   }
1768
1769   if (Attr.getNumArgs() != 1) {
1770     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1771     Attr.setInvalid();
1772     return;
1773   }
1774   Expr *priorityExpr = Attr.getArg(0);
1775
1776   llvm::APSInt priority(32);
1777   if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
1778       !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
1779     S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1780     << "init_priority" << priorityExpr->getSourceRange();
1781     Attr.setInvalid();
1782     return;
1783   }
1784   unsigned prioritynum = priority.getZExtValue();
1785   if (prioritynum < 101 || prioritynum > 65535) {
1786     S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
1787     <<  priorityExpr->getSourceRange();
1788     Attr.setInvalid();
1789     return;
1790   }
1791   D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getLoc(), S.Context,
1792                                                 prioritynum));
1793 }
1794
1795 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
1796 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1797 static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1798
1799   if (!Attr.getParameterName()) {
1800     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1801       << "format" << 1;
1802     return;
1803   }
1804
1805   if (Attr.getNumArgs() != 2) {
1806     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
1807     return;
1808   }
1809
1810   if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) {
1811     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1812       << Attr.getName() << ExpectedFunction;
1813     return;
1814   }
1815
1816   // In C++ the implicit 'this' function parameter also counts, and they are
1817   // counted from one.
1818   bool HasImplicitThisParam = isInstanceMethod(D);
1819   unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1820   unsigned FirstIdx = 1;
1821
1822   llvm::StringRef Format = Attr.getParameterName()->getName();
1823
1824   // Normalize the argument, __foo__ becomes foo.
1825   if (Format.startswith("__") && Format.endswith("__"))
1826     Format = Format.substr(2, Format.size() - 4);
1827
1828   // Check for supported formats.
1829   FormatAttrKind Kind = getFormatAttrKind(Format);
1830
1831   if (Kind == IgnoredFormat)
1832     return;
1833
1834   if (Kind == InvalidFormat) {
1835     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1836       << "format" << Attr.getParameterName()->getName();
1837     return;
1838   }
1839
1840   // checks for the 2nd argument
1841   Expr *IdxExpr = Attr.getArg(0);
1842   llvm::APSInt Idx(32);
1843   if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1844       !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1845     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1846       << "format" << 2 << IdxExpr->getSourceRange();
1847     return;
1848   }
1849
1850   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1851     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1852       << "format" << 2 << IdxExpr->getSourceRange();
1853     return;
1854   }
1855
1856   // FIXME: Do we need to bounds check?
1857   unsigned ArgIdx = Idx.getZExtValue() - 1;
1858
1859   if (HasImplicitThisParam) {
1860     if (ArgIdx == 0) {
1861       S.Diag(Attr.getLoc(),
1862              diag::err_format_attribute_implicit_this_format_string)
1863         << IdxExpr->getSourceRange();
1864       return;
1865     }
1866     ArgIdx--;
1867   }
1868
1869   // make sure the format string is really a string
1870   QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
1871
1872   if (Kind == CFStringFormat) {
1873     if (!isCFStringType(Ty, S.Context)) {
1874       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1875         << "a CFString" << IdxExpr->getSourceRange();
1876       return;
1877     }
1878   } else if (Kind == NSStringFormat) {
1879     // FIXME: do we need to check if the type is NSString*?  What are the
1880     // semantics?
1881     if (!isNSStringType(Ty, S.Context)) {
1882       // FIXME: Should highlight the actual expression that has the wrong type.
1883       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1884         << "an NSString" << IdxExpr->getSourceRange();
1885       return;
1886     }
1887   } else if (!Ty->isPointerType() ||
1888              !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
1889     // FIXME: Should highlight the actual expression that has the wrong type.
1890     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1891       << "a string type" << IdxExpr->getSourceRange();
1892     return;
1893   }
1894
1895   // check the 3rd argument
1896   Expr *FirstArgExpr = Attr.getArg(1);
1897   llvm::APSInt FirstArg(32);
1898   if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
1899       !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
1900     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1901       << "format" << 3 << FirstArgExpr->getSourceRange();
1902     return;
1903   }
1904
1905   // check if the function is variadic if the 3rd argument non-zero
1906   if (FirstArg != 0) {
1907     if (isFunctionOrMethodVariadic(D)) {
1908       ++NumArgs; // +1 for ...
1909     } else {
1910       S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
1911       return;
1912     }
1913   }
1914
1915   // strftime requires FirstArg to be 0 because it doesn't read from any
1916   // variable the input is just the current time + the format string.
1917   if (Kind == StrftimeFormat) {
1918     if (FirstArg != 0) {
1919       S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
1920         << FirstArgExpr->getSourceRange();
1921       return;
1922     }
1923   // if 0 it disables parameter checking (to use with e.g. va_list)
1924   } else if (FirstArg != 0 && FirstArg != NumArgs) {
1925     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1926       << "format" << 3 << FirstArgExpr->getSourceRange();
1927     return;
1928   }
1929
1930   // Check whether we already have an equivalent format attribute.
1931   for (specific_attr_iterator<FormatAttr>
1932          i = D->specific_attr_begin<FormatAttr>(),
1933          e = D->specific_attr_end<FormatAttr>();
1934        i != e ; ++i) {
1935     FormatAttr *f = *i;
1936     if (f->getType() == Format &&
1937         f->getFormatIdx() == (int)Idx.getZExtValue() &&
1938         f->getFirstArg() == (int)FirstArg.getZExtValue()) {
1939       // If we don't have a valid location for this attribute, adopt the
1940       // location.
1941       if (f->getLocation().isInvalid())
1942         f->setLocation(Attr.getLoc());
1943       return;
1944     }
1945   }
1946
1947   D->addAttr(::new (S.Context) FormatAttr(Attr.getLoc(), S.Context, Format,
1948                                           Idx.getZExtValue(),
1949                                           FirstArg.getZExtValue()));
1950 }
1951
1952 static void handleTransparentUnionAttr(Sema &S, Decl *D,
1953                                        const AttributeList &Attr) {
1954   // check the attribute arguments.
1955   if (!checkAttributeNumArgs(S, Attr, 0))
1956     return;
1957
1958
1959   // Try to find the underlying union declaration.
1960   RecordDecl *RD = 0;
1961   TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
1962   if (TD && TD->getUnderlyingType()->isUnionType())
1963     RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
1964   else
1965     RD = dyn_cast<RecordDecl>(D);
1966
1967   if (!RD || !RD->isUnion()) {
1968     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1969       << Attr.getName() << ExpectedUnion;
1970     return;
1971   }
1972
1973   if (!RD->isDefinition()) {
1974     S.Diag(Attr.getLoc(),
1975         diag::warn_transparent_union_attribute_not_definition);
1976     return;
1977   }
1978
1979   RecordDecl::field_iterator Field = RD->field_begin(),
1980                           FieldEnd = RD->field_end();
1981   if (Field == FieldEnd) {
1982     S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
1983     return;
1984   }
1985
1986   FieldDecl *FirstField = *Field;
1987   QualType FirstType = FirstField->getType();
1988   if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
1989     S.Diag(FirstField->getLocation(),
1990            diag::warn_transparent_union_attribute_floating)
1991       << FirstType->isVectorType() << FirstType;
1992     return;
1993   }
1994
1995   uint64_t FirstSize = S.Context.getTypeSize(FirstType);
1996   uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
1997   for (; Field != FieldEnd; ++Field) {
1998     QualType FieldType = Field->getType();
1999     if (S.Context.getTypeSize(FieldType) != FirstSize ||
2000         S.Context.getTypeAlign(FieldType) != FirstAlign) {
2001       // Warn if we drop the attribute.
2002       bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
2003       unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
2004                                  : S.Context.getTypeAlign(FieldType);
2005       S.Diag(Field->getLocation(),
2006           diag::warn_transparent_union_attribute_field_size_align)
2007         << isSize << Field->getDeclName() << FieldBits;
2008       unsigned FirstBits = isSize? FirstSize : FirstAlign;
2009       S.Diag(FirstField->getLocation(),
2010              diag::note_transparent_union_first_field_size_align)
2011         << isSize << FirstBits;
2012       return;
2013     }
2014   }
2015
2016   RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getLoc(), S.Context));
2017 }
2018
2019 static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2020   // check the attribute arguments.
2021   if (!checkAttributeNumArgs(S, Attr, 1))
2022     return;
2023
2024   Expr *ArgExpr = Attr.getArg(0);
2025   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
2026
2027   // Make sure that there is a string literal as the annotation's single
2028   // argument.
2029   if (!SE) {
2030     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
2031     return;
2032   }
2033   D->addAttr(::new (S.Context) AnnotateAttr(Attr.getLoc(), S.Context,
2034                                             SE->getString()));
2035 }
2036
2037 static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2038   // check the attribute arguments.
2039   if (Attr.getNumArgs() > 1) {
2040     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2041     return;
2042   }
2043
2044   //FIXME: The C++0x version of this attribute has more limited applicabilty
2045   //       than GNU's, and should error out when it is used to specify a
2046   //       weaker alignment, rather than being silently ignored.
2047
2048   if (Attr.getNumArgs() == 0) {
2049     D->addAttr(::new (S.Context) AlignedAttr(Attr.getLoc(), S.Context, true, 0));
2050     return;
2051   }
2052
2053   S.AddAlignedAttr(Attr.getLoc(), D, Attr.getArg(0));
2054 }
2055
2056 void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, Expr *E) {
2057   if (E->isTypeDependent() || E->isValueDependent()) {
2058     // Save dependent expressions in the AST to be instantiated.
2059     D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
2060     return;
2061   }
2062
2063   // FIXME: Cache the number on the Attr object?
2064   llvm::APSInt Alignment(32);
2065   if (!E->isIntegerConstantExpr(Alignment, Context)) {
2066     Diag(AttrLoc, diag::err_attribute_argument_not_int)
2067       << "aligned" << E->getSourceRange();
2068     return;
2069   }
2070   if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
2071     Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
2072       << E->getSourceRange();
2073     return;
2074   }
2075
2076   D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
2077 }
2078
2079 void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, TypeSourceInfo *TS) {
2080   // FIXME: Cache the number on the Attr object if non-dependent?
2081   // FIXME: Perform checking of type validity
2082   D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, false, TS));
2083   return;
2084 }
2085
2086 /// handleModeAttr - This attribute modifies the width of a decl with primitive
2087 /// type.
2088 ///
2089 /// Despite what would be logical, the mode attribute is a decl attribute, not a
2090 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
2091 /// HImode, not an intermediate pointer.
2092 static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2093   // This attribute isn't documented, but glibc uses it.  It changes
2094   // the width of an int or unsigned int to the specified size.
2095
2096   // Check that there aren't any arguments
2097   if (!checkAttributeNumArgs(S, Attr, 0))
2098     return;
2099
2100
2101   IdentifierInfo *Name = Attr.getParameterName();
2102   if (!Name) {
2103     S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
2104     return;
2105   }
2106
2107   llvm::StringRef Str = Attr.getParameterName()->getName();
2108
2109   // Normalize the attribute name, __foo__ becomes foo.
2110   if (Str.startswith("__") && Str.endswith("__"))
2111     Str = Str.substr(2, Str.size() - 4);
2112
2113   unsigned DestWidth = 0;
2114   bool IntegerMode = true;
2115   bool ComplexMode = false;
2116   switch (Str.size()) {
2117   case 2:
2118     switch (Str[0]) {
2119     case 'Q': DestWidth = 8; break;
2120     case 'H': DestWidth = 16; break;
2121     case 'S': DestWidth = 32; break;
2122     case 'D': DestWidth = 64; break;
2123     case 'X': DestWidth = 96; break;
2124     case 'T': DestWidth = 128; break;
2125     }
2126     if (Str[1] == 'F') {
2127       IntegerMode = false;
2128     } else if (Str[1] == 'C') {
2129       IntegerMode = false;
2130       ComplexMode = true;
2131     } else if (Str[1] != 'I') {
2132       DestWidth = 0;
2133     }
2134     break;
2135   case 4:
2136     // FIXME: glibc uses 'word' to define register_t; this is narrower than a
2137     // pointer on PIC16 and other embedded platforms.
2138     if (Str == "word")
2139       DestWidth = S.Context.Target.getPointerWidth(0);
2140     else if (Str == "byte")
2141       DestWidth = S.Context.Target.getCharWidth();
2142     break;
2143   case 7:
2144     if (Str == "pointer")
2145       DestWidth = S.Context.Target.getPointerWidth(0);
2146     break;
2147   }
2148
2149   QualType OldTy;
2150   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
2151     OldTy = TD->getUnderlyingType();
2152   else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
2153     OldTy = VD->getType();
2154   else {
2155     S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
2156       << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc());
2157     return;
2158   }
2159
2160   if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
2161     S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
2162   else if (IntegerMode) {
2163     if (!OldTy->isIntegralOrEnumerationType())
2164       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2165   } else if (ComplexMode) {
2166     if (!OldTy->isComplexType())
2167       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2168   } else {
2169     if (!OldTy->isFloatingType())
2170       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2171   }
2172
2173   // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
2174   // and friends, at least with glibc.
2175   // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
2176   // width on unusual platforms.
2177   // FIXME: Make sure floating-point mappings are accurate
2178   // FIXME: Support XF and TF types
2179   QualType NewTy;
2180   switch (DestWidth) {
2181   case 0:
2182     S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
2183     return;
2184   default:
2185     S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2186     return;
2187   case 8:
2188     if (!IntegerMode) {
2189       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2190       return;
2191     }
2192     if (OldTy->isSignedIntegerType())
2193       NewTy = S.Context.SignedCharTy;
2194     else
2195       NewTy = S.Context.UnsignedCharTy;
2196     break;
2197   case 16:
2198     if (!IntegerMode) {
2199       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2200       return;
2201     }
2202     if (OldTy->isSignedIntegerType())
2203       NewTy = S.Context.ShortTy;
2204     else
2205       NewTy = S.Context.UnsignedShortTy;
2206     break;
2207   case 32:
2208     if (!IntegerMode)
2209       NewTy = S.Context.FloatTy;
2210     else if (OldTy->isSignedIntegerType())
2211       NewTy = S.Context.IntTy;
2212     else
2213       NewTy = S.Context.UnsignedIntTy;
2214     break;
2215   case 64:
2216     if (!IntegerMode)
2217       NewTy = S.Context.DoubleTy;
2218     else if (OldTy->isSignedIntegerType())
2219       if (S.Context.Target.getLongWidth() == 64)
2220         NewTy = S.Context.LongTy;
2221       else
2222         NewTy = S.Context.LongLongTy;
2223     else
2224       if (S.Context.Target.getLongWidth() == 64)
2225         NewTy = S.Context.UnsignedLongTy;
2226       else
2227         NewTy = S.Context.UnsignedLongLongTy;
2228     break;
2229   case 96:
2230     NewTy = S.Context.LongDoubleTy;
2231     break;
2232   case 128:
2233     if (!IntegerMode) {
2234       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2235       return;
2236     }
2237     if (OldTy->isSignedIntegerType())
2238       NewTy = S.Context.Int128Ty;
2239     else
2240       NewTy = S.Context.UnsignedInt128Ty;
2241     break;
2242   }
2243
2244   if (ComplexMode) {
2245     NewTy = S.Context.getComplexType(NewTy);
2246   }
2247
2248   // Install the new type.
2249   if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2250     // FIXME: preserve existing source info.
2251     TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
2252   } else
2253     cast<ValueDecl>(D)->setType(NewTy);
2254 }
2255
2256 static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2257   // check the attribute arguments.
2258   if (!checkAttributeNumArgs(S, Attr, 0))
2259     return;
2260
2261   if (!isFunctionOrMethod(D)) {
2262     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2263       << Attr.getName() << ExpectedFunction;
2264     return;
2265   }
2266
2267   D->addAttr(::new (S.Context) NoDebugAttr(Attr.getLoc(), S.Context));
2268 }
2269
2270 static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2271   // check the attribute arguments.
2272   if (!checkAttributeNumArgs(S, Attr, 0))
2273     return;
2274
2275
2276   if (!isa<FunctionDecl>(D)) {
2277     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2278       << Attr.getName() << ExpectedFunction;
2279     return;
2280   }
2281
2282   D->addAttr(::new (S.Context) NoInlineAttr(Attr.getLoc(), S.Context));
2283 }
2284
2285 static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
2286                                            const AttributeList &Attr) {
2287   // check the attribute arguments.
2288   if (!checkAttributeNumArgs(S, Attr, 0))
2289     return;
2290
2291
2292   if (!isa<FunctionDecl>(D)) {
2293     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2294       << Attr.getName() << ExpectedFunction;
2295     return;
2296   }
2297
2298   D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getLoc(),
2299                                                         S.Context));
2300 }
2301
2302 static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2303   if (S.LangOpts.CUDA) {
2304     // check the attribute arguments.
2305     if (Attr.hasParameterOrArguments()) {
2306       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2307       return;
2308     }
2309
2310     if (!isa<VarDecl>(D)) {
2311       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2312         << Attr.getName() << ExpectedVariable;
2313       return;
2314     }
2315
2316     D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getLoc(), S.Context));
2317   } else {
2318     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
2319   }
2320 }
2321
2322 static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2323   if (S.LangOpts.CUDA) {
2324     // check the attribute arguments.
2325     if (Attr.getNumArgs() != 0) {
2326       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2327       return;
2328     }
2329
2330     if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
2331       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2332         << Attr.getName() << ExpectedVariableOrFunction;
2333       return;
2334     }
2335
2336     D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getLoc(), S.Context));
2337   } else {
2338     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
2339   }
2340 }
2341
2342 static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2343   if (S.LangOpts.CUDA) {
2344     // check the attribute arguments.
2345     if (!checkAttributeNumArgs(S, Attr, 0))
2346       return;
2347
2348     if (!isa<FunctionDecl>(D)) {
2349       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2350         << Attr.getName() << ExpectedFunction;
2351       return;
2352     }
2353
2354     FunctionDecl *FD = cast<FunctionDecl>(D);
2355     if (!FD->getResultType()->isVoidType()) {
2356       TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
2357       if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
2358         S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2359           << FD->getType()
2360           << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
2361                                           "void");
2362       } else {
2363         S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2364           << FD->getType();
2365       }
2366       return;
2367     }
2368
2369     D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getLoc(), S.Context));
2370   } else {
2371     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
2372   }
2373 }
2374
2375 static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2376   if (S.LangOpts.CUDA) {
2377     // check the attribute arguments.
2378     if (!checkAttributeNumArgs(S, Attr, 0))
2379       return;
2380
2381
2382     if (!isa<FunctionDecl>(D)) {
2383       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2384         << Attr.getName() << ExpectedFunction;
2385       return;
2386     }
2387
2388     D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getLoc(), S.Context));
2389   } else {
2390     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
2391   }
2392 }
2393
2394 static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2395   if (S.LangOpts.CUDA) {
2396     // check the attribute arguments.
2397     if (!checkAttributeNumArgs(S, Attr, 0))
2398       return;
2399
2400
2401     if (!isa<VarDecl>(D)) {
2402       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2403         << Attr.getName() << ExpectedVariable;
2404       return;
2405     }
2406
2407     D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getLoc(), S.Context));
2408   } else {
2409     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
2410   }
2411 }
2412
2413 static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2414   // check the attribute arguments.
2415   if (!checkAttributeNumArgs(S, Attr, 0))
2416     return;
2417
2418   FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
2419   if (Fn == 0) {
2420     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2421       << Attr.getName() << ExpectedFunction;
2422     return;
2423   }
2424
2425   if (!Fn->isInlineSpecified()) {
2426     S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
2427     return;
2428   }
2429
2430   D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getLoc(), S.Context));
2431 }
2432
2433 static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2434   if (hasDeclarator(D)) return;
2435
2436   // Diagnostic is emitted elsewhere: here we store the (valid) Attr
2437   // in the Decl node for syntactic reasoning, e.g., pretty-printing.
2438   CallingConv CC;
2439   if (S.CheckCallingConvAttr(Attr, CC))
2440     return;
2441
2442   if (!isa<ObjCMethodDecl>(D)) {
2443     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2444       << Attr.getName() << ExpectedFunctionOrMethod;
2445     return;
2446   }
2447
2448   switch (Attr.getKind()) {
2449   case AttributeList::AT_fastcall:
2450     D->addAttr(::new (S.Context) FastCallAttr(Attr.getLoc(), S.Context));
2451     return;
2452   case AttributeList::AT_stdcall:
2453     D->addAttr(::new (S.Context) StdCallAttr(Attr.getLoc(), S.Context));
2454     return;
2455   case AttributeList::AT_thiscall:
2456     D->addAttr(::new (S.Context) ThisCallAttr(Attr.getLoc(), S.Context));
2457     return;
2458   case AttributeList::AT_cdecl:
2459     D->addAttr(::new (S.Context) CDeclAttr(Attr.getLoc(), S.Context));
2460     return;
2461   case AttributeList::AT_pascal:
2462     D->addAttr(::new (S.Context) PascalAttr(Attr.getLoc(), S.Context));
2463     return;
2464   case AttributeList::AT_pcs: {
2465     Expr *Arg = Attr.getArg(0);
2466     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2467     if (Str == 0 || Str->isWide()) {
2468       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2469         << "pcs" << 1;
2470       Attr.setInvalid();
2471       return;
2472     }
2473
2474     llvm::StringRef StrRef = Str->getString();
2475     PcsAttr::PCSType PCS;
2476     if (StrRef == "aapcs")
2477       PCS = PcsAttr::AAPCS;
2478     else if (StrRef == "aapcs-vfp")
2479       PCS = PcsAttr::AAPCS_VFP;
2480     else {
2481       S.Diag(Attr.getLoc(), diag::err_invalid_pcs);
2482       Attr.setInvalid();
2483       return;
2484     }
2485
2486     D->addAttr(::new (S.Context) PcsAttr(Attr.getLoc(), S.Context, PCS));
2487   }
2488   default:
2489     llvm_unreachable("unexpected attribute kind");
2490     return;
2491   }
2492 }
2493
2494 static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
2495   assert(!Attr.isInvalid());
2496   D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getLoc(), S.Context));
2497 }
2498
2499 bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
2500   if (attr.isInvalid())
2501     return true;
2502
2503   if ((attr.getNumArgs() != 0 &&
2504       !(attr.getKind() == AttributeList::AT_pcs && attr.getNumArgs() == 1)) ||
2505       attr.getParameterName()) {
2506     Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2507     attr.setInvalid();
2508     return true;
2509   }
2510
2511   // TODO: diagnose uses of these conventions on the wrong target. Or, better
2512   // move to TargetAttributesSema one day.
2513   switch (attr.getKind()) {
2514   case AttributeList::AT_cdecl: CC = CC_C; break;
2515   case AttributeList::AT_fastcall: CC = CC_X86FastCall; break;
2516   case AttributeList::AT_stdcall: CC = CC_X86StdCall; break;
2517   case AttributeList::AT_thiscall: CC = CC_X86ThisCall; break;
2518   case AttributeList::AT_pascal: CC = CC_X86Pascal; break;
2519   case AttributeList::AT_pcs: {
2520     Expr *Arg = attr.getArg(0);
2521     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2522     if (Str == 0 || Str->isWide()) {
2523       Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
2524         << "pcs" << 1;
2525       attr.setInvalid();
2526       return true;
2527     }
2528
2529     llvm::StringRef StrRef = Str->getString();
2530     if (StrRef == "aapcs") {
2531       CC = CC_AAPCS;
2532       break;
2533     } else if (StrRef == "aapcs-vfp") {
2534       CC = CC_AAPCS_VFP;
2535       break;
2536     }
2537     // FALLS THROUGH
2538   }
2539   default: llvm_unreachable("unexpected attribute kind"); return true;
2540   }
2541
2542   return false;
2543 }
2544
2545 static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2546   if (hasDeclarator(D)) return;
2547
2548   unsigned numParams;
2549   if (S.CheckRegparmAttr(Attr, numParams))
2550     return;
2551
2552   if (!isa<ObjCMethodDecl>(D)) {
2553     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2554       << Attr.getName() << ExpectedFunctionOrMethod;
2555     return;
2556   }
2557
2558   D->addAttr(::new (S.Context) RegparmAttr(Attr.getLoc(), S.Context, numParams));
2559 }
2560
2561 /// Checks a regparm attribute, returning true if it is ill-formed and
2562 /// otherwise setting numParams to the appropriate value.
2563 bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
2564   if (Attr.isInvalid())
2565     return true;
2566
2567   if (Attr.getNumArgs() != 1) {
2568     Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2569     Attr.setInvalid();
2570     return true;
2571   }
2572
2573   Expr *NumParamsExpr = Attr.getArg(0);
2574   llvm::APSInt NumParams(32);
2575   if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
2576       !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
2577     Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2578       << "regparm" << NumParamsExpr->getSourceRange();
2579     Attr.setInvalid();
2580     return true;
2581   }
2582
2583   if (Context.Target.getRegParmMax() == 0) {
2584     Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
2585       << NumParamsExpr->getSourceRange();
2586     Attr.setInvalid();
2587     return true;
2588   }
2589
2590   numParams = NumParams.getZExtValue();
2591   if (numParams > Context.Target.getRegParmMax()) {
2592     Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
2593       << Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange();
2594     Attr.setInvalid();
2595     return true;
2596   }
2597
2598   return false;
2599 }
2600
2601 static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
2602   if (S.LangOpts.CUDA) {
2603     // check the attribute arguments.
2604     if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
2605       // FIXME: 0 is not okay.
2606       S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
2607       return;
2608     }
2609
2610     if (!isFunctionOrMethod(D)) {
2611       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2612         << Attr.getName() << ExpectedFunctionOrMethod;
2613       return;
2614     }
2615
2616     Expr *MaxThreadsExpr = Attr.getArg(0);
2617     llvm::APSInt MaxThreads(32);
2618     if (MaxThreadsExpr->isTypeDependent() ||
2619         MaxThreadsExpr->isValueDependent() ||
2620         !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
2621       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2622         << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
2623       return;
2624     }
2625
2626     llvm::APSInt MinBlocks(32);
2627     if (Attr.getNumArgs() > 1) {
2628       Expr *MinBlocksExpr = Attr.getArg(1);
2629       if (MinBlocksExpr->isTypeDependent() ||
2630           MinBlocksExpr->isValueDependent() ||
2631           !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
2632         S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2633           << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
2634         return;
2635       }
2636     }
2637
2638     D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getLoc(), S.Context,
2639                                                       MaxThreads.getZExtValue(),
2640                                                      MinBlocks.getZExtValue()));
2641   } else {
2642     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
2643   }
2644 }
2645
2646 //===----------------------------------------------------------------------===//
2647 // Checker-specific attribute handlers.
2648 //===----------------------------------------------------------------------===//
2649
2650 static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
2651   return type->isObjCObjectPointerType() || S.Context.isObjCNSObjectType(type);
2652 }
2653 static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
2654   return type->isPointerType() || isValidSubjectOfNSAttribute(S, type);
2655 }
2656
2657 static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2658   ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
2659   if (!param) {
2660     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2661       << SourceRange(Attr.getLoc()) << Attr.getName() << ExpectedParameter;
2662     return;
2663   }
2664
2665   bool typeOK, cf;
2666   if (Attr.getKind() == AttributeList::AT_ns_consumed) {
2667     typeOK = isValidSubjectOfNSAttribute(S, param->getType());
2668     cf = false;
2669   } else {
2670     typeOK = isValidSubjectOfCFAttribute(S, param->getType());
2671     cf = true;
2672   }
2673
2674   if (!typeOK) {
2675     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
2676       << SourceRange(Attr.getLoc()) << Attr.getName() << cf;
2677     return;
2678   }
2679
2680   if (cf)
2681     param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getLoc(), S.Context));
2682   else
2683     param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getLoc(), S.Context));
2684 }
2685
2686 static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
2687                                      const AttributeList &Attr) {
2688   if (!isa<ObjCMethodDecl>(D)) {
2689     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2690       << SourceRange(Attr.getLoc()) << Attr.getName() << ExpectedMethod;
2691     return;
2692   }
2693
2694   D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getLoc(), S.Context));
2695 }
2696
2697 static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
2698                                         const AttributeList &Attr) {
2699
2700   QualType returnType;
2701
2702   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2703     returnType = MD->getResultType();
2704   else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
2705     returnType = PD->getType();
2706   else if (S.getLangOptions().ObjCAutoRefCount && hasDeclarator(D) &&
2707            (Attr.getKind() == AttributeList::AT_ns_returns_retained))
2708     return; // ignore: was handled as a type attribute
2709   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2710     returnType = FD->getResultType();
2711   else {
2712     S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2713         << SourceRange(Attr.getLoc()) << Attr.getName()
2714         << ExpectedFunctionOrMethod;
2715     return;
2716   }
2717
2718   bool typeOK;
2719   bool cf;
2720   switch (Attr.getKind()) {
2721   default: llvm_unreachable("invalid ownership attribute"); return;
2722   case AttributeList::AT_ns_returns_autoreleased:
2723   case AttributeList::AT_ns_returns_retained:
2724   case AttributeList::AT_ns_returns_not_retained:
2725     typeOK = isValidSubjectOfNSAttribute(S, returnType);
2726     cf = false;
2727     break;
2728
2729   case AttributeList::AT_cf_returns_retained:
2730   case AttributeList::AT_cf_returns_not_retained:
2731     typeOK = isValidSubjectOfCFAttribute(S, returnType);
2732     cf = true;
2733     break;
2734   }
2735
2736   if (!typeOK) {
2737     S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
2738       << SourceRange(Attr.getLoc())
2739       << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
2740     return;
2741   }
2742
2743   switch (Attr.getKind()) {
2744     default:
2745       assert(0 && "invalid ownership attribute");
2746       return;
2747     case AttributeList::AT_ns_returns_autoreleased:
2748       D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getLoc(),
2749                                                              S.Context));
2750       return;
2751     case AttributeList::AT_cf_returns_not_retained:
2752       D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getLoc(),
2753                                                             S.Context));
2754       return;
2755     case AttributeList::AT_ns_returns_not_retained:
2756       D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getLoc(),
2757                                                             S.Context));
2758       return;
2759     case AttributeList::AT_cf_returns_retained:
2760       D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getLoc(),
2761                                                          S.Context));
2762       return;
2763     case AttributeList::AT_ns_returns_retained:
2764       D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getLoc(),
2765                                                          S.Context));
2766       return;
2767   };
2768 }
2769
2770 static void handleObjCOwnershipAttr(Sema &S, Decl *D,
2771                                     const AttributeList &Attr) {
2772   if (hasDeclarator(D)) return;
2773
2774   SourceLocation L = Attr.getLoc();
2775   S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
2776     << SourceRange(L, L) << Attr.getName() << 12 /* variable */;
2777 }
2778
2779 static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
2780                                           const AttributeList &Attr) {
2781   if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
2782     SourceLocation L = Attr.getLoc();
2783     S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
2784       << SourceRange(L, L) << Attr.getName() << 12 /* variable */;
2785     return;
2786   }
2787
2788   ValueDecl *vd = cast<ValueDecl>(D);
2789   QualType type = vd->getType();
2790
2791   if (!type->isDependentType() &&
2792       !type->isObjCLifetimeType()) {
2793     S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
2794       << type;
2795     return;
2796   }
2797
2798   Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
2799
2800   // If we have no lifetime yet, check the lifetime we're presumably
2801   // going to infer.
2802   if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
2803     lifetime = type->getObjCARCImplicitLifetime();
2804
2805   switch (lifetime) {
2806   case Qualifiers::OCL_None:
2807     assert(type->isDependentType() &&
2808            "didn't infer lifetime for non-dependent type?");
2809     break;
2810
2811   case Qualifiers::OCL_Weak:   // meaningful
2812   case Qualifiers::OCL_Strong: // meaningful
2813     break;
2814
2815   case Qualifiers::OCL_ExplicitNone:
2816   case Qualifiers::OCL_Autoreleasing:
2817     S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
2818       << (lifetime == Qualifiers::OCL_Autoreleasing);
2819     break;
2820   }
2821
2822   D->addAttr(::new (S.Context)
2823                  ObjCPreciseLifetimeAttr(Attr.getLoc(), S.Context));
2824 }
2825
2826 static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
2827   return Attr.getKind() == AttributeList::AT_dllimport ||
2828          Attr.getKind() == AttributeList::AT_dllexport ||
2829          Attr.getKind() == AttributeList::AT_uuid;
2830 }
2831
2832 //===----------------------------------------------------------------------===//
2833 // Microsoft specific attribute handlers.
2834 //===----------------------------------------------------------------------===//
2835
2836 static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2837   if (S.LangOpts.Microsoft || S.LangOpts.Borland) {
2838     // check the attribute arguments.
2839     if (!checkAttributeNumArgs(S, Attr, 1))
2840       return;
2841
2842     Expr *Arg = Attr.getArg(0);
2843     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2844     if (Str == 0 || Str->isWide()) {
2845       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2846         << "uuid" << 1;
2847       return;
2848     }
2849
2850     llvm::StringRef StrRef = Str->getString();
2851
2852     bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
2853                    StrRef.back() == '}';
2854
2855     // Validate GUID length.
2856     if (IsCurly && StrRef.size() != 38) {
2857       S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2858       return;
2859     }
2860     if (!IsCurly && StrRef.size() != 36) {
2861       S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2862       return;
2863     }
2864
2865     // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
2866     // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
2867     llvm::StringRef::iterator I = StrRef.begin();
2868     if (IsCurly) // Skip the optional '{'
2869        ++I;
2870
2871     for (int i = 0; i < 36; ++i) {
2872       if (i == 8 || i == 13 || i == 18 || i == 23) {
2873         if (*I != '-') {
2874           S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2875           return;
2876         }
2877       } else if (!isxdigit(*I)) {
2878         S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2879         return;
2880       }
2881       I++;
2882     }
2883
2884     D->addAttr(::new (S.Context) UuidAttr(Attr.getLoc(), S.Context,
2885                                           Str->getString()));
2886   } else
2887     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
2888 }
2889
2890 //===----------------------------------------------------------------------===//
2891 // Top Level Sema Entry Points
2892 //===----------------------------------------------------------------------===//
2893
2894 static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
2895                                           const AttributeList &Attr) {
2896   switch (Attr.getKind()) {
2897   case AttributeList::AT_device:      handleDeviceAttr      (S, D, Attr); break;
2898   case AttributeList::AT_host:        handleHostAttr        (S, D, Attr); break;
2899   case AttributeList::AT_overloadable:handleOverloadableAttr(S, D, Attr); break;
2900   default:
2901     break;
2902   }
2903 }
2904
2905 static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
2906                                        const AttributeList &Attr) {
2907   switch (Attr.getKind()) {
2908   case AttributeList::AT_IBAction:            handleIBAction(S, D, Attr); break;
2909     case AttributeList::AT_IBOutlet:          handleIBOutlet(S, D, Attr); break;
2910   case AttributeList::AT_IBOutletCollection:
2911       handleIBOutletCollection(S, D, Attr); break;
2912   case AttributeList::AT_address_space:
2913   case AttributeList::AT_opencl_image_access:
2914   case AttributeList::AT_objc_gc:
2915   case AttributeList::AT_vector_size:
2916   case AttributeList::AT_neon_vector_type:
2917   case AttributeList::AT_neon_polyvector_type:
2918     // Ignore these, these are type attributes, handled by
2919     // ProcessTypeAttributes.
2920     break;
2921   case AttributeList::AT_device:
2922   case AttributeList::AT_host:
2923   case AttributeList::AT_overloadable:
2924     // Ignore, this is a non-inheritable attribute, handled
2925     // by ProcessNonInheritableDeclAttr.
2926     break;
2927   case AttributeList::AT_alias:       handleAliasAttr       (S, D, Attr); break;
2928   case AttributeList::AT_aligned:     handleAlignedAttr     (S, D, Attr); break;
2929   case AttributeList::AT_always_inline:
2930     handleAlwaysInlineAttr  (S, D, Attr); break;
2931   case AttributeList::AT_analyzer_noreturn:
2932     handleAnalyzerNoReturnAttr  (S, D, Attr); break;
2933   case AttributeList::AT_annotate:    handleAnnotateAttr    (S, D, Attr); break;
2934   case AttributeList::AT_availability:handleAvailabilityAttr(S, D, Attr); break;
2935   case AttributeList::AT_carries_dependency:
2936                                       handleDependencyAttr  (S, D, Attr); break;
2937   case AttributeList::AT_common:      handleCommonAttr      (S, D, Attr); break;
2938   case AttributeList::AT_constant:    handleConstantAttr    (S, D, Attr); break;
2939   case AttributeList::AT_constructor: handleConstructorAttr (S, D, Attr); break;
2940   case AttributeList::AT_deprecated:  handleDeprecatedAttr  (S, D, Attr); break;
2941   case AttributeList::AT_destructor:  handleDestructorAttr  (S, D, Attr); break;
2942   case AttributeList::AT_ext_vector_type:
2943     handleExtVectorTypeAttr(S, scope, D, Attr);
2944     break;
2945   case AttributeList::AT_format:      handleFormatAttr      (S, D, Attr); break;
2946   case AttributeList::AT_format_arg:  handleFormatArgAttr   (S, D, Attr); break;
2947   case AttributeList::AT_global:      handleGlobalAttr      (S, D, Attr); break;
2948   case AttributeList::AT_gnu_inline:  handleGNUInlineAttr   (S, D, Attr); break;
2949   case AttributeList::AT_launch_bounds:
2950     handleLaunchBoundsAttr(S, D, Attr);
2951     break;
2952   case AttributeList::AT_mode:        handleModeAttr        (S, D, Attr); break;
2953   case AttributeList::AT_malloc:      handleMallocAttr      (S, D, Attr); break;
2954   case AttributeList::AT_may_alias:   handleMayAliasAttr    (S, D, Attr); break;
2955   case AttributeList::AT_nocommon:    handleNoCommonAttr    (S, D, Attr); break;
2956   case AttributeList::AT_nonnull:     handleNonNullAttr     (S, D, Attr); break;
2957   case AttributeList::AT_ownership_returns:
2958   case AttributeList::AT_ownership_takes:
2959   case AttributeList::AT_ownership_holds:
2960       handleOwnershipAttr     (S, D, Attr); break;
2961   case AttributeList::AT_naked:       handleNakedAttr       (S, D, Attr); break;
2962   case AttributeList::AT_noreturn:    handleNoReturnAttr    (S, D, Attr); break;
2963   case AttributeList::AT_nothrow:     handleNothrowAttr     (S, D, Attr); break;
2964   case AttributeList::AT_shared:      handleSharedAttr      (S, D, Attr); break;
2965   case AttributeList::AT_vecreturn:   handleVecReturnAttr   (S, D, Attr); break;
2966
2967   case AttributeList::AT_objc_ownership:
2968     handleObjCOwnershipAttr(S, D, Attr); break;
2969   case AttributeList::AT_objc_precise_lifetime:
2970     handleObjCPreciseLifetimeAttr(S, D, Attr); break;
2971
2972   // Checker-specific.
2973   case AttributeList::AT_cf_consumed:
2974   case AttributeList::AT_ns_consumed: handleNSConsumedAttr  (S, D, Attr); break;
2975   case AttributeList::AT_ns_consumes_self:
2976     handleNSConsumesSelfAttr(S, D, Attr); break;
2977
2978   case AttributeList::AT_ns_returns_autoreleased:
2979   case AttributeList::AT_ns_returns_not_retained:
2980   case AttributeList::AT_cf_returns_not_retained:
2981   case AttributeList::AT_ns_returns_retained:
2982   case AttributeList::AT_cf_returns_retained:
2983     handleNSReturnsRetainedAttr(S, D, Attr); break;
2984
2985   case AttributeList::AT_reqd_wg_size:
2986     handleReqdWorkGroupSize(S, D, Attr); break;
2987
2988   case AttributeList::AT_init_priority:
2989       handleInitPriorityAttr(S, D, Attr); break;
2990
2991   case AttributeList::AT_packed:      handlePackedAttr      (S, D, Attr); break;
2992   case AttributeList::AT_MsStruct:    handleMsStructAttr    (S, D, Attr); break;
2993   case AttributeList::AT_section:     handleSectionAttr     (S, D, Attr); break;
2994   case AttributeList::AT_unavailable: handleUnavailableAttr (S, D, Attr); break;
2995   case AttributeList::AT_arc_weakref_unavailable:
2996     handleArcWeakrefUnavailableAttr (S, D, Attr);
2997     break;
2998   case AttributeList::AT_unused:      handleUnusedAttr      (S, D, Attr); break;
2999   case AttributeList::AT_used:        handleUsedAttr        (S, D, Attr); break;
3000   case AttributeList::AT_visibility:  handleVisibilityAttr  (S, D, Attr); break;
3001   case AttributeList::AT_warn_unused_result: handleWarnUnusedResult(S, D, Attr);
3002     break;
3003   case AttributeList::AT_weak:        handleWeakAttr        (S, D, Attr); break;
3004   case AttributeList::AT_weakref:     handleWeakRefAttr     (S, D, Attr); break;
3005   case AttributeList::AT_weak_import: handleWeakImportAttr  (S, D, Attr); break;
3006   case AttributeList::AT_transparent_union:
3007     handleTransparentUnionAttr(S, D, Attr);
3008     break;
3009   case AttributeList::AT_objc_exception:
3010     handleObjCExceptionAttr(S, D, Attr);
3011     break;
3012   case AttributeList::AT_objc_method_family:
3013     handleObjCMethodFamilyAttr(S, D, Attr);
3014     break;
3015   case AttributeList::AT_nsobject:    handleObjCNSObject    (S, D, Attr); break;
3016   case AttributeList::AT_blocks:      handleBlocksAttr      (S, D, Attr); break;
3017   case AttributeList::AT_sentinel:    handleSentinelAttr    (S, D, Attr); break;
3018   case AttributeList::AT_const:       handleConstAttr       (S, D, Attr); break;
3019   case AttributeList::AT_pure:        handlePureAttr        (S, D, Attr); break;
3020   case AttributeList::AT_cleanup:     handleCleanupAttr     (S, D, Attr); break;
3021   case AttributeList::AT_nodebug:     handleNoDebugAttr     (S, D, Attr); break;
3022   case AttributeList::AT_noinline:    handleNoInlineAttr    (S, D, Attr); break;
3023   case AttributeList::AT_regparm:     handleRegparmAttr     (S, D, Attr); break;
3024   case AttributeList::IgnoredAttribute:
3025     // Just ignore
3026     break;
3027   case AttributeList::AT_no_instrument_function:  // Interacts with -pg.
3028     handleNoInstrumentFunctionAttr(S, D, Attr);
3029     break;
3030   case AttributeList::AT_stdcall:
3031   case AttributeList::AT_cdecl:
3032   case AttributeList::AT_fastcall:
3033   case AttributeList::AT_thiscall:
3034   case AttributeList::AT_pascal:
3035   case AttributeList::AT_pcs:
3036     handleCallConvAttr(S, D, Attr);
3037     break;
3038   case AttributeList::AT_opencl_kernel_function:
3039     handleOpenCLKernelAttr(S, D, Attr);
3040     break;
3041   case AttributeList::AT_uuid:
3042     handleUuidAttr(S, D, Attr);
3043     break;
3044   default:
3045     // Ask target about the attribute.
3046     const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
3047     if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
3048       S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored)
3049         << Attr.getName();
3050     break;
3051   }
3052 }
3053
3054 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
3055 /// the attribute applies to decls.  If the attribute is a type attribute, just
3056 /// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
3057 /// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
3058 static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
3059                                  const AttributeList &Attr,
3060                                  bool NonInheritable, bool Inheritable) {
3061   if (Attr.isInvalid())
3062     return;
3063
3064   if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
3065     // FIXME: Try to deal with other __declspec attributes!
3066     return;
3067
3068   if (NonInheritable)
3069     ProcessNonInheritableDeclAttr(S, scope, D, Attr);
3070
3071   if (Inheritable)
3072     ProcessInheritableDeclAttr(S, scope, D, Attr);
3073 }
3074
3075 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
3076 /// attribute list to the specified decl, ignoring any type attributes.
3077 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
3078                                     const AttributeList *AttrList,
3079                                     bool NonInheritable, bool Inheritable) {
3080   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
3081     ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable);
3082   }
3083
3084   // GCC accepts
3085   // static int a9 __attribute__((weakref));
3086   // but that looks really pointless. We reject it.
3087   if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
3088     Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
3089     dyn_cast<NamedDecl>(D)->getNameAsString();
3090     return;
3091   }
3092 }
3093
3094 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
3095 /// #pragma weak needs a non-definition decl and source may not have one
3096 NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) {
3097   assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
3098   NamedDecl *NewD = 0;
3099   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
3100     NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
3101                                 FD->getInnerLocStart(),
3102                                 FD->getLocation(), DeclarationName(II),
3103                                 FD->getType(), FD->getTypeSourceInfo());
3104     if (FD->getQualifier()) {
3105       FunctionDecl *NewFD = cast<FunctionDecl>(NewD);
3106       NewFD->setQualifierInfo(FD->getQualifierLoc());
3107     }
3108   } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
3109     NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
3110                            VD->getInnerLocStart(), VD->getLocation(), II,
3111                            VD->getType(), VD->getTypeSourceInfo(),
3112                            VD->getStorageClass(),
3113                            VD->getStorageClassAsWritten());
3114     if (VD->getQualifier()) {
3115       VarDecl *NewVD = cast<VarDecl>(NewD);
3116       NewVD->setQualifierInfo(VD->getQualifierLoc());
3117     }
3118   }
3119   return NewD;
3120 }
3121
3122 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
3123 /// applied to it, possibly with an alias.
3124 void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
3125   if (W.getUsed()) return; // only do this once
3126   W.setUsed(true);
3127   if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
3128     IdentifierInfo *NDId = ND->getIdentifier();
3129     NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias());
3130     NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
3131                                             NDId->getName()));
3132     NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3133     WeakTopLevelDecl.push_back(NewD);
3134     // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
3135     // to insert Decl at TU scope, sorry.
3136     DeclContext *SavedContext = CurContext;
3137     CurContext = Context.getTranslationUnitDecl();
3138     PushOnScopeChains(NewD, S);
3139     CurContext = SavedContext;
3140   } else { // just add weak to existing
3141     ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3142   }
3143 }
3144
3145 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
3146 /// it, apply them to D.  This is a bit tricky because PD can have attributes
3147 /// specified in many different places, and we need to find and apply them all.
3148 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
3149                                  bool NonInheritable, bool Inheritable) {
3150   // It's valid to "forward-declare" #pragma weak, in which case we
3151   // have to do this.
3152   if (Inheritable && !WeakUndeclaredIdentifiers.empty()) {
3153     if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
3154       if (IdentifierInfo *Id = ND->getIdentifier()) {
3155         llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
3156           = WeakUndeclaredIdentifiers.find(Id);
3157         if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
3158           WeakInfo W = I->second;
3159           DeclApplyPragmaWeak(S, ND, W);
3160           WeakUndeclaredIdentifiers[Id] = W;
3161         }
3162       }
3163     }
3164   }
3165
3166   // Apply decl attributes from the DeclSpec if present.
3167   if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
3168     ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3169
3170   // Walk the declarator structure, applying decl attributes that were in a type
3171   // position to the decl itself.  This handles cases like:
3172   //   int *__attr__(x)** D;
3173   // when X is a decl attribute.
3174   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
3175     if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
3176       ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3177
3178   // Finally, apply any attributes on the decl itself.
3179   if (const AttributeList *Attrs = PD.getAttributes())
3180     ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3181 }
3182
3183 /// Is the given declaration allowed to use a forbidden type?
3184 static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
3185   // Private ivars are always okay.  Unfortunately, people don't
3186   // always properly make their ivars private, even in system headers.
3187   // Plus we need to make fields okay, too.
3188   if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl))
3189     return false;
3190
3191   // Require it to be declared in a system header.
3192   return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
3193 }
3194
3195 /// Handle a delayed forbidden-type diagnostic.
3196 static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
3197                                        Decl *decl) {
3198   if (decl && isForbiddenTypeAllowed(S, decl)) {
3199     decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
3200                         "this system declaration uses an unsupported type"));
3201     return;
3202   }
3203
3204   S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
3205     << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
3206   diag.Triggered = true;
3207 }
3208
3209 // This duplicates a vector push_back but hides the need to know the
3210 // size of the type.
3211 void Sema::DelayedDiagnostics::add(const DelayedDiagnostic &diag) {
3212   assert(StackSize <= StackCapacity);
3213
3214   // Grow the stack if necessary.
3215   if (StackSize == StackCapacity) {
3216     unsigned newCapacity = 2 * StackCapacity + 2;
3217     char *newBuffer = new char[newCapacity * sizeof(DelayedDiagnostic)];
3218     const char *oldBuffer = (const char*) Stack;
3219
3220     if (StackCapacity)
3221       memcpy(newBuffer, oldBuffer, StackCapacity * sizeof(DelayedDiagnostic));
3222
3223     delete[] oldBuffer;
3224     Stack = reinterpret_cast<sema::DelayedDiagnostic*>(newBuffer);
3225     StackCapacity = newCapacity;
3226   }
3227
3228   assert(StackSize < StackCapacity);
3229   new (&Stack[StackSize++]) DelayedDiagnostic(diag);
3230 }
3231
3232 void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
3233                                               Decl *decl) {
3234   DelayedDiagnostics &DD = S.DelayedDiagnostics;
3235
3236   // Check the invariants.
3237   assert(DD.StackSize >= state.SavedStackSize);
3238   assert(state.SavedStackSize >= DD.ActiveStackBase);
3239   assert(DD.ParsingDepth > 0);
3240
3241   // Drop the parsing depth.
3242   DD.ParsingDepth--;
3243
3244   // If there are no active diagnostics, we're done.
3245   if (DD.StackSize == DD.ActiveStackBase)
3246     return;
3247
3248   // We only want to actually emit delayed diagnostics when we
3249   // successfully parsed a decl.
3250   if (decl && !decl->isInvalidDecl()) {
3251     // We emit all the active diagnostics, not just those starting
3252     // from the saved state.  The idea is this:  we get one push for a
3253     // decl spec and another for each declarator;  in a decl group like:
3254     //   deprecated_typedef foo, *bar, baz();
3255     // only the declarator pops will be passed decls.  This is correct;
3256     // we really do need to consider delayed diagnostics from the decl spec
3257     // for each of the different declarations.
3258     for (unsigned i = DD.ActiveStackBase, e = DD.StackSize; i != e; ++i) {
3259       DelayedDiagnostic &diag = DD.Stack[i];
3260       if (diag.Triggered)
3261         continue;
3262
3263       switch (diag.Kind) {
3264       case DelayedDiagnostic::Deprecation:
3265         S.HandleDelayedDeprecationCheck(diag, decl);
3266         break;
3267
3268       case DelayedDiagnostic::Access:
3269         S.HandleDelayedAccessCheck(diag, decl);
3270         break;
3271
3272       case DelayedDiagnostic::ForbiddenType:
3273         handleDelayedForbiddenType(S, diag, decl);
3274         break;
3275       }
3276     }
3277   }
3278
3279   // Destroy all the delayed diagnostics we're about to pop off.
3280   for (unsigned i = state.SavedStackSize, e = DD.StackSize; i != e; ++i)
3281     DD.Stack[i].Destroy();
3282
3283   DD.StackSize = state.SavedStackSize;
3284 }
3285
3286 static bool isDeclDeprecated(Decl *D) {
3287   do {
3288     if (D->isDeprecated())
3289       return true;
3290   } while ((D = cast_or_null<Decl>(D->getDeclContext())));
3291   return false;
3292 }
3293
3294 void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
3295                                          Decl *Ctx) {
3296   if (isDeclDeprecated(Ctx))
3297     return;
3298
3299   DD.Triggered = true;
3300   if (!DD.getDeprecationMessage().empty())
3301     Diag(DD.Loc, diag::warn_deprecated_message)
3302       << DD.getDeprecationDecl()->getDeclName()
3303       << DD.getDeprecationMessage();
3304   else
3305     Diag(DD.Loc, diag::warn_deprecated)
3306       << DD.getDeprecationDecl()->getDeclName();
3307 }
3308
3309 void Sema::EmitDeprecationWarning(NamedDecl *D, llvm::StringRef Message,
3310                                   SourceLocation Loc,
3311                                   const ObjCInterfaceDecl *UnknownObjCClass) {
3312   // Delay if we're currently parsing a declaration.
3313   if (DelayedDiagnostics.shouldDelayDiagnostics()) {
3314     DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D, Message));
3315     return;
3316   }
3317
3318   // Otherwise, don't warn if our current context is deprecated.
3319   if (isDeclDeprecated(cast<Decl>(CurContext)))
3320     return;
3321   if (!Message.empty())
3322     Diag(Loc, diag::warn_deprecated_message) << D->getDeclName()
3323                                              << Message;
3324   else {
3325     if (!UnknownObjCClass)
3326       Diag(Loc, diag::warn_deprecated) << D->getDeclName();
3327     else {
3328       Diag(Loc, diag::warn_deprecated_fwdclass_message) << D->getDeclName();
3329       Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
3330     }
3331   }
3332 }