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