SemaDeclAttr.cpp revision 3be17941f1edff4843692066f9d33d438a517612 
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"
22using namespace clang;
23
24//===----------------------------------------------------------------------===//
25//  Helper functions
26//===----------------------------------------------------------------------===//
27
28static 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).
53static 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.
60static 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.
67static 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.
81static 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).
93static 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
101static 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
110static 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
116static 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
127static 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
143static 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
167static 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
206static 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
228static 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
245static 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
262static 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
332static 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
340static 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
412static 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
434static 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
451static 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
469static 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
492static 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
505static 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
511static 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
520static 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
537static 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
558static 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
587static 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
616static 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
626static 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
636static 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
672static 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
688static 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
704static void
705HandleOverloadableAttr(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
719static 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
743static 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
834static 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
862static 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
886static 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    if (S.Context.Target.getTriple().getOS() != llvm::Triple::Darwin ||
904        !isa<ObjCInterfaceDecl>(D) ||
905        S.Context.Target.getTriple().getDarwinMajorNumber() <= 10) {
906
907        S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
908        << Attr.getName() << 2 /*variable and function*/;
909      return;
910    }
911  }
912
913  // Merge should handle any subsequent violations.
914  if (isDef) {
915    S.Diag(Attr.getLoc(),
916           diag::warn_attribute_weak_import_invalid_on_definition)
917      << "weak_import" << 2 /*variable and function*/;
918    return;
919  }
920
921  D->addAttr(::new (S.Context) WeakImportAttr());
922}
923
924static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr,
925                                    Sema &S) {
926  // Attribute has 3 arguments.
927  if (Attr.getNumArgs() != 3) {
928    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
929    return;
930  }
931
932  unsigned WGSize[3];
933  for (unsigned i = 0; i < 3; ++i) {
934    Expr *E = static_cast<Expr *>(Attr.getArg(i));
935    llvm::APSInt ArgNum(32);
936    if (!E->isIntegerConstantExpr(ArgNum, S.Context)) {
937      S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
938        << "reqd_work_group_size" << E->getSourceRange();
939      return;
940    }
941    WGSize[i] = (unsigned) ArgNum.getZExtValue();
942  }
943  D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(WGSize[0], WGSize[1],
944                                                     WGSize[2]));
945}
946
947static void HandleSectionAttr(Decl *D, const AttributeList &Attr, Sema &S) {
948  // Attribute has no arguments.
949  if (Attr.getNumArgs() != 1) {
950    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
951    return;
952  }
953
954  // Make sure that there is a string literal as the sections's single
955  // argument.
956  Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0));
957  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
958  if (!SE) {
959    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
960    return;
961  }
962
963  // If the target wants to validate the section specifier, make it happen.
964  std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString());
965  if (!Error.empty()) {
966    S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
967    << Error;
968    return;
969  }
970
971  // This attribute cannot be applied to local variables.
972  if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
973    S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
974    return;
975  }
976
977  D->addAttr(::new (S.Context) SectionAttr(S.Context, SE->getString()));
978}
979
980
981static void HandleNothrowAttr(Decl *d, const AttributeList &Attr, Sema &S) {
982  // check the attribute arguments.
983  if (Attr.getNumArgs() != 0) {
984    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
985    return;
986  }
987
988  d->addAttr(::new (S.Context) NoThrowAttr());
989}
990
991static void HandleConstAttr(Decl *d, const AttributeList &Attr, Sema &S) {
992  // check the attribute arguments.
993  if (Attr.getNumArgs() != 0) {
994    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
995    return;
996  }
997
998  d->addAttr(::new (S.Context) ConstAttr());
999}
1000
1001static void HandlePureAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1002  // check the attribute arguments.
1003  if (Attr.getNumArgs() != 0) {
1004    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1005    return;
1006  }
1007
1008  d->addAttr(::new (S.Context) PureAttr());
1009}
1010
1011static void HandleCleanupAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1012  if (!Attr.getParameterName()) {
1013    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1014    return;
1015  }
1016
1017  if (Attr.getNumArgs() != 0) {
1018    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1019    return;
1020  }
1021
1022  VarDecl *VD = dyn_cast<VarDecl>(d);
1023
1024  if (!VD || !VD->hasLocalStorage()) {
1025    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
1026    return;
1027  }
1028
1029  // Look up the function
1030  NamedDecl *CleanupDecl
1031    = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
1032                         Sema::LookupOrdinaryName);
1033  if (!CleanupDecl) {
1034    S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_found) <<
1035      Attr.getParameterName();
1036    return;
1037  }
1038
1039  FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
1040  if (!FD) {
1041    S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_function) <<
1042      Attr.getParameterName();
1043    return;
1044  }
1045
1046  if (FD->getNumParams() != 1) {
1047    S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_func_must_take_one_arg) <<
1048      Attr.getParameterName();
1049    return;
1050  }
1051
1052  // We're currently more strict than GCC about what function types we accept.
1053  // If this ever proves to be a problem it should be easy to fix.
1054  QualType Ty = S.Context.getPointerType(VD->getType());
1055  QualType ParamTy = FD->getParamDecl(0)->getType();
1056  if (S.CheckAssignmentConstraints(ParamTy, Ty) != Sema::Compatible) {
1057    S.Diag(Attr.getLoc(),
1058           diag::err_attribute_cleanup_func_arg_incompatible_type) <<
1059      Attr.getParameterName() << ParamTy << Ty;
1060    return;
1061  }
1062
1063  d->addAttr(::new (S.Context) CleanupAttr(FD));
1064}
1065
1066/// Handle __attribute__((format_arg((idx)))) attribute based on
1067/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1068static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1069  if (Attr.getNumArgs() != 1) {
1070    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1071    return;
1072  }
1073  if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) {
1074    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1075    << Attr.getName() << 0 /*function*/;
1076    return;
1077  }
1078  // FIXME: in C++ the implicit 'this' function parameter also counts.  this is
1079  // needed in order to be compatible with GCC the index must start with 1.
1080  unsigned NumArgs  = getFunctionOrMethodNumArgs(d);
1081  unsigned FirstIdx = 1;
1082  // checks for the 2nd argument
1083  Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0));
1084  llvm::APSInt Idx(32);
1085  if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1086    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1087    << "format" << 2 << IdxExpr->getSourceRange();
1088    return;
1089  }
1090
1091  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1092    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1093    << "format" << 2 << IdxExpr->getSourceRange();
1094    return;
1095  }
1096
1097  unsigned ArgIdx = Idx.getZExtValue() - 1;
1098
1099  // make sure the format string is really a string
1100  QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
1101
1102  bool not_nsstring_type = !isNSStringType(Ty, S.Context);
1103  if (not_nsstring_type &&
1104      !isCFStringType(Ty, S.Context) &&
1105      (!Ty->isPointerType() ||
1106       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1107    // FIXME: Should highlight the actual expression that has the wrong type.
1108    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1109    << (not_nsstring_type ? "a string type" : "an NSString")
1110       << IdxExpr->getSourceRange();
1111    return;
1112  }
1113  Ty = getFunctionOrMethodResultType(d);
1114  if (!isNSStringType(Ty, S.Context) &&
1115      !isCFStringType(Ty, S.Context) &&
1116      (!Ty->isPointerType() ||
1117       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1118    // FIXME: Should highlight the actual expression that has the wrong type.
1119    S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
1120    << (not_nsstring_type ? "string type" : "NSString")
1121       << IdxExpr->getSourceRange();
1122    return;
1123  }
1124
1125  d->addAttr(::new (S.Context) FormatArgAttr(Idx.getZExtValue()));
1126}
1127
1128enum FormatAttrKind {
1129  CFStringFormat,
1130  NSStringFormat,
1131  StrftimeFormat,
1132  SupportedFormat,
1133  IgnoredFormat,
1134  InvalidFormat
1135};
1136
1137/// getFormatAttrKind - Map from format attribute names to supported format
1138/// types.
1139static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) {
1140  // Check for formats that get handled specially.
1141  if (Format == "NSString")
1142    return NSStringFormat;
1143  if (Format == "CFString")
1144    return CFStringFormat;
1145  if (Format == "strftime")
1146    return StrftimeFormat;
1147
1148  // Otherwise, check for supported formats.
1149  if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
1150      Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
1151      Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
1152      Format == "zcmn_err")
1153    return SupportedFormat;
1154
1155  if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
1156      Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
1157    return IgnoredFormat;
1158
1159  return InvalidFormat;
1160}
1161
1162/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
1163/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1164static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1165
1166  if (!Attr.getParameterName()) {
1167    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1168      << "format" << 1;
1169    return;
1170  }
1171
1172  if (Attr.getNumArgs() != 2) {
1173    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
1174    return;
1175  }
1176
1177  if (!isFunctionOrMethodOrBlock(d) || !hasFunctionProto(d)) {
1178    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1179      << Attr.getName() << 0 /*function*/;
1180    return;
1181  }
1182
1183  unsigned NumArgs  = getFunctionOrMethodNumArgs(d);
1184  unsigned FirstIdx = 1;
1185
1186  llvm::StringRef Format = Attr.getParameterName()->getName();
1187
1188  // Normalize the argument, __foo__ becomes foo.
1189  if (Format.startswith("__") && Format.endswith("__"))
1190    Format = Format.substr(2, Format.size() - 4);
1191
1192  // Check for supported formats.
1193  FormatAttrKind Kind = getFormatAttrKind(Format);
1194
1195  if (Kind == IgnoredFormat)
1196    return;
1197
1198  if (Kind == InvalidFormat) {
1199    S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1200      << "format" << Attr.getParameterName()->getName();
1201    return;
1202  }
1203
1204  // checks for the 2nd argument
1205  Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0));
1206  llvm::APSInt Idx(32);
1207  if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1208    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1209      << "format" << 2 << IdxExpr->getSourceRange();
1210    return;
1211  }
1212
1213  // FIXME: We should handle the implicit 'this' parameter in a more generic
1214  // way that can be used for other arguments.
1215  bool HasImplicitThisParam = false;
1216  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(d)) {
1217    if (MD->isInstance()) {
1218      HasImplicitThisParam = true;
1219      NumArgs++;
1220    }
1221  }
1222
1223  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1224    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1225      << "format" << 2 << IdxExpr->getSourceRange();
1226    return;
1227  }
1228
1229  // FIXME: Do we need to bounds check?
1230  unsigned ArgIdx = Idx.getZExtValue() - 1;
1231
1232  if (HasImplicitThisParam) {
1233    if (ArgIdx == 0) {
1234      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1235        << "a string type" << IdxExpr->getSourceRange();
1236      return;
1237    }
1238    ArgIdx--;
1239  }
1240
1241  // make sure the format string is really a string
1242  QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
1243
1244  if (Kind == CFStringFormat) {
1245    if (!isCFStringType(Ty, S.Context)) {
1246      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1247        << "a CFString" << IdxExpr->getSourceRange();
1248      return;
1249    }
1250  } else if (Kind == NSStringFormat) {
1251    // FIXME: do we need to check if the type is NSString*?  What are the
1252    // semantics?
1253    if (!isNSStringType(Ty, S.Context)) {
1254      // FIXME: Should highlight the actual expression that has the wrong type.
1255      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1256        << "an NSString" << IdxExpr->getSourceRange();
1257      return;
1258    }
1259  } else if (!Ty->isPointerType() ||
1260             !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
1261    // FIXME: Should highlight the actual expression that has the wrong type.
1262    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1263      << "a string type" << IdxExpr->getSourceRange();
1264    return;
1265  }
1266
1267  // check the 3rd argument
1268  Expr *FirstArgExpr = static_cast<Expr *>(Attr.getArg(1));
1269  llvm::APSInt FirstArg(32);
1270  if (!FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
1271    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1272      << "format" << 3 << FirstArgExpr->getSourceRange();
1273    return;
1274  }
1275
1276  // check if the function is variadic if the 3rd argument non-zero
1277  if (FirstArg != 0) {
1278    if (isFunctionOrMethodVariadic(d)) {
1279      ++NumArgs; // +1 for ...
1280    } else {
1281      S.Diag(d->getLocation(), diag::err_format_attribute_requires_variadic);
1282      return;
1283    }
1284  }
1285
1286  // strftime requires FirstArg to be 0 because it doesn't read from any
1287  // variable the input is just the current time + the format string.
1288  if (Kind == StrftimeFormat) {
1289    if (FirstArg != 0) {
1290      S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
1291        << FirstArgExpr->getSourceRange();
1292      return;
1293    }
1294  // if 0 it disables parameter checking (to use with e.g. va_list)
1295  } else if (FirstArg != 0 && FirstArg != NumArgs) {
1296    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1297      << "format" << 3 << FirstArgExpr->getSourceRange();
1298    return;
1299  }
1300
1301  d->addAttr(::new (S.Context) FormatAttr(S.Context, Format, Idx.getZExtValue(),
1302                                          FirstArg.getZExtValue()));
1303}
1304
1305static void HandleTransparentUnionAttr(Decl *d, const AttributeList &Attr,
1306                                       Sema &S) {
1307  // check the attribute arguments.
1308  if (Attr.getNumArgs() != 0) {
1309    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1310    return;
1311  }
1312
1313  // Try to find the underlying union declaration.
1314  RecordDecl *RD = 0;
1315  TypedefDecl *TD = dyn_cast<TypedefDecl>(d);
1316  if (TD && TD->getUnderlyingType()->isUnionType())
1317    RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
1318  else
1319    RD = dyn_cast<RecordDecl>(d);
1320
1321  if (!RD || !RD->isUnion()) {
1322    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1323      << Attr.getName() << 1 /*union*/;
1324    return;
1325  }
1326
1327  if (!RD->isDefinition()) {
1328    S.Diag(Attr.getLoc(),
1329        diag::warn_transparent_union_attribute_not_definition);
1330    return;
1331  }
1332
1333  RecordDecl::field_iterator Field = RD->field_begin(),
1334                          FieldEnd = RD->field_end();
1335  if (Field == FieldEnd) {
1336    S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
1337    return;
1338  }
1339
1340  FieldDecl *FirstField = *Field;
1341  QualType FirstType = FirstField->getType();
1342  if (FirstType->isFloatingType() || FirstType->isVectorType()) {
1343    S.Diag(FirstField->getLocation(),
1344           diag::warn_transparent_union_attribute_floating);
1345    return;
1346  }
1347
1348  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
1349  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
1350  for (; Field != FieldEnd; ++Field) {
1351    QualType FieldType = Field->getType();
1352    if (S.Context.getTypeSize(FieldType) != FirstSize ||
1353        S.Context.getTypeAlign(FieldType) != FirstAlign) {
1354      // Warn if we drop the attribute.
1355      bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
1356      unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
1357                                 : S.Context.getTypeAlign(FieldType);
1358      S.Diag(Field->getLocation(),
1359          diag::warn_transparent_union_attribute_field_size_align)
1360        << isSize << Field->getDeclName() << FieldBits;
1361      unsigned FirstBits = isSize? FirstSize : FirstAlign;
1362      S.Diag(FirstField->getLocation(),
1363             diag::note_transparent_union_first_field_size_align)
1364        << isSize << FirstBits;
1365      return;
1366    }
1367  }
1368
1369  RD->addAttr(::new (S.Context) TransparentUnionAttr());
1370}
1371
1372static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1373  // check the attribute arguments.
1374  if (Attr.getNumArgs() != 1) {
1375    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1376    return;
1377  }
1378  Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0));
1379  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
1380
1381  // Make sure that there is a string literal as the annotation's single
1382  // argument.
1383  if (!SE) {
1384    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
1385    return;
1386  }
1387  d->addAttr(::new (S.Context) AnnotateAttr(S.Context, SE->getString()));
1388}
1389
1390static void HandleAlignedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1391  // check the attribute arguments.
1392  if (Attr.getNumArgs() > 1) {
1393    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1394    return;
1395  }
1396
1397  //FIXME: The C++0x version of this attribute has more limited applicabilty
1398  //       than GNU's, and should error out when it is used to specify a
1399  //       weaker alignment, rather than being silently ignored.
1400
1401  unsigned Align = 0;
1402  if (Attr.getNumArgs() == 0) {
1403    // FIXME: This should be the target specific maximum alignment.
1404    // (For now we just use 128 bits which is the maximum on X86).
1405    Align = 128;
1406    d->addAttr(::new (S.Context) AlignedAttr(Align));
1407    return;
1408  }
1409
1410  Expr *alignmentExpr = static_cast<Expr *>(Attr.getArg(0));
1411  llvm::APSInt Alignment(32);
1412  if (!alignmentExpr->isIntegerConstantExpr(Alignment, S.Context)) {
1413    S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1414      << "aligned" << alignmentExpr->getSourceRange();
1415    return;
1416  }
1417  if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
1418    S.Diag(Attr.getLoc(), diag::err_attribute_aligned_not_power_of_two)
1419      << alignmentExpr->getSourceRange();
1420    return;
1421  }
1422
1423  d->addAttr(::new (S.Context) AlignedAttr(Alignment.getZExtValue() * 8));
1424}
1425
1426/// HandleModeAttr - This attribute modifies the width of a decl with primitive
1427/// type.
1428///
1429/// Despite what would be logical, the mode attribute is a decl attribute, not a
1430/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
1431/// HImode, not an intermediate pointer.
1432static void HandleModeAttr(Decl *D, const AttributeList &Attr, Sema &S) {
1433  // This attribute isn't documented, but glibc uses it.  It changes
1434  // the width of an int or unsigned int to the specified size.
1435
1436  // Check that there aren't any arguments
1437  if (Attr.getNumArgs() != 0) {
1438    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1439    return;
1440  }
1441
1442  IdentifierInfo *Name = Attr.getParameterName();
1443  if (!Name) {
1444    S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
1445    return;
1446  }
1447
1448  llvm::StringRef Str = Attr.getParameterName()->getName();
1449
1450  // Normalize the attribute name, __foo__ becomes foo.
1451  if (Str.startswith("__") && Str.endswith("__"))
1452    Str = Str.substr(2, Str.size() - 4);
1453
1454  unsigned DestWidth = 0;
1455  bool IntegerMode = true;
1456  bool ComplexMode = false;
1457  switch (Str.size()) {
1458  case 2:
1459    switch (Str[0]) {
1460    case 'Q': DestWidth = 8; break;
1461    case 'H': DestWidth = 16; break;
1462    case 'S': DestWidth = 32; break;
1463    case 'D': DestWidth = 64; break;
1464    case 'X': DestWidth = 96; break;
1465    case 'T': DestWidth = 128; break;
1466    }
1467    if (Str[1] == 'F') {
1468      IntegerMode = false;
1469    } else if (Str[1] == 'C') {
1470      IntegerMode = false;
1471      ComplexMode = true;
1472    } else if (Str[1] != 'I') {
1473      DestWidth = 0;
1474    }
1475    break;
1476  case 4:
1477    // FIXME: glibc uses 'word' to define register_t; this is narrower than a
1478    // pointer on PIC16 and other embedded platforms.
1479    if (Str == "word")
1480      DestWidth = S.Context.Target.getPointerWidth(0);
1481    else if (Str == "byte")
1482      DestWidth = S.Context.Target.getCharWidth();
1483    break;
1484  case 7:
1485    if (Str == "pointer")
1486      DestWidth = S.Context.Target.getPointerWidth(0);
1487    break;
1488  }
1489
1490  QualType OldTy;
1491  if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D))
1492    OldTy = TD->getUnderlyingType();
1493  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
1494    OldTy = VD->getType();
1495  else {
1496    S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
1497      << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc());
1498    return;
1499  }
1500
1501  if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
1502    S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
1503  else if (IntegerMode) {
1504    if (!OldTy->isIntegralType())
1505      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1506  } else if (ComplexMode) {
1507    if (!OldTy->isComplexType())
1508      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1509  } else {
1510    if (!OldTy->isFloatingType())
1511      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
1512  }
1513
1514  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
1515  // and friends, at least with glibc.
1516  // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
1517  // width on unusual platforms.
1518  // FIXME: Make sure floating-point mappings are accurate
1519  // FIXME: Support XF and TF types
1520  QualType NewTy;
1521  switch (DestWidth) {
1522  case 0:
1523    S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
1524    return;
1525  default:
1526    S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1527    return;
1528  case 8:
1529    if (!IntegerMode) {
1530      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1531      return;
1532    }
1533    if (OldTy->isSignedIntegerType())
1534      NewTy = S.Context.SignedCharTy;
1535    else
1536      NewTy = S.Context.UnsignedCharTy;
1537    break;
1538  case 16:
1539    if (!IntegerMode) {
1540      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1541      return;
1542    }
1543    if (OldTy->isSignedIntegerType())
1544      NewTy = S.Context.ShortTy;
1545    else
1546      NewTy = S.Context.UnsignedShortTy;
1547    break;
1548  case 32:
1549    if (!IntegerMode)
1550      NewTy = S.Context.FloatTy;
1551    else if (OldTy->isSignedIntegerType())
1552      NewTy = S.Context.IntTy;
1553    else
1554      NewTy = S.Context.UnsignedIntTy;
1555    break;
1556  case 64:
1557    if (!IntegerMode)
1558      NewTy = S.Context.DoubleTy;
1559    else if (OldTy->isSignedIntegerType())
1560      if (S.Context.Target.getLongWidth() == 64)
1561        NewTy = S.Context.LongTy;
1562      else
1563        NewTy = S.Context.LongLongTy;
1564    else
1565      if (S.Context.Target.getLongWidth() == 64)
1566        NewTy = S.Context.UnsignedLongTy;
1567      else
1568        NewTy = S.Context.UnsignedLongLongTy;
1569    break;
1570  case 96:
1571    NewTy = S.Context.LongDoubleTy;
1572    break;
1573  case 128:
1574    if (!IntegerMode) {
1575      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
1576      return;
1577    }
1578    if (OldTy->isSignedIntegerType())
1579      NewTy = S.Context.Int128Ty;
1580    else
1581      NewTy = S.Context.UnsignedInt128Ty;
1582    break;
1583  }
1584
1585  if (ComplexMode) {
1586    NewTy = S.Context.getComplexType(NewTy);
1587  }
1588
1589  // Install the new type.
1590  if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
1591    // FIXME: preserve existing source info.
1592    TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
1593  } else
1594    cast<ValueDecl>(D)->setType(NewTy);
1595}
1596
1597static void HandleNoDebugAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1598  // check the attribute arguments.
1599  if (Attr.getNumArgs() > 0) {
1600    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1601    return;
1602  }
1603
1604  if (!isFunctionOrMethod(d)) {
1605    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1606      << Attr.getName() << 0 /*function*/;
1607    return;
1608  }
1609
1610  d->addAttr(::new (S.Context) NoDebugAttr());
1611}
1612
1613static void HandleNoInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1614  // check the attribute arguments.
1615  if (Attr.getNumArgs() != 0) {
1616    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1617    return;
1618  }
1619
1620  if (!isa<FunctionDecl>(d)) {
1621    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1622    << Attr.getName() << 0 /*function*/;
1623    return;
1624  }
1625
1626  d->addAttr(::new (S.Context) NoInlineAttr());
1627}
1628
1629static void HandleGNUInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1630  // check the attribute arguments.
1631  if (Attr.getNumArgs() != 0) {
1632    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1633    return;
1634  }
1635
1636  FunctionDecl *Fn = dyn_cast<FunctionDecl>(d);
1637  if (Fn == 0) {
1638    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1639      << Attr.getName() << 0 /*function*/;
1640    return;
1641  }
1642
1643  if (!Fn->isInlineSpecified()) {
1644    S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
1645    return;
1646  }
1647
1648  d->addAttr(::new (S.Context) GNUInlineAttr());
1649}
1650
1651static void HandleRegparmAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1652  // check the attribute arguments.
1653  if (Attr.getNumArgs() != 1) {
1654    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1655    return;
1656  }
1657
1658  if (!isFunctionOrMethod(d)) {
1659    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1660    << Attr.getName() << 0 /*function*/;
1661    return;
1662  }
1663
1664  Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArg(0));
1665  llvm::APSInt NumParams(32);
1666  if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
1667    S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1668      << "regparm" << NumParamsExpr->getSourceRange();
1669    return;
1670  }
1671
1672  if (S.Context.Target.getRegParmMax() == 0) {
1673    S.Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
1674      << NumParamsExpr->getSourceRange();
1675    return;
1676  }
1677
1678  if (NumParams.getLimitedValue(255) > S.Context.Target.getRegParmMax()) {
1679    S.Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
1680      << S.Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange();
1681    return;
1682  }
1683
1684  d->addAttr(::new (S.Context) RegparmAttr(NumParams.getZExtValue()));
1685}
1686
1687static void HandleFinalAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1688  // check the attribute arguments.
1689  if (Attr.getNumArgs() != 0) {
1690    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1691    return;
1692  }
1693
1694  if (!isa<CXXRecordDecl>(d)
1695   && (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual())) {
1696    S.Diag(Attr.getLoc(),
1697           Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1698                                   : diag::warn_attribute_wrong_decl_type)
1699      << Attr.getName() << 7 /*virtual method or class*/;
1700    return;
1701  }
1702
1703  // FIXME: Conform to C++0x redeclaration rules.
1704
1705  if (d->getAttr<FinalAttr>()) {
1706    S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "final";
1707    return;
1708  }
1709
1710  d->addAttr(::new (S.Context) FinalAttr());
1711}
1712
1713//===----------------------------------------------------------------------===//
1714// C++0x member checking attributes
1715//===----------------------------------------------------------------------===//
1716
1717static void HandleBaseCheckAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1718  if (Attr.getNumArgs() != 0) {
1719    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1720    return;
1721  }
1722
1723  if (!isa<CXXRecordDecl>(d)) {
1724    S.Diag(Attr.getLoc(),
1725           Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1726                                   : diag::warn_attribute_wrong_decl_type)
1727      << Attr.getName() << 9 /*class*/;
1728    return;
1729  }
1730
1731  if (d->getAttr<BaseCheckAttr>()) {
1732    S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "base_check";
1733    return;
1734  }
1735
1736  d->addAttr(::new (S.Context) BaseCheckAttr());
1737}
1738
1739static void HandleHidingAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1740  if (Attr.getNumArgs() != 0) {
1741    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1742    return;
1743  }
1744
1745  if (!isa<RecordDecl>(d->getDeclContext())) {
1746    // FIXME: It's not the type that's the problem
1747    S.Diag(Attr.getLoc(),
1748           Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1749                                   : diag::warn_attribute_wrong_decl_type)
1750      << Attr.getName() << 11 /*member*/;
1751    return;
1752  }
1753
1754  // FIXME: Conform to C++0x redeclaration rules.
1755
1756  if (d->getAttr<HidingAttr>()) {
1757    S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "hiding";
1758    return;
1759  }
1760
1761  d->addAttr(::new (S.Context) HidingAttr());
1762}
1763
1764static void HandleOverrideAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1765  if (Attr.getNumArgs() != 0) {
1766    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1767    return;
1768  }
1769
1770  if (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual()) {
1771    // FIXME: It's not the type that's the problem
1772    S.Diag(Attr.getLoc(),
1773           Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1774                                   : diag::warn_attribute_wrong_decl_type)
1775      << Attr.getName() << 10 /*virtual method*/;
1776    return;
1777  }
1778
1779  // FIXME: Conform to C++0x redeclaration rules.
1780
1781  if (d->getAttr<OverrideAttr>()) {
1782    S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "override";
1783    return;
1784  }
1785
1786  d->addAttr(::new (S.Context) OverrideAttr());
1787}
1788
1789//===----------------------------------------------------------------------===//
1790// Checker-specific attribute handlers.
1791//===----------------------------------------------------------------------===//
1792
1793static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &Attr,
1794                                        Sema &S) {
1795
1796  QualType RetTy;
1797
1798  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d))
1799    RetTy = MD->getResultType();
1800  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d))
1801    RetTy = FD->getResultType();
1802  else {
1803    SourceLocation L = Attr.getLoc();
1804    S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type)
1805        << SourceRange(L, L) << Attr.getName() << 3 /* function or method */;
1806    return;
1807  }
1808
1809  if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAs<PointerType>()
1810        || RetTy->getAs<ObjCObjectPointerType>())) {
1811    SourceLocation L = Attr.getLoc();
1812    S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
1813      << SourceRange(L, L) << Attr.getName();
1814    return;
1815  }
1816
1817  switch (Attr.getKind()) {
1818    default:
1819      assert(0 && "invalid ownership attribute");
1820      return;
1821    case AttributeList::AT_cf_returns_not_retained:
1822      d->addAttr(::new (S.Context) CFReturnsNotRetainedAttr());
1823      return;
1824    case AttributeList::AT_ns_returns_not_retained:
1825      d->addAttr(::new (S.Context) NSReturnsNotRetainedAttr());
1826      return;
1827    case AttributeList::AT_cf_returns_retained:
1828      d->addAttr(::new (S.Context) CFReturnsRetainedAttr());
1829      return;
1830    case AttributeList::AT_ns_returns_retained:
1831      d->addAttr(::new (S.Context) NSReturnsRetainedAttr());
1832      return;
1833  };
1834}
1835
1836static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
1837  return Attr.getKind() == AttributeList::AT_dllimport ||
1838         Attr.getKind() == AttributeList::AT_dllexport;
1839}
1840
1841//===----------------------------------------------------------------------===//
1842// Top Level Sema Entry Points
1843//===----------------------------------------------------------------------===//
1844
1845/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
1846/// the attribute applies to decls.  If the attribute is a type attribute, just
1847/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
1848/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
1849static void ProcessDeclAttribute(Scope *scope, Decl *D,
1850                                 const AttributeList &Attr, Sema &S) {
1851  if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
1852    // FIXME: Try to deal with other __declspec attributes!
1853    return;
1854  switch (Attr.getKind()) {
1855  case AttributeList::AT_IBAction:            HandleIBAction(D, Attr, S); break;
1856  case AttributeList::AT_IBOutlet:            HandleIBOutlet(D, Attr, S); break;
1857  case AttributeList::AT_address_space:
1858  case AttributeList::AT_objc_gc:
1859  case AttributeList::AT_vector_size:
1860    // Ignore these, these are type attributes, handled by
1861    // ProcessTypeAttributes.
1862    break;
1863  case AttributeList::AT_alias:       HandleAliasAttr       (D, Attr, S); break;
1864  case AttributeList::AT_aligned:     HandleAlignedAttr     (D, Attr, S); break;
1865  case AttributeList::AT_always_inline:
1866    HandleAlwaysInlineAttr  (D, Attr, S); break;
1867  case AttributeList::AT_analyzer_noreturn:
1868    HandleAnalyzerNoReturnAttr  (D, Attr, S); break;
1869  case AttributeList::AT_annotate:    HandleAnnotateAttr    (D, Attr, S); break;
1870  case AttributeList::AT_base_check:  HandleBaseCheckAttr   (D, Attr, S); break;
1871  case AttributeList::AT_carries_dependency:
1872                                      HandleDependencyAttr  (D, Attr, S); break;
1873  case AttributeList::AT_constructor: HandleConstructorAttr (D, Attr, S); break;
1874  case AttributeList::AT_deprecated:  HandleDeprecatedAttr  (D, Attr, S); break;
1875  case AttributeList::AT_destructor:  HandleDestructorAttr  (D, Attr, S); break;
1876  case AttributeList::AT_ext_vector_type:
1877    HandleExtVectorTypeAttr(scope, D, Attr, S);
1878    break;
1879  case AttributeList::AT_final:       HandleFinalAttr       (D, Attr, S); break;
1880  case AttributeList::AT_format:      HandleFormatAttr      (D, Attr, S); break;
1881  case AttributeList::AT_format_arg:  HandleFormatArgAttr   (D, Attr, S); break;
1882  case AttributeList::AT_gnu_inline:  HandleGNUInlineAttr   (D, Attr, S); break;
1883  case AttributeList::AT_hiding:      HandleHidingAttr      (D, Attr, S); break;
1884  case AttributeList::AT_mode:        HandleModeAttr        (D, Attr, S); break;
1885  case AttributeList::AT_malloc:      HandleMallocAttr      (D, Attr, S); break;
1886  case AttributeList::AT_nonnull:     HandleNonNullAttr     (D, Attr, S); break;
1887  case AttributeList::AT_noreturn:    HandleNoReturnAttr    (D, Attr, S); break;
1888  case AttributeList::AT_nothrow:     HandleNothrowAttr     (D, Attr, S); break;
1889  case AttributeList::AT_override:    HandleOverrideAttr    (D, Attr, S); break;
1890
1891  // Checker-specific.
1892  case AttributeList::AT_ns_returns_not_retained:
1893  case AttributeList::AT_cf_returns_not_retained:
1894  case AttributeList::AT_ns_returns_retained:
1895  case AttributeList::AT_cf_returns_retained:
1896    HandleNSReturnsRetainedAttr(D, Attr, S); break;
1897
1898  case AttributeList::AT_reqd_wg_size:
1899    HandleReqdWorkGroupSize(D, Attr, S); break;
1900
1901  case AttributeList::AT_packed:      HandlePackedAttr      (D, Attr, S); break;
1902  case AttributeList::AT_section:     HandleSectionAttr     (D, Attr, S); break;
1903  case AttributeList::AT_unavailable: HandleUnavailableAttr (D, Attr, S); break;
1904  case AttributeList::AT_unused:      HandleUnusedAttr      (D, Attr, S); break;
1905  case AttributeList::AT_used:        HandleUsedAttr        (D, Attr, S); break;
1906  case AttributeList::AT_visibility:  HandleVisibilityAttr  (D, Attr, S); break;
1907  case AttributeList::AT_warn_unused_result: HandleWarnUnusedResult(D,Attr,S);
1908    break;
1909  case AttributeList::AT_weak:        HandleWeakAttr        (D, Attr, S); break;
1910  case AttributeList::AT_weakref:     HandleWeakRefAttr     (D, Attr, S); break;
1911  case AttributeList::AT_weak_import: HandleWeakImportAttr  (D, Attr, S); break;
1912  case AttributeList::AT_transparent_union:
1913    HandleTransparentUnionAttr(D, Attr, S);
1914    break;
1915  case AttributeList::AT_objc_exception:
1916    HandleObjCExceptionAttr(D, Attr, S);
1917    break;
1918  case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break;
1919  case AttributeList::AT_nsobject:    HandleObjCNSObject    (D, Attr, S); break;
1920  case AttributeList::AT_blocks:      HandleBlocksAttr      (D, Attr, S); break;
1921  case AttributeList::AT_sentinel:    HandleSentinelAttr    (D, Attr, S); break;
1922  case AttributeList::AT_const:       HandleConstAttr       (D, Attr, S); break;
1923  case AttributeList::AT_pure:        HandlePureAttr        (D, Attr, S); break;
1924  case AttributeList::AT_cleanup:     HandleCleanupAttr     (D, Attr, S); break;
1925  case AttributeList::AT_nodebug:     HandleNoDebugAttr     (D, Attr, S); break;
1926  case AttributeList::AT_noinline:    HandleNoInlineAttr    (D, Attr, S); break;
1927  case AttributeList::AT_regparm:     HandleRegparmAttr     (D, Attr, S); break;
1928  case AttributeList::IgnoredAttribute:
1929  case AttributeList::AT_no_instrument_function:  // Interacts with -pg.
1930    // Just ignore
1931    break;
1932  case AttributeList::AT_stdcall:
1933  case AttributeList::AT_cdecl:
1934  case AttributeList::AT_fastcall:
1935    // These are all treated as type attributes.
1936    break;
1937  default:
1938    // Ask target about the attribute.
1939    const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
1940    if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
1941      S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1942    break;
1943  }
1944}
1945
1946/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
1947/// attribute list to the specified decl, ignoring any type attributes.
1948void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList) {
1949  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
1950    ProcessDeclAttribute(S, D, *l, *this);
1951  }
1952
1953  // GCC accepts
1954  // static int a9 __attribute__((weakref));
1955  // but that looks really pointless. We reject it.
1956  if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
1957    Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
1958	dyn_cast<NamedDecl>(D)->getNameAsString();
1959    return;
1960  }
1961}
1962
1963/// DeclClonePragmaWeak - clone existing decl (maybe definition),
1964/// #pragma weak needs a non-definition decl and source may not have one
1965NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) {
1966  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
1967  NamedDecl *NewD = 0;
1968  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
1969    NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
1970                                FD->getLocation(), DeclarationName(II),
1971                                FD->getType(), FD->getTypeSourceInfo());
1972    if (FD->getQualifier()) {
1973      FunctionDecl *NewFD = cast<FunctionDecl>(NewD);
1974      NewFD->setQualifierInfo(FD->getQualifier(), FD->getQualifierRange());
1975    }
1976  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1977    NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
1978                           VD->getLocation(), II,
1979                           VD->getType(), VD->getTypeSourceInfo(),
1980                           VD->getStorageClass());
1981    if (VD->getQualifier()) {
1982      VarDecl *NewVD = cast<VarDecl>(NewD);
1983      NewVD->setQualifierInfo(VD->getQualifier(), VD->getQualifierRange());
1984    }
1985  }
1986  return NewD;
1987}
1988
1989/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
1990/// applied to it, possibly with an alias.
1991void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
1992  if (W.getUsed()) return; // only do this once
1993  W.setUsed(true);
1994  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
1995    IdentifierInfo *NDId = ND->getIdentifier();
1996    NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias());
1997    NewD->addAttr(::new (Context) AliasAttr(Context, NDId->getName()));
1998    NewD->addAttr(::new (Context) WeakAttr());
1999    WeakTopLevelDecl.push_back(NewD);
2000    // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
2001    // to insert Decl at TU scope, sorry.
2002    DeclContext *SavedContext = CurContext;
2003    CurContext = Context.getTranslationUnitDecl();
2004    PushOnScopeChains(NewD, S);
2005    CurContext = SavedContext;
2006  } else { // just add weak to existing
2007    ND->addAttr(::new (Context) WeakAttr());
2008  }
2009}
2010
2011/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
2012/// it, apply them to D.  This is a bit tricky because PD can have attributes
2013/// specified in many different places, and we need to find and apply them all.
2014void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
2015  // Handle #pragma weak
2016  if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
2017    if (ND->hasLinkage()) {
2018      WeakInfo W = WeakUndeclaredIdentifiers.lookup(ND->getIdentifier());
2019      if (W != WeakInfo()) {
2020        // Identifier referenced by #pragma weak before it was declared
2021        DeclApplyPragmaWeak(S, ND, W);
2022        WeakUndeclaredIdentifiers[ND->getIdentifier()] = W;
2023      }
2024    }
2025  }
2026
2027  // Apply decl attributes from the DeclSpec if present.
2028  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes())
2029    ProcessDeclAttributeList(S, D, Attrs);
2030
2031  // Walk the declarator structure, applying decl attributes that were in a type
2032  // position to the decl itself.  This handles cases like:
2033  //   int *__attr__(x)** D;
2034  // when X is a decl attribute.
2035  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
2036    if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
2037      ProcessDeclAttributeList(S, D, Attrs);
2038
2039  // Finally, apply any attributes on the decl itself.
2040  if (const AttributeList *Attrs = PD.getAttributes())
2041    ProcessDeclAttributeList(S, D, Attrs);
2042}
2043
2044/// PushParsingDeclaration - Enter a new "scope" of deprecation
2045/// warnings.
2046///
2047/// The state token we use is the start index of this scope
2048/// on the warning stack.
2049Action::ParsingDeclStackState Sema::PushParsingDeclaration() {
2050  ParsingDeclDepth++;
2051  return (ParsingDeclStackState) DelayedDiagnostics.size();
2052}
2053
2054void Sema::PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy Ctx) {
2055  assert(ParsingDeclDepth > 0 && "empty ParsingDeclaration stack");
2056  ParsingDeclDepth--;
2057
2058  if (DelayedDiagnostics.empty())
2059    return;
2060
2061  unsigned SavedIndex = (unsigned) S;
2062  assert(SavedIndex <= DelayedDiagnostics.size() &&
2063         "saved index is out of bounds");
2064
2065  unsigned E = DelayedDiagnostics.size();
2066
2067  // We only want to actually emit delayed diagnostics when we
2068  // successfully parsed a decl.
2069  Decl *D = Ctx ? Ctx.getAs<Decl>() : 0;
2070  if (D) {
2071    // We really do want to start with 0 here.  We get one push for a
2072    // decl spec and another for each declarator;  in a decl group like:
2073    //   deprecated_typedef foo, *bar, baz();
2074    // only the declarator pops will be passed decls.  This is correct;
2075    // we really do need to consider delayed diagnostics from the decl spec
2076    // for each of the different declarations.
2077    for (unsigned I = 0; I != E; ++I) {
2078      if (DelayedDiagnostics[I].Triggered)
2079        continue;
2080
2081      switch (DelayedDiagnostics[I].Kind) {
2082      case DelayedDiagnostic::Deprecation:
2083        HandleDelayedDeprecationCheck(DelayedDiagnostics[I], D);
2084        break;
2085
2086      case DelayedDiagnostic::Access:
2087        HandleDelayedAccessCheck(DelayedDiagnostics[I], D);
2088        break;
2089      }
2090    }
2091  }
2092
2093  // Destroy all the delayed diagnostics we're about to pop off.
2094  for (unsigned I = SavedIndex; I != E; ++I)
2095    DelayedDiagnostics[I].destroy();
2096
2097  DelayedDiagnostics.set_size(SavedIndex);
2098}
2099
2100static bool isDeclDeprecated(Decl *D) {
2101  do {
2102    if (D->hasAttr<DeprecatedAttr>())
2103      return true;
2104  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
2105  return false;
2106}
2107
2108void Sema::HandleDelayedDeprecationCheck(Sema::DelayedDiagnostic &DD,
2109                                         Decl *Ctx) {
2110  if (isDeclDeprecated(Ctx))
2111    return;
2112
2113  DD.Triggered = true;
2114  Diag(DD.Loc, diag::warn_deprecated)
2115    << DD.DeprecationData.Decl->getDeclName();
2116}
2117
2118void Sema::EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc) {
2119  // Delay if we're currently parsing a declaration.
2120  if (ParsingDeclDepth) {
2121    DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D));
2122    return;
2123  }
2124
2125  // Otherwise, don't warn if our current context is deprecated.
2126  if (isDeclDeprecated(cast<Decl>(CurContext)))
2127    return;
2128
2129  Diag(Loc, diag::warn_deprecated) << D->getDeclName();
2130}
2131