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