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