SemaDeclAttr.cpp revision 13c7fcceb9fd96f5be03af038ce16b05bb5e9598 
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::err_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::err_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 handleAvailabilityAttr(Sema &S, Decl *D,
1583                                   const AttributeList &Attr) {
1584  IdentifierInfo *Platform = Attr.getParameterName();
1585  SourceLocation PlatformLoc = Attr.getParameterLoc();
1586
1587  StringRef PlatformName
1588    = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1589  if (PlatformName.empty()) {
1590    S.Diag(PlatformLoc, diag::warn_availability_unknown_platform)
1591      << Platform;
1592
1593    PlatformName = Platform->getName();
1594  }
1595
1596  AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1597  AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1598  AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
1599  bool IsUnavailable = Attr.getUnavailableLoc().isValid();
1600
1601  // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
1602  // of these steps are needed).
1603  if (Introduced.isValid() && Deprecated.isValid() &&
1604      !(Introduced.Version <= Deprecated.Version)) {
1605    S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1606      << 1 << PlatformName << Deprecated.Version.getAsString()
1607      << 0 << Introduced.Version.getAsString();
1608    return;
1609  }
1610
1611  if (Introduced.isValid() && Obsoleted.isValid() &&
1612      !(Introduced.Version <= Obsoleted.Version)) {
1613    S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1614      << 2 << PlatformName << Obsoleted.Version.getAsString()
1615      << 0 << Introduced.Version.getAsString();
1616    return;
1617  }
1618
1619  if (Deprecated.isValid() && Obsoleted.isValid() &&
1620      !(Deprecated.Version <= Obsoleted.Version)) {
1621    S.Diag(Deprecated.KeywordLoc, diag::warn_availability_version_ordering)
1622      << 2 << PlatformName << Obsoleted.Version.getAsString()
1623      << 1 << Deprecated.Version.getAsString();
1624    return;
1625  }
1626
1627  D->addAttr(::new (S.Context) AvailabilityAttr(Attr.getRange(), S.Context,
1628                                                Platform,
1629                                                Introduced.Version,
1630                                                Deprecated.Version,
1631                                                Obsoleted.Version,
1632                                                IsUnavailable));
1633}
1634
1635static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1636  // check the attribute arguments.
1637  if(!checkAttributeNumArgs(S, Attr, 1))
1638    return;
1639
1640  Expr *Arg = Attr.getArg(0);
1641  Arg = Arg->IgnoreParenCasts();
1642  StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1643
1644  if (!Str || !Str->isAscii()) {
1645    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1646      << "visibility" << 1;
1647    return;
1648  }
1649
1650  StringRef TypeStr = Str->getString();
1651  VisibilityAttr::VisibilityType type;
1652
1653  if (TypeStr == "default")
1654    type = VisibilityAttr::Default;
1655  else if (TypeStr == "hidden")
1656    type = VisibilityAttr::Hidden;
1657  else if (TypeStr == "internal")
1658    type = VisibilityAttr::Hidden; // FIXME
1659  else if (TypeStr == "protected")
1660    type = VisibilityAttr::Protected;
1661  else {
1662    S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
1663    return;
1664  }
1665
1666  D->addAttr(::new (S.Context) VisibilityAttr(Attr.getRange(), S.Context, type));
1667}
1668
1669static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
1670                                       const AttributeList &Attr) {
1671  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl);
1672  if (!method) {
1673    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1674      << ExpectedMethod;
1675    return;
1676  }
1677
1678  if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) {
1679    if (!Attr.getParameterName() && Attr.getNumArgs() == 1) {
1680      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1681        << "objc_method_family" << 1;
1682    } else {
1683      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1684    }
1685    Attr.setInvalid();
1686    return;
1687  }
1688
1689  StringRef param = Attr.getParameterName()->getName();
1690  ObjCMethodFamilyAttr::FamilyKind family;
1691  if (param == "none")
1692    family = ObjCMethodFamilyAttr::OMF_None;
1693  else if (param == "alloc")
1694    family = ObjCMethodFamilyAttr::OMF_alloc;
1695  else if (param == "copy")
1696    family = ObjCMethodFamilyAttr::OMF_copy;
1697  else if (param == "init")
1698    family = ObjCMethodFamilyAttr::OMF_init;
1699  else if (param == "mutableCopy")
1700    family = ObjCMethodFamilyAttr::OMF_mutableCopy;
1701  else if (param == "new")
1702    family = ObjCMethodFamilyAttr::OMF_new;
1703  else {
1704    // Just warn and ignore it.  This is future-proof against new
1705    // families being used in system headers.
1706    S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family);
1707    return;
1708  }
1709
1710  if (family == ObjCMethodFamilyAttr::OMF_init &&
1711      !method->getResultType()->isObjCObjectPointerType()) {
1712    S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
1713      << method->getResultType();
1714    // Ignore the attribute.
1715    return;
1716  }
1717
1718  method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
1719                                                       S.Context, family));
1720}
1721
1722static void handleObjCExceptionAttr(Sema &S, Decl *D,
1723                                    const AttributeList &Attr) {
1724  if (!checkAttributeNumArgs(S, Attr, 0))
1725    return;
1726
1727  ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
1728  if (OCI == 0) {
1729    S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1730    return;
1731  }
1732
1733  D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getRange(), S.Context));
1734}
1735
1736static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
1737  if (Attr.getNumArgs() != 0) {
1738    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1739    return;
1740  }
1741  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1742    QualType T = TD->getUnderlyingType();
1743    if (!T->isPointerType() ||
1744        !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
1745      S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
1746      return;
1747    }
1748  }
1749  D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getRange(), S.Context));
1750}
1751
1752static void
1753handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1754  if (Attr.getNumArgs() != 0) {
1755    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1756    return;
1757  }
1758
1759  if (!isa<FunctionDecl>(D)) {
1760    S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
1761    return;
1762  }
1763
1764  D->addAttr(::new (S.Context) OverloadableAttr(Attr.getRange(), S.Context));
1765}
1766
1767static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1768  if (!Attr.getParameterName()) {
1769    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1770      << "blocks" << 1;
1771    return;
1772  }
1773
1774  if (Attr.getNumArgs() != 0) {
1775    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1776    return;
1777  }
1778
1779  BlocksAttr::BlockType type;
1780  if (Attr.getParameterName()->isStr("byref"))
1781    type = BlocksAttr::ByRef;
1782  else {
1783    S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1784      << "blocks" << Attr.getParameterName();
1785    return;
1786  }
1787
1788  D->addAttr(::new (S.Context) BlocksAttr(Attr.getRange(), S.Context, type));
1789}
1790
1791static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1792  // check the attribute arguments.
1793  if (Attr.getNumArgs() > 2) {
1794    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
1795    return;
1796  }
1797
1798  unsigned sentinel = 0;
1799  if (Attr.getNumArgs() > 0) {
1800    Expr *E = Attr.getArg(0);
1801    llvm::APSInt Idx(32);
1802    if (E->isTypeDependent() || E->isValueDependent() ||
1803        !E->isIntegerConstantExpr(Idx, S.Context)) {
1804      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1805       << "sentinel" << 1 << E->getSourceRange();
1806      return;
1807    }
1808
1809    if (Idx.isSigned() && Idx.isNegative()) {
1810      S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
1811        << E->getSourceRange();
1812      return;
1813    }
1814
1815    sentinel = Idx.getZExtValue();
1816  }
1817
1818  unsigned nullPos = 0;
1819  if (Attr.getNumArgs() > 1) {
1820    Expr *E = Attr.getArg(1);
1821    llvm::APSInt Idx(32);
1822    if (E->isTypeDependent() || E->isValueDependent() ||
1823        !E->isIntegerConstantExpr(Idx, S.Context)) {
1824      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1825        << "sentinel" << 2 << E->getSourceRange();
1826      return;
1827    }
1828    nullPos = Idx.getZExtValue();
1829
1830    if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
1831      // FIXME: This error message could be improved, it would be nice
1832      // to say what the bounds actually are.
1833      S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
1834        << E->getSourceRange();
1835      return;
1836    }
1837  }
1838
1839  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1840    const FunctionType *FT = FD->getType()->castAs<FunctionType>();
1841    if (isa<FunctionNoProtoType>(FT)) {
1842      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
1843      return;
1844    }
1845
1846    if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1847      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1848      return;
1849    }
1850  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
1851    if (!MD->isVariadic()) {
1852      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1853      return;
1854    }
1855  } else if (isa<BlockDecl>(D)) {
1856    // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the
1857    // caller.
1858    ;
1859  } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
1860    QualType Ty = V->getType();
1861    if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
1862      const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D)
1863       : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
1864      if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1865        int m = Ty->isFunctionPointerType() ? 0 : 1;
1866        S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
1867        return;
1868      }
1869    } else {
1870      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1871        << Attr.getName() << ExpectedFunctionMethodOrBlock;
1872      return;
1873    }
1874  } else {
1875    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1876      << Attr.getName() << ExpectedFunctionMethodOrBlock;
1877    return;
1878  }
1879  D->addAttr(::new (S.Context) SentinelAttr(Attr.getRange(), S.Context, sentinel,
1880                                            nullPos));
1881}
1882
1883static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
1884  // check the attribute arguments.
1885  if (!checkAttributeNumArgs(S, Attr, 0))
1886    return;
1887
1888  if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
1889    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1890      << Attr.getName() << ExpectedFunctionOrMethod;
1891    return;
1892  }
1893
1894  if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
1895    S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1896      << Attr.getName() << 0;
1897    return;
1898  }
1899  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
1900    if (MD->getResultType()->isVoidType()) {
1901      S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1902      << Attr.getName() << 1;
1903      return;
1904    }
1905
1906  D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getRange(), S.Context));
1907}
1908
1909static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1910  // check the attribute arguments.
1911  if (Attr.hasParameterOrArguments()) {
1912    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1913    return;
1914  }
1915
1916  if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
1917    if (isa<CXXRecordDecl>(D)) {
1918      D->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
1919      return;
1920    }
1921    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1922      << Attr.getName() << ExpectedVariableOrFunction;
1923    return;
1924  }
1925
1926  NamedDecl *nd = cast<NamedDecl>(D);
1927
1928  // 'weak' only applies to declarations with external linkage.
1929  if (hasEffectivelyInternalLinkage(nd)) {
1930    S.Diag(Attr.getLoc(), diag::err_attribute_weak_static);
1931    return;
1932  }
1933
1934  nd->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
1935}
1936
1937static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1938  // check the attribute arguments.
1939  if (!checkAttributeNumArgs(S, Attr, 0))
1940    return;
1941
1942
1943  // weak_import only applies to variable & function declarations.
1944  bool isDef = false;
1945  if (!D->canBeWeakImported(isDef)) {
1946    if (isDef)
1947      S.Diag(Attr.getLoc(),
1948             diag::warn_attribute_weak_import_invalid_on_definition)
1949        << "weak_import" << 2 /*variable and function*/;
1950    else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
1951             (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
1952              isa<ObjCInterfaceDecl>(D))) {
1953      // Nothing to warn about here.
1954    } else
1955      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1956        << Attr.getName() << ExpectedVariableOrFunction;
1957
1958    return;
1959  }
1960
1961  D->addAttr(::new (S.Context) WeakImportAttr(Attr.getRange(), S.Context));
1962}
1963
1964static void handleReqdWorkGroupSize(Sema &S, Decl *D,
1965                                    const AttributeList &Attr) {
1966  // Attribute has 3 arguments.
1967  if (!checkAttributeNumArgs(S, Attr, 3))
1968    return;
1969
1970  unsigned WGSize[3];
1971  for (unsigned i = 0; i < 3; ++i) {
1972    Expr *E = Attr.getArg(i);
1973    llvm::APSInt ArgNum(32);
1974    if (E->isTypeDependent() || E->isValueDependent() ||
1975        !E->isIntegerConstantExpr(ArgNum, S.Context)) {
1976      S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1977        << "reqd_work_group_size" << E->getSourceRange();
1978      return;
1979    }
1980    WGSize[i] = (unsigned) ArgNum.getZExtValue();
1981  }
1982  D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getRange(), S.Context,
1983                                                     WGSize[0], WGSize[1],
1984                                                     WGSize[2]));
1985}
1986
1987static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1988  // Attribute has no arguments.
1989  if (!checkAttributeNumArgs(S, Attr, 1))
1990    return;
1991
1992  // Make sure that there is a string literal as the sections's single
1993  // argument.
1994  Expr *ArgExpr = Attr.getArg(0);
1995  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
1996  if (!SE) {
1997    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
1998    return;
1999  }
2000
2001  // If the target wants to validate the section specifier, make it happen.
2002  std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(SE->getString());
2003  if (!Error.empty()) {
2004    S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
2005    << Error;
2006    return;
2007  }
2008
2009  // This attribute cannot be applied to local variables.
2010  if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
2011    S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
2012    return;
2013  }
2014
2015  D->addAttr(::new (S.Context) SectionAttr(Attr.getRange(), S.Context,
2016                                           SE->getString()));
2017}
2018
2019
2020static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2021  // check the attribute arguments.
2022  if (Attr.hasParameterOrArguments()) {
2023    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2024    return;
2025  }
2026
2027  if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) {
2028    if (Existing->getLocation().isInvalid())
2029      Existing->setRange(Attr.getRange());
2030  } else {
2031    D->addAttr(::new (S.Context) NoThrowAttr(Attr.getRange(), S.Context));
2032  }
2033}
2034
2035static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2036  // check the attribute arguments.
2037  if (Attr.hasParameterOrArguments()) {
2038    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2039    return;
2040  }
2041
2042  if (ConstAttr *Existing = D->getAttr<ConstAttr>()) {
2043   if (Existing->getLocation().isInvalid())
2044     Existing->setRange(Attr.getRange());
2045  } else {
2046    D->addAttr(::new (S.Context) ConstAttr(Attr.getRange(), S.Context));
2047  }
2048}
2049
2050static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2051  // check the attribute arguments.
2052  if (!checkAttributeNumArgs(S, Attr, 0))
2053    return;
2054
2055  D->addAttr(::new (S.Context) PureAttr(Attr.getRange(), S.Context));
2056}
2057
2058static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2059  if (!Attr.getParameterName()) {
2060    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2061    return;
2062  }
2063
2064  if (Attr.getNumArgs() != 0) {
2065    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2066    return;
2067  }
2068
2069  VarDecl *VD = dyn_cast<VarDecl>(D);
2070
2071  if (!VD || !VD->hasLocalStorage()) {
2072    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
2073    return;
2074  }
2075
2076  // Look up the function
2077  // FIXME: Lookup probably isn't looking in the right place
2078  NamedDecl *CleanupDecl
2079    = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
2080                         Attr.getParameterLoc(), Sema::LookupOrdinaryName);
2081  if (!CleanupDecl) {
2082    S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
2083      Attr.getParameterName();
2084    return;
2085  }
2086
2087  FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
2088  if (!FD) {
2089    S.Diag(Attr.getParameterLoc(),
2090           diag::err_attribute_cleanup_arg_not_function)
2091      << Attr.getParameterName();
2092    return;
2093  }
2094
2095  if (FD->getNumParams() != 1) {
2096    S.Diag(Attr.getParameterLoc(),
2097           diag::err_attribute_cleanup_func_must_take_one_arg)
2098      << Attr.getParameterName();
2099    return;
2100  }
2101
2102  // We're currently more strict than GCC about what function types we accept.
2103  // If this ever proves to be a problem it should be easy to fix.
2104  QualType Ty = S.Context.getPointerType(VD->getType());
2105  QualType ParamTy = FD->getParamDecl(0)->getType();
2106  if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
2107                                   ParamTy, Ty) != Sema::Compatible) {
2108    S.Diag(Attr.getParameterLoc(),
2109           diag::err_attribute_cleanup_func_arg_incompatible_type) <<
2110      Attr.getParameterName() << ParamTy << Ty;
2111    return;
2112  }
2113
2114  D->addAttr(::new (S.Context) CleanupAttr(Attr.getRange(), S.Context, FD));
2115  S.MarkDeclarationReferenced(Attr.getParameterLoc(), FD);
2116}
2117
2118/// Handle __attribute__((format_arg((idx)))) attribute based on
2119/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2120static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2121  if (!checkAttributeNumArgs(S, Attr, 1))
2122    return;
2123
2124  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
2125    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2126      << Attr.getName() << ExpectedFunction;
2127    return;
2128  }
2129
2130  // In C++ the implicit 'this' function parameter also counts, and they are
2131  // counted from one.
2132  bool HasImplicitThisParam = isInstanceMethod(D);
2133  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
2134  unsigned FirstIdx = 1;
2135
2136  // checks for the 2nd argument
2137  Expr *IdxExpr = Attr.getArg(0);
2138  llvm::APSInt Idx(32);
2139  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2140      !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
2141    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2142    << "format" << 2 << IdxExpr->getSourceRange();
2143    return;
2144  }
2145
2146  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
2147    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2148    << "format" << 2 << IdxExpr->getSourceRange();
2149    return;
2150  }
2151
2152  unsigned ArgIdx = Idx.getZExtValue() - 1;
2153
2154  if (HasImplicitThisParam) {
2155    if (ArgIdx == 0) {
2156      S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
2157        << "format_arg" << IdxExpr->getSourceRange();
2158      return;
2159    }
2160    ArgIdx--;
2161  }
2162
2163  // make sure the format string is really a string
2164  QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
2165
2166  bool not_nsstring_type = !isNSStringType(Ty, S.Context);
2167  if (not_nsstring_type &&
2168      !isCFStringType(Ty, S.Context) &&
2169      (!Ty->isPointerType() ||
2170       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2171    // FIXME: Should highlight the actual expression that has the wrong type.
2172    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2173    << (not_nsstring_type ? "a string type" : "an NSString")
2174       << IdxExpr->getSourceRange();
2175    return;
2176  }
2177  Ty = getFunctionOrMethodResultType(D);
2178  if (!isNSStringType(Ty, S.Context) &&
2179      !isCFStringType(Ty, S.Context) &&
2180      (!Ty->isPointerType() ||
2181       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
2182    // FIXME: Should highlight the actual expression that has the wrong type.
2183    S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
2184    << (not_nsstring_type ? "string type" : "NSString")
2185       << IdxExpr->getSourceRange();
2186    return;
2187  }
2188
2189  D->addAttr(::new (S.Context) FormatArgAttr(Attr.getRange(), S.Context,
2190                                             Idx.getZExtValue()));
2191}
2192
2193enum FormatAttrKind {
2194  CFStringFormat,
2195  NSStringFormat,
2196  StrftimeFormat,
2197  SupportedFormat,
2198  IgnoredFormat,
2199  InvalidFormat
2200};
2201
2202/// getFormatAttrKind - Map from format attribute names to supported format
2203/// types.
2204static FormatAttrKind getFormatAttrKind(StringRef Format) {
2205  // Check for formats that get handled specially.
2206  if (Format == "NSString")
2207    return NSStringFormat;
2208  if (Format == "CFString")
2209    return CFStringFormat;
2210  if (Format == "strftime")
2211    return StrftimeFormat;
2212
2213  // Otherwise, check for supported formats.
2214  if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
2215      Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
2216      Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
2217      Format == "zcmn_err" ||
2218      Format == "kprintf")  // OpenBSD.
2219    return SupportedFormat;
2220
2221  if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
2222      Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
2223    return IgnoredFormat;
2224
2225  return InvalidFormat;
2226}
2227
2228/// Handle __attribute__((init_priority(priority))) attributes based on
2229/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
2230static void handleInitPriorityAttr(Sema &S, Decl *D,
2231                                   const AttributeList &Attr) {
2232  if (!S.getLangOptions().CPlusPlus) {
2233    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2234    return;
2235  }
2236
2237  if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) {
2238    S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2239    Attr.setInvalid();
2240    return;
2241  }
2242  QualType T = dyn_cast<VarDecl>(D)->getType();
2243  if (S.Context.getAsArrayType(T))
2244    T = S.Context.getBaseElementType(T);
2245  if (!T->getAs<RecordType>()) {
2246    S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2247    Attr.setInvalid();
2248    return;
2249  }
2250
2251  if (Attr.getNumArgs() != 1) {
2252    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2253    Attr.setInvalid();
2254    return;
2255  }
2256  Expr *priorityExpr = Attr.getArg(0);
2257
2258  llvm::APSInt priority(32);
2259  if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
2260      !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
2261    S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2262    << "init_priority" << priorityExpr->getSourceRange();
2263    Attr.setInvalid();
2264    return;
2265  }
2266  unsigned prioritynum = priority.getZExtValue();
2267  if (prioritynum < 101 || prioritynum > 65535) {
2268    S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
2269    <<  priorityExpr->getSourceRange();
2270    Attr.setInvalid();
2271    return;
2272  }
2273  D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getRange(), S.Context,
2274                                                prioritynum));
2275}
2276
2277/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
2278/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
2279static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2280
2281  if (!Attr.getParameterName()) {
2282    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2283      << "format" << 1;
2284    return;
2285  }
2286
2287  if (Attr.getNumArgs() != 2) {
2288    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
2289    return;
2290  }
2291
2292  if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) {
2293    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2294      << Attr.getName() << ExpectedFunction;
2295    return;
2296  }
2297
2298  // In C++ the implicit 'this' function parameter also counts, and they are
2299  // counted from one.
2300  bool HasImplicitThisParam = isInstanceMethod(D);
2301  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
2302  unsigned FirstIdx = 1;
2303
2304  StringRef Format = Attr.getParameterName()->getName();
2305
2306  // Normalize the argument, __foo__ becomes foo.
2307  if (Format.startswith("__") && Format.endswith("__"))
2308    Format = Format.substr(2, Format.size() - 4);
2309
2310  // Check for supported formats.
2311  FormatAttrKind Kind = getFormatAttrKind(Format);
2312
2313  if (Kind == IgnoredFormat)
2314    return;
2315
2316  if (Kind == InvalidFormat) {
2317    S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2318      << "format" << Attr.getParameterName()->getName();
2319    return;
2320  }
2321
2322  // checks for the 2nd argument
2323  Expr *IdxExpr = Attr.getArg(0);
2324  llvm::APSInt Idx(32);
2325  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2326      !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
2327    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2328      << "format" << 2 << IdxExpr->getSourceRange();
2329    return;
2330  }
2331
2332  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
2333    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2334      << "format" << 2 << IdxExpr->getSourceRange();
2335    return;
2336  }
2337
2338  // FIXME: Do we need to bounds check?
2339  unsigned ArgIdx = Idx.getZExtValue() - 1;
2340
2341  if (HasImplicitThisParam) {
2342    if (ArgIdx == 0) {
2343      S.Diag(Attr.getLoc(),
2344             diag::err_format_attribute_implicit_this_format_string)
2345        << IdxExpr->getSourceRange();
2346      return;
2347    }
2348    ArgIdx--;
2349  }
2350
2351  // make sure the format string is really a string
2352  QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
2353
2354  if (Kind == CFStringFormat) {
2355    if (!isCFStringType(Ty, S.Context)) {
2356      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2357        << "a CFString" << IdxExpr->getSourceRange();
2358      return;
2359    }
2360  } else if (Kind == NSStringFormat) {
2361    // FIXME: do we need to check if the type is NSString*?  What are the
2362    // semantics?
2363    if (!isNSStringType(Ty, S.Context)) {
2364      // FIXME: Should highlight the actual expression that has the wrong type.
2365      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2366        << "an NSString" << IdxExpr->getSourceRange();
2367      return;
2368    }
2369  } else if (!Ty->isPointerType() ||
2370             !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
2371    // FIXME: Should highlight the actual expression that has the wrong type.
2372    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2373      << "a string type" << IdxExpr->getSourceRange();
2374    return;
2375  }
2376
2377  // check the 3rd argument
2378  Expr *FirstArgExpr = Attr.getArg(1);
2379  llvm::APSInt FirstArg(32);
2380  if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
2381      !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
2382    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2383      << "format" << 3 << FirstArgExpr->getSourceRange();
2384    return;
2385  }
2386
2387  // check if the function is variadic if the 3rd argument non-zero
2388  if (FirstArg != 0) {
2389    if (isFunctionOrMethodVariadic(D)) {
2390      ++NumArgs; // +1 for ...
2391    } else {
2392      S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
2393      return;
2394    }
2395  }
2396
2397  // strftime requires FirstArg to be 0 because it doesn't read from any
2398  // variable the input is just the current time + the format string.
2399  if (Kind == StrftimeFormat) {
2400    if (FirstArg != 0) {
2401      S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
2402        << FirstArgExpr->getSourceRange();
2403      return;
2404    }
2405  // if 0 it disables parameter checking (to use with e.g. va_list)
2406  } else if (FirstArg != 0 && FirstArg != NumArgs) {
2407    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2408      << "format" << 3 << FirstArgExpr->getSourceRange();
2409    return;
2410  }
2411
2412  // Check whether we already have an equivalent format attribute.
2413  for (specific_attr_iterator<FormatAttr>
2414         i = D->specific_attr_begin<FormatAttr>(),
2415         e = D->specific_attr_end<FormatAttr>();
2416       i != e ; ++i) {
2417    FormatAttr *f = *i;
2418    if (f->getType() == Format &&
2419        f->getFormatIdx() == (int)Idx.getZExtValue() &&
2420        f->getFirstArg() == (int)FirstArg.getZExtValue()) {
2421      // If we don't have a valid location for this attribute, adopt the
2422      // location.
2423      if (f->getLocation().isInvalid())
2424        f->setRange(Attr.getRange());
2425      return;
2426    }
2427  }
2428
2429  D->addAttr(::new (S.Context) FormatAttr(Attr.getRange(), S.Context, Format,
2430                                          Idx.getZExtValue(),
2431                                          FirstArg.getZExtValue()));
2432}
2433
2434static void handleTransparentUnionAttr(Sema &S, Decl *D,
2435                                       const AttributeList &Attr) {
2436  // check the attribute arguments.
2437  if (!checkAttributeNumArgs(S, Attr, 0))
2438    return;
2439
2440
2441  // Try to find the underlying union declaration.
2442  RecordDecl *RD = 0;
2443  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
2444  if (TD && TD->getUnderlyingType()->isUnionType())
2445    RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
2446  else
2447    RD = dyn_cast<RecordDecl>(D);
2448
2449  if (!RD || !RD->isUnion()) {
2450    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2451      << Attr.getName() << ExpectedUnion;
2452    return;
2453  }
2454
2455  if (!RD->isCompleteDefinition()) {
2456    S.Diag(Attr.getLoc(),
2457        diag::warn_transparent_union_attribute_not_definition);
2458    return;
2459  }
2460
2461  RecordDecl::field_iterator Field = RD->field_begin(),
2462                          FieldEnd = RD->field_end();
2463  if (Field == FieldEnd) {
2464    S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
2465    return;
2466  }
2467
2468  FieldDecl *FirstField = *Field;
2469  QualType FirstType = FirstField->getType();
2470  if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
2471    S.Diag(FirstField->getLocation(),
2472           diag::warn_transparent_union_attribute_floating)
2473      << FirstType->isVectorType() << FirstType;
2474    return;
2475  }
2476
2477  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
2478  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
2479  for (; Field != FieldEnd; ++Field) {
2480    QualType FieldType = Field->getType();
2481    if (S.Context.getTypeSize(FieldType) != FirstSize ||
2482        S.Context.getTypeAlign(FieldType) != FirstAlign) {
2483      // Warn if we drop the attribute.
2484      bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
2485      unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
2486                                 : S.Context.getTypeAlign(FieldType);
2487      S.Diag(Field->getLocation(),
2488          diag::warn_transparent_union_attribute_field_size_align)
2489        << isSize << Field->getDeclName() << FieldBits;
2490      unsigned FirstBits = isSize? FirstSize : FirstAlign;
2491      S.Diag(FirstField->getLocation(),
2492             diag::note_transparent_union_first_field_size_align)
2493        << isSize << FirstBits;
2494      return;
2495    }
2496  }
2497
2498  RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getRange(), S.Context));
2499}
2500
2501static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2502  // check the attribute arguments.
2503  if (!checkAttributeNumArgs(S, Attr, 1))
2504    return;
2505
2506  Expr *ArgExpr = Attr.getArg(0);
2507  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
2508
2509  // Make sure that there is a string literal as the annotation's single
2510  // argument.
2511  if (!SE) {
2512    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
2513    return;
2514  }
2515
2516  // Don't duplicate annotations that are already set.
2517  for (specific_attr_iterator<AnnotateAttr>
2518       i = D->specific_attr_begin<AnnotateAttr>(),
2519       e = D->specific_attr_end<AnnotateAttr>(); i != e; ++i) {
2520      if ((*i)->getAnnotation() == SE->getString())
2521          return;
2522  }
2523  D->addAttr(::new (S.Context) AnnotateAttr(Attr.getRange(), S.Context,
2524                                            SE->getString()));
2525}
2526
2527static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2528  // check the attribute arguments.
2529  if (Attr.getNumArgs() > 1) {
2530    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2531    return;
2532  }
2533
2534  //FIXME: The C++0x version of this attribute has more limited applicabilty
2535  //       than GNU's, and should error out when it is used to specify a
2536  //       weaker alignment, rather than being silently ignored.
2537
2538  if (Attr.getNumArgs() == 0) {
2539    D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context, true, 0));
2540    return;
2541  }
2542
2543  S.AddAlignedAttr(Attr.getRange(), D, Attr.getArg(0));
2544}
2545
2546void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E) {
2547  if (E->isTypeDependent() || E->isValueDependent()) {
2548    // Save dependent expressions in the AST to be instantiated.
2549    D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, E));
2550    return;
2551  }
2552
2553  SourceLocation AttrLoc = AttrRange.getBegin();
2554  // FIXME: Cache the number on the Attr object?
2555  llvm::APSInt Alignment(32);
2556  if (!E->isIntegerConstantExpr(Alignment, Context)) {
2557    Diag(AttrLoc, diag::err_attribute_argument_not_int)
2558      << "aligned" << E->getSourceRange();
2559    return;
2560  }
2561  if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
2562    Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
2563      << E->getSourceRange();
2564    return;
2565  }
2566
2567  D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, E));
2568}
2569
2570void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS) {
2571  // FIXME: Cache the number on the Attr object if non-dependent?
2572  // FIXME: Perform checking of type validity
2573  D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, false, TS));
2574  return;
2575}
2576
2577/// handleModeAttr - This attribute modifies the width of a decl with primitive
2578/// type.
2579///
2580/// Despite what would be logical, the mode attribute is a decl attribute, not a
2581/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
2582/// HImode, not an intermediate pointer.
2583static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2584  // This attribute isn't documented, but glibc uses it.  It changes
2585  // the width of an int or unsigned int to the specified size.
2586
2587  // Check that there aren't any arguments
2588  if (!checkAttributeNumArgs(S, Attr, 0))
2589    return;
2590
2591
2592  IdentifierInfo *Name = Attr.getParameterName();
2593  if (!Name) {
2594    S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
2595    return;
2596  }
2597
2598  StringRef Str = Attr.getParameterName()->getName();
2599
2600  // Normalize the attribute name, __foo__ becomes foo.
2601  if (Str.startswith("__") && Str.endswith("__"))
2602    Str = Str.substr(2, Str.size() - 4);
2603
2604  unsigned DestWidth = 0;
2605  bool IntegerMode = true;
2606  bool ComplexMode = false;
2607  switch (Str.size()) {
2608  case 2:
2609    switch (Str[0]) {
2610    case 'Q': DestWidth = 8; break;
2611    case 'H': DestWidth = 16; break;
2612    case 'S': DestWidth = 32; break;
2613    case 'D': DestWidth = 64; break;
2614    case 'X': DestWidth = 96; break;
2615    case 'T': DestWidth = 128; break;
2616    }
2617    if (Str[1] == 'F') {
2618      IntegerMode = false;
2619    } else if (Str[1] == 'C') {
2620      IntegerMode = false;
2621      ComplexMode = true;
2622    } else if (Str[1] != 'I') {
2623      DestWidth = 0;
2624    }
2625    break;
2626  case 4:
2627    // FIXME: glibc uses 'word' to define register_t; this is narrower than a
2628    // pointer on PIC16 and other embedded platforms.
2629    if (Str == "word")
2630      DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
2631    else if (Str == "byte")
2632      DestWidth = S.Context.getTargetInfo().getCharWidth();
2633    break;
2634  case 7:
2635    if (Str == "pointer")
2636      DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
2637    break;
2638  }
2639
2640  QualType OldTy;
2641  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
2642    OldTy = TD->getUnderlyingType();
2643  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
2644    OldTy = VD->getType();
2645  else {
2646    S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
2647      << "mode" << Attr.getRange();
2648    return;
2649  }
2650
2651  if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
2652    S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
2653  else if (IntegerMode) {
2654    if (!OldTy->isIntegralOrEnumerationType())
2655      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2656  } else if (ComplexMode) {
2657    if (!OldTy->isComplexType())
2658      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2659  } else {
2660    if (!OldTy->isFloatingType())
2661      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2662  }
2663
2664  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
2665  // and friends, at least with glibc.
2666  // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
2667  // width on unusual platforms.
2668  // FIXME: Make sure floating-point mappings are accurate
2669  // FIXME: Support XF and TF types
2670  QualType NewTy;
2671  switch (DestWidth) {
2672  case 0:
2673    S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
2674    return;
2675  default:
2676    S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2677    return;
2678  case 8:
2679    if (!IntegerMode) {
2680      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2681      return;
2682    }
2683    if (OldTy->isSignedIntegerType())
2684      NewTy = S.Context.SignedCharTy;
2685    else
2686      NewTy = S.Context.UnsignedCharTy;
2687    break;
2688  case 16:
2689    if (!IntegerMode) {
2690      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2691      return;
2692    }
2693    if (OldTy->isSignedIntegerType())
2694      NewTy = S.Context.ShortTy;
2695    else
2696      NewTy = S.Context.UnsignedShortTy;
2697    break;
2698  case 32:
2699    if (!IntegerMode)
2700      NewTy = S.Context.FloatTy;
2701    else if (OldTy->isSignedIntegerType())
2702      NewTy = S.Context.IntTy;
2703    else
2704      NewTy = S.Context.UnsignedIntTy;
2705    break;
2706  case 64:
2707    if (!IntegerMode)
2708      NewTy = S.Context.DoubleTy;
2709    else if (OldTy->isSignedIntegerType())
2710      if (S.Context.getTargetInfo().getLongWidth() == 64)
2711        NewTy = S.Context.LongTy;
2712      else
2713        NewTy = S.Context.LongLongTy;
2714    else
2715      if (S.Context.getTargetInfo().getLongWidth() == 64)
2716        NewTy = S.Context.UnsignedLongTy;
2717      else
2718        NewTy = S.Context.UnsignedLongLongTy;
2719    break;
2720  case 96:
2721    NewTy = S.Context.LongDoubleTy;
2722    break;
2723  case 128:
2724    if (!IntegerMode) {
2725      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2726      return;
2727    }
2728    if (OldTy->isSignedIntegerType())
2729      NewTy = S.Context.Int128Ty;
2730    else
2731      NewTy = S.Context.UnsignedInt128Ty;
2732    break;
2733  }
2734
2735  if (ComplexMode) {
2736    NewTy = S.Context.getComplexType(NewTy);
2737  }
2738
2739  // Install the new type.
2740  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2741    // FIXME: preserve existing source info.
2742    TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
2743  } else
2744    cast<ValueDecl>(D)->setType(NewTy);
2745}
2746
2747static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2748  // check the attribute arguments.
2749  if (!checkAttributeNumArgs(S, Attr, 0))
2750    return;
2751
2752  if (!isFunctionOrMethod(D)) {
2753    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2754      << Attr.getName() << ExpectedFunction;
2755    return;
2756  }
2757
2758  D->addAttr(::new (S.Context) NoDebugAttr(Attr.getRange(), S.Context));
2759}
2760
2761static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2762  // check the attribute arguments.
2763  if (!checkAttributeNumArgs(S, Attr, 0))
2764    return;
2765
2766
2767  if (!isa<FunctionDecl>(D)) {
2768    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2769      << Attr.getName() << ExpectedFunction;
2770    return;
2771  }
2772
2773  D->addAttr(::new (S.Context) NoInlineAttr(Attr.getRange(), S.Context));
2774}
2775
2776static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
2777                                           const AttributeList &Attr) {
2778  // check the attribute arguments.
2779  if (!checkAttributeNumArgs(S, Attr, 0))
2780    return;
2781
2782
2783  if (!isa<FunctionDecl>(D)) {
2784    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2785      << Attr.getName() << ExpectedFunction;
2786    return;
2787  }
2788
2789  D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getRange(),
2790                                                        S.Context));
2791}
2792
2793static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2794  if (S.LangOpts.CUDA) {
2795    // check the attribute arguments.
2796    if (Attr.hasParameterOrArguments()) {
2797      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2798      return;
2799    }
2800
2801    if (!isa<VarDecl>(D)) {
2802      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2803        << Attr.getName() << ExpectedVariable;
2804      return;
2805    }
2806
2807    D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getRange(), S.Context));
2808  } else {
2809    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
2810  }
2811}
2812
2813static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2814  if (S.LangOpts.CUDA) {
2815    // check the attribute arguments.
2816    if (Attr.getNumArgs() != 0) {
2817      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2818      return;
2819    }
2820
2821    if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
2822      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2823        << Attr.getName() << ExpectedVariableOrFunction;
2824      return;
2825    }
2826
2827    D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getRange(), S.Context));
2828  } else {
2829    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
2830  }
2831}
2832
2833static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2834  if (S.LangOpts.CUDA) {
2835    // check the attribute arguments.
2836    if (!checkAttributeNumArgs(S, Attr, 0))
2837      return;
2838
2839    if (!isa<FunctionDecl>(D)) {
2840      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2841        << Attr.getName() << ExpectedFunction;
2842      return;
2843    }
2844
2845    FunctionDecl *FD = cast<FunctionDecl>(D);
2846    if (!FD->getResultType()->isVoidType()) {
2847      TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
2848      if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
2849        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2850          << FD->getType()
2851          << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
2852                                          "void");
2853      } else {
2854        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2855          << FD->getType();
2856      }
2857      return;
2858    }
2859
2860    D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getRange(), S.Context));
2861  } else {
2862    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
2863  }
2864}
2865
2866static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2867  if (S.LangOpts.CUDA) {
2868    // check the attribute arguments.
2869    if (!checkAttributeNumArgs(S, Attr, 0))
2870      return;
2871
2872
2873    if (!isa<FunctionDecl>(D)) {
2874      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2875        << Attr.getName() << ExpectedFunction;
2876      return;
2877    }
2878
2879    D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getRange(), S.Context));
2880  } else {
2881    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
2882  }
2883}
2884
2885static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2886  if (S.LangOpts.CUDA) {
2887    // check the attribute arguments.
2888    if (!checkAttributeNumArgs(S, Attr, 0))
2889      return;
2890
2891
2892    if (!isa<VarDecl>(D)) {
2893      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2894        << Attr.getName() << ExpectedVariable;
2895      return;
2896    }
2897
2898    D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getRange(), S.Context));
2899  } else {
2900    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
2901  }
2902}
2903
2904static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2905  // check the attribute arguments.
2906  if (!checkAttributeNumArgs(S, Attr, 0))
2907    return;
2908
2909  FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
2910  if (Fn == 0) {
2911    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2912      << Attr.getName() << ExpectedFunction;
2913    return;
2914  }
2915
2916  if (!Fn->isInlineSpecified()) {
2917    S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
2918    return;
2919  }
2920
2921  D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getRange(), S.Context));
2922}
2923
2924static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2925  if (hasDeclarator(D)) return;
2926
2927  // Diagnostic is emitted elsewhere: here we store the (valid) Attr
2928  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
2929  CallingConv CC;
2930  if (S.CheckCallingConvAttr(Attr, CC))
2931    return;
2932
2933  if (!isa<ObjCMethodDecl>(D)) {
2934    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2935      << Attr.getName() << ExpectedFunctionOrMethod;
2936    return;
2937  }
2938
2939  switch (Attr.getKind()) {
2940  case AttributeList::AT_fastcall:
2941    D->addAttr(::new (S.Context) FastCallAttr(Attr.getRange(), S.Context));
2942    return;
2943  case AttributeList::AT_stdcall:
2944    D->addAttr(::new (S.Context) StdCallAttr(Attr.getRange(), S.Context));
2945    return;
2946  case AttributeList::AT_thiscall:
2947    D->addAttr(::new (S.Context) ThisCallAttr(Attr.getRange(), S.Context));
2948    return;
2949  case AttributeList::AT_cdecl:
2950    D->addAttr(::new (S.Context) CDeclAttr(Attr.getRange(), S.Context));
2951    return;
2952  case AttributeList::AT_pascal:
2953    D->addAttr(::new (S.Context) PascalAttr(Attr.getRange(), S.Context));
2954    return;
2955  case AttributeList::AT_pcs: {
2956    Expr *Arg = Attr.getArg(0);
2957    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2958    if (!Str || !Str->isAscii()) {
2959      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2960        << "pcs" << 1;
2961      Attr.setInvalid();
2962      return;
2963    }
2964
2965    StringRef StrRef = Str->getString();
2966    PcsAttr::PCSType PCS;
2967    if (StrRef == "aapcs")
2968      PCS = PcsAttr::AAPCS;
2969    else if (StrRef == "aapcs-vfp")
2970      PCS = PcsAttr::AAPCS_VFP;
2971    else {
2972      S.Diag(Attr.getLoc(), diag::err_invalid_pcs);
2973      Attr.setInvalid();
2974      return;
2975    }
2976
2977    D->addAttr(::new (S.Context) PcsAttr(Attr.getRange(), S.Context, PCS));
2978  }
2979  default:
2980    llvm_unreachable("unexpected attribute kind");
2981    return;
2982  }
2983}
2984
2985static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
2986  assert(!Attr.isInvalid());
2987  D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getRange(), S.Context));
2988}
2989
2990bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
2991  if (attr.isInvalid())
2992    return true;
2993
2994  if ((attr.getNumArgs() != 0 &&
2995      !(attr.getKind() == AttributeList::AT_pcs && attr.getNumArgs() == 1)) ||
2996      attr.getParameterName()) {
2997    Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2998    attr.setInvalid();
2999    return true;
3000  }
3001
3002  // TODO: diagnose uses of these conventions on the wrong target. Or, better
3003  // move to TargetAttributesSema one day.
3004  switch (attr.getKind()) {
3005  case AttributeList::AT_cdecl: CC = CC_C; break;
3006  case AttributeList::AT_fastcall: CC = CC_X86FastCall; break;
3007  case AttributeList::AT_stdcall: CC = CC_X86StdCall; break;
3008  case AttributeList::AT_thiscall: CC = CC_X86ThisCall; break;
3009  case AttributeList::AT_pascal: CC = CC_X86Pascal; break;
3010  case AttributeList::AT_pcs: {
3011    Expr *Arg = attr.getArg(0);
3012    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
3013    if (!Str || !Str->isAscii()) {
3014      Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
3015        << "pcs" << 1;
3016      attr.setInvalid();
3017      return true;
3018    }
3019
3020    StringRef StrRef = Str->getString();
3021    if (StrRef == "aapcs") {
3022      CC = CC_AAPCS;
3023      break;
3024    } else if (StrRef == "aapcs-vfp") {
3025      CC = CC_AAPCS_VFP;
3026      break;
3027    }
3028    // FALLS THROUGH
3029  }
3030  default: llvm_unreachable("unexpected attribute kind"); return true;
3031  }
3032
3033  return false;
3034}
3035
3036static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3037  if (hasDeclarator(D)) return;
3038
3039  unsigned numParams;
3040  if (S.CheckRegparmAttr(Attr, numParams))
3041    return;
3042
3043  if (!isa<ObjCMethodDecl>(D)) {
3044    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3045      << Attr.getName() << ExpectedFunctionOrMethod;
3046    return;
3047  }
3048
3049  D->addAttr(::new (S.Context) RegparmAttr(Attr.getRange(), S.Context, numParams));
3050}
3051
3052/// Checks a regparm attribute, returning true if it is ill-formed and
3053/// otherwise setting numParams to the appropriate value.
3054bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3055  if (Attr.isInvalid())
3056    return true;
3057
3058  if (Attr.getNumArgs() != 1) {
3059    Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
3060    Attr.setInvalid();
3061    return true;
3062  }
3063
3064  Expr *NumParamsExpr = Attr.getArg(0);
3065  llvm::APSInt NumParams(32);
3066  if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
3067      !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
3068    Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
3069      << "regparm" << NumParamsExpr->getSourceRange();
3070    Attr.setInvalid();
3071    return true;
3072  }
3073
3074  if (Context.getTargetInfo().getRegParmMax() == 0) {
3075    Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
3076      << NumParamsExpr->getSourceRange();
3077    Attr.setInvalid();
3078    return true;
3079  }
3080
3081  numParams = NumParams.getZExtValue();
3082  if (numParams > Context.getTargetInfo().getRegParmMax()) {
3083    Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
3084      << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
3085    Attr.setInvalid();
3086    return true;
3087  }
3088
3089  return false;
3090}
3091
3092static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
3093  if (S.LangOpts.CUDA) {
3094    // check the attribute arguments.
3095    if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
3096      // FIXME: 0 is not okay.
3097      S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
3098      return;
3099    }
3100
3101    if (!isFunctionOrMethod(D)) {
3102      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3103        << Attr.getName() << ExpectedFunctionOrMethod;
3104      return;
3105    }
3106
3107    Expr *MaxThreadsExpr = Attr.getArg(0);
3108    llvm::APSInt MaxThreads(32);
3109    if (MaxThreadsExpr->isTypeDependent() ||
3110        MaxThreadsExpr->isValueDependent() ||
3111        !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
3112      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3113        << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
3114      return;
3115    }
3116
3117    llvm::APSInt MinBlocks(32);
3118    if (Attr.getNumArgs() > 1) {
3119      Expr *MinBlocksExpr = Attr.getArg(1);
3120      if (MinBlocksExpr->isTypeDependent() ||
3121          MinBlocksExpr->isValueDependent() ||
3122          !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
3123        S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3124          << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
3125        return;
3126      }
3127    }
3128
3129    D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getRange(), S.Context,
3130                                                      MaxThreads.getZExtValue(),
3131                                                     MinBlocks.getZExtValue()));
3132  } else {
3133    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
3134  }
3135}
3136
3137//===----------------------------------------------------------------------===//
3138// Checker-specific attribute handlers.
3139//===----------------------------------------------------------------------===//
3140
3141static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
3142  return type->isDependentType() ||
3143         type->isObjCObjectPointerType() ||
3144         S.Context.isObjCNSObjectType(type);
3145}
3146static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
3147  return type->isDependentType() ||
3148         type->isPointerType() ||
3149         isValidSubjectOfNSAttribute(S, type);
3150}
3151
3152static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3153  ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
3154  if (!param) {
3155    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3156      << Attr.getRange() << Attr.getName() << ExpectedParameter;
3157    return;
3158  }
3159
3160  bool typeOK, cf;
3161  if (Attr.getKind() == AttributeList::AT_ns_consumed) {
3162    typeOK = isValidSubjectOfNSAttribute(S, param->getType());
3163    cf = false;
3164  } else {
3165    typeOK = isValidSubjectOfCFAttribute(S, param->getType());
3166    cf = true;
3167  }
3168
3169  if (!typeOK) {
3170    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
3171      << Attr.getRange() << Attr.getName() << cf;
3172    return;
3173  }
3174
3175  if (cf)
3176    param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getRange(), S.Context));
3177  else
3178    param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getRange(), S.Context));
3179}
3180
3181static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
3182                                     const AttributeList &Attr) {
3183  if (!isa<ObjCMethodDecl>(D)) {
3184    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3185      << Attr.getRange() << Attr.getName() << ExpectedMethod;
3186    return;
3187  }
3188
3189  D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getRange(), S.Context));
3190}
3191
3192static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
3193                                        const AttributeList &Attr) {
3194
3195  QualType returnType;
3196
3197  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
3198    returnType = MD->getResultType();
3199  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
3200    returnType = PD->getType();
3201  else if (S.getLangOptions().ObjCAutoRefCount && hasDeclarator(D) &&
3202           (Attr.getKind() == AttributeList::AT_ns_returns_retained))
3203    return; // ignore: was handled as a type attribute
3204  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
3205    returnType = FD->getResultType();
3206  else {
3207    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
3208        << Attr.getRange() << Attr.getName()
3209        << ExpectedFunctionOrMethod;
3210    return;
3211  }
3212
3213  bool typeOK;
3214  bool cf;
3215  switch (Attr.getKind()) {
3216  default: llvm_unreachable("invalid ownership attribute"); return;
3217  case AttributeList::AT_ns_returns_autoreleased:
3218  case AttributeList::AT_ns_returns_retained:
3219  case AttributeList::AT_ns_returns_not_retained:
3220    typeOK = isValidSubjectOfNSAttribute(S, returnType);
3221    cf = false;
3222    break;
3223
3224  case AttributeList::AT_cf_returns_retained:
3225  case AttributeList::AT_cf_returns_not_retained:
3226    typeOK = isValidSubjectOfCFAttribute(S, returnType);
3227    cf = true;
3228    break;
3229  }
3230
3231  if (!typeOK) {
3232    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3233      << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
3234    return;
3235  }
3236
3237  switch (Attr.getKind()) {
3238    default:
3239      llvm_unreachable("invalid ownership attribute");
3240    case AttributeList::AT_ns_returns_autoreleased:
3241      D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getRange(),
3242                                                             S.Context));
3243      return;
3244    case AttributeList::AT_cf_returns_not_retained:
3245      D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getRange(),
3246                                                            S.Context));
3247      return;
3248    case AttributeList::AT_ns_returns_not_retained:
3249      D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getRange(),
3250                                                            S.Context));
3251      return;
3252    case AttributeList::AT_cf_returns_retained:
3253      D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getRange(),
3254                                                         S.Context));
3255      return;
3256    case AttributeList::AT_ns_returns_retained:
3257      D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getRange(),
3258                                                         S.Context));
3259      return;
3260  };
3261}
3262
3263static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
3264                                              const AttributeList &attr) {
3265  SourceLocation loc = attr.getLoc();
3266
3267  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
3268
3269  if (!isa<ObjCMethodDecl>(method)) {
3270    S.Diag(method->getLocStart(), diag::err_attribute_wrong_decl_type)
3271      << SourceRange(loc, loc) << attr.getName() << 13 /* methods */;
3272    return;
3273  }
3274
3275  // Check that the method returns a normal pointer.
3276  QualType resultType = method->getResultType();
3277
3278  if (!resultType->isReferenceType() &&
3279      (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
3280    S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3281      << SourceRange(loc)
3282      << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2;
3283
3284    // Drop the attribute.
3285    return;
3286  }
3287
3288  method->addAttr(
3289    ::new (S.Context) ObjCReturnsInnerPointerAttr(attr.getRange(), S.Context));
3290}
3291
3292/// Handle cf_audited_transfer and cf_unknown_transfer.
3293static void handleCFTransferAttr(Sema &S, Decl *D, const AttributeList &A) {
3294  if (!isa<FunctionDecl>(D)) {
3295    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3296      << A.getRange() << A.getName() << 0 /*function*/;
3297    return;
3298  }
3299
3300  bool IsAudited = (A.getKind() == AttributeList::AT_cf_audited_transfer);
3301
3302  // Check whether there's a conflicting attribute already present.
3303  Attr *Existing;
3304  if (IsAudited) {
3305    Existing = D->getAttr<CFUnknownTransferAttr>();
3306  } else {
3307    Existing = D->getAttr<CFAuditedTransferAttr>();
3308  }
3309  if (Existing) {
3310    S.Diag(D->getLocStart(), diag::err_attributes_are_not_compatible)
3311      << A.getName()
3312      << (IsAudited ? "cf_unknown_transfer" : "cf_audited_transfer")
3313      << A.getRange() << Existing->getRange();
3314    return;
3315  }
3316
3317  // All clear;  add the attribute.
3318  if (IsAudited) {
3319    D->addAttr(
3320      ::new (S.Context) CFAuditedTransferAttr(A.getRange(), S.Context));
3321  } else {
3322    D->addAttr(
3323      ::new (S.Context) CFUnknownTransferAttr(A.getRange(), S.Context));
3324  }
3325}
3326
3327static void handleNSBridgedAttr(Sema &S, Scope *Sc, Decl *D,
3328                                const AttributeList &Attr) {
3329  RecordDecl *RD = dyn_cast<RecordDecl>(D);
3330  if (!RD || RD->isUnion()) {
3331    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3332      << Attr.getRange() << Attr.getName() << 14 /*struct */;
3333  }
3334
3335  IdentifierInfo *ParmName = Attr.getParameterName();
3336
3337  // In Objective-C, verify that the type names an Objective-C type.
3338  // We don't want to check this outside of ObjC because people sometimes
3339  // do crazy C declarations of Objective-C types.
3340  if (ParmName && S.getLangOptions().ObjC1) {
3341    // Check for an existing type with this name.
3342    LookupResult R(S, DeclarationName(ParmName), Attr.getParameterLoc(),
3343                   Sema::LookupOrdinaryName);
3344    if (S.LookupName(R, Sc)) {
3345      NamedDecl *Target = R.getFoundDecl();
3346      if (Target && !isa<ObjCInterfaceDecl>(Target)) {
3347        S.Diag(D->getLocStart(), diag::err_ns_bridged_not_interface);
3348        S.Diag(Target->getLocStart(), diag::note_declared_at);
3349      }
3350    }
3351  }
3352
3353  D->addAttr(::new (S.Context) NSBridgedAttr(Attr.getRange(), S.Context,
3354                                             ParmName));
3355}
3356
3357static void handleObjCOwnershipAttr(Sema &S, Decl *D,
3358                                    const AttributeList &Attr) {
3359  if (hasDeclarator(D)) return;
3360
3361  S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3362    << Attr.getRange() << Attr.getName() << 12 /* variable */;
3363}
3364
3365static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
3366                                          const AttributeList &Attr) {
3367  if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
3368    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
3369      << Attr.getRange() << Attr.getName() << 12 /* variable */;
3370    return;
3371  }
3372
3373  ValueDecl *vd = cast<ValueDecl>(D);
3374  QualType type = vd->getType();
3375
3376  if (!type->isDependentType() &&
3377      !type->isObjCLifetimeType()) {
3378    S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
3379      << type;
3380    return;
3381  }
3382
3383  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
3384
3385  // If we have no lifetime yet, check the lifetime we're presumably
3386  // going to infer.
3387  if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
3388    lifetime = type->getObjCARCImplicitLifetime();
3389
3390  switch (lifetime) {
3391  case Qualifiers::OCL_None:
3392    assert(type->isDependentType() &&
3393           "didn't infer lifetime for non-dependent type?");
3394    break;
3395
3396  case Qualifiers::OCL_Weak:   // meaningful
3397  case Qualifiers::OCL_Strong: // meaningful
3398    break;
3399
3400  case Qualifiers::OCL_ExplicitNone:
3401  case Qualifiers::OCL_Autoreleasing:
3402    S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
3403      << (lifetime == Qualifiers::OCL_Autoreleasing);
3404    break;
3405  }
3406
3407  D->addAttr(::new (S.Context)
3408                 ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context));
3409}
3410
3411static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
3412  return Attr.getKind() == AttributeList::AT_dllimport ||
3413         Attr.getKind() == AttributeList::AT_dllexport ||
3414         Attr.getKind() == AttributeList::AT_uuid;
3415}
3416
3417//===----------------------------------------------------------------------===//
3418// Microsoft specific attribute handlers.
3419//===----------------------------------------------------------------------===//
3420
3421static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3422  if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) {
3423    // check the attribute arguments.
3424    if (!checkAttributeNumArgs(S, Attr, 1))
3425      return;
3426
3427    Expr *Arg = Attr.getArg(0);
3428    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
3429    if (!Str || !Str->isAscii()) {
3430      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
3431        << "uuid" << 1;
3432      return;
3433    }
3434
3435    StringRef StrRef = Str->getString();
3436
3437    bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
3438                   StrRef.back() == '}';
3439
3440    // Validate GUID length.
3441    if (IsCurly && StrRef.size() != 38) {
3442      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3443      return;
3444    }
3445    if (!IsCurly && StrRef.size() != 36) {
3446      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3447      return;
3448    }
3449
3450    // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
3451    // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
3452    StringRef::iterator I = StrRef.begin();
3453    if (IsCurly) // Skip the optional '{'
3454       ++I;
3455
3456    for (int i = 0; i < 36; ++i) {
3457      if (i == 8 || i == 13 || i == 18 || i == 23) {
3458        if (*I != '-') {
3459          S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3460          return;
3461        }
3462      } else if (!isxdigit(*I)) {
3463        S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3464        return;
3465      }
3466      I++;
3467    }
3468
3469    D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context,
3470                                          Str->getString()));
3471  } else
3472    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
3473}
3474
3475//===----------------------------------------------------------------------===//
3476// Top Level Sema Entry Points
3477//===----------------------------------------------------------------------===//
3478
3479static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
3480                                          const AttributeList &Attr) {
3481  switch (Attr.getKind()) {
3482  case AttributeList::AT_device:      handleDeviceAttr      (S, D, Attr); break;
3483  case AttributeList::AT_host:        handleHostAttr        (S, D, Attr); break;
3484  case AttributeList::AT_overloadable:handleOverloadableAttr(S, D, Attr); break;
3485  default:
3486    break;
3487  }
3488}
3489
3490static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
3491                                       const AttributeList &Attr) {
3492  switch (Attr.getKind()) {
3493  case AttributeList::AT_IBAction:            handleIBAction(S, D, Attr); break;
3494    case AttributeList::AT_IBOutlet:          handleIBOutlet(S, D, Attr); break;
3495  case AttributeList::AT_IBOutletCollection:
3496      handleIBOutletCollection(S, D, Attr); break;
3497  case AttributeList::AT_address_space:
3498  case AttributeList::AT_opencl_image_access:
3499  case AttributeList::AT_objc_gc:
3500  case AttributeList::AT_vector_size:
3501  case AttributeList::AT_neon_vector_type:
3502  case AttributeList::AT_neon_polyvector_type:
3503    // Ignore these, these are type attributes, handled by
3504    // ProcessTypeAttributes.
3505    break;
3506  case AttributeList::AT_device:
3507  case AttributeList::AT_host:
3508  case AttributeList::AT_overloadable:
3509    // Ignore, this is a non-inheritable attribute, handled
3510    // by ProcessNonInheritableDeclAttr.
3511    break;
3512  case AttributeList::AT_alias:       handleAliasAttr       (S, D, Attr); break;
3513  case AttributeList::AT_aligned:     handleAlignedAttr     (S, D, Attr); break;
3514  case AttributeList::AT_always_inline:
3515    handleAlwaysInlineAttr  (S, D, Attr); break;
3516  case AttributeList::AT_analyzer_noreturn:
3517    handleAnalyzerNoReturnAttr  (S, D, Attr); break;
3518  case AttributeList::AT_annotate:    handleAnnotateAttr    (S, D, Attr); break;
3519  case AttributeList::AT_availability:handleAvailabilityAttr(S, D, Attr); break;
3520  case AttributeList::AT_carries_dependency:
3521                                      handleDependencyAttr  (S, D, Attr); break;
3522  case AttributeList::AT_common:      handleCommonAttr      (S, D, Attr); break;
3523  case AttributeList::AT_constant:    handleConstantAttr    (S, D, Attr); break;
3524  case AttributeList::AT_constructor: handleConstructorAttr (S, D, Attr); break;
3525  case AttributeList::AT_deprecated:  handleDeprecatedAttr  (S, D, Attr); break;
3526  case AttributeList::AT_destructor:  handleDestructorAttr  (S, D, Attr); break;
3527  case AttributeList::AT_ext_vector_type:
3528    handleExtVectorTypeAttr(S, scope, D, Attr);
3529    break;
3530  case AttributeList::AT_format:      handleFormatAttr      (S, D, Attr); break;
3531  case AttributeList::AT_format_arg:  handleFormatArgAttr   (S, D, Attr); break;
3532  case AttributeList::AT_global:      handleGlobalAttr      (S, D, Attr); break;
3533  case AttributeList::AT_gnu_inline:  handleGNUInlineAttr   (S, D, Attr); break;
3534  case AttributeList::AT_launch_bounds:
3535    handleLaunchBoundsAttr(S, D, Attr);
3536    break;
3537  case AttributeList::AT_mode:        handleModeAttr        (S, D, Attr); break;
3538  case AttributeList::AT_malloc:      handleMallocAttr      (S, D, Attr); break;
3539  case AttributeList::AT_may_alias:   handleMayAliasAttr    (S, D, Attr); break;
3540  case AttributeList::AT_nocommon:    handleNoCommonAttr    (S, D, Attr); break;
3541  case AttributeList::AT_nonnull:     handleNonNullAttr     (S, D, Attr); break;
3542  case AttributeList::AT_ownership_returns:
3543  case AttributeList::AT_ownership_takes:
3544  case AttributeList::AT_ownership_holds:
3545      handleOwnershipAttr     (S, D, Attr); break;
3546  case AttributeList::AT_naked:       handleNakedAttr       (S, D, Attr); break;
3547  case AttributeList::AT_noreturn:    handleNoReturnAttr    (S, D, Attr); break;
3548  case AttributeList::AT_nothrow:     handleNothrowAttr     (S, D, Attr); break;
3549  case AttributeList::AT_shared:      handleSharedAttr      (S, D, Attr); break;
3550  case AttributeList::AT_vecreturn:   handleVecReturnAttr   (S, D, Attr); break;
3551
3552  case AttributeList::AT_objc_ownership:
3553    handleObjCOwnershipAttr(S, D, Attr); break;
3554  case AttributeList::AT_objc_precise_lifetime:
3555    handleObjCPreciseLifetimeAttr(S, D, Attr); break;
3556
3557  case AttributeList::AT_objc_returns_inner_pointer:
3558    handleObjCReturnsInnerPointerAttr(S, D, Attr); break;
3559
3560  case AttributeList::AT_ns_bridged:
3561    handleNSBridgedAttr(S, scope, D, Attr); break;
3562
3563  case AttributeList::AT_cf_audited_transfer:
3564  case AttributeList::AT_cf_unknown_transfer:
3565    handleCFTransferAttr(S, D, Attr); break;
3566
3567  // Checker-specific.
3568  case AttributeList::AT_cf_consumed:
3569  case AttributeList::AT_ns_consumed: handleNSConsumedAttr  (S, D, Attr); break;
3570  case AttributeList::AT_ns_consumes_self:
3571    handleNSConsumesSelfAttr(S, D, Attr); break;
3572
3573  case AttributeList::AT_ns_returns_autoreleased:
3574  case AttributeList::AT_ns_returns_not_retained:
3575  case AttributeList::AT_cf_returns_not_retained:
3576  case AttributeList::AT_ns_returns_retained:
3577  case AttributeList::AT_cf_returns_retained:
3578    handleNSReturnsRetainedAttr(S, D, Attr); break;
3579
3580  case AttributeList::AT_reqd_wg_size:
3581    handleReqdWorkGroupSize(S, D, Attr); break;
3582
3583  case AttributeList::AT_init_priority:
3584      handleInitPriorityAttr(S, D, Attr); break;
3585
3586  case AttributeList::AT_packed:      handlePackedAttr      (S, D, Attr); break;
3587  case AttributeList::AT_MsStruct:    handleMsStructAttr    (S, D, Attr); break;
3588  case AttributeList::AT_section:     handleSectionAttr     (S, D, Attr); break;
3589  case AttributeList::AT_unavailable: handleUnavailableAttr (S, D, Attr); break;
3590  case AttributeList::AT_arc_weakref_unavailable:
3591    handleArcWeakrefUnavailableAttr (S, D, Attr);
3592    break;
3593  case AttributeList::AT_unused:      handleUnusedAttr      (S, D, Attr); break;
3594  case AttributeList::AT_returns_twice:
3595    handleReturnsTwiceAttr(S, D, Attr);
3596    break;
3597  case AttributeList::AT_used:        handleUsedAttr        (S, D, Attr); break;
3598  case AttributeList::AT_visibility:  handleVisibilityAttr  (S, D, Attr); break;
3599  case AttributeList::AT_warn_unused_result: handleWarnUnusedResult(S, D, Attr);
3600    break;
3601  case AttributeList::AT_weak:        handleWeakAttr        (S, D, Attr); break;
3602  case AttributeList::AT_weakref:     handleWeakRefAttr     (S, D, Attr); break;
3603  case AttributeList::AT_weak_import: handleWeakImportAttr  (S, D, Attr); break;
3604  case AttributeList::AT_transparent_union:
3605    handleTransparentUnionAttr(S, D, Attr);
3606    break;
3607  case AttributeList::AT_objc_exception:
3608    handleObjCExceptionAttr(S, D, Attr);
3609    break;
3610  case AttributeList::AT_objc_method_family:
3611    handleObjCMethodFamilyAttr(S, D, Attr);
3612    break;
3613  case AttributeList::AT_nsobject:    handleObjCNSObject    (S, D, Attr); break;
3614  case AttributeList::AT_blocks:      handleBlocksAttr      (S, D, Attr); break;
3615  case AttributeList::AT_sentinel:    handleSentinelAttr    (S, D, Attr); break;
3616  case AttributeList::AT_const:       handleConstAttr       (S, D, Attr); break;
3617  case AttributeList::AT_pure:        handlePureAttr        (S, D, Attr); break;
3618  case AttributeList::AT_cleanup:     handleCleanupAttr     (S, D, Attr); break;
3619  case AttributeList::AT_nodebug:     handleNoDebugAttr     (S, D, Attr); break;
3620  case AttributeList::AT_noinline:    handleNoInlineAttr    (S, D, Attr); break;
3621  case AttributeList::AT_regparm:     handleRegparmAttr     (S, D, Attr); break;
3622  case AttributeList::IgnoredAttribute:
3623    // Just ignore
3624    break;
3625  case AttributeList::AT_no_instrument_function:  // Interacts with -pg.
3626    handleNoInstrumentFunctionAttr(S, D, Attr);
3627    break;
3628  case AttributeList::AT_stdcall:
3629  case AttributeList::AT_cdecl:
3630  case AttributeList::AT_fastcall:
3631  case AttributeList::AT_thiscall:
3632  case AttributeList::AT_pascal:
3633  case AttributeList::AT_pcs:
3634    handleCallConvAttr(S, D, Attr);
3635    break;
3636  case AttributeList::AT_opencl_kernel_function:
3637    handleOpenCLKernelAttr(S, D, Attr);
3638    break;
3639  case AttributeList::AT_uuid:
3640    handleUuidAttr(S, D, Attr);
3641    break;
3642
3643  // Thread safety attributes:
3644  case AttributeList::AT_guarded_var:
3645    handleGuardedVarAttr(S, D, Attr);
3646    break;
3647  case AttributeList::AT_pt_guarded_var:
3648    handleGuardedVarAttr(S, D, Attr, /*pointer = */true);
3649    break;
3650  case AttributeList::AT_scoped_lockable:
3651    handleLockableAttr(S, D, Attr, /*scoped = */true);
3652    break;
3653  case AttributeList::AT_no_thread_safety_analysis:
3654    handleNoThreadSafetyAttr(S, D, Attr);
3655    break;
3656  case AttributeList::AT_lockable:
3657    handleLockableAttr(S, D, Attr);
3658    break;
3659  case AttributeList::AT_guarded_by:
3660    handleGuardedByAttr(S, D, Attr);
3661    break;
3662  case AttributeList::AT_pt_guarded_by:
3663    handleGuardedByAttr(S, D, Attr, /*pointer = */true);
3664    break;
3665  case AttributeList::AT_exclusive_lock_function:
3666    handleLockFunAttr(S, D, Attr, /*exclusive = */true);
3667    break;
3668  case AttributeList::AT_exclusive_locks_required:
3669    handleLocksRequiredAttr(S, D, Attr, /*exclusive = */true);
3670    break;
3671  case AttributeList::AT_exclusive_trylock_function:
3672    handleTrylockFunAttr(S, D, Attr, /*exclusive = */true);
3673    break;
3674  case AttributeList::AT_lock_returned:
3675    handleLockReturnedAttr(S, D, Attr);
3676    break;
3677  case AttributeList::AT_locks_excluded:
3678    handleLocksExcludedAttr(S, D, Attr);
3679    break;
3680  case AttributeList::AT_shared_lock_function:
3681    handleLockFunAttr(S, D, Attr);
3682    break;
3683  case AttributeList::AT_shared_locks_required:
3684    handleLocksRequiredAttr(S, D, Attr);
3685    break;
3686  case AttributeList::AT_shared_trylock_function:
3687    handleTrylockFunAttr(S, D, Attr);
3688    break;
3689  case AttributeList::AT_unlock_function:
3690    handleUnlockFunAttr(S, D, Attr);
3691    break;
3692  case AttributeList::AT_acquired_before:
3693    handleAcquireOrderAttr(S, D, Attr, /*before = */true);
3694    break;
3695  case AttributeList::AT_acquired_after:
3696    handleAcquireOrderAttr(S, D, Attr, /*before = */false);
3697    break;
3698
3699  default:
3700    // Ask target about the attribute.
3701    const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
3702    if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
3703      S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored)
3704        << Attr.getName();
3705    break;
3706  }
3707}
3708
3709/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
3710/// the attribute applies to decls.  If the attribute is a type attribute, just
3711/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
3712/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
3713static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
3714                                 const AttributeList &Attr,
3715                                 bool NonInheritable, bool Inheritable) {
3716  if (Attr.isInvalid())
3717    return;
3718
3719  if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
3720    // FIXME: Try to deal with other __declspec attributes!
3721    return;
3722
3723  if (NonInheritable)
3724    ProcessNonInheritableDeclAttr(S, scope, D, Attr);
3725
3726  if (Inheritable)
3727    ProcessInheritableDeclAttr(S, scope, D, Attr);
3728}
3729
3730/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
3731/// attribute list to the specified decl, ignoring any type attributes.
3732void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
3733                                    const AttributeList *AttrList,
3734                                    bool NonInheritable, bool Inheritable) {
3735  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
3736    ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable);
3737  }
3738
3739  // GCC accepts
3740  // static int a9 __attribute__((weakref));
3741  // but that looks really pointless. We reject it.
3742  if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
3743    Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
3744    dyn_cast<NamedDecl>(D)->getNameAsString();
3745    return;
3746  }
3747}
3748
3749// Annotation attributes are the only attributes allowed after an access
3750// specifier.
3751bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
3752                                          const AttributeList *AttrList) {
3753  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
3754    if (l->getKind() == AttributeList::AT_annotate) {
3755      handleAnnotateAttr(*this, ASDecl, *l);
3756    } else {
3757      Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
3758      return true;
3759    }
3760  }
3761
3762  return false;
3763}
3764
3765/// checkUnusedDeclAttributes - Check a list of attributes to see if it
3766/// contains any decl attributes that we should warn about.
3767static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
3768  for ( ; A; A = A->getNext()) {
3769    // Only warn if the attribute is an unignored, non-type attribute.
3770    if (A->isUsedAsTypeAttr()) continue;
3771    if (A->getKind() == AttributeList::IgnoredAttribute) continue;
3772
3773    if (A->getKind() == AttributeList::UnknownAttribute) {
3774      S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
3775        << A->getName() << A->getRange();
3776    } else {
3777      S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
3778        << A->getName() << A->getRange();
3779    }
3780  }
3781}
3782
3783/// checkUnusedDeclAttributes - Given a declarator which is not being
3784/// used to build a declaration, complain about any decl attributes
3785/// which might be lying around on it.
3786void Sema::checkUnusedDeclAttributes(Declarator &D) {
3787  ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
3788  ::checkUnusedDeclAttributes(*this, D.getAttributes());
3789  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
3790    ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
3791}
3792
3793/// DeclClonePragmaWeak - clone existing decl (maybe definition),
3794/// #pragma weak needs a non-definition decl and source may not have one
3795NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
3796                                      SourceLocation Loc) {
3797  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
3798  NamedDecl *NewD = 0;
3799  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
3800    FunctionDecl *NewFD;
3801    // FIXME: Missing call to CheckFunctionDeclaration().
3802    // FIXME: Mangling?
3803    // FIXME: Is the qualifier info correct?
3804    // FIXME: Is the DeclContext correct?
3805    NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
3806                                 Loc, Loc, DeclarationName(II),
3807                                 FD->getType(), FD->getTypeSourceInfo(),
3808                                 SC_None, SC_None,
3809                                 false/*isInlineSpecified*/,
3810                                 FD->hasPrototype(),
3811                                 false/*isConstexprSpecified*/);
3812    NewD = NewFD;
3813
3814    if (FD->getQualifier())
3815      NewFD->setQualifierInfo(FD->getQualifierLoc());
3816
3817    // Fake up parameter variables; they are declared as if this were
3818    // a typedef.
3819    QualType FDTy = FD->getType();
3820    if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
3821      SmallVector<ParmVarDecl*, 16> Params;
3822      for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
3823           AE = FT->arg_type_end(); AI != AE; ++AI) {
3824        ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, *AI);
3825        Param->setScopeInfo(0, Params.size());
3826        Params.push_back(Param);
3827      }
3828      NewFD->setParams(Params);
3829    }
3830  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
3831    NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
3832                           VD->getInnerLocStart(), VD->getLocation(), II,
3833                           VD->getType(), VD->getTypeSourceInfo(),
3834                           VD->getStorageClass(),
3835                           VD->getStorageClassAsWritten());
3836    if (VD->getQualifier()) {
3837      VarDecl *NewVD = cast<VarDecl>(NewD);
3838      NewVD->setQualifierInfo(VD->getQualifierLoc());
3839    }
3840  }
3841  return NewD;
3842}
3843
3844/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
3845/// applied to it, possibly with an alias.
3846void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
3847  if (W.getUsed()) return; // only do this once
3848  W.setUsed(true);
3849  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
3850    IdentifierInfo *NDId = ND->getIdentifier();
3851    NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
3852    NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
3853                                            NDId->getName()));
3854    NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3855    WeakTopLevelDecl.push_back(NewD);
3856    // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
3857    // to insert Decl at TU scope, sorry.
3858    DeclContext *SavedContext = CurContext;
3859    CurContext = Context.getTranslationUnitDecl();
3860    PushOnScopeChains(NewD, S);
3861    CurContext = SavedContext;
3862  } else { // just add weak to existing
3863    ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3864  }
3865}
3866
3867/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
3868/// it, apply them to D.  This is a bit tricky because PD can have attributes
3869/// specified in many different places, and we need to find and apply them all.
3870void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
3871                                 bool NonInheritable, bool Inheritable) {
3872  // It's valid to "forward-declare" #pragma weak, in which case we
3873  // have to do this.
3874  if (Inheritable) {
3875    LoadExternalWeakUndeclaredIdentifiers();
3876    if (!WeakUndeclaredIdentifiers.empty()) {
3877      if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
3878        if (IdentifierInfo *Id = ND->getIdentifier()) {
3879          llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
3880            = WeakUndeclaredIdentifiers.find(Id);
3881          if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
3882            WeakInfo W = I->second;
3883            DeclApplyPragmaWeak(S, ND, W);
3884            WeakUndeclaredIdentifiers[Id] = W;
3885          }
3886        }
3887      }
3888    }
3889  }
3890
3891  // Apply decl attributes from the DeclSpec if present.
3892  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
3893    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3894
3895  // Walk the declarator structure, applying decl attributes that were in a type
3896  // position to the decl itself.  This handles cases like:
3897  //   int *__attr__(x)** D;
3898  // when X is a decl attribute.
3899  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
3900    if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
3901      ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3902
3903  // Finally, apply any attributes on the decl itself.
3904  if (const AttributeList *Attrs = PD.getAttributes())
3905    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3906}
3907
3908/// Is the given declaration allowed to use a forbidden type?
3909static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
3910  // Private ivars are always okay.  Unfortunately, people don't
3911  // always properly make their ivars private, even in system headers.
3912  // Plus we need to make fields okay, too.
3913  // Function declarations in sys headers will be marked unavailable.
3914  if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
3915      !isa<FunctionDecl>(decl))
3916    return false;
3917
3918  // Require it to be declared in a system header.
3919  return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
3920}
3921
3922/// Handle a delayed forbidden-type diagnostic.
3923static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
3924                                       Decl *decl) {
3925  if (decl && isForbiddenTypeAllowed(S, decl)) {
3926    decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
3927                        "this system declaration uses an unsupported type"));
3928    return;
3929  }
3930  if (S.getLangOptions().ObjCAutoRefCount)
3931    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
3932      // FIXME. we may want to supress diagnostics for all
3933      // kind of forbidden type messages on unavailable functions.
3934      if (FD->hasAttr<UnavailableAttr>() &&
3935          diag.getForbiddenTypeDiagnostic() ==
3936          diag::err_arc_array_param_no_ownership) {
3937        diag.Triggered = true;
3938        return;
3939      }
3940    }
3941
3942  S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
3943    << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
3944  diag.Triggered = true;
3945}
3946
3947// This duplicates a vector push_back but hides the need to know the
3948// size of the type.
3949void Sema::DelayedDiagnostics::add(const DelayedDiagnostic &diag) {
3950  assert(StackSize <= StackCapacity);
3951
3952  // Grow the stack if necessary.
3953  if (StackSize == StackCapacity) {
3954    unsigned newCapacity = 2 * StackCapacity + 2;
3955    char *newBuffer = new char[newCapacity * sizeof(DelayedDiagnostic)];
3956    const char *oldBuffer = (const char*) Stack;
3957
3958    if (StackCapacity)
3959      memcpy(newBuffer, oldBuffer, StackCapacity * sizeof(DelayedDiagnostic));
3960
3961    delete[] oldBuffer;
3962    Stack = reinterpret_cast<sema::DelayedDiagnostic*>(newBuffer);
3963    StackCapacity = newCapacity;
3964  }
3965
3966  assert(StackSize < StackCapacity);
3967  new (&Stack[StackSize++]) DelayedDiagnostic(diag);
3968}
3969
3970void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
3971                                              Decl *decl) {
3972  DelayedDiagnostics &DD = S.DelayedDiagnostics;
3973
3974  // Check the invariants.
3975  assert(DD.StackSize >= state.SavedStackSize);
3976  assert(state.SavedStackSize >= DD.ActiveStackBase);
3977  assert(DD.ParsingDepth > 0);
3978
3979  // Drop the parsing depth.
3980  DD.ParsingDepth--;
3981
3982  // If there are no active diagnostics, we're done.
3983  if (DD.StackSize == DD.ActiveStackBase)
3984    return;
3985
3986  // We only want to actually emit delayed diagnostics when we
3987  // successfully parsed a decl.
3988  if (decl && !decl->isInvalidDecl()) {
3989    // We emit all the active diagnostics, not just those starting
3990    // from the saved state.  The idea is this:  we get one push for a
3991    // decl spec and another for each declarator;  in a decl group like:
3992    //   deprecated_typedef foo, *bar, baz();
3993    // only the declarator pops will be passed decls.  This is correct;
3994    // we really do need to consider delayed diagnostics from the decl spec
3995    // for each of the different declarations.
3996    for (unsigned i = DD.ActiveStackBase, e = DD.StackSize; i != e; ++i) {
3997      DelayedDiagnostic &diag = DD.Stack[i];
3998      if (diag.Triggered)
3999        continue;
4000
4001      switch (diag.Kind) {
4002      case DelayedDiagnostic::Deprecation:
4003        S.HandleDelayedDeprecationCheck(diag, decl);
4004        break;
4005
4006      case DelayedDiagnostic::Access:
4007        S.HandleDelayedAccessCheck(diag, decl);
4008        break;
4009
4010      case DelayedDiagnostic::ForbiddenType:
4011        handleDelayedForbiddenType(S, diag, decl);
4012        break;
4013      }
4014    }
4015  }
4016
4017  // Destroy all the delayed diagnostics we're about to pop off.
4018  for (unsigned i = state.SavedStackSize, e = DD.StackSize; i != e; ++i)
4019    DD.Stack[i].Destroy();
4020
4021  DD.StackSize = state.SavedStackSize;
4022}
4023
4024static bool isDeclDeprecated(Decl *D) {
4025  do {
4026    if (D->isDeprecated())
4027      return true;
4028    // A category implicitly has the availability of the interface.
4029    if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
4030      return CatD->getClassInterface()->isDeprecated();
4031  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
4032  return false;
4033}
4034
4035void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
4036                                         Decl *Ctx) {
4037  if (isDeclDeprecated(Ctx))
4038    return;
4039
4040  DD.Triggered = true;
4041  if (!DD.getDeprecationMessage().empty())
4042    Diag(DD.Loc, diag::warn_deprecated_message)
4043      << DD.getDeprecationDecl()->getDeclName()
4044      << DD.getDeprecationMessage();
4045  else
4046    Diag(DD.Loc, diag::warn_deprecated)
4047      << DD.getDeprecationDecl()->getDeclName();
4048}
4049
4050void Sema::EmitDeprecationWarning(NamedDecl *D, StringRef Message,
4051                                  SourceLocation Loc,
4052                                  const ObjCInterfaceDecl *UnknownObjCClass) {
4053  // Delay if we're currently parsing a declaration.
4054  if (DelayedDiagnostics.shouldDelayDiagnostics()) {
4055    DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D, Message));
4056    return;
4057  }
4058
4059  // Otherwise, don't warn if our current context is deprecated.
4060  if (isDeclDeprecated(cast<Decl>(getCurLexicalContext())))
4061    return;
4062  if (!Message.empty())
4063    Diag(Loc, diag::warn_deprecated_message) << D->getDeclName()
4064                                             << Message;
4065  else {
4066    if (!UnknownObjCClass)
4067      Diag(Loc, diag::warn_deprecated) << D->getDeclName();
4068    else {
4069      Diag(Loc, diag::warn_deprecated_fwdclass_message) << D->getDeclName();
4070      Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
4071    }
4072  }
4073}
4074