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