SemaDeclAttr.cpp revision dc7c5ad7a15914b7ae24f31f18a20ad2f8ecd0bc 
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/DeclCXX.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/Expr.h"
20#include "clang/Basic/SourceManager.h"
21#include "clang/Basic/TargetInfo.h"
22#include "clang/Sema/DeclSpec.h"
23#include "clang/Sema/DelayedDiagnostic.h"
24#include "llvm/ADT/StringExtras.h"
25using namespace clang;
26using namespace sema;
27
28/// These constants match the enumerated choices of
29/// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
30enum {
31  ExpectedFunction,
32  ExpectedUnion,
33  ExpectedVariableOrFunction,
34  ExpectedFunctionOrMethod,
35  ExpectedParameter,
36  ExpectedParameterOrMethod,
37  ExpectedFunctionMethodOrBlock,
38  ExpectedClassOrVirtualMethod,
39  ExpectedFunctionMethodOrParameter,
40  ExpectedClass,
41  ExpectedVirtualMethod,
42  ExpectedClassMember,
43  ExpectedVariable,
44  ExpectedMethod,
45  ExpectedVariableFunctionOrLabel
46};
47
48//===----------------------------------------------------------------------===//
49//  Helper functions
50//===----------------------------------------------------------------------===//
51
52static const FunctionType *getFunctionType(const Decl *D,
53                                           bool blocksToo = true) {
54  QualType Ty;
55  if (const ValueDecl *decl = dyn_cast<ValueDecl>(D))
56    Ty = decl->getType();
57  else if (const FieldDecl *decl = dyn_cast<FieldDecl>(D))
58    Ty = decl->getType();
59  else if (const TypedefNameDecl* decl = dyn_cast<TypedefNameDecl>(D))
60    Ty = decl->getUnderlyingType();
61  else
62    return 0;
63
64  if (Ty->isFunctionPointerType())
65    Ty = Ty->getAs<PointerType>()->getPointeeType();
66  else if (blocksToo && Ty->isBlockPointerType())
67    Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
68
69  return Ty->getAs<FunctionType>();
70}
71
72// FIXME: We should provide an abstraction around a method or function
73// to provide the following bits of information.
74
75/// isFunction - Return true if the given decl has function
76/// type (function or function-typed variable).
77static bool isFunction(const Decl *D) {
78  return getFunctionType(D, false) != NULL;
79}
80
81/// isFunctionOrMethod - Return true if the given decl has function
82/// type (function or function-typed variable) or an Objective-C
83/// method.
84static bool isFunctionOrMethod(const Decl *D) {
85  return isFunction(D)|| isa<ObjCMethodDecl>(D);
86}
87
88/// isFunctionOrMethodOrBlock - Return true if the given decl has function
89/// type (function or function-typed variable) or an Objective-C
90/// method or a block.
91static bool isFunctionOrMethodOrBlock(const Decl *D) {
92  if (isFunctionOrMethod(D))
93    return true;
94  // check for block is more involved.
95  if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
96    QualType Ty = V->getType();
97    return Ty->isBlockPointerType();
98  }
99  return isa<BlockDecl>(D);
100}
101
102/// Return true if the given decl has a declarator that should have
103/// been processed by Sema::GetTypeForDeclarator.
104static bool hasDeclarator(const Decl *D) {
105  // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
106  return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
107         isa<ObjCPropertyDecl>(D);
108}
109
110/// hasFunctionProto - Return true if the given decl has a argument
111/// information. This decl should have already passed
112/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
113static bool hasFunctionProto(const Decl *D) {
114  if (const FunctionType *FnTy = getFunctionType(D))
115    return isa<FunctionProtoType>(FnTy);
116  else {
117    assert(isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D));
118    return true;
119  }
120}
121
122/// getFunctionOrMethodNumArgs - Return number of function or method
123/// arguments. It is an error to call this on a K&R function (use
124/// hasFunctionProto first).
125static unsigned getFunctionOrMethodNumArgs(const Decl *D) {
126  if (const FunctionType *FnTy = getFunctionType(D))
127    return cast<FunctionProtoType>(FnTy)->getNumArgs();
128  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
129    return BD->getNumParams();
130  return cast<ObjCMethodDecl>(D)->param_size();
131}
132
133static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) {
134  if (const FunctionType *FnTy = getFunctionType(D))
135    return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
136  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
137    return BD->getParamDecl(Idx)->getType();
138
139  return cast<ObjCMethodDecl>(D)->param_begin()[Idx]->getType();
140}
141
142static QualType getFunctionOrMethodResultType(const Decl *D) {
143  if (const FunctionType *FnTy = getFunctionType(D))
144    return cast<FunctionProtoType>(FnTy)->getResultType();
145  return cast<ObjCMethodDecl>(D)->getResultType();
146}
147
148static bool isFunctionOrMethodVariadic(const Decl *D) {
149  if (const FunctionType *FnTy = getFunctionType(D)) {
150    const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
151    return proto->isVariadic();
152  } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
153    return BD->isVariadic();
154  else {
155    return cast<ObjCMethodDecl>(D)->isVariadic();
156  }
157}
158
159static bool isInstanceMethod(const Decl *D) {
160  if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
161    return MethodDecl->isInstance();
162  return false;
163}
164
165static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
166  const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
167  if (!PT)
168    return false;
169
170  ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
171  if (!Cls)
172    return false;
173
174  IdentifierInfo* ClsName = Cls->getIdentifier();
175
176  // FIXME: Should we walk the chain of classes?
177  return ClsName == &Ctx.Idents.get("NSString") ||
178         ClsName == &Ctx.Idents.get("NSMutableString");
179}
180
181static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
182  const PointerType *PT = T->getAs<PointerType>();
183  if (!PT)
184    return false;
185
186  const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
187  if (!RT)
188    return false;
189
190  const RecordDecl *RD = RT->getDecl();
191  if (RD->getTagKind() != TTK_Struct)
192    return false;
193
194  return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
195}
196
197static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
198                                  unsigned int Num) {
199  if (Attr.getNumArgs() != Num) {
200    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num;
201    return false;
202  }
203
204  return true;
205}
206
207//===----------------------------------------------------------------------===//
208// Attribute Implementations
209//===----------------------------------------------------------------------===//
210
211// FIXME: All this manual attribute parsing code is gross. At the
212// least add some helper functions to check most argument patterns (#
213// and types of args).
214
215static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
216                                    const AttributeList &Attr) {
217  TypedefNameDecl *tDecl = dyn_cast<TypedefNameDecl>(D);
218  if (tDecl == 0) {
219    S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
220    return;
221  }
222
223  QualType curType = tDecl->getUnderlyingType();
224
225  Expr *sizeExpr;
226
227  // Special case where the argument is a template id.
228  if (Attr.getParameterName()) {
229    CXXScopeSpec SS;
230    UnqualifiedId id;
231    id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
232
233    ExprResult Size = S.ActOnIdExpression(scope, SS, id, false, false);
234    if (Size.isInvalid())
235      return;
236
237    sizeExpr = Size.get();
238  } else {
239    // check the attribute arguments.
240    if (!checkAttributeNumArgs(S, Attr, 1))
241      return;
242
243    sizeExpr = Attr.getArg(0);
244  }
245
246  // Instantiate/Install the vector type, and let Sema build the type for us.
247  // This will run the reguired checks.
248  QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc());
249  if (!T.isNull()) {
250    // FIXME: preserve the old source info.
251    tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
252
253    // Remember this typedef decl, we will need it later for diagnostics.
254    S.ExtVectorDecls.push_back(tDecl);
255  }
256}
257
258static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
259  // check the attribute arguments.
260  if (!checkAttributeNumArgs(S, Attr, 0))
261    return;
262
263  if (TagDecl *TD = dyn_cast<TagDecl>(D))
264    TD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
265  else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
266    // If the alignment is less than or equal to 8 bits, the packed attribute
267    // has no effect.
268    if (!FD->getType()->isIncompleteType() &&
269        S.Context.getTypeAlign(FD->getType()) <= 8)
270      S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
271        << Attr.getName() << FD->getType();
272    else
273      FD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
274  } else
275    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
276}
277
278static void handleMsStructAttr(Sema &S, Decl *D, const AttributeList &Attr) {
279  if (TagDecl *TD = dyn_cast<TagDecl>(D))
280    TD->addAttr(::new (S.Context) MsStructAttr(Attr.getLoc(), S.Context));
281  else
282    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
283}
284
285static void handleIBAction(Sema &S, Decl *D, const AttributeList &Attr) {
286  // check the attribute arguments.
287  if (!checkAttributeNumArgs(S, Attr, 0))
288    return;
289
290  // The IBAction attributes only apply to instance methods.
291  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
292    if (MD->isInstanceMethod()) {
293      D->addAttr(::new (S.Context) IBActionAttr(Attr.getLoc(), S.Context));
294      return;
295    }
296
297  S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName();
298}
299
300static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
301  // check the attribute arguments.
302  if (!checkAttributeNumArgs(S, Attr, 0))
303    return;
304
305  // The IBOutlet attributes only apply to instance variables of
306  // Objective-C classes.
307  if (isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D)) {
308    D->addAttr(::new (S.Context) IBOutletAttr(Attr.getLoc(), S.Context));
309    return;
310  }
311
312  S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
313}
314
315static void handleIBOutletCollection(Sema &S, Decl *D,
316                                     const AttributeList &Attr) {
317
318  // The iboutletcollection attribute can have zero or one arguments.
319  if (Attr.getParameterName() && Attr.getNumArgs() > 0) {
320    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
321    return;
322  }
323
324  // The IBOutletCollection attributes only apply to instance variables of
325  // Objective-C classes.
326  if (!(isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {
327    S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
328    return;
329  }
330  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
331    if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
332      S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
333        << VD->getType() << 0;
334      return;
335    }
336  if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
337    if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
338      S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
339        << PD->getType() << 1;
340      return;
341    }
342
343  IdentifierInfo *II = Attr.getParameterName();
344  if (!II)
345    II = &S.Context.Idents.get("id");
346
347  ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(),
348                        S.getScopeForContext(D->getDeclContext()->getParent()));
349  if (!TypeRep) {
350    S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
351    return;
352  }
353  QualType QT = TypeRep.get();
354  // Diagnose use of non-object type in iboutletcollection attribute.
355  // FIXME. Gnu attribute extension ignores use of builtin types in
356  // attributes. So, __attribute__((iboutletcollection(char))) will be
357  // treated as __attribute__((iboutletcollection())).
358  if (!QT->isObjCIdType() && !QT->isObjCClassType() &&
359      !QT->isObjCObjectType()) {
360    S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
361    return;
362  }
363  D->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getLoc(), S.Context,
364                                                      QT));
365}
366
367static void possibleTransparentUnionPointerType(QualType &T) {
368  if (const RecordType *UT = T->getAsUnionType())
369    if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
370      RecordDecl *UD = UT->getDecl();
371      for (RecordDecl::field_iterator it = UD->field_begin(),
372           itend = UD->field_end(); it != itend; ++it) {
373        QualType QT = it->getType();
374        if (QT->isAnyPointerType() || QT->isBlockPointerType()) {
375          T = QT;
376          return;
377        }
378      }
379    }
380}
381
382static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
383  // GCC ignores the nonnull attribute on K&R style function prototypes, so we
384  // ignore it as well
385  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
386    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
387      << Attr.getName() << ExpectedFunction;
388    return;
389  }
390
391  // In C++ the implicit 'this' function parameter also counts, and they are
392  // counted from one.
393  bool HasImplicitThisParam = isInstanceMethod(D);
394  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
395
396  // The nonnull attribute only applies to pointers.
397  llvm::SmallVector<unsigned, 10> NonNullArgs;
398
399  for (AttributeList::arg_iterator I=Attr.arg_begin(),
400                                   E=Attr.arg_end(); I!=E; ++I) {
401
402
403    // The argument must be an integer constant expression.
404    Expr *Ex = *I;
405    llvm::APSInt ArgNum(32);
406    if (Ex->isTypeDependent() || Ex->isValueDependent() ||
407        !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
408      S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
409        << "nonnull" << Ex->getSourceRange();
410      return;
411    }
412
413    unsigned x = (unsigned) ArgNum.getZExtValue();
414
415    if (x < 1 || x > NumArgs) {
416      S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
417       << "nonnull" << I.getArgNum() << Ex->getSourceRange();
418      return;
419    }
420
421    --x;
422    if (HasImplicitThisParam) {
423      if (x == 0) {
424        S.Diag(Attr.getLoc(),
425               diag::err_attribute_invalid_implicit_this_argument)
426          << "nonnull" << Ex->getSourceRange();
427        return;
428      }
429      --x;
430    }
431
432    // Is the function argument a pointer type?
433    QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
434    possibleTransparentUnionPointerType(T);
435
436    if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
437      // FIXME: Should also highlight argument in decl.
438      S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only)
439        << "nonnull" << Ex->getSourceRange();
440      continue;
441    }
442
443    NonNullArgs.push_back(x);
444  }
445
446  // If no arguments were specified to __attribute__((nonnull)) then all pointer
447  // arguments have a nonnull attribute.
448  if (NonNullArgs.empty()) {
449    for (unsigned I = 0, E = getFunctionOrMethodNumArgs(D); I != E; ++I) {
450      QualType T = getFunctionOrMethodArgType(D, I).getNonReferenceType();
451      possibleTransparentUnionPointerType(T);
452      if (T->isAnyPointerType() || T->isBlockPointerType())
453        NonNullArgs.push_back(I);
454    }
455
456    // No pointer arguments?
457    if (NonNullArgs.empty()) {
458      // Warn the trivial case only if attribute is not coming from a
459      // macro instantiation.
460      if (Attr.getLoc().isFileID())
461        S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
462      return;
463    }
464  }
465
466  unsigned* start = &NonNullArgs[0];
467  unsigned size = NonNullArgs.size();
468  llvm::array_pod_sort(start, start + size);
469  D->addAttr(::new (S.Context) NonNullAttr(Attr.getLoc(), S.Context, start,
470                                           size));
471}
472
473static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
474  // This attribute must be applied to a function declaration.
475  // The first argument to the attribute must be a string,
476  // the name of the resource, for example "malloc".
477  // The following arguments must be argument indexes, the arguments must be
478  // of integer type for Returns, otherwise of pointer type.
479  // The difference between Holds and Takes is that a pointer may still be used
480  // after being held.  free() should be __attribute((ownership_takes)), whereas
481  // a list append function may well be __attribute((ownership_holds)).
482
483  if (!AL.getParameterName()) {
484    S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string)
485        << AL.getName()->getName() << 1;
486    return;
487  }
488  // Figure out our Kind, and check arguments while we're at it.
489  OwnershipAttr::OwnershipKind K;
490  switch (AL.getKind()) {
491  case AttributeList::AT_ownership_takes:
492    K = OwnershipAttr::Takes;
493    if (AL.getNumArgs() < 1) {
494      S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
495      return;
496    }
497    break;
498  case AttributeList::AT_ownership_holds:
499    K = OwnershipAttr::Holds;
500    if (AL.getNumArgs() < 1) {
501      S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
502      return;
503    }
504    break;
505  case AttributeList::AT_ownership_returns:
506    K = OwnershipAttr::Returns;
507    if (AL.getNumArgs() > 1) {
508      S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
509          << AL.getNumArgs() + 1;
510      return;
511    }
512    break;
513  default:
514    // This should never happen given how we are called.
515    llvm_unreachable("Unknown ownership attribute");
516  }
517
518  if (!isFunction(D) || !hasFunctionProto(D)) {
519    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
520      << AL.getName() << ExpectedFunction;
521    return;
522  }
523
524  // In C++ the implicit 'this' function parameter also counts, and they are
525  // counted from one.
526  bool HasImplicitThisParam = isInstanceMethod(D);
527  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
528
529  llvm::StringRef Module = AL.getParameterName()->getName();
530
531  // Normalize the argument, __foo__ becomes foo.
532  if (Module.startswith("__") && Module.endswith("__"))
533    Module = Module.substr(2, Module.size() - 4);
534
535  llvm::SmallVector<unsigned, 10> OwnershipArgs;
536
537  for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E;
538       ++I) {
539
540    Expr *IdxExpr = *I;
541    llvm::APSInt ArgNum(32);
542    if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
543        || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
544      S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int)
545          << AL.getName()->getName() << IdxExpr->getSourceRange();
546      continue;
547    }
548
549    unsigned x = (unsigned) ArgNum.getZExtValue();
550
551    if (x > NumArgs || x < 1) {
552      S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
553          << AL.getName()->getName() << x << IdxExpr->getSourceRange();
554      continue;
555    }
556    --x;
557    if (HasImplicitThisParam) {
558      if (x == 0) {
559        S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
560          << "ownership" << IdxExpr->getSourceRange();
561        return;
562      }
563      --x;
564    }
565
566    switch (K) {
567    case OwnershipAttr::Takes:
568    case OwnershipAttr::Holds: {
569      // Is the function argument a pointer type?
570      QualType T = getFunctionOrMethodArgType(D, x);
571      if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
572        // FIXME: Should also highlight argument in decl.
573        S.Diag(AL.getLoc(), diag::err_ownership_type)
574            << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds")
575            << "pointer"
576            << IdxExpr->getSourceRange();
577        continue;
578      }
579      break;
580    }
581    case OwnershipAttr::Returns: {
582      if (AL.getNumArgs() > 1) {
583          // Is the function argument an integer type?
584          Expr *IdxExpr = AL.getArg(0);
585          llvm::APSInt ArgNum(32);
586          if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
587              || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
588            S.Diag(AL.getLoc(), diag::err_ownership_type)
589                << "ownership_returns" << "integer"
590                << IdxExpr->getSourceRange();
591            return;
592          }
593      }
594      break;
595    }
596    default:
597      llvm_unreachable("Unknown ownership attribute");
598    } // switch
599
600    // Check we don't have a conflict with another ownership attribute.
601    for (specific_attr_iterator<OwnershipAttr>
602          i = D->specific_attr_begin<OwnershipAttr>(),
603          e = D->specific_attr_end<OwnershipAttr>();
604        i != e; ++i) {
605      if ((*i)->getOwnKind() != K) {
606        for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end();
607             I!=E; ++I) {
608          if (x == *I) {
609            S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
610                << AL.getName()->getName() << "ownership_*";
611          }
612        }
613      }
614    }
615    OwnershipArgs.push_back(x);
616  }
617
618  unsigned* start = OwnershipArgs.data();
619  unsigned size = OwnershipArgs.size();
620  llvm::array_pod_sort(start, start + size);
621
622  if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) {
623    S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
624    return;
625  }
626
627  D->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module,
628                                             start, size));
629}
630
631/// Whether this declaration has internal linkage for the purposes of
632/// things that want to complain about things not have internal linkage.
633static bool hasEffectivelyInternalLinkage(NamedDecl *D) {
634  switch (D->getLinkage()) {
635  case NoLinkage:
636  case InternalLinkage:
637    return true;
638
639  // Template instantiations that go from external to unique-external
640  // shouldn't get diagnosed.
641  case UniqueExternalLinkage:
642    return true;
643
644  case ExternalLinkage:
645    return false;
646  }
647  llvm_unreachable("unknown linkage kind!");
648  return false;
649}
650
651static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
652  // Check the attribute arguments.
653  if (Attr.getNumArgs() > 1) {
654    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
655    return;
656  }
657
658  if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
659    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
660      << Attr.getName() << ExpectedVariableOrFunction;
661    return;
662  }
663
664  NamedDecl *nd = cast<NamedDecl>(D);
665
666  // gcc rejects
667  // class c {
668  //   static int a __attribute__((weakref ("v2")));
669  //   static int b() __attribute__((weakref ("f3")));
670  // };
671  // and ignores the attributes of
672  // void f(void) {
673  //   static int a __attribute__((weakref ("v2")));
674  // }
675  // we reject them
676  const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
677  if (!Ctx->isFileContext()) {
678    S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
679        nd->getNameAsString();
680    return;
681  }
682
683  // The GCC manual says
684  //
685  // At present, a declaration to which `weakref' is attached can only
686  // be `static'.
687  //
688  // It also says
689  //
690  // Without a TARGET,
691  // given as an argument to `weakref' or to `alias', `weakref' is
692  // equivalent to `weak'.
693  //
694  // gcc 4.4.1 will accept
695  // int a7 __attribute__((weakref));
696  // as
697  // int a7 __attribute__((weak));
698  // This looks like a bug in gcc. We reject that for now. We should revisit
699  // it if this behaviour is actually used.
700
701  if (!hasEffectivelyInternalLinkage(nd)) {
702    S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static);
703    return;
704  }
705
706  // GCC rejects
707  // static ((alias ("y"), weakref)).
708  // Should we? How to check that weakref is before or after alias?
709
710  if (Attr.getNumArgs() == 1) {
711    Expr *Arg = Attr.getArg(0);
712    Arg = Arg->IgnoreParenCasts();
713    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
714
715    if (Str == 0 || Str->isWide()) {
716      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
717          << "weakref" << 1;
718      return;
719    }
720    // GCC will accept anything as the argument of weakref. Should we
721    // check for an existing decl?
722    D->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
723                                           Str->getString()));
724  }
725
726  D->addAttr(::new (S.Context) WeakRefAttr(Attr.getLoc(), S.Context));
727}
728
729static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
730  // check the attribute arguments.
731  if (Attr.getNumArgs() != 1) {
732    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
733    return;
734  }
735
736  Expr *Arg = Attr.getArg(0);
737  Arg = Arg->IgnoreParenCasts();
738  StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
739
740  if (Str == 0 || Str->isWide()) {
741    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
742      << "alias" << 1;
743    return;
744  }
745
746  if (S.Context.Target.getTriple().isOSDarwin()) {
747    S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
748    return;
749  }
750
751  // FIXME: check if target symbol exists in current file
752
753  D->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
754                                         Str->getString()));
755}
756
757static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
758  // Check the attribute arguments.
759  if (!checkAttributeNumArgs(S, Attr, 0))
760    return;
761
762  if (!isa<FunctionDecl>(D)) {
763    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
764      << Attr.getName() << ExpectedFunction;
765    return;
766  }
767
768  D->addAttr(::new (S.Context) NakedAttr(Attr.getLoc(), S.Context));
769}
770
771static void handleAlwaysInlineAttr(Sema &S, Decl *D,
772                                   const AttributeList &Attr) {
773  // Check the attribute arguments.
774  if (Attr.hasParameterOrArguments()) {
775    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
776    return;
777  }
778
779  if (!isa<FunctionDecl>(D)) {
780    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
781      << Attr.getName() << ExpectedFunction;
782    return;
783  }
784
785  D->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getLoc(), S.Context));
786}
787
788static void handleMallocAttr(Sema &S, Decl *D, const AttributeList &Attr) {
789  // Check the attribute arguments.
790  if (Attr.hasParameterOrArguments()) {
791    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
792    return;
793  }
794
795  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
796    QualType RetTy = FD->getResultType();
797    if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
798      D->addAttr(::new (S.Context) MallocAttr(Attr.getLoc(), S.Context));
799      return;
800    }
801  }
802
803  S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
804}
805
806static void handleMayAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
807  // check the attribute arguments.
808  if (!checkAttributeNumArgs(S, Attr, 0))
809    return;
810
811  D->addAttr(::new (S.Context) MayAliasAttr(Attr.getLoc(), S.Context));
812}
813
814static void handleNoCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
815  assert(!Attr.isInvalid());
816  if (isa<VarDecl>(D))
817    D->addAttr(::new (S.Context) NoCommonAttr(Attr.getLoc(), S.Context));
818  else
819    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
820      << Attr.getName() << ExpectedVariable;
821}
822
823static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
824  assert(!Attr.isInvalid());
825  if (isa<VarDecl>(D))
826    D->addAttr(::new (S.Context) CommonAttr(Attr.getLoc(), S.Context));
827  else
828    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
829      << Attr.getName() << ExpectedVariable;
830}
831
832static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
833  if (hasDeclarator(D)) return;
834
835  if (S.CheckNoReturnAttr(attr)) return;
836
837  if (!isa<ObjCMethodDecl>(D)) {
838    S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
839      << attr.getName() << ExpectedFunctionOrMethod;
840    return;
841  }
842
843  D->addAttr(::new (S.Context) NoReturnAttr(attr.getLoc(), S.Context));
844}
845
846bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
847  if (attr.hasParameterOrArguments()) {
848    Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
849    attr.setInvalid();
850    return true;
851  }
852
853  return false;
854}
855
856static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
857                                       const AttributeList &Attr) {
858
859  // The checking path for 'noreturn' and 'analyzer_noreturn' are different
860  // because 'analyzer_noreturn' does not impact the type.
861
862  if(!checkAttributeNumArgs(S, Attr, 0))
863      return;
864
865  if (!isFunctionOrMethod(D) && !isa<BlockDecl>(D)) {
866    ValueDecl *VD = dyn_cast<ValueDecl>(D);
867    if (VD == 0 || (!VD->getType()->isBlockPointerType()
868                    && !VD->getType()->isFunctionPointerType())) {
869      S.Diag(Attr.getLoc(),
870             Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
871             : diag::warn_attribute_wrong_decl_type)
872        << Attr.getName() << ExpectedFunctionMethodOrBlock;
873      return;
874    }
875  }
876
877  D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getLoc(), S.Context));
878}
879
880// PS3 PPU-specific.
881static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
882/*
883  Returning a Vector Class in Registers
884
885  According to the PPU ABI specifications, a class with a single member of
886  vector type is returned in memory when used as the return value of a function.
887  This results in inefficient code when implementing vector classes. To return
888  the value in a single vector register, add the vecreturn attribute to the
889  class definition. This attribute is also applicable to struct types.
890
891  Example:
892
893  struct Vector
894  {
895    __vector float xyzw;
896  } __attribute__((vecreturn));
897
898  Vector Add(Vector lhs, Vector rhs)
899  {
900    Vector result;
901    result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
902    return result; // This will be returned in a register
903  }
904*/
905  if (!isa<RecordDecl>(D)) {
906    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
907      << Attr.getName() << ExpectedClass;
908    return;
909  }
910
911  if (D->getAttr<VecReturnAttr>()) {
912    S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn";
913    return;
914  }
915
916  RecordDecl *record = cast<RecordDecl>(D);
917  int count = 0;
918
919  if (!isa<CXXRecordDecl>(record)) {
920    S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
921    return;
922  }
923
924  if (!cast<CXXRecordDecl>(record)->isPOD()) {
925    S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
926    return;
927  }
928
929  for (RecordDecl::field_iterator iter = record->field_begin();
930       iter != record->field_end(); iter++) {
931    if ((count == 1) || !iter->getType()->isVectorType()) {
932      S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
933      return;
934    }
935    count++;
936  }
937
938  D->addAttr(::new (S.Context) VecReturnAttr(Attr.getLoc(), S.Context));
939}
940
941static void handleDependencyAttr(Sema &S, Decl *D, const AttributeList &Attr) {
942  if (!isFunctionOrMethod(D) && !isa<ParmVarDecl>(D)) {
943    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
944      << Attr.getName() << ExpectedFunctionMethodOrParameter;
945    return;
946  }
947  // FIXME: Actually store the attribute on the declaration
948}
949
950static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
951  // check the attribute arguments.
952  if (Attr.hasParameterOrArguments()) {
953    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
954    return;
955  }
956
957  if (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isFunctionOrMethod(D) &&
958      !isa<TypeDecl>(D) && !isa<LabelDecl>(D)) {
959    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
960      << Attr.getName() << ExpectedVariableFunctionOrLabel;
961    return;
962  }
963
964  D->addAttr(::new (S.Context) UnusedAttr(Attr.getLoc(), S.Context));
965}
966
967static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
968  // check the attribute arguments.
969  if (Attr.hasParameterOrArguments()) {
970    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
971    return;
972  }
973
974  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
975    if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
976      S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
977      return;
978    }
979  } else if (!isFunctionOrMethod(D)) {
980    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
981      << Attr.getName() << ExpectedVariableOrFunction;
982    return;
983  }
984
985  D->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
986}
987
988static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
989  // check the attribute arguments.
990  if (Attr.getNumArgs() > 1) {
991    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
992    return;
993  }
994
995  int priority = 65535; // FIXME: Do not hardcode such constants.
996  if (Attr.getNumArgs() > 0) {
997    Expr *E = Attr.getArg(0);
998    llvm::APSInt Idx(32);
999    if (E->isTypeDependent() || E->isValueDependent() ||
1000        !E->isIntegerConstantExpr(Idx, S.Context)) {
1001      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1002        << "constructor" << 1 << E->getSourceRange();
1003      return;
1004    }
1005    priority = Idx.getZExtValue();
1006  }
1007
1008  if (!isa<FunctionDecl>(D)) {
1009    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1010      << Attr.getName() << ExpectedFunction;
1011    return;
1012  }
1013
1014  D->addAttr(::new (S.Context) ConstructorAttr(Attr.getLoc(), S.Context,
1015                                               priority));
1016}
1017
1018static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1019  // check the attribute arguments.
1020  if (Attr.getNumArgs() > 1) {
1021    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1022    return;
1023  }
1024
1025  int priority = 65535; // FIXME: Do not hardcode such constants.
1026  if (Attr.getNumArgs() > 0) {
1027    Expr *E = Attr.getArg(0);
1028    llvm::APSInt Idx(32);
1029    if (E->isTypeDependent() || E->isValueDependent() ||
1030        !E->isIntegerConstantExpr(Idx, S.Context)) {
1031      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1032        << "destructor" << 1 << E->getSourceRange();
1033      return;
1034    }
1035    priority = Idx.getZExtValue();
1036  }
1037
1038  if (!isa<FunctionDecl>(D)) {
1039    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1040      << Attr.getName() << ExpectedFunction;
1041    return;
1042  }
1043
1044  D->addAttr(::new (S.Context) DestructorAttr(Attr.getLoc(), S.Context,
1045                                              priority));
1046}
1047
1048static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1049  unsigned NumArgs = Attr.getNumArgs();
1050  if (NumArgs > 1) {
1051    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1052    return;
1053  }
1054
1055  // Handle the case where deprecated attribute has a text message.
1056  llvm::StringRef Str;
1057  if (NumArgs == 1) {
1058    StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
1059    if (!SE) {
1060      S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string)
1061        << "deprecated";
1062      return;
1063    }
1064    Str = SE->getString();
1065  }
1066
1067  D->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context, Str));
1068}
1069
1070static void handleUnavailableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1071  unsigned NumArgs = Attr.getNumArgs();
1072  if (NumArgs > 1) {
1073    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
1074    return;
1075  }
1076
1077  // Handle the case where unavailable attribute has a text message.
1078  llvm::StringRef Str;
1079  if (NumArgs == 1) {
1080    StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
1081    if (!SE) {
1082      S.Diag(Attr.getArg(0)->getLocStart(),
1083             diag::err_attribute_not_string) << "unavailable";
1084      return;
1085    }
1086    Str = SE->getString();
1087  }
1088  D->addAttr(::new (S.Context) UnavailableAttr(Attr.getLoc(), S.Context, Str));
1089}
1090
1091static void handleArcWeakrefUnavailableAttr(Sema &S, Decl *D,
1092                                            const AttributeList &Attr) {
1093  unsigned NumArgs = Attr.getNumArgs();
1094  if (NumArgs > 0) {
1095    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1096    return;
1097  }
1098
1099  D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(
1100                                          Attr.getLoc(), S.Context));
1101}
1102
1103static void handleAvailabilityAttr(Sema &S, Decl *D,
1104                                   const AttributeList &Attr) {
1105  IdentifierInfo *Platform = Attr.getParameterName();
1106  SourceLocation PlatformLoc = Attr.getParameterLoc();
1107
1108  llvm::StringRef PlatformName
1109    = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1110  if (PlatformName.empty()) {
1111    S.Diag(PlatformLoc, diag::warn_availability_unknown_platform)
1112      << Platform;
1113
1114    PlatformName = Platform->getName();
1115  }
1116
1117  AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1118  AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1119  AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
1120  bool IsUnavailable = Attr.getUnavailableLoc().isValid();
1121
1122  // Ensure that Introduced < Deprecated < Obsoleted (although not all
1123  // of these steps are needed).
1124  if (Introduced.isValid() && Deprecated.isValid() &&
1125      !(Introduced.Version < Deprecated.Version)) {
1126    S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1127      << 1 << PlatformName << Deprecated.Version.getAsString()
1128      << 0 << Introduced.Version.getAsString();
1129    return;
1130  }
1131
1132  if (Introduced.isValid() && Obsoleted.isValid() &&
1133      !(Introduced.Version < Obsoleted.Version)) {
1134    S.Diag(Introduced.KeywordLoc, diag::warn_availability_version_ordering)
1135      << 2 << PlatformName << Obsoleted.Version.getAsString()
1136      << 0 << Introduced.Version.getAsString();
1137    return;
1138  }
1139
1140  if (Deprecated.isValid() && Obsoleted.isValid() &&
1141      !(Deprecated.Version < Obsoleted.Version)) {
1142    S.Diag(Deprecated.KeywordLoc, diag::warn_availability_version_ordering)
1143      << 2 << PlatformName << Obsoleted.Version.getAsString()
1144      << 1 << Deprecated.Version.getAsString();
1145    return;
1146  }
1147
1148  D->addAttr(::new (S.Context) AvailabilityAttr(Attr.getLoc(), S.Context,
1149                                                Platform,
1150                                                Introduced.Version,
1151                                                Deprecated.Version,
1152                                                Obsoleted.Version,
1153                                                IsUnavailable));
1154}
1155
1156static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1157  // check the attribute arguments.
1158  if(!checkAttributeNumArgs(S, Attr, 1))
1159    return;
1160
1161  Expr *Arg = Attr.getArg(0);
1162  Arg = Arg->IgnoreParenCasts();
1163  StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1164
1165  if (Str == 0 || Str->isWide()) {
1166    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1167      << "visibility" << 1;
1168    return;
1169  }
1170
1171  llvm::StringRef TypeStr = Str->getString();
1172  VisibilityAttr::VisibilityType type;
1173
1174  if (TypeStr == "default")
1175    type = VisibilityAttr::Default;
1176  else if (TypeStr == "hidden")
1177    type = VisibilityAttr::Hidden;
1178  else if (TypeStr == "internal")
1179    type = VisibilityAttr::Hidden; // FIXME
1180  else if (TypeStr == "protected")
1181    type = VisibilityAttr::Protected;
1182  else {
1183    S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
1184    return;
1185  }
1186
1187  D->addAttr(::new (S.Context) VisibilityAttr(Attr.getLoc(), S.Context, type));
1188}
1189
1190static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
1191                                       const AttributeList &Attr) {
1192  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl);
1193  if (!method) {
1194    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
1195      << ExpectedMethod;
1196    return;
1197  }
1198
1199  if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) {
1200    if (!Attr.getParameterName() && Attr.getNumArgs() == 1) {
1201      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1202        << "objc_method_family" << 1;
1203    } else {
1204      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1205    }
1206    Attr.setInvalid();
1207    return;
1208  }
1209
1210  llvm::StringRef param = Attr.getParameterName()->getName();
1211  ObjCMethodFamilyAttr::FamilyKind family;
1212  if (param == "none")
1213    family = ObjCMethodFamilyAttr::OMF_None;
1214  else if (param == "alloc")
1215    family = ObjCMethodFamilyAttr::OMF_alloc;
1216  else if (param == "copy")
1217    family = ObjCMethodFamilyAttr::OMF_copy;
1218  else if (param == "init")
1219    family = ObjCMethodFamilyAttr::OMF_init;
1220  else if (param == "mutableCopy")
1221    family = ObjCMethodFamilyAttr::OMF_mutableCopy;
1222  else if (param == "new")
1223    family = ObjCMethodFamilyAttr::OMF_new;
1224  else {
1225    // Just warn and ignore it.  This is future-proof against new
1226    // families being used in system headers.
1227    S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family);
1228    return;
1229  }
1230
1231  if (family == ObjCMethodFamilyAttr::OMF_init &&
1232      !method->getResultType()->isObjCObjectPointerType()) {
1233    S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
1234      << method->getResultType();
1235    // Ignore the attribute.
1236    return;
1237  }
1238
1239  method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getLoc(),
1240                                                       S.Context, family));
1241}
1242
1243static void handleObjCExceptionAttr(Sema &S, Decl *D,
1244                                    const AttributeList &Attr) {
1245  if (!checkAttributeNumArgs(S, Attr, 0))
1246    return;
1247
1248  ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
1249  if (OCI == 0) {
1250    S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1251    return;
1252  }
1253
1254  D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getLoc(), S.Context));
1255}
1256
1257static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
1258  if (Attr.getNumArgs() != 0) {
1259    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1260    return;
1261  }
1262  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
1263    QualType T = TD->getUnderlyingType();
1264    if (!T->isPointerType() ||
1265        !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
1266      S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
1267      return;
1268    }
1269  }
1270  D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getLoc(), S.Context));
1271}
1272
1273static void
1274handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1275  if (Attr.getNumArgs() != 0) {
1276    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1277    return;
1278  }
1279
1280  if (!isa<FunctionDecl>(D)) {
1281    S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
1282    return;
1283  }
1284
1285  D->addAttr(::new (S.Context) OverloadableAttr(Attr.getLoc(), S.Context));
1286}
1287
1288static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1289  if (!Attr.getParameterName()) {
1290    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1291      << "blocks" << 1;
1292    return;
1293  }
1294
1295  if (Attr.getNumArgs() != 0) {
1296    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1297    return;
1298  }
1299
1300  BlocksAttr::BlockType type;
1301  if (Attr.getParameterName()->isStr("byref"))
1302    type = BlocksAttr::ByRef;
1303  else {
1304    S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1305      << "blocks" << Attr.getParameterName();
1306    return;
1307  }
1308
1309  D->addAttr(::new (S.Context) BlocksAttr(Attr.getLoc(), S.Context, type));
1310}
1311
1312static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1313  // check the attribute arguments.
1314  if (Attr.getNumArgs() > 2) {
1315    S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
1316    return;
1317  }
1318
1319  int sentinel = 0;
1320  if (Attr.getNumArgs() > 0) {
1321    Expr *E = Attr.getArg(0);
1322    llvm::APSInt Idx(32);
1323    if (E->isTypeDependent() || E->isValueDependent() ||
1324        !E->isIntegerConstantExpr(Idx, S.Context)) {
1325      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1326       << "sentinel" << 1 << E->getSourceRange();
1327      return;
1328    }
1329    sentinel = Idx.getZExtValue();
1330
1331    if (sentinel < 0) {
1332      S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
1333        << E->getSourceRange();
1334      return;
1335    }
1336  }
1337
1338  int nullPos = 0;
1339  if (Attr.getNumArgs() > 1) {
1340    Expr *E = Attr.getArg(1);
1341    llvm::APSInt Idx(32);
1342    if (E->isTypeDependent() || E->isValueDependent() ||
1343        !E->isIntegerConstantExpr(Idx, S.Context)) {
1344      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1345        << "sentinel" << 2 << E->getSourceRange();
1346      return;
1347    }
1348    nullPos = Idx.getZExtValue();
1349
1350    if (nullPos > 1 || nullPos < 0) {
1351      // FIXME: This error message could be improved, it would be nice
1352      // to say what the bounds actually are.
1353      S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
1354        << E->getSourceRange();
1355      return;
1356    }
1357  }
1358
1359  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1360    const FunctionType *FT = FD->getType()->getAs<FunctionType>();
1361    assert(FT && "FunctionDecl has non-function type?");
1362
1363    if (isa<FunctionNoProtoType>(FT)) {
1364      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
1365      return;
1366    }
1367
1368    if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1369      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1370      return;
1371    }
1372  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
1373    if (!MD->isVariadic()) {
1374      S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
1375      return;
1376    }
1377  } else if (isa<BlockDecl>(D)) {
1378    // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the
1379    // caller.
1380    ;
1381  } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
1382    QualType Ty = V->getType();
1383    if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
1384      const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D)
1385       : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
1386      if (!cast<FunctionProtoType>(FT)->isVariadic()) {
1387        int m = Ty->isFunctionPointerType() ? 0 : 1;
1388        S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
1389        return;
1390      }
1391    } else {
1392      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1393        << Attr.getName() << ExpectedFunctionMethodOrBlock;
1394      return;
1395    }
1396  } else {
1397    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1398      << Attr.getName() << ExpectedFunctionMethodOrBlock;
1399    return;
1400  }
1401  D->addAttr(::new (S.Context) SentinelAttr(Attr.getLoc(), S.Context, sentinel,
1402                                            nullPos));
1403}
1404
1405static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
1406  // check the attribute arguments.
1407  if (!checkAttributeNumArgs(S, Attr, 0))
1408    return;
1409
1410  if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
1411    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1412      << Attr.getName() << ExpectedFunctionOrMethod;
1413    return;
1414  }
1415
1416  if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
1417    S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1418      << Attr.getName() << 0;
1419    return;
1420  }
1421  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
1422    if (MD->getResultType()->isVoidType()) {
1423      S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1424      << Attr.getName() << 1;
1425      return;
1426    }
1427
1428  D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getLoc(), S.Context));
1429}
1430
1431static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1432  // check the attribute arguments.
1433  if (Attr.hasParameterOrArguments()) {
1434    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1435    return;
1436  }
1437
1438  if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
1439    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1440      << Attr.getName() << ExpectedVariableOrFunction;
1441    return;
1442  }
1443
1444  NamedDecl *nd = cast<NamedDecl>(D);
1445
1446  // 'weak' only applies to declarations with external linkage.
1447  if (hasEffectivelyInternalLinkage(nd)) {
1448    S.Diag(Attr.getLoc(), diag::err_attribute_weak_static);
1449    return;
1450  }
1451
1452  nd->addAttr(::new (S.Context) WeakAttr(Attr.getLoc(), S.Context));
1453}
1454
1455static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1456  // check the attribute arguments.
1457  if (!checkAttributeNumArgs(S, Attr, 0))
1458    return;
1459
1460
1461  // weak_import only applies to variable & function declarations.
1462  bool isDef = false;
1463  if (!D->canBeWeakImported(isDef)) {
1464    if (isDef)
1465      S.Diag(Attr.getLoc(),
1466             diag::warn_attribute_weak_import_invalid_on_definition)
1467        << "weak_import" << 2 /*variable and function*/;
1468    else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
1469             (S.Context.Target.getTriple().isOSDarwin() &&
1470              isa<ObjCInterfaceDecl>(D))) {
1471      // Nothing to warn about here.
1472    } else
1473      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1474        << Attr.getName() << ExpectedVariableOrFunction;
1475
1476    return;
1477  }
1478
1479  D->addAttr(::new (S.Context) WeakImportAttr(Attr.getLoc(), S.Context));
1480}
1481
1482static void handleReqdWorkGroupSize(Sema &S, Decl *D,
1483                                    const AttributeList &Attr) {
1484  // Attribute has 3 arguments.
1485  if (!checkAttributeNumArgs(S, Attr, 3))
1486    return;
1487
1488  unsigned WGSize[3];
1489  for (unsigned i = 0; i < 3; ++i) {
1490    Expr *E = Attr.getArg(i);
1491    llvm::APSInt ArgNum(32);
1492    if (E->isTypeDependent() || E->isValueDependent() ||
1493        !E->isIntegerConstantExpr(ArgNum, S.Context)) {
1494      S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1495        << "reqd_work_group_size" << E->getSourceRange();
1496      return;
1497    }
1498    WGSize[i] = (unsigned) ArgNum.getZExtValue();
1499  }
1500  D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getLoc(), S.Context,
1501                                                     WGSize[0], WGSize[1],
1502                                                     WGSize[2]));
1503}
1504
1505static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1506  // Attribute has no arguments.
1507  if (!checkAttributeNumArgs(S, Attr, 1))
1508    return;
1509
1510  // Make sure that there is a string literal as the sections's single
1511  // argument.
1512  Expr *ArgExpr = Attr.getArg(0);
1513  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
1514  if (!SE) {
1515    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
1516    return;
1517  }
1518
1519  // If the target wants to validate the section specifier, make it happen.
1520  std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString());
1521  if (!Error.empty()) {
1522    S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
1523    << Error;
1524    return;
1525  }
1526
1527  // This attribute cannot be applied to local variables.
1528  if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
1529    S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
1530    return;
1531  }
1532
1533  D->addAttr(::new (S.Context) SectionAttr(Attr.getLoc(), S.Context,
1534                                           SE->getString()));
1535}
1536
1537
1538static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1539  // check the attribute arguments.
1540  if (Attr.hasParameterOrArguments()) {
1541    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1542    return;
1543  }
1544
1545  if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) {
1546    if (Existing->getLocation().isInvalid())
1547      Existing->setLocation(Attr.getLoc());
1548  } else {
1549    D->addAttr(::new (S.Context) NoThrowAttr(Attr.getLoc(), S.Context));
1550  }
1551}
1552
1553static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1554  // check the attribute arguments.
1555  if (Attr.hasParameterOrArguments()) {
1556    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1557    return;
1558  }
1559
1560  if (ConstAttr *Existing = D->getAttr<ConstAttr>()) {
1561   if (Existing->getLocation().isInvalid())
1562     Existing->setLocation(Attr.getLoc());
1563  } else {
1564    D->addAttr(::new (S.Context) ConstAttr(Attr.getLoc(), S.Context));
1565  }
1566}
1567
1568static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1569  // check the attribute arguments.
1570  if (!checkAttributeNumArgs(S, Attr, 0))
1571    return;
1572
1573  D->addAttr(::new (S.Context) PureAttr(Attr.getLoc(), S.Context));
1574}
1575
1576static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1577  if (!Attr.getParameterName()) {
1578    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1579    return;
1580  }
1581
1582  if (Attr.getNumArgs() != 0) {
1583    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1584    return;
1585  }
1586
1587  VarDecl *VD = dyn_cast<VarDecl>(D);
1588
1589  if (!VD || !VD->hasLocalStorage()) {
1590    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
1591    return;
1592  }
1593
1594  // Look up the function
1595  // FIXME: Lookup probably isn't looking in the right place
1596  NamedDecl *CleanupDecl
1597    = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
1598                         Attr.getParameterLoc(), Sema::LookupOrdinaryName);
1599  if (!CleanupDecl) {
1600    S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
1601      Attr.getParameterName();
1602    return;
1603  }
1604
1605  FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
1606  if (!FD) {
1607    S.Diag(Attr.getParameterLoc(),
1608           diag::err_attribute_cleanup_arg_not_function)
1609      << Attr.getParameterName();
1610    return;
1611  }
1612
1613  if (FD->getNumParams() != 1) {
1614    S.Diag(Attr.getParameterLoc(),
1615           diag::err_attribute_cleanup_func_must_take_one_arg)
1616      << Attr.getParameterName();
1617    return;
1618  }
1619
1620  // We're currently more strict than GCC about what function types we accept.
1621  // If this ever proves to be a problem it should be easy to fix.
1622  QualType Ty = S.Context.getPointerType(VD->getType());
1623  QualType ParamTy = FD->getParamDecl(0)->getType();
1624  if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
1625                                   ParamTy, Ty) != Sema::Compatible) {
1626    S.Diag(Attr.getParameterLoc(),
1627           diag::err_attribute_cleanup_func_arg_incompatible_type) <<
1628      Attr.getParameterName() << ParamTy << Ty;
1629    return;
1630  }
1631
1632  D->addAttr(::new (S.Context) CleanupAttr(Attr.getLoc(), S.Context, FD));
1633  S.MarkDeclarationReferenced(Attr.getParameterLoc(), FD);
1634}
1635
1636/// Handle __attribute__((format_arg((idx)))) attribute based on
1637/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1638static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1639  if (!checkAttributeNumArgs(S, Attr, 1))
1640    return;
1641
1642  if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
1643    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1644      << Attr.getName() << ExpectedFunction;
1645    return;
1646  }
1647
1648  // In C++ the implicit 'this' function parameter also counts, and they are
1649  // counted from one.
1650  bool HasImplicitThisParam = isInstanceMethod(D);
1651  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1652  unsigned FirstIdx = 1;
1653
1654  // checks for the 2nd argument
1655  Expr *IdxExpr = Attr.getArg(0);
1656  llvm::APSInt Idx(32);
1657  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1658      !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1659    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1660    << "format" << 2 << IdxExpr->getSourceRange();
1661    return;
1662  }
1663
1664  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1665    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1666    << "format" << 2 << IdxExpr->getSourceRange();
1667    return;
1668  }
1669
1670  unsigned ArgIdx = Idx.getZExtValue() - 1;
1671
1672  if (HasImplicitThisParam) {
1673    if (ArgIdx == 0) {
1674      S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
1675        << "format_arg" << IdxExpr->getSourceRange();
1676      return;
1677    }
1678    ArgIdx--;
1679  }
1680
1681  // make sure the format string is really a string
1682  QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
1683
1684  bool not_nsstring_type = !isNSStringType(Ty, S.Context);
1685  if (not_nsstring_type &&
1686      !isCFStringType(Ty, S.Context) &&
1687      (!Ty->isPointerType() ||
1688       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1689    // FIXME: Should highlight the actual expression that has the wrong type.
1690    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1691    << (not_nsstring_type ? "a string type" : "an NSString")
1692       << IdxExpr->getSourceRange();
1693    return;
1694  }
1695  Ty = getFunctionOrMethodResultType(D);
1696  if (!isNSStringType(Ty, S.Context) &&
1697      !isCFStringType(Ty, S.Context) &&
1698      (!Ty->isPointerType() ||
1699       !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
1700    // FIXME: Should highlight the actual expression that has the wrong type.
1701    S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
1702    << (not_nsstring_type ? "string type" : "NSString")
1703       << IdxExpr->getSourceRange();
1704    return;
1705  }
1706
1707  D->addAttr(::new (S.Context) FormatArgAttr(Attr.getLoc(), S.Context,
1708                                             Idx.getZExtValue()));
1709}
1710
1711enum FormatAttrKind {
1712  CFStringFormat,
1713  NSStringFormat,
1714  StrftimeFormat,
1715  SupportedFormat,
1716  IgnoredFormat,
1717  InvalidFormat
1718};
1719
1720/// getFormatAttrKind - Map from format attribute names to supported format
1721/// types.
1722static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) {
1723  // Check for formats that get handled specially.
1724  if (Format == "NSString")
1725    return NSStringFormat;
1726  if (Format == "CFString")
1727    return CFStringFormat;
1728  if (Format == "strftime")
1729    return StrftimeFormat;
1730
1731  // Otherwise, check for supported formats.
1732  if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
1733      Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
1734      Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
1735      Format == "zcmn_err" ||
1736      Format == "kprintf")  // OpenBSD.
1737    return SupportedFormat;
1738
1739  if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
1740      Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
1741    return IgnoredFormat;
1742
1743  return InvalidFormat;
1744}
1745
1746/// Handle __attribute__((init_priority(priority))) attributes based on
1747/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
1748static void handleInitPriorityAttr(Sema &S, Decl *D,
1749                                   const AttributeList &Attr) {
1750  if (!S.getLangOptions().CPlusPlus) {
1751    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1752    return;
1753  }
1754
1755  if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) {
1756    S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1757    Attr.setInvalid();
1758    return;
1759  }
1760  QualType T = dyn_cast<VarDecl>(D)->getType();
1761  if (S.Context.getAsArrayType(T))
1762    T = S.Context.getBaseElementType(T);
1763  if (!T->getAs<RecordType>()) {
1764    S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1765    Attr.setInvalid();
1766    return;
1767  }
1768
1769  if (Attr.getNumArgs() != 1) {
1770    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1771    Attr.setInvalid();
1772    return;
1773  }
1774  Expr *priorityExpr = Attr.getArg(0);
1775
1776  llvm::APSInt priority(32);
1777  if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
1778      !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
1779    S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1780    << "init_priority" << priorityExpr->getSourceRange();
1781    Attr.setInvalid();
1782    return;
1783  }
1784  unsigned prioritynum = priority.getZExtValue();
1785  if (prioritynum < 101 || prioritynum > 65535) {
1786    S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
1787    <<  priorityExpr->getSourceRange();
1788    Attr.setInvalid();
1789    return;
1790  }
1791  D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getLoc(), S.Context,
1792                                                prioritynum));
1793}
1794
1795/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
1796/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1797static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1798
1799  if (!Attr.getParameterName()) {
1800    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1801      << "format" << 1;
1802    return;
1803  }
1804
1805  if (Attr.getNumArgs() != 2) {
1806    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
1807    return;
1808  }
1809
1810  if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) {
1811    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1812      << Attr.getName() << ExpectedFunction;
1813    return;
1814  }
1815
1816  // In C++ the implicit 'this' function parameter also counts, and they are
1817  // counted from one.
1818  bool HasImplicitThisParam = isInstanceMethod(D);
1819  unsigned NumArgs  = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
1820  unsigned FirstIdx = 1;
1821
1822  llvm::StringRef Format = Attr.getParameterName()->getName();
1823
1824  // Normalize the argument, __foo__ becomes foo.
1825  if (Format.startswith("__") && Format.endswith("__"))
1826    Format = Format.substr(2, Format.size() - 4);
1827
1828  // Check for supported formats.
1829  FormatAttrKind Kind = getFormatAttrKind(Format);
1830
1831  if (Kind == IgnoredFormat)
1832    return;
1833
1834  if (Kind == InvalidFormat) {
1835    S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1836      << "format" << Attr.getParameterName()->getName();
1837    return;
1838  }
1839
1840  // checks for the 2nd argument
1841  Expr *IdxExpr = Attr.getArg(0);
1842  llvm::APSInt Idx(32);
1843  if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1844      !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
1845    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1846      << "format" << 2 << IdxExpr->getSourceRange();
1847    return;
1848  }
1849
1850  if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1851    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1852      << "format" << 2 << IdxExpr->getSourceRange();
1853    return;
1854  }
1855
1856  // FIXME: Do we need to bounds check?
1857  unsigned ArgIdx = Idx.getZExtValue() - 1;
1858
1859  if (HasImplicitThisParam) {
1860    if (ArgIdx == 0) {
1861      S.Diag(Attr.getLoc(),
1862             diag::err_format_attribute_implicit_this_format_string)
1863        << IdxExpr->getSourceRange();
1864      return;
1865    }
1866    ArgIdx--;
1867  }
1868
1869  // make sure the format string is really a string
1870  QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
1871
1872  if (Kind == CFStringFormat) {
1873    if (!isCFStringType(Ty, S.Context)) {
1874      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1875        << "a CFString" << IdxExpr->getSourceRange();
1876      return;
1877    }
1878  } else if (Kind == NSStringFormat) {
1879    // FIXME: do we need to check if the type is NSString*?  What are the
1880    // semantics?
1881    if (!isNSStringType(Ty, S.Context)) {
1882      // FIXME: Should highlight the actual expression that has the wrong type.
1883      S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1884        << "an NSString" << IdxExpr->getSourceRange();
1885      return;
1886    }
1887  } else if (!Ty->isPointerType() ||
1888             !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
1889    // FIXME: Should highlight the actual expression that has the wrong type.
1890    S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1891      << "a string type" << IdxExpr->getSourceRange();
1892    return;
1893  }
1894
1895  // check the 3rd argument
1896  Expr *FirstArgExpr = Attr.getArg(1);
1897  llvm::APSInt FirstArg(32);
1898  if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
1899      !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
1900    S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1901      << "format" << 3 << FirstArgExpr->getSourceRange();
1902    return;
1903  }
1904
1905  // check if the function is variadic if the 3rd argument non-zero
1906  if (FirstArg != 0) {
1907    if (isFunctionOrMethodVariadic(D)) {
1908      ++NumArgs; // +1 for ...
1909    } else {
1910      S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
1911      return;
1912    }
1913  }
1914
1915  // strftime requires FirstArg to be 0 because it doesn't read from any
1916  // variable the input is just the current time + the format string.
1917  if (Kind == StrftimeFormat) {
1918    if (FirstArg != 0) {
1919      S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
1920        << FirstArgExpr->getSourceRange();
1921      return;
1922    }
1923  // if 0 it disables parameter checking (to use with e.g. va_list)
1924  } else if (FirstArg != 0 && FirstArg != NumArgs) {
1925    S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1926      << "format" << 3 << FirstArgExpr->getSourceRange();
1927    return;
1928  }
1929
1930  // Check whether we already have an equivalent format attribute.
1931  for (specific_attr_iterator<FormatAttr>
1932         i = D->specific_attr_begin<FormatAttr>(),
1933         e = D->specific_attr_end<FormatAttr>();
1934       i != e ; ++i) {
1935    FormatAttr *f = *i;
1936    if (f->getType() == Format &&
1937        f->getFormatIdx() == (int)Idx.getZExtValue() &&
1938        f->getFirstArg() == (int)FirstArg.getZExtValue()) {
1939      // If we don't have a valid location for this attribute, adopt the
1940      // location.
1941      if (f->getLocation().isInvalid())
1942        f->setLocation(Attr.getLoc());
1943      return;
1944    }
1945  }
1946
1947  D->addAttr(::new (S.Context) FormatAttr(Attr.getLoc(), S.Context, Format,
1948                                          Idx.getZExtValue(),
1949                                          FirstArg.getZExtValue()));
1950}
1951
1952static void handleTransparentUnionAttr(Sema &S, Decl *D,
1953                                       const AttributeList &Attr) {
1954  // check the attribute arguments.
1955  if (!checkAttributeNumArgs(S, Attr, 0))
1956    return;
1957
1958
1959  // Try to find the underlying union declaration.
1960  RecordDecl *RD = 0;
1961  TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
1962  if (TD && TD->getUnderlyingType()->isUnionType())
1963    RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
1964  else
1965    RD = dyn_cast<RecordDecl>(D);
1966
1967  if (!RD || !RD->isUnion()) {
1968    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1969      << Attr.getName() << ExpectedUnion;
1970    return;
1971  }
1972
1973  if (!RD->isDefinition()) {
1974    S.Diag(Attr.getLoc(),
1975        diag::warn_transparent_union_attribute_not_definition);
1976    return;
1977  }
1978
1979  RecordDecl::field_iterator Field = RD->field_begin(),
1980                          FieldEnd = RD->field_end();
1981  if (Field == FieldEnd) {
1982    S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
1983    return;
1984  }
1985
1986  FieldDecl *FirstField = *Field;
1987  QualType FirstType = FirstField->getType();
1988  if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
1989    S.Diag(FirstField->getLocation(),
1990           diag::warn_transparent_union_attribute_floating)
1991      << FirstType->isVectorType() << FirstType;
1992    return;
1993  }
1994
1995  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
1996  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
1997  for (; Field != FieldEnd; ++Field) {
1998    QualType FieldType = Field->getType();
1999    if (S.Context.getTypeSize(FieldType) != FirstSize ||
2000        S.Context.getTypeAlign(FieldType) != FirstAlign) {
2001      // Warn if we drop the attribute.
2002      bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
2003      unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
2004                                 : S.Context.getTypeAlign(FieldType);
2005      S.Diag(Field->getLocation(),
2006          diag::warn_transparent_union_attribute_field_size_align)
2007        << isSize << Field->getDeclName() << FieldBits;
2008      unsigned FirstBits = isSize? FirstSize : FirstAlign;
2009      S.Diag(FirstField->getLocation(),
2010             diag::note_transparent_union_first_field_size_align)
2011        << isSize << FirstBits;
2012      return;
2013    }
2014  }
2015
2016  RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getLoc(), S.Context));
2017}
2018
2019static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2020  // check the attribute arguments.
2021  if (!checkAttributeNumArgs(S, Attr, 1))
2022    return;
2023
2024  Expr *ArgExpr = Attr.getArg(0);
2025  StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
2026
2027  // Make sure that there is a string literal as the annotation's single
2028  // argument.
2029  if (!SE) {
2030    S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
2031    return;
2032  }
2033  D->addAttr(::new (S.Context) AnnotateAttr(Attr.getLoc(), S.Context,
2034                                            SE->getString()));
2035}
2036
2037static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2038  // check the attribute arguments.
2039  if (Attr.getNumArgs() > 1) {
2040    S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2041    return;
2042  }
2043
2044  //FIXME: The C++0x version of this attribute has more limited applicabilty
2045  //       than GNU's, and should error out when it is used to specify a
2046  //       weaker alignment, rather than being silently ignored.
2047
2048  if (Attr.getNumArgs() == 0) {
2049    D->addAttr(::new (S.Context) AlignedAttr(Attr.getLoc(), S.Context, true, 0));
2050    return;
2051  }
2052
2053  S.AddAlignedAttr(Attr.getLoc(), D, Attr.getArg(0));
2054}
2055
2056void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, Expr *E) {
2057  if (E->isTypeDependent() || E->isValueDependent()) {
2058    // Save dependent expressions in the AST to be instantiated.
2059    D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
2060    return;
2061  }
2062
2063  // FIXME: Cache the number on the Attr object?
2064  llvm::APSInt Alignment(32);
2065  if (!E->isIntegerConstantExpr(Alignment, Context)) {
2066    Diag(AttrLoc, diag::err_attribute_argument_not_int)
2067      << "aligned" << E->getSourceRange();
2068    return;
2069  }
2070  if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
2071    Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
2072      << E->getSourceRange();
2073    return;
2074  }
2075
2076  D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
2077}
2078
2079void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, TypeSourceInfo *TS) {
2080  // FIXME: Cache the number on the Attr object if non-dependent?
2081  // FIXME: Perform checking of type validity
2082  D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, false, TS));
2083  return;
2084}
2085
2086/// handleModeAttr - This attribute modifies the width of a decl with primitive
2087/// type.
2088///
2089/// Despite what would be logical, the mode attribute is a decl attribute, not a
2090/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
2091/// HImode, not an intermediate pointer.
2092static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2093  // This attribute isn't documented, but glibc uses it.  It changes
2094  // the width of an int or unsigned int to the specified size.
2095
2096  // Check that there aren't any arguments
2097  if (!checkAttributeNumArgs(S, Attr, 0))
2098    return;
2099
2100
2101  IdentifierInfo *Name = Attr.getParameterName();
2102  if (!Name) {
2103    S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
2104    return;
2105  }
2106
2107  llvm::StringRef Str = Attr.getParameterName()->getName();
2108
2109  // Normalize the attribute name, __foo__ becomes foo.
2110  if (Str.startswith("__") && Str.endswith("__"))
2111    Str = Str.substr(2, Str.size() - 4);
2112
2113  unsigned DestWidth = 0;
2114  bool IntegerMode = true;
2115  bool ComplexMode = false;
2116  switch (Str.size()) {
2117  case 2:
2118    switch (Str[0]) {
2119    case 'Q': DestWidth = 8; break;
2120    case 'H': DestWidth = 16; break;
2121    case 'S': DestWidth = 32; break;
2122    case 'D': DestWidth = 64; break;
2123    case 'X': DestWidth = 96; break;
2124    case 'T': DestWidth = 128; break;
2125    }
2126    if (Str[1] == 'F') {
2127      IntegerMode = false;
2128    } else if (Str[1] == 'C') {
2129      IntegerMode = false;
2130      ComplexMode = true;
2131    } else if (Str[1] != 'I') {
2132      DestWidth = 0;
2133    }
2134    break;
2135  case 4:
2136    // FIXME: glibc uses 'word' to define register_t; this is narrower than a
2137    // pointer on PIC16 and other embedded platforms.
2138    if (Str == "word")
2139      DestWidth = S.Context.Target.getPointerWidth(0);
2140    else if (Str == "byte")
2141      DestWidth = S.Context.Target.getCharWidth();
2142    break;
2143  case 7:
2144    if (Str == "pointer")
2145      DestWidth = S.Context.Target.getPointerWidth(0);
2146    break;
2147  }
2148
2149  QualType OldTy;
2150  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
2151    OldTy = TD->getUnderlyingType();
2152  else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
2153    OldTy = VD->getType();
2154  else {
2155    S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
2156      << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc());
2157    return;
2158  }
2159
2160  if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
2161    S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
2162  else if (IntegerMode) {
2163    if (!OldTy->isIntegralOrEnumerationType())
2164      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2165  } else if (ComplexMode) {
2166    if (!OldTy->isComplexType())
2167      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2168  } else {
2169    if (!OldTy->isFloatingType())
2170      S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2171  }
2172
2173  // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
2174  // and friends, at least with glibc.
2175  // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
2176  // width on unusual platforms.
2177  // FIXME: Make sure floating-point mappings are accurate
2178  // FIXME: Support XF and TF types
2179  QualType NewTy;
2180  switch (DestWidth) {
2181  case 0:
2182    S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
2183    return;
2184  default:
2185    S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2186    return;
2187  case 8:
2188    if (!IntegerMode) {
2189      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2190      return;
2191    }
2192    if (OldTy->isSignedIntegerType())
2193      NewTy = S.Context.SignedCharTy;
2194    else
2195      NewTy = S.Context.UnsignedCharTy;
2196    break;
2197  case 16:
2198    if (!IntegerMode) {
2199      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2200      return;
2201    }
2202    if (OldTy->isSignedIntegerType())
2203      NewTy = S.Context.ShortTy;
2204    else
2205      NewTy = S.Context.UnsignedShortTy;
2206    break;
2207  case 32:
2208    if (!IntegerMode)
2209      NewTy = S.Context.FloatTy;
2210    else if (OldTy->isSignedIntegerType())
2211      NewTy = S.Context.IntTy;
2212    else
2213      NewTy = S.Context.UnsignedIntTy;
2214    break;
2215  case 64:
2216    if (!IntegerMode)
2217      NewTy = S.Context.DoubleTy;
2218    else if (OldTy->isSignedIntegerType())
2219      if (S.Context.Target.getLongWidth() == 64)
2220        NewTy = S.Context.LongTy;
2221      else
2222        NewTy = S.Context.LongLongTy;
2223    else
2224      if (S.Context.Target.getLongWidth() == 64)
2225        NewTy = S.Context.UnsignedLongTy;
2226      else
2227        NewTy = S.Context.UnsignedLongLongTy;
2228    break;
2229  case 96:
2230    NewTy = S.Context.LongDoubleTy;
2231    break;
2232  case 128:
2233    if (!IntegerMode) {
2234      S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2235      return;
2236    }
2237    if (OldTy->isSignedIntegerType())
2238      NewTy = S.Context.Int128Ty;
2239    else
2240      NewTy = S.Context.UnsignedInt128Ty;
2241    break;
2242  }
2243
2244  if (ComplexMode) {
2245    NewTy = S.Context.getComplexType(NewTy);
2246  }
2247
2248  // Install the new type.
2249  if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2250    // FIXME: preserve existing source info.
2251    TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
2252  } else
2253    cast<ValueDecl>(D)->setType(NewTy);
2254}
2255
2256static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2257  // check the attribute arguments.
2258  if (!checkAttributeNumArgs(S, Attr, 0))
2259    return;
2260
2261  if (!isFunctionOrMethod(D)) {
2262    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2263      << Attr.getName() << ExpectedFunction;
2264    return;
2265  }
2266
2267  D->addAttr(::new (S.Context) NoDebugAttr(Attr.getLoc(), S.Context));
2268}
2269
2270static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2271  // check the attribute arguments.
2272  if (!checkAttributeNumArgs(S, Attr, 0))
2273    return;
2274
2275
2276  if (!isa<FunctionDecl>(D)) {
2277    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2278      << Attr.getName() << ExpectedFunction;
2279    return;
2280  }
2281
2282  D->addAttr(::new (S.Context) NoInlineAttr(Attr.getLoc(), S.Context));
2283}
2284
2285static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
2286                                           const AttributeList &Attr) {
2287  // check the attribute arguments.
2288  if (!checkAttributeNumArgs(S, Attr, 0))
2289    return;
2290
2291
2292  if (!isa<FunctionDecl>(D)) {
2293    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2294      << Attr.getName() << ExpectedFunction;
2295    return;
2296  }
2297
2298  D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getLoc(),
2299                                                        S.Context));
2300}
2301
2302static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2303  if (S.LangOpts.CUDA) {
2304    // check the attribute arguments.
2305    if (Attr.hasParameterOrArguments()) {
2306      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2307      return;
2308    }
2309
2310    if (!isa<VarDecl>(D)) {
2311      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2312        << Attr.getName() << ExpectedVariable;
2313      return;
2314    }
2315
2316    D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getLoc(), S.Context));
2317  } else {
2318    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
2319  }
2320}
2321
2322static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2323  if (S.LangOpts.CUDA) {
2324    // check the attribute arguments.
2325    if (Attr.getNumArgs() != 0) {
2326      S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2327      return;
2328    }
2329
2330    if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
2331      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2332        << Attr.getName() << ExpectedVariableOrFunction;
2333      return;
2334    }
2335
2336    D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getLoc(), S.Context));
2337  } else {
2338    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
2339  }
2340}
2341
2342static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2343  if (S.LangOpts.CUDA) {
2344    // check the attribute arguments.
2345    if (!checkAttributeNumArgs(S, Attr, 0))
2346      return;
2347
2348    if (!isa<FunctionDecl>(D)) {
2349      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2350        << Attr.getName() << ExpectedFunction;
2351      return;
2352    }
2353
2354    FunctionDecl *FD = cast<FunctionDecl>(D);
2355    if (!FD->getResultType()->isVoidType()) {
2356      TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
2357      if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
2358        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2359          << FD->getType()
2360          << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
2361                                          "void");
2362      } else {
2363        S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2364          << FD->getType();
2365      }
2366      return;
2367    }
2368
2369    D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getLoc(), S.Context));
2370  } else {
2371    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
2372  }
2373}
2374
2375static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2376  if (S.LangOpts.CUDA) {
2377    // check the attribute arguments.
2378    if (!checkAttributeNumArgs(S, Attr, 0))
2379      return;
2380
2381
2382    if (!isa<FunctionDecl>(D)) {
2383      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2384        << Attr.getName() << ExpectedFunction;
2385      return;
2386    }
2387
2388    D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getLoc(), S.Context));
2389  } else {
2390    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
2391  }
2392}
2393
2394static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2395  if (S.LangOpts.CUDA) {
2396    // check the attribute arguments.
2397    if (!checkAttributeNumArgs(S, Attr, 0))
2398      return;
2399
2400
2401    if (!isa<VarDecl>(D)) {
2402      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2403        << Attr.getName() << ExpectedVariable;
2404      return;
2405    }
2406
2407    D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getLoc(), S.Context));
2408  } else {
2409    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
2410  }
2411}
2412
2413static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2414  // check the attribute arguments.
2415  if (!checkAttributeNumArgs(S, Attr, 0))
2416    return;
2417
2418  FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
2419  if (Fn == 0) {
2420    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2421      << Attr.getName() << ExpectedFunction;
2422    return;
2423  }
2424
2425  if (!Fn->isInlineSpecified()) {
2426    S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
2427    return;
2428  }
2429
2430  D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getLoc(), S.Context));
2431}
2432
2433static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2434  if (hasDeclarator(D)) return;
2435
2436  // Diagnostic is emitted elsewhere: here we store the (valid) Attr
2437  // in the Decl node for syntactic reasoning, e.g., pretty-printing.
2438  CallingConv CC;
2439  if (S.CheckCallingConvAttr(Attr, CC))
2440    return;
2441
2442  if (!isa<ObjCMethodDecl>(D)) {
2443    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2444      << Attr.getName() << ExpectedFunctionOrMethod;
2445    return;
2446  }
2447
2448  switch (Attr.getKind()) {
2449  case AttributeList::AT_fastcall:
2450    D->addAttr(::new (S.Context) FastCallAttr(Attr.getLoc(), S.Context));
2451    return;
2452  case AttributeList::AT_stdcall:
2453    D->addAttr(::new (S.Context) StdCallAttr(Attr.getLoc(), S.Context));
2454    return;
2455  case AttributeList::AT_thiscall:
2456    D->addAttr(::new (S.Context) ThisCallAttr(Attr.getLoc(), S.Context));
2457    return;
2458  case AttributeList::AT_cdecl:
2459    D->addAttr(::new (S.Context) CDeclAttr(Attr.getLoc(), S.Context));
2460    return;
2461  case AttributeList::AT_pascal:
2462    D->addAttr(::new (S.Context) PascalAttr(Attr.getLoc(), S.Context));
2463    return;
2464  case AttributeList::AT_pcs: {
2465    Expr *Arg = Attr.getArg(0);
2466    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2467    if (Str == 0 || Str->isWide()) {
2468      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2469        << "pcs" << 1;
2470      Attr.setInvalid();
2471      return;
2472    }
2473
2474    llvm::StringRef StrRef = Str->getString();
2475    PcsAttr::PCSType PCS;
2476    if (StrRef == "aapcs")
2477      PCS = PcsAttr::AAPCS;
2478    else if (StrRef == "aapcs-vfp")
2479      PCS = PcsAttr::AAPCS_VFP;
2480    else {
2481      S.Diag(Attr.getLoc(), diag::err_invalid_pcs);
2482      Attr.setInvalid();
2483      return;
2484    }
2485
2486    D->addAttr(::new (S.Context) PcsAttr(Attr.getLoc(), S.Context, PCS));
2487  }
2488  default:
2489    llvm_unreachable("unexpected attribute kind");
2490    return;
2491  }
2492}
2493
2494static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
2495  assert(!Attr.isInvalid());
2496  D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getLoc(), S.Context));
2497}
2498
2499bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
2500  if (attr.isInvalid())
2501    return true;
2502
2503  if ((attr.getNumArgs() != 0 &&
2504      !(attr.getKind() == AttributeList::AT_pcs && attr.getNumArgs() == 1)) ||
2505      attr.getParameterName()) {
2506    Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2507    attr.setInvalid();
2508    return true;
2509  }
2510
2511  // TODO: diagnose uses of these conventions on the wrong target. Or, better
2512  // move to TargetAttributesSema one day.
2513  switch (attr.getKind()) {
2514  case AttributeList::AT_cdecl: CC = CC_C; break;
2515  case AttributeList::AT_fastcall: CC = CC_X86FastCall; break;
2516  case AttributeList::AT_stdcall: CC = CC_X86StdCall; break;
2517  case AttributeList::AT_thiscall: CC = CC_X86ThisCall; break;
2518  case AttributeList::AT_pascal: CC = CC_X86Pascal; break;
2519  case AttributeList::AT_pcs: {
2520    Expr *Arg = attr.getArg(0);
2521    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2522    if (Str == 0 || Str->isWide()) {
2523      Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
2524        << "pcs" << 1;
2525      attr.setInvalid();
2526      return true;
2527    }
2528
2529    llvm::StringRef StrRef = Str->getString();
2530    if (StrRef == "aapcs") {
2531      CC = CC_AAPCS;
2532      break;
2533    } else if (StrRef == "aapcs-vfp") {
2534      CC = CC_AAPCS_VFP;
2535      break;
2536    }
2537    // FALLS THROUGH
2538  }
2539  default: llvm_unreachable("unexpected attribute kind"); return true;
2540  }
2541
2542  return false;
2543}
2544
2545static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2546  if (hasDeclarator(D)) return;
2547
2548  unsigned numParams;
2549  if (S.CheckRegparmAttr(Attr, numParams))
2550    return;
2551
2552  if (!isa<ObjCMethodDecl>(D)) {
2553    S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2554      << Attr.getName() << ExpectedFunctionOrMethod;
2555    return;
2556  }
2557
2558  D->addAttr(::new (S.Context) RegparmAttr(Attr.getLoc(), S.Context, numParams));
2559}
2560
2561/// Checks a regparm attribute, returning true if it is ill-formed and
2562/// otherwise setting numParams to the appropriate value.
2563bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
2564  if (Attr.isInvalid())
2565    return true;
2566
2567  if (Attr.getNumArgs() != 1) {
2568    Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2569    Attr.setInvalid();
2570    return true;
2571  }
2572
2573  Expr *NumParamsExpr = Attr.getArg(0);
2574  llvm::APSInt NumParams(32);
2575  if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
2576      !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
2577    Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2578      << "regparm" << NumParamsExpr->getSourceRange();
2579    Attr.setInvalid();
2580    return true;
2581  }
2582
2583  if (Context.Target.getRegParmMax() == 0) {
2584    Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
2585      << NumParamsExpr->getSourceRange();
2586    Attr.setInvalid();
2587    return true;
2588  }
2589
2590  numParams = NumParams.getZExtValue();
2591  if (numParams > Context.Target.getRegParmMax()) {
2592    Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
2593      << Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange();
2594    Attr.setInvalid();
2595    return true;
2596  }
2597
2598  return false;
2599}
2600
2601static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
2602  if (S.LangOpts.CUDA) {
2603    // check the attribute arguments.
2604    if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
2605      // FIXME: 0 is not okay.
2606      S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
2607      return;
2608    }
2609
2610    if (!isFunctionOrMethod(D)) {
2611      S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2612        << Attr.getName() << ExpectedFunctionOrMethod;
2613      return;
2614    }
2615
2616    Expr *MaxThreadsExpr = Attr.getArg(0);
2617    llvm::APSInt MaxThreads(32);
2618    if (MaxThreadsExpr->isTypeDependent() ||
2619        MaxThreadsExpr->isValueDependent() ||
2620        !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
2621      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2622        << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
2623      return;
2624    }
2625
2626    llvm::APSInt MinBlocks(32);
2627    if (Attr.getNumArgs() > 1) {
2628      Expr *MinBlocksExpr = Attr.getArg(1);
2629      if (MinBlocksExpr->isTypeDependent() ||
2630          MinBlocksExpr->isValueDependent() ||
2631          !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
2632        S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2633          << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
2634        return;
2635      }
2636    }
2637
2638    D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getLoc(), S.Context,
2639                                                      MaxThreads.getZExtValue(),
2640                                                     MinBlocks.getZExtValue()));
2641  } else {
2642    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
2643  }
2644}
2645
2646//===----------------------------------------------------------------------===//
2647// Checker-specific attribute handlers.
2648//===----------------------------------------------------------------------===//
2649
2650static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
2651  return type->isObjCObjectPointerType() || S.Context.isObjCNSObjectType(type);
2652}
2653static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
2654  return type->isPointerType() || isValidSubjectOfNSAttribute(S, type);
2655}
2656
2657static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2658  ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
2659  if (!param) {
2660    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2661      << SourceRange(Attr.getLoc()) << Attr.getName() << ExpectedParameter;
2662    return;
2663  }
2664
2665  bool typeOK, cf;
2666  if (Attr.getKind() == AttributeList::AT_ns_consumed) {
2667    typeOK = isValidSubjectOfNSAttribute(S, param->getType());
2668    cf = false;
2669  } else {
2670    typeOK = isValidSubjectOfCFAttribute(S, param->getType());
2671    cf = true;
2672  }
2673
2674  if (!typeOK) {
2675    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
2676      << SourceRange(Attr.getLoc()) << Attr.getName() << cf;
2677    return;
2678  }
2679
2680  if (cf)
2681    param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getLoc(), S.Context));
2682  else
2683    param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getLoc(), S.Context));
2684}
2685
2686static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
2687                                     const AttributeList &Attr) {
2688  if (!isa<ObjCMethodDecl>(D)) {
2689    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2690      << SourceRange(Attr.getLoc()) << Attr.getName() << ExpectedMethod;
2691    return;
2692  }
2693
2694  D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getLoc(), S.Context));
2695}
2696
2697static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
2698                                        const AttributeList &Attr) {
2699
2700  QualType returnType;
2701
2702  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2703    returnType = MD->getResultType();
2704  else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
2705    returnType = PD->getType();
2706  else if (S.getLangOptions().ObjCAutoRefCount && hasDeclarator(D) &&
2707           (Attr.getKind() == AttributeList::AT_ns_returns_retained))
2708    return; // ignore: was handled as a type attribute
2709  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
2710    returnType = FD->getResultType();
2711  else {
2712    S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
2713        << SourceRange(Attr.getLoc()) << Attr.getName()
2714        << ExpectedFunctionOrMethod;
2715    return;
2716  }
2717
2718  bool typeOK;
2719  bool cf;
2720  switch (Attr.getKind()) {
2721  default: llvm_unreachable("invalid ownership attribute"); return;
2722  case AttributeList::AT_ns_returns_autoreleased:
2723  case AttributeList::AT_ns_returns_retained:
2724  case AttributeList::AT_ns_returns_not_retained:
2725    typeOK = isValidSubjectOfNSAttribute(S, returnType);
2726    cf = false;
2727    break;
2728
2729  case AttributeList::AT_cf_returns_retained:
2730  case AttributeList::AT_cf_returns_not_retained:
2731    typeOK = isValidSubjectOfCFAttribute(S, returnType);
2732    cf = true;
2733    break;
2734  }
2735
2736  if (!typeOK) {
2737    S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
2738      << SourceRange(Attr.getLoc())
2739      << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
2740    return;
2741  }
2742
2743  switch (Attr.getKind()) {
2744    default:
2745      assert(0 && "invalid ownership attribute");
2746      return;
2747    case AttributeList::AT_ns_returns_autoreleased:
2748      D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getLoc(),
2749                                                             S.Context));
2750      return;
2751    case AttributeList::AT_cf_returns_not_retained:
2752      D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getLoc(),
2753                                                            S.Context));
2754      return;
2755    case AttributeList::AT_ns_returns_not_retained:
2756      D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getLoc(),
2757                                                            S.Context));
2758      return;
2759    case AttributeList::AT_cf_returns_retained:
2760      D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getLoc(),
2761                                                         S.Context));
2762      return;
2763    case AttributeList::AT_ns_returns_retained:
2764      D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getLoc(),
2765                                                         S.Context));
2766      return;
2767  };
2768}
2769
2770static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
2771                                              const AttributeList &attr) {
2772  SourceLocation loc = attr.getLoc();
2773
2774  ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
2775
2776  if (!isa<ObjCMethodDecl>(method)) {
2777    S.Diag(method->getLocStart(), diag::err_attribute_wrong_decl_type)
2778      << SourceRange(loc, loc) << attr.getName() << 13 /* methods */;
2779    return;
2780  }
2781
2782  // Check that the method returns a normal pointer.
2783  QualType resultType = method->getResultType();
2784  if (!resultType->isPointerType() || resultType->isObjCRetainableType()) {
2785    S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
2786      << SourceRange(loc)
2787      << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2;
2788
2789    // Drop the attribute.
2790    return;
2791  }
2792
2793  method->addAttr(
2794    ::new (S.Context) ObjCReturnsInnerPointerAttr(loc, S.Context));
2795}
2796
2797static void handleObjCOwnershipAttr(Sema &S, Decl *D,
2798                                    const AttributeList &Attr) {
2799  if (hasDeclarator(D)) return;
2800
2801  SourceLocation L = Attr.getLoc();
2802  S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
2803    << SourceRange(L, L) << Attr.getName() << 12 /* variable */;
2804}
2805
2806static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
2807                                          const AttributeList &Attr) {
2808  if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
2809    SourceLocation L = Attr.getLoc();
2810    S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
2811      << SourceRange(L, L) << Attr.getName() << 12 /* variable */;
2812    return;
2813  }
2814
2815  ValueDecl *vd = cast<ValueDecl>(D);
2816  QualType type = vd->getType();
2817
2818  if (!type->isDependentType() &&
2819      !type->isObjCLifetimeType()) {
2820    S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
2821      << type;
2822    return;
2823  }
2824
2825  Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
2826
2827  // If we have no lifetime yet, check the lifetime we're presumably
2828  // going to infer.
2829  if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
2830    lifetime = type->getObjCARCImplicitLifetime();
2831
2832  switch (lifetime) {
2833  case Qualifiers::OCL_None:
2834    assert(type->isDependentType() &&
2835           "didn't infer lifetime for non-dependent type?");
2836    break;
2837
2838  case Qualifiers::OCL_Weak:   // meaningful
2839  case Qualifiers::OCL_Strong: // meaningful
2840    break;
2841
2842  case Qualifiers::OCL_ExplicitNone:
2843  case Qualifiers::OCL_Autoreleasing:
2844    S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
2845      << (lifetime == Qualifiers::OCL_Autoreleasing);
2846    break;
2847  }
2848
2849  D->addAttr(::new (S.Context)
2850                 ObjCPreciseLifetimeAttr(Attr.getLoc(), S.Context));
2851}
2852
2853static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
2854  return Attr.getKind() == AttributeList::AT_dllimport ||
2855         Attr.getKind() == AttributeList::AT_dllexport ||
2856         Attr.getKind() == AttributeList::AT_uuid;
2857}
2858
2859//===----------------------------------------------------------------------===//
2860// Microsoft specific attribute handlers.
2861//===----------------------------------------------------------------------===//
2862
2863static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2864  if (S.LangOpts.Microsoft || S.LangOpts.Borland) {
2865    // check the attribute arguments.
2866    if (!checkAttributeNumArgs(S, Attr, 1))
2867      return;
2868
2869    Expr *Arg = Attr.getArg(0);
2870    StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
2871    if (Str == 0 || Str->isWide()) {
2872      S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2873        << "uuid" << 1;
2874      return;
2875    }
2876
2877    llvm::StringRef StrRef = Str->getString();
2878
2879    bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
2880                   StrRef.back() == '}';
2881
2882    // Validate GUID length.
2883    if (IsCurly && StrRef.size() != 38) {
2884      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2885      return;
2886    }
2887    if (!IsCurly && StrRef.size() != 36) {
2888      S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2889      return;
2890    }
2891
2892    // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
2893    // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
2894    llvm::StringRef::iterator I = StrRef.begin();
2895    if (IsCurly) // Skip the optional '{'
2896       ++I;
2897
2898    for (int i = 0; i < 36; ++i) {
2899      if (i == 8 || i == 13 || i == 18 || i == 23) {
2900        if (*I != '-') {
2901          S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2902          return;
2903        }
2904      } else if (!isxdigit(*I)) {
2905        S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2906        return;
2907      }
2908      I++;
2909    }
2910
2911    D->addAttr(::new (S.Context) UuidAttr(Attr.getLoc(), S.Context,
2912                                          Str->getString()));
2913  } else
2914    S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
2915}
2916
2917//===----------------------------------------------------------------------===//
2918// Top Level Sema Entry Points
2919//===----------------------------------------------------------------------===//
2920
2921static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
2922                                          const AttributeList &Attr) {
2923  switch (Attr.getKind()) {
2924  case AttributeList::AT_device:      handleDeviceAttr      (S, D, Attr); break;
2925  case AttributeList::AT_host:        handleHostAttr        (S, D, Attr); break;
2926  case AttributeList::AT_overloadable:handleOverloadableAttr(S, D, Attr); break;
2927  default:
2928    break;
2929  }
2930}
2931
2932static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
2933                                       const AttributeList &Attr) {
2934  switch (Attr.getKind()) {
2935  case AttributeList::AT_IBAction:            handleIBAction(S, D, Attr); break;
2936    case AttributeList::AT_IBOutlet:          handleIBOutlet(S, D, Attr); break;
2937  case AttributeList::AT_IBOutletCollection:
2938      handleIBOutletCollection(S, D, Attr); break;
2939  case AttributeList::AT_address_space:
2940  case AttributeList::AT_opencl_image_access:
2941  case AttributeList::AT_objc_gc:
2942  case AttributeList::AT_vector_size:
2943  case AttributeList::AT_neon_vector_type:
2944  case AttributeList::AT_neon_polyvector_type:
2945    // Ignore these, these are type attributes, handled by
2946    // ProcessTypeAttributes.
2947    break;
2948  case AttributeList::AT_device:
2949  case AttributeList::AT_host:
2950  case AttributeList::AT_overloadable:
2951    // Ignore, this is a non-inheritable attribute, handled
2952    // by ProcessNonInheritableDeclAttr.
2953    break;
2954  case AttributeList::AT_alias:       handleAliasAttr       (S, D, Attr); break;
2955  case AttributeList::AT_aligned:     handleAlignedAttr     (S, D, Attr); break;
2956  case AttributeList::AT_always_inline:
2957    handleAlwaysInlineAttr  (S, D, Attr); break;
2958  case AttributeList::AT_analyzer_noreturn:
2959    handleAnalyzerNoReturnAttr  (S, D, Attr); break;
2960  case AttributeList::AT_annotate:    handleAnnotateAttr    (S, D, Attr); break;
2961  case AttributeList::AT_availability:handleAvailabilityAttr(S, D, Attr); break;
2962  case AttributeList::AT_carries_dependency:
2963                                      handleDependencyAttr  (S, D, Attr); break;
2964  case AttributeList::AT_common:      handleCommonAttr      (S, D, Attr); break;
2965  case AttributeList::AT_constant:    handleConstantAttr    (S, D, Attr); break;
2966  case AttributeList::AT_constructor: handleConstructorAttr (S, D, Attr); break;
2967  case AttributeList::AT_deprecated:  handleDeprecatedAttr  (S, D, Attr); break;
2968  case AttributeList::AT_destructor:  handleDestructorAttr  (S, D, Attr); break;
2969  case AttributeList::AT_ext_vector_type:
2970    handleExtVectorTypeAttr(S, scope, D, Attr);
2971    break;
2972  case AttributeList::AT_format:      handleFormatAttr      (S, D, Attr); break;
2973  case AttributeList::AT_format_arg:  handleFormatArgAttr   (S, D, Attr); break;
2974  case AttributeList::AT_global:      handleGlobalAttr      (S, D, Attr); break;
2975  case AttributeList::AT_gnu_inline:  handleGNUInlineAttr   (S, D, Attr); break;
2976  case AttributeList::AT_launch_bounds:
2977    handleLaunchBoundsAttr(S, D, Attr);
2978    break;
2979  case AttributeList::AT_mode:        handleModeAttr        (S, D, Attr); break;
2980  case AttributeList::AT_malloc:      handleMallocAttr      (S, D, Attr); break;
2981  case AttributeList::AT_may_alias:   handleMayAliasAttr    (S, D, Attr); break;
2982  case AttributeList::AT_nocommon:    handleNoCommonAttr    (S, D, Attr); break;
2983  case AttributeList::AT_nonnull:     handleNonNullAttr     (S, D, Attr); break;
2984  case AttributeList::AT_ownership_returns:
2985  case AttributeList::AT_ownership_takes:
2986  case AttributeList::AT_ownership_holds:
2987      handleOwnershipAttr     (S, D, Attr); break;
2988  case AttributeList::AT_naked:       handleNakedAttr       (S, D, Attr); break;
2989  case AttributeList::AT_noreturn:    handleNoReturnAttr    (S, D, Attr); break;
2990  case AttributeList::AT_nothrow:     handleNothrowAttr     (S, D, Attr); break;
2991  case AttributeList::AT_shared:      handleSharedAttr      (S, D, Attr); break;
2992  case AttributeList::AT_vecreturn:   handleVecReturnAttr   (S, D, Attr); break;
2993
2994  case AttributeList::AT_objc_ownership:
2995    handleObjCOwnershipAttr(S, D, Attr); break;
2996  case AttributeList::AT_objc_precise_lifetime:
2997    handleObjCPreciseLifetimeAttr(S, D, Attr); break;
2998
2999  case AttributeList::AT_objc_returns_inner_pointer:
3000    handleObjCReturnsInnerPointerAttr(S, D, Attr); break;
3001
3002  // Checker-specific.
3003  case AttributeList::AT_cf_consumed:
3004  case AttributeList::AT_ns_consumed: handleNSConsumedAttr  (S, D, Attr); break;
3005  case AttributeList::AT_ns_consumes_self:
3006    handleNSConsumesSelfAttr(S, D, Attr); break;
3007
3008  case AttributeList::AT_ns_returns_autoreleased:
3009  case AttributeList::AT_ns_returns_not_retained:
3010  case AttributeList::AT_cf_returns_not_retained:
3011  case AttributeList::AT_ns_returns_retained:
3012  case AttributeList::AT_cf_returns_retained:
3013    handleNSReturnsRetainedAttr(S, D, Attr); break;
3014
3015  case AttributeList::AT_reqd_wg_size:
3016    handleReqdWorkGroupSize(S, D, Attr); break;
3017
3018  case AttributeList::AT_init_priority:
3019      handleInitPriorityAttr(S, D, Attr); break;
3020
3021  case AttributeList::AT_packed:      handlePackedAttr      (S, D, Attr); break;
3022  case AttributeList::AT_MsStruct:    handleMsStructAttr    (S, D, Attr); break;
3023  case AttributeList::AT_section:     handleSectionAttr     (S, D, Attr); break;
3024  case AttributeList::AT_unavailable: handleUnavailableAttr (S, D, Attr); break;
3025  case AttributeList::AT_arc_weakref_unavailable:
3026    handleArcWeakrefUnavailableAttr (S, D, Attr);
3027    break;
3028  case AttributeList::AT_unused:      handleUnusedAttr      (S, D, Attr); break;
3029  case AttributeList::AT_used:        handleUsedAttr        (S, D, Attr); break;
3030  case AttributeList::AT_visibility:  handleVisibilityAttr  (S, D, Attr); break;
3031  case AttributeList::AT_warn_unused_result: handleWarnUnusedResult(S, D, Attr);
3032    break;
3033  case AttributeList::AT_weak:        handleWeakAttr        (S, D, Attr); break;
3034  case AttributeList::AT_weakref:     handleWeakRefAttr     (S, D, Attr); break;
3035  case AttributeList::AT_weak_import: handleWeakImportAttr  (S, D, Attr); break;
3036  case AttributeList::AT_transparent_union:
3037    handleTransparentUnionAttr(S, D, Attr);
3038    break;
3039  case AttributeList::AT_objc_exception:
3040    handleObjCExceptionAttr(S, D, Attr);
3041    break;
3042  case AttributeList::AT_objc_method_family:
3043    handleObjCMethodFamilyAttr(S, D, Attr);
3044    break;
3045  case AttributeList::AT_nsobject:    handleObjCNSObject    (S, D, Attr); break;
3046  case AttributeList::AT_blocks:      handleBlocksAttr      (S, D, Attr); break;
3047  case AttributeList::AT_sentinel:    handleSentinelAttr    (S, D, Attr); break;
3048  case AttributeList::AT_const:       handleConstAttr       (S, D, Attr); break;
3049  case AttributeList::AT_pure:        handlePureAttr        (S, D, Attr); break;
3050  case AttributeList::AT_cleanup:     handleCleanupAttr     (S, D, Attr); break;
3051  case AttributeList::AT_nodebug:     handleNoDebugAttr     (S, D, Attr); break;
3052  case AttributeList::AT_noinline:    handleNoInlineAttr    (S, D, Attr); break;
3053  case AttributeList::AT_regparm:     handleRegparmAttr     (S, D, Attr); break;
3054  case AttributeList::IgnoredAttribute:
3055    // Just ignore
3056    break;
3057  case AttributeList::AT_no_instrument_function:  // Interacts with -pg.
3058    handleNoInstrumentFunctionAttr(S, D, Attr);
3059    break;
3060  case AttributeList::AT_stdcall:
3061  case AttributeList::AT_cdecl:
3062  case AttributeList::AT_fastcall:
3063  case AttributeList::AT_thiscall:
3064  case AttributeList::AT_pascal:
3065  case AttributeList::AT_pcs:
3066    handleCallConvAttr(S, D, Attr);
3067    break;
3068  case AttributeList::AT_opencl_kernel_function:
3069    handleOpenCLKernelAttr(S, D, Attr);
3070    break;
3071  case AttributeList::AT_uuid:
3072    handleUuidAttr(S, D, Attr);
3073    break;
3074  default:
3075    // Ask target about the attribute.
3076    const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
3077    if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
3078      S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored)
3079        << Attr.getName();
3080    break;
3081  }
3082}
3083
3084/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
3085/// the attribute applies to decls.  If the attribute is a type attribute, just
3086/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
3087/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
3088static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
3089                                 const AttributeList &Attr,
3090                                 bool NonInheritable, bool Inheritable) {
3091  if (Attr.isInvalid())
3092    return;
3093
3094  if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
3095    // FIXME: Try to deal with other __declspec attributes!
3096    return;
3097
3098  if (NonInheritable)
3099    ProcessNonInheritableDeclAttr(S, scope, D, Attr);
3100
3101  if (Inheritable)
3102    ProcessInheritableDeclAttr(S, scope, D, Attr);
3103}
3104
3105/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
3106/// attribute list to the specified decl, ignoring any type attributes.
3107void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
3108                                    const AttributeList *AttrList,
3109                                    bool NonInheritable, bool Inheritable) {
3110  for (const AttributeList* l = AttrList; l; l = l->getNext()) {
3111    ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable);
3112  }
3113
3114  // GCC accepts
3115  // static int a9 __attribute__((weakref));
3116  // but that looks really pointless. We reject it.
3117  if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
3118    Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
3119    dyn_cast<NamedDecl>(D)->getNameAsString();
3120    return;
3121  }
3122}
3123
3124/// DeclClonePragmaWeak - clone existing decl (maybe definition),
3125/// #pragma weak needs a non-definition decl and source may not have one
3126NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) {
3127  assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
3128  NamedDecl *NewD = 0;
3129  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
3130    NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
3131                                FD->getInnerLocStart(),
3132                                FD->getLocation(), DeclarationName(II),
3133                                FD->getType(), FD->getTypeSourceInfo());
3134    if (FD->getQualifier()) {
3135      FunctionDecl *NewFD = cast<FunctionDecl>(NewD);
3136      NewFD->setQualifierInfo(FD->getQualifierLoc());
3137    }
3138  } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
3139    NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
3140                           VD->getInnerLocStart(), VD->getLocation(), II,
3141                           VD->getType(), VD->getTypeSourceInfo(),
3142                           VD->getStorageClass(),
3143                           VD->getStorageClassAsWritten());
3144    if (VD->getQualifier()) {
3145      VarDecl *NewVD = cast<VarDecl>(NewD);
3146      NewVD->setQualifierInfo(VD->getQualifierLoc());
3147    }
3148  }
3149  return NewD;
3150}
3151
3152/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
3153/// applied to it, possibly with an alias.
3154void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
3155  if (W.getUsed()) return; // only do this once
3156  W.setUsed(true);
3157  if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
3158    IdentifierInfo *NDId = ND->getIdentifier();
3159    NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias());
3160    NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
3161                                            NDId->getName()));
3162    NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3163    WeakTopLevelDecl.push_back(NewD);
3164    // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
3165    // to insert Decl at TU scope, sorry.
3166    DeclContext *SavedContext = CurContext;
3167    CurContext = Context.getTranslationUnitDecl();
3168    PushOnScopeChains(NewD, S);
3169    CurContext = SavedContext;
3170  } else { // just add weak to existing
3171    ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
3172  }
3173}
3174
3175/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
3176/// it, apply them to D.  This is a bit tricky because PD can have attributes
3177/// specified in many different places, and we need to find and apply them all.
3178void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
3179                                 bool NonInheritable, bool Inheritable) {
3180  // It's valid to "forward-declare" #pragma weak, in which case we
3181  // have to do this.
3182  if (Inheritable && !WeakUndeclaredIdentifiers.empty()) {
3183    if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
3184      if (IdentifierInfo *Id = ND->getIdentifier()) {
3185        llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
3186          = WeakUndeclaredIdentifiers.find(Id);
3187        if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
3188          WeakInfo W = I->second;
3189          DeclApplyPragmaWeak(S, ND, W);
3190          WeakUndeclaredIdentifiers[Id] = W;
3191        }
3192      }
3193    }
3194  }
3195
3196  // Apply decl attributes from the DeclSpec if present.
3197  if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
3198    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3199
3200  // Walk the declarator structure, applying decl attributes that were in a type
3201  // position to the decl itself.  This handles cases like:
3202  //   int *__attr__(x)** D;
3203  // when X is a decl attribute.
3204  for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
3205    if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
3206      ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3207
3208  // Finally, apply any attributes on the decl itself.
3209  if (const AttributeList *Attrs = PD.getAttributes())
3210    ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
3211}
3212
3213/// Is the given declaration allowed to use a forbidden type?
3214static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
3215  // Private ivars are always okay.  Unfortunately, people don't
3216  // always properly make their ivars private, even in system headers.
3217  // Plus we need to make fields okay, too.
3218  if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl))
3219    return false;
3220
3221  // Require it to be declared in a system header.
3222  return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
3223}
3224
3225/// Handle a delayed forbidden-type diagnostic.
3226static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
3227                                       Decl *decl) {
3228  if (decl && isForbiddenTypeAllowed(S, decl)) {
3229    decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
3230                        "this system declaration uses an unsupported type"));
3231    return;
3232  }
3233
3234  S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
3235    << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
3236  diag.Triggered = true;
3237}
3238
3239// This duplicates a vector push_back but hides the need to know the
3240// size of the type.
3241void Sema::DelayedDiagnostics::add(const DelayedDiagnostic &diag) {
3242  assert(StackSize <= StackCapacity);
3243
3244  // Grow the stack if necessary.
3245  if (StackSize == StackCapacity) {
3246    unsigned newCapacity = 2 * StackCapacity + 2;
3247    char *newBuffer = new char[newCapacity * sizeof(DelayedDiagnostic)];
3248    const char *oldBuffer = (const char*) Stack;
3249
3250    if (StackCapacity)
3251      memcpy(newBuffer, oldBuffer, StackCapacity * sizeof(DelayedDiagnostic));
3252
3253    delete[] oldBuffer;
3254    Stack = reinterpret_cast<sema::DelayedDiagnostic*>(newBuffer);
3255    StackCapacity = newCapacity;
3256  }
3257
3258  assert(StackSize < StackCapacity);
3259  new (&Stack[StackSize++]) DelayedDiagnostic(diag);
3260}
3261
3262void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
3263                                              Decl *decl) {
3264  DelayedDiagnostics &DD = S.DelayedDiagnostics;
3265
3266  // Check the invariants.
3267  assert(DD.StackSize >= state.SavedStackSize);
3268  assert(state.SavedStackSize >= DD.ActiveStackBase);
3269  assert(DD.ParsingDepth > 0);
3270
3271  // Drop the parsing depth.
3272  DD.ParsingDepth--;
3273
3274  // If there are no active diagnostics, we're done.
3275  if (DD.StackSize == DD.ActiveStackBase)
3276    return;
3277
3278  // We only want to actually emit delayed diagnostics when we
3279  // successfully parsed a decl.
3280  if (decl && !decl->isInvalidDecl()) {
3281    // We emit all the active diagnostics, not just those starting
3282    // from the saved state.  The idea is this:  we get one push for a
3283    // decl spec and another for each declarator;  in a decl group like:
3284    //   deprecated_typedef foo, *bar, baz();
3285    // only the declarator pops will be passed decls.  This is correct;
3286    // we really do need to consider delayed diagnostics from the decl spec
3287    // for each of the different declarations.
3288    for (unsigned i = DD.ActiveStackBase, e = DD.StackSize; i != e; ++i) {
3289      DelayedDiagnostic &diag = DD.Stack[i];
3290      if (diag.Triggered)
3291        continue;
3292
3293      switch (diag.Kind) {
3294      case DelayedDiagnostic::Deprecation:
3295        S.HandleDelayedDeprecationCheck(diag, decl);
3296        break;
3297
3298      case DelayedDiagnostic::Access:
3299        S.HandleDelayedAccessCheck(diag, decl);
3300        break;
3301
3302      case DelayedDiagnostic::ForbiddenType:
3303        handleDelayedForbiddenType(S, diag, decl);
3304        break;
3305      }
3306    }
3307  }
3308
3309  // Destroy all the delayed diagnostics we're about to pop off.
3310  for (unsigned i = state.SavedStackSize, e = DD.StackSize; i != e; ++i)
3311    DD.Stack[i].Destroy();
3312
3313  DD.StackSize = state.SavedStackSize;
3314}
3315
3316static bool isDeclDeprecated(Decl *D) {
3317  do {
3318    if (D->isDeprecated())
3319      return true;
3320  } while ((D = cast_or_null<Decl>(D->getDeclContext())));
3321  return false;
3322}
3323
3324void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
3325                                         Decl *Ctx) {
3326  if (isDeclDeprecated(Ctx))
3327    return;
3328
3329  DD.Triggered = true;
3330  if (!DD.getDeprecationMessage().empty())
3331    Diag(DD.Loc, diag::warn_deprecated_message)
3332      << DD.getDeprecationDecl()->getDeclName()
3333      << DD.getDeprecationMessage();
3334  else
3335    Diag(DD.Loc, diag::warn_deprecated)
3336      << DD.getDeprecationDecl()->getDeclName();
3337}
3338
3339void Sema::EmitDeprecationWarning(NamedDecl *D, llvm::StringRef Message,
3340                                  SourceLocation Loc,
3341                                  const ObjCInterfaceDecl *UnknownObjCClass) {
3342  // Delay if we're currently parsing a declaration.
3343  if (DelayedDiagnostics.shouldDelayDiagnostics()) {
3344    DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D, Message));
3345    return;
3346  }
3347
3348  // Otherwise, don't warn if our current context is deprecated.
3349  if (isDeclDeprecated(cast<Decl>(CurContext)))
3350    return;
3351  if (!Message.empty())
3352    Diag(Loc, diag::warn_deprecated_message) << D->getDeclName()
3353                                             << Message;
3354  else {
3355    if (!UnknownObjCClass)
3356      Diag(Loc, diag::warn_deprecated) << D->getDeclName();
3357    else {
3358      Diag(Loc, diag::warn_deprecated_fwdclass_message) << D->getDeclName();
3359      Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
3360    }
3361  }
3362}
3363