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