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