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