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 "Sema.h"
  15 #include "TargetAttributesSema.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/Basic/TargetInfo.h"
  20 #include "clang/Parse/DeclSpec.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 using namespace clang;
  23
  24 //===----------------------------------------------------------------------===//
  25 //  Helper functions
  26 //===----------------------------------------------------------------------===//
  27
  28 static const FunctionType *getFunctionType(const Decl *d,
  29                                            bool blocksToo = true) {
  30   QualType Ty;
  31   if (const ValueDecl *decl = dyn_cast<ValueDecl>(d))
  32     Ty = decl->getType();
  33   else if (const FieldDecl *decl = dyn_cast<FieldDecl>(d))
  34     Ty = decl->getType();
  35   else if (const TypedefDecl* decl = dyn_cast<TypedefDecl>(d))
  36     Ty = decl->getUnderlyingType();
  37   else
  38     return 0;
  39
  40   if (Ty->isFunctionPointerType())
  41     Ty = Ty->getAs<PointerType>()->getPointeeType();
  42   else if (blocksToo && Ty->isBlockPointerType())
  43     Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
  44
  45   return Ty->getAs<FunctionType>();
  46 }
  47
  48 // FIXME: We should provide an abstraction around a method or function
  49 // to provide the following bits of information.
  50
  51 /// isFunction - Return true if the given decl has function
  52 /// type (function or function-typed variable).
  53 static bool isFunction(const Decl *d) {
  54   return getFunctionType(d, false) != NULL;
  55 }
  56
  57 /// isFunctionOrMethod - Return true if the given decl has function
  58 /// type (function or function-typed variable) or an Objective-C
  59 /// method.
  60 static bool isFunctionOrMethod(const Decl *d) {
  61   return isFunction(d)|| isa<ObjCMethodDecl>(d);
  62 }
  63
  64 /// isFunctionOrMethodOrBlock - Return true if the given decl has function
  65 /// type (function or function-typed variable) or an Objective-C
  66 /// method or a block.
  67 static bool isFunctionOrMethodOrBlock(const Decl *d) {
  68   if (isFunctionOrMethod(d))
  69     return true;
  70   // check for block is more involved.
  71   if (const VarDecl *V = dyn_cast<VarDecl>(d)) {
  72     QualType Ty = V->getType();
  73     return Ty->isBlockPointerType();
  74   }
  75   return isa<BlockDecl>(d);
  76 }
  77
  78 /// hasFunctionProto - Return true if the given decl has a argument
  79 /// information. This decl should have already passed
  80 /// isFunctionOrMethod or isFunctionOrMethodOrBlock.
  81 static bool hasFunctionProto(const Decl *d) {
  82   if (const FunctionType *FnTy = getFunctionType(d))
  83     return isa<FunctionProtoType>(FnTy);
  84   else {
  85     assert(isa<ObjCMethodDecl>(d) || isa<BlockDecl>(d));
  86     return true;
  87   }
  88 }
  89
  90 /// getFunctionOrMethodNumArgs - Return number of function or method
  91 /// arguments. It is an error to call this on a K&R function (use
  92 /// hasFunctionProto first).
  93 static unsigned getFunctionOrMethodNumArgs(const Decl *d) {
  94   if (const FunctionType *FnTy = getFunctionType(d))
  95     return cast<FunctionProtoType>(FnTy)->getNumArgs();
  96   if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
  97     return BD->getNumParams();
  98   return cast<ObjCMethodDecl>(d)->param_size();
  99 }
 100
 101 static QualType getFunctionOrMethodArgType(const Decl *d, unsigned Idx) {
 102   if (const FunctionType *FnTy = getFunctionType(d))
 103     return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
 104   if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
 105     return BD->getParamDecl(Idx)->getType();
 106
 107   return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType();
 108 }
 109
 110 static QualType getFunctionOrMethodResultType(const Decl *d) {
 111   if (const FunctionType *FnTy = getFunctionType(d))
 112     return cast<FunctionProtoType>(FnTy)->getResultType();
 113   return cast<ObjCMethodDecl>(d)->getResultType();
 114 }
 115
 116 static bool isFunctionOrMethodVariadic(const Decl *d) {
 117   if (const FunctionType *FnTy = getFunctionType(d)) {
 118     const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
 119     return proto->isVariadic();
 120   } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
 121     return BD->IsVariadic();
 122   else {
 123     return cast<ObjCMethodDecl>(d)->isVariadic();
 124   }
 125 }
 126
 127 static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
 128   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
 129   if (!PT)
 130     return false;
 131
 132   const ObjCInterfaceType *ClsT =PT->getPointeeType()->getAs<ObjCInterfaceType>();
 133   if (!ClsT)
 134     return false;
 135
 136   IdentifierInfo* ClsName = ClsT->getDecl()->getIdentifier();
 137
 138   // FIXME: Should we walk the chain of classes?
 139   return ClsName == &Ctx.Idents.get("NSString") ||
 140          ClsName == &Ctx.Idents.get("NSMutableString");
 141 }
 142
 143 static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
 144   const PointerType *PT = T->getAs<PointerType>();
 145   if (!PT)
 146     return false;
 147
 148   const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
 149   if (!RT)
 150     return false;
 151
 152   const RecordDecl *RD = RT->getDecl();
 153   if (RD->getTagKind() != TagDecl::TK_struct)
 154     return false;
 155
 156   return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
 157 }
 158
 159 //===----------------------------------------------------------------------===//
 160 // Attribute Implementations
 161 //===----------------------------------------------------------------------===//
 162
 163 // FIXME: All this manual attribute parsing code is gross. At the
 164 // least add some helper functions to check most argument patterns (#
 165 // and types of args).
 166
 167 static void HandleExtVectorTypeAttr(Scope *scope, Decl *d,
 168                                     const AttributeList &Attr, Sema &S) {
 169   TypedefDecl *tDecl = dyn_cast<TypedefDecl>(d);
 170   if (tDecl == 0) {
 171     S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
 172     return;
 173   }
 174
 175   QualType curType = tDecl->getUnderlyingType();
 176
 177   Expr *sizeExpr;
 178
 179   // Special case where the argument is a template id.
 180   if (Attr.getParameterName()) {
 181     CXXScopeSpec SS;
 182     UnqualifiedId id;
 183     id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
 184     sizeExpr = S.ActOnIdExpression(scope, SS, id, false, false).takeAs<Expr>();
 185   } else {
 186     // check the attribute arguments.
 187     if (Attr.getNumArgs() != 1) {
 188       S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 189       return;
 190     }
 191     sizeExpr = static_cast<Expr *>(Attr.getArg(0));
 192   }
 193
 194   // Instantiate/Install the vector type, and let Sema build the type for us.
 195   // This will run the reguired checks.
 196   QualType T = S.BuildExtVectorType(curType, S.Owned(sizeExpr), Attr.getLoc());
 197   if (!T.isNull()) {
 198     // FIXME: preserve the old source info.
 199     tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
 200
 201     // Remember this typedef decl, we will need it later for diagnostics.
 202     S.ExtVectorDecls.push_back(tDecl);
 203   }
 204 }
 205
 206 static void HandlePackedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 207   // check the attribute arguments.
 208   if (Attr.getNumArgs() > 0) {
 209     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 210     return;
 211   }
 212
 213   if (TagDecl *TD = dyn_cast<TagDecl>(d))
 214     TD->addAttr(::new (S.Context) PackedAttr);
 215   else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) {
 216     // If the alignment is less than or equal to 8 bits, the packed attribute
 217     // has no effect.
 218     if (!FD->getType()->isIncompleteType() &&
 219         S.Context.getTypeAlign(FD->getType()) <= 8)
 220       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
 221         << Attr.getName() << FD->getType();
 222     else
 223       FD->addAttr(::new (S.Context) PackedAttr);
 224   } else
 225     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
 226 }
 227
 228 static void HandleIBAction(Decl *d, const AttributeList &Attr, Sema &S) {
 229   // check the attribute arguments.
 230   if (Attr.getNumArgs() > 0) {
 231     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 232     return;
 233   }
 234
 235   // The IBAction attributes only apply to instance methods.
 236   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d))
 237     if (MD->isInstanceMethod()) {
 238       d->addAttr(::new (S.Context) IBActionAttr());
 239       return;
 240     }
 241
 242   S.Diag(Attr.getLoc(), diag::err_attribute_ibaction) << Attr.getName();
 243 }
 244
 245 static void HandleIBOutlet(Decl *d, const AttributeList &Attr, Sema &S) {
 246   // check the attribute arguments.
 247   if (Attr.getNumArgs() > 0) {
 248     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 249     return;
 250   }
 251
 252   // The IBOutlet attributes only apply to instance variables of
 253   // Objective-C classes.
 254   if (isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d)) {
 255     d->addAttr(::new (S.Context) IBOutletAttr());
 256     return;
 257   }
 258
 259   S.Diag(Attr.getLoc(), diag::err_attribute_iboutlet) << Attr.getName();
 260 }
 261
 262 static void HandleNonNullAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 263   // GCC ignores the nonnull attribute on K&R style function prototypes, so we
 264   // ignore it as well
 265   if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) {
 266     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 267       << Attr.getName() << 0 /*function*/;
 268     return;
 269   }
 270
 271   unsigned NumArgs = getFunctionOrMethodNumArgs(d);
 272
 273   // The nonnull attribute only applies to pointers.
 274   llvm::SmallVector<unsigned, 10> NonNullArgs;
 275
 276   for (AttributeList::arg_iterator I=Attr.arg_begin(),
 277                                    E=Attr.arg_end(); I!=E; ++I) {
 278
 279
 280     // The argument must be an integer constant expression.
 281     Expr *Ex = static_cast<Expr *>(*I);
 282     llvm::APSInt ArgNum(32);
 283     if (!Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
 284       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
 285         << "nonnull" << Ex->getSourceRange();
 286       return;
 287     }
 288
 289     unsigned x = (unsigned) ArgNum.getZExtValue();
 290
 291     if (x < 1 || x > NumArgs) {
 292       S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
 293        << "nonnull" << I.getArgNum() << Ex->getSourceRange();
 294       return;
 295     }
 296
 297     --x;
 298
 299     // Is the function argument a pointer type?
 300     QualType T = getFunctionOrMethodArgType(d, x);
 301     if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
 302       // FIXME: Should also highlight argument in decl.
 303       S.Diag(Attr.getLoc(), diag::err_nonnull_pointers_only)
 304         << "nonnull" << Ex->getSourceRange();
 305       continue;
 306     }
 307
 308     NonNullArgs.push_back(x);
 309   }
 310
 311   // If no arguments were specified to __attribute__((nonnull)) then all pointer
 312   // arguments have a nonnull attribute.
 313   if (NonNullArgs.empty()) {
 314     for (unsigned I = 0, E = getFunctionOrMethodNumArgs(d); I != E; ++I) {
 315       QualType T = getFunctionOrMethodArgType(d, I);
 316       if (T->isAnyPointerType() || T->isBlockPointerType())
 317         NonNullArgs.push_back(I);
 318     }
 319
 320     if (NonNullArgs.empty()) {
 321       S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
 322       return;
 323     }
 324   }
 325
 326   unsigned* start = &NonNullArgs[0];
 327   unsigned size = NonNullArgs.size();
 328   std::sort(start, start + size);
 329   d->addAttr(::new (S.Context) NonNullAttr(S.Context, start, size));
 330 }
 331
 332 static bool isStaticVarOrStaticFunciton(Decl *D) {
 333   if (VarDecl *VD = dyn_cast<VarDecl>(D))
 334     return VD->getStorageClass() == VarDecl::Static;
 335   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
 336     return FD->getStorageClass() == FunctionDecl::Static;
 337   return false;
 338 }
 339
 340 static void HandleWeakRefAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 341   // Check the attribute arguments.
 342   if (Attr.getNumArgs() > 1) {
 343     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 344     return;
 345   }
 346
 347   // gcc rejects
 348   // class c {
 349   //   static int a __attribute__((weakref ("v2")));
 350   //   static int b() __attribute__((weakref ("f3")));
 351   // };
 352   // and ignores the attributes of
 353   // void f(void) {
 354   //   static int a __attribute__((weakref ("v2")));
 355   // }
 356   // we reject them
 357   if (const DeclContext *Ctx = d->getDeclContext()) {
 358     Ctx = Ctx->getLookupContext();
 359     if (!isa<TranslationUnitDecl>(Ctx) && !isa<NamespaceDecl>(Ctx) ) {
 360       S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
 361         dyn_cast<NamedDecl>(d)->getNameAsString();
 362       return;
 363     }
 364   }
 365
 366   // The GCC manual says
 367   //
 368   // At present, a declaration to which `weakref' is attached can only
 369   // be `static'.
 370   //
 371   // It also says
 372   //
 373   // Without a TARGET,
 374   // given as an argument to `weakref' or to `alias', `weakref' is
 375   // equivalent to `weak'.
 376   //
 377   // gcc 4.4.1 will accept
 378   // int a7 __attribute__((weakref));
 379   // as
 380   // int a7 __attribute__((weak));
 381   // This looks like a bug in gcc. We reject that for now. We should revisit
 382   // it if this behaviour is actually used.
 383
 384   if (!isStaticVarOrStaticFunciton(d)) {
 385     S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static) <<
 386       dyn_cast<NamedDecl>(d)->getNameAsString();
 387     return;
 388   }
 389
 390   // GCC rejects
 391   // static ((alias ("y"), weakref)).
 392   // Should we? How to check that weakref is before or after alias?
 393
 394   if (Attr.getNumArgs() == 1) {
 395     Expr *Arg = static_cast<Expr*>(Attr.getArg(0));
 396     Arg = Arg->IgnoreParenCasts();
 397     StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
 398
 399     if (Str == 0 || Str->isWide()) {
 400       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 401           << "weakref" << 1;
 402       return;
 403     }
 404     // GCC will accept anything as the argument of weakref. Should we
 405     // check for an existing decl?
 406     d->addAttr(::new (S.Context) AliasAttr(S.Context, Str->getString()));
 407   }
 408
 409   d->addAttr(::new (S.Context) WeakRefAttr());
 410 }
 411
 412 static void HandleAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 413   // check the attribute arguments.
 414   if (Attr.getNumArgs() != 1) {
 415     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 416     return;
 417   }
 418
 419   Expr *Arg = static_cast<Expr*>(Attr.getArg(0));
 420   Arg = Arg->IgnoreParenCasts();
 421   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
 422
 423   if (Str == 0 || Str->isWide()) {
 424     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 425       << "alias" << 1;
 426     return;
 427   }
 428
 429   // FIXME: check if target symbol exists in current file
 430
 431   d->addAttr(::new (S.Context) AliasAttr(S.Context, Str->getString()));
 432 }
 433
 434 static void HandleAlwaysInlineAttr(Decl *d, const AttributeList &Attr,
 435                                    Sema &S) {
 436   // check the attribute arguments.
 437   if (Attr.getNumArgs() != 0) {
 438     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 439     return;
 440   }
 441
 442   if (!isa<FunctionDecl>(d)) {
 443     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 444     << Attr.getName() << 0 /*function*/;
 445     return;
 446   }
 447
 448   d->addAttr(::new (S.Context) AlwaysInlineAttr());
 449 }
 450
 451 static void HandleMallocAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 452   // check the attribute arguments.
 453   if (Attr.getNumArgs() != 0) {
 454     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 455     return;
 456   }
 457
 458   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
 459     QualType RetTy = FD->getResultType();
 460     if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
 461       d->addAttr(::new (S.Context) MallocAttr());
 462       return;
 463     }
 464   }
 465
 466   S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
 467 }
 468
 469 static bool HandleCommonNoReturnAttr(Decl *d, const AttributeList &Attr,
 470                                      Sema &S) {
 471   // check the attribute arguments.
 472   if (Attr.getNumArgs() != 0) {
 473     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 474     return false;
 475   }
 476
 477   if (!isFunctionOrMethod(d) && !isa<BlockDecl>(d)) {
 478     ValueDecl *VD = dyn_cast<ValueDecl>(d);
 479     if (VD == 0 || (!VD->getType()->isBlockPointerType()
 480                     && !VD->getType()->isFunctionPointerType())) {
 481       S.Diag(Attr.getLoc(),
 482              Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
 483                                      : diag::warn_attribute_wrong_decl_type)
 484         << Attr.getName() << 0 /*function*/;
 485       return false;
 486     }
 487   }
 488
 489   return true;
 490 }
 491
 492 static void HandleNoReturnAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 493   // NOTE: We don't add the attribute to a FunctionDecl because the noreturn
 494   //  trait will be part of the function's type.
 495
 496   // Don't apply as a decl attribute to ValueDecl.
 497   // FIXME: probably ought to diagnose this.
 498   if (isa<ValueDecl>(d))
 499     return;
 500
 501   if (HandleCommonNoReturnAttr(d, Attr, S))
 502     d->addAttr(::new (S.Context) NoReturnAttr());
 503 }
 504
 505 static void HandleAnalyzerNoReturnAttr(Decl *d, const AttributeList &Attr,
 506                                        Sema &S) {
 507   if (HandleCommonNoReturnAttr(d, Attr, S))
 508     d->addAttr(::new (S.Context) AnalyzerNoReturnAttr());
 509 }
 510
 511 static void HandleDependencyAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 512   if (!isFunctionOrMethod(d) && !isa<ParmVarDecl>(d)) {
 513     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
 514       << Attr.getName() << 8 /*function, method, or parameter*/;
 515     return;
 516   }
 517   // FIXME: Actually store the attribute on the declaration
 518 }
 519
 520 static void HandleUnusedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 521   // check the attribute arguments.
 522   if (Attr.getNumArgs() != 0) {
 523     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 524     return;
 525   }
 526
 527   if (!isa<VarDecl>(d) && !isa<ObjCIvarDecl>(d) && !isFunctionOrMethod(d) &&
 528       !isa<TypeDecl>(d)) {
 529     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 530       << Attr.getName() << 2 /*variable and function*/;
 531     return;
 532   }
 533
 534   d->addAttr(::new (S.Context) UnusedAttr());
 535 }
 536
 537 static void HandleUsedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 538   // check the attribute arguments.
 539   if (Attr.getNumArgs() != 0) {
 540     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 541     return;
 542   }
 543
 544   if (const VarDecl *VD = dyn_cast<VarDecl>(d)) {
 545     if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
 546       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
 547       return;
 548     }
 549   } else if (!isFunctionOrMethod(d)) {
 550     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 551       << Attr.getName() << 2 /*variable and function*/;
 552     return;
 553   }
 554
 555   d->addAttr(::new (S.Context) UsedAttr());
 556 }
 557
 558 static void HandleConstructorAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 559   // check the attribute arguments.
 560   if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) {
 561     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
 562       << "0 or 1";
 563     return;
 564   }
 565
 566   int priority = 65535; // FIXME: Do not hardcode such constants.
 567   if (Attr.getNumArgs() > 0) {
 568     Expr *E = static_cast<Expr *>(Attr.getArg(0));
 569     llvm::APSInt Idx(32);
 570     if (!E->isIntegerConstantExpr(Idx, S.Context)) {
 571       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
 572         << "constructor" << 1 << E->getSourceRange();
 573       return;
 574     }
 575     priority = Idx.getZExtValue();
 576   }
 577
 578   if (!isa<FunctionDecl>(d)) {
 579     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 580       << Attr.getName() << 0 /*function*/;
 581     return;
 582   }
 583
 584   d->addAttr(::new (S.Context) ConstructorAttr(priority));
 585 }
 586
 587 static void HandleDestructorAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 588   // check the attribute arguments.
 589   if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) {
 590     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
 591        << "0 or 1";
 592     return;
 593   }
 594
 595   int priority = 65535; // FIXME: Do not hardcode such constants.
 596   if (Attr.getNumArgs() > 0) {
 597     Expr *E = static_cast<Expr *>(Attr.getArg(0));
 598     llvm::APSInt Idx(32);
 599     if (!E->isIntegerConstantExpr(Idx, S.Context)) {
 600       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
 601         << "destructor" << 1 << E->getSourceRange();
 602       return;
 603     }
 604     priority = Idx.getZExtValue();
 605   }
 606
 607   if (!isa<FunctionDecl>(d)) {
 608     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 609       << Attr.getName() << 0 /*function*/;
 610     return;
 611   }
 612
 613   d->addAttr(::new (S.Context) DestructorAttr(priority));
 614 }
 615
 616 static void HandleDeprecatedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 617   // check the attribute arguments.
 618   if (Attr.getNumArgs() != 0) {
 619     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 620     return;
 621   }
 622
 623   d->addAttr(::new (S.Context) DeprecatedAttr());
 624 }
 625
 626 static void HandleUnavailableAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 627   // check the attribute arguments.
 628   if (Attr.getNumArgs() != 0) {
 629     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 630     return;
 631   }
 632
 633   d->addAttr(::new (S.Context) UnavailableAttr());
 634 }
 635
 636 static void HandleVisibilityAttr(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   Expr *Arg = static_cast<Expr*>(Attr.getArg(0));
 644   Arg = Arg->IgnoreParenCasts();
 645   StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
 646
 647   if (Str == 0 || Str->isWide()) {
 648     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 649       << "visibility" << 1;
 650     return;
 651   }
 652
 653   llvm::StringRef TypeStr = Str->getString();
 654   VisibilityAttr::VisibilityTypes type;
 655
 656   if (TypeStr == "default")
 657     type = VisibilityAttr::DefaultVisibility;
 658   else if (TypeStr == "hidden")
 659     type = VisibilityAttr::HiddenVisibility;
 660   else if (TypeStr == "internal")
 661     type = VisibilityAttr::HiddenVisibility; // FIXME
 662   else if (TypeStr == "protected")
 663     type = VisibilityAttr::ProtectedVisibility;
 664   else {
 665     S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
 666     return;
 667   }
 668
 669   d->addAttr(::new (S.Context) VisibilityAttr(type));
 670 }
 671
 672 static void HandleObjCExceptionAttr(Decl *D, const AttributeList &Attr,
 673                                     Sema &S) {
 674   if (Attr.getNumArgs() != 0) {
 675     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 676     return;
 677   }
 678
 679   ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
 680   if (OCI == 0) {
 681     S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
 682     return;
 683   }
 684
 685   D->addAttr(::new (S.Context) ObjCExceptionAttr());
 686 }
 687
 688 static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) {
 689   if (Attr.getNumArgs() != 0) {
 690     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 691     return;
 692   }
 693   if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
 694     QualType T = TD->getUnderlyingType();
 695     if (!T->isPointerType() ||
 696         !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
 697       S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
 698       return;
 699     }
 700   }
 701   D->addAttr(::new (S.Context) ObjCNSObjectAttr());
 702 }
 703
 704 static void
 705 HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 706   if (Attr.getNumArgs() != 0) {
 707     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 708     return;
 709   }
 710
 711   if (!isa<FunctionDecl>(D)) {
 712     S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
 713     return;
 714   }
 715
 716   D->addAttr(::new (S.Context) OverloadableAttr());
 717 }
 718
 719 static void HandleBlocksAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 720   if (!Attr.getParameterName()) {
 721     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
 722       << "blocks" << 1;
 723     return;
 724   }
 725
 726   if (Attr.getNumArgs() != 0) {
 727     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 728     return;
 729   }
 730
 731   BlocksAttr::BlocksAttrTypes type;
 732   if (Attr.getParameterName()->isStr("byref"))
 733     type = BlocksAttr::ByRef;
 734   else {
 735     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
 736       << "blocks" << Attr.getParameterName();
 737     return;
 738   }
 739
 740   d->addAttr(::new (S.Context) BlocksAttr(type));
 741 }
 742
 743 static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 744   // check the attribute arguments.
 745   if (Attr.getNumArgs() > 2) {
 746     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
 747       << "0, 1 or 2";
 748     return;
 749   }
 750
 751   int sentinel = 0;
 752   if (Attr.getNumArgs() > 0) {
 753     Expr *E = static_cast<Expr *>(Attr.getArg(0));
 754     llvm::APSInt Idx(32);
 755     if (!E->isIntegerConstantExpr(Idx, S.Context)) {
 756       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
 757        << "sentinel" << 1 << E->getSourceRange();
 758       return;
 759     }
 760     sentinel = Idx.getZExtValue();
 761
 762     if (sentinel < 0) {
 763       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
 764         << E->getSourceRange();
 765       return;
 766     }
 767   }
 768
 769   int nullPos = 0;
 770   if (Attr.getNumArgs() > 1) {
 771     Expr *E = static_cast<Expr *>(Attr.getArg(1));
 772     llvm::APSInt Idx(32);
 773     if (!E->isIntegerConstantExpr(Idx, S.Context)) {
 774       S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
 775         << "sentinel" << 2 << E->getSourceRange();
 776       return;
 777     }
 778     nullPos = Idx.getZExtValue();
 779
 780     if (nullPos > 1 || nullPos < 0) {
 781       // FIXME: This error message could be improved, it would be nice
 782       // to say what the bounds actually are.
 783       S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
 784         << E->getSourceRange();
 785       return;
 786     }
 787   }
 788
 789   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
 790     const FunctionType *FT = FD->getType()->getAs<FunctionType>();
 791     assert(FT && "FunctionDecl has non-function type?");
 792
 793     if (isa<FunctionNoProtoType>(FT)) {
 794       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
 795       return;
 796     }
 797
 798     if (!cast<FunctionProtoType>(FT)->isVariadic()) {
 799       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
 800       return;
 801     }
 802   } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) {
 803     if (!MD->isVariadic()) {
 804       S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
 805       return;
 806     }
 807   } else if (isa<BlockDecl>(d)) {
 808     // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the
 809     // caller.
 810     ;
 811   } else if (const VarDecl *V = dyn_cast<VarDecl>(d)) {
 812     QualType Ty = V->getType();
 813     if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
 814       const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(d)
 815         : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
 816       if (!cast<FunctionProtoType>(FT)->isVariadic()) {
 817         int m = Ty->isFunctionPointerType() ? 0 : 1;
 818         S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
 819         return;
 820       }
 821     } else {
 822       S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 823       << Attr.getName() << 6 /*function, method or block */;
 824       return;
 825     }
 826   } else {
 827     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 828       << Attr.getName() << 6 /*function, method or block */;
 829     return;
 830   }
 831   d->addAttr(::new (S.Context) SentinelAttr(sentinel, nullPos));
 832 }
 833
 834 static void HandleWarnUnusedResult(Decl *D, const AttributeList &Attr, Sema &S) {
 835   // check the attribute arguments.
 836   if (Attr.getNumArgs() != 0) {
 837     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 838     return;
 839   }
 840
 841   if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
 842     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 843       << Attr.getName() << 0 /*function*/;
 844     return;
 845   }
 846
 847   if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
 848     S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
 849       << Attr.getName() << 0;
 850     return;
 851   }
 852   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
 853     if (MD->getResultType()->isVoidType()) {
 854       S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
 855       << Attr.getName() << 1;
 856       return;
 857     }
 858
 859   D->addAttr(::new (S.Context) WarnUnusedResultAttr());
 860 }
 861
 862 static void HandleWeakAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 863   // check the attribute arguments.
 864   if (Attr.getNumArgs() != 0) {
 865     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 866     return;
 867   }
 868
 869   /* weak only applies to non-static declarations */
 870   if (isStaticVarOrStaticFunciton(D)) {
 871     S.Diag(Attr.getLoc(), diag::err_attribute_weak_static) <<
 872       dyn_cast<NamedDecl>(D)->getNameAsString();
 873     return;
 874   }
 875
 876   // TODO: could also be applied to methods?
 877   if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
 878     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 879       << Attr.getName() << 2 /*variable and function*/;
 880     return;
 881   }
 882
 883   D->addAttr(::new (S.Context) WeakAttr());
 884 }
 885
 886 static void HandleWeakImportAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 887   // check the attribute arguments.
 888   if (Attr.getNumArgs() != 0) {
 889     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 890     return;
 891   }
 892
 893   // weak_import only applies to variable & function declarations.
 894   bool isDef = false;
 895   if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
 896     isDef = (!VD->hasExternalStorage() || VD->getInit());
 897   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 898     isDef = FD->getBody();
 899   } else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D)) {
 900     // We ignore weak import on properties and methods
 901     return;
 902   } else if (!(S.LangOpts.ObjCNonFragileABI && isa<ObjCInterfaceDecl>(D))) {
 903     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
 904     << Attr.getName() << 2 /*variable and function*/;
 905     return;
 906   }
 907
 908   // Merge should handle any subsequent violations.
 909   if (isDef) {
 910     S.Diag(Attr.getLoc(),
 911            diag::warn_attribute_weak_import_invalid_on_definition)
 912       << "weak_import" << 2 /*variable and function*/;
 913     return;
 914   }
 915
 916   D->addAttr(::new (S.Context) WeakImportAttr());
 917 }
 918
 919 static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr,
 920                                     Sema &S) {
 921   // Attribute has 3 arguments.
 922   if (Attr.getNumArgs() != 3) {
 923     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 924     return;
 925   }
 926
 927   unsigned WGSize[3];
 928   for (unsigned i = 0; i < 3; ++i) {
 929     Expr *E = static_cast<Expr *>(Attr.getArg(i));
 930     llvm::APSInt ArgNum(32);
 931     if (!E->isIntegerConstantExpr(ArgNum, S.Context)) {
 932       S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
 933         << "reqd_work_group_size" << E->getSourceRange();
 934       return;
 935     }
 936     WGSize[i] = (unsigned) ArgNum.getZExtValue();
 937   }
 938   D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(WGSize[0], WGSize[1],
 939                                                      WGSize[2]));
 940 }
 941
 942 static void HandleSectionAttr(Decl *D, const AttributeList &Attr, Sema &S) {
 943   // Attribute has no arguments.
 944   if (Attr.getNumArgs() != 1) {
 945     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
 946     return;
 947   }
 948
 949   // Make sure that there is a string literal as the sections's single
 950   // argument.
 951   Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0));
 952   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
 953   if (!SE) {
 954     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
 955     return;
 956   }
 957
 958   // If the target wants to validate the section specifier, make it happen.
 959   std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString());
 960   if (!Error.empty()) {
 961     S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
 962     << Error;
 963     return;
 964   }
 965
 966   // This attribute cannot be applied to local variables.
 967   if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
 968     S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
 969     return;
 970   }
 971
 972   D->addAttr(::new (S.Context) SectionAttr(S.Context, SE->getString()));
 973 }
 974
 975
 976 static void HandleNothrowAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 977   // check the attribute arguments.
 978   if (Attr.getNumArgs() != 0) {
 979     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 980     return;
 981   }
 982
 983   d->addAttr(::new (S.Context) NoThrowAttr());
 984 }
 985
 986 static void HandleConstAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 987   // check the attribute arguments.
 988   if (Attr.getNumArgs() != 0) {
 989     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
 990     return;
 991   }
 992
 993   d->addAttr(::new (S.Context) ConstAttr());
 994 }
 995
 996 static void HandlePureAttr(Decl *d, const AttributeList &Attr, Sema &S) {
 997   // check the attribute arguments.
 998   if (Attr.getNumArgs() != 0) {
 999     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1000     return;
1001   }
1002
1003   d->addAttr(::new (S.Context) PureAttr());
1004 }
1005
1006 static void HandleCleanupAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1007   if (!Attr.getParameterName()) {
1008     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1009     return;
1010   }
1011
1012   if (Attr.getNumArgs() != 0) {
1013     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1014     return;
1015   }
1016
1017   VarDecl *VD = dyn_cast<VarDecl>(d);
1018
1019   if (!VD || !VD->hasLocalStorage()) {
1020     S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
1021     return;
1022   }
1023
1024   // Look up the function
1025   NamedDecl *CleanupDecl
1026     = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
1027                          Sema::LookupOrdinaryName);
1028   if (!CleanupDecl) {
1029     S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_found) <<
1030       Attr.getParameterName();
1031     return;
1032   }
1033
1034   FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
1035   if (!FD) {
1036     S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_function) <<
1037       Attr.getParameterName();
1038     return;
1039   }
1040
1041   if (FD->getNumParams() != 1) {
1042     S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_func_must_take_one_arg) <<
1043       Attr.getParameterName();
1044     return;
1045   }
1046
1047   // We're currently more strict than GCC about what function types we accept.
1048   // If this ever proves to be a problem it should be easy to fix.
1049   QualType Ty = S.Context.getPointerType(VD->getType());
1050   QualType ParamTy = FD->getParamDecl(0)->getType();
1051   if (S.CheckAssignmentConstraints(ParamTy, Ty) != Sema::Compatible) {
1052     S.Diag(Attr.getLoc(),
1053            diag::err_attribute_cleanup_func_arg_incompatible_type) <<
1054       Attr.getParameterName() << ParamTy << Ty;
1055     return;
1056   }
1057
1058   d->addAttr(::new (S.Context) CleanupAttr(FD));
1059 }
1060
1061 /// Handle __attribute__((format_arg((idx)))) attribute based on
1062 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1063 static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1064   if (Attr.getNumArgs() != 1) {
1065     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1066     return;
1067   }
1068   if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) {
1069     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1070     << Attr.getName() << 0 /*function*/;
1071     return;
1072   }
1073   // FIXME: in C++ the implicit 'this' function parameter also counts.  this is
1074   // needed in order to be compatible with GCC the index must start with 1.
1075   unsigned NumArgs  = getFunctionOrMethodNumArgs(d);
1076   unsigned FirstIdx = 1;
1077   // checks for the 2nd argument
1078   Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0));
1079   llvm::APSInt Idx(32);
1080   if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1081     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1082     << "format" << 2 << IdxExpr->getSourceRange();
1083     return;
1084   }
1085
1086   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1087     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1088     << "format" << 2 << IdxExpr->getSourceRange();
1089     return;
1090   }
1091
1092   unsigned ArgIdx = Idx.getZExtValue() - 1;
1093
1094   // make sure the format string is really a string
1095   QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
1096
1097   bool not_nsstring_type = !isNSStringType(Ty, S.Context);
1098   if (not_nsstring_type &&
1099       !isCFStringType(Ty, S.Context) &&
1100       (!Ty->isPointerType() ||
1101        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1102     // FIXME: Should highlight the actual expression that has the wrong type.
1103     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1104     << (not_nsstring_type ? "a string type" : "an NSString")
1105        << IdxExpr->getSourceRange();
1106     return;
1107   }
1108   Ty = getFunctionOrMethodResultType(d);
1109   if (!isNSStringType(Ty, S.Context) &&
1110       !isCFStringType(Ty, S.Context) &&
1111       (!Ty->isPointerType() ||
1112        !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1113     // FIXME: Should highlight the actual expression that has the wrong type.
1114     S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
1115     << (not_nsstring_type ? "string type" : "NSString")
1116        << IdxExpr->getSourceRange();
1117     return;
1118   }
1119
1120   d->addAttr(::new (S.Context) FormatArgAttr(Idx.getZExtValue()));
1121 }
1122
1123 enum FormatAttrKind {
1124   CFStringFormat,
1125   NSStringFormat,
1126   StrftimeFormat,
1127   SupportedFormat,
1128   IgnoredFormat,
1129   InvalidFormat
1130 };
1131
1132 /// getFormatAttrKind - Map from format attribute names to supported format
1133 /// types.
1134 static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) {
1135   // Check for formats that get handled specially.
1136   if (Format == "NSString")
1137     return NSStringFormat;
1138   if (Format == "CFString")
1139     return CFStringFormat;
1140   if (Format == "strftime")
1141     return StrftimeFormat;
1142
1143   // Otherwise, check for supported formats.
1144   if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
1145       Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
1146       Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
1147       Format == "zcmn_err")
1148     return SupportedFormat;
1149
1150   if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
1151       Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
1152     return IgnoredFormat;
1153
1154   return InvalidFormat;
1155 }
1156
1157 /// Handle __attribute__((format(type,idx,firstarg))) attributes based on
1158 /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1159 static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1160
1161   if (!Attr.getParameterName()) {
1162     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1163       << "format" << 1;
1164     return;
1165   }
1166
1167   if (Attr.getNumArgs() != 2) {
1168     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
1169     return;
1170   }
1171
1172   if (!isFunctionOrMethodOrBlock(d) || !hasFunctionProto(d)) {
1173     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1174       << Attr.getName() << 0 /*function*/;
1175     return;
1176   }
1177
1178   unsigned NumArgs  = getFunctionOrMethodNumArgs(d);
1179   unsigned FirstIdx = 1;
1180
1181   llvm::StringRef Format = Attr.getParameterName()->getName();
1182
1183   // Normalize the argument, __foo__ becomes foo.
1184   if (Format.startswith("__") && Format.endswith("__"))
1185     Format = Format.substr(2, Format.size() - 4);
1186
1187   // Check for supported formats.
1188   FormatAttrKind Kind = getFormatAttrKind(Format);
1189
1190   if (Kind == IgnoredFormat)
1191     return;
1192
1193   if (Kind == InvalidFormat) {
1194     S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1195       << "format" << Attr.getParameterName()->getName();
1196     return;
1197   }
1198
1199   // checks for the 2nd argument
1200   Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0));
1201   llvm::APSInt Idx(32);
1202   if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1203     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1204       << "format" << 2 << IdxExpr->getSourceRange();
1205     return;
1206   }
1207
1208   // FIXME: We should handle the implicit 'this' parameter in a more generic
1209   // way that can be used for other arguments.
1210   bool HasImplicitThisParam = false;
1211   if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(d)) {
1212     if (MD->isInstance()) {
1213       HasImplicitThisParam = true;
1214       NumArgs++;
1215     }
1216   }
1217
1218   if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1219     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1220       << "format" << 2 << IdxExpr->getSourceRange();
1221     return;
1222   }
1223
1224   // FIXME: Do we need to bounds check?
1225   unsigned ArgIdx = Idx.getZExtValue() - 1;
1226
1227   if (HasImplicitThisParam) {
1228     if (ArgIdx == 0) {
1229       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1230         << "a string type" << IdxExpr->getSourceRange();
1231       return;
1232     }
1233     ArgIdx--;
1234   }
1235
1236   // make sure the format string is really a string
1237   QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
1238
1239   if (Kind == CFStringFormat) {
1240     if (!isCFStringType(Ty, S.Context)) {
1241       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1242         << "a CFString" << IdxExpr->getSourceRange();
1243       return;
1244     }
1245   } else if (Kind == NSStringFormat) {
1246     // FIXME: do we need to check if the type is NSString*?  What are the
1247     // semantics?
1248     if (!isNSStringType(Ty, S.Context)) {
1249       // FIXME: Should highlight the actual expression that has the wrong type.
1250       S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1251         << "an NSString" << IdxExpr->getSourceRange();
1252       return;
1253     }
1254   } else if (!Ty->isPointerType() ||
1255              !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
1256     // FIXME: Should highlight the actual expression that has the wrong type.
1257     S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1258       << "a string type" << IdxExpr->getSourceRange();
1259     return;
1260   }
1261
1262   // check the 3rd argument
1263   Expr *FirstArgExpr = static_cast<Expr *>(Attr.getArg(1));
1264   llvm::APSInt FirstArg(32);
1265   if (!FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
1266     S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1267       << "format" << 3 << FirstArgExpr->getSourceRange();
1268     return;
1269   }
1270
1271   // check if the function is variadic if the 3rd argument non-zero
1272   if (FirstArg != 0) {
1273     if (isFunctionOrMethodVariadic(d)) {
1274       ++NumArgs; // +1 for ...
1275     } else {
1276       S.Diag(d->getLocation(), diag::err_format_attribute_requires_variadic);
1277       return;
1278     }
1279   }
1280
1281   // strftime requires FirstArg to be 0 because it doesn't read from any
1282   // variable the input is just the current time + the format string.
1283   if (Kind == StrftimeFormat) {
1284     if (FirstArg != 0) {
1285       S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
1286         << FirstArgExpr->getSourceRange();
1287       return;
1288     }
1289   // if 0 it disables parameter checking (to use with e.g. va_list)
1290   } else if (FirstArg != 0 && FirstArg != NumArgs) {
1291     S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1292       << "format" << 3 << FirstArgExpr->getSourceRange();
1293     return;
1294   }
1295
1296   d->addAttr(::new (S.Context) FormatAttr(S.Context, Format, Idx.getZExtValue(),
1297                                           FirstArg.getZExtValue()));
1298 }
1299
1300 static void HandleTransparentUnionAttr(Decl *d, const AttributeList &Attr,
1301                                        Sema &S) {
1302   // check the attribute arguments.
1303   if (Attr.getNumArgs() != 0) {
1304     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1305     return;
1306   }
1307
1308   // Try to find the underlying union declaration.
1309   RecordDecl *RD = 0;
1310   TypedefDecl *TD = dyn_cast<TypedefDecl>(d);
1311   if (TD && TD->getUnderlyingType()->isUnionType())
1312     RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
1313   else
1314     RD = dyn_cast<RecordDecl>(d);
1315
1316   if (!RD || !RD->isUnion()) {
1317     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1318       << Attr.getName() << 1 /*union*/;
1319     return;
1320   }
1321
1322   if (!RD->isDefinition()) {
1323     S.Diag(Attr.getLoc(),
1324         diag::warn_transparent_union_attribute_not_definition);
1325     return;
1326   }
1327
1328   RecordDecl::field_iterator Field = RD->field_begin(),
1329                           FieldEnd = RD->field_end();
1330   if (Field == FieldEnd) {
1331     S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
1332     return;
1333   }
1334
1335   FieldDecl *FirstField = *Field;
1336   QualType FirstType = FirstField->getType();
1337   if (FirstType->isFloatingType() || FirstType->isVectorType()) {
1338     S.Diag(FirstField->getLocation(),
1339            diag::warn_transparent_union_attribute_floating);
1340     return;
1341   }
1342
1343   uint64_t FirstSize = S.Context.getTypeSize(FirstType);
1344   uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
1345   for (; Field != FieldEnd; ++Field) {
1346     QualType FieldType = Field->getType();
1347     if (S.Context.getTypeSize(FieldType) != FirstSize ||
1348         S.Context.getTypeAlign(FieldType) != FirstAlign) {
1349       // Warn if we drop the attribute.
1350       bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
1351       unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
1352                                  : S.Context.getTypeAlign(FieldType);
1353       S.Diag(Field->getLocation(),
1354           diag::warn_transparent_union_attribute_field_size_align)
1355         << isSize << Field->getDeclName() << FieldBits;
1356       unsigned FirstBits = isSize? FirstSize : FirstAlign;
1357       S.Diag(FirstField->getLocation(),
1358              diag::note_transparent_union_first_field_size_align)
1359         << isSize << FirstBits;
1360       return;
1361     }
1362   }
1363
1364   RD->addAttr(::new (S.Context) TransparentUnionAttr());
1365 }
1366
1367 static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1368   // check the attribute arguments.
1369   if (Attr.getNumArgs() != 1) {
1370     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1371     return;
1372   }
1373   Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0));
1374   StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
1375
1376   // Make sure that there is a string literal as the annotation's single
1377   // argument.
1378   if (!SE) {
1379     S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
1380     return;
1381   }
1382   d->addAttr(::new (S.Context) AnnotateAttr(S.Context, SE->getString()));
1383 }
1384
1385 static void HandleAlignedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1386   // check the attribute arguments.
1387   if (Attr.getNumArgs() > 1) {
1388     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1389     return;
1390   }
1391
1392   //FIXME: The C++0x version of this attribute has more limited applicabilty
1393   //       than GNU's, and should error out when it is used to specify a
1394   //       weaker alignment, rather than being silently ignored.
1395
1396   unsigned Align = 0;
1397   if (Attr.getNumArgs() == 0) {
1398     // FIXME: This should be the target specific maximum alignment.
1399     // (For now we just use 128 bits which is the maximum on X86).
1400     Align = 128;
1401     d->addAttr(::new (S.Context) AlignedAttr(Align));
1402     return;
1403   }
1404
1405   Expr *alignmentExpr = static_cast<Expr *>(Attr.getArg(0));
1406   llvm::APSInt Alignment(32);
1407   if (!alignmentExpr->isIntegerConstantExpr(Alignment, S.Context)) {
1408     S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1409       << "aligned" << alignmentExpr->getSourceRange();
1410     return;
1411   }
1412   if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
1413     S.Diag(Attr.getLoc(), diag::err_attribute_aligned_not_power_of_two)
1414       << alignmentExpr->getSourceRange();
1415     return;
1416   }
1417
1418   d->addAttr(::new (S.Context) AlignedAttr(Alignment.getZExtValue() * 8));
1419 }
1420
1421 /// HandleModeAttr - This attribute modifies the width of a decl with primitive
1422 /// type.
1423 ///
1424 /// Despite what would be logical, the mode attribute is a decl attribute, not a
1425 /// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
1426 /// HImode, not an intermediate pointer.
1427 static void HandleModeAttr(Decl *D, const AttributeList &Attr, Sema &S) {
1428   // This attribute isn't documented, but glibc uses it.  It changes
1429   // the width of an int or unsigned int to the specified size.
1430
1431   // Check that there aren't any arguments
1432   if (Attr.getNumArgs() != 0) {
1433     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1434     return;
1435   }
1436
1437   IdentifierInfo *Name = Attr.getParameterName();
1438   if (!Name) {
1439     S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
1440     return;
1441   }
1442
1443   llvm::StringRef Str = Attr.getParameterName()->getName();
1444
1445   // Normalize the attribute name, __foo__ becomes foo.
1446   if (Str.startswith("__") && Str.endswith("__"))
1447     Str = Str.substr(2, Str.size() - 4);
1448
1449   unsigned DestWidth = 0;
1450   bool IntegerMode = true;
1451   bool ComplexMode = false;
1452   switch (Str.size()) {
1453   case 2:
1454     switch (Str[0]) {
1455     case 'Q': DestWidth = 8; break;
1456     case 'H': DestWidth = 16; break;
1457     case 'S': DestWidth = 32; break;
1458     case 'D': DestWidth = 64; break;
1459     case 'X': DestWidth = 96; break;
1460     case 'T': DestWidth = 128; break;
1461     }
1462     if (Str[1] == 'F') {
1463       IntegerMode = false;
1464     } else if (Str[1] == 'C') {
1465       IntegerMode = false;
1466       ComplexMode = true;
1467     } else if (Str[1] != 'I') {
1468       DestWidth = 0;
1469     }
1470     break;
1471   case 4:
1472     // FIXME: glibc uses 'word' to define register_t; this is narrower than a
1473     // pointer on PIC16 and other embedded platforms.
1474     if (Str == "word")
1475       DestWidth = S.Context.Target.getPointerWidth(0);
1476     else if (Str == "byte")
1477       DestWidth = S.Context.Target.getCharWidth();
1478     break;
1479   case 7:
1480     if (Str == "pointer")
1481       DestWidth = S.Context.Target.getPointerWidth(0);
1482     break;
1483   }
1484
1485   QualType OldTy;
1486   if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D))
1487     OldTy = TD->getUnderlyingType();
1488   else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
1489     OldTy = VD->getType();
1490   else {
1491     S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
1492       << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc());
1493     return;
1494   }
1495
1496   if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
1497     S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
1498   else if (IntegerMode) {
1499     if (!OldTy->isIntegralType())
1500       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1501   } else if (ComplexMode) {
1502     if (!OldTy->isComplexType())
1503       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1504   } else {
1505     if (!OldTy->isFloatingType())
1506       S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1507   }
1508
1509   // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
1510   // and friends, at least with glibc.
1511   // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
1512   // width on unusual platforms.
1513   // FIXME: Make sure floating-point mappings are accurate
1514   // FIXME: Support XF and TF types
1515   QualType NewTy;
1516   switch (DestWidth) {
1517   case 0:
1518     S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
1519     return;
1520   default:
1521     S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1522     return;
1523   case 8:
1524     if (!IntegerMode) {
1525       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1526       return;
1527     }
1528     if (OldTy->isSignedIntegerType())
1529       NewTy = S.Context.SignedCharTy;
1530     else
1531       NewTy = S.Context.UnsignedCharTy;
1532     break;
1533   case 16:
1534     if (!IntegerMode) {
1535       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1536       return;
1537     }
1538     if (OldTy->isSignedIntegerType())
1539       NewTy = S.Context.ShortTy;
1540     else
1541       NewTy = S.Context.UnsignedShortTy;
1542     break;
1543   case 32:
1544     if (!IntegerMode)
1545       NewTy = S.Context.FloatTy;
1546     else if (OldTy->isSignedIntegerType())
1547       NewTy = S.Context.IntTy;
1548     else
1549       NewTy = S.Context.UnsignedIntTy;
1550     break;
1551   case 64:
1552     if (!IntegerMode)
1553       NewTy = S.Context.DoubleTy;
1554     else if (OldTy->isSignedIntegerType())
1555       if (S.Context.Target.getLongWidth() == 64)
1556         NewTy = S.Context.LongTy;
1557       else
1558         NewTy = S.Context.LongLongTy;
1559     else
1560       if (S.Context.Target.getLongWidth() == 64)
1561         NewTy = S.Context.UnsignedLongTy;
1562       else
1563         NewTy = S.Context.UnsignedLongLongTy;
1564     break;
1565   case 96:
1566     NewTy = S.Context.LongDoubleTy;
1567     break;
1568   case 128:
1569     if (!IntegerMode) {
1570       S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1571       return;
1572     }
1573     if (OldTy->isSignedIntegerType())
1574       NewTy = S.Context.Int128Ty;
1575     else
1576       NewTy = S.Context.UnsignedInt128Ty;
1577     break;
1578   }
1579
1580   if (ComplexMode) {
1581     NewTy = S.Context.getComplexType(NewTy);
1582   }
1583
1584   // Install the new type.
1585   if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
1586     // FIXME: preserve existing source info.
1587     TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
1588   } else
1589     cast<ValueDecl>(D)->setType(NewTy);
1590 }
1591
1592 static void HandleNoDebugAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1593   // check the attribute arguments.
1594   if (Attr.getNumArgs() > 0) {
1595     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1596     return;
1597   }
1598
1599   if (!isFunctionOrMethod(d)) {
1600     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1601       << Attr.getName() << 0 /*function*/;
1602     return;
1603   }
1604
1605   d->addAttr(::new (S.Context) NoDebugAttr());
1606 }
1607
1608 static void HandleNoInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1609   // check the attribute arguments.
1610   if (Attr.getNumArgs() != 0) {
1611     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1612     return;
1613   }
1614
1615   if (!isa<FunctionDecl>(d)) {
1616     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1617     << Attr.getName() << 0 /*function*/;
1618     return;
1619   }
1620
1621   d->addAttr(::new (S.Context) NoInlineAttr());
1622 }
1623
1624 static void HandleGNUInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1625   // check the attribute arguments.
1626   if (Attr.getNumArgs() != 0) {
1627     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1628     return;
1629   }
1630
1631   FunctionDecl *Fn = dyn_cast<FunctionDecl>(d);
1632   if (Fn == 0) {
1633     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1634       << Attr.getName() << 0 /*function*/;
1635     return;
1636   }
1637
1638   if (!Fn->isInlineSpecified()) {
1639     S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
1640     return;
1641   }
1642
1643   d->addAttr(::new (S.Context) GNUInlineAttr());
1644 }
1645
1646 static void HandleRegparmAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1647   // check the attribute arguments.
1648   if (Attr.getNumArgs() != 1) {
1649     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1650     return;
1651   }
1652
1653   if (!isFunctionOrMethod(d)) {
1654     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1655     << Attr.getName() << 0 /*function*/;
1656     return;
1657   }
1658
1659   Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArg(0));
1660   llvm::APSInt NumParams(32);
1661   if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
1662     S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1663       << "regparm" << NumParamsExpr->getSourceRange();
1664     return;
1665   }
1666
1667   if (S.Context.Target.getRegParmMax() == 0) {
1668     S.Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
1669       << NumParamsExpr->getSourceRange();
1670     return;
1671   }
1672
1673   if (NumParams.getLimitedValue(255) > S.Context.Target.getRegParmMax()) {
1674     S.Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
1675       << S.Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange();
1676     return;
1677   }
1678
1679   d->addAttr(::new (S.Context) RegparmAttr(NumParams.getZExtValue()));
1680 }
1681
1682 static void HandleFinalAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1683   // check the attribute arguments.
1684   if (Attr.getNumArgs() != 0) {
1685     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1686     return;
1687   }
1688
1689   if (!isa<CXXRecordDecl>(d)
1690    && (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual())) {
1691     S.Diag(Attr.getLoc(),
1692            Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1693                                    : diag::warn_attribute_wrong_decl_type)
1694       << Attr.getName() << 7 /*virtual method or class*/;
1695     return;
1696   }
1697
1698   // FIXME: Conform to C++0x redeclaration rules.
1699
1700   if (d->getAttr<FinalAttr>()) {
1701     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "final";
1702     return;
1703   }
1704
1705   d->addAttr(::new (S.Context) FinalAttr());
1706 }
1707
1708 //===----------------------------------------------------------------------===//
1709 // C++0x member checking attributes
1710 //===----------------------------------------------------------------------===//
1711
1712 static void HandleBaseCheckAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1713   if (Attr.getNumArgs() != 0) {
1714     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1715     return;
1716   }
1717
1718   if (!isa<CXXRecordDecl>(d)) {
1719     S.Diag(Attr.getLoc(),
1720            Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1721                                    : diag::warn_attribute_wrong_decl_type)
1722       << Attr.getName() << 9 /*class*/;
1723     return;
1724   }
1725
1726   if (d->getAttr<BaseCheckAttr>()) {
1727     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "base_check";
1728     return;
1729   }
1730
1731   d->addAttr(::new (S.Context) BaseCheckAttr());
1732 }
1733
1734 static void HandleHidingAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1735   if (Attr.getNumArgs() != 0) {
1736     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1737     return;
1738   }
1739
1740   if (!isa<RecordDecl>(d->getDeclContext())) {
1741     // FIXME: It's not the type that's the problem
1742     S.Diag(Attr.getLoc(),
1743            Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1744                                    : diag::warn_attribute_wrong_decl_type)
1745       << Attr.getName() << 11 /*member*/;
1746     return;
1747   }
1748
1749   // FIXME: Conform to C++0x redeclaration rules.
1750
1751   if (d->getAttr<HidingAttr>()) {
1752     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "hiding";
1753     return;
1754   }
1755
1756   d->addAttr(::new (S.Context) HidingAttr());
1757 }
1758
1759 static void HandleOverrideAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1760   if (Attr.getNumArgs() != 0) {
1761     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1762     return;
1763   }
1764
1765   if (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual()) {
1766     // FIXME: It's not the type that's the problem
1767     S.Diag(Attr.getLoc(),
1768            Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1769                                    : diag::warn_attribute_wrong_decl_type)
1770       << Attr.getName() << 10 /*virtual method*/;
1771     return;
1772   }
1773
1774   // FIXME: Conform to C++0x redeclaration rules.
1775
1776   if (d->getAttr<OverrideAttr>()) {
1777     S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "override";
1778     return;
1779   }
1780
1781   d->addAttr(::new (S.Context) OverrideAttr());
1782 }
1783
1784 //===----------------------------------------------------------------------===//
1785 // Checker-specific attribute handlers.
1786 //===----------------------------------------------------------------------===//
1787
1788 static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &Attr,
1789                                         Sema &S) {
1790
1791   QualType RetTy;
1792
1793   if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d))
1794     RetTy = MD->getResultType();
1795   else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d))
1796     RetTy = FD->getResultType();
1797   else {
1798     SourceLocation L = Attr.getLoc();
1799     S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type)
1800         << SourceRange(L, L) << Attr.getName() << 3 /* function or method */;
1801     return;
1802   }
1803
1804   if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAs<PointerType>()
1805         || RetTy->getAs<ObjCObjectPointerType>())) {
1806     SourceLocation L = Attr.getLoc();
1807     S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
1808       << SourceRange(L, L) << Attr.getName();
1809     return;
1810   }
1811
1812   switch (Attr.getKind()) {
1813     default:
1814       assert(0 && "invalid ownership attribute");
1815       return;
1816     case AttributeList::AT_cf_returns_not_retained:
1817       d->addAttr(::new (S.Context) CFReturnsNotRetainedAttr());
1818       return;
1819     case AttributeList::AT_ns_returns_not_retained:
1820       d->addAttr(::new (S.Context) NSReturnsNotRetainedAttr());
1821       return;
1822     case AttributeList::AT_cf_returns_retained:
1823       d->addAttr(::new (S.Context) CFReturnsRetainedAttr());
1824       return;
1825     case AttributeList::AT_ns_returns_retained:
1826       d->addAttr(::new (S.Context) NSReturnsRetainedAttr());
1827       return;
1828   };
1829 }
1830
1831 static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
1832   return Attr.getKind() == AttributeList::AT_dllimport ||
1833          Attr.getKind() == AttributeList::AT_dllexport;
1834 }
1835
1836 //===----------------------------------------------------------------------===//
1837 // Top Level Sema Entry Points
1838 //===----------------------------------------------------------------------===//
1839
1840 /// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
1841 /// the attribute applies to decls.  If the attribute is a type attribute, just
1842 /// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
1843 /// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
1844 static void ProcessDeclAttribute(Scope *scope, Decl *D,
1845                                  const AttributeList &Attr, Sema &S) {
1846   if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
1847     // FIXME: Try to deal with other __declspec attributes!
1848     return;
1849   switch (Attr.getKind()) {
1850   case AttributeList::AT_IBAction:            HandleIBAction(D, Attr, S); break;
1851   case AttributeList::AT_IBOutlet:            HandleIBOutlet(D, Attr, S); break;
1852   case AttributeList::AT_address_space:
1853   case AttributeList::AT_objc_gc:
1854   case AttributeList::AT_vector_size:
1855     // Ignore these, these are type attributes, handled by
1856     // ProcessTypeAttributes.
1857     break;
1858   case AttributeList::AT_alias:       HandleAliasAttr       (D, Attr, S); break;
1859   case AttributeList::AT_aligned:     HandleAlignedAttr     (D, Attr, S); break;
1860   case AttributeList::AT_always_inline:
1861     HandleAlwaysInlineAttr  (D, Attr, S); break;
1862   case AttributeList::AT_analyzer_noreturn:
1863     HandleAnalyzerNoReturnAttr  (D, Attr, S); break;
1864   case AttributeList::AT_annotate:    HandleAnnotateAttr    (D, Attr, S); break;
1865   case AttributeList::AT_base_check:  HandleBaseCheckAttr   (D, Attr, S); break;
1866   case AttributeList::AT_carries_dependency:
1867                                       HandleDependencyAttr  (D, Attr, S); break;
1868   case AttributeList::AT_constructor: HandleConstructorAttr (D, Attr, S); break;
1869   case AttributeList::AT_deprecated:  HandleDeprecatedAttr  (D, Attr, S); break;
1870   case AttributeList::AT_destructor:  HandleDestructorAttr  (D, Attr, S); break;
1871   case AttributeList::AT_ext_vector_type:
1872     HandleExtVectorTypeAttr(scope, D, Attr, S);
1873     break;
1874   case AttributeList::AT_final:       HandleFinalAttr       (D, Attr, S); break;
1875   case AttributeList::AT_format:      HandleFormatAttr      (D, Attr, S); break;
1876   case AttributeList::AT_format_arg:  HandleFormatArgAttr   (D, Attr, S); break;
1877   case AttributeList::AT_gnu_inline:  HandleGNUInlineAttr   (D, Attr, S); break;
1878   case AttributeList::AT_hiding:      HandleHidingAttr      (D, Attr, S); break;
1879   case AttributeList::AT_mode:        HandleModeAttr        (D, Attr, S); break;
1880   case AttributeList::AT_malloc:      HandleMallocAttr      (D, Attr, S); break;
1881   case AttributeList::AT_nonnull:     HandleNonNullAttr     (D, Attr, S); break;
1882   case AttributeList::AT_noreturn:    HandleNoReturnAttr    (D, Attr, S); break;
1883   case AttributeList::AT_nothrow:     HandleNothrowAttr     (D, Attr, S); break;
1884   case AttributeList::AT_override:    HandleOverrideAttr    (D, Attr, S); break;
1885
1886   // Checker-specific.
1887   case AttributeList::AT_ns_returns_not_retained:
1888   case AttributeList::AT_cf_returns_not_retained:
1889   case AttributeList::AT_ns_returns_retained:
1890   case AttributeList::AT_cf_returns_retained:
1891     HandleNSReturnsRetainedAttr(D, Attr, S); break;
1892
1893   case AttributeList::AT_reqd_wg_size:
1894     HandleReqdWorkGroupSize(D, Attr, S); break;
1895
1896   case AttributeList::AT_packed:      HandlePackedAttr      (D, Attr, S); break;
1897   case AttributeList::AT_section:     HandleSectionAttr     (D, Attr, S); break;
1898   case AttributeList::AT_unavailable: HandleUnavailableAttr (D, Attr, S); break;
1899   case AttributeList::AT_unused:      HandleUnusedAttr      (D, Attr, S); break;
1900   case AttributeList::AT_used:        HandleUsedAttr        (D, Attr, S); break;
1901   case AttributeList::AT_visibility:  HandleVisibilityAttr  (D, Attr, S); break;
1902   case AttributeList::AT_warn_unused_result: HandleWarnUnusedResult(D,Attr,S);
1903     break;
1904   case AttributeList::AT_weak:        HandleWeakAttr        (D, Attr, S); break;
1905   case AttributeList::AT_weakref:     HandleWeakRefAttr     (D, Attr, S); break;
1906   case AttributeList::AT_weak_import: HandleWeakImportAttr  (D, Attr, S); break;
1907   case AttributeList::AT_transparent_union:
1908     HandleTransparentUnionAttr(D, Attr, S);
1909     break;
1910   case AttributeList::AT_objc_exception:
1911     HandleObjCExceptionAttr(D, Attr, S);
1912     break;
1913   case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break;
1914   case AttributeList::AT_nsobject:    HandleObjCNSObject    (D, Attr, S); break;
1915   case AttributeList::AT_blocks:      HandleBlocksAttr      (D, Attr, S); break;
1916   case AttributeList::AT_sentinel:    HandleSentinelAttr    (D, Attr, S); break;
1917   case AttributeList::AT_const:       HandleConstAttr       (D, Attr, S); break;
1918   case AttributeList::AT_pure:        HandlePureAttr        (D, Attr, S); break;
1919   case AttributeList::AT_cleanup:     HandleCleanupAttr     (D, Attr, S); break;
1920   case AttributeList::AT_nodebug:     HandleNoDebugAttr     (D, Attr, S); break;
1921   case AttributeList::AT_noinline:    HandleNoInlineAttr    (D, Attr, S); break;
1922   case AttributeList::AT_regparm:     HandleRegparmAttr     (D, Attr, S); break;
1923   case AttributeList::IgnoredAttribute:
1924   case AttributeList::AT_no_instrument_function:  // Interacts with -pg.
1925     // Just ignore
1926     break;
1927   case AttributeList::AT_stdcall:
1928   case AttributeList::AT_cdecl:
1929   case AttributeList::AT_fastcall:
1930     // These are all treated as type attributes.
1931     break;
1932   default:
1933     // Ask target about the attribute.
1934     const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
1935     if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
1936       S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1937     break;
1938   }
1939 }
1940
1941 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
1942 /// attribute list to the specified decl, ignoring any type attributes.
1943 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList) {
1944   for (const AttributeList* l = AttrList; l; l = l->getNext()) {
1945     ProcessDeclAttribute(S, D, *l, *this);
1946   }
1947
1948   // GCC accepts
1949   // static int a9 __attribute__((weakref));
1950   // but that looks really pointless. We reject it.
1951   if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
1952     Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
1953         dyn_cast<NamedDecl>(D)->getNameAsString();
1954     return;
1955   }
1956 }
1957
1958 /// DeclClonePragmaWeak - clone existing decl (maybe definition),
1959 /// #pragma weak needs a non-definition decl and source may not have one
1960 NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) {
1961   assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
1962   NamedDecl *NewD = 0;
1963   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1964     NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
1965                                 FD->getLocation(), DeclarationName(II),
1966                                 FD->getType(), FD->getTypeSourceInfo());
1967     if (FD->getQualifier()) {
1968       FunctionDecl *NewFD = cast<FunctionDecl>(NewD);
1969       NewFD->setQualifierInfo(FD->getQualifier(), FD->getQualifierRange());
1970     }
1971   } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1972     NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
1973                            VD->getLocation(), II,
1974                            VD->getType(), VD->getTypeSourceInfo(),
1975                            VD->getStorageClass());
1976     if (VD->getQualifier()) {
1977       VarDecl *NewVD = cast<VarDecl>(NewD);
1978       NewVD->setQualifierInfo(VD->getQualifier(), VD->getQualifierRange());
1979     }
1980   }
1981   return NewD;
1982 }
1983
1984 /// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
1985 /// applied to it, possibly with an alias.
1986 void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
1987   if (W.getUsed()) return; // only do this once
1988   W.setUsed(true);
1989   if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
1990     IdentifierInfo *NDId = ND->getIdentifier();
1991     NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias());
1992     NewD->addAttr(::new (Context) AliasAttr(Context, NDId->getName()));
1993     NewD->addAttr(::new (Context) WeakAttr());
1994     WeakTopLevelDecl.push_back(NewD);
1995     // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
1996     // to insert Decl at TU scope, sorry.
1997     DeclContext *SavedContext = CurContext;
1998     CurContext = Context.getTranslationUnitDecl();
1999     PushOnScopeChains(NewD, S);
2000     CurContext = SavedContext;
2001   } else { // just add weak to existing
2002     ND->addAttr(::new (Context) WeakAttr());
2003   }
2004 }
2005
2006 /// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
2007 /// it, apply them to D.  This is a bit tricky because PD can have attributes
2008 /// specified in many different places, and we need to find and apply them all.
2009 void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
2010   // Handle #pragma weak
2011   if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
2012     if (ND->hasLinkage()) {
2013       WeakInfo W = WeakUndeclaredIdentifiers.lookup(ND->getIdentifier());
2014       if (W != WeakInfo()) {
2015         // Identifier referenced by #pragma weak before it was declared
2016         DeclApplyPragmaWeak(S, ND, W);
2017         WeakUndeclaredIdentifiers[ND->getIdentifier()] = W;
2018       }
2019     }
2020   }
2021
2022   // Apply decl attributes from the DeclSpec if present.
2023   if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes())
2024     ProcessDeclAttributeList(S, D, Attrs);
2025
2026   // Walk the declarator structure, applying decl attributes that were in a type
2027   // position to the decl itself.  This handles cases like:
2028   //   int *__attr__(x)** D;
2029   // when X is a decl attribute.
2030   for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
2031     if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
2032       ProcessDeclAttributeList(S, D, Attrs);
2033
2034   // Finally, apply any attributes on the decl itself.
2035   if (const AttributeList *Attrs = PD.getAttributes())
2036     ProcessDeclAttributeList(S, D, Attrs);
2037 }
2038
2039 /// PushParsingDeclaration - Enter a new "scope" of deprecation
2040 /// warnings.
2041 ///
2042 /// The state token we use is the start index of this scope
2043 /// on the warning stack.
2044 Action::ParsingDeclStackState Sema::PushParsingDeclaration() {
2045   ParsingDeclDepth++;
2046   return (ParsingDeclStackState) DelayedDiagnostics.size();
2047 }
2048
2049 void Sema::PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy Ctx) {
2050   assert(ParsingDeclDepth > 0 && "empty ParsingDeclaration stack");
2051   ParsingDeclDepth--;
2052
2053   if (DelayedDiagnostics.empty())
2054     return;
2055
2056   unsigned SavedIndex = (unsigned) S;
2057   assert(SavedIndex <= DelayedDiagnostics.size() &&
2058          "saved index is out of bounds");
2059
2060   unsigned E = DelayedDiagnostics.size();
2061
2062   // We only want to actually emit delayed diagnostics when we
2063   // successfully parsed a decl.
2064   Decl *D = Ctx ? Ctx.getAs<Decl>() : 0;
2065   if (D) {
2066     // We really do want to start with 0 here.  We get one push for a
2067     // decl spec and another for each declarator;  in a decl group like:
2068     //   deprecated_typedef foo, *bar, baz();
2069     // only the declarator pops will be passed decls.  This is correct;
2070     // we really do need to consider delayed diagnostics from the decl spec
2071     // for each of the different declarations.
2072     for (unsigned I = 0; I != E; ++I) {
2073       if (DelayedDiagnostics[I].Triggered)
2074         continue;
2075
2076       switch (DelayedDiagnostics[I].Kind) {
2077       case DelayedDiagnostic::Deprecation:
2078         HandleDelayedDeprecationCheck(DelayedDiagnostics[I], D);
2079         break;
2080
2081       case DelayedDiagnostic::Access:
2082         HandleDelayedAccessCheck(DelayedDiagnostics[I], D);
2083         break;
2084       }
2085     }
2086   }
2087
2088   // Destroy all the delayed diagnostics we're about to pop off.
2089   for (unsigned I = SavedIndex; I != E; ++I)
2090     DelayedDiagnostics[I].destroy();
2091
2092   DelayedDiagnostics.set_size(SavedIndex);
2093 }
2094
2095 static bool isDeclDeprecated(Decl *D) {
2096   do {
2097     if (D->hasAttr<DeprecatedAttr>())
2098       return true;
2099   } while ((D = cast_or_null<Decl>(D->getDeclContext())));
2100   return false;
2101 }
2102
2103 void Sema::HandleDelayedDeprecationCheck(Sema::DelayedDiagnostic &DD,
2104                                          Decl *Ctx) {
2105   if (isDeclDeprecated(Ctx))
2106     return;
2107
2108   DD.Triggered = true;
2109   Diag(DD.Loc, diag::warn_deprecated)
2110     << DD.DeprecationData.Decl->getDeclName();
2111 }
2112
2113 void Sema::EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc) {
2114   // Delay if we're currently parsing a declaration.
2115   if (ParsingDeclDepth) {
2116     DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D));
2117     return;
2118   }
2119
2120   // Otherwise, don't warn if our current context is deprecated.
2121   if (isDeclDeprecated(cast<Decl>(CurContext)))
2122     return;
2123
2124   Diag(Loc, diag::warn_deprecated) << D->getDeclName();
2125 }