blob: bef1bb451f028c337e4dc568f5be7c6551085f4d [file] [log] [blame]
Chris Lattner6b6b5372008-06-26 18:38:35 +00001//===--- 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
John McCall2d887082010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000015#include "TargetAttributesSema.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000016#include "clang/AST/ASTContext.h"
John McCall384aff82010-08-25 07:42:41 +000017#include "clang/AST/DeclCXX.h"
Daniel Dunbaracc5f3e2008-08-11 06:23:49 +000018#include "clang/AST/DeclObjC.h"
19#include "clang/AST/Expr.h"
Chris Lattnerfbf13472008-06-27 22:18:37 +000020#include "clang/Basic/TargetInfo.h"
John McCall19510852010-08-20 18:27:03 +000021#include "clang/Sema/DeclSpec.h"
John McCall9c3087b2010-08-26 02:13:20 +000022#include "clang/Sema/DelayedDiagnostic.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000023#include "llvm/ADT/StringExtras.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000024using namespace clang;
John McCall9c3087b2010-08-26 02:13:20 +000025using namespace sema;
Chris Lattner6b6b5372008-06-26 18:38:35 +000026
Chris Lattnere5c5ee12008-06-29 00:16:31 +000027//===----------------------------------------------------------------------===//
28// Helper functions
29//===----------------------------------------------------------------------===//
30
Ted Kremeneka18d7d82009-08-14 20:49:40 +000031static const FunctionType *getFunctionType(const Decl *d,
32 bool blocksToo = true) {
Chris Lattner6b6b5372008-06-26 18:38:35 +000033 QualType Ty;
Ted Kremeneka18d7d82009-08-14 20:49:40 +000034 if (const ValueDecl *decl = dyn_cast<ValueDecl>(d))
Chris Lattner6b6b5372008-06-26 18:38:35 +000035 Ty = decl->getType();
Ted Kremeneka18d7d82009-08-14 20:49:40 +000036 else if (const FieldDecl *decl = dyn_cast<FieldDecl>(d))
Chris Lattner6b6b5372008-06-26 18:38:35 +000037 Ty = decl->getType();
Ted Kremeneka18d7d82009-08-14 20:49:40 +000038 else if (const TypedefDecl* decl = dyn_cast<TypedefDecl>(d))
Chris Lattner6b6b5372008-06-26 18:38:35 +000039 Ty = decl->getUnderlyingType();
40 else
41 return 0;
Mike Stumpbf916502009-07-24 19:02:52 +000042
Chris Lattner6b6b5372008-06-26 18:38:35 +000043 if (Ty->isFunctionPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +000044 Ty = Ty->getAs<PointerType>()->getPointeeType();
Fariborz Jahanian755f9d22009-05-18 17:39:25 +000045 else if (blocksToo && Ty->isBlockPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +000046 Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
Daniel Dunbard3f2c102008-10-19 02:04:16 +000047
John McCall183700f2009-09-21 23:43:11 +000048 return Ty->getAs<FunctionType>();
Chris Lattner6b6b5372008-06-26 18:38:35 +000049}
50
Daniel Dunbar35682492008-09-26 04:12:28 +000051// FIXME: We should provide an abstraction around a method or function
52// to provide the following bits of information.
53
Nuno Lopesd20254f2009-12-20 23:11:08 +000054/// isFunction - Return true if the given decl has function
Ted Kremeneka18d7d82009-08-14 20:49:40 +000055/// type (function or function-typed variable).
56static bool isFunction(const Decl *d) {
57 return getFunctionType(d, false) != NULL;
58}
59
60/// isFunctionOrMethod - Return true if the given decl has function
Daniel Dunbard3f2c102008-10-19 02:04:16 +000061/// type (function or function-typed variable) or an Objective-C
62/// method.
Ted Kremeneka18d7d82009-08-14 20:49:40 +000063static bool isFunctionOrMethod(const Decl *d) {
64 return isFunction(d)|| isa<ObjCMethodDecl>(d);
Daniel Dunbar35682492008-09-26 04:12:28 +000065}
66
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000067/// isFunctionOrMethodOrBlock - Return true if the given decl has function
68/// type (function or function-typed variable) or an Objective-C
69/// method or a block.
Ted Kremeneka18d7d82009-08-14 20:49:40 +000070static bool isFunctionOrMethodOrBlock(const Decl *d) {
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000071 if (isFunctionOrMethod(d))
72 return true;
73 // check for block is more involved.
74 if (const VarDecl *V = dyn_cast<VarDecl>(d)) {
75 QualType Ty = V->getType();
76 return Ty->isBlockPointerType();
77 }
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +000078 return isa<BlockDecl>(d);
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000079}
80
John McCall711c52b2011-01-05 12:14:39 +000081/// Return true if the given decl has a declarator that should have
82/// been processed by Sema::GetTypeForDeclarator.
83static bool hasDeclarator(const Decl *d) {
84 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
85 return isa<DeclaratorDecl>(d) || isa<BlockDecl>(d) || isa<TypedefDecl>(d);
86}
87
Daniel Dunbard3f2c102008-10-19 02:04:16 +000088/// hasFunctionProto - Return true if the given decl has a argument
89/// information. This decl should have already passed
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000090/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
Ted Kremeneka18d7d82009-08-14 20:49:40 +000091static bool hasFunctionProto(const Decl *d) {
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000092 if (const FunctionType *FnTy = getFunctionType(d))
Douglas Gregor72564e72009-02-26 23:50:07 +000093 return isa<FunctionProtoType>(FnTy);
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000094 else {
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +000095 assert(isa<ObjCMethodDecl>(d) || isa<BlockDecl>(d));
Daniel Dunbard3f2c102008-10-19 02:04:16 +000096 return true;
97 }
98}
99
100/// getFunctionOrMethodNumArgs - Return number of function or method
101/// arguments. It is an error to call this on a K&R function (use
102/// hasFunctionProto first).
Ted Kremeneka18d7d82009-08-14 20:49:40 +0000103static unsigned getFunctionOrMethodNumArgs(const Decl *d) {
Chris Lattner89951a82009-02-20 18:43:26 +0000104 if (const FunctionType *FnTy = getFunctionType(d))
Douglas Gregor72564e72009-02-26 23:50:07 +0000105 return cast<FunctionProtoType>(FnTy)->getNumArgs();
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000106 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
107 return BD->getNumParams();
Chris Lattner89951a82009-02-20 18:43:26 +0000108 return cast<ObjCMethodDecl>(d)->param_size();
Daniel Dunbar35682492008-09-26 04:12:28 +0000109}
110
Ted Kremeneka18d7d82009-08-14 20:49:40 +0000111static QualType getFunctionOrMethodArgType(const Decl *d, unsigned Idx) {
Chris Lattner89951a82009-02-20 18:43:26 +0000112 if (const FunctionType *FnTy = getFunctionType(d))
Douglas Gregor72564e72009-02-26 23:50:07 +0000113 return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000114 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
115 return BD->getParamDecl(Idx)->getType();
Mike Stumpbf916502009-07-24 19:02:52 +0000116
Chris Lattner89951a82009-02-20 18:43:26 +0000117 return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType();
Daniel Dunbar35682492008-09-26 04:12:28 +0000118}
119
Ted Kremeneka18d7d82009-08-14 20:49:40 +0000120static QualType getFunctionOrMethodResultType(const Decl *d) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +0000121 if (const FunctionType *FnTy = getFunctionType(d))
122 return cast<FunctionProtoType>(FnTy)->getResultType();
123 return cast<ObjCMethodDecl>(d)->getResultType();
124}
125
Ted Kremeneka18d7d82009-08-14 20:49:40 +0000126static bool isFunctionOrMethodVariadic(const Decl *d) {
Daniel Dunbard3f2c102008-10-19 02:04:16 +0000127 if (const FunctionType *FnTy = getFunctionType(d)) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000128 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
Daniel Dunbar35682492008-09-26 04:12:28 +0000129 return proto->isVariadic();
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000130 } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(d))
Ted Kremenekdb9a0ae2010-04-29 16:48:58 +0000131 return BD->isVariadic();
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000132 else {
Daniel Dunbar35682492008-09-26 04:12:28 +0000133 return cast<ObjCMethodDecl>(d)->isVariadic();
134 }
135}
136
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000137static bool isInstanceMethod(const Decl *d) {
138 if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(d))
139 return MethodDecl->isInstance();
140 return false;
141}
142
Chris Lattner6b6b5372008-06-26 18:38:35 +0000143static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
John McCall183700f2009-09-21 23:43:11 +0000144 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
Chris Lattnerb77792e2008-07-26 22:17:49 +0000145 if (!PT)
Chris Lattner6b6b5372008-06-26 18:38:35 +0000146 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000147
John McCall506b57e2010-05-17 21:00:27 +0000148 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
149 if (!Cls)
Chris Lattner6b6b5372008-06-26 18:38:35 +0000150 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000151
John McCall506b57e2010-05-17 21:00:27 +0000152 IdentifierInfo* ClsName = Cls->getIdentifier();
Mike Stumpbf916502009-07-24 19:02:52 +0000153
Chris Lattner6b6b5372008-06-26 18:38:35 +0000154 // FIXME: Should we walk the chain of classes?
155 return ClsName == &Ctx.Idents.get("NSString") ||
156 ClsName == &Ctx.Idents.get("NSMutableString");
157}
158
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000159static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000160 const PointerType *PT = T->getAs<PointerType>();
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000161 if (!PT)
162 return false;
163
Ted Kremenek6217b802009-07-29 21:53:49 +0000164 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000165 if (!RT)
166 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000167
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000168 const RecordDecl *RD = RT->getDecl();
Abramo Bagnara465d41b2010-05-11 21:36:43 +0000169 if (RD->getTagKind() != TTK_Struct)
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000170 return false;
171
172 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
173}
174
Chris Lattnere5c5ee12008-06-29 00:16:31 +0000175//===----------------------------------------------------------------------===//
Chris Lattnere5c5ee12008-06-29 00:16:31 +0000176// Attribute Implementations
177//===----------------------------------------------------------------------===//
178
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000179// FIXME: All this manual attribute parsing code is gross. At the
180// least add some helper functions to check most argument patterns (#
181// and types of args).
182
Mike Stumpbf916502009-07-24 19:02:52 +0000183static void HandleExtVectorTypeAttr(Scope *scope, Decl *d,
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000184 const AttributeList &Attr, Sema &S) {
Chris Lattner545dd342008-06-28 23:36:30 +0000185 TypedefDecl *tDecl = dyn_cast<TypedefDecl>(d);
186 if (tDecl == 0) {
Chris Lattner803d0802008-06-29 00:43:07 +0000187 S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
Chris Lattner545dd342008-06-28 23:36:30 +0000188 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +0000189 }
Mike Stumpbf916502009-07-24 19:02:52 +0000190
Chris Lattner6b6b5372008-06-26 18:38:35 +0000191 QualType curType = tDecl->getUnderlyingType();
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000192
193 Expr *sizeExpr;
194
195 // Special case where the argument is a template id.
196 if (Attr.getParameterName()) {
John McCallf7a1a742009-11-24 19:00:30 +0000197 CXXScopeSpec SS;
198 UnqualifiedId id;
199 id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
200 sizeExpr = S.ActOnIdExpression(scope, SS, id, false, false).takeAs<Expr>();
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000201 } else {
202 // check the attribute arguments.
203 if (Attr.getNumArgs() != 1) {
204 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
205 return;
206 }
Peter Collingbourne7a730022010-11-23 20:45:58 +0000207 sizeExpr = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +0000208 }
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000209
210 // Instantiate/Install the vector type, and let Sema build the type for us.
211 // This will run the reguired checks.
John McCall9ae2f072010-08-23 23:25:46 +0000212 QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc());
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000213 if (!T.isNull()) {
John McCallba6a9bd2009-10-24 08:00:42 +0000214 // FIXME: preserve the old source info.
John McCalla93c9342009-12-07 02:54:59 +0000215 tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
Mike Stumpbf916502009-07-24 19:02:52 +0000216
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000217 // Remember this typedef decl, we will need it later for diagnostics.
218 S.ExtVectorDecls.push_back(tDecl);
Chris Lattner6b6b5372008-06-26 18:38:35 +0000219 }
Chris Lattner6b6b5372008-06-26 18:38:35 +0000220}
221
Chris Lattner803d0802008-06-29 00:43:07 +0000222static void HandlePackedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +0000223 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +0000224 if (Attr.getNumArgs() > 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000225 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +0000226 return;
227 }
Mike Stumpbf916502009-07-24 19:02:52 +0000228
Chris Lattner6b6b5372008-06-26 18:38:35 +0000229 if (TagDecl *TD = dyn_cast<TagDecl>(d))
Sean Huntcf807c42010-08-18 23:23:40 +0000230 TD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +0000231 else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) {
232 // If the alignment is less than or equal to 8 bits, the packed attribute
233 // has no effect.
234 if (!FD->getType()->isIncompleteType() &&
Chris Lattner803d0802008-06-29 00:43:07 +0000235 S.Context.getTypeAlign(FD->getType()) <= 8)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000236 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
Chris Lattner08631c52008-11-23 21:45:46 +0000237 << Attr.getName() << FD->getType();
Chris Lattner6b6b5372008-06-26 18:38:35 +0000238 else
Sean Huntcf807c42010-08-18 23:23:40 +0000239 FD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +0000240 } else
Chris Lattner3c73c412008-11-19 08:23:25 +0000241 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +0000242}
243
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000244static void HandleIBAction(Decl *d, const AttributeList &Attr, Sema &S) {
Ted Kremenek96329d42008-07-15 22:26:48 +0000245 // check the attribute arguments.
246 if (Attr.getNumArgs() > 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000247 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Ted Kremenek96329d42008-07-15 22:26:48 +0000248 return;
249 }
Mike Stumpbf916502009-07-24 19:02:52 +0000250
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000251 // The IBAction attributes only apply to instance methods.
252 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d))
253 if (MD->isInstanceMethod()) {
Sean Huntcf807c42010-08-18 23:23:40 +0000254 d->addAttr(::new (S.Context) IBActionAttr(Attr.getLoc(), S.Context));
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000255 return;
256 }
257
Ted Kremenek4ee2bb12011-02-04 06:54:16 +0000258 S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName();
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000259}
260
261static void HandleIBOutlet(Decl *d, const AttributeList &Attr, Sema &S) {
262 // check the attribute arguments.
263 if (Attr.getNumArgs() > 0) {
264 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
265 return;
266 }
267
268 // The IBOutlet attributes only apply to instance variables of
Ted Kremenekefbddd22010-02-17 02:37:45 +0000269 // Objective-C classes.
270 if (isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d)) {
Sean Huntcf807c42010-08-18 23:23:40 +0000271 d->addAttr(::new (S.Context) IBOutletAttr(Attr.getLoc(), S.Context));
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000272 return;
Ted Kremenekefbddd22010-02-17 02:37:45 +0000273 }
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000274
Ted Kremenek4ee2bb12011-02-04 06:54:16 +0000275 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
Ted Kremenek96329d42008-07-15 22:26:48 +0000276}
277
Ted Kremenek857e9182010-05-19 17:38:06 +0000278static void HandleIBOutletCollection(Decl *d, const AttributeList &Attr,
279 Sema &S) {
280
281 // The iboutletcollection attribute can have zero or one arguments.
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000282 if (Attr.getParameterName() && Attr.getNumArgs() > 0) {
Ted Kremenek857e9182010-05-19 17:38:06 +0000283 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
284 return;
285 }
286
287 // The IBOutletCollection attributes only apply to instance variables of
288 // Objective-C classes.
289 if (!(isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d))) {
Ted Kremenek4ee2bb12011-02-04 06:54:16 +0000290 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
Ted Kremenek857e9182010-05-19 17:38:06 +0000291 return;
292 }
Fariborz Jahanian3a3400b2010-08-17 21:39:27 +0000293 if (const ValueDecl *VD = dyn_cast<ValueDecl>(d))
294 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
295 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
296 << VD->getType() << 0;
297 return;
298 }
299 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(d))
300 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
301 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type)
302 << PD->getType() << 1;
303 return;
304 }
305
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000306 IdentifierInfo *II = Attr.getParameterName();
307 if (!II)
308 II = &S.Context.Idents.get("id");
Fariborz Jahanian3a3400b2010-08-17 21:39:27 +0000309
John McCallb3d87482010-08-24 05:47:05 +0000310 ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(),
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000311 S.getScopeForContext(d->getDeclContext()->getParent()));
312 if (!TypeRep) {
313 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
314 return;
315 }
John McCallb3d87482010-08-24 05:47:05 +0000316 QualType QT = TypeRep.get();
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000317 // Diagnose use of non-object type in iboutletcollection attribute.
318 // FIXME. Gnu attribute extension ignores use of builtin types in
319 // attributes. So, __attribute__((iboutletcollection(char))) will be
320 // treated as __attribute__((iboutletcollection())).
321 if (!QT->isObjCIdType() && !QT->isObjCClassType() &&
322 !QT->isObjCObjectType()) {
323 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
324 return;
325 }
Sean Huntcf807c42010-08-18 23:23:40 +0000326 d->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getLoc(), S.Context,
327 QT));
Ted Kremenek857e9182010-05-19 17:38:06 +0000328}
329
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000330static void HandleNonNullAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Mike Stumpbf916502009-07-24 19:02:52 +0000331 // GCC ignores the nonnull attribute on K&R style function prototypes, so we
332 // ignore it as well
Daniel Dunbard3f2c102008-10-19 02:04:16 +0000333 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000334 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +0000335 << Attr.getName() << 0 /*function*/;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000336 return;
337 }
Mike Stumpbf916502009-07-24 19:02:52 +0000338
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000339 // In C++ the implicit 'this' function parameter also counts, and they are
340 // counted from one.
341 bool HasImplicitThisParam = isInstanceMethod(d);
342 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000343
344 // The nonnull attribute only applies to pointers.
345 llvm::SmallVector<unsigned, 10> NonNullArgs;
Mike Stumpbf916502009-07-24 19:02:52 +0000346
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000347 for (AttributeList::arg_iterator I=Attr.arg_begin(),
348 E=Attr.arg_end(); I!=E; ++I) {
Mike Stumpbf916502009-07-24 19:02:52 +0000349
350
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000351 // The argument must be an integer constant expression.
Peter Collingbourne7a730022010-11-23 20:45:58 +0000352 Expr *Ex = *I;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000353 llvm::APSInt ArgNum(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +0000354 if (Ex->isTypeDependent() || Ex->isValueDependent() ||
355 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000356 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
357 << "nonnull" << Ex->getSourceRange();
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000358 return;
359 }
Mike Stumpbf916502009-07-24 19:02:52 +0000360
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000361 unsigned x = (unsigned) ArgNum.getZExtValue();
Mike Stumpbf916502009-07-24 19:02:52 +0000362
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000363 if (x < 1 || x > NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000364 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner30bc9652008-11-19 07:22:31 +0000365 << "nonnull" << I.getArgNum() << Ex->getSourceRange();
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000366 return;
367 }
Mike Stumpbf916502009-07-24 19:02:52 +0000368
Ted Kremenek465172f2008-07-21 22:09:15 +0000369 --x;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000370 if (HasImplicitThisParam) {
371 if (x == 0) {
372 S.Diag(Attr.getLoc(),
373 diag::err_attribute_invalid_implicit_this_argument)
374 << "nonnull" << Ex->getSourceRange();
375 return;
376 }
377 --x;
378 }
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000379
380 // Is the function argument a pointer type?
Douglas Gregorde436322010-12-15 15:41:46 +0000381 QualType T = getFunctionOrMethodArgType(d, x).getNonReferenceType();
Ted Kremenekdbfe99e2009-07-15 23:23:54 +0000382 if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000383 // FIXME: Should also highlight argument in decl.
Douglas Gregorc9ef4052010-08-12 18:48:43 +0000384 S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000385 << "nonnull" << Ex->getSourceRange();
Ted Kremenek7fb43c12008-09-01 19:57:52 +0000386 continue;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000387 }
Mike Stumpbf916502009-07-24 19:02:52 +0000388
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000389 NonNullArgs.push_back(x);
390 }
Mike Stumpbf916502009-07-24 19:02:52 +0000391
392 // If no arguments were specified to __attribute__((nonnull)) then all pointer
393 // arguments have a nonnull attribute.
Ted Kremenek7fb43c12008-09-01 19:57:52 +0000394 if (NonNullArgs.empty()) {
Ted Kremenek46bbaca2008-11-18 06:52:58 +0000395 for (unsigned I = 0, E = getFunctionOrMethodNumArgs(d); I != E; ++I) {
Douglas Gregorde436322010-12-15 15:41:46 +0000396 QualType T = getFunctionOrMethodArgType(d, I).getNonReferenceType();
Ted Kremenekdbfe99e2009-07-15 23:23:54 +0000397 if (T->isAnyPointerType() || T->isBlockPointerType())
Daniel Dunbard3f2c102008-10-19 02:04:16 +0000398 NonNullArgs.push_back(I);
Fariborz Jahanianff3a0782010-09-27 22:42:37 +0000399 else if (const RecordType *UT = T->getAsUnionType()) {
400 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
401 RecordDecl *UD = UT->getDecl();
402 for (RecordDecl::field_iterator it = UD->field_begin(),
403 itend = UD->field_end(); it != itend; ++it) {
404 T = it->getType();
405 if (T->isAnyPointerType() || T->isBlockPointerType()) {
406 NonNullArgs.push_back(I);
407 break;
408 }
409 }
410 }
411 }
Ted Kremenek46bbaca2008-11-18 06:52:58 +0000412 }
Mike Stumpbf916502009-07-24 19:02:52 +0000413
Ted Kremenekee1c08c2010-10-21 18:49:36 +0000414 // No pointer arguments?
Fariborz Jahanian60acea42010-09-27 19:05:51 +0000415 if (NonNullArgs.empty()) {
416 // Warn the trivial case only if attribute is not coming from a
417 // macro instantiation.
418 if (Attr.getLoc().isFileID())
419 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
Ted Kremenek7fb43c12008-09-01 19:57:52 +0000420 return;
Fariborz Jahanian60acea42010-09-27 19:05:51 +0000421 }
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000422 }
Ted Kremenek7fb43c12008-09-01 19:57:52 +0000423
424 unsigned* start = &NonNullArgs[0];
425 unsigned size = NonNullArgs.size();
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000426 llvm::array_pod_sort(start, start + size);
Sean Huntcf807c42010-08-18 23:23:40 +0000427 d->addAttr(::new (S.Context) NonNullAttr(Attr.getLoc(), S.Context, start,
428 size));
Ted Kremenekeb2b2a32008-07-21 21:53:04 +0000429}
430
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000431static void HandleOwnershipAttr(Decl *d, const AttributeList &AL, Sema &S) {
432 // This attribute must be applied to a function declaration.
433 // The first argument to the attribute must be a string,
434 // the name of the resource, for example "malloc".
435 // The following arguments must be argument indexes, the arguments must be
436 // of integer type for Returns, otherwise of pointer type.
437 // The difference between Holds and Takes is that a pointer may still be used
Jordy Rose2a479922010-08-12 08:54:03 +0000438 // after being held. free() should be __attribute((ownership_takes)), whereas
439 // a list append function may well be __attribute((ownership_holds)).
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000440
441 if (!AL.getParameterName()) {
442 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string)
443 << AL.getName()->getName() << 1;
444 return;
445 }
446 // Figure out our Kind, and check arguments while we're at it.
Sean Huntcf807c42010-08-18 23:23:40 +0000447 OwnershipAttr::OwnershipKind K;
Jordy Rose2a479922010-08-12 08:54:03 +0000448 switch (AL.getKind()) {
449 case AttributeList::AT_ownership_takes:
Sean Huntcf807c42010-08-18 23:23:40 +0000450 K = OwnershipAttr::Takes;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000451 if (AL.getNumArgs() < 1) {
452 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
453 return;
454 }
Jordy Rose2a479922010-08-12 08:54:03 +0000455 break;
456 case AttributeList::AT_ownership_holds:
Sean Huntcf807c42010-08-18 23:23:40 +0000457 K = OwnershipAttr::Holds;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000458 if (AL.getNumArgs() < 1) {
459 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
460 return;
461 }
Jordy Rose2a479922010-08-12 08:54:03 +0000462 break;
463 case AttributeList::AT_ownership_returns:
Sean Huntcf807c42010-08-18 23:23:40 +0000464 K = OwnershipAttr::Returns;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000465 if (AL.getNumArgs() > 1) {
466 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
467 << AL.getNumArgs() + 1;
468 return;
469 }
Jordy Rose2a479922010-08-12 08:54:03 +0000470 break;
471 default:
472 // This should never happen given how we are called.
473 llvm_unreachable("Unknown ownership attribute");
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000474 }
475
476 if (!isFunction(d) || !hasFunctionProto(d)) {
477 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL.getName()
478 << 0 /*function*/;
479 return;
480 }
481
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000482 // In C++ the implicit 'this' function parameter also counts, and they are
483 // counted from one.
484 bool HasImplicitThisParam = isInstanceMethod(d);
485 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000486
487 llvm::StringRef Module = AL.getParameterName()->getName();
488
489 // Normalize the argument, __foo__ becomes foo.
490 if (Module.startswith("__") && Module.endswith("__"))
491 Module = Module.substr(2, Module.size() - 4);
492
493 llvm::SmallVector<unsigned, 10> OwnershipArgs;
494
Jordy Rose2a479922010-08-12 08:54:03 +0000495 for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E;
496 ++I) {
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000497
Peter Collingbourne7a730022010-11-23 20:45:58 +0000498 Expr *IdxExpr = *I;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000499 llvm::APSInt ArgNum(32);
500 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
501 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
502 S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int)
503 << AL.getName()->getName() << IdxExpr->getSourceRange();
504 continue;
505 }
506
507 unsigned x = (unsigned) ArgNum.getZExtValue();
508
509 if (x > NumArgs || x < 1) {
510 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
511 << AL.getName()->getName() << x << IdxExpr->getSourceRange();
512 continue;
513 }
514 --x;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000515 if (HasImplicitThisParam) {
516 if (x == 0) {
517 S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
518 << "ownership" << IdxExpr->getSourceRange();
519 return;
520 }
521 --x;
522 }
523
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000524 switch (K) {
Sean Huntcf807c42010-08-18 23:23:40 +0000525 case OwnershipAttr::Takes:
526 case OwnershipAttr::Holds: {
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000527 // Is the function argument a pointer type?
528 QualType T = getFunctionOrMethodArgType(d, x);
529 if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
530 // FIXME: Should also highlight argument in decl.
531 S.Diag(AL.getLoc(), diag::err_ownership_type)
Sean Huntcf807c42010-08-18 23:23:40 +0000532 << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds")
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000533 << "pointer"
534 << IdxExpr->getSourceRange();
535 continue;
536 }
537 break;
538 }
Sean Huntcf807c42010-08-18 23:23:40 +0000539 case OwnershipAttr::Returns: {
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000540 if (AL.getNumArgs() > 1) {
541 // Is the function argument an integer type?
Peter Collingbourne7a730022010-11-23 20:45:58 +0000542 Expr *IdxExpr = AL.getArg(0);
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000543 llvm::APSInt ArgNum(32);
544 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
545 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
546 S.Diag(AL.getLoc(), diag::err_ownership_type)
547 << "ownership_returns" << "integer"
548 << IdxExpr->getSourceRange();
549 return;
550 }
551 }
552 break;
553 }
Jordy Rose2a479922010-08-12 08:54:03 +0000554 default:
555 llvm_unreachable("Unknown ownership attribute");
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000556 } // switch
557
558 // Check we don't have a conflict with another ownership attribute.
Sean Huntcf807c42010-08-18 23:23:40 +0000559 for (specific_attr_iterator<OwnershipAttr>
560 i = d->specific_attr_begin<OwnershipAttr>(),
561 e = d->specific_attr_end<OwnershipAttr>();
562 i != e; ++i) {
563 if ((*i)->getOwnKind() != K) {
564 for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end();
565 I!=E; ++I) {
566 if (x == *I) {
567 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
568 << AL.getName()->getName() << "ownership_*";
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000569 }
570 }
571 }
572 }
573 OwnershipArgs.push_back(x);
574 }
575
576 unsigned* start = OwnershipArgs.data();
577 unsigned size = OwnershipArgs.size();
578 llvm::array_pod_sort(start, start + size);
Sean Huntcf807c42010-08-18 23:23:40 +0000579
580 if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) {
581 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
582 return;
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000583 }
Sean Huntcf807c42010-08-18 23:23:40 +0000584
585 d->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module,
586 start, size));
Ted Kremenekdd0e4902010-07-31 01:52:11 +0000587}
588
John McCall332bb2a2011-02-08 22:35:49 +0000589/// Whether this declaration has internal linkage for the purposes of
590/// things that want to complain about things not have internal linkage.
591static bool hasEffectivelyInternalLinkage(NamedDecl *D) {
592 switch (D->getLinkage()) {
593 case NoLinkage:
594 case InternalLinkage:
595 return true;
596
597 // Template instantiations that go from external to unique-external
598 // shouldn't get diagnosed.
599 case UniqueExternalLinkage:
600 return true;
601
602 case ExternalLinkage:
603 return false;
604 }
605 llvm_unreachable("unknown linkage kind!");
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000606 return false;
607}
608
609static void HandleWeakRefAttr(Decl *d, const AttributeList &Attr, Sema &S) {
610 // Check the attribute arguments.
611 if (Attr.getNumArgs() > 1) {
612 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
613 return;
614 }
615
John McCall332bb2a2011-02-08 22:35:49 +0000616 if (!isa<VarDecl>(d) && !isa<FunctionDecl>(d)) {
617 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
618 << Attr.getName() << 2 /*variables and functions*/;
619 return;
620 }
621
622 NamedDecl *nd = cast<NamedDecl>(d);
623
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000624 // gcc rejects
625 // class c {
626 // static int a __attribute__((weakref ("v2")));
627 // static int b() __attribute__((weakref ("f3")));
628 // };
629 // and ignores the attributes of
630 // void f(void) {
631 // static int a __attribute__((weakref ("v2")));
632 // }
633 // we reject them
Sebastian Redl7a126a42010-08-31 00:36:30 +0000634 const DeclContext *Ctx = d->getDeclContext()->getRedeclContext();
635 if (!Ctx->isFileContext()) {
636 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
John McCall332bb2a2011-02-08 22:35:49 +0000637 nd->getNameAsString();
Sebastian Redl7a126a42010-08-31 00:36:30 +0000638 return;
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000639 }
640
641 // The GCC manual says
642 //
643 // At present, a declaration to which `weakref' is attached can only
644 // be `static'.
645 //
646 // It also says
647 //
648 // Without a TARGET,
649 // given as an argument to `weakref' or to `alias', `weakref' is
650 // equivalent to `weak'.
651 //
652 // gcc 4.4.1 will accept
653 // int a7 __attribute__((weakref));
654 // as
655 // int a7 __attribute__((weak));
656 // This looks like a bug in gcc. We reject that for now. We should revisit
657 // it if this behaviour is actually used.
658
John McCall332bb2a2011-02-08 22:35:49 +0000659 if (!hasEffectivelyInternalLinkage(nd)) {
660 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static);
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000661 return;
662 }
663
664 // GCC rejects
665 // static ((alias ("y"), weakref)).
666 // Should we? How to check that weakref is before or after alias?
667
668 if (Attr.getNumArgs() == 1) {
Peter Collingbourne7a730022010-11-23 20:45:58 +0000669 Expr *Arg = Attr.getArg(0);
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000670 Arg = Arg->IgnoreParenCasts();
671 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
672
673 if (Str == 0 || Str->isWide()) {
674 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
675 << "weakref" << 1;
676 return;
677 }
678 // GCC will accept anything as the argument of weakref. Should we
679 // check for an existing decl?
Eric Christopherf48f3672010-12-01 22:13:54 +0000680 d->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
681 Str->getString()));
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000682 }
683
Sean Huntcf807c42010-08-18 23:23:40 +0000684 d->addAttr(::new (S.Context) WeakRefAttr(Attr.getLoc(), S.Context));
Rafael Espindola11e8ce72010-02-23 22:00:30 +0000685}
686
Chris Lattner803d0802008-06-29 00:43:07 +0000687static void HandleAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +0000688 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +0000689 if (Attr.getNumArgs() != 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000690 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +0000691 return;
692 }
Mike Stumpbf916502009-07-24 19:02:52 +0000693
Peter Collingbourne7a730022010-11-23 20:45:58 +0000694 Expr *Arg = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +0000695 Arg = Arg->IgnoreParenCasts();
696 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Mike Stumpbf916502009-07-24 19:02:52 +0000697
Chris Lattner6b6b5372008-06-26 18:38:35 +0000698 if (Str == 0 || Str->isWide()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000699 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +0000700 << "alias" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +0000701 return;
702 }
Mike Stumpbf916502009-07-24 19:02:52 +0000703
Rafael Espindolaf5fe2922010-12-07 15:23:23 +0000704 if (S.Context.Target.getTriple().getOS() == llvm::Triple::Darwin) {
705 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
706 return;
707 }
708
Chris Lattner6b6b5372008-06-26 18:38:35 +0000709 // FIXME: check if target symbol exists in current file
Mike Stumpbf916502009-07-24 19:02:52 +0000710
Eric Christopherf48f3672010-12-01 22:13:54 +0000711 d->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context,
712 Str->getString()));
Chris Lattner6b6b5372008-06-26 18:38:35 +0000713}
714
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000715static void HandleNakedAttr(Decl *d, const AttributeList &Attr,
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000716 Sema &S) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000717 // Check the attribute arguments.
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000718 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000719 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000720 return;
721 }
Anders Carlsson5bab7882009-02-19 19:16:48 +0000722
Chris Lattnerc5197432009-04-14 17:02:11 +0000723 if (!isa<FunctionDecl>(d)) {
Anders Carlsson5bab7882009-02-19 19:16:48 +0000724 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000725 << Attr.getName() << 0 /*function*/;
726 return;
727 }
728
729 d->addAttr(::new (S.Context) NakedAttr(Attr.getLoc(), S.Context));
730}
731
732static void HandleAlwaysInlineAttr(Decl *d, const AttributeList &Attr,
733 Sema &S) {
734 // Check the attribute arguments.
735 if (Attr.getNumArgs() != 0) {
736 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
737 return;
738 }
739
740 if (!isa<FunctionDecl>(d)) {
741 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
742 << Attr.getName() << 0 /*function*/;
Anders Carlsson5bab7882009-02-19 19:16:48 +0000743 return;
744 }
Mike Stumpbf916502009-07-24 19:02:52 +0000745
Sean Huntcf807c42010-08-18 23:23:40 +0000746 d->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getLoc(), S.Context));
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000747}
748
Ryan Flynn76168e22009-08-09 20:07:29 +0000749static void HandleMallocAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000750 // Check the attribute arguments.
Ryan Flynn76168e22009-08-09 20:07:29 +0000751 if (Attr.getNumArgs() != 0) {
752 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
753 return;
754 }
Mike Stump1eb44332009-09-09 15:08:12 +0000755
Ted Kremenek2cff7d12009-08-15 00:51:46 +0000756 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000757 QualType RetTy = FD->getResultType();
Ted Kremenek2cff7d12009-08-15 00:51:46 +0000758 if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
Sean Huntcf807c42010-08-18 23:23:40 +0000759 d->addAttr(::new (S.Context) MallocAttr(Attr.getLoc(), S.Context));
Ted Kremenek2cff7d12009-08-15 00:51:46 +0000760 return;
761 }
Ryan Flynn76168e22009-08-09 20:07:29 +0000762 }
763
Ted Kremenek2cff7d12009-08-15 00:51:46 +0000764 S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
Ryan Flynn76168e22009-08-09 20:07:29 +0000765}
766
Dan Gohman34c26302010-11-17 00:03:07 +0000767static void HandleMayAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) {
768 // check the attribute arguments.
769 if (Attr.getNumArgs() != 0) {
770 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
771 return;
772 }
773
Dan Gohman34c26302010-11-17 00:03:07 +0000774 d->addAttr(::new (S.Context) MayAliasAttr(Attr.getLoc(), S.Context));
775}
776
Eric Christophera6cf1e72010-12-02 02:45:55 +0000777static void HandleNoCommonAttr(Decl *d, const AttributeList &Attr, Sema &S) {
778 assert(Attr.isInvalid() == false);
Eric Christopher722109c2010-12-03 06:58:14 +0000779 if (isa<VarDecl>(d))
780 d->addAttr(::new (S.Context) NoCommonAttr(Attr.getLoc(), S.Context));
781 else
782 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
783 << Attr.getName() << 12 /* variable */;
Eric Christophera6cf1e72010-12-02 02:45:55 +0000784}
785
786static void HandleCommonAttr(Decl *d, const AttributeList &Attr, Sema &S) {
787 assert(Attr.isInvalid() == false);
Eric Christopher722109c2010-12-03 06:58:14 +0000788 if (isa<VarDecl>(d))
789 d->addAttr(::new (S.Context) CommonAttr(Attr.getLoc(), S.Context));
790 else
791 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
792 << Attr.getName() << 12 /* variable */;
Eric Christophera6cf1e72010-12-02 02:45:55 +0000793}
794
John McCall711c52b2011-01-05 12:14:39 +0000795static void HandleNoReturnAttr(Decl *d, const AttributeList &attr, Sema &S) {
796 if (hasDeclarator(d)) return;
797
798 if (S.CheckNoReturnAttr(attr)) return;
799
800 if (!isa<ObjCMethodDecl>(d)) {
801 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
802 << attr.getName() << 0 /*function*/;
803 return;
804 }
805
806 d->addAttr(::new (S.Context) NoReturnAttr(attr.getLoc(), S.Context));
807}
808
809bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
810 if (attr.getNumArgs() != 0) {
811 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
812 attr.setInvalid();
813 return true;
814 }
815
816 return false;
Ted Kremenekb7252322009-04-10 00:01:14 +0000817}
818
819static void HandleAnalyzerNoReturnAttr(Decl *d, const AttributeList &Attr,
820 Sema &S) {
Ted Kremenekb56c1cc2010-08-19 00:51:58 +0000821
822 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
823 // because 'analyzer_noreturn' does not impact the type.
824
825 if (Attr.getNumArgs() != 0) {
826 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
827 return;
828 }
829
830 if (!isFunctionOrMethod(d) && !isa<BlockDecl>(d)) {
831 ValueDecl *VD = dyn_cast<ValueDecl>(d);
832 if (VD == 0 || (!VD->getType()->isBlockPointerType()
833 && !VD->getType()->isFunctionPointerType())) {
834 S.Diag(Attr.getLoc(),
835 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
836 : diag::warn_attribute_wrong_decl_type)
837 << Attr.getName() << 0 /*function*/;
838 return;
839 }
840 }
841
842 d->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +0000843}
844
John Thompson35cc9622010-08-09 21:53:52 +0000845// PS3 PPU-specific.
846static void HandleVecReturnAttr(Decl *d, const AttributeList &Attr,
847 Sema &S) {
848/*
849 Returning a Vector Class in Registers
850
Eric Christopherf48f3672010-12-01 22:13:54 +0000851 According to the PPU ABI specifications, a class with a single member of
852 vector type is returned in memory when used as the return value of a function.
853 This results in inefficient code when implementing vector classes. To return
854 the value in a single vector register, add the vecreturn attribute to the
855 class definition. This attribute is also applicable to struct types.
John Thompson35cc9622010-08-09 21:53:52 +0000856
857 Example:
858
859 struct Vector
860 {
861 __vector float xyzw;
862 } __attribute__((vecreturn));
863
864 Vector Add(Vector lhs, Vector rhs)
865 {
866 Vector result;
867 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
868 return result; // This will be returned in a register
869 }
870*/
John Thompson01add592010-09-18 01:12:07 +0000871 if (!isa<RecordDecl>(d)) {
John Thompson35cc9622010-08-09 21:53:52 +0000872 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
873 << Attr.getName() << 9 /*class*/;
874 return;
875 }
876
877 if (d->getAttr<VecReturnAttr>()) {
878 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn";
879 return;
880 }
881
John Thompson01add592010-09-18 01:12:07 +0000882 RecordDecl *record = cast<RecordDecl>(d);
883 int count = 0;
884
885 if (!isa<CXXRecordDecl>(record)) {
886 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
887 return;
888 }
889
890 if (!cast<CXXRecordDecl>(record)->isPOD()) {
891 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
892 return;
893 }
894
Eric Christopherf48f3672010-12-01 22:13:54 +0000895 for (RecordDecl::field_iterator iter = record->field_begin();
896 iter != record->field_end(); iter++) {
John Thompson01add592010-09-18 01:12:07 +0000897 if ((count == 1) || !iter->getType()->isVectorType()) {
898 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
899 return;
900 }
901 count++;
902 }
903
Sean Huntcf807c42010-08-18 23:23:40 +0000904 d->addAttr(::new (S.Context) VecReturnAttr(Attr.getLoc(), S.Context));
John Thompson35cc9622010-08-09 21:53:52 +0000905}
906
Sean Huntbbd37c62009-11-21 08:43:09 +0000907static void HandleDependencyAttr(Decl *d, const AttributeList &Attr, Sema &S) {
908 if (!isFunctionOrMethod(d) && !isa<ParmVarDecl>(d)) {
909 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
John McCall04a67a62010-02-05 21:31:56 +0000910 << Attr.getName() << 8 /*function, method, or parameter*/;
Sean Huntbbd37c62009-11-21 08:43:09 +0000911 return;
912 }
913 // FIXME: Actually store the attribute on the declaration
914}
915
Ted Kremenek73798892008-07-25 04:39:19 +0000916static void HandleUnusedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
917 // check the attribute arguments.
918 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +0000919 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Ted Kremenek73798892008-07-25 04:39:19 +0000920 return;
921 }
Mike Stumpbf916502009-07-24 19:02:52 +0000922
John McCallaec58602010-03-31 02:47:45 +0000923 if (!isa<VarDecl>(d) && !isa<ObjCIvarDecl>(d) && !isFunctionOrMethod(d) &&
Chris Lattner57ad3782011-02-17 20:34:02 +0000924 !isa<TypeDecl>(d) && !isa<LabelDecl>(d)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000925 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Chris Lattner57ad3782011-02-17 20:34:02 +0000926 << Attr.getName() << 14 /*variable, function, labels*/;
Ted Kremenek73798892008-07-25 04:39:19 +0000927 return;
928 }
Mike Stumpbf916502009-07-24 19:02:52 +0000929
Sean Huntcf807c42010-08-18 23:23:40 +0000930 d->addAttr(::new (S.Context) UnusedAttr(Attr.getLoc(), S.Context));
Ted Kremenek73798892008-07-25 04:39:19 +0000931}
932
Daniel Dunbarb805dad2009-02-13 19:23:53 +0000933static void HandleUsedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
934 // check the attribute arguments.
935 if (Attr.getNumArgs() != 0) {
936 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
937 return;
938 }
Mike Stumpbf916502009-07-24 19:02:52 +0000939
Daniel Dunbarb805dad2009-02-13 19:23:53 +0000940 if (const VarDecl *VD = dyn_cast<VarDecl>(d)) {
Daniel Dunbar186204b2009-02-13 22:48:56 +0000941 if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
Daniel Dunbarb805dad2009-02-13 19:23:53 +0000942 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
943 return;
944 }
945 } else if (!isFunctionOrMethod(d)) {
946 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +0000947 << Attr.getName() << 2 /*variable and function*/;
Daniel Dunbarb805dad2009-02-13 19:23:53 +0000948 return;
949 }
Mike Stumpbf916502009-07-24 19:02:52 +0000950
Sean Huntcf807c42010-08-18 23:23:40 +0000951 d->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context));
Daniel Dunbarb805dad2009-02-13 19:23:53 +0000952}
953
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000954static void HandleConstructorAttr(Decl *d, const AttributeList &Attr, Sema &S) {
955 // check the attribute arguments.
956 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000957 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
958 << "0 or 1";
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000959 return;
Mike Stumpbf916502009-07-24 19:02:52 +0000960 }
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000961
962 int priority = 65535; // FIXME: Do not hardcode such constants.
963 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +0000964 Expr *E = Attr.getArg(0);
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000965 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +0000966 if (E->isTypeDependent() || E->isValueDependent() ||
967 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000968 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +0000969 << "constructor" << 1 << E->getSourceRange();
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000970 return;
971 }
972 priority = Idx.getZExtValue();
973 }
Mike Stumpbf916502009-07-24 19:02:52 +0000974
Chris Lattnerc5197432009-04-14 17:02:11 +0000975 if (!isa<FunctionDecl>(d)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000976 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +0000977 << Attr.getName() << 0 /*function*/;
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000978 return;
979 }
980
Eric Christopherf48f3672010-12-01 22:13:54 +0000981 d->addAttr(::new (S.Context) ConstructorAttr(Attr.getLoc(), S.Context,
982 priority));
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000983}
984
985static void HandleDestructorAttr(Decl *d, const AttributeList &Attr, Sema &S) {
986 // check the attribute arguments.
987 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000988 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
989 << "0 or 1";
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000990 return;
Mike Stumpbf916502009-07-24 19:02:52 +0000991 }
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000992
993 int priority = 65535; // FIXME: Do not hardcode such constants.
994 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +0000995 Expr *E = Attr.getArg(0);
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000996 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +0000997 if (E->isTypeDependent() || E->isValueDependent() ||
998 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000999 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001000 << "destructor" << 1 << E->getSourceRange();
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001001 return;
1002 }
1003 priority = Idx.getZExtValue();
1004 }
Mike Stumpbf916502009-07-24 19:02:52 +00001005
Anders Carlsson6782fc62008-08-22 22:10:48 +00001006 if (!isa<FunctionDecl>(d)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001007 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00001008 << Attr.getName() << 0 /*function*/;
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001009 return;
1010 }
1011
Eric Christopherf48f3672010-12-01 22:13:54 +00001012 d->addAttr(::new (S.Context) DestructorAttr(Attr.getLoc(), S.Context,
1013 priority));
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001014}
1015
Chris Lattner803d0802008-06-29 00:43:07 +00001016static void HandleDeprecatedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001017 unsigned NumArgs = Attr.getNumArgs();
1018 if (NumArgs > 1) {
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001019 S.Diag(Attr.getLoc(),
1020 diag::err_attribute_wrong_number_arguments) << "0 or 1";
Chris Lattner6b6b5372008-06-26 18:38:35 +00001021 return;
1022 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001023
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001024 // Handle the case where deprecated attribute has a text message.
Chris Lattner951bbb22011-02-24 05:42:24 +00001025 llvm::StringRef Str;
1026 if (NumArgs == 1) {
1027 StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001028 if (!SE) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001029 S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string)
1030 << "deprecated";
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001031 return;
1032 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001033 Str = SE->getString();
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001034 }
Mike Stumpbf916502009-07-24 19:02:52 +00001035
Chris Lattner951bbb22011-02-24 05:42:24 +00001036 d->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context, Str));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001037}
1038
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00001039static void HandleUnavailableAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001040 unsigned NumArgs = Attr.getNumArgs();
1041 if (NumArgs > 1) {
Eric Christopherf48f3672010-12-01 22:13:54 +00001042 S.Diag(Attr.getLoc(),
1043 diag::err_attribute_wrong_number_arguments) << "0 or 1";
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00001044 return;
1045 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001046
Fariborz Jahanianc784dc12010-10-06 23:12:32 +00001047 // Handle the case where unavailable attribute has a text message.
Chris Lattner951bbb22011-02-24 05:42:24 +00001048 llvm::StringRef Str;
1049 if (NumArgs == 1) {
1050 StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
Fariborz Jahanianc784dc12010-10-06 23:12:32 +00001051 if (!SE) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001052 S.Diag(Attr.getArg(0)->getLocStart(),
Fariborz Jahanianc784dc12010-10-06 23:12:32 +00001053 diag::err_attribute_not_string) << "unavailable";
1054 return;
1055 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001056 Str = SE->getString();
Fariborz Jahanianc784dc12010-10-06 23:12:32 +00001057 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001058 d->addAttr(::new (S.Context) UnavailableAttr(Attr.getLoc(), S.Context, Str));
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00001059}
1060
Chris Lattner803d0802008-06-29 00:43:07 +00001061static void HandleVisibilityAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001062 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001063 if (Attr.getNumArgs() != 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001064 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001065 return;
1066 }
Mike Stumpbf916502009-07-24 19:02:52 +00001067
Peter Collingbourne7a730022010-11-23 20:45:58 +00001068 Expr *Arg = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001069 Arg = Arg->IgnoreParenCasts();
1070 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Mike Stumpbf916502009-07-24 19:02:52 +00001071
Chris Lattner6b6b5372008-06-26 18:38:35 +00001072 if (Str == 0 || Str->isWide()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001073 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00001074 << "visibility" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001075 return;
1076 }
Mike Stumpbf916502009-07-24 19:02:52 +00001077
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001078 llvm::StringRef TypeStr = Str->getString();
Sean Huntcf807c42010-08-18 23:23:40 +00001079 VisibilityAttr::VisibilityType type;
Mike Stumpbf916502009-07-24 19:02:52 +00001080
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001081 if (TypeStr == "default")
Sean Huntcf807c42010-08-18 23:23:40 +00001082 type = VisibilityAttr::Default;
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001083 else if (TypeStr == "hidden")
Sean Huntcf807c42010-08-18 23:23:40 +00001084 type = VisibilityAttr::Hidden;
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001085 else if (TypeStr == "internal")
Sean Huntcf807c42010-08-18 23:23:40 +00001086 type = VisibilityAttr::Hidden; // FIXME
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001087 else if (TypeStr == "protected")
Sean Huntcf807c42010-08-18 23:23:40 +00001088 type = VisibilityAttr::Protected;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001089 else {
Chris Lattner08631c52008-11-23 21:45:46 +00001090 S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001091 return;
1092 }
Mike Stumpbf916502009-07-24 19:02:52 +00001093
Sean Huntcf807c42010-08-18 23:23:40 +00001094 d->addAttr(::new (S.Context) VisibilityAttr(Attr.getLoc(), S.Context, type));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001095}
1096
Chris Lattner0db29ec2009-02-14 08:09:34 +00001097static void HandleObjCExceptionAttr(Decl *D, const AttributeList &Attr,
1098 Sema &S) {
1099 if (Attr.getNumArgs() != 0) {
1100 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1101 return;
1102 }
Mike Stumpbf916502009-07-24 19:02:52 +00001103
Chris Lattner0db29ec2009-02-14 08:09:34 +00001104 ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
1105 if (OCI == 0) {
1106 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1107 return;
1108 }
Mike Stumpbf916502009-07-24 19:02:52 +00001109
Sean Huntcf807c42010-08-18 23:23:40 +00001110 D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getLoc(), S.Context));
Chris Lattner0db29ec2009-02-14 08:09:34 +00001111}
1112
1113static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00001114 if (Attr.getNumArgs() != 0) {
John McCall2b7baf02010-05-28 18:25:28 +00001115 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00001116 return;
1117 }
Chris Lattner0db29ec2009-02-14 08:09:34 +00001118 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00001119 QualType T = TD->getUnderlyingType();
1120 if (!T->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00001121 !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00001122 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
1123 return;
1124 }
1125 }
Sean Huntcf807c42010-08-18 23:23:40 +00001126 D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getLoc(), S.Context));
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00001127}
1128
Mike Stumpbf916502009-07-24 19:02:52 +00001129static void
Douglas Gregorf9201e02009-02-11 23:02:49 +00001130HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) {
1131 if (Attr.getNumArgs() != 0) {
John McCall2b7baf02010-05-28 18:25:28 +00001132 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Douglas Gregorf9201e02009-02-11 23:02:49 +00001133 return;
1134 }
1135
1136 if (!isa<FunctionDecl>(D)) {
1137 S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
1138 return;
1139 }
1140
Sean Huntcf807c42010-08-18 23:23:40 +00001141 D->addAttr(::new (S.Context) OverloadableAttr(Attr.getLoc(), S.Context));
Douglas Gregorf9201e02009-02-11 23:02:49 +00001142}
1143
Steve Naroff9eae5762008-09-18 16:44:58 +00001144static void HandleBlocksAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Mike Stumpbf916502009-07-24 19:02:52 +00001145 if (!Attr.getParameterName()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001146 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00001147 << "blocks" << 1;
Steve Naroff9eae5762008-09-18 16:44:58 +00001148 return;
1149 }
Mike Stumpbf916502009-07-24 19:02:52 +00001150
Steve Naroff9eae5762008-09-18 16:44:58 +00001151 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001152 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Steve Naroff9eae5762008-09-18 16:44:58 +00001153 return;
1154 }
Mike Stumpbf916502009-07-24 19:02:52 +00001155
Sean Huntcf807c42010-08-18 23:23:40 +00001156 BlocksAttr::BlockType type;
Chris Lattner92e62b02008-11-20 04:42:34 +00001157 if (Attr.getParameterName()->isStr("byref"))
Steve Naroff9eae5762008-09-18 16:44:58 +00001158 type = BlocksAttr::ByRef;
1159 else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001160 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
Chris Lattner3c73c412008-11-19 08:23:25 +00001161 << "blocks" << Attr.getParameterName();
Steve Naroff9eae5762008-09-18 16:44:58 +00001162 return;
1163 }
Mike Stumpbf916502009-07-24 19:02:52 +00001164
Sean Huntcf807c42010-08-18 23:23:40 +00001165 d->addAttr(::new (S.Context) BlocksAttr(Attr.getLoc(), S.Context, type));
Steve Naroff9eae5762008-09-18 16:44:58 +00001166}
1167
Anders Carlsson77091822008-10-05 18:05:59 +00001168static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1169 // check the attribute arguments.
1170 if (Attr.getNumArgs() > 2) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001171 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1172 << "0, 1 or 2";
Anders Carlsson77091822008-10-05 18:05:59 +00001173 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001174 }
1175
Anders Carlsson77091822008-10-05 18:05:59 +00001176 int sentinel = 0;
1177 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001178 Expr *E = Attr.getArg(0);
Anders Carlsson77091822008-10-05 18:05:59 +00001179 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001180 if (E->isTypeDependent() || E->isValueDependent() ||
1181 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001182 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001183 << "sentinel" << 1 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00001184 return;
1185 }
1186 sentinel = Idx.getZExtValue();
Mike Stumpbf916502009-07-24 19:02:52 +00001187
Anders Carlsson77091822008-10-05 18:05:59 +00001188 if (sentinel < 0) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001189 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
1190 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00001191 return;
1192 }
1193 }
1194
1195 int nullPos = 0;
1196 if (Attr.getNumArgs() > 1) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001197 Expr *E = Attr.getArg(1);
Anders Carlsson77091822008-10-05 18:05:59 +00001198 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001199 if (E->isTypeDependent() || E->isValueDependent() ||
1200 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001201 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001202 << "sentinel" << 2 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00001203 return;
1204 }
1205 nullPos = Idx.getZExtValue();
Mike Stumpbf916502009-07-24 19:02:52 +00001206
Anders Carlsson77091822008-10-05 18:05:59 +00001207 if (nullPos > 1 || nullPos < 0) {
1208 // FIXME: This error message could be improved, it would be nice
1209 // to say what the bounds actually are.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001210 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
1211 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00001212 return;
1213 }
1214 }
1215
1216 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) {
John McCall183700f2009-09-21 23:43:11 +00001217 const FunctionType *FT = FD->getType()->getAs<FunctionType>();
Chris Lattner897cd902009-03-17 23:03:47 +00001218 assert(FT && "FunctionDecl has non-function type?");
Mike Stumpbf916502009-07-24 19:02:52 +00001219
Chris Lattner897cd902009-03-17 23:03:47 +00001220 if (isa<FunctionNoProtoType>(FT)) {
1221 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
1222 return;
1223 }
Mike Stumpbf916502009-07-24 19:02:52 +00001224
Chris Lattner897cd902009-03-17 23:03:47 +00001225 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00001226 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
Anders Carlsson77091822008-10-05 18:05:59 +00001227 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001228 }
Anders Carlsson77091822008-10-05 18:05:59 +00001229 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) {
1230 if (!MD->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00001231 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
Anders Carlsson77091822008-10-05 18:05:59 +00001232 return;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001233 }
1234 } else if (isa<BlockDecl>(d)) {
Mike Stumpbf916502009-07-24 19:02:52 +00001235 // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the
1236 // caller.
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001237 ;
1238 } else if (const VarDecl *V = dyn_cast<VarDecl>(d)) {
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001239 QualType Ty = V->getType();
Fariborz Jahaniandaf04152009-05-15 20:33:25 +00001240 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
Mike Stumpbf916502009-07-24 19:02:52 +00001241 const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(d)
Eric Christopherf48f3672010-12-01 22:13:54 +00001242 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001243 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00001244 int m = Ty->isFunctionPointerType() ? 0 : 1;
1245 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001246 return;
1247 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001248 } else {
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001249 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Fariborz Jahanianffb00812009-05-14 20:57:28 +00001250 << Attr.getName() << 6 /*function, method or block */;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00001251 return;
1252 }
Anders Carlsson77091822008-10-05 18:05:59 +00001253 } else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001254 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Fariborz Jahanianffb00812009-05-14 20:57:28 +00001255 << Attr.getName() << 6 /*function, method or block */;
Anders Carlsson77091822008-10-05 18:05:59 +00001256 return;
1257 }
Eric Christopherf48f3672010-12-01 22:13:54 +00001258 d->addAttr(::new (S.Context) SentinelAttr(Attr.getLoc(), S.Context, sentinel,
1259 nullPos));
Anders Carlsson77091822008-10-05 18:05:59 +00001260}
1261
Chris Lattner026dc962009-02-14 07:37:35 +00001262static void HandleWarnUnusedResult(Decl *D, const AttributeList &Attr, Sema &S) {
1263 // check the attribute arguments.
1264 if (Attr.getNumArgs() != 0) {
1265 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1266 return;
1267 }
1268
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001269 if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
Chris Lattner026dc962009-02-14 07:37:35 +00001270 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00001271 << Attr.getName() << 0 /*function*/;
Chris Lattner026dc962009-02-14 07:37:35 +00001272 return;
1273 }
Mike Stumpbf916502009-07-24 19:02:52 +00001274
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001275 if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
1276 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1277 << Attr.getName() << 0;
Nuno Lopesf8577982009-12-22 23:59:52 +00001278 return;
1279 }
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001280 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
1281 if (MD->getResultType()->isVoidType()) {
1282 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
1283 << Attr.getName() << 1;
1284 return;
1285 }
1286
Sean Huntcf807c42010-08-18 23:23:40 +00001287 D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getLoc(), S.Context));
Chris Lattner026dc962009-02-14 07:37:35 +00001288}
1289
John McCall332bb2a2011-02-08 22:35:49 +00001290static void HandleWeakAttr(Decl *d, const AttributeList &attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001291 // check the attribute arguments.
John McCall332bb2a2011-02-08 22:35:49 +00001292 if (attr.getNumArgs() != 0) {
1293 S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001294 return;
1295 }
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001296
John McCall332bb2a2011-02-08 22:35:49 +00001297 if (!isa<VarDecl>(d) && !isa<FunctionDecl>(d)) {
1298 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1299 << attr.getName() << 2 /*variables and functions*/;
Fariborz Jahanianf23ecd92009-07-16 01:12:24 +00001300 return;
1301 }
1302
John McCall332bb2a2011-02-08 22:35:49 +00001303 NamedDecl *nd = cast<NamedDecl>(d);
1304
1305 // 'weak' only applies to declarations with external linkage.
1306 if (hasEffectivelyInternalLinkage(nd)) {
1307 S.Diag(attr.getLoc(), diag::err_attribute_weak_static);
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001308 return;
1309 }
Mike Stumpbf916502009-07-24 19:02:52 +00001310
John McCall332bb2a2011-02-08 22:35:49 +00001311 nd->addAttr(::new (S.Context) WeakAttr(attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001312}
1313
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001314static void HandleWeakImportAttr(Decl *D, const AttributeList &Attr, Sema &S) {
1315 // check the attribute arguments.
1316 if (Attr.getNumArgs() != 0) {
1317 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1318 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001319 }
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001320
1321 // weak_import only applies to variable & function declarations.
1322 bool isDef = false;
1323 if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1324 isDef = (!VD->hasExternalStorage() || VD->getInit());
1325 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001326 isDef = FD->hasBody();
Fariborz Jahaniand4edddd2009-05-04 19:35:12 +00001327 } else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D)) {
1328 // We ignore weak import on properties and methods
Mike Stump1c90f4d2009-03-18 17:39:31 +00001329 return;
Fariborz Jahanian5f8f8572009-11-17 19:08:08 +00001330 } else if (!(S.LangOpts.ObjCNonFragileABI && isa<ObjCInterfaceDecl>(D))) {
Fariborz Jahanianc0349742010-04-13 20:22:35 +00001331 // Don't issue the warning for darwin as target; yet, ignore the attribute.
Fariborz Jahanian3be17942010-04-12 16:57:31 +00001332 if (S.Context.Target.getTriple().getOS() != llvm::Triple::Darwin ||
Fariborz Jahanianc0349742010-04-13 20:22:35 +00001333 !isa<ObjCInterfaceDecl>(D))
1334 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Fariborz Jahanian3be17942010-04-12 16:57:31 +00001335 << Attr.getName() << 2 /*variable and function*/;
1336 return;
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001337 }
1338
1339 // Merge should handle any subsequent violations.
1340 if (isDef) {
Mike Stumpbf916502009-07-24 19:02:52 +00001341 S.Diag(Attr.getLoc(),
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001342 diag::warn_attribute_weak_import_invalid_on_definition)
1343 << "weak_import" << 2 /*variable and function*/;
1344 return;
1345 }
1346
Sean Huntcf807c42010-08-18 23:23:40 +00001347 D->addAttr(::new (S.Context) WeakImportAttr(Attr.getLoc(), S.Context));
Daniel Dunbar6e775db2009-03-06 06:39:57 +00001348}
1349
Nate Begeman6f3d8382009-06-26 06:32:41 +00001350static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr,
1351 Sema &S) {
1352 // Attribute has 3 arguments.
1353 if (Attr.getNumArgs() != 3) {
John McCall2b7baf02010-05-28 18:25:28 +00001354 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Nate Begeman6f3d8382009-06-26 06:32:41 +00001355 return;
1356 }
1357
1358 unsigned WGSize[3];
1359 for (unsigned i = 0; i < 3; ++i) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001360 Expr *E = Attr.getArg(i);
Nate Begeman6f3d8382009-06-26 06:32:41 +00001361 llvm::APSInt ArgNum(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001362 if (E->isTypeDependent() || E->isValueDependent() ||
1363 !E->isIntegerConstantExpr(ArgNum, S.Context)) {
Nate Begeman6f3d8382009-06-26 06:32:41 +00001364 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1365 << "reqd_work_group_size" << E->getSourceRange();
1366 return;
1367 }
1368 WGSize[i] = (unsigned) ArgNum.getZExtValue();
1369 }
Sean Huntcf807c42010-08-18 23:23:40 +00001370 D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getLoc(), S.Context,
1371 WGSize[0], WGSize[1],
Nate Begeman6f3d8382009-06-26 06:32:41 +00001372 WGSize[2]));
1373}
1374
Chris Lattner026dc962009-02-14 07:37:35 +00001375static void HandleSectionAttr(Decl *D, const AttributeList &Attr, Sema &S) {
Daniel Dunbar17f194f2009-02-12 17:28:23 +00001376 // Attribute has no arguments.
1377 if (Attr.getNumArgs() != 1) {
1378 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1379 return;
1380 }
1381
1382 // Make sure that there is a string literal as the sections's single
1383 // argument.
Peter Collingbourne7a730022010-11-23 20:45:58 +00001384 Expr *ArgExpr = Attr.getArg(0);
Chris Lattner797c3c42009-08-10 19:03:04 +00001385 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
Daniel Dunbar17f194f2009-02-12 17:28:23 +00001386 if (!SE) {
Chris Lattner797c3c42009-08-10 19:03:04 +00001387 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
Daniel Dunbar17f194f2009-02-12 17:28:23 +00001388 return;
1389 }
Mike Stump1eb44332009-09-09 15:08:12 +00001390
Chris Lattner797c3c42009-08-10 19:03:04 +00001391 // If the target wants to validate the section specifier, make it happen.
Benjamin Kramerbb377ed2009-11-30 17:08:26 +00001392 std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString());
Chris Lattnera1e1dc72010-01-12 20:58:53 +00001393 if (!Error.empty()) {
1394 S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
1395 << Error;
Chris Lattner797c3c42009-08-10 19:03:04 +00001396 return;
1397 }
Mike Stump1eb44332009-09-09 15:08:12 +00001398
Chris Lattnera1e1dc72010-01-12 20:58:53 +00001399 // This attribute cannot be applied to local variables.
1400 if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
1401 S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
1402 return;
1403 }
1404
Eric Christopherf48f3672010-12-01 22:13:54 +00001405 D->addAttr(::new (S.Context) SectionAttr(Attr.getLoc(), S.Context,
1406 SE->getString()));
Daniel Dunbar17f194f2009-02-12 17:28:23 +00001407}
1408
Chris Lattner6b6b5372008-06-26 18:38:35 +00001409
Chris Lattner803d0802008-06-29 00:43:07 +00001410static void HandleNothrowAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001411 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001412 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001413 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001414 return;
1415 }
Mike Stumpbf916502009-07-24 19:02:52 +00001416
Sean Huntcf807c42010-08-18 23:23:40 +00001417 d->addAttr(::new (S.Context) NoThrowAttr(Attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001418}
1419
Anders Carlsson232eb7d2008-10-05 23:32:53 +00001420static void HandleConstAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1421 // check the attribute arguments.
1422 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001423 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Anders Carlsson232eb7d2008-10-05 23:32:53 +00001424 return;
1425 }
Mike Stumpbf916502009-07-24 19:02:52 +00001426
Sean Huntcf807c42010-08-18 23:23:40 +00001427 d->addAttr(::new (S.Context) ConstAttr(Attr.getLoc(), S.Context));
Anders Carlsson232eb7d2008-10-05 23:32:53 +00001428}
1429
1430static void HandlePureAttr(Decl *d, const AttributeList &Attr, Sema &S) {
1431 // check the attribute arguments.
1432 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001433 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Anders Carlsson232eb7d2008-10-05 23:32:53 +00001434 return;
1435 }
Mike Stumpbf916502009-07-24 19:02:52 +00001436
Sean Huntcf807c42010-08-18 23:23:40 +00001437 d->addAttr(::new (S.Context) PureAttr(Attr.getLoc(), S.Context));
Anders Carlsson232eb7d2008-10-05 23:32:53 +00001438}
1439
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001440static void HandleCleanupAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Mike Stumpbf916502009-07-24 19:02:52 +00001441 if (!Attr.getParameterName()) {
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001442 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1443 return;
1444 }
Mike Stumpbf916502009-07-24 19:02:52 +00001445
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001446 if (Attr.getNumArgs() != 0) {
1447 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1448 return;
1449 }
Mike Stumpbf916502009-07-24 19:02:52 +00001450
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001451 VarDecl *VD = dyn_cast<VarDecl>(d);
Mike Stumpbf916502009-07-24 19:02:52 +00001452
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001453 if (!VD || !VD->hasLocalStorage()) {
1454 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
1455 return;
1456 }
Mike Stumpbf916502009-07-24 19:02:52 +00001457
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001458 // Look up the function
Douglas Gregorc83c6872010-04-15 22:33:43 +00001459 // FIXME: Lookup probably isn't looking in the right place
John McCallf36e02d2009-10-09 21:13:30 +00001460 NamedDecl *CleanupDecl
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00001461 = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
1462 Attr.getParameterLoc(), Sema::LookupOrdinaryName);
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001463 if (!CleanupDecl) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00001464 S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001465 Attr.getParameterName();
1466 return;
1467 }
Mike Stumpbf916502009-07-24 19:02:52 +00001468
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001469 FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
1470 if (!FD) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00001471 S.Diag(Attr.getParameterLoc(),
1472 diag::err_attribute_cleanup_arg_not_function)
1473 << Attr.getParameterName();
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001474 return;
1475 }
1476
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001477 if (FD->getNumParams() != 1) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00001478 S.Diag(Attr.getParameterLoc(),
1479 diag::err_attribute_cleanup_func_must_take_one_arg)
1480 << Attr.getParameterName();
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001481 return;
1482 }
Mike Stumpbf916502009-07-24 19:02:52 +00001483
Anders Carlsson89941c12009-02-07 23:16:50 +00001484 // We're currently more strict than GCC about what function types we accept.
1485 // If this ever proves to be a problem it should be easy to fix.
1486 QualType Ty = S.Context.getPointerType(VD->getType());
1487 QualType ParamTy = FD->getParamDecl(0)->getType();
Douglas Gregorb608b982011-01-28 02:26:04 +00001488 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
1489 ParamTy, Ty) != Sema::Compatible) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00001490 S.Diag(Attr.getParameterLoc(),
Anders Carlsson89941c12009-02-07 23:16:50 +00001491 diag::err_attribute_cleanup_func_arg_incompatible_type) <<
1492 Attr.getParameterName() << ParamTy << Ty;
1493 return;
1494 }
Mike Stumpbf916502009-07-24 19:02:52 +00001495
Sean Huntcf807c42010-08-18 23:23:40 +00001496 d->addAttr(::new (S.Context) CleanupAttr(Attr.getLoc(), S.Context, FD));
Argyrios Kyrtzidis223ae5c2010-12-06 17:51:53 +00001497 S.MarkDeclarationReferenced(Attr.getParameterLoc(), FD);
Anders Carlssonf6e35d02009-01-31 01:16:18 +00001498}
1499
Mike Stumpbf916502009-07-24 19:02:52 +00001500/// Handle __attribute__((format_arg((idx)))) attribute based on
1501/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
1502static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001503 if (Attr.getNumArgs() != 1) {
1504 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1505 return;
1506 }
1507 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) {
1508 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1509 << Attr.getName() << 0 /*function*/;
1510 return;
1511 }
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001512
1513 // In C++ the implicit 'this' function parameter also counts, and they are
1514 // counted from one.
1515 bool HasImplicitThisParam = isInstanceMethod(d);
1516 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam;
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001517 unsigned FirstIdx = 1;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001518
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001519 // checks for the 2nd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00001520 Expr *IdxExpr = Attr.getArg(0);
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001521 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001522 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1523 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001524 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
1525 << "format" << 2 << IdxExpr->getSourceRange();
1526 return;
1527 }
Mike Stumpbf916502009-07-24 19:02:52 +00001528
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001529 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
1530 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
1531 << "format" << 2 << IdxExpr->getSourceRange();
1532 return;
1533 }
Mike Stumpbf916502009-07-24 19:02:52 +00001534
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001535 unsigned ArgIdx = Idx.getZExtValue() - 1;
Mike Stumpbf916502009-07-24 19:02:52 +00001536
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001537 if (HasImplicitThisParam) {
1538 if (ArgIdx == 0) {
1539 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
1540 << "format_arg" << IdxExpr->getSourceRange();
1541 return;
1542 }
1543 ArgIdx--;
1544 }
1545
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001546 // make sure the format string is really a string
1547 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
Mike Stumpbf916502009-07-24 19:02:52 +00001548
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001549 bool not_nsstring_type = !isNSStringType(Ty, S.Context);
1550 if (not_nsstring_type &&
1551 !isCFStringType(Ty, S.Context) &&
1552 (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00001553 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001554 // FIXME: Should highlight the actual expression that has the wrong type.
1555 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
Mike Stumpbf916502009-07-24 19:02:52 +00001556 << (not_nsstring_type ? "a string type" : "an NSString")
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001557 << IdxExpr->getSourceRange();
1558 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001559 }
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001560 Ty = getFunctionOrMethodResultType(d);
1561 if (!isNSStringType(Ty, S.Context) &&
1562 !isCFStringType(Ty, S.Context) &&
1563 (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00001564 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001565 // FIXME: Should highlight the actual expression that has the wrong type.
1566 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
Mike Stumpbf916502009-07-24 19:02:52 +00001567 << (not_nsstring_type ? "string type" : "NSString")
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001568 << IdxExpr->getSourceRange();
1569 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001570 }
1571
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001572 d->addAttr(::new (S.Context) FormatArgAttr(Attr.getLoc(), S.Context,
1573 Idx.getZExtValue()));
Fariborz Jahanian5b160922009-05-20 17:41:43 +00001574}
1575
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001576enum FormatAttrKind {
1577 CFStringFormat,
1578 NSStringFormat,
1579 StrftimeFormat,
1580 SupportedFormat,
Chris Lattner3c989022010-03-22 21:08:50 +00001581 IgnoredFormat,
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001582 InvalidFormat
1583};
1584
1585/// getFormatAttrKind - Map from format attribute names to supported format
1586/// types.
1587static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) {
1588 // Check for formats that get handled specially.
1589 if (Format == "NSString")
1590 return NSStringFormat;
1591 if (Format == "CFString")
1592 return CFStringFormat;
1593 if (Format == "strftime")
1594 return StrftimeFormat;
1595
1596 // Otherwise, check for supported formats.
1597 if (Format == "scanf" || Format == "printf" || Format == "printf0" ||
1598 Format == "strfmon" || Format == "cmn_err" || Format == "strftime" ||
1599 Format == "NSString" || Format == "CFString" || Format == "vcmn_err" ||
Chris Lattnercd5b3062011-02-18 17:05:55 +00001600 Format == "zcmn_err" ||
1601 Format == "kprintf") // OpenBSD.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001602 return SupportedFormat;
1603
Duncan Sandsbc525952010-03-23 14:44:19 +00001604 if (Format == "gcc_diag" || Format == "gcc_cdiag" ||
1605 Format == "gcc_cxxdiag" || Format == "gcc_tdiag")
Chris Lattner3c989022010-03-22 21:08:50 +00001606 return IgnoredFormat;
1607
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001608 return InvalidFormat;
1609}
1610
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00001611/// Handle __attribute__((init_priority(priority))) attributes based on
1612/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
1613static void HandleInitPriorityAttr(Decl *d, const AttributeList &Attr,
1614 Sema &S) {
1615 if (!S.getLangOptions().CPlusPlus) {
1616 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1617 return;
1618 }
1619
Fariborz Jahanianb9d5c222010-06-18 23:14:53 +00001620 if (!isa<VarDecl>(d) || S.getCurFunctionOrMethodDecl()) {
1621 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1622 Attr.setInvalid();
1623 return;
1624 }
1625 QualType T = dyn_cast<VarDecl>(d)->getType();
1626 if (S.Context.getAsArrayType(T))
1627 T = S.Context.getBaseElementType(T);
1628 if (!T->getAs<RecordType>()) {
1629 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
1630 Attr.setInvalid();
1631 return;
1632 }
1633
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00001634 if (Attr.getNumArgs() != 1) {
1635 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1636 Attr.setInvalid();
1637 return;
1638 }
Peter Collingbourne7a730022010-11-23 20:45:58 +00001639 Expr *priorityExpr = Attr.getArg(0);
Fariborz Jahanianb9d5c222010-06-18 23:14:53 +00001640
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00001641 llvm::APSInt priority(32);
1642 if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
1643 !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
1644 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1645 << "init_priority" << priorityExpr->getSourceRange();
1646 Attr.setInvalid();
1647 return;
1648 }
Fariborz Jahanian9f967c52010-06-21 18:45:05 +00001649 unsigned prioritynum = priority.getZExtValue();
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00001650 if (prioritynum < 101 || prioritynum > 65535) {
1651 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
1652 << priorityExpr->getSourceRange();
1653 Attr.setInvalid();
1654 return;
1655 }
Eric Christopherf48f3672010-12-01 22:13:54 +00001656 d->addAttr(::new (S.Context) InitPriorityAttr(Attr.getLoc(), S.Context,
1657 prioritynum));
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00001658}
1659
Mike Stumpbf916502009-07-24 19:02:52 +00001660/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
1661/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
Chris Lattner803d0802008-06-29 00:43:07 +00001662static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001663
Chris Lattner545dd342008-06-28 23:36:30 +00001664 if (!Attr.getParameterName()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001665 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00001666 << "format" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001667 return;
1668 }
1669
Chris Lattner545dd342008-06-28 23:36:30 +00001670 if (Attr.getNumArgs() != 2) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001671 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001672 return;
1673 }
1674
Fariborz Jahanian620d89c2009-05-15 23:15:03 +00001675 if (!isFunctionOrMethodOrBlock(d) || !hasFunctionProto(d)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001676 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00001677 << Attr.getName() << 0 /*function*/;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001678 return;
1679 }
1680
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001681 // In C++ the implicit 'this' function parameter also counts, and they are
1682 // counted from one.
1683 bool HasImplicitThisParam = isInstanceMethod(d);
1684 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001685 unsigned FirstIdx = 1;
1686
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00001687 llvm::StringRef Format = Attr.getParameterName()->getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001688
1689 // Normalize the argument, __foo__ becomes foo.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001690 if (Format.startswith("__") && Format.endswith("__"))
1691 Format = Format.substr(2, Format.size() - 4);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001692
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001693 // Check for supported formats.
1694 FormatAttrKind Kind = getFormatAttrKind(Format);
Chris Lattner3c989022010-03-22 21:08:50 +00001695
1696 if (Kind == IgnoredFormat)
1697 return;
1698
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001699 if (Kind == InvalidFormat) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001700 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00001701 << "format" << Attr.getParameterName()->getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001702 return;
1703 }
1704
1705 // checks for the 2nd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00001706 Expr *IdxExpr = Attr.getArg(0);
Chris Lattner803d0802008-06-29 00:43:07 +00001707 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001708 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
1709 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001710 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001711 << "format" << 2 << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001712 return;
1713 }
1714
1715 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001716 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner3c73c412008-11-19 08:23:25 +00001717 << "format" << 2 << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001718 return;
1719 }
1720
1721 // FIXME: Do we need to bounds check?
1722 unsigned ArgIdx = Idx.getZExtValue() - 1;
Mike Stumpbf916502009-07-24 19:02:52 +00001723
Sebastian Redl4a2614e2009-11-17 18:02:24 +00001724 if (HasImplicitThisParam) {
1725 if (ArgIdx == 0) {
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001726 S.Diag(Attr.getLoc(),
1727 diag::err_format_attribute_implicit_this_format_string)
1728 << IdxExpr->getSourceRange();
Sebastian Redl4a2614e2009-11-17 18:02:24 +00001729 return;
1730 }
1731 ArgIdx--;
1732 }
Mike Stump1eb44332009-09-09 15:08:12 +00001733
Chris Lattner6b6b5372008-06-26 18:38:35 +00001734 // make sure the format string is really a string
Daniel Dunbar35682492008-09-26 04:12:28 +00001735 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001736
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001737 if (Kind == CFStringFormat) {
Daniel Dunbar085e8f72008-09-26 03:32:58 +00001738 if (!isCFStringType(Ty, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001739 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1740 << "a CFString" << IdxExpr->getSourceRange();
Daniel Dunbar085e8f72008-09-26 03:32:58 +00001741 return;
1742 }
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001743 } else if (Kind == NSStringFormat) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001744 // FIXME: do we need to check if the type is NSString*? What are the
1745 // semantics?
Chris Lattner803d0802008-06-29 00:43:07 +00001746 if (!isNSStringType(Ty, S.Context)) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001747 // FIXME: Should highlight the actual expression that has the wrong type.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001748 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1749 << "an NSString" << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001750 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001751 }
Chris Lattner6b6b5372008-06-26 18:38:35 +00001752 } else if (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00001753 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001754 // FIXME: Should highlight the actual expression that has the wrong type.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001755 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
1756 << "a string type" << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001757 return;
1758 }
1759
1760 // check the 3rd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00001761 Expr *FirstArgExpr = Attr.getArg(1);
Chris Lattner803d0802008-06-29 00:43:07 +00001762 llvm::APSInt FirstArg(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001763 if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
1764 !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001765 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001766 << "format" << 3 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001767 return;
1768 }
1769
1770 // check if the function is variadic if the 3rd argument non-zero
1771 if (FirstArg != 0) {
Daniel Dunbar35682492008-09-26 04:12:28 +00001772 if (isFunctionOrMethodVariadic(d)) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001773 ++NumArgs; // +1 for ...
1774 } else {
Chris Lattner803d0802008-06-29 00:43:07 +00001775 S.Diag(d->getLocation(), diag::err_format_attribute_requires_variadic);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001776 return;
1777 }
1778 }
1779
Chris Lattner3c73c412008-11-19 08:23:25 +00001780 // strftime requires FirstArg to be 0 because it doesn't read from any
1781 // variable the input is just the current time + the format string.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001782 if (Kind == StrftimeFormat) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001783 if (FirstArg != 0) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001784 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
1785 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001786 return;
1787 }
1788 // if 0 it disables parameter checking (to use with e.g. va_list)
1789 } else if (FirstArg != 0 && FirstArg != NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001790 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner3c73c412008-11-19 08:23:25 +00001791 << "format" << 3 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00001792 return;
1793 }
1794
Sean Huntcf807c42010-08-18 23:23:40 +00001795 d->addAttr(::new (S.Context) FormatAttr(Attr.getLoc(), S.Context, Format,
1796 Idx.getZExtValue(),
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00001797 FirstArg.getZExtValue()));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001798}
1799
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001800static void HandleTransparentUnionAttr(Decl *d, const AttributeList &Attr,
1801 Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001802 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001803 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001804 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001805 return;
1806 }
1807
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001808 // Try to find the underlying union declaration.
1809 RecordDecl *RD = 0;
Eli Friedmanbc887452008-09-02 05:19:23 +00001810 TypedefDecl *TD = dyn_cast<TypedefDecl>(d);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001811 if (TD && TD->getUnderlyingType()->isUnionType())
1812 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
1813 else
1814 RD = dyn_cast<RecordDecl>(d);
1815
1816 if (!RD || !RD->isUnion()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001817 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00001818 << Attr.getName() << 1 /*union*/;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001819 return;
1820 }
1821
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001822 if (!RD->isDefinition()) {
Mike Stumpbf916502009-07-24 19:02:52 +00001823 S.Diag(Attr.getLoc(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001824 diag::warn_transparent_union_attribute_not_definition);
1825 return;
1826 }
Chris Lattner6b6b5372008-06-26 18:38:35 +00001827
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001828 RecordDecl::field_iterator Field = RD->field_begin(),
1829 FieldEnd = RD->field_end();
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001830 if (Field == FieldEnd) {
1831 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
1832 return;
1833 }
Eli Friedmanbc887452008-09-02 05:19:23 +00001834
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001835 FieldDecl *FirstField = *Field;
1836 QualType FirstType = FirstField->getType();
Douglas Gregor90cd6722010-06-30 17:24:13 +00001837 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
Mike Stumpbf916502009-07-24 19:02:52 +00001838 S.Diag(FirstField->getLocation(),
Douglas Gregor90cd6722010-06-30 17:24:13 +00001839 diag::warn_transparent_union_attribute_floating)
1840 << FirstType->isVectorType() << FirstType;
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001841 return;
1842 }
1843
1844 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
1845 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
1846 for (; Field != FieldEnd; ++Field) {
1847 QualType FieldType = Field->getType();
1848 if (S.Context.getTypeSize(FieldType) != FirstSize ||
1849 S.Context.getTypeAlign(FieldType) != FirstAlign) {
1850 // Warn if we drop the attribute.
1851 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
Mike Stumpbf916502009-07-24 19:02:52 +00001852 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001853 : S.Context.getTypeAlign(FieldType);
Mike Stumpbf916502009-07-24 19:02:52 +00001854 S.Diag(Field->getLocation(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001855 diag::warn_transparent_union_attribute_field_size_align)
1856 << isSize << Field->getDeclName() << FieldBits;
1857 unsigned FirstBits = isSize? FirstSize : FirstAlign;
Mike Stumpbf916502009-07-24 19:02:52 +00001858 S.Diag(FirstField->getLocation(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00001859 diag::note_transparent_union_first_field_size_align)
1860 << isSize << FirstBits;
Eli Friedmanbc887452008-09-02 05:19:23 +00001861 return;
1862 }
1863 }
1864
Sean Huntcf807c42010-08-18 23:23:40 +00001865 RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getLoc(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001866}
1867
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001868static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001869 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001870 if (Attr.getNumArgs() != 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001871 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001872 return;
1873 }
Peter Collingbourne7a730022010-11-23 20:45:58 +00001874 Expr *ArgExpr = Attr.getArg(0);
Chris Lattner797c3c42009-08-10 19:03:04 +00001875 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
Mike Stumpbf916502009-07-24 19:02:52 +00001876
Chris Lattner6b6b5372008-06-26 18:38:35 +00001877 // Make sure that there is a string literal as the annotation's single
1878 // argument.
1879 if (!SE) {
Chris Lattner797c3c42009-08-10 19:03:04 +00001880 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
Chris Lattner6b6b5372008-06-26 18:38:35 +00001881 return;
1882 }
Eric Christopherf48f3672010-12-01 22:13:54 +00001883 d->addAttr(::new (S.Context) AnnotateAttr(Attr.getLoc(), S.Context,
1884 SE->getString()));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001885}
1886
Chandler Carruth4ced79f2010-06-25 03:22:07 +00001887static void HandleAlignedAttr(Decl *D, const AttributeList &Attr, Sema &S) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001888 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001889 if (Attr.getNumArgs() > 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001890 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001891 return;
1892 }
Sean Huntbbd37c62009-11-21 08:43:09 +00001893
1894 //FIXME: The C++0x version of this attribute has more limited applicabilty
1895 // than GNU's, and should error out when it is used to specify a
1896 // weaker alignment, rather than being silently ignored.
Chris Lattner6b6b5372008-06-26 18:38:35 +00001897
Chris Lattner545dd342008-06-28 23:36:30 +00001898 if (Attr.getNumArgs() == 0) {
Sean Huntcf807c42010-08-18 23:23:40 +00001899 D->addAttr(::new (S.Context) AlignedAttr(Attr.getLoc(), S.Context, true, 0));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001900 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001901 }
Mike Stumpbf916502009-07-24 19:02:52 +00001902
Peter Collingbourne7a730022010-11-23 20:45:58 +00001903 S.AddAlignedAttr(Attr.getLoc(), D, Attr.getArg(0));
Chandler Carruth4ced79f2010-06-25 03:22:07 +00001904}
1905
1906void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, Expr *E) {
1907 if (E->isTypeDependent() || E->isValueDependent()) {
1908 // Save dependent expressions in the AST to be instantiated.
Sean Huntcf807c42010-08-18 23:23:40 +00001909 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
Chandler Carruth4ced79f2010-06-25 03:22:07 +00001910 return;
1911 }
1912
Sean Huntcf807c42010-08-18 23:23:40 +00001913 // FIXME: Cache the number on the Attr object?
Chris Lattner49e2d342008-06-28 23:50:44 +00001914 llvm::APSInt Alignment(32);
Chandler Carruth4ced79f2010-06-25 03:22:07 +00001915 if (!E->isIntegerConstantExpr(Alignment, Context)) {
1916 Diag(AttrLoc, diag::err_attribute_argument_not_int)
1917 << "aligned" << E->getSourceRange();
Chris Lattner49e2d342008-06-28 23:50:44 +00001918 return;
1919 }
Daniel Dunbar396b2a22009-02-16 23:37:57 +00001920 if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
Chandler Carruth4ced79f2010-06-25 03:22:07 +00001921 Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
1922 << E->getSourceRange();
Daniel Dunbar396b2a22009-02-16 23:37:57 +00001923 return;
1924 }
1925
Sean Huntcf807c42010-08-18 23:23:40 +00001926 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E));
1927}
1928
1929void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, TypeSourceInfo *TS) {
1930 // FIXME: Cache the number on the Attr object if non-dependent?
1931 // FIXME: Perform checking of type validity
1932 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, false, TS));
1933 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001934}
Chris Lattnerfbf13472008-06-27 22:18:37 +00001935
Mike Stumpbf916502009-07-24 19:02:52 +00001936/// HandleModeAttr - This attribute modifies the width of a decl with primitive
1937/// type.
Chris Lattnerfbf13472008-06-27 22:18:37 +00001938///
Mike Stumpbf916502009-07-24 19:02:52 +00001939/// Despite what would be logical, the mode attribute is a decl attribute, not a
1940/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
1941/// HImode, not an intermediate pointer.
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001942static void HandleModeAttr(Decl *D, const AttributeList &Attr, Sema &S) {
Chris Lattnerfbf13472008-06-27 22:18:37 +00001943 // This attribute isn't documented, but glibc uses it. It changes
1944 // the width of an int or unsigned int to the specified size.
1945
1946 // Check that there aren't any arguments
1947 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001948 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattnerfbf13472008-06-27 22:18:37 +00001949 return;
1950 }
1951
1952 IdentifierInfo *Name = Attr.getParameterName();
1953 if (!Name) {
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001954 S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
Chris Lattnerfbf13472008-06-27 22:18:37 +00001955 return;
1956 }
Daniel Dunbar210ae982009-10-18 02:09:24 +00001957
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00001958 llvm::StringRef Str = Attr.getParameterName()->getName();
Chris Lattnerfbf13472008-06-27 22:18:37 +00001959
1960 // Normalize the attribute name, __foo__ becomes foo.
Daniel Dunbar210ae982009-10-18 02:09:24 +00001961 if (Str.startswith("__") && Str.endswith("__"))
1962 Str = Str.substr(2, Str.size() - 4);
Chris Lattnerfbf13472008-06-27 22:18:37 +00001963
1964 unsigned DestWidth = 0;
1965 bool IntegerMode = true;
Eli Friedman73397492009-03-03 06:41:03 +00001966 bool ComplexMode = false;
Daniel Dunbar210ae982009-10-18 02:09:24 +00001967 switch (Str.size()) {
Chris Lattnerfbf13472008-06-27 22:18:37 +00001968 case 2:
Eli Friedman73397492009-03-03 06:41:03 +00001969 switch (Str[0]) {
1970 case 'Q': DestWidth = 8; break;
1971 case 'H': DestWidth = 16; break;
1972 case 'S': DestWidth = 32; break;
1973 case 'D': DestWidth = 64; break;
1974 case 'X': DestWidth = 96; break;
1975 case 'T': DestWidth = 128; break;
1976 }
1977 if (Str[1] == 'F') {
1978 IntegerMode = false;
1979 } else if (Str[1] == 'C') {
1980 IntegerMode = false;
1981 ComplexMode = true;
1982 } else if (Str[1] != 'I') {
1983 DestWidth = 0;
1984 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00001985 break;
1986 case 4:
1987 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
1988 // pointer on PIC16 and other embedded platforms.
Daniel Dunbar210ae982009-10-18 02:09:24 +00001989 if (Str == "word")
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001990 DestWidth = S.Context.Target.getPointerWidth(0);
Daniel Dunbar210ae982009-10-18 02:09:24 +00001991 else if (Str == "byte")
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001992 DestWidth = S.Context.Target.getCharWidth();
Chris Lattnerfbf13472008-06-27 22:18:37 +00001993 break;
1994 case 7:
Daniel Dunbar210ae982009-10-18 02:09:24 +00001995 if (Str == "pointer")
Chris Lattner0b2f4da2008-06-29 00:28:59 +00001996 DestWidth = S.Context.Target.getPointerWidth(0);
Chris Lattnerfbf13472008-06-27 22:18:37 +00001997 break;
1998 }
1999
2000 QualType OldTy;
2001 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D))
2002 OldTy = TD->getUnderlyingType();
2003 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
2004 OldTy = VD->getType();
2005 else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002006 S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
2007 << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc());
Chris Lattnerfbf13472008-06-27 22:18:37 +00002008 return;
2009 }
Eli Friedman73397492009-03-03 06:41:03 +00002010
John McCall183700f2009-09-21 23:43:11 +00002011 if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
Eli Friedman73397492009-03-03 06:41:03 +00002012 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
2013 else if (IntegerMode) {
Douglas Gregor2ade35e2010-06-16 00:17:44 +00002014 if (!OldTy->isIntegralOrEnumerationType())
Eli Friedman73397492009-03-03 06:41:03 +00002015 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2016 } else if (ComplexMode) {
2017 if (!OldTy->isComplexType())
2018 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2019 } else {
2020 if (!OldTy->isFloatingType())
2021 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
2022 }
2023
Mike Stump390b4cc2009-05-16 07:39:55 +00002024 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
2025 // and friends, at least with glibc.
2026 // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
2027 // width on unusual platforms.
Eli Friedmanf98aba32009-02-13 02:31:07 +00002028 // FIXME: Make sure floating-point mappings are accurate
2029 // FIXME: Support XF and TF types
Chris Lattnerfbf13472008-06-27 22:18:37 +00002030 QualType NewTy;
2031 switch (DestWidth) {
2032 case 0:
Chris Lattner3c73c412008-11-19 08:23:25 +00002033 S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002034 return;
2035 default:
Chris Lattner3c73c412008-11-19 08:23:25 +00002036 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002037 return;
2038 case 8:
Eli Friedman73397492009-03-03 06:41:03 +00002039 if (!IntegerMode) {
2040 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2041 return;
2042 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00002043 if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002044 NewTy = S.Context.SignedCharTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002045 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002046 NewTy = S.Context.UnsignedCharTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002047 break;
2048 case 16:
Eli Friedman73397492009-03-03 06:41:03 +00002049 if (!IntegerMode) {
2050 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2051 return;
2052 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00002053 if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002054 NewTy = S.Context.ShortTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002055 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002056 NewTy = S.Context.UnsignedShortTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002057 break;
2058 case 32:
2059 if (!IntegerMode)
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002060 NewTy = S.Context.FloatTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002061 else if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002062 NewTy = S.Context.IntTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002063 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002064 NewTy = S.Context.UnsignedIntTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002065 break;
2066 case 64:
2067 if (!IntegerMode)
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002068 NewTy = S.Context.DoubleTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002069 else if (OldTy->isSignedIntegerType())
Chandler Carruthaec7caa2010-01-26 06:39:24 +00002070 if (S.Context.Target.getLongWidth() == 64)
2071 NewTy = S.Context.LongTy;
2072 else
2073 NewTy = S.Context.LongLongTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002074 else
Chandler Carruthaec7caa2010-01-26 06:39:24 +00002075 if (S.Context.Target.getLongWidth() == 64)
2076 NewTy = S.Context.UnsignedLongTy;
2077 else
2078 NewTy = S.Context.UnsignedLongLongTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002079 break;
Eli Friedman73397492009-03-03 06:41:03 +00002080 case 96:
2081 NewTy = S.Context.LongDoubleTy;
2082 break;
Eli Friedmanf98aba32009-02-13 02:31:07 +00002083 case 128:
2084 if (!IntegerMode) {
2085 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
2086 return;
2087 }
Anders Carlssonf5f7d862009-12-29 07:07:36 +00002088 if (OldTy->isSignedIntegerType())
2089 NewTy = S.Context.Int128Ty;
2090 else
2091 NewTy = S.Context.UnsignedInt128Ty;
Eli Friedman73397492009-03-03 06:41:03 +00002092 break;
Chris Lattnerfbf13472008-06-27 22:18:37 +00002093 }
2094
Eli Friedman73397492009-03-03 06:41:03 +00002095 if (ComplexMode) {
2096 NewTy = S.Context.getComplexType(NewTy);
Chris Lattnerfbf13472008-06-27 22:18:37 +00002097 }
2098
2099 // Install the new type.
John McCallba6a9bd2009-10-24 08:00:42 +00002100 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
2101 // FIXME: preserve existing source info.
John McCalla93c9342009-12-07 02:54:59 +00002102 TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
John McCallba6a9bd2009-10-24 08:00:42 +00002103 } else
Chris Lattnerfbf13472008-06-27 22:18:37 +00002104 cast<ValueDecl>(D)->setType(NewTy);
2105}
Chris Lattner0744e5f2008-06-29 00:23:49 +00002106
Mike Stump1feade82009-08-26 22:31:08 +00002107static void HandleNoDebugAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Anders Carlssond87df372009-02-13 06:46:13 +00002108 // check the attribute arguments.
2109 if (Attr.getNumArgs() > 0) {
2110 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2111 return;
2112 }
Anders Carlssone896d982009-02-13 08:11:52 +00002113
Anders Carlsson5bab7882009-02-19 19:16:48 +00002114 if (!isFunctionOrMethod(d)) {
Anders Carlssond87df372009-02-13 06:46:13 +00002115 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002116 << Attr.getName() << 0 /*function*/;
Anders Carlssond87df372009-02-13 06:46:13 +00002117 return;
2118 }
Mike Stumpbf916502009-07-24 19:02:52 +00002119
Sean Huntcf807c42010-08-18 23:23:40 +00002120 d->addAttr(::new (S.Context) NoDebugAttr(Attr.getLoc(), S.Context));
Anders Carlssond87df372009-02-13 06:46:13 +00002121}
2122
Mike Stump1feade82009-08-26 22:31:08 +00002123static void HandleNoInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Anders Carlsson5bab7882009-02-19 19:16:48 +00002124 // check the attribute arguments.
2125 if (Attr.getNumArgs() != 0) {
2126 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2127 return;
2128 }
Mike Stumpbf916502009-07-24 19:02:52 +00002129
Chris Lattnerc5197432009-04-14 17:02:11 +00002130 if (!isa<FunctionDecl>(d)) {
Anders Carlsson5bab7882009-02-19 19:16:48 +00002131 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002132 << Attr.getName() << 0 /*function*/;
Anders Carlsson5bab7882009-02-19 19:16:48 +00002133 return;
2134 }
Mike Stumpbf916502009-07-24 19:02:52 +00002135
Sean Huntcf807c42010-08-18 23:23:40 +00002136 d->addAttr(::new (S.Context) NoInlineAttr(Attr.getLoc(), S.Context));
Anders Carlsson5bab7882009-02-19 19:16:48 +00002137}
2138
Chris Lattner7255a2d2010-06-22 00:03:40 +00002139static void HandleNoInstrumentFunctionAttr(Decl *d, const AttributeList &Attr,
2140 Sema &S) {
2141 // check the attribute arguments.
2142 if (Attr.getNumArgs() != 0) {
2143 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2144 return;
2145 }
2146
2147 if (!isa<FunctionDecl>(d)) {
2148 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2149 << Attr.getName() << 0 /*function*/;
2150 return;
2151 }
2152
Eric Christopherf48f3672010-12-01 22:13:54 +00002153 d->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getLoc(),
2154 S.Context));
Chris Lattner7255a2d2010-06-22 00:03:40 +00002155}
2156
Peter Collingbourneced76712010-12-01 03:15:31 +00002157static void HandleConstantAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2158 if (S.LangOpts.CUDA) {
2159 // check the attribute arguments.
2160 if (Attr.getNumArgs() != 0) {
2161 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2162 return;
2163 }
2164
2165 if (!isa<VarDecl>(d)) {
2166 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2167 << Attr.getName() << 12 /*variable*/;
2168 return;
2169 }
2170
2171 d->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getLoc(), S.Context));
2172 } else {
2173 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
2174 }
2175}
2176
2177static void HandleDeviceAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2178 if (S.LangOpts.CUDA) {
2179 // check the attribute arguments.
2180 if (Attr.getNumArgs() != 0) {
2181 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2182 return;
2183 }
2184
2185 if (!isa<FunctionDecl>(d) && !isa<VarDecl>(d)) {
2186 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2187 << Attr.getName() << 2 /*variable and function*/;
2188 return;
2189 }
2190
2191 d->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getLoc(), S.Context));
2192 } else {
2193 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
2194 }
2195}
2196
2197static void HandleGlobalAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2198 if (S.LangOpts.CUDA) {
2199 // check the attribute arguments.
2200 if (Attr.getNumArgs() != 0) {
2201 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2202 return;
2203 }
2204
2205 if (!isa<FunctionDecl>(d)) {
2206 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2207 << Attr.getName() << 0 /*function*/;
2208 return;
2209 }
2210
Peter Collingbourne2c2c8dd2010-12-12 23:02:57 +00002211 FunctionDecl *FD = cast<FunctionDecl>(d);
2212 if (!FD->getResultType()->isVoidType()) {
Abramo Bagnara723df242010-12-14 22:11:44 +00002213 TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
Peter Collingbourne2c2c8dd2010-12-12 23:02:57 +00002214 if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
2215 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2216 << FD->getType()
2217 << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
2218 "void");
2219 } else {
2220 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
2221 << FD->getType();
2222 }
2223 return;
2224 }
2225
Peter Collingbourneced76712010-12-01 03:15:31 +00002226 d->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getLoc(), S.Context));
2227 } else {
2228 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
2229 }
2230}
2231
2232static void HandleHostAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2233 if (S.LangOpts.CUDA) {
2234 // check the attribute arguments.
2235 if (Attr.getNumArgs() != 0) {
2236 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2237 return;
2238 }
2239
2240 if (!isa<FunctionDecl>(d)) {
2241 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2242 << Attr.getName() << 0 /*function*/;
2243 return;
2244 }
2245
2246 d->addAttr(::new (S.Context) CUDAHostAttr(Attr.getLoc(), S.Context));
2247 } else {
2248 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
2249 }
2250}
2251
2252static void HandleSharedAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2253 if (S.LangOpts.CUDA) {
2254 // check the attribute arguments.
2255 if (Attr.getNumArgs() != 0) {
2256 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2257 return;
2258 }
2259
2260 if (!isa<VarDecl>(d)) {
2261 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2262 << Attr.getName() << 12 /*variable*/;
2263 return;
2264 }
2265
2266 d->addAttr(::new (S.Context) CUDASharedAttr(Attr.getLoc(), S.Context));
2267 } else {
2268 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
2269 }
2270}
2271
Chris Lattnercf2a7212009-04-20 19:12:28 +00002272static void HandleGNUInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) {
Chris Lattner26e25542009-04-14 16:30:50 +00002273 // check the attribute arguments.
2274 if (Attr.getNumArgs() != 0) {
2275 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2276 return;
2277 }
Mike Stumpbf916502009-07-24 19:02:52 +00002278
Chris Lattnerc5197432009-04-14 17:02:11 +00002279 FunctionDecl *Fn = dyn_cast<FunctionDecl>(d);
2280 if (Fn == 0) {
Chris Lattner26e25542009-04-14 16:30:50 +00002281 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002282 << Attr.getName() << 0 /*function*/;
Chris Lattner26e25542009-04-14 16:30:50 +00002283 return;
2284 }
Mike Stumpbf916502009-07-24 19:02:52 +00002285
Douglas Gregor0130f3c2009-10-27 21:01:01 +00002286 if (!Fn->isInlineSpecified()) {
Chris Lattnercf2a7212009-04-20 19:12:28 +00002287 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
Chris Lattnerc5197432009-04-14 17:02:11 +00002288 return;
2289 }
Mike Stumpbf916502009-07-24 19:02:52 +00002290
Sean Huntcf807c42010-08-18 23:23:40 +00002291 d->addAttr(::new (S.Context) GNUInlineAttr(Attr.getLoc(), S.Context));
Chris Lattner26e25542009-04-14 16:30:50 +00002292}
2293
John McCall711c52b2011-01-05 12:14:39 +00002294static void HandleCallConvAttr(Decl *d, const AttributeList &attr, Sema &S) {
2295 if (hasDeclarator(d)) return;
Abramo Bagnarae215f722010-04-30 13:10:51 +00002296
John McCall711c52b2011-01-05 12:14:39 +00002297 // Diagnostic is emitted elsewhere: here we store the (valid) attr
2298 // in the Decl node for syntactic reasoning, e.g., pretty-printing.
2299 CallingConv CC;
2300 if (S.CheckCallingConvAttr(attr, CC))
2301 return;
2302
2303 if (!isa<ObjCMethodDecl>(d)) {
2304 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2305 << attr.getName() << 0 /*function*/;
2306 return;
2307 }
2308
2309 switch (attr.getKind()) {
Abramo Bagnarae215f722010-04-30 13:10:51 +00002310 case AttributeList::AT_fastcall:
John McCall711c52b2011-01-05 12:14:39 +00002311 d->addAttr(::new (S.Context) FastCallAttr(attr.getLoc(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00002312 return;
2313 case AttributeList::AT_stdcall:
John McCall711c52b2011-01-05 12:14:39 +00002314 d->addAttr(::new (S.Context) StdCallAttr(attr.getLoc(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00002315 return;
Douglas Gregorf813a2c2010-05-18 16:57:00 +00002316 case AttributeList::AT_thiscall:
John McCall711c52b2011-01-05 12:14:39 +00002317 d->addAttr(::new (S.Context) ThisCallAttr(attr.getLoc(), S.Context));
Douglas Gregor04633eb2010-08-30 23:30:49 +00002318 return;
Abramo Bagnarae215f722010-04-30 13:10:51 +00002319 case AttributeList::AT_cdecl:
John McCall711c52b2011-01-05 12:14:39 +00002320 d->addAttr(::new (S.Context) CDeclAttr(attr.getLoc(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00002321 return;
Dawn Perchik52fc3142010-09-03 01:29:35 +00002322 case AttributeList::AT_pascal:
John McCall711c52b2011-01-05 12:14:39 +00002323 d->addAttr(::new (S.Context) PascalAttr(attr.getLoc(), S.Context));
Dawn Perchik52fc3142010-09-03 01:29:35 +00002324 return;
Abramo Bagnarae215f722010-04-30 13:10:51 +00002325 default:
2326 llvm_unreachable("unexpected attribute kind");
2327 return;
2328 }
2329}
2330
Peter Collingbournef315fa82011-02-14 01:42:53 +00002331static void HandleOpenCLKernelAttr(Decl *d, const AttributeList &Attr, Sema &S){
2332 assert(Attr.isInvalid() == false);
2333 d->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getLoc(), S.Context));
2334}
2335
John McCall711c52b2011-01-05 12:14:39 +00002336bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
2337 if (attr.isInvalid())
2338 return true;
2339
2340 if (attr.getNumArgs() != 0) {
2341 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
2342 attr.setInvalid();
2343 return true;
2344 }
2345
2346 // TODO: diagnose uses of these conventions on the wrong target.
2347 switch (attr.getKind()) {
2348 case AttributeList::AT_cdecl: CC = CC_C; break;
2349 case AttributeList::AT_fastcall: CC = CC_X86FastCall; break;
2350 case AttributeList::AT_stdcall: CC = CC_X86StdCall; break;
2351 case AttributeList::AT_thiscall: CC = CC_X86ThisCall; break;
2352 case AttributeList::AT_pascal: CC = CC_X86Pascal; break;
2353 default: llvm_unreachable("unexpected attribute kind"); return true;
2354 }
2355
2356 return false;
2357}
2358
2359static void HandleRegparmAttr(Decl *d, const AttributeList &attr, Sema &S) {
2360 if (hasDeclarator(d)) return;
2361
2362 unsigned numParams;
2363 if (S.CheckRegparmAttr(attr, numParams))
2364 return;
2365
2366 if (!isa<ObjCMethodDecl>(d)) {
2367 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2368 << attr.getName() << 0 /*function*/;
Fariborz Jahanianee760332009-03-27 18:38:55 +00002369 return;
2370 }
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002371
John McCall711c52b2011-01-05 12:14:39 +00002372 d->addAttr(::new (S.Context) RegparmAttr(attr.getLoc(), S.Context, numParams));
2373}
2374
2375/// Checks a regparm attribute, returning true if it is ill-formed and
2376/// otherwise setting numParams to the appropriate value.
2377bool Sema::CheckRegparmAttr(const AttributeList &attr, unsigned &numParams) {
2378 if (attr.isInvalid())
2379 return true;
2380
2381 if (attr.getNumArgs() != 1) {
2382 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2383 attr.setInvalid();
2384 return true;
Fariborz Jahanianee760332009-03-27 18:38:55 +00002385 }
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002386
John McCall711c52b2011-01-05 12:14:39 +00002387 Expr *NumParamsExpr = attr.getArg(0);
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002388 llvm::APSInt NumParams(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002389 if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
John McCall711c52b2011-01-05 12:14:39 +00002390 !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
2391 Diag(attr.getLoc(), diag::err_attribute_argument_not_int)
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002392 << "regparm" << NumParamsExpr->getSourceRange();
John McCall711c52b2011-01-05 12:14:39 +00002393 attr.setInvalid();
2394 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002395 }
2396
John McCall711c52b2011-01-05 12:14:39 +00002397 if (Context.Target.getRegParmMax() == 0) {
2398 Diag(attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002399 << NumParamsExpr->getSourceRange();
John McCall711c52b2011-01-05 12:14:39 +00002400 attr.setInvalid();
2401 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002402 }
2403
John McCall711c52b2011-01-05 12:14:39 +00002404 numParams = NumParams.getZExtValue();
2405 if (numParams > Context.Target.getRegParmMax()) {
2406 Diag(attr.getLoc(), diag::err_attribute_regparm_invalid_number)
2407 << Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange();
2408 attr.setInvalid();
2409 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00002410 }
2411
John McCall711c52b2011-01-05 12:14:39 +00002412 return false;
Fariborz Jahanianee760332009-03-27 18:38:55 +00002413}
2414
Peter Collingbourne7b381982010-12-12 23:03:07 +00002415static void HandleLaunchBoundsAttr(Decl *d, const AttributeList &Attr, Sema &S){
2416 if (S.LangOpts.CUDA) {
2417 // check the attribute arguments.
2418 if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
2419 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2420 << "1 or 2";
2421 return;
2422 }
2423
2424 if (!isFunctionOrMethod(d)) {
2425 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2426 << Attr.getName() << 0 /*function*/;
2427 return;
2428 }
2429
2430 Expr *MaxThreadsExpr = Attr.getArg(0);
2431 llvm::APSInt MaxThreads(32);
2432 if (MaxThreadsExpr->isTypeDependent() ||
2433 MaxThreadsExpr->isValueDependent() ||
2434 !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
2435 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2436 << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
2437 return;
2438 }
2439
2440 llvm::APSInt MinBlocks(32);
2441 if (Attr.getNumArgs() > 1) {
2442 Expr *MinBlocksExpr = Attr.getArg(1);
2443 if (MinBlocksExpr->isTypeDependent() ||
2444 MinBlocksExpr->isValueDependent() ||
2445 !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
2446 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2447 << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
2448 return;
2449 }
2450 }
2451
2452 d->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getLoc(), S.Context,
2453 MaxThreads.getZExtValue(),
2454 MinBlocks.getZExtValue()));
2455 } else {
2456 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
2457 }
2458}
2459
Chris Lattner0744e5f2008-06-29 00:23:49 +00002460//===----------------------------------------------------------------------===//
Ted Kremenekb71368d2009-05-09 02:44:38 +00002461// Checker-specific attribute handlers.
2462//===----------------------------------------------------------------------===//
2463
John McCallc7ad3812011-01-25 03:31:58 +00002464static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
2465 return type->isObjCObjectPointerType() || S.Context.isObjCNSObjectType(type);
2466}
2467static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
2468 return type->isPointerType() || isValidSubjectOfNSAttribute(S, type);
2469}
2470
2471static void HandleNSConsumedAttr(Decl *d, const AttributeList &attr, Sema &S) {
2472 ParmVarDecl *param = dyn_cast<ParmVarDecl>(d);
2473 if (!param) {
2474 S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type)
2475 << SourceRange(attr.getLoc()) << attr.getName() << 4 /*parameter*/;
2476 return;
2477 }
2478
2479 bool typeOK, cf;
2480 if (attr.getKind() == AttributeList::AT_ns_consumed) {
2481 typeOK = isValidSubjectOfNSAttribute(S, param->getType());
2482 cf = false;
2483 } else {
2484 typeOK = isValidSubjectOfCFAttribute(S, param->getType());
2485 cf = true;
2486 }
2487
2488 if (!typeOK) {
2489 S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
2490 << SourceRange(attr.getLoc()) << attr.getName() << cf;
2491 return;
2492 }
2493
2494 if (cf)
2495 param->addAttr(::new (S.Context) CFConsumedAttr(attr.getLoc(), S.Context));
2496 else
2497 param->addAttr(::new (S.Context) NSConsumedAttr(attr.getLoc(), S.Context));
2498}
2499
2500static void HandleNSConsumesSelfAttr(Decl *d, const AttributeList &attr,
2501 Sema &S) {
2502 if (!isa<ObjCMethodDecl>(d)) {
2503 S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type)
2504 << SourceRange(attr.getLoc()) << attr.getName() << 13 /*method*/;
2505 return;
2506 }
2507
2508 d->addAttr(::new (S.Context) NSConsumesSelfAttr(attr.getLoc(), S.Context));
2509}
2510
2511static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &attr,
Ted Kremenekb71368d2009-05-09 02:44:38 +00002512 Sema &S) {
2513
John McCallc7ad3812011-01-25 03:31:58 +00002514 QualType returnType;
Mike Stumpbf916502009-07-24 19:02:52 +00002515
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002516 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d))
John McCallc7ad3812011-01-25 03:31:58 +00002517 returnType = MD->getResultType();
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002518 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d))
John McCallc7ad3812011-01-25 03:31:58 +00002519 returnType = FD->getResultType();
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002520 else {
Ted Kremenek21531fa2009-08-19 23:56:48 +00002521 S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type)
John McCallc7ad3812011-01-25 03:31:58 +00002522 << SourceRange(attr.getLoc()) << attr.getName()
2523 << 3 /* function or method */;
Ted Kremenekb71368d2009-05-09 02:44:38 +00002524 return;
2525 }
Mike Stumpbf916502009-07-24 19:02:52 +00002526
John McCallc7ad3812011-01-25 03:31:58 +00002527 bool typeOK;
2528 bool cf;
2529 switch (attr.getKind()) {
2530 default: llvm_unreachable("invalid ownership attribute"); return;
2531 case AttributeList::AT_ns_returns_autoreleased:
2532 case AttributeList::AT_ns_returns_retained:
2533 case AttributeList::AT_ns_returns_not_retained:
2534 typeOK = isValidSubjectOfNSAttribute(S, returnType);
2535 cf = false;
2536 break;
2537
2538 case AttributeList::AT_cf_returns_retained:
2539 case AttributeList::AT_cf_returns_not_retained:
2540 typeOK = isValidSubjectOfCFAttribute(S, returnType);
2541 cf = true;
2542 break;
2543 }
2544
2545 if (!typeOK) {
Ted Kremenek21531fa2009-08-19 23:56:48 +00002546 S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
John McCallc7ad3812011-01-25 03:31:58 +00002547 << SourceRange(attr.getLoc())
2548 << attr.getName() << isa<ObjCMethodDecl>(d) << cf;
Mike Stumpbf916502009-07-24 19:02:52 +00002549 return;
Ted Kremenek5dc53c92009-05-13 21:07:32 +00002550 }
Mike Stumpbf916502009-07-24 19:02:52 +00002551
John McCallc7ad3812011-01-25 03:31:58 +00002552 switch (attr.getKind()) {
Ted Kremenekb71368d2009-05-09 02:44:38 +00002553 default:
2554 assert(0 && "invalid ownership attribute");
2555 return;
John McCallc7ad3812011-01-25 03:31:58 +00002556 case AttributeList::AT_ns_returns_autoreleased:
2557 d->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(attr.getLoc(),
2558 S.Context));
2559 return;
Ted Kremenek31c780d2010-02-18 00:05:45 +00002560 case AttributeList::AT_cf_returns_not_retained:
John McCallc7ad3812011-01-25 03:31:58 +00002561 d->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(attr.getLoc(),
Eric Christopherf48f3672010-12-01 22:13:54 +00002562 S.Context));
Ted Kremenek31c780d2010-02-18 00:05:45 +00002563 return;
2564 case AttributeList::AT_ns_returns_not_retained:
John McCallc7ad3812011-01-25 03:31:58 +00002565 d->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(attr.getLoc(),
Eric Christopherf48f3672010-12-01 22:13:54 +00002566 S.Context));
Ted Kremenek31c780d2010-02-18 00:05:45 +00002567 return;
Ted Kremenekb71368d2009-05-09 02:44:38 +00002568 case AttributeList::AT_cf_returns_retained:
John McCallc7ad3812011-01-25 03:31:58 +00002569 d->addAttr(::new (S.Context) CFReturnsRetainedAttr(attr.getLoc(),
Eric Christopherf48f3672010-12-01 22:13:54 +00002570 S.Context));
Ted Kremenekb71368d2009-05-09 02:44:38 +00002571 return;
2572 case AttributeList::AT_ns_returns_retained:
John McCallc7ad3812011-01-25 03:31:58 +00002573 d->addAttr(::new (S.Context) NSReturnsRetainedAttr(attr.getLoc(),
Eric Christopherf48f3672010-12-01 22:13:54 +00002574 S.Context));
Ted Kremenekb71368d2009-05-09 02:44:38 +00002575 return;
2576 };
2577}
2578
Charles Davisf0122fe2010-02-16 18:27:26 +00002579static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
2580 return Attr.getKind() == AttributeList::AT_dllimport ||
Francois Pichet11542142010-12-19 06:50:37 +00002581 Attr.getKind() == AttributeList::AT_dllexport ||
2582 Attr.getKind() == AttributeList::AT_uuid;
2583}
2584
2585//===----------------------------------------------------------------------===//
2586// Microsoft specific attribute handlers.
2587//===----------------------------------------------------------------------===//
2588
2589static void HandleUuidAttr(Decl *d, const AttributeList &Attr, Sema &S) {
2590 if (S.LangOpts.Microsoft || S.LangOpts.Borland) {
2591 // check the attribute arguments.
2592 if (Attr.getNumArgs() != 1) {
2593 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2594 return;
2595 }
2596 Expr *Arg = Attr.getArg(0);
2597 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Francois Pichetd3d3be92010-12-20 01:41:49 +00002598 if (Str == 0 || Str->isWide()) {
2599 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
2600 << "uuid" << 1;
2601 return;
2602 }
2603
2604 llvm::StringRef StrRef = Str->getString();
2605
2606 bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
2607 StrRef.back() == '}';
2608
2609 // Validate GUID length.
2610 if (IsCurly && StrRef.size() != 38) {
2611 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2612 return;
2613 }
2614 if (!IsCurly && StrRef.size() != 36) {
2615 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2616 return;
2617 }
2618
2619 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
2620 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
Anders Carlssonf89e0422011-01-23 21:07:30 +00002621 llvm::StringRef::iterator I = StrRef.begin();
2622 if (IsCurly) // Skip the optional '{'
2623 ++I;
2624
2625 for (int i = 0; i < 36; ++i) {
Francois Pichetd3d3be92010-12-20 01:41:49 +00002626 if (i == 8 || i == 13 || i == 18 || i == 23) {
2627 if (*I != '-') {
2628 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2629 return;
2630 }
2631 } else if (!isxdigit(*I)) {
2632 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
2633 return;
2634 }
2635 I++;
2636 }
Francois Pichet11542142010-12-19 06:50:37 +00002637
2638 d->addAttr(::new (S.Context) UuidAttr(Attr.getLoc(), S.Context,
2639 Str->getString()));
Francois Pichetd3d3be92010-12-20 01:41:49 +00002640 } else
Francois Pichet11542142010-12-19 06:50:37 +00002641 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
Charles Davisf0122fe2010-02-16 18:27:26 +00002642}
2643
Ted Kremenekb71368d2009-05-09 02:44:38 +00002644//===----------------------------------------------------------------------===//
Chris Lattner0744e5f2008-06-29 00:23:49 +00002645// Top Level Sema Entry Points
2646//===----------------------------------------------------------------------===//
2647
Peter Collingbourne60700392011-01-21 02:08:45 +00002648static void ProcessNonInheritableDeclAttr(Scope *scope, Decl *D,
2649 const AttributeList &Attr, Sema &S) {
2650 switch (Attr.getKind()) {
2651 case AttributeList::AT_device: HandleDeviceAttr (D, Attr, S); break;
2652 case AttributeList::AT_host: HandleHostAttr (D, Attr, S); break;
2653 case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break;
2654 default:
2655 break;
2656 }
2657}
Abramo Bagnarae215f722010-04-30 13:10:51 +00002658
Peter Collingbourne60700392011-01-21 02:08:45 +00002659static void ProcessInheritableDeclAttr(Scope *scope, Decl *D,
2660 const AttributeList &Attr, Sema &S) {
Chris Lattner803d0802008-06-29 00:43:07 +00002661 switch (Attr.getKind()) {
Ted Kremenek63e5d7c2010-02-18 03:08:58 +00002662 case AttributeList::AT_IBAction: HandleIBAction(D, Attr, S); break;
Ted Kremenek857e9182010-05-19 17:38:06 +00002663 case AttributeList::AT_IBOutlet: HandleIBOutlet(D, Attr, S); break;
2664 case AttributeList::AT_IBOutletCollection:
2665 HandleIBOutletCollection(D, Attr, S); break;
Chris Lattner803d0802008-06-29 00:43:07 +00002666 case AttributeList::AT_address_space:
Fariborz Jahanianba372b82009-02-18 17:52:36 +00002667 case AttributeList::AT_objc_gc:
John Thompson6e132aa2009-12-04 21:51:28 +00002668 case AttributeList::AT_vector_size:
Bob Wilson4211bb62010-11-16 00:32:24 +00002669 case AttributeList::AT_neon_vector_type:
2670 case AttributeList::AT_neon_polyvector_type:
Mike Stumpbf916502009-07-24 19:02:52 +00002671 // Ignore these, these are type attributes, handled by
2672 // ProcessTypeAttributes.
Chris Lattner803d0802008-06-29 00:43:07 +00002673 break;
Peter Collingbourne60700392011-01-21 02:08:45 +00002674 case AttributeList::AT_device:
2675 case AttributeList::AT_host:
2676 case AttributeList::AT_overloadable:
2677 // Ignore, this is a non-inheritable attribute, handled
2678 // by ProcessNonInheritableDeclAttr.
2679 break;
Sean Hunt7725e672009-11-25 04:20:27 +00002680 case AttributeList::AT_alias: HandleAliasAttr (D, Attr, S); break;
2681 case AttributeList::AT_aligned: HandleAlignedAttr (D, Attr, S); break;
Mike Stumpbf916502009-07-24 19:02:52 +00002682 case AttributeList::AT_always_inline:
Daniel Dunbaraf668b02008-10-28 00:17:57 +00002683 HandleAlwaysInlineAttr (D, Attr, S); break;
Ted Kremenekb7252322009-04-10 00:01:14 +00002684 case AttributeList::AT_analyzer_noreturn:
Mike Stumpbf916502009-07-24 19:02:52 +00002685 HandleAnalyzerNoReturnAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002686 case AttributeList::AT_annotate: HandleAnnotateAttr (D, Attr, S); break;
Sean Huntbbd37c62009-11-21 08:43:09 +00002687 case AttributeList::AT_carries_dependency:
Sean Hunt7725e672009-11-25 04:20:27 +00002688 HandleDependencyAttr (D, Attr, S); break;
Eric Christophera6cf1e72010-12-02 02:45:55 +00002689 case AttributeList::AT_common: HandleCommonAttr (D, Attr, S); break;
Peter Collingbourneced76712010-12-01 03:15:31 +00002690 case AttributeList::AT_constant: HandleConstantAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002691 case AttributeList::AT_constructor: HandleConstructorAttr (D, Attr, S); break;
2692 case AttributeList::AT_deprecated: HandleDeprecatedAttr (D, Attr, S); break;
2693 case AttributeList::AT_destructor: HandleDestructorAttr (D, Attr, S); break;
Chris Lattner803d0802008-06-29 00:43:07 +00002694 case AttributeList::AT_ext_vector_type:
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00002695 HandleExtVectorTypeAttr(scope, D, Attr, S);
Chris Lattner803d0802008-06-29 00:43:07 +00002696 break;
Sean Hunt7725e672009-11-25 04:20:27 +00002697 case AttributeList::AT_format: HandleFormatAttr (D, Attr, S); break;
2698 case AttributeList::AT_format_arg: HandleFormatArgAttr (D, Attr, S); break;
Peter Collingbourneced76712010-12-01 03:15:31 +00002699 case AttributeList::AT_global: HandleGlobalAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002700 case AttributeList::AT_gnu_inline: HandleGNUInlineAttr (D, Attr, S); break;
Peter Collingbourne7b381982010-12-12 23:03:07 +00002701 case AttributeList::AT_launch_bounds:
2702 HandleLaunchBoundsAttr(D, Attr, S);
2703 break;
Sean Hunt7725e672009-11-25 04:20:27 +00002704 case AttributeList::AT_mode: HandleModeAttr (D, Attr, S); break;
2705 case AttributeList::AT_malloc: HandleMallocAttr (D, Attr, S); break;
Dan Gohman34c26302010-11-17 00:03:07 +00002706 case AttributeList::AT_may_alias: HandleMayAliasAttr (D, Attr, S); break;
Eric Christophera6cf1e72010-12-02 02:45:55 +00002707 case AttributeList::AT_nocommon: HandleNoCommonAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002708 case AttributeList::AT_nonnull: HandleNonNullAttr (D, Attr, S); break;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00002709 case AttributeList::AT_ownership_returns:
2710 case AttributeList::AT_ownership_takes:
2711 case AttributeList::AT_ownership_holds:
2712 HandleOwnershipAttr (D, Attr, S); break;
Daniel Dunbardd0cb222010-09-29 18:20:25 +00002713 case AttributeList::AT_naked: HandleNakedAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002714 case AttributeList::AT_noreturn: HandleNoReturnAttr (D, Attr, S); break;
2715 case AttributeList::AT_nothrow: HandleNothrowAttr (D, Attr, S); break;
Peter Collingbourneced76712010-12-01 03:15:31 +00002716 case AttributeList::AT_shared: HandleSharedAttr (D, Attr, S); break;
John Thompson35cc9622010-08-09 21:53:52 +00002717 case AttributeList::AT_vecreturn: HandleVecReturnAttr (D, Attr, S); break;
Ted Kremenekb71368d2009-05-09 02:44:38 +00002718
2719 // Checker-specific.
John McCallc7ad3812011-01-25 03:31:58 +00002720 case AttributeList::AT_cf_consumed:
2721 case AttributeList::AT_ns_consumed: HandleNSConsumedAttr (D, Attr, S); break;
2722 case AttributeList::AT_ns_consumes_self:
2723 HandleNSConsumesSelfAttr(D, Attr, S); break;
2724
2725 case AttributeList::AT_ns_returns_autoreleased:
Ted Kremenek31c780d2010-02-18 00:05:45 +00002726 case AttributeList::AT_ns_returns_not_retained:
2727 case AttributeList::AT_cf_returns_not_retained:
Ted Kremenekb71368d2009-05-09 02:44:38 +00002728 case AttributeList::AT_ns_returns_retained:
2729 case AttributeList::AT_cf_returns_retained:
2730 HandleNSReturnsRetainedAttr(D, Attr, S); break;
2731
Nate Begeman6f3d8382009-06-26 06:32:41 +00002732 case AttributeList::AT_reqd_wg_size:
2733 HandleReqdWorkGroupSize(D, Attr, S); break;
2734
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002735 case AttributeList::AT_init_priority:
2736 HandleInitPriorityAttr(D, Attr, S); break;
2737
Sean Hunt7725e672009-11-25 04:20:27 +00002738 case AttributeList::AT_packed: HandlePackedAttr (D, Attr, S); break;
2739 case AttributeList::AT_section: HandleSectionAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002740 case AttributeList::AT_unavailable: HandleUnavailableAttr (D, Attr, S); break;
2741 case AttributeList::AT_unused: HandleUnusedAttr (D, Attr, S); break;
2742 case AttributeList::AT_used: HandleUsedAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002743 case AttributeList::AT_visibility: HandleVisibilityAttr (D, Attr, S); break;
Chris Lattner026dc962009-02-14 07:37:35 +00002744 case AttributeList::AT_warn_unused_result: HandleWarnUnusedResult(D,Attr,S);
2745 break;
Sean Hunt7725e672009-11-25 04:20:27 +00002746 case AttributeList::AT_weak: HandleWeakAttr (D, Attr, S); break;
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002747 case AttributeList::AT_weakref: HandleWeakRefAttr (D, Attr, S); break;
Sean Hunt7725e672009-11-25 04:20:27 +00002748 case AttributeList::AT_weak_import: HandleWeakImportAttr (D, Attr, S); break;
Chris Lattner803d0802008-06-29 00:43:07 +00002749 case AttributeList::AT_transparent_union:
2750 HandleTransparentUnionAttr(D, Attr, S);
2751 break;
Chris Lattner0db29ec2009-02-14 08:09:34 +00002752 case AttributeList::AT_objc_exception:
2753 HandleObjCExceptionAttr(D, Attr, S);
2754 break;
Sean Hunt7725e672009-11-25 04:20:27 +00002755 case AttributeList::AT_nsobject: HandleObjCNSObject (D, Attr, S); break;
2756 case AttributeList::AT_blocks: HandleBlocksAttr (D, Attr, S); break;
2757 case AttributeList::AT_sentinel: HandleSentinelAttr (D, Attr, S); break;
2758 case AttributeList::AT_const: HandleConstAttr (D, Attr, S); break;
2759 case AttributeList::AT_pure: HandlePureAttr (D, Attr, S); break;
2760 case AttributeList::AT_cleanup: HandleCleanupAttr (D, Attr, S); break;
2761 case AttributeList::AT_nodebug: HandleNoDebugAttr (D, Attr, S); break;
2762 case AttributeList::AT_noinline: HandleNoInlineAttr (D, Attr, S); break;
2763 case AttributeList::AT_regparm: HandleRegparmAttr (D, Attr, S); break;
Mike Stumpbf916502009-07-24 19:02:52 +00002764 case AttributeList::IgnoredAttribute:
Anders Carlsson05f8e472009-02-13 08:16:43 +00002765 // Just ignore
2766 break;
Chris Lattner7255a2d2010-06-22 00:03:40 +00002767 case AttributeList::AT_no_instrument_function: // Interacts with -pg.
2768 HandleNoInstrumentFunctionAttr(D, Attr, S);
2769 break;
John McCall04a67a62010-02-05 21:31:56 +00002770 case AttributeList::AT_stdcall:
2771 case AttributeList::AT_cdecl:
2772 case AttributeList::AT_fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00002773 case AttributeList::AT_thiscall:
Dawn Perchik52fc3142010-09-03 01:29:35 +00002774 case AttributeList::AT_pascal:
Abramo Bagnarae215f722010-04-30 13:10:51 +00002775 HandleCallConvAttr(D, Attr, S);
John McCall04a67a62010-02-05 21:31:56 +00002776 break;
Peter Collingbournef315fa82011-02-14 01:42:53 +00002777 case AttributeList::AT_opencl_kernel_function:
2778 HandleOpenCLKernelAttr(D, Attr, S);
2779 break;
Francois Pichet11542142010-12-19 06:50:37 +00002780 case AttributeList::AT_uuid:
2781 HandleUuidAttr(D, Attr, S);
2782 break;
Chris Lattner803d0802008-06-29 00:43:07 +00002783 default:
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00002784 // Ask target about the attribute.
2785 const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
2786 if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
Chandler Carruth7d5c45e2010-07-08 09:42:26 +00002787 S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored)
2788 << Attr.getName();
Chris Lattner803d0802008-06-29 00:43:07 +00002789 break;
2790 }
2791}
2792
Peter Collingbourne60700392011-01-21 02:08:45 +00002793/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
2794/// the attribute applies to decls. If the attribute is a type attribute, just
2795/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
2796/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
2797static void ProcessDeclAttribute(Scope *scope, Decl *D,
2798 const AttributeList &Attr, Sema &S,
2799 bool NonInheritable, bool Inheritable) {
2800 if (Attr.isInvalid())
2801 return;
2802
2803 if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
2804 // FIXME: Try to deal with other __declspec attributes!
2805 return;
2806
2807 if (NonInheritable)
2808 ProcessNonInheritableDeclAttr(scope, D, Attr, S);
2809
2810 if (Inheritable)
2811 ProcessInheritableDeclAttr(scope, D, Attr, S);
2812}
2813
Chris Lattner803d0802008-06-29 00:43:07 +00002814/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
2815/// attribute list to the specified decl, ignoring any type attributes.
Eric Christopherf48f3672010-12-01 22:13:54 +00002816void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
Peter Collingbourne60700392011-01-21 02:08:45 +00002817 const AttributeList *AttrList,
2818 bool NonInheritable, bool Inheritable) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002819 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
Peter Collingbourne60700392011-01-21 02:08:45 +00002820 ProcessDeclAttribute(S, D, *l, *this, NonInheritable, Inheritable);
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002821 }
2822
2823 // GCC accepts
2824 // static int a9 __attribute__((weakref));
2825 // but that looks really pointless. We reject it.
Peter Collingbourne60700392011-01-21 02:08:45 +00002826 if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002827 Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
Ted Kremenekdd0e4902010-07-31 01:52:11 +00002828 dyn_cast<NamedDecl>(D)->getNameAsString();
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002829 return;
Chris Lattner803d0802008-06-29 00:43:07 +00002830 }
2831}
2832
Ryan Flynne25ff832009-07-30 03:15:39 +00002833/// DeclClonePragmaWeak - clone existing decl (maybe definition),
2834/// #pragma weak needs a non-definition decl and source may not have one
Mike Stump1eb44332009-09-09 15:08:12 +00002835NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) {
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00002836 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
Ryan Flynne25ff832009-07-30 03:15:39 +00002837 NamedDecl *NewD = 0;
2838 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
2839 NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
2840 FD->getLocation(), DeclarationName(II),
John McCalla93c9342009-12-07 02:54:59 +00002841 FD->getType(), FD->getTypeSourceInfo());
John McCallb6217662010-03-15 10:12:16 +00002842 if (FD->getQualifier()) {
2843 FunctionDecl *NewFD = cast<FunctionDecl>(NewD);
2844 NewFD->setQualifierInfo(FD->getQualifier(), FD->getQualifierRange());
2845 }
Ryan Flynne25ff832009-07-30 03:15:39 +00002846 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
2847 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
2848 VD->getLocation(), II,
John McCalla93c9342009-12-07 02:54:59 +00002849 VD->getType(), VD->getTypeSourceInfo(),
Douglas Gregor16573fa2010-04-19 22:54:31 +00002850 VD->getStorageClass(),
2851 VD->getStorageClassAsWritten());
John McCallb6217662010-03-15 10:12:16 +00002852 if (VD->getQualifier()) {
2853 VarDecl *NewVD = cast<VarDecl>(NewD);
2854 NewVD->setQualifierInfo(VD->getQualifier(), VD->getQualifierRange());
2855 }
Ryan Flynne25ff832009-07-30 03:15:39 +00002856 }
2857 return NewD;
2858}
2859
2860/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak
2861/// applied to it, possibly with an alias.
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00002862void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
Chris Lattnerc4f1fb12009-09-08 18:10:11 +00002863 if (W.getUsed()) return; // only do this once
2864 W.setUsed(true);
2865 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
2866 IdentifierInfo *NDId = ND->getIdentifier();
2867 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias());
Sean Huntcf807c42010-08-18 23:23:40 +00002868 NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
2869 NDId->getName()));
2870 NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
Chris Lattnerc4f1fb12009-09-08 18:10:11 +00002871 WeakTopLevelDecl.push_back(NewD);
2872 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
2873 // to insert Decl at TU scope, sorry.
2874 DeclContext *SavedContext = CurContext;
2875 CurContext = Context.getTranslationUnitDecl();
2876 PushOnScopeChains(NewD, S);
2877 CurContext = SavedContext;
2878 } else { // just add weak to existing
Sean Huntcf807c42010-08-18 23:23:40 +00002879 ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
Ryan Flynne25ff832009-07-30 03:15:39 +00002880 }
2881}
2882
Chris Lattner0744e5f2008-06-29 00:23:49 +00002883/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
2884/// it, apply them to D. This is a bit tricky because PD can have attributes
2885/// specified in many different places, and we need to find and apply them all.
Peter Collingbourne60700392011-01-21 02:08:45 +00002886void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
2887 bool NonInheritable, bool Inheritable) {
John McCalld4aff0e2010-10-27 00:59:00 +00002888 // It's valid to "forward-declare" #pragma weak, in which case we
2889 // have to do this.
Peter Collingbourne60700392011-01-21 02:08:45 +00002890 if (Inheritable && !WeakUndeclaredIdentifiers.empty()) {
John McCalld4aff0e2010-10-27 00:59:00 +00002891 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
2892 if (IdentifierInfo *Id = ND->getIdentifier()) {
2893 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
2894 = WeakUndeclaredIdentifiers.find(Id);
2895 if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
2896 WeakInfo W = I->second;
2897 DeclApplyPragmaWeak(S, ND, W);
2898 WeakUndeclaredIdentifiers[Id] = W;
2899 }
Ryan Flynne25ff832009-07-30 03:15:39 +00002900 }
2901 }
2902 }
2903
Chris Lattner0744e5f2008-06-29 00:23:49 +00002904 // Apply decl attributes from the DeclSpec if present.
John McCall7f040a92010-12-24 02:08:15 +00002905 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
Peter Collingbourne60700392011-01-21 02:08:45 +00002906 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Mike Stumpbf916502009-07-24 19:02:52 +00002907
Chris Lattner0744e5f2008-06-29 00:23:49 +00002908 // Walk the declarator structure, applying decl attributes that were in a type
2909 // position to the decl itself. This handles cases like:
2910 // int *__attr__(x)** D;
2911 // when X is a decl attribute.
2912 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
2913 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
Peter Collingbourne60700392011-01-21 02:08:45 +00002914 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Mike Stumpbf916502009-07-24 19:02:52 +00002915
Chris Lattner0744e5f2008-06-29 00:23:49 +00002916 // Finally, apply any attributes on the decl itself.
2917 if (const AttributeList *Attrs = PD.getAttributes())
Peter Collingbourne60700392011-01-21 02:08:45 +00002918 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Chris Lattner0744e5f2008-06-29 00:23:49 +00002919}
John McCall54abf7d2009-11-04 02:18:39 +00002920
John McCalleee1d542011-02-14 07:13:47 +00002921// This duplicates a vector push_back but hides the need to know the
2922// size of the type.
2923void Sema::DelayedDiagnostics::add(const DelayedDiagnostic &diag) {
2924 assert(StackSize <= StackCapacity);
2925
2926 // Grow the stack if necessary.
2927 if (StackSize == StackCapacity) {
2928 unsigned newCapacity = 2 * StackCapacity + 2;
2929 char *newBuffer = new char[newCapacity * sizeof(DelayedDiagnostic)];
2930 const char *oldBuffer = (const char*) Stack;
2931
2932 if (StackCapacity)
2933 memcpy(newBuffer, oldBuffer, StackCapacity * sizeof(DelayedDiagnostic));
2934
2935 delete[] oldBuffer;
2936 Stack = reinterpret_cast<sema::DelayedDiagnostic*>(newBuffer);
2937 StackCapacity = newCapacity;
2938 }
2939
2940 assert(StackSize < StackCapacity);
2941 new (&Stack[StackSize++]) DelayedDiagnostic(diag);
John McCall2f514482010-01-27 03:50:35 +00002942}
2943
John McCalleee1d542011-02-14 07:13:47 +00002944void Sema::DelayedDiagnostics::popParsingDecl(Sema &S, ParsingDeclState state,
2945 Decl *decl) {
2946 DelayedDiagnostics &DD = S.DelayedDiagnostics;
John McCall2f514482010-01-27 03:50:35 +00002947
John McCalleee1d542011-02-14 07:13:47 +00002948 // Check the invariants.
2949 assert(DD.StackSize >= state.SavedStackSize);
2950 assert(state.SavedStackSize >= DD.ActiveStackBase);
2951 assert(DD.ParsingDepth > 0);
2952
2953 // Drop the parsing depth.
2954 DD.ParsingDepth--;
2955
2956 // If there are no active diagnostics, we're done.
2957 if (DD.StackSize == DD.ActiveStackBase)
John McCall2f514482010-01-27 03:50:35 +00002958 return;
2959
John McCall2f514482010-01-27 03:50:35 +00002960 // We only want to actually emit delayed diagnostics when we
2961 // successfully parsed a decl.
John McCalleee1d542011-02-14 07:13:47 +00002962 if (decl) {
2963 // We emit all the active diagnostics, not just those starting
2964 // from the saved state. The idea is this: we get one push for a
John McCall2f514482010-01-27 03:50:35 +00002965 // decl spec and another for each declarator; in a decl group like:
2966 // deprecated_typedef foo, *bar, baz();
2967 // only the declarator pops will be passed decls. This is correct;
2968 // we really do need to consider delayed diagnostics from the decl spec
2969 // for each of the different declarations.
John McCalleee1d542011-02-14 07:13:47 +00002970 for (unsigned i = DD.ActiveStackBase, e = DD.StackSize; i != e; ++i) {
2971 DelayedDiagnostic &diag = DD.Stack[i];
2972 if (diag.Triggered)
John McCall2f514482010-01-27 03:50:35 +00002973 continue;
2974
John McCalleee1d542011-02-14 07:13:47 +00002975 switch (diag.Kind) {
John McCall2f514482010-01-27 03:50:35 +00002976 case DelayedDiagnostic::Deprecation:
John McCalleee1d542011-02-14 07:13:47 +00002977 S.HandleDelayedDeprecationCheck(diag, decl);
John McCall2f514482010-01-27 03:50:35 +00002978 break;
2979
2980 case DelayedDiagnostic::Access:
John McCalleee1d542011-02-14 07:13:47 +00002981 S.HandleDelayedAccessCheck(diag, decl);
John McCall2f514482010-01-27 03:50:35 +00002982 break;
2983 }
2984 }
2985 }
2986
John McCall58e6f342010-03-16 05:22:47 +00002987 // Destroy all the delayed diagnostics we're about to pop off.
John McCalleee1d542011-02-14 07:13:47 +00002988 for (unsigned i = state.SavedStackSize, e = DD.StackSize; i != e; ++i)
2989 DD.Stack[i].destroy();
John McCall58e6f342010-03-16 05:22:47 +00002990
John McCalleee1d542011-02-14 07:13:47 +00002991 DD.StackSize = state.SavedStackSize;
John McCall54abf7d2009-11-04 02:18:39 +00002992}
2993
2994static bool isDeclDeprecated(Decl *D) {
2995 do {
2996 if (D->hasAttr<DeprecatedAttr>())
2997 return true;
2998 } while ((D = cast_or_null<Decl>(D->getDeclContext())));
2999 return false;
3000}
3001
John McCall9c3087b2010-08-26 02:13:20 +00003002void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
John McCall2f514482010-01-27 03:50:35 +00003003 Decl *Ctx) {
3004 if (isDeclDeprecated(Ctx))
John McCall54abf7d2009-11-04 02:18:39 +00003005 return;
3006
John McCall2f514482010-01-27 03:50:35 +00003007 DD.Triggered = true;
Benjamin Kramerce2d1862010-10-09 15:49:00 +00003008 if (!DD.getDeprecationMessage().empty())
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00003009 Diag(DD.Loc, diag::warn_deprecated_message)
Benjamin Kramerce2d1862010-10-09 15:49:00 +00003010 << DD.getDeprecationDecl()->getDeclName()
3011 << DD.getDeprecationMessage();
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00003012 else
3013 Diag(DD.Loc, diag::warn_deprecated)
Benjamin Kramerce2d1862010-10-09 15:49:00 +00003014 << DD.getDeprecationDecl()->getDeclName();
John McCall54abf7d2009-11-04 02:18:39 +00003015}
3016
Benjamin Kramerce2d1862010-10-09 15:49:00 +00003017void Sema::EmitDeprecationWarning(NamedDecl *D, llvm::StringRef Message,
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00003018 SourceLocation Loc,
Peter Collingbourne743b82b2011-01-02 19:53:12 +00003019 bool UnknownObjCClass) {
John McCall54abf7d2009-11-04 02:18:39 +00003020 // Delay if we're currently parsing a declaration.
John McCalleee1d542011-02-14 07:13:47 +00003021 if (DelayedDiagnostics.shouldDelayDiagnostics()) {
3022 DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D, Message));
John McCall54abf7d2009-11-04 02:18:39 +00003023 return;
3024 }
3025
3026 // Otherwise, don't warn if our current context is deprecated.
3027 if (isDeclDeprecated(cast<Decl>(CurContext)))
3028 return;
Benjamin Kramerce2d1862010-10-09 15:49:00 +00003029 if (!Message.empty())
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00003030 Diag(Loc, diag::warn_deprecated_message) << D->getDeclName()
3031 << Message;
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00003032 else {
Peter Collingbourne743b82b2011-01-02 19:53:12 +00003033 if (!UnknownObjCClass)
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00003034 Diag(Loc, diag::warn_deprecated) << D->getDeclName();
3035 else
3036 Diag(Loc, diag::warn_deprecated_fwdclass_message) << D->getDeclName();
3037 }
John McCall54abf7d2009-11-04 02:18:39 +00003038}