SemaDeclAttr.cpp revision 28965bfa833926fd908a902cf2373d07c47b9067 
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  // FIXME: The C++11 version of this attribute should error out when it is
3319  //        used to specify a weaker alignment, rather than being silently
3320  //        ignored. This constraint cannot be applied until we have seen
3321  //        all the attributes which apply to the variable.
3322
3323  if (Attr.getNumArgs() == 0) {
3324    D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
3325               true, 0, Attr.getAttributeSpellingListIndex()));
3326    return;
3327  }
3328
3329  S.AddAlignedAttr(Attr.getRange(), D, Attr.getArg(0),
3330                   Attr.getAttributeSpellingListIndex());
3331}
3332
3333void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3334                          unsigned SpellingListIndex) {
3335  // FIXME: Handle pack-expansions here.
3336  if (DiagnoseUnexpandedParameterPack(E))
3337    return;
3338
3339  AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3340  SourceLocation AttrLoc = AttrRange.getBegin();
3341
3342  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3343  if (TmpAttr.isAlignas()) {
3344    // C++11 [dcl.align]p1:
3345    //   An alignment-specifier may be applied to a variable or to a class
3346    //   data member, but it shall not be applied to a bit-field, a function
3347    //   parameter, the formal parameter of a catch clause, or a variable
3348    //   declared with the register storage class specifier. An
3349    //   alignment-specifier may also be applied to the declaration of a class
3350    //   or enumeration type.
3351    // C11 6.7.5/2:
3352    //   An alignment attribute shall not be specified in a declaration of
3353    //   a typedef, or a bit-field, or a function, or a parameter, or an
3354    //   object declared with the register storage-class specifier.
3355    int DiagKind = -1;
3356    if (isa<ParmVarDecl>(D)) {
3357      DiagKind = 0;
3358    } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
3359      if (VD->getStorageClass() == SC_Register)
3360        DiagKind = 1;
3361      if (VD->isExceptionVariable())
3362        DiagKind = 2;
3363    } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
3364      if (FD->isBitField())
3365        DiagKind = 3;
3366    } else if (!isa<TagDecl>(D)) {
3367      Diag(AttrLoc, diag::err_attribute_wrong_decl_type)
3368        << (TmpAttr.isC11() ? "'_Alignas'" : "'alignas'")
3369        << (TmpAttr.isC11() ? ExpectedVariableOrField
3370                            : ExpectedVariableFieldOrTag);
3371      return;
3372    }
3373    if (DiagKind != -1) {
3374      Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3375        << TmpAttr.isC11() << DiagKind;
3376      return;
3377    }
3378  }
3379
3380  if (E->isTypeDependent() || E->isValueDependent()) {
3381    // Save dependent expressions in the AST to be instantiated.
3382    D->addAttr(::new (Context) AlignedAttr(TmpAttr));
3383    return;
3384  }
3385
3386  // FIXME: Cache the number on the Attr object?
3387  llvm::APSInt Alignment(32);
3388  ExprResult ICE
3389    = VerifyIntegerConstantExpression(E, &Alignment,
3390        diag::err_aligned_attribute_argument_not_int,
3391        /*AllowFold*/ false);
3392  if (ICE.isInvalid())
3393    return;
3394
3395  // C++11 [dcl.align]p2:
3396  //   -- if the constant expression evaluates to zero, the alignment
3397  //      specifier shall have no effect
3398  // C11 6.7.5p6:
3399  //   An alignment specification of zero has no effect.
3400  if (!(TmpAttr.isAlignas() && !Alignment) &&
3401      !llvm::isPowerOf2_64(Alignment.getZExtValue())) {
3402    Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
3403      << E->getSourceRange();
3404    return;
3405  }
3406
3407  if (TmpAttr.isDeclspec()) {
3408    // We've already verified it's a power of 2, now let's make sure it's
3409    // 8192 or less.
3410    if (Alignment.getZExtValue() > 8192) {
3411      Diag(AttrLoc, diag::err_attribute_aligned_greater_than_8192)
3412        << E->getSourceRange();
3413      return;
3414    }
3415  }
3416
3417  D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true,
3418                                         ICE.take(), SpellingListIndex));
3419}
3420
3421void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3422                          unsigned SpellingListIndex) {
3423  // FIXME: Cache the number on the Attr object if non-dependent?
3424  // FIXME: Perform checking of type validity
3425  D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3426                                         SpellingListIndex));
3427  return;
3428}
3429
3430void Sema::CheckAlignasUnderalignment(Decl *D) {
3431  assert(D->hasAttrs() && "no attributes on decl");
3432
3433  QualType Ty;
3434  if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3435    Ty = VD->getType();
3436  else
3437    Ty = Context.getTagDeclType(cast<TagDecl>(D));
3438  if (Ty->isDependentType())
3439    return;
3440
3441  // C++11 [dcl.align]p5, C11 6.7.5/4:
3442  //   The combined effect of all alignment attributes in a declaration shall
3443  //   not specify an alignment that is less strict than the alignment that
3444  //   would otherwise be required for the entity being declared.
3445  AlignedAttr *AlignasAttr = 0;
3446  unsigned Align = 0;
3447  for (specific_attr_iterator<AlignedAttr>
3448         I = D->specific_attr_begin<AlignedAttr>(),
3449         E = D->specific_attr_end<AlignedAttr>(); I != E; ++I) {
3450    if (I->isAlignmentDependent())
3451      return;
3452    if (I->isAlignas())
3453      AlignasAttr = *I;
3454    Align = std::max(Align, I->getAlignment(Context));
3455  }
3456
3457  if (AlignasAttr && Align) {
3458    CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3459    CharUnits NaturalAlign = Context.getTypeAlignInChars(Ty);
3460    if (NaturalAlign > RequestedAlign)
3461      Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3462        << Ty << (unsigned)NaturalAlign.getQuantity();
3463  }
3464}
3465
3466/// handleModeAttr - This attribute modifies the width of a decl with primitive
3467/// type.
3468///
3469/// Despite what would be logical, the mode attribute is a decl attribute, not a
3470/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3471/// HImode, not an intermediate pointer.
3472static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3473  // This attribute isn't documented, but glibc uses it.  It changes
3474  // the width of an int or unsigned int to the specified size.
3475
3476  // Check that there aren't any arguments
3477  if (!checkAttributeNumArgs(S, Attr, 0))
3478    return;
3479
3480
3481  IdentifierInfo *Name = Attr.getParameterName();
3482  if (!Name) {
3483    S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
3484    return;
3485  }
3486
3487  StringRef Str = Attr.getParameterName()->getName();
3488
3489  // Normalize the attribute name, __foo__ becomes foo.
3490  if (Str.startswith("__") && Str.endswith("__"))
3491    Str = Str.substr(2, Str.size() - 4);
3492
3493  unsigned DestWidth = 0;
3494  bool IntegerMode = true;
3495  bool ComplexMode = false;
3496  switch (Str.size()) {
3497  case 2:
3498    switch (Str[0]) {
3499    case 'Q': DestWidth = 8; break;
3500    case 'H': DestWidth = 16; break;
3501    case 'S': DestWidth = 32; break;
3502    case 'D': DestWidth = 64; break;
3503    case 'X': DestWidth = 96; break;
3504    case 'T': DestWidth = 128; break;
3505    }
3506    if (Str[1] == 'F') {
3507      IntegerMode = false;
3508    } else if (Str[1] == 'C') {
3509      IntegerMode = false;
3510      ComplexMode = true;
3511    } else if (Str[1] != 'I') {
3512      DestWidth = 0;
3513    }
3514    break;
3515  case 4:
3516    // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3517    // pointer on PIC16 and other embedded platforms.
3518    if (Str == "word")
3519      DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3520    else if (Str == "byte")
3521      DestWidth = S.Context.getTargetInfo().getCharWidth();
3522    break;
3523  case 7:
3524    if (Str == "pointer")
3525      DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3526    break;
3527  case 11:
3528    if (Str == "unwind_word")
3529      DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
3530    break;
3531  }
3532
3533  QualType OldTy;
3534  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3535    OldTy = TD->getUnderlyingType();
3536  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3537    OldTy = VD->getType();
3538  else {
3539    S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
3540      << "mode" << Attr.getRange();
3541    return;
3542  }
3543
3544  if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
3545    S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
3546  else if (IntegerMode) {
3547    if (!OldTy->isIntegralOrEnumerationType())
3548      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3549  } else if (ComplexMode) {
3550    if (!OldTy->isComplexType())
3551      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3552  } else {
3553    if (!OldTy->isFloatingType())
3554      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3555  }
3556
3557  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3558  // and friends, at least with glibc.
3559  // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
3560  // width on unusual platforms.
3561  // FIXME: Make sure floating-point mappings are accurate
3562  // FIXME: Support XF and TF types
3563  QualType NewTy;
3564  switch (DestWidth) {
3565  case 0:
3566    S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
3567    return;
3568  default:
3569    S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3570    return;
3571  case 8:
3572    if (!IntegerMode) {
3573      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3574      return;
3575    }
3576    if (OldTy->isSignedIntegerType())
3577      NewTy = S.Context.SignedCharTy;
3578    else
3579      NewTy = S.Context.UnsignedCharTy;
3580    break;
3581  case 16:
3582    if (!IntegerMode) {
3583      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3584      return;
3585    }
3586    if (OldTy->isSignedIntegerType())
3587      NewTy = S.Context.ShortTy;
3588    else
3589      NewTy = S.Context.UnsignedShortTy;
3590    break;
3591  case 32:
3592    if (!IntegerMode)
3593      NewTy = S.Context.FloatTy;
3594    else if (OldTy->isSignedIntegerType())
3595      NewTy = S.Context.IntTy;
3596    else
3597      NewTy = S.Context.UnsignedIntTy;
3598    break;
3599  case 64:
3600    if (!IntegerMode)
3601      NewTy = S.Context.DoubleTy;
3602    else if (OldTy->isSignedIntegerType())
3603      if (S.Context.getTargetInfo().getLongWidth() == 64)
3604        NewTy = S.Context.LongTy;
3605      else
3606        NewTy = S.Context.LongLongTy;
3607    else
3608      if (S.Context.getTargetInfo().getLongWidth() == 64)
3609        NewTy = S.Context.UnsignedLongTy;
3610      else
3611        NewTy = S.Context.UnsignedLongLongTy;
3612    break;
3613  case 96:
3614    NewTy = S.Context.LongDoubleTy;
3615    break;
3616  case 128:
3617    if (!IntegerMode) {
3618      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3619      return;
3620    }
3621    if (OldTy->isSignedIntegerType())
3622      NewTy = S.Context.Int128Ty;
3623    else
3624      NewTy = S.Context.UnsignedInt128Ty;
3625    break;
3626  }
3627
3628  if (ComplexMode) {
3629    NewTy = S.Context.getComplexType(NewTy);
3630  }
3631
3632  // Install the new type.
3633  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
3634    // FIXME: preserve existing source info.
3635    TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
3636  } else
3637    cast<ValueDecl>(D)->setType(NewTy);
3638}
3639
3640static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3641  // check the attribute arguments.
3642  if (!checkAttributeNumArgs(S, Attr, 0))
3643    return;
3644
3645  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
3646    if (!VD->hasGlobalStorage())
3647      S.Diag(Attr.getLoc(),
3648             diag::warn_attribute_requires_functions_or_static_globals)
3649        << Attr.getName();
3650  } else if (!isFunctionOrMethod(D)) {
3651    S.Diag(Attr.getLoc(),
3652           diag::warn_attribute_requires_functions_or_static_globals)
3653      << Attr.getName();
3654    return;
3655  }
3656
3657  D->addAttr(::new (S.Context)
3658             NoDebugAttr(Attr.getRange(), S.Context,
3659                         Attr.getAttributeSpellingListIndex()));
3660}
3661
3662static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3663  // check the attribute arguments.
3664  if (!checkAttributeNumArgs(S, Attr, 0))
3665    return;
3666
3667
3668  if (!isa<FunctionDecl>(D)) {
3669    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3670      << Attr.getName() << ExpectedFunction;
3671    return;
3672  }
3673
3674  D->addAttr(::new (S.Context)
3675             NoInlineAttr(Attr.getRange(), S.Context,
3676             Attr.getAttributeSpellingListIndex()));
3677}
3678
3679static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
3680                                           const AttributeList &Attr) {
3681  // check the attribute arguments.
3682  if (!checkAttributeNumArgs(S, Attr, 0))
3683    return;
3684
3685
3686  if (!isa<FunctionDecl>(D)) {
3687    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3688      << Attr.getName() << ExpectedFunction;
3689    return;
3690  }
3691
3692  D->addAttr(::new (S.Context)
3693             NoInstrumentFunctionAttr(Attr.getRange(), S.Context,
3694                                      Attr.getAttributeSpellingListIndex()));
3695}
3696
3697static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3698  if (S.LangOpts.CUDA) {
3699    // check the attribute arguments.
3700    if (Attr.hasParameterOrArguments()) {
3701      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3702      return;
3703    }
3704
3705    if (!isa<VarDecl>(D)) {
3706      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3707        << Attr.getName() << ExpectedVariable;
3708      return;
3709    }
3710
3711    D->addAttr(::new (S.Context)
3712               CUDAConstantAttr(Attr.getRange(), S.Context,
3713                                Attr.getAttributeSpellingListIndex()));
3714  } else {
3715    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
3716  }
3717}
3718
3719static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3720  if (S.LangOpts.CUDA) {
3721    // check the attribute arguments.
3722    if (Attr.getNumArgs() != 0) {
3723      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3724      return;
3725    }
3726
3727    if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
3728      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3729        << Attr.getName() << ExpectedVariableOrFunction;
3730      return;
3731    }
3732
3733    D->addAttr(::new (S.Context)
3734               CUDADeviceAttr(Attr.getRange(), S.Context,
3735                              Attr.getAttributeSpellingListIndex()));
3736  } else {
3737    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
3738  }
3739}
3740
3741static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3742  if (S.LangOpts.CUDA) {
3743    // check the attribute arguments.
3744    if (!checkAttributeNumArgs(S, Attr, 0))
3745      return;
3746
3747    if (!isa<FunctionDecl>(D)) {
3748      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3749        << Attr.getName() << ExpectedFunction;
3750      return;
3751    }
3752
3753    FunctionDecl *FD = cast<FunctionDecl>(D);
3754    if (!FD->getResultType()->isVoidType()) {
3755      TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
3756      if (FunctionTypeLoc FTL = TL.getAs<FunctionTypeLoc>()) {
3757        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3758          << FD->getType()
3759          << FixItHint::CreateReplacement(FTL.getResultLoc().getSourceRange(),
3760                                          "void");
3761      } else {
3762        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3763          << FD->getType();
3764      }
3765      return;
3766    }
3767
3768    D->addAttr(::new (S.Context)
3769               CUDAGlobalAttr(Attr.getRange(), S.Context,
3770                              Attr.getAttributeSpellingListIndex()));
3771  } else {
3772    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
3773  }
3774}
3775
3776static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3777  if (S.LangOpts.CUDA) {
3778    // check the attribute arguments.
3779    if (!checkAttributeNumArgs(S, Attr, 0))
3780      return;
3781
3782
3783    if (!isa<FunctionDecl>(D)) {
3784      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3785        << Attr.getName() << ExpectedFunction;
3786      return;
3787    }
3788
3789    D->addAttr(::new (S.Context)
3790               CUDAHostAttr(Attr.getRange(), S.Context,
3791                            Attr.getAttributeSpellingListIndex()));
3792  } else {
3793    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
3794  }
3795}
3796
3797static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3798  if (S.LangOpts.CUDA) {
3799    // check the attribute arguments.
3800    if (!checkAttributeNumArgs(S, Attr, 0))
3801      return;
3802
3803    if (!isa<VarDecl>(D)) {
3804      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3805        << Attr.getName() << ExpectedVariable;
3806      return;
3807    }
3808
3809    D->addAttr(::new (S.Context)
3810               CUDASharedAttr(Attr.getRange(), S.Context,
3811                              Attr.getAttributeSpellingListIndex()));
3812  } else {
3813    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
3814  }
3815}
3816
3817static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3818  // check the attribute arguments.
3819  if (!checkAttributeNumArgs(S, Attr, 0))
3820    return;
3821
3822  FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
3823  if (Fn == 0) {
3824    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3825      << Attr.getName() << ExpectedFunction;
3826    return;
3827  }
3828
3829  if (!Fn->isInlineSpecified()) {
3830    S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
3831    return;
3832  }
3833
3834  D->addAttr(::new (S.Context)
3835             GNUInlineAttr(Attr.getRange(), S.Context,
3836                           Attr.getAttributeSpellingListIndex()));
3837}
3838
3839static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3840  if (hasDeclarator(D)) return;
3841
3842  const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
3843  // Diagnostic is emitted elsewhere: here we store the (valid) Attr
3844  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
3845  CallingConv CC;
3846  if (S.CheckCallingConvAttr(Attr, CC, FD))
3847    return;
3848
3849  if (!isa<ObjCMethodDecl>(D)) {
3850    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3851      << Attr.getName() << ExpectedFunctionOrMethod;
3852    return;
3853  }
3854
3855  switch (Attr.getKind()) {
3856  case AttributeList::AT_FastCall:
3857    D->addAttr(::new (S.Context)
3858               FastCallAttr(Attr.getRange(), S.Context,
3859                            Attr.getAttributeSpellingListIndex()));
3860    return;
3861  case AttributeList::AT_StdCall:
3862    D->addAttr(::new (S.Context)
3863               StdCallAttr(Attr.getRange(), S.Context,
3864                           Attr.getAttributeSpellingListIndex()));
3865    return;
3866  case AttributeList::AT_ThisCall:
3867    D->addAttr(::new (S.Context)
3868               ThisCallAttr(Attr.getRange(), S.Context,
3869                            Attr.getAttributeSpellingListIndex()));
3870    return;
3871  case AttributeList::AT_CDecl:
3872    D->addAttr(::new (S.Context)
3873               CDeclAttr(Attr.getRange(), S.Context,
3874                         Attr.getAttributeSpellingListIndex()));
3875    return;
3876  case AttributeList::AT_Pascal:
3877    D->addAttr(::new (S.Context)
3878               PascalAttr(Attr.getRange(), S.Context,
3879                          Attr.getAttributeSpellingListIndex()));
3880    return;
3881  case AttributeList::AT_Pcs: {
3882    PcsAttr::PCSType PCS;
3883    switch (CC) {
3884    case CC_AAPCS:
3885      PCS = PcsAttr::AAPCS;
3886      break;
3887    case CC_AAPCS_VFP:
3888      PCS = PcsAttr::AAPCS_VFP;
3889      break;
3890    default:
3891      llvm_unreachable("unexpected calling convention in pcs attribute");
3892    }
3893
3894    D->addAttr(::new (S.Context)
3895               PcsAttr(Attr.getRange(), S.Context, PCS,
3896                       Attr.getAttributeSpellingListIndex()));
3897    return;
3898  }
3899  case AttributeList::AT_PnaclCall:
3900    D->addAttr(::new (S.Context)
3901               PnaclCallAttr(Attr.getRange(), S.Context,
3902                             Attr.getAttributeSpellingListIndex()));
3903    return;
3904  case AttributeList::AT_IntelOclBicc:
3905    D->addAttr(::new (S.Context)
3906               IntelOclBiccAttr(Attr.getRange(), S.Context,
3907                                Attr.getAttributeSpellingListIndex()));
3908    return;
3909
3910  default:
3911    llvm_unreachable("unexpected attribute kind");
3912  }
3913}
3914
3915static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
3916  assert(!Attr.isInvalid());
3917  D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getRange(), S.Context));
3918}
3919
3920bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC,
3921                                const FunctionDecl *FD) {
3922  if (attr.isInvalid())
3923    return true;
3924
3925  unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0;
3926  if (attr.getNumArgs() != ReqArgs || attr.getParameterName()) {
3927    Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << ReqArgs;
3928    attr.setInvalid();
3929    return true;
3930  }
3931
3932  // TODO: diagnose uses of these conventions on the wrong target. Or, better
3933  // move to TargetAttributesSema one day.
3934  switch (attr.getKind()) {
3935  case AttributeList::AT_CDecl: CC = CC_C; break;
3936  case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
3937  case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
3938  case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
3939  case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
3940  case AttributeList::AT_Pcs: {
3941    Expr *Arg = attr.getArg(0);
3942    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
3943    if (!Str || !Str->isAscii()) {
3944      Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
3945        << "pcs" << 1;
3946      attr.setInvalid();
3947      return true;
3948    }
3949
3950    StringRef StrRef = Str->getString();
3951    if (StrRef == "aapcs") {
3952      CC = CC_AAPCS;
3953      break;
3954    } else if (StrRef == "aapcs-vfp") {
3955      CC = CC_AAPCS_VFP;
3956      break;
3957    }
3958
3959    attr.setInvalid();
3960    Diag(attr.getLoc(), diag::err_invalid_pcs);
3961    return true;
3962  }
3963  case AttributeList::AT_PnaclCall: CC = CC_PnaclCall; break;
3964  case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
3965  default: llvm_unreachable("unexpected attribute kind");
3966  }
3967
3968  const TargetInfo &TI = Context.getTargetInfo();
3969  TargetInfo::CallingConvCheckResult A = TI.checkCallingConvention(CC);
3970  if (A == TargetInfo::CCCR_Warning) {
3971    Diag(attr.getLoc(), diag::warn_cconv_ignored) << attr.getName();
3972
3973    TargetInfo::CallingConvMethodType MT = TargetInfo::CCMT_Unknown;
3974    if (FD)
3975      MT = FD->isCXXInstanceMember() ? TargetInfo::CCMT_Member :
3976                                    TargetInfo::CCMT_NonMember;
3977    CC = TI.getDefaultCallingConv(MT);
3978  }
3979
3980  return false;
3981}
3982
3983static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3984  if (hasDeclarator(D)) return;
3985
3986  unsigned numParams;
3987  if (S.CheckRegparmAttr(Attr, numParams))
3988    return;
3989
3990  if (!isa<ObjCMethodDecl>(D)) {
3991    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3992      << Attr.getName() << ExpectedFunctionOrMethod;
3993    return;
3994  }
3995
3996  D->addAttr(::new (S.Context)
3997             RegparmAttr(Attr.getRange(), S.Context, numParams,
3998                         Attr.getAttributeSpellingListIndex()));
3999}
4000
4001/// Checks a regparm attribute, returning true if it is ill-formed and
4002/// otherwise setting numParams to the appropriate value.
4003bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
4004  if (Attr.isInvalid())
4005    return true;
4006
4007  if (Attr.getNumArgs() != 1) {
4008    Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
4009    Attr.setInvalid();
4010    return true;
4011  }
4012
4013  Expr *NumParamsExpr = Attr.getArg(0);
4014  llvm::APSInt NumParams(32);
4015  if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
4016      !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
4017    Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
4018      << "regparm" << NumParamsExpr->getSourceRange();
4019    Attr.setInvalid();
4020    return true;
4021  }
4022
4023  if (Context.getTargetInfo().getRegParmMax() == 0) {
4024    Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
4025      << NumParamsExpr->getSourceRange();
4026    Attr.setInvalid();
4027    return true;
4028  }
4029
4030  numParams = NumParams.getZExtValue();
4031  if (numParams > Context.getTargetInfo().getRegParmMax()) {
4032    Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
4033      << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4034    Attr.setInvalid();
4035    return true;
4036  }
4037
4038  return false;
4039}
4040
4041static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
4042  if (S.LangOpts.CUDA) {
4043    // check the attribute arguments.
4044    if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
4045      // FIXME: 0 is not okay.
4046      S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
4047      return;
4048    }
4049
4050    if (!isFunctionOrMethod(D)) {
4051      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4052        << Attr.getName() << ExpectedFunctionOrMethod;
4053      return;
4054    }
4055
4056    Expr *MaxThreadsExpr = Attr.getArg(0);
4057    llvm::APSInt MaxThreads(32);
4058    if (MaxThreadsExpr->isTypeDependent() ||
4059        MaxThreadsExpr->isValueDependent() ||
4060        !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
4061      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
4062        << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
4063      return;
4064    }
4065
4066    llvm::APSInt MinBlocks(32);
4067    if (Attr.getNumArgs() > 1) {
4068      Expr *MinBlocksExpr = Attr.getArg(1);
4069      if (MinBlocksExpr->isTypeDependent() ||
4070          MinBlocksExpr->isValueDependent() ||
4071          !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
4072        S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
4073          << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
4074        return;
4075      }
4076    }
4077
4078    D->addAttr(::new (S.Context)
4079               CUDALaunchBoundsAttr(Attr.getRange(), S.Context,
4080                                    MaxThreads.getZExtValue(),
4081                                    MinBlocks.getZExtValue(),
4082                                    Attr.getAttributeSpellingListIndex()));
4083  } else {
4084    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
4085  }
4086}
4087
4088static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
4089                                          const AttributeList &Attr) {
4090  StringRef AttrName = Attr.getName()->getName();
4091  if (!Attr.getParameterName()) {
4092    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier)
4093      << Attr.getName() << /* arg num = */ 1;
4094    return;
4095  }
4096
4097  if (Attr.getNumArgs() != 2) {
4098    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
4099      << /* required args = */ 3;
4100    return;
4101  }
4102
4103  IdentifierInfo *ArgumentKind = Attr.getParameterName();
4104
4105  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
4106    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
4107      << Attr.getName() << ExpectedFunctionOrMethod;
4108    return;
4109  }
4110
4111  uint64_t ArgumentIdx;
4112  if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName,
4113                                          Attr.getLoc(), 2,
4114                                          Attr.getArg(0), ArgumentIdx))
4115    return;
4116
4117  uint64_t TypeTagIdx;
4118  if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName,
4119                                          Attr.getLoc(), 3,
4120                                          Attr.getArg(1), TypeTagIdx))
4121    return;
4122
4123  bool IsPointer = (AttrName == "pointer_with_type_tag");
4124  if (IsPointer) {
4125    // Ensure that buffer has a pointer type.
4126    QualType BufferTy = getFunctionOrMethodArgType(D, ArgumentIdx);
4127    if (!BufferTy->isPointerType()) {
4128      S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
4129        << AttrName;
4130    }
4131  }
4132
4133  D->addAttr(::new (S.Context)
4134             ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
4135                                     ArgumentIdx, TypeTagIdx, IsPointer,
4136                                     Attr.getAttributeSpellingListIndex()));
4137}
4138
4139static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
4140                                         const AttributeList &Attr) {
4141  IdentifierInfo *PointerKind = Attr.getParameterName();
4142  if (!PointerKind) {
4143    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier)
4144      << "type_tag_for_datatype" << 1;
4145    return;
4146  }
4147
4148  QualType MatchingCType = S.GetTypeFromParser(Attr.getMatchingCType(), NULL);
4149
4150  D->addAttr(::new (S.Context)
4151             TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
4152                                    MatchingCType,
4153                                    Attr.getLayoutCompatible(),
4154                                    Attr.getMustBeNull(),
4155                                    Attr.getAttributeSpellingListIndex()));
4156}
4157
4158//===----------------------------------------------------------------------===//
4159// Checker-specific attribute handlers.
4160//===----------------------------------------------------------------------===//
4161
4162static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
4163  return type->isDependentType() ||
4164         type->isObjCObjectPointerType() ||
4165         S.Context.isObjCNSObjectType(type);
4166}
4167static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
4168  return type->isDependentType() ||
4169         type->isPointerType() ||
4170         isValidSubjectOfNSAttribute(S, type);
4171}
4172
4173static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4174  ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
4175  if (!param) {
4176    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4177      << Attr.getRange() << Attr.getName() << ExpectedParameter;
4178    return;
4179  }
4180
4181  bool typeOK, cf;
4182  if (Attr.getKind() == AttributeList::AT_NSConsumed) {
4183    typeOK = isValidSubjectOfNSAttribute(S, param->getType());
4184    cf = false;
4185  } else {
4186    typeOK = isValidSubjectOfCFAttribute(S, param->getType());
4187    cf = true;
4188  }
4189
4190  if (!typeOK) {
4191    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4192      << Attr.getRange() << Attr.getName() << cf;
4193    return;
4194  }
4195
4196  if (cf)
4197    param->addAttr(::new (S.Context)
4198                   CFConsumedAttr(Attr.getRange(), S.Context,
4199                                  Attr.getAttributeSpellingListIndex()));
4200  else
4201    param->addAttr(::new (S.Context)
4202                   NSConsumedAttr(Attr.getRange(), S.Context,
4203                                  Attr.getAttributeSpellingListIndex()));
4204}
4205
4206static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
4207                                     const AttributeList &Attr) {
4208  if (!isa<ObjCMethodDecl>(D)) {
4209    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4210      << Attr.getRange() << Attr.getName() << ExpectedMethod;
4211    return;
4212  }
4213
4214  D->addAttr(::new (S.Context)
4215             NSConsumesSelfAttr(Attr.getRange(), S.Context,
4216                                Attr.getAttributeSpellingListIndex()));
4217}
4218
4219static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
4220                                        const AttributeList &Attr) {
4221
4222  QualType returnType;
4223
4224  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
4225    returnType = MD->getResultType();
4226  else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
4227           (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
4228    return; // ignore: was handled as a type attribute
4229  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
4230    returnType = PD->getType();
4231  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
4232    returnType = FD->getResultType();
4233  else {
4234    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4235        << Attr.getRange() << Attr.getName()
4236        << ExpectedFunctionOrMethod;
4237    return;
4238  }
4239
4240  bool typeOK;
4241  bool cf;
4242  switch (Attr.getKind()) {
4243  default: llvm_unreachable("invalid ownership attribute");
4244  case AttributeList::AT_NSReturnsAutoreleased:
4245  case AttributeList::AT_NSReturnsRetained:
4246  case AttributeList::AT_NSReturnsNotRetained:
4247    typeOK = isValidSubjectOfNSAttribute(S, returnType);
4248    cf = false;
4249    break;
4250
4251  case AttributeList::AT_CFReturnsRetained:
4252  case AttributeList::AT_CFReturnsNotRetained:
4253    typeOK = isValidSubjectOfCFAttribute(S, returnType);
4254    cf = true;
4255    break;
4256  }
4257
4258  if (!typeOK) {
4259    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4260      << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
4261    return;
4262  }
4263
4264  switch (Attr.getKind()) {
4265    default:
4266      llvm_unreachable("invalid ownership attribute");
4267    case AttributeList::AT_NSReturnsAutoreleased:
4268      D->addAttr(::new (S.Context)
4269                 NSReturnsAutoreleasedAttr(Attr.getRange(), S.Context,
4270                                           Attr.getAttributeSpellingListIndex()));
4271      return;
4272    case AttributeList::AT_CFReturnsNotRetained:
4273      D->addAttr(::new (S.Context)
4274                 CFReturnsNotRetainedAttr(Attr.getRange(), S.Context,
4275                                          Attr.getAttributeSpellingListIndex()));
4276      return;
4277    case AttributeList::AT_NSReturnsNotRetained:
4278      D->addAttr(::new (S.Context)
4279                 NSReturnsNotRetainedAttr(Attr.getRange(), S.Context,
4280                                          Attr.getAttributeSpellingListIndex()));
4281      return;
4282    case AttributeList::AT_CFReturnsRetained:
4283      D->addAttr(::new (S.Context)
4284                 CFReturnsRetainedAttr(Attr.getRange(), S.Context,
4285                                       Attr.getAttributeSpellingListIndex()));
4286      return;
4287    case AttributeList::AT_NSReturnsRetained:
4288      D->addAttr(::new (S.Context)
4289                 NSReturnsRetainedAttr(Attr.getRange(), S.Context,
4290                                       Attr.getAttributeSpellingListIndex()));
4291      return;
4292  };
4293}
4294
4295static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
4296                                              const AttributeList &attr) {
4297  SourceLocation loc = attr.getLoc();
4298
4299  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
4300
4301  if (!method) {
4302    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4303      << SourceRange(loc, loc) << attr.getName() << ExpectedMethod;
4304    return;
4305  }
4306
4307  // Check that the method returns a normal pointer.
4308  QualType resultType = method->getResultType();
4309
4310  if (!resultType->isReferenceType() &&
4311      (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
4312    S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4313      << SourceRange(loc)
4314      << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2;
4315
4316    // Drop the attribute.
4317    return;
4318  }
4319
4320  method->addAttr(::new (S.Context)
4321                  ObjCReturnsInnerPointerAttr(attr.getRange(), S.Context,
4322                                              attr.getAttributeSpellingListIndex()));
4323}
4324
4325static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
4326                                        const AttributeList &attr) {
4327  SourceLocation loc = attr.getLoc();
4328  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
4329
4330  if (!method) {
4331   S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4332   << SourceRange(loc, loc) << attr.getName() << ExpectedMethod;
4333    return;
4334  }
4335  DeclContext *DC = method->getDeclContext();
4336  if (const ObjCProtocolDecl *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
4337    S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4338    << attr.getName() << 0;
4339    S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
4340    return;
4341  }
4342  if (method->getMethodFamily() == OMF_dealloc) {
4343    S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4344    << attr.getName() << 1;
4345    return;
4346  }
4347
4348  method->addAttr(::new (S.Context)
4349                  ObjCRequiresSuperAttr(attr.getRange(), S.Context,
4350                                        attr.getAttributeSpellingListIndex()));
4351}
4352
4353/// Handle cf_audited_transfer and cf_unknown_transfer.
4354static void handleCFTransferAttr(Sema &S, Decl *D, const AttributeList &A) {
4355  if (!isa<FunctionDecl>(D)) {
4356    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4357      << A.getRange() << A.getName() << ExpectedFunction;
4358    return;
4359  }
4360
4361  bool IsAudited = (A.getKind() == AttributeList::AT_CFAuditedTransfer);
4362
4363  // Check whether there's a conflicting attribute already present.
4364  Attr *Existing;
4365  if (IsAudited) {
4366    Existing = D->getAttr<CFUnknownTransferAttr>();
4367  } else {
4368    Existing = D->getAttr<CFAuditedTransferAttr>();
4369  }
4370  if (Existing) {
4371    S.Diag(D->getLocStart(), diag::err_attributes_are_not_compatible)
4372      << A.getName()
4373      << (IsAudited ? "cf_unknown_transfer" : "cf_audited_transfer")
4374      << A.getRange() << Existing->getRange();
4375    return;
4376  }
4377
4378  // All clear;  add the attribute.
4379  if (IsAudited) {
4380    D->addAttr(::new (S.Context)
4381               CFAuditedTransferAttr(A.getRange(), S.Context,
4382                                     A.getAttributeSpellingListIndex()));
4383  } else {
4384    D->addAttr(::new (S.Context)
4385               CFUnknownTransferAttr(A.getRange(), S.Context,
4386                                     A.getAttributeSpellingListIndex()));
4387  }
4388}
4389
4390static void handleNSBridgedAttr(Sema &S, Scope *Sc, Decl *D,
4391                                const AttributeList &Attr) {
4392  RecordDecl *RD = dyn_cast<RecordDecl>(D);
4393  if (!RD || RD->isUnion()) {
4394    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4395      << Attr.getRange() << Attr.getName() << ExpectedStruct;
4396  }
4397
4398  IdentifierInfo *ParmName = Attr.getParameterName();
4399
4400  // In Objective-C, verify that the type names an Objective-C type.
4401  // We don't want to check this outside of ObjC because people sometimes
4402  // do crazy C declarations of Objective-C types.
4403  if (ParmName && S.getLangOpts().ObjC1) {
4404    // Check for an existing type with this name.
4405    LookupResult R(S, DeclarationName(ParmName), Attr.getParameterLoc(),
4406                   Sema::LookupOrdinaryName);
4407    if (S.LookupName(R, Sc)) {
4408      NamedDecl *Target = R.getFoundDecl();
4409      if (Target && !isa<ObjCInterfaceDecl>(Target)) {
4410        S.Diag(D->getLocStart(), diag::err_ns_bridged_not_interface);
4411        S.Diag(Target->getLocStart(), diag::note_declared_at);
4412      }
4413    }
4414  }
4415
4416  D->addAttr(::new (S.Context)
4417             NSBridgedAttr(Attr.getRange(), S.Context, ParmName,
4418                           Attr.getAttributeSpellingListIndex()));
4419}
4420
4421static void handleObjCOwnershipAttr(Sema &S, Decl *D,
4422                                    const AttributeList &Attr) {
4423  if (hasDeclarator(D)) return;
4424
4425  S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4426    << Attr.getRange() << Attr.getName() << ExpectedVariable;
4427}
4428
4429static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
4430                                          const AttributeList &Attr) {
4431  if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
4432    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
4433      << Attr.getRange() << Attr.getName() << ExpectedVariable;
4434    return;
4435  }
4436
4437  ValueDecl *vd = cast<ValueDecl>(D);
4438  QualType type = vd->getType();
4439
4440  if (!type->isDependentType() &&
4441      !type->isObjCLifetimeType()) {
4442    S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
4443      << type;
4444    return;
4445  }
4446
4447  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
4448
4449  // If we have no lifetime yet, check the lifetime we're presumably
4450  // going to infer.
4451  if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
4452    lifetime = type->getObjCARCImplicitLifetime();
4453
4454  switch (lifetime) {
4455  case Qualifiers::OCL_None:
4456    assert(type->isDependentType() &&
4457           "didn't infer lifetime for non-dependent type?");
4458    break;
4459
4460  case Qualifiers::OCL_Weak:   // meaningful
4461  case Qualifiers::OCL_Strong: // meaningful
4462    break;
4463
4464  case Qualifiers::OCL_ExplicitNone:
4465  case Qualifiers::OCL_Autoreleasing:
4466    S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
4467      << (lifetime == Qualifiers::OCL_Autoreleasing);
4468    break;
4469  }
4470
4471  D->addAttr(::new (S.Context)
4472             ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
4473                                     Attr.getAttributeSpellingListIndex()));
4474}
4475
4476//===----------------------------------------------------------------------===//
4477// Microsoft specific attribute handlers.
4478//===----------------------------------------------------------------------===//
4479
4480static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4481  if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) {
4482    // check the attribute arguments.
4483    if (!checkAttributeNumArgs(S, Attr, 1))
4484      return;
4485
4486    Expr *Arg = Attr.getArg(0);
4487    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
4488    if (!Str || !Str->isAscii()) {
4489      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
4490        << "uuid" << 1;
4491      return;
4492    }
4493
4494    StringRef StrRef = Str->getString();
4495
4496    bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
4497                   StrRef.back() == '}';
4498
4499    // Validate GUID length.
4500    if (IsCurly && StrRef.size() != 38) {
4501      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4502      return;
4503    }
4504    if (!IsCurly && StrRef.size() != 36) {
4505      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4506      return;
4507    }
4508
4509    // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
4510    // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
4511    StringRef::iterator I = StrRef.begin();
4512    if (IsCurly) // Skip the optional '{'
4513       ++I;
4514
4515    for (int i = 0; i < 36; ++i) {
4516      if (i == 8 || i == 13 || i == 18 || i == 23) {
4517        if (*I != '-') {
4518          S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4519          return;
4520        }
4521      } else if (!isHexDigit(*I)) {
4522        S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
4523        return;
4524      }
4525      I++;
4526    }
4527
4528    D->addAttr(::new (S.Context)
4529               UuidAttr(Attr.getRange(), S.Context, Str->getString(),
4530                        Attr.getAttributeSpellingListIndex()));
4531  } else
4532    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
4533}
4534
4535static void handleInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4536  if (!S.LangOpts.MicrosoftExt) {
4537    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4538    return;
4539  }
4540
4541  AttributeList::Kind Kind = Attr.getKind();
4542  if (Kind == AttributeList::AT_SingleInheritance)
4543    D->addAttr(
4544        ::new (S.Context)
4545               SingleInheritanceAttr(Attr.getRange(), S.Context,
4546                                     Attr.getAttributeSpellingListIndex()));
4547  else if (Kind == AttributeList::AT_MultipleInheritance)
4548    D->addAttr(
4549        ::new (S.Context)
4550               MultipleInheritanceAttr(Attr.getRange(), S.Context,
4551                                       Attr.getAttributeSpellingListIndex()));
4552  else if (Kind == AttributeList::AT_VirtualInheritance)
4553    D->addAttr(
4554        ::new (S.Context)
4555               VirtualInheritanceAttr(Attr.getRange(), S.Context,
4556                                      Attr.getAttributeSpellingListIndex()));
4557}
4558
4559static void handlePortabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4560  if (S.LangOpts.MicrosoftExt) {
4561    AttributeList::Kind Kind = Attr.getKind();
4562    if (Kind == AttributeList::AT_Ptr32)
4563      D->addAttr(
4564          ::new (S.Context) Ptr32Attr(Attr.getRange(), S.Context,
4565                                      Attr.getAttributeSpellingListIndex()));
4566    else if (Kind == AttributeList::AT_Ptr64)
4567      D->addAttr(
4568          ::new (S.Context) Ptr64Attr(Attr.getRange(), S.Context,
4569                                      Attr.getAttributeSpellingListIndex()));
4570    else if (Kind == AttributeList::AT_Win64)
4571      D->addAttr(
4572          ::new (S.Context) Win64Attr(Attr.getRange(), S.Context,
4573                                      Attr.getAttributeSpellingListIndex()));
4574  } else
4575    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4576}
4577
4578static void handleForceInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4579  if (S.LangOpts.MicrosoftExt)
4580    D->addAttr(::new (S.Context)
4581               ForceInlineAttr(Attr.getRange(), S.Context,
4582                               Attr.getAttributeSpellingListIndex()));
4583  else
4584    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
4585}
4586
4587//===----------------------------------------------------------------------===//
4588// Top Level Sema Entry Points
4589//===----------------------------------------------------------------------===//
4590
4591static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
4592                                          const AttributeList &Attr) {
4593  switch (Attr.getKind()) {
4594  case AttributeList::AT_CUDADevice:  handleDeviceAttr      (S, D, Attr); break;
4595  case AttributeList::AT_CUDAHost:    handleHostAttr        (S, D, Attr); break;
4596  case AttributeList::AT_Overloadable:handleOverloadableAttr(S, D, Attr); break;
4597  default:
4598    break;
4599  }
4600}
4601
4602static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
4603                                       const AttributeList &Attr) {
4604  switch (Attr.getKind()) {
4605  case AttributeList::AT_IBAction:    handleIBAction(S, D, Attr); break;
4606  case AttributeList::AT_IBOutlet:    handleIBOutlet(S, D, Attr); break;
4607  case AttributeList::AT_IBOutletCollection:
4608    handleIBOutletCollection(S, D, Attr); break;
4609  case AttributeList::AT_AddressSpace:
4610  case AttributeList::AT_OpenCLImageAccess:
4611  case AttributeList::AT_ObjCGC:
4612  case AttributeList::AT_VectorSize:
4613  case AttributeList::AT_NeonVectorType:
4614  case AttributeList::AT_NeonPolyVectorType:
4615    // Ignore these, these are type attributes, handled by
4616    // ProcessTypeAttributes.
4617    break;
4618  case AttributeList::AT_CUDADevice:
4619  case AttributeList::AT_CUDAHost:
4620  case AttributeList::AT_Overloadable:
4621    // Ignore, this is a non-inheritable attribute, handled
4622    // by ProcessNonInheritableDeclAttr.
4623    break;
4624  case AttributeList::AT_Alias:       handleAliasAttr       (S, D, Attr); break;
4625  case AttributeList::AT_Aligned:     handleAlignedAttr     (S, D, Attr); break;
4626  case AttributeList::AT_AllocSize:   handleAllocSizeAttr   (S, D, Attr); break;
4627  case AttributeList::AT_AlwaysInline:
4628    handleAlwaysInlineAttr  (S, D, Attr); break;
4629  case AttributeList::AT_AnalyzerNoReturn:
4630    handleAnalyzerNoReturnAttr  (S, D, Attr); break;
4631  case AttributeList::AT_TLSModel:    handleTLSModelAttr    (S, D, Attr); break;
4632  case AttributeList::AT_Annotate:    handleAnnotateAttr    (S, D, Attr); break;
4633  case AttributeList::AT_Availability:handleAvailabilityAttr(S, D, Attr); break;
4634  case AttributeList::AT_CarriesDependency:
4635    handleDependencyAttr(S, scope, D, Attr);
4636    break;
4637  case AttributeList::AT_Common:      handleCommonAttr      (S, D, Attr); break;
4638  case AttributeList::AT_CUDAConstant:handleConstantAttr    (S, D, Attr); break;
4639  case AttributeList::AT_Constructor: handleConstructorAttr (S, D, Attr); break;
4640  case AttributeList::AT_CXX11NoReturn:
4641    handleCXX11NoReturnAttr(S, D, Attr);
4642    break;
4643  case AttributeList::AT_Deprecated:
4644    handleAttrWithMessage<DeprecatedAttr>(S, D, Attr, "deprecated");
4645    break;
4646  case AttributeList::AT_Destructor:  handleDestructorAttr  (S, D, Attr); break;
4647  case AttributeList::AT_ExtVectorType:
4648    handleExtVectorTypeAttr(S, scope, D, Attr);
4649    break;
4650  case AttributeList::AT_MinSize:
4651    handleMinSizeAttr(S, D, Attr);
4652    break;
4653  case AttributeList::AT_Format:      handleFormatAttr      (S, D, Attr); break;
4654  case AttributeList::AT_FormatArg:   handleFormatArgAttr   (S, D, Attr); break;
4655  case AttributeList::AT_CUDAGlobal:  handleGlobalAttr      (S, D, Attr); break;
4656  case AttributeList::AT_GNUInline:   handleGNUInlineAttr   (S, D, Attr); break;
4657  case AttributeList::AT_CUDALaunchBounds:
4658    handleLaunchBoundsAttr(S, D, Attr);
4659    break;
4660  case AttributeList::AT_Mode:        handleModeAttr        (S, D, Attr); break;
4661  case AttributeList::AT_Malloc:      handleMallocAttr      (S, D, Attr); break;
4662  case AttributeList::AT_MayAlias:    handleMayAliasAttr    (S, D, Attr); break;
4663  case AttributeList::AT_NoCommon:    handleNoCommonAttr    (S, D, Attr); break;
4664  case AttributeList::AT_NonNull:     handleNonNullAttr     (S, D, Attr); break;
4665  case AttributeList::AT_ownership_returns:
4666  case AttributeList::AT_ownership_takes:
4667  case AttributeList::AT_ownership_holds:
4668      handleOwnershipAttr     (S, D, Attr); break;
4669  case AttributeList::AT_Cold:        handleColdAttr        (S, D, Attr); break;
4670  case AttributeList::AT_Hot:         handleHotAttr         (S, D, Attr); break;
4671  case AttributeList::AT_Naked:       handleNakedAttr       (S, D, Attr); break;
4672  case AttributeList::AT_NoReturn:    handleNoReturnAttr    (S, D, Attr); break;
4673  case AttributeList::AT_NoThrow:     handleNothrowAttr     (S, D, Attr); break;
4674  case AttributeList::AT_CUDAShared:  handleSharedAttr      (S, D, Attr); break;
4675  case AttributeList::AT_VecReturn:   handleVecReturnAttr   (S, D, Attr); break;
4676
4677  case AttributeList::AT_ObjCOwnership:
4678    handleObjCOwnershipAttr(S, D, Attr); break;
4679  case AttributeList::AT_ObjCPreciseLifetime:
4680    handleObjCPreciseLifetimeAttr(S, D, Attr); break;
4681
4682  case AttributeList::AT_ObjCReturnsInnerPointer:
4683    handleObjCReturnsInnerPointerAttr(S, D, Attr); break;
4684
4685  case AttributeList::AT_ObjCRequiresSuper:
4686      handleObjCRequiresSuperAttr(S, D, Attr); break;
4687
4688  case AttributeList::AT_NSBridged:
4689    handleNSBridgedAttr(S, scope, D, Attr); break;
4690
4691  case AttributeList::AT_CFAuditedTransfer:
4692  case AttributeList::AT_CFUnknownTransfer:
4693    handleCFTransferAttr(S, D, Attr); break;
4694
4695  // Checker-specific.
4696  case AttributeList::AT_CFConsumed:
4697  case AttributeList::AT_NSConsumed:  handleNSConsumedAttr  (S, D, Attr); break;
4698  case AttributeList::AT_NSConsumesSelf:
4699    handleNSConsumesSelfAttr(S, D, Attr); break;
4700
4701  case AttributeList::AT_NSReturnsAutoreleased:
4702  case AttributeList::AT_NSReturnsNotRetained:
4703  case AttributeList::AT_CFReturnsNotRetained:
4704  case AttributeList::AT_NSReturnsRetained:
4705  case AttributeList::AT_CFReturnsRetained:
4706    handleNSReturnsRetainedAttr(S, D, Attr); break;
4707
4708  case AttributeList::AT_WorkGroupSizeHint:
4709  case AttributeList::AT_ReqdWorkGroupSize:
4710    handleWorkGroupSize(S, D, Attr); break;
4711
4712  case AttributeList::AT_InitPriority:
4713      handleInitPriorityAttr(S, D, Attr); break;
4714
4715  case AttributeList::AT_Packed:      handlePackedAttr      (S, D, Attr); break;
4716  case AttributeList::AT_Section:     handleSectionAttr     (S, D, Attr); break;
4717  case AttributeList::AT_Unavailable:
4718    handleAttrWithMessage<UnavailableAttr>(S, D, Attr, "unavailable");
4719    break;
4720  case AttributeList::AT_ArcWeakrefUnavailable:
4721    handleArcWeakrefUnavailableAttr (S, D, Attr);
4722    break;
4723  case AttributeList::AT_ObjCRootClass:
4724    handleObjCRootClassAttr(S, D, Attr);
4725    break;
4726  case AttributeList::AT_ObjCRequiresPropertyDefs:
4727    handleObjCRequiresPropertyDefsAttr (S, D, Attr);
4728    break;
4729  case AttributeList::AT_Unused:      handleUnusedAttr      (S, D, Attr); break;
4730  case AttributeList::AT_ReturnsTwice:
4731    handleReturnsTwiceAttr(S, D, Attr);
4732    break;
4733  case AttributeList::AT_Used:        handleUsedAttr        (S, D, Attr); break;
4734  case AttributeList::AT_Visibility:
4735    handleVisibilityAttr(S, D, Attr, false);
4736    break;
4737  case AttributeList::AT_TypeVisibility:
4738    handleVisibilityAttr(S, D, Attr, true);
4739    break;
4740  case AttributeList::AT_WarnUnusedResult: handleWarnUnusedResult(S, D, Attr);
4741    break;
4742  case AttributeList::AT_Weak:        handleWeakAttr        (S, D, Attr); break;
4743  case AttributeList::AT_WeakRef:     handleWeakRefAttr     (S, D, Attr); break;
4744  case AttributeList::AT_WeakImport:  handleWeakImportAttr  (S, D, Attr); break;
4745  case AttributeList::AT_TransparentUnion:
4746    handleTransparentUnionAttr(S, D, Attr);
4747    break;
4748  case AttributeList::AT_ObjCException:
4749    handleObjCExceptionAttr(S, D, Attr);
4750    break;
4751  case AttributeList::AT_ObjCMethodFamily:
4752    handleObjCMethodFamilyAttr(S, D, Attr);
4753    break;
4754  case AttributeList::AT_ObjCNSObject:handleObjCNSObject    (S, D, Attr); break;
4755  case AttributeList::AT_Blocks:      handleBlocksAttr      (S, D, Attr); break;
4756  case AttributeList::AT_Sentinel:    handleSentinelAttr    (S, D, Attr); break;
4757  case AttributeList::AT_Const:       handleConstAttr       (S, D, Attr); break;
4758  case AttributeList::AT_Pure:        handlePureAttr        (S, D, Attr); break;
4759  case AttributeList::AT_Cleanup:     handleCleanupAttr     (S, D, Attr); break;
4760  case AttributeList::AT_NoDebug:     handleNoDebugAttr     (S, D, Attr); break;
4761  case AttributeList::AT_NoInline:    handleNoInlineAttr    (S, D, Attr); break;
4762  case AttributeList::AT_Regparm:     handleRegparmAttr     (S, D, Attr); break;
4763  case AttributeList::IgnoredAttribute:
4764    // Just ignore
4765    break;
4766  case AttributeList::AT_NoInstrumentFunction:  // Interacts with -pg.
4767    handleNoInstrumentFunctionAttr(S, D, Attr);
4768    break;
4769  case AttributeList::AT_StdCall:
4770  case AttributeList::AT_CDecl:
4771  case AttributeList::AT_FastCall:
4772  case AttributeList::AT_ThisCall:
4773  case AttributeList::AT_Pascal:
4774  case AttributeList::AT_Pcs:
4775  case AttributeList::AT_PnaclCall:
4776  case AttributeList::AT_IntelOclBicc:
4777    handleCallConvAttr(S, D, Attr);
4778    break;
4779  case AttributeList::AT_OpenCLKernel:
4780    handleOpenCLKernelAttr(S, D, Attr);
4781    break;
4782
4783  // Microsoft attributes:
4784  case AttributeList::AT_MsStruct:
4785    handleMsStructAttr(S, D, Attr);
4786    break;
4787  case AttributeList::AT_Uuid:
4788    handleUuidAttr(S, D, Attr);
4789    break;
4790  case AttributeList::AT_SingleInheritance:
4791  case AttributeList::AT_MultipleInheritance:
4792  case AttributeList::AT_VirtualInheritance:
4793    handleInheritanceAttr(S, D, Attr);
4794    break;
4795  case AttributeList::AT_Win64:
4796  case AttributeList::AT_Ptr32:
4797  case AttributeList::AT_Ptr64:
4798    handlePortabilityAttr(S, D, Attr);
4799    break;
4800  case AttributeList::AT_ForceInline:
4801    handleForceInlineAttr(S, D, Attr);
4802    break;
4803
4804  // Thread safety attributes:
4805  case AttributeList::AT_GuardedVar:
4806    handleGuardedVarAttr(S, D, Attr);
4807    break;
4808  case AttributeList::AT_PtGuardedVar:
4809    handlePtGuardedVarAttr(S, D, Attr);
4810    break;
4811  case AttributeList::AT_ScopedLockable:
4812    handleScopedLockableAttr(S, D, Attr);
4813    break;
4814  case AttributeList::AT_NoAddressSafetyAnalysis:
4815    handleNoAddressSafetyAttr(S, D, Attr);
4816    break;
4817  case AttributeList::AT_NoThreadSafetyAnalysis:
4818    handleNoThreadSafetyAttr(S, D, Attr);
4819    break;
4820  case AttributeList::AT_Lockable:
4821    handleLockableAttr(S, D, Attr);
4822    break;
4823  case AttributeList::AT_GuardedBy:
4824    handleGuardedByAttr(S, D, Attr);
4825    break;
4826  case AttributeList::AT_PtGuardedBy:
4827    handlePtGuardedByAttr(S, D, Attr);
4828    break;
4829  case AttributeList::AT_ExclusiveLockFunction:
4830    handleExclusiveLockFunctionAttr(S, D, Attr);
4831    break;
4832  case AttributeList::AT_ExclusiveLocksRequired:
4833    handleExclusiveLocksRequiredAttr(S, D, Attr);
4834    break;
4835  case AttributeList::AT_ExclusiveTrylockFunction:
4836    handleExclusiveTrylockFunctionAttr(S, D, Attr);
4837    break;
4838  case AttributeList::AT_LockReturned:
4839    handleLockReturnedAttr(S, D, Attr);
4840    break;
4841  case AttributeList::AT_LocksExcluded:
4842    handleLocksExcludedAttr(S, D, Attr);
4843    break;
4844  case AttributeList::AT_SharedLockFunction:
4845    handleSharedLockFunctionAttr(S, D, Attr);
4846    break;
4847  case AttributeList::AT_SharedLocksRequired:
4848    handleSharedLocksRequiredAttr(S, D, Attr);
4849    break;
4850  case AttributeList::AT_SharedTrylockFunction:
4851    handleSharedTrylockFunctionAttr(S, D, Attr);
4852    break;
4853  case AttributeList::AT_UnlockFunction:
4854    handleUnlockFunAttr(S, D, Attr);
4855    break;
4856  case AttributeList::AT_AcquiredBefore:
4857    handleAcquiredBeforeAttr(S, D, Attr);
4858    break;
4859  case AttributeList::AT_AcquiredAfter:
4860    handleAcquiredAfterAttr(S, D, Attr);
4861    break;
4862
4863  // Type safety attributes.
4864  case AttributeList::AT_ArgumentWithTypeTag:
4865    handleArgumentWithTypeTagAttr(S, D, Attr);
4866    break;
4867  case AttributeList::AT_TypeTagForDatatype:
4868    handleTypeTagForDatatypeAttr(S, D, Attr);
4869    break;
4870
4871  default:
4872    // Ask target about the attribute.
4873    const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
4874    if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
4875      S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute() ?
4876             diag::warn_unhandled_ms_attribute_ignored :
4877             diag::warn_unknown_attribute_ignored) << Attr.getName();
4878    break;
4879  }
4880}
4881
4882/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
4883/// the attribute applies to decls.  If the attribute is a type attribute, just
4884/// silently ignore it if a GNU attribute.
4885static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
4886                                 const AttributeList &Attr,
4887                                 bool NonInheritable, bool Inheritable,
4888                                 bool IncludeCXX11Attributes) {
4889  if (Attr.isInvalid())
4890    return;
4891
4892  // Ignore C++11 attributes on declarator chunks: they appertain to the type
4893  // instead.
4894  if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
4895    return;
4896
4897  if (NonInheritable)
4898    ProcessNonInheritableDeclAttr(S, scope, D, Attr);
4899
4900  if (Inheritable)
4901    ProcessInheritableDeclAttr(S, scope, D, Attr);
4902}
4903
4904/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
4905/// attribute list to the specified decl, ignoring any type attributes.
4906void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
4907                                    const AttributeList *AttrList,
4908                                    bool NonInheritable, bool Inheritable,
4909                                    bool IncludeCXX11Attributes) {
4910  for (const AttributeList* l = AttrList; l; l = l->getNext())
4911    ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable,
4912                         IncludeCXX11Attributes);
4913
4914  // GCC accepts
4915  // static int a9 __attribute__((weakref));
4916  // but that looks really pointless. We reject it.
4917  if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
4918    Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
4919    cast<NamedDecl>(D)->getNameAsString();
4920    D->dropAttr<WeakRefAttr>();
4921    return;
4922  }
4923}
4924
4925// Annotation attributes are the only attributes allowed after an access
4926// specifier.
4927bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4928                                          const AttributeList *AttrList) {
4929  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4930    if (l->getKind() == AttributeList::AT_Annotate) {
4931      handleAnnotateAttr(*this, ASDecl, *l);
4932    } else {
4933      Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
4934      return true;
4935    }
4936  }
4937
4938  return false;
4939}
4940
4941/// checkUnusedDeclAttributes - Check a list of attributes to see if it
4942/// contains any decl attributes that we should warn about.
4943static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
4944  for ( ; A; A = A->getNext()) {
4945    // Only warn if the attribute is an unignored, non-type attribute.
4946    if (A->isUsedAsTypeAttr() || A->isInvalid()) continue;
4947    if (A->getKind() == AttributeList::IgnoredAttribute) continue;
4948
4949    if (A->getKind() == AttributeList::UnknownAttribute) {
4950      S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
4951        << A->getName() << A->getRange();
4952    } else {
4953      S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
4954        << A->getName() << A->getRange();
4955    }
4956  }
4957}
4958
4959/// checkUnusedDeclAttributes - Given a declarator which is not being
4960/// used to build a declaration, complain about any decl attributes
4961/// which might be lying around on it.
4962void Sema::checkUnusedDeclAttributes(Declarator &D) {
4963  ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
4964  ::checkUnusedDeclAttributes(*this, D.getAttributes());
4965  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
4966    ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
4967}
4968
4969/// DeclClonePragmaWeak - clone existing decl (maybe definition),
4970/// \#pragma weak needs a non-definition decl and source may not have one.
4971NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
4972                                      SourceLocation Loc) {
4973  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
4974  NamedDecl *NewD = 0;
4975  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
4976    FunctionDecl *NewFD;
4977    // FIXME: Missing call to CheckFunctionDeclaration().
4978    // FIXME: Mangling?
4979    // FIXME: Is the qualifier info correct?
4980    // FIXME: Is the DeclContext correct?
4981    NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
4982                                 Loc, Loc, DeclarationName(II),
4983                                 FD->getType(), FD->getTypeSourceInfo(),
4984                                 SC_None, SC_None,
4985                                 false/*isInlineSpecified*/,
4986                                 FD->hasPrototype(),
4987                                 false/*isConstexprSpecified*/);
4988    NewD = NewFD;
4989
4990    if (FD->getQualifier())
4991      NewFD->setQualifierInfo(FD->getQualifierLoc());
4992
4993    // Fake up parameter variables; they are declared as if this were
4994    // a typedef.
4995    QualType FDTy = FD->getType();
4996    if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
4997      SmallVector<ParmVarDecl*, 16> Params;
4998      for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
4999           AE = FT->arg_type_end(); AI != AE; ++AI) {
5000        ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, *AI);
5001        Param->setScopeInfo(0, Params.size());
5002        Params.push_back(Param);
5003      }
5004      NewFD->setParams(Params);
5005    }
5006  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
5007    NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
5008                           VD->getInnerLocStart(), VD->getLocation(), II,
5009                           VD->getType(), VD->getTypeSourceInfo(),
5010                           VD->getStorageClass(),
5011                           VD->getStorageClassAsWritten());
5012    if (VD->getQualifier()) {
5013      VarDecl *NewVD = cast<VarDecl>(NewD);
5014      NewVD->setQualifierInfo(VD->getQualifierLoc());
5015    }
5016  }
5017  return NewD;
5018}
5019
5020/// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
5021/// applied to it, possibly with an alias.
5022void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
5023  if (W.getUsed()) return; // only do this once
5024  W.setUsed(true);
5025  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
5026    IdentifierInfo *NDId = ND->getIdentifier();
5027    NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
5028    NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
5029                                            NDId->getName()));
5030    NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
5031    WeakTopLevelDecl.push_back(NewD);
5032    // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
5033    // to insert Decl at TU scope, sorry.
5034    DeclContext *SavedContext = CurContext;
5035    CurContext = Context.getTranslationUnitDecl();
5036    PushOnScopeChains(NewD, S);
5037    CurContext = SavedContext;
5038  } else { // just add weak to existing
5039    ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
5040  }
5041}
5042
5043/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
5044/// it, apply them to D.  This is a bit tricky because PD can have attributes
5045/// specified in many different places, and we need to find and apply them all.
5046void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
5047                                 bool NonInheritable, bool Inheritable) {
5048  // It's valid to "forward-declare" #pragma weak, in which case we
5049  // have to do this.
5050  if (Inheritable) {
5051    LoadExternalWeakUndeclaredIdentifiers();
5052    if (!WeakUndeclaredIdentifiers.empty()) {
5053      if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
5054        if (IdentifierInfo *Id = ND->getIdentifier()) {
5055          llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
5056            = WeakUndeclaredIdentifiers.find(Id);
5057          if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
5058            WeakInfo W = I->second;
5059            DeclApplyPragmaWeak(S, ND, W);
5060            WeakUndeclaredIdentifiers[Id] = W;
5061          }
5062        }
5063      }
5064    }
5065  }
5066
5067  // Apply decl attributes from the DeclSpec if present.
5068  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
5069    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
5070
5071  // Walk the declarator structure, applying decl attributes that were in a type
5072  // position to the decl itself.  This handles cases like:
5073  //   int *__attr__(x)** D;
5074  // when X is a decl attribute.
5075  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
5076    if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
5077      ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable,
5078                               /*IncludeCXX11Attributes=*/false);
5079
5080  // Finally, apply any attributes on the decl itself.
5081  if (const AttributeList *Attrs = PD.getAttributes())
5082    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
5083}
5084
5085/// Is the given declaration allowed to use a forbidden type?
5086static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
5087  // Private ivars are always okay.  Unfortunately, people don't
5088  // always properly make their ivars private, even in system headers.
5089  // Plus we need to make fields okay, too.
5090  // Function declarations in sys headers will be marked unavailable.
5091  if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
5092      !isa<FunctionDecl>(decl))
5093    return false;
5094
5095  // Require it to be declared in a system header.
5096  return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
5097}
5098
5099/// Handle a delayed forbidden-type diagnostic.
5100static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
5101                                       Decl *decl) {
5102  if (decl && isForbiddenTypeAllowed(S, decl)) {
5103    decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
5104                        "this system declaration uses an unsupported type"));
5105    return;
5106  }
5107  if (S.getLangOpts().ObjCAutoRefCount)
5108    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
5109      // FIXME: we may want to suppress diagnostics for all
5110      // kind of forbidden type messages on unavailable functions.
5111      if (FD->hasAttr<UnavailableAttr>() &&
5112          diag.getForbiddenTypeDiagnostic() ==
5113          diag::err_arc_array_param_no_ownership) {
5114        diag.Triggered = true;
5115        return;
5116      }
5117    }
5118
5119  S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
5120    << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
5121  diag.Triggered = true;
5122}
5123
5124void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
5125  assert(DelayedDiagnostics.getCurrentPool());
5126  DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
5127  DelayedDiagnostics.popWithoutEmitting(state);
5128
5129  // When delaying diagnostics to run in the context of a parsed
5130  // declaration, we only want to actually emit anything if parsing
5131  // succeeds.
5132  if (!decl) return;
5133
5134  // We emit all the active diagnostics in this pool or any of its
5135  // parents.  In general, we'll get one pool for the decl spec
5136  // and a child pool for each declarator; in a decl group like:
5137  //   deprecated_typedef foo, *bar, baz();
5138  // only the declarator pops will be passed decls.  This is correct;
5139  // we really do need to consider delayed diagnostics from the decl spec
5140  // for each of the different declarations.
5141  const DelayedDiagnosticPool *pool = &poppedPool;
5142  do {
5143    for (DelayedDiagnosticPool::pool_iterator
5144           i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
5145      // This const_cast is a bit lame.  Really, Triggered should be mutable.
5146      DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
5147      if (diag.Triggered)
5148        continue;
5149
5150      switch (diag.Kind) {
5151      case DelayedDiagnostic::Deprecation:
5152        // Don't bother giving deprecation diagnostics if the decl is invalid.
5153        if (!decl->isInvalidDecl())
5154          HandleDelayedDeprecationCheck(diag, decl);
5155        break;
5156
5157      case DelayedDiagnostic::Access:
5158        HandleDelayedAccessCheck(diag, decl);
5159        break;
5160
5161      case DelayedDiagnostic::ForbiddenType:
5162        handleDelayedForbiddenType(*this, diag, decl);
5163        break;
5164      }
5165    }
5166  } while ((pool = pool->getParent()));
5167}
5168
5169/// Given a set of delayed diagnostics, re-emit them as if they had
5170/// been delayed in the current context instead of in the given pool.
5171/// Essentially, this just moves them to the current pool.
5172void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
5173  DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
5174  assert(curPool && "re-emitting in undelayed context not supported");
5175  curPool->steal(pool);
5176}
5177
5178static bool isDeclDeprecated(Decl *D) {
5179  do {
5180    if (D->isDeprecated())
5181      return true;
5182    // A category implicitly has the availability of the interface.
5183    if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
5184      return CatD->getClassInterface()->isDeprecated();
5185  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
5186  return false;
5187}
5188
5189static void
5190DoEmitDeprecationWarning(Sema &S, const NamedDecl *D, StringRef Message,
5191                         SourceLocation Loc,
5192                         const ObjCInterfaceDecl *UnknownObjCClass,
5193                         const ObjCPropertyDecl *ObjCPropery) {
5194  DeclarationName Name = D->getDeclName();
5195  if (!Message.empty()) {
5196    S.Diag(Loc, diag::warn_deprecated_message) << Name << Message;
5197    S.Diag(D->getLocation(),
5198           isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
5199                                  : diag::note_previous_decl) << Name;
5200    if (ObjCPropery)
5201      S.Diag(ObjCPropery->getLocation(), diag::note_property_attribute)
5202        << ObjCPropery->getDeclName() << 0;
5203  } else if (!UnknownObjCClass) {
5204    S.Diag(Loc, diag::warn_deprecated) << D->getDeclName();
5205    S.Diag(D->getLocation(),
5206           isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
5207                                  : diag::note_previous_decl) << Name;
5208    if (ObjCPropery)
5209      S.Diag(ObjCPropery->getLocation(), diag::note_property_attribute)
5210        << ObjCPropery->getDeclName() << 0;
5211  } else {
5212    S.Diag(Loc, diag::warn_deprecated_fwdclass_message) << Name;
5213    S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
5214  }
5215}
5216
5217void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
5218                                         Decl *Ctx) {
5219  if (isDeclDeprecated(Ctx))
5220    return;
5221
5222  DD.Triggered = true;
5223  DoEmitDeprecationWarning(*this, DD.getDeprecationDecl(),
5224                           DD.getDeprecationMessage(), DD.Loc,
5225                           DD.getUnknownObjCClass(),
5226                           DD.getObjCProperty());
5227}
5228
5229void Sema::EmitDeprecationWarning(NamedDecl *D, StringRef Message,
5230                                  SourceLocation Loc,
5231                                  const ObjCInterfaceDecl *UnknownObjCClass,
5232                                  const ObjCPropertyDecl  *ObjCProperty) {
5233  // Delay if we're currently parsing a declaration.
5234  if (DelayedDiagnostics.shouldDelayDiagnostics()) {
5235    DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D,
5236                                                              UnknownObjCClass,
5237                                                              ObjCProperty,
5238                                                              Message));
5239    return;
5240  }
5241
5242  // Otherwise, don't warn if our current context is deprecated.
5243  if (isDeclDeprecated(cast<Decl>(getCurLexicalContext())))
5244    return;
5245  DoEmitDeprecationWarning(*this, D, Message, Loc, UnknownObjCClass, ObjCProperty);
5246}
5247