blob: 516f6976522c9f70008ea4b76064928031843789 [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"
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +000017#include "clang/AST/CXXInheritance.h"
John McCall384aff82010-08-25 07:42:41 +000018#include "clang/AST/DeclCXX.h"
Caitlin Sadowskib51e0312011-08-09 17:59:31 +000019#include "clang/AST/DeclTemplate.h"
Daniel Dunbaracc5f3e2008-08-11 06:23:49 +000020#include "clang/AST/DeclObjC.h"
21#include "clang/AST/Expr.h"
John McCallf85e1932011-06-15 23:02:42 +000022#include "clang/Basic/SourceManager.h"
Chris Lattnerfbf13472008-06-27 22:18:37 +000023#include "clang/Basic/TargetInfo.h"
John McCall19510852010-08-20 18:27:03 +000024#include "clang/Sema/DeclSpec.h"
John McCall9c3087b2010-08-26 02:13:20 +000025#include "clang/Sema/DelayedDiagnostic.h"
John McCallfe98da02011-09-29 07:17:38 +000026#include "clang/Sema/Lookup.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000027#include "llvm/ADT/StringExtras.h"
Chris Lattner6b6b5372008-06-26 18:38:35 +000028using namespace clang;
John McCall9c3087b2010-08-26 02:13:20 +000029using namespace sema;
Chris Lattner6b6b5372008-06-26 18:38:35 +000030
John McCall883cc2c2011-03-02 12:29:23 +000031/// These constants match the enumerated choices of
32/// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
Caitlin Sadowskib51e0312011-08-09 17:59:31 +000033enum AttributeDeclKind {
John McCall883cc2c2011-03-02 12:29:23 +000034 ExpectedFunction,
35 ExpectedUnion,
36 ExpectedVariableOrFunction,
37 ExpectedFunctionOrMethod,
38 ExpectedParameter,
John McCall883cc2c2011-03-02 12:29:23 +000039 ExpectedFunctionMethodOrBlock,
John McCall883cc2c2011-03-02 12:29:23 +000040 ExpectedFunctionMethodOrParameter,
41 ExpectedClass,
John McCall883cc2c2011-03-02 12:29:23 +000042 ExpectedVariable,
43 ExpectedMethod,
Caitlin Sadowskidb33e142011-07-28 20:12:35 +000044 ExpectedVariableFunctionOrLabel,
Douglas Gregorf6b8b582012-03-14 16:55:17 +000045 ExpectedFieldOrGlobalVar,
46 ExpectedStruct
John McCall883cc2c2011-03-02 12:29:23 +000047};
48
Chris Lattnere5c5ee12008-06-29 00:16:31 +000049//===----------------------------------------------------------------------===//
50// Helper functions
51//===----------------------------------------------------------------------===//
52
Chandler Carruth87c44602011-07-01 23:49:12 +000053static const FunctionType *getFunctionType(const Decl *D,
Ted Kremeneka18d7d82009-08-14 20:49:40 +000054 bool blocksToo = true) {
Chris Lattner6b6b5372008-06-26 18:38:35 +000055 QualType Ty;
Chandler Carruth87c44602011-07-01 23:49:12 +000056 if (const ValueDecl *decl = dyn_cast<ValueDecl>(D))
Chris Lattner6b6b5372008-06-26 18:38:35 +000057 Ty = decl->getType();
Chandler Carruth87c44602011-07-01 23:49:12 +000058 else if (const FieldDecl *decl = dyn_cast<FieldDecl>(D))
Chris Lattner6b6b5372008-06-26 18:38:35 +000059 Ty = decl->getType();
Chandler Carruth87c44602011-07-01 23:49:12 +000060 else if (const TypedefNameDecl* decl = dyn_cast<TypedefNameDecl>(D))
Chris Lattner6b6b5372008-06-26 18:38:35 +000061 Ty = decl->getUnderlyingType();
62 else
63 return 0;
Mike Stumpbf916502009-07-24 19:02:52 +000064
Chris Lattner6b6b5372008-06-26 18:38:35 +000065 if (Ty->isFunctionPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +000066 Ty = Ty->getAs<PointerType>()->getPointeeType();
Fariborz Jahanian755f9d22009-05-18 17:39:25 +000067 else if (blocksToo && Ty->isBlockPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +000068 Ty = Ty->getAs<BlockPointerType>()->getPointeeType();
Daniel Dunbard3f2c102008-10-19 02:04:16 +000069
John McCall183700f2009-09-21 23:43:11 +000070 return Ty->getAs<FunctionType>();
Chris Lattner6b6b5372008-06-26 18:38:35 +000071}
72
Daniel Dunbar35682492008-09-26 04:12:28 +000073// FIXME: We should provide an abstraction around a method or function
74// to provide the following bits of information.
75
Nuno Lopesd20254f2009-12-20 23:11:08 +000076/// isFunction - Return true if the given decl has function
Ted Kremeneka18d7d82009-08-14 20:49:40 +000077/// type (function or function-typed variable).
Chandler Carruth87c44602011-07-01 23:49:12 +000078static bool isFunction(const Decl *D) {
79 return getFunctionType(D, false) != NULL;
Ted Kremeneka18d7d82009-08-14 20:49:40 +000080}
81
82/// isFunctionOrMethod - Return true if the given decl has function
Daniel Dunbard3f2c102008-10-19 02:04:16 +000083/// type (function or function-typed variable) or an Objective-C
84/// method.
Chandler Carruth87c44602011-07-01 23:49:12 +000085static bool isFunctionOrMethod(const Decl *D) {
86 return isFunction(D)|| isa<ObjCMethodDecl>(D);
Daniel Dunbar35682492008-09-26 04:12:28 +000087}
88
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000089/// isFunctionOrMethodOrBlock - Return true if the given decl has function
90/// type (function or function-typed variable) or an Objective-C
91/// method or a block.
Chandler Carruth87c44602011-07-01 23:49:12 +000092static bool isFunctionOrMethodOrBlock(const Decl *D) {
93 if (isFunctionOrMethod(D))
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000094 return true;
95 // check for block is more involved.
Chandler Carruth87c44602011-07-01 23:49:12 +000096 if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
Fariborz Jahanian620d89c2009-05-15 23:15:03 +000097 QualType Ty = V->getType();
98 return Ty->isBlockPointerType();
99 }
Chandler Carruth87c44602011-07-01 23:49:12 +0000100 return isa<BlockDecl>(D);
Fariborz Jahanian620d89c2009-05-15 23:15:03 +0000101}
102
John McCall711c52b2011-01-05 12:14:39 +0000103/// Return true if the given decl has a declarator that should have
104/// been processed by Sema::GetTypeForDeclarator.
Chandler Carruth87c44602011-07-01 23:49:12 +0000105static bool hasDeclarator(const Decl *D) {
John McCallf85e1932011-06-15 23:02:42 +0000106 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
Chandler Carruth87c44602011-07-01 23:49:12 +0000107 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
108 isa<ObjCPropertyDecl>(D);
John McCall711c52b2011-01-05 12:14:39 +0000109}
110
Daniel Dunbard3f2c102008-10-19 02:04:16 +0000111/// hasFunctionProto - Return true if the given decl has a argument
112/// information. This decl should have already passed
Fariborz Jahanian620d89c2009-05-15 23:15:03 +0000113/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
Chandler Carruth87c44602011-07-01 23:49:12 +0000114static bool hasFunctionProto(const Decl *D) {
115 if (const FunctionType *FnTy = getFunctionType(D))
Douglas Gregor72564e72009-02-26 23:50:07 +0000116 return isa<FunctionProtoType>(FnTy);
Fariborz Jahanian620d89c2009-05-15 23:15:03 +0000117 else {
Chandler Carruth87c44602011-07-01 23:49:12 +0000118 assert(isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D));
Daniel Dunbard3f2c102008-10-19 02:04:16 +0000119 return true;
120 }
121}
122
123/// getFunctionOrMethodNumArgs - Return number of function or method
124/// arguments. It is an error to call this on a K&R function (use
125/// hasFunctionProto first).
Chandler Carruth87c44602011-07-01 23:49:12 +0000126static unsigned getFunctionOrMethodNumArgs(const Decl *D) {
127 if (const FunctionType *FnTy = getFunctionType(D))
Douglas Gregor72564e72009-02-26 23:50:07 +0000128 return cast<FunctionProtoType>(FnTy)->getNumArgs();
Chandler Carruth87c44602011-07-01 23:49:12 +0000129 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000130 return BD->getNumParams();
Chandler Carruth87c44602011-07-01 23:49:12 +0000131 return cast<ObjCMethodDecl>(D)->param_size();
Daniel Dunbar35682492008-09-26 04:12:28 +0000132}
133
Chandler Carruth87c44602011-07-01 23:49:12 +0000134static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) {
135 if (const FunctionType *FnTy = getFunctionType(D))
Douglas Gregor72564e72009-02-26 23:50:07 +0000136 return cast<FunctionProtoType>(FnTy)->getArgType(Idx);
Chandler Carruth87c44602011-07-01 23:49:12 +0000137 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000138 return BD->getParamDecl(Idx)->getType();
Mike Stumpbf916502009-07-24 19:02:52 +0000139
Chandler Carruth87c44602011-07-01 23:49:12 +0000140 return cast<ObjCMethodDecl>(D)->param_begin()[Idx]->getType();
Daniel Dunbar35682492008-09-26 04:12:28 +0000141}
142
Chandler Carruth87c44602011-07-01 23:49:12 +0000143static QualType getFunctionOrMethodResultType(const Decl *D) {
144 if (const FunctionType *FnTy = getFunctionType(D))
Fariborz Jahanian5b160922009-05-20 17:41:43 +0000145 return cast<FunctionProtoType>(FnTy)->getResultType();
Chandler Carruth87c44602011-07-01 23:49:12 +0000146 return cast<ObjCMethodDecl>(D)->getResultType();
Fariborz Jahanian5b160922009-05-20 17:41:43 +0000147}
148
Chandler Carruth87c44602011-07-01 23:49:12 +0000149static bool isFunctionOrMethodVariadic(const Decl *D) {
150 if (const FunctionType *FnTy = getFunctionType(D)) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000151 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
Daniel Dunbar35682492008-09-26 04:12:28 +0000152 return proto->isVariadic();
Chandler Carruth87c44602011-07-01 23:49:12 +0000153 } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
Ted Kremenekdb9a0ae2010-04-29 16:48:58 +0000154 return BD->isVariadic();
Fariborz Jahaniand66f22d2009-05-19 17:08:59 +0000155 else {
Chandler Carruth87c44602011-07-01 23:49:12 +0000156 return cast<ObjCMethodDecl>(D)->isVariadic();
Daniel Dunbar35682492008-09-26 04:12:28 +0000157 }
158}
159
Chandler Carruth87c44602011-07-01 23:49:12 +0000160static bool isInstanceMethod(const Decl *D) {
161 if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
Chandler Carruth07d7e7a2010-11-16 08:35:43 +0000162 return MethodDecl->isInstance();
163 return false;
164}
165
Chris Lattner6b6b5372008-06-26 18:38:35 +0000166static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
John McCall183700f2009-09-21 23:43:11 +0000167 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
Chris Lattnerb77792e2008-07-26 22:17:49 +0000168 if (!PT)
Chris Lattner6b6b5372008-06-26 18:38:35 +0000169 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000170
John McCall506b57e2010-05-17 21:00:27 +0000171 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
172 if (!Cls)
Chris Lattner6b6b5372008-06-26 18:38:35 +0000173 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000174
John McCall506b57e2010-05-17 21:00:27 +0000175 IdentifierInfo* ClsName = Cls->getIdentifier();
Mike Stumpbf916502009-07-24 19:02:52 +0000176
Chris Lattner6b6b5372008-06-26 18:38:35 +0000177 // FIXME: Should we walk the chain of classes?
178 return ClsName == &Ctx.Idents.get("NSString") ||
179 ClsName == &Ctx.Idents.get("NSMutableString");
180}
181
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000182static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000183 const PointerType *PT = T->getAs<PointerType>();
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000184 if (!PT)
185 return false;
186
Ted Kremenek6217b802009-07-29 21:53:49 +0000187 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000188 if (!RT)
189 return false;
Mike Stumpbf916502009-07-24 19:02:52 +0000190
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000191 const RecordDecl *RD = RT->getDecl();
Abramo Bagnara465d41b2010-05-11 21:36:43 +0000192 if (RD->getTagKind() != TTK_Struct)
Daniel Dunbar085e8f72008-09-26 03:32:58 +0000193 return false;
194
195 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
196}
197
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000198/// \brief Check if the attribute has exactly as many args as Num. May
199/// output an error.
Chandler Carruth1731e202011-07-11 23:30:35 +0000200static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
201 unsigned int Num) {
202 if (Attr.getNumArgs() != Num) {
203 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num;
204 return false;
205 }
206
207 return true;
208}
209
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000210
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000211/// \brief Check if the attribute has at least as many args as Num. May
212/// output an error.
213static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr,
214 unsigned int Num) {
215 if (Attr.getNumArgs() < Num) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000216 S.Diag(Attr.getLoc(), diag::err_attribute_too_few_arguments) << Num;
217 return false;
218 }
219
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000220 return true;
221}
222
223///
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000224/// \brief Check if passed in Decl is a field or potentially shared global var
225/// \return true if the Decl is a field or potentially shared global variable
226///
Benjamin Kramer39997fc2011-08-02 04:50:49 +0000227static bool mayBeSharedVariable(const Decl *D) {
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000228 if (isa<FieldDecl>(D))
229 return true;
Benjamin Kramer39997fc2011-08-02 04:50:49 +0000230 if (const VarDecl *vd = dyn_cast<VarDecl>(D))
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000231 return (vd->hasGlobalStorage() && !(vd->isThreadSpecified()));
232
233 return false;
234}
235
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000236/// \brief Check if the passed-in expression is of type int or bool.
237static bool isIntOrBool(Expr *Exp) {
238 QualType QT = Exp->getType();
239 return QT->isBooleanType() || QT->isIntegerType();
240}
241
DeLesley Hutchinsaed9ea32012-04-23 18:39:55 +0000242
243// Check to see if the type is a smart pointer of some kind. We assume
244// it's a smart pointer if it defines both operator-> and operator*.
DeLesley Hutchins60f20242012-05-02 22:18:42 +0000245static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
246 DeclContextLookupConstResult Res1 = RT->getDecl()->lookup(
247 S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
248 if (Res1.first == Res1.second)
249 return false;
DeLesley Hutchinsaed9ea32012-04-23 18:39:55 +0000250
DeLesley Hutchins60f20242012-05-02 22:18:42 +0000251 DeclContextLookupConstResult Res2 = RT->getDecl()->lookup(
252 S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
253 if (Res2.first == Res2.second)
254 return false;
255
256 return true;
DeLesley Hutchinsaed9ea32012-04-23 18:39:55 +0000257}
258
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000259/// \brief Check if passed in Decl is a pointer type.
260/// Note that this function may produce an error message.
261/// \return true if the Decl is a pointer type; false otherwise
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000262static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
263 const AttributeList &Attr) {
Benjamin Kramer39997fc2011-08-02 04:50:49 +0000264 if (const ValueDecl *vd = dyn_cast<ValueDecl>(D)) {
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000265 QualType QT = vd->getType();
Benjamin Kramer39997fc2011-08-02 04:50:49 +0000266 if (QT->isAnyPointerType())
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000267 return true;
DeLesley Hutchinsaed9ea32012-04-23 18:39:55 +0000268
DeLesley Hutchins60f20242012-05-02 22:18:42 +0000269 if (const RecordType *RT = QT->getAs<RecordType>()) {
270 // If it's an incomplete type, it could be a smart pointer; skip it.
271 // (We don't want to force template instantiation if we can avoid it,
272 // since that would alter the order in which templates are instantiated.)
273 if (RT->isIncompleteType())
274 return true;
275
276 if (threadSafetyCheckIsSmartPointer(S, RT))
277 return true;
278 }
DeLesley Hutchinsaed9ea32012-04-23 18:39:55 +0000279
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000280 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000281 << Attr.getName()->getName() << QT;
282 } else {
283 S.Diag(Attr.getLoc(), diag::err_attribute_can_be_applied_only_to_value_decl)
284 << Attr.getName();
285 }
286 return false;
287}
288
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000289/// \brief Checks that the passed in QualType either is of RecordType or points
290/// to RecordType. Returns the relevant RecordType, null if it does not exit.
Benjamin Kramer7d23b4a2011-08-19 04:18:11 +0000291static const RecordType *getRecordType(QualType QT) {
292 if (const RecordType *RT = QT->getAs<RecordType>())
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000293 return RT;
Benjamin Kramer7d23b4a2011-08-19 04:18:11 +0000294
295 // Now check if we point to record type.
296 if (const PointerType *PT = QT->getAs<PointerType>())
297 return PT->getPointeeType()->getAs<RecordType>();
298
299 return 0;
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000300}
301
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +0000302
Jordy Rosefad5de92012-05-08 03:27:22 +0000303static bool checkBaseClassIsLockableCallback(const CXXBaseSpecifier *Specifier,
304 CXXBasePath &Path, void *Unused) {
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +0000305 const RecordType *RT = Specifier->getType()->getAs<RecordType>();
306 if (RT->getDecl()->getAttr<LockableAttr>())
307 return true;
308 return false;
309}
310
311
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000312/// \brief Thread Safety Analysis: Checks that the passed in RecordType
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000313/// resolves to a lockable object.
DeLesley Hutchins83cad452012-04-06 20:02:30 +0000314static void checkForLockableRecord(Sema &S, Decl *D, const AttributeList &Attr,
315 QualType Ty) {
316 const RecordType *RT = getRecordType(Ty);
317
318 // Warn if could not get record type for this argument.
Benjamin Kramerd77ba892011-09-03 03:30:59 +0000319 if (!RT) {
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000320 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_class)
DeLesley Hutchins83cad452012-04-06 20:02:30 +0000321 << Attr.getName() << Ty.getAsString();
322 return;
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000323 }
DeLesley Hutchins60f20242012-05-02 22:18:42 +0000324
DeLesley Hutchins634b2932012-02-16 17:15:51 +0000325 // Don't check for lockable if the class hasn't been defined yet.
326 if (RT->isIncompleteType())
DeLesley Hutchins83cad452012-04-06 20:02:30 +0000327 return;
DeLesley Hutchins60f20242012-05-02 22:18:42 +0000328
329 // Allow smart pointers to be used as lockable objects.
330 // FIXME -- Check the type that the smart pointer points to.
331 if (threadSafetyCheckIsSmartPointer(S, RT))
332 return;
333
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +0000334 // Check if the type is lockable.
335 RecordDecl *RD = RT->getDecl();
336 if (RD->getAttr<LockableAttr>())
DeLesley Hutchins83cad452012-04-06 20:02:30 +0000337 return;
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +0000338
339 // Else check if any base classes are lockable.
340 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
341 CXXBasePaths BPaths(false, false);
342 if (CRD->lookupInBases(checkBaseClassIsLockableCallback, 0, BPaths))
343 return;
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000344 }
DeLesley Hutchinsbbba25f2012-05-04 16:28:38 +0000345
346 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
347 << Attr.getName() << Ty.getAsString();
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000348}
349
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000350/// \brief Thread Safety Analysis: Checks that all attribute arguments, starting
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000351/// from Sidx, resolve to a lockable object.
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000352/// \param Sidx The attribute argument index to start checking with.
353/// \param ParamIdxOk Whether an argument can be indexing into a function
354/// parameter list.
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000355static void checkAttrArgsAreLockableObjs(Sema &S, Decl *D,
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000356 const AttributeList &Attr,
357 SmallVectorImpl<Expr*> &Args,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000358 int Sidx = 0,
359 bool ParamIdxOk = false) {
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000360 for(unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000361 Expr *ArgExp = Attr.getArg(Idx);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000362
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000363 if (ArgExp->isTypeDependent()) {
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000364 // FIXME -- need to check this again on template instantiation
Caitlin Sadowskied9d84a2011-09-08 17:42:31 +0000365 Args.push_back(ArgExp);
366 continue;
367 }
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000368
DeLesley Hutchins79747e02012-04-23 16:45:01 +0000369 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
370 // Ignore empty strings without warnings
371 if (StrLit->getLength() == 0)
372 continue;
373
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000374 // We allow constant strings to be used as a placeholder for expressions
375 // that are not valid C++ syntax, but warn that they are ignored.
376 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
377 Attr.getName();
378 continue;
379 }
380
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000381 QualType ArgTy = ArgExp->getType();
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000382
DeLesley Hutchins79747e02012-04-23 16:45:01 +0000383 // A pointer to member expression of the form &MyClass::mu is treated
384 // specially -- we need to look at the type of the member.
385 if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp))
386 if (UOp->getOpcode() == UO_AddrOf)
387 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
388 if (DRE->getDecl()->isCXXInstanceMember())
389 ArgTy = DRE->getDecl()->getType();
390
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000391 // First see if we can just cast to record type, or point to record type.
392 const RecordType *RT = getRecordType(ArgTy);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000393
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000394 // Now check if we index into a record type function param.
395 if(!RT && ParamIdxOk) {
396 FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000397 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp);
398 if(FD && IL) {
399 unsigned int NumParams = FD->getNumParams();
400 llvm::APInt ArgValue = IL->getValue();
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000401 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
402 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
403 if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000404 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
405 << Attr.getName() << Idx + 1 << NumParams;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000406 continue;
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000407 }
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000408 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000409 }
410 }
411
DeLesley Hutchins83cad452012-04-06 20:02:30 +0000412 checkForLockableRecord(S, D, Attr, ArgTy);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000413
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000414 Args.push_back(ArgExp);
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000415 }
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000416}
417
Chris Lattnere5c5ee12008-06-29 00:16:31 +0000418//===----------------------------------------------------------------------===//
Chris Lattnere5c5ee12008-06-29 00:16:31 +0000419// Attribute Implementations
420//===----------------------------------------------------------------------===//
421
Daniel Dunbar3068ae02008-07-31 22:40:48 +0000422// FIXME: All this manual attribute parsing code is gross. At the
423// least add some helper functions to check most argument patterns (#
424// and types of args).
425
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000426static void handleGuardedVarAttr(Sema &S, Decl *D, const AttributeList &Attr,
427 bool pointer = false) {
428 assert(!Attr.isInvalid());
429
430 if (!checkAttributeNumArgs(S, Attr, 0))
431 return;
432
433 // D must be either a member field or global (potentially shared) variable.
434 if (!mayBeSharedVariable(D)) {
435 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000436 << Attr.getName() << ExpectedFieldOrGlobalVar;
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000437 return;
438 }
439
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000440 if (pointer && !threadSafetyCheckIsPointer(S, D, Attr))
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000441 return;
442
443 if (pointer)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000444 D->addAttr(::new (S.Context) PtGuardedVarAttr(Attr.getRange(), S.Context));
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000445 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000446 D->addAttr(::new (S.Context) GuardedVarAttr(Attr.getRange(), S.Context));
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000447}
448
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000449static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000450 bool pointer = false) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000451 assert(!Attr.isInvalid());
452
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000453 if (!checkAttributeNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000454 return;
455
456 // D must be either a member field or global (potentially shared) variable.
457 if (!mayBeSharedVariable(D)) {
458 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000459 << Attr.getName() << ExpectedFieldOrGlobalVar;
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000460 return;
461 }
462
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000463 if (pointer && !threadSafetyCheckIsPointer(S, D, Attr))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000464 return;
465
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000466 SmallVector<Expr*, 1> Args;
467 // check that all arguments are lockable objects
468 checkAttrArgsAreLockableObjs(S, D, Attr, Args);
469 unsigned Size = Args.size();
470 if (Size != 1)
471 return;
472 Expr *Arg = Args[0];
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000473
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000474 if (pointer)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000475 D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000476 S.Context, Arg));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000477 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000478 D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000479}
480
481
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000482static void handleLockableAttr(Sema &S, Decl *D, const AttributeList &Attr,
483 bool scoped = false) {
484 assert(!Attr.isInvalid());
485
486 if (!checkAttributeNumArgs(S, Attr, 0))
487 return;
488
Caitlin Sadowski1748b122011-09-16 00:35:54 +0000489 // FIXME: Lockable structs for C code.
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000490 if (!isa<CXXRecordDecl>(D)) {
491 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
492 << Attr.getName() << ExpectedClass;
493 return;
494 }
495
496 if (scoped)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000497 D->addAttr(::new (S.Context) ScopedLockableAttr(Attr.getRange(), S.Context));
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000498 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000499 D->addAttr(::new (S.Context) LockableAttr(Attr.getRange(), S.Context));
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000500}
501
502static void handleNoThreadSafetyAttr(Sema &S, Decl *D,
503 const AttributeList &Attr) {
504 assert(!Attr.isInvalid());
505
506 if (!checkAttributeNumArgs(S, Attr, 0))
507 return;
508
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000509 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000510 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
511 << Attr.getName() << ExpectedFunctionOrMethod;
512 return;
513 }
514
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000515 D->addAttr(::new (S.Context) NoThreadSafetyAnalysisAttr(Attr.getRange(),
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +0000516 S.Context));
517}
518
Kostya Serebryany71efba02012-01-24 19:25:38 +0000519static void handleNoAddressSafetyAttr(Sema &S, Decl *D,
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000520 const AttributeList &Attr) {
Kostya Serebryany71efba02012-01-24 19:25:38 +0000521 assert(!Attr.isInvalid());
522
523 if (!checkAttributeNumArgs(S, Attr, 0))
524 return;
525
526 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
527 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
528 << Attr.getName() << ExpectedFunctionOrMethod;
529 return;
530 }
531
532 D->addAttr(::new (S.Context) NoAddressSafetyAnalysisAttr(Attr.getRange(),
533 S.Context));
534}
535
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000536static void handleAcquireOrderAttr(Sema &S, Decl *D, const AttributeList &Attr,
537 bool before) {
538 assert(!Attr.isInvalid());
539
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000540 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000541 return;
542
543 // D must be either a member field or global (potentially shared) variable.
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000544 ValueDecl *VD = dyn_cast<ValueDecl>(D);
545 if (!VD || !mayBeSharedVariable(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000546 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000547 << Attr.getName() << ExpectedFieldOrGlobalVar;
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000548 return;
549 }
550
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000551 // Check that this attribute only applies to lockable types.
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000552 QualType QT = VD->getType();
553 if (!QT->isDependentType()) {
554 const RecordType *RT = getRecordType(QT);
555 if (!RT || !RT->getDecl()->getAttr<LockableAttr>()) {
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000556 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000557 << Attr.getName();
558 return;
559 }
560 }
561
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000562 SmallVector<Expr*, 1> Args;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000563 // Check that all arguments are lockable objects.
564 checkAttrArgsAreLockableObjs(S, D, Attr, Args);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000565 unsigned Size = Args.size();
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000566 if (Size == 0)
567 return;
568 Expr **StartArg = &Args[0];
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000569
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000570 if (before)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000571 D->addAttr(::new (S.Context) AcquiredBeforeAttr(Attr.getRange(), S.Context,
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000572 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000573 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000574 D->addAttr(::new (S.Context) AcquiredAfterAttr(Attr.getRange(), S.Context,
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000575 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000576}
577
578static void handleLockFunAttr(Sema &S, Decl *D, const AttributeList &Attr,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000579 bool exclusive = false) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000580 assert(!Attr.isInvalid());
581
582 // zero or more arguments ok
583
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000584 // check that the attribute is applied to a function
585 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000586 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
587 << Attr.getName() << ExpectedFunctionOrMethod;
588 return;
589 }
590
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000591 // check that all arguments are lockable objects
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000592 SmallVector<Expr*, 1> Args;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000593 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000594 unsigned Size = Args.size();
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000595 Expr **StartArg = Size == 0 ? 0 : &Args[0];
596
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000597 if (exclusive)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000598 D->addAttr(::new (S.Context) ExclusiveLockFunctionAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000599 S.Context, StartArg,
600 Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000601 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000602 D->addAttr(::new (S.Context) SharedLockFunctionAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000603 S.Context, StartArg,
604 Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000605}
606
607static void handleTrylockFunAttr(Sema &S, Decl *D, const AttributeList &Attr,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000608 bool exclusive = false) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000609 assert(!Attr.isInvalid());
610
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000611 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000612 return;
613
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000614 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000615 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
616 << Attr.getName() << ExpectedFunctionOrMethod;
617 return;
618 }
619
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000620 if (!isIntOrBool(Attr.getArg(0))) {
621 S.Diag(Attr.getLoc(), diag::err_attribute_first_argument_not_int_or_bool)
622 << Attr.getName();
623 return;
624 }
625
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000626 SmallVector<Expr*, 2> Args;
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000627 // check that all arguments are lockable objects
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000628 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 1);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000629 unsigned Size = Args.size();
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000630 Expr **StartArg = Size == 0 ? 0 : &Args[0];
631
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000632 if (exclusive)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000633 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000634 S.Context,
Caitlin Sadowski69f5d142011-09-15 17:50:19 +0000635 Attr.getArg(0),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000636 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000637 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000638 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(Attr.getRange(),
Caitlin Sadowski69f5d142011-09-15 17:50:19 +0000639 S.Context,
640 Attr.getArg(0),
641 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000642}
643
644static void handleLocksRequiredAttr(Sema &S, Decl *D, const AttributeList &Attr,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000645 bool exclusive = false) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000646 assert(!Attr.isInvalid());
647
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000648 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000649 return;
650
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000651 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000652 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
653 << Attr.getName() << ExpectedFunctionOrMethod;
654 return;
655 }
656
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000657 // check that all arguments are lockable objects
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000658 SmallVector<Expr*, 1> Args;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000659 checkAttrArgsAreLockableObjs(S, D, Attr, Args);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000660 unsigned Size = Args.size();
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000661 if (Size == 0)
662 return;
663 Expr **StartArg = &Args[0];
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000664
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000665 if (exclusive)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000666 D->addAttr(::new (S.Context) ExclusiveLocksRequiredAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000667 S.Context, StartArg,
668 Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000669 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000670 D->addAttr(::new (S.Context) SharedLocksRequiredAttr(Attr.getRange(),
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000671 S.Context, StartArg,
672 Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000673}
674
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000675static void handleUnlockFunAttr(Sema &S, Decl *D,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000676 const AttributeList &Attr) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000677 assert(!Attr.isInvalid());
678
679 // zero or more arguments ok
680
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000681 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000682 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
683 << Attr.getName() << ExpectedFunctionOrMethod;
684 return;
685 }
686
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000687 // check that all arguments are lockable objects
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000688 SmallVector<Expr*, 1> Args;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000689 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000690 unsigned Size = Args.size();
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000691 Expr **StartArg = Size == 0 ? 0 : &Args[0];
692
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000693 D->addAttr(::new (S.Context) UnlockFunctionAttr(Attr.getRange(), S.Context,
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000694 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000695}
696
697static void handleLockReturnedAttr(Sema &S, Decl *D,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000698 const AttributeList &Attr) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000699 assert(!Attr.isInvalid());
700
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000701 if (!checkAttributeNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000702 return;
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000703 Expr *Arg = Attr.getArg(0);
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000704
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000705 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000706 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
707 << Attr.getName() << ExpectedFunctionOrMethod;
708 return;
709 }
710
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000711 if (Arg->isTypeDependent())
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000712 return;
713
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000714 // check that the argument is lockable object
DeLesley Hutchinsf26efd72012-05-02 17:38:37 +0000715 SmallVector<Expr*, 1> Args;
716 checkAttrArgsAreLockableObjs(S, D, Attr, Args);
717 unsigned Size = Args.size();
718 if (Size == 0)
719 return;
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000720
DeLesley Hutchinsf26efd72012-05-02 17:38:37 +0000721 D->addAttr(::new (S.Context) LockReturnedAttr(Attr.getRange(), S.Context,
722 Args[0]));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000723}
724
725static void handleLocksExcludedAttr(Sema &S, Decl *D,
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000726 const AttributeList &Attr) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000727 assert(!Attr.isInvalid());
728
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000729 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000730 return;
731
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000732 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) {
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000733 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
734 << Attr.getName() << ExpectedFunctionOrMethod;
735 return;
736 }
737
Caitlin Sadowskib51e0312011-08-09 17:59:31 +0000738 // check that all arguments are lockable objects
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000739 SmallVector<Expr*, 1> Args;
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000740 checkAttrArgsAreLockableObjs(S, D, Attr, Args);
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000741 unsigned Size = Args.size();
DeLesley Hutchinsae519c42012-04-19 16:10:44 +0000742 if (Size == 0)
743 return;
744 Expr **StartArg = &Args[0];
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000745
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000746 D->addAttr(::new (S.Context) LocksExcludedAttr(Attr.getRange(), S.Context,
Caitlin Sadowski3ac1fbc2011-08-23 18:46:34 +0000747 StartArg, Size));
Caitlin Sadowskidb33e142011-07-28 20:12:35 +0000748}
749
750
Chandler Carruth1b03c872011-07-02 00:01:44 +0000751static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
752 const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +0000753 TypedefNameDecl *tDecl = dyn_cast<TypedefNameDecl>(D);
Chris Lattner545dd342008-06-28 23:36:30 +0000754 if (tDecl == 0) {
Chris Lattner803d0802008-06-29 00:43:07 +0000755 S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef);
Chris Lattner545dd342008-06-28 23:36:30 +0000756 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +0000757 }
Mike Stumpbf916502009-07-24 19:02:52 +0000758
Chris Lattner6b6b5372008-06-26 18:38:35 +0000759 QualType curType = tDecl->getUnderlyingType();
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000760
761 Expr *sizeExpr;
762
763 // Special case where the argument is a template id.
764 if (Attr.getParameterName()) {
John McCallf7a1a742009-11-24 19:00:30 +0000765 CXXScopeSpec SS;
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000766 SourceLocation TemplateKWLoc;
John McCallf7a1a742009-11-24 19:00:30 +0000767 UnqualifiedId id;
768 id.setIdentifier(Attr.getParameterName(), Attr.getLoc());
Douglas Gregor4ac01402011-06-15 16:02:29 +0000769
Abramo Bagnarae4b92762012-01-27 09:46:47 +0000770 ExprResult Size = S.ActOnIdExpression(scope, SS, TemplateKWLoc, id,
771 false, false);
Douglas Gregor4ac01402011-06-15 16:02:29 +0000772 if (Size.isInvalid())
773 return;
774
775 sizeExpr = Size.get();
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000776 } else {
777 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +0000778 if (!checkAttributeNumArgs(S, Attr, 1))
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000779 return;
Chandler Carruth1731e202011-07-11 23:30:35 +0000780
Peter Collingbourne7a730022010-11-23 20:45:58 +0000781 sizeExpr = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +0000782 }
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000783
784 // Instantiate/Install the vector type, and let Sema build the type for us.
785 // This will run the reguired checks.
John McCall9ae2f072010-08-23 23:25:46 +0000786 QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc());
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000787 if (!T.isNull()) {
John McCallba6a9bd2009-10-24 08:00:42 +0000788 // FIXME: preserve the old source info.
John McCalla93c9342009-12-07 02:54:59 +0000789 tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T));
Mike Stumpbf916502009-07-24 19:02:52 +0000790
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000791 // Remember this typedef decl, we will need it later for diagnostics.
792 S.ExtVectorDecls.push_back(tDecl);
Chris Lattner6b6b5372008-06-26 18:38:35 +0000793 }
Chris Lattner6b6b5372008-06-26 18:38:35 +0000794}
795
Chandler Carruth1b03c872011-07-02 00:01:44 +0000796static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +0000797 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +0000798 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner6b6b5372008-06-26 18:38:35 +0000799 return;
Mike Stumpbf916502009-07-24 19:02:52 +0000800
Chandler Carruth87c44602011-07-01 23:49:12 +0000801 if (TagDecl *TD = dyn_cast<TagDecl>(D))
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000802 TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context));
Chandler Carruth87c44602011-07-01 23:49:12 +0000803 else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
Chris Lattner6b6b5372008-06-26 18:38:35 +0000804 // If the alignment is less than or equal to 8 bits, the packed attribute
805 // has no effect.
806 if (!FD->getType()->isIncompleteType() &&
Chris Lattner803d0802008-06-29 00:43:07 +0000807 S.Context.getTypeAlign(FD->getType()) <= 8)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000808 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
Chris Lattner08631c52008-11-23 21:45:46 +0000809 << Attr.getName() << FD->getType();
Chris Lattner6b6b5372008-06-26 18:38:35 +0000810 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000811 FD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +0000812 } else
Chris Lattner3c73c412008-11-19 08:23:25 +0000813 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +0000814}
815
Chandler Carruth1b03c872011-07-02 00:01:44 +0000816static void handleMsStructAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +0000817 if (TagDecl *TD = dyn_cast<TagDecl>(D))
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000818 TD->addAttr(::new (S.Context) MsStructAttr(Attr.getRange(), S.Context));
Fariborz Jahanianc1a0a732011-04-26 17:54:40 +0000819 else
820 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
821}
822
Chandler Carruth1b03c872011-07-02 00:01:44 +0000823static void handleIBAction(Sema &S, Decl *D, const AttributeList &Attr) {
Ted Kremenek96329d42008-07-15 22:26:48 +0000824 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +0000825 if (!checkAttributeNumArgs(S, Attr, 0))
Ted Kremenek96329d42008-07-15 22:26:48 +0000826 return;
Mike Stumpbf916502009-07-24 19:02:52 +0000827
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000828 // The IBAction attributes only apply to instance methods.
Chandler Carruth87c44602011-07-01 23:49:12 +0000829 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000830 if (MD->isInstanceMethod()) {
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +0000831 D->addAttr(::new (S.Context) IBActionAttr(Attr.getRange(), S.Context));
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000832 return;
833 }
834
Ted Kremenek4ee2bb12011-02-04 06:54:16 +0000835 S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName();
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000836}
837
Ted Kremenek2f041d02011-09-29 07:02:25 +0000838static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
839 // The IBOutlet/IBOutletCollection attributes only apply to instance
840 // variables or properties of Objective-C classes. The outlet must also
841 // have an object reference type.
842 if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) {
843 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
Ted Kremenek0bfaf062011-11-01 18:08:35 +0000844 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
Ted Kremenek2f041d02011-09-29 07:02:25 +0000845 << Attr.getName() << VD->getType() << 0;
846 return false;
847 }
848 }
849 else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
850 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
Douglas Gregorf6b8b582012-03-14 16:55:17 +0000851 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
Ted Kremenek2f041d02011-09-29 07:02:25 +0000852 << Attr.getName() << PD->getType() << 1;
853 return false;
854 }
855 }
856 else {
857 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
858 return false;
859 }
Douglas Gregorf6b8b582012-03-14 16:55:17 +0000860
Ted Kremenek2f041d02011-09-29 07:02:25 +0000861 return true;
862}
863
Chandler Carruth1b03c872011-07-02 00:01:44 +0000864static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000865 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +0000866 if (!checkAttributeNumArgs(S, Attr, 0))
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000867 return;
Ted Kremenek2f041d02011-09-29 07:02:25 +0000868
869 if (!checkIBOutletCommon(S, D, Attr))
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000870 return;
Ted Kremenek63e5d7c2010-02-18 03:08:58 +0000871
Ted Kremenek2f041d02011-09-29 07:02:25 +0000872 D->addAttr(::new (S.Context) IBOutletAttr(Attr.getRange(), S.Context));
Ted Kremenek96329d42008-07-15 22:26:48 +0000873}
874
Chandler Carruth1b03c872011-07-02 00:01:44 +0000875static void handleIBOutletCollection(Sema &S, Decl *D,
876 const AttributeList &Attr) {
Ted Kremenek857e9182010-05-19 17:38:06 +0000877
878 // The iboutletcollection attribute can have zero or one arguments.
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000879 if (Attr.getParameterName() && Attr.getNumArgs() > 0) {
Ted Kremenek857e9182010-05-19 17:38:06 +0000880 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
881 return;
882 }
883
Ted Kremenek2f041d02011-09-29 07:02:25 +0000884 if (!checkIBOutletCommon(S, D, Attr))
Ted Kremenek857e9182010-05-19 17:38:06 +0000885 return;
Ted Kremenek2f041d02011-09-29 07:02:25 +0000886
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000887 IdentifierInfo *II = Attr.getParameterName();
888 if (!II)
Fariborz Jahanianf4072ae2011-10-18 19:54:31 +0000889 II = &S.Context.Idents.get("NSObject");
Fariborz Jahanian3a3400b2010-08-17 21:39:27 +0000890
John McCallb3d87482010-08-24 05:47:05 +0000891 ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(),
Chandler Carruth87c44602011-07-01 23:49:12 +0000892 S.getScopeForContext(D->getDeclContext()->getParent()));
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000893 if (!TypeRep) {
894 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
895 return;
896 }
John McCallb3d87482010-08-24 05:47:05 +0000897 QualType QT = TypeRep.get();
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000898 // Diagnose use of non-object type in iboutletcollection attribute.
899 // FIXME. Gnu attribute extension ignores use of builtin types in
900 // attributes. So, __attribute__((iboutletcollection(char))) will be
901 // treated as __attribute__((iboutletcollection())).
Fariborz Jahanianf4072ae2011-10-18 19:54:31 +0000902 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
Fariborz Jahaniana8fb24f2010-08-17 20:23:12 +0000903 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II;
904 return;
905 }
Argyrios Kyrtzidisf1e7af32011-09-13 18:41:59 +0000906 D->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getRange(),S.Context,
907 QT, Attr.getParameterLoc()));
Ted Kremenek857e9182010-05-19 17:38:06 +0000908}
909
Chandler Carruthd309c812011-07-01 23:49:16 +0000910static void possibleTransparentUnionPointerType(QualType &T) {
Fariborz Jahanian68fe96a2011-06-27 21:12:03 +0000911 if (const RecordType *UT = T->getAsUnionType())
912 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
913 RecordDecl *UD = UT->getDecl();
914 for (RecordDecl::field_iterator it = UD->field_begin(),
915 itend = UD->field_end(); it != itend; ++it) {
916 QualType QT = it->getType();
917 if (QT->isAnyPointerType() || QT->isBlockPointerType()) {
918 T = QT;
919 return;
920 }
921 }
922 }
923}
924
Nuno Lopes587de5b2012-05-24 00:22:00 +0000925static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
926 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
927 return;
928
929 // In C++ the implicit 'this' function parameter also counts, and they are
930 // counted from one.
931 bool HasImplicitThisParam = isInstanceMethod(D);
932 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
933
934 SmallVector<unsigned, 8> SizeArgs;
935
936 for (AttributeList::arg_iterator I = Attr.arg_begin(),
937 E = Attr.arg_end(); I!=E; ++I) {
938 // The argument must be an integer constant expression.
939 Expr *Ex = *I;
940 llvm::APSInt ArgNum;
941 if (Ex->isTypeDependent() || Ex->isValueDependent() ||
942 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
943 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
944 << "alloc_size" << Ex->getSourceRange();
945 return;
946 }
947
948 uint64_t x = ArgNum.getZExtValue();
949
950 if (x < 1 || x > NumArgs) {
951 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
952 << "alloc_size" << I.getArgNum() << Ex->getSourceRange();
953 return;
954 }
955
956 --x;
957 if (HasImplicitThisParam) {
958 if (x == 0) {
959 S.Diag(Attr.getLoc(),
960 diag::err_attribute_invalid_implicit_this_argument)
961 << "alloc_size" << Ex->getSourceRange();
962 return;
963 }
964 --x;
965 }
966
967 // check if the function argument is of an integer type
968 QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
969 if (!T->isIntegerType()) {
970 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
971 << "alloc_size" << Ex->getSourceRange();
972 return;
973 }
974
975 // check if the argument is a duplicate
976 SmallVectorImpl<unsigned>::iterator Pos;
977 Pos = std::find(SizeArgs.begin(), SizeArgs.end(), x);
978 if (Pos != SizeArgs.end()) {
979 S.Diag(Attr.getLoc(), diag::err_attribute_argument_duplicate)
980 << "alloc_size" << I.getArgNum() << Ex->getSourceRange();
981 return;
982 }
983
984 SizeArgs.push_back(x);
985 }
986
987 // check if the function returns a pointer
988 if (!getFunctionType(D)->getResultType()->isAnyPointerType()) {
989 S.Diag(Attr.getLoc(), diag::warn_ns_attribute_wrong_return_type)
990 << "alloc_size" << 0 /*function*/<< 1 /*pointer*/ << D->getSourceRange();
991 }
992
993 unsigned size = SizeArgs.size();
994 unsigned* start = &SizeArgs[0];
995 llvm::array_pod_sort(start, start + size);
996 D->addAttr(::new (S.Context) AllocSizeAttr(Attr.getRange(), S.Context, start,
997 size));
998}
999
Chandler Carruth1b03c872011-07-02 00:01:44 +00001000static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Mike Stumpbf916502009-07-24 19:02:52 +00001001 // GCC ignores the nonnull attribute on K&R style function prototypes, so we
1002 // ignore it as well
Chandler Carruth87c44602011-07-01 23:49:12 +00001003 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001004 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001005 << Attr.getName() << ExpectedFunction;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001006 return;
1007 }
Mike Stumpbf916502009-07-24 19:02:52 +00001008
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001009 // In C++ the implicit 'this' function parameter also counts, and they are
1010 // counted from one.
Chandler Carruth87c44602011-07-01 23:49:12 +00001011 bool HasImplicitThisParam = isInstanceMethod(D);
1012 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001013
1014 // The nonnull attribute only applies to pointers.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001015 SmallVector<unsigned, 10> NonNullArgs;
Mike Stumpbf916502009-07-24 19:02:52 +00001016
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001017 for (AttributeList::arg_iterator I=Attr.arg_begin(),
1018 E=Attr.arg_end(); I!=E; ++I) {
Mike Stumpbf916502009-07-24 19:02:52 +00001019
1020
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001021 // The argument must be an integer constant expression.
Peter Collingbourne7a730022010-11-23 20:45:58 +00001022 Expr *Ex = *I;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001023 llvm::APSInt ArgNum(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001024 if (Ex->isTypeDependent() || Ex->isValueDependent() ||
1025 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001026 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
1027 << "nonnull" << Ex->getSourceRange();
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001028 return;
1029 }
Mike Stumpbf916502009-07-24 19:02:52 +00001030
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001031 unsigned x = (unsigned) ArgNum.getZExtValue();
Mike Stumpbf916502009-07-24 19:02:52 +00001032
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001033 if (x < 1 || x > NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001034 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner30bc9652008-11-19 07:22:31 +00001035 << "nonnull" << I.getArgNum() << Ex->getSourceRange();
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001036 return;
1037 }
Mike Stumpbf916502009-07-24 19:02:52 +00001038
Ted Kremenek465172f2008-07-21 22:09:15 +00001039 --x;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001040 if (HasImplicitThisParam) {
1041 if (x == 0) {
1042 S.Diag(Attr.getLoc(),
1043 diag::err_attribute_invalid_implicit_this_argument)
1044 << "nonnull" << Ex->getSourceRange();
1045 return;
1046 }
1047 --x;
1048 }
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001049
1050 // Is the function argument a pointer type?
Chandler Carruth87c44602011-07-01 23:49:12 +00001051 QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType();
Chandler Carruthd309c812011-07-01 23:49:16 +00001052 possibleTransparentUnionPointerType(T);
Fariborz Jahanian68fe96a2011-06-27 21:12:03 +00001053
Ted Kremenekdbfe99e2009-07-15 23:23:54 +00001054 if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001055 // FIXME: Should also highlight argument in decl.
Douglas Gregorc9ef4052010-08-12 18:48:43 +00001056 S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001057 << "nonnull" << Ex->getSourceRange();
Ted Kremenek7fb43c12008-09-01 19:57:52 +00001058 continue;
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001059 }
Mike Stumpbf916502009-07-24 19:02:52 +00001060
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001061 NonNullArgs.push_back(x);
1062 }
Mike Stumpbf916502009-07-24 19:02:52 +00001063
1064 // If no arguments were specified to __attribute__((nonnull)) then all pointer
1065 // arguments have a nonnull attribute.
Ted Kremenek7fb43c12008-09-01 19:57:52 +00001066 if (NonNullArgs.empty()) {
Chandler Carruth87c44602011-07-01 23:49:12 +00001067 for (unsigned I = 0, E = getFunctionOrMethodNumArgs(D); I != E; ++I) {
1068 QualType T = getFunctionOrMethodArgType(D, I).getNonReferenceType();
Chandler Carruthd309c812011-07-01 23:49:16 +00001069 possibleTransparentUnionPointerType(T);
Ted Kremenekdbfe99e2009-07-15 23:23:54 +00001070 if (T->isAnyPointerType() || T->isBlockPointerType())
Daniel Dunbard3f2c102008-10-19 02:04:16 +00001071 NonNullArgs.push_back(I);
Ted Kremenek46bbaca2008-11-18 06:52:58 +00001072 }
Mike Stumpbf916502009-07-24 19:02:52 +00001073
Ted Kremenekee1c08c2010-10-21 18:49:36 +00001074 // No pointer arguments?
Fariborz Jahanian60acea42010-09-27 19:05:51 +00001075 if (NonNullArgs.empty()) {
1076 // Warn the trivial case only if attribute is not coming from a
1077 // macro instantiation.
1078 if (Attr.getLoc().isFileID())
1079 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
Ted Kremenek7fb43c12008-09-01 19:57:52 +00001080 return;
Fariborz Jahanian60acea42010-09-27 19:05:51 +00001081 }
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001082 }
Ted Kremenek7fb43c12008-09-01 19:57:52 +00001083
1084 unsigned* start = &NonNullArgs[0];
1085 unsigned size = NonNullArgs.size();
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001086 llvm::array_pod_sort(start, start + size);
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001087 D->addAttr(::new (S.Context) NonNullAttr(Attr.getRange(), S.Context, start,
Sean Huntcf807c42010-08-18 23:23:40 +00001088 size));
Ted Kremenekeb2b2a32008-07-21 21:53:04 +00001089}
1090
Chandler Carruth1b03c872011-07-02 00:01:44 +00001091static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001092 // This attribute must be applied to a function declaration.
1093 // The first argument to the attribute must be a string,
1094 // the name of the resource, for example "malloc".
1095 // The following arguments must be argument indexes, the arguments must be
1096 // of integer type for Returns, otherwise of pointer type.
1097 // The difference between Holds and Takes is that a pointer may still be used
Jordy Rose2a479922010-08-12 08:54:03 +00001098 // after being held. free() should be __attribute((ownership_takes)), whereas
1099 // a list append function may well be __attribute((ownership_holds)).
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001100
1101 if (!AL.getParameterName()) {
1102 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string)
1103 << AL.getName()->getName() << 1;
1104 return;
1105 }
1106 // Figure out our Kind, and check arguments while we're at it.
Sean Huntcf807c42010-08-18 23:23:40 +00001107 OwnershipAttr::OwnershipKind K;
Jordy Rose2a479922010-08-12 08:54:03 +00001108 switch (AL.getKind()) {
1109 case AttributeList::AT_ownership_takes:
Sean Huntcf807c42010-08-18 23:23:40 +00001110 K = OwnershipAttr::Takes;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001111 if (AL.getNumArgs() < 1) {
1112 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1113 return;
1114 }
Jordy Rose2a479922010-08-12 08:54:03 +00001115 break;
1116 case AttributeList::AT_ownership_holds:
Sean Huntcf807c42010-08-18 23:23:40 +00001117 K = OwnershipAttr::Holds;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001118 if (AL.getNumArgs() < 1) {
1119 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1120 return;
1121 }
Jordy Rose2a479922010-08-12 08:54:03 +00001122 break;
1123 case AttributeList::AT_ownership_returns:
Sean Huntcf807c42010-08-18 23:23:40 +00001124 K = OwnershipAttr::Returns;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001125 if (AL.getNumArgs() > 1) {
1126 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
1127 << AL.getNumArgs() + 1;
1128 return;
1129 }
Jordy Rose2a479922010-08-12 08:54:03 +00001130 break;
1131 default:
1132 // This should never happen given how we are called.
1133 llvm_unreachable("Unknown ownership attribute");
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001134 }
1135
Chandler Carruth87c44602011-07-01 23:49:12 +00001136 if (!isFunction(D) || !hasFunctionProto(D)) {
John McCall883cc2c2011-03-02 12:29:23 +00001137 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
1138 << AL.getName() << ExpectedFunction;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001139 return;
1140 }
1141
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001142 // In C++ the implicit 'this' function parameter also counts, and they are
1143 // counted from one.
Chandler Carruth87c44602011-07-01 23:49:12 +00001144 bool HasImplicitThisParam = isInstanceMethod(D);
1145 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001146
Chris Lattner5f9e2722011-07-23 10:55:15 +00001147 StringRef Module = AL.getParameterName()->getName();
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001148
1149 // Normalize the argument, __foo__ becomes foo.
1150 if (Module.startswith("__") && Module.endswith("__"))
1151 Module = Module.substr(2, Module.size() - 4);
1152
Chris Lattner5f9e2722011-07-23 10:55:15 +00001153 SmallVector<unsigned, 10> OwnershipArgs;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001154
Jordy Rose2a479922010-08-12 08:54:03 +00001155 for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E;
1156 ++I) {
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001157
Peter Collingbourne7a730022010-11-23 20:45:58 +00001158 Expr *IdxExpr = *I;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001159 llvm::APSInt ArgNum(32);
1160 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
1161 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
1162 S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int)
1163 << AL.getName()->getName() << IdxExpr->getSourceRange();
1164 continue;
1165 }
1166
1167 unsigned x = (unsigned) ArgNum.getZExtValue();
1168
1169 if (x > NumArgs || x < 1) {
1170 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
1171 << AL.getName()->getName() << x << IdxExpr->getSourceRange();
1172 continue;
1173 }
1174 --x;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00001175 if (HasImplicitThisParam) {
1176 if (x == 0) {
1177 S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
1178 << "ownership" << IdxExpr->getSourceRange();
1179 return;
1180 }
1181 --x;
1182 }
1183
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001184 switch (K) {
Sean Huntcf807c42010-08-18 23:23:40 +00001185 case OwnershipAttr::Takes:
1186 case OwnershipAttr::Holds: {
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001187 // Is the function argument a pointer type?
Chandler Carruth87c44602011-07-01 23:49:12 +00001188 QualType T = getFunctionOrMethodArgType(D, x);
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001189 if (!T->isAnyPointerType() && !T->isBlockPointerType()) {
1190 // FIXME: Should also highlight argument in decl.
1191 S.Diag(AL.getLoc(), diag::err_ownership_type)
Sean Huntcf807c42010-08-18 23:23:40 +00001192 << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds")
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001193 << "pointer"
1194 << IdxExpr->getSourceRange();
1195 continue;
1196 }
1197 break;
1198 }
Sean Huntcf807c42010-08-18 23:23:40 +00001199 case OwnershipAttr::Returns: {
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001200 if (AL.getNumArgs() > 1) {
1201 // Is the function argument an integer type?
Peter Collingbourne7a730022010-11-23 20:45:58 +00001202 Expr *IdxExpr = AL.getArg(0);
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001203 llvm::APSInt ArgNum(32);
1204 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent()
1205 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) {
1206 S.Diag(AL.getLoc(), diag::err_ownership_type)
1207 << "ownership_returns" << "integer"
1208 << IdxExpr->getSourceRange();
1209 return;
1210 }
1211 }
1212 break;
1213 }
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001214 } // switch
1215
1216 // Check we don't have a conflict with another ownership attribute.
Sean Huntcf807c42010-08-18 23:23:40 +00001217 for (specific_attr_iterator<OwnershipAttr>
Chandler Carruth87c44602011-07-01 23:49:12 +00001218 i = D->specific_attr_begin<OwnershipAttr>(),
1219 e = D->specific_attr_end<OwnershipAttr>();
Sean Huntcf807c42010-08-18 23:23:40 +00001220 i != e; ++i) {
1221 if ((*i)->getOwnKind() != K) {
1222 for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end();
1223 I!=E; ++I) {
1224 if (x == *I) {
1225 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1226 << AL.getName()->getName() << "ownership_*";
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001227 }
1228 }
1229 }
1230 }
1231 OwnershipArgs.push_back(x);
1232 }
1233
1234 unsigned* start = OwnershipArgs.data();
1235 unsigned size = OwnershipArgs.size();
1236 llvm::array_pod_sort(start, start + size);
Sean Huntcf807c42010-08-18 23:23:40 +00001237
1238 if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) {
1239 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2;
1240 return;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001241 }
Sean Huntcf807c42010-08-18 23:23:40 +00001242
Chandler Carruth87c44602011-07-01 23:49:12 +00001243 D->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module,
Sean Huntcf807c42010-08-18 23:23:40 +00001244 start, size));
Ted Kremenekdd0e4902010-07-31 01:52:11 +00001245}
1246
John McCall332bb2a2011-02-08 22:35:49 +00001247/// Whether this declaration has internal linkage for the purposes of
1248/// things that want to complain about things not have internal linkage.
1249static bool hasEffectivelyInternalLinkage(NamedDecl *D) {
1250 switch (D->getLinkage()) {
1251 case NoLinkage:
1252 case InternalLinkage:
1253 return true;
1254
1255 // Template instantiations that go from external to unique-external
1256 // shouldn't get diagnosed.
1257 case UniqueExternalLinkage:
1258 return true;
1259
1260 case ExternalLinkage:
1261 return false;
1262 }
1263 llvm_unreachable("unknown linkage kind!");
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001264}
1265
Chandler Carruth1b03c872011-07-02 00:01:44 +00001266static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001267 // Check the attribute arguments.
1268 if (Attr.getNumArgs() > 1) {
1269 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1270 return;
1271 }
1272
Chandler Carruth87c44602011-07-01 23:49:12 +00001273 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
John McCall332bb2a2011-02-08 22:35:49 +00001274 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001275 << Attr.getName() << ExpectedVariableOrFunction;
John McCall332bb2a2011-02-08 22:35:49 +00001276 return;
1277 }
1278
Chandler Carruth87c44602011-07-01 23:49:12 +00001279 NamedDecl *nd = cast<NamedDecl>(D);
John McCall332bb2a2011-02-08 22:35:49 +00001280
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001281 // gcc rejects
1282 // class c {
1283 // static int a __attribute__((weakref ("v2")));
1284 // static int b() __attribute__((weakref ("f3")));
1285 // };
1286 // and ignores the attributes of
1287 // void f(void) {
1288 // static int a __attribute__((weakref ("v2")));
1289 // }
1290 // we reject them
Chandler Carruth87c44602011-07-01 23:49:12 +00001291 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
Sebastian Redl7a126a42010-08-31 00:36:30 +00001292 if (!Ctx->isFileContext()) {
1293 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) <<
John McCall332bb2a2011-02-08 22:35:49 +00001294 nd->getNameAsString();
Sebastian Redl7a126a42010-08-31 00:36:30 +00001295 return;
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001296 }
1297
1298 // The GCC manual says
1299 //
1300 // At present, a declaration to which `weakref' is attached can only
1301 // be `static'.
1302 //
1303 // It also says
1304 //
1305 // Without a TARGET,
1306 // given as an argument to `weakref' or to `alias', `weakref' is
1307 // equivalent to `weak'.
1308 //
1309 // gcc 4.4.1 will accept
1310 // int a7 __attribute__((weakref));
1311 // as
1312 // int a7 __attribute__((weak));
1313 // This looks like a bug in gcc. We reject that for now. We should revisit
1314 // it if this behaviour is actually used.
1315
John McCall332bb2a2011-02-08 22:35:49 +00001316 if (!hasEffectivelyInternalLinkage(nd)) {
1317 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static);
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001318 return;
1319 }
1320
1321 // GCC rejects
1322 // static ((alias ("y"), weakref)).
1323 // Should we? How to check that weakref is before or after alias?
1324
1325 if (Attr.getNumArgs() == 1) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001326 Expr *Arg = Attr.getArg(0);
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001327 Arg = Arg->IgnoreParenCasts();
1328 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
1329
Douglas Gregor5cee1192011-07-27 05:40:30 +00001330 if (!Str || !Str->isAscii()) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001331 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1332 << "weakref" << 1;
1333 return;
1334 }
1335 // GCC will accept anything as the argument of weakref. Should we
1336 // check for an existing decl?
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001337 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00001338 Str->getString()));
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001339 }
1340
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001341 D->addAttr(::new (S.Context) WeakRefAttr(Attr.getRange(), S.Context));
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001342}
1343
Chandler Carruth1b03c872011-07-02 00:01:44 +00001344static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001345 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00001346 if (Attr.getNumArgs() != 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001347 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001348 return;
1349 }
Mike Stumpbf916502009-07-24 19:02:52 +00001350
Peter Collingbourne7a730022010-11-23 20:45:58 +00001351 Expr *Arg = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001352 Arg = Arg->IgnoreParenCasts();
1353 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Mike Stumpbf916502009-07-24 19:02:52 +00001354
Douglas Gregor5cee1192011-07-27 05:40:30 +00001355 if (!Str || !Str->isAscii()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001356 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00001357 << "alias" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001358 return;
1359 }
Mike Stumpbf916502009-07-24 19:02:52 +00001360
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001361 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
Rafael Espindolaf5fe2922010-12-07 15:23:23 +00001362 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1363 return;
1364 }
1365
Chris Lattner6b6b5372008-06-26 18:38:35 +00001366 // FIXME: check if target symbol exists in current file
Mike Stumpbf916502009-07-24 19:02:52 +00001367
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001368 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00001369 Str->getString()));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001370}
1371
Benjamin Krameree409a92012-05-12 21:10:52 +00001372static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1373 // Check the attribute arguments.
1374 if (!checkAttributeNumArgs(S, Attr, 0))
1375 return;
1376
1377 if (!isa<FunctionDecl>(D)) {
1378 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1379 << Attr.getName() << ExpectedFunction;
1380 return;
1381 }
1382
1383 if (D->hasAttr<HotAttr>()) {
1384 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
1385 << Attr.getName() << "hot";
1386 return;
1387 }
1388
1389 D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context));
1390}
1391
1392static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1393 // Check the attribute arguments.
1394 if (!checkAttributeNumArgs(S, Attr, 0))
1395 return;
1396
1397 if (!isa<FunctionDecl>(D)) {
1398 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1399 << Attr.getName() << ExpectedFunction;
1400 return;
1401 }
1402
1403 if (D->hasAttr<ColdAttr>()) {
1404 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
1405 << Attr.getName() << "cold";
1406 return;
1407 }
1408
1409 D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context));
1410}
1411
Chandler Carruth1b03c872011-07-02 00:01:44 +00001412static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001413 // Check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00001414 if (!checkAttributeNumArgs(S, Attr, 0))
Daniel Dunbaraf668b02008-10-28 00:17:57 +00001415 return;
Anders Carlsson5bab7882009-02-19 19:16:48 +00001416
Chandler Carruth87c44602011-07-01 23:49:12 +00001417 if (!isa<FunctionDecl>(D)) {
Anders Carlsson5bab7882009-02-19 19:16:48 +00001418 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001419 << Attr.getName() << ExpectedFunction;
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001420 return;
1421 }
1422
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001423 D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context));
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001424}
1425
Chandler Carruth1b03c872011-07-02 00:01:44 +00001426static void handleAlwaysInlineAttr(Sema &S, Decl *D,
1427 const AttributeList &Attr) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001428 // Check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00001429 if (Attr.hasParameterOrArguments()) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001430 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1431 return;
1432 }
1433
Chandler Carruth87c44602011-07-01 23:49:12 +00001434 if (!isa<FunctionDecl>(D)) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001435 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001436 << Attr.getName() << ExpectedFunction;
Anders Carlsson5bab7882009-02-19 19:16:48 +00001437 return;
1438 }
Mike Stumpbf916502009-07-24 19:02:52 +00001439
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001440 D->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getRange(), S.Context));
Daniel Dunbaraf668b02008-10-28 00:17:57 +00001441}
1442
Chandler Carruth1b03c872011-07-02 00:01:44 +00001443static void handleMallocAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbardd0cb222010-09-29 18:20:25 +00001444 // Check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00001445 if (Attr.hasParameterOrArguments()) {
Ryan Flynn76168e22009-08-09 20:07:29 +00001446 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1447 return;
1448 }
Mike Stump1eb44332009-09-09 15:08:12 +00001449
Chandler Carruth87c44602011-07-01 23:49:12 +00001450 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001451 QualType RetTy = FD->getResultType();
Ted Kremenek2cff7d12009-08-15 00:51:46 +00001452 if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) {
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001453 D->addAttr(::new (S.Context) MallocAttr(Attr.getRange(), S.Context));
Ted Kremenek2cff7d12009-08-15 00:51:46 +00001454 return;
1455 }
Ryan Flynn76168e22009-08-09 20:07:29 +00001456 }
1457
Ted Kremenek2cff7d12009-08-15 00:51:46 +00001458 S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only);
Ryan Flynn76168e22009-08-09 20:07:29 +00001459}
1460
Chandler Carruth1b03c872011-07-02 00:01:44 +00001461static void handleMayAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Dan Gohman34c26302010-11-17 00:03:07 +00001462 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00001463 if (!checkAttributeNumArgs(S, Attr, 0))
Dan Gohman34c26302010-11-17 00:03:07 +00001464 return;
Dan Gohman34c26302010-11-17 00:03:07 +00001465
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001466 D->addAttr(::new (S.Context) MayAliasAttr(Attr.getRange(), S.Context));
Dan Gohman34c26302010-11-17 00:03:07 +00001467}
1468
Chandler Carruth1b03c872011-07-02 00:01:44 +00001469static void handleNoCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth56aeb402011-07-11 23:33:05 +00001470 assert(!Attr.isInvalid());
Chandler Carruth87c44602011-07-01 23:49:12 +00001471 if (isa<VarDecl>(D))
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001472 D->addAttr(::new (S.Context) NoCommonAttr(Attr.getRange(), S.Context));
Eric Christopher722109c2010-12-03 06:58:14 +00001473 else
1474 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001475 << Attr.getName() << ExpectedVariable;
Eric Christophera6cf1e72010-12-02 02:45:55 +00001476}
1477
Chandler Carruth1b03c872011-07-02 00:01:44 +00001478static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth56aeb402011-07-11 23:33:05 +00001479 assert(!Attr.isInvalid());
Chandler Carruth87c44602011-07-01 23:49:12 +00001480 if (isa<VarDecl>(D))
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001481 D->addAttr(::new (S.Context) CommonAttr(Attr.getRange(), S.Context));
Eric Christopher722109c2010-12-03 06:58:14 +00001482 else
1483 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001484 << Attr.getName() << ExpectedVariable;
Eric Christophera6cf1e72010-12-02 02:45:55 +00001485}
1486
Chandler Carruth1b03c872011-07-02 00:01:44 +00001487static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00001488 if (hasDeclarator(D)) return;
John McCall711c52b2011-01-05 12:14:39 +00001489
1490 if (S.CheckNoReturnAttr(attr)) return;
1491
Chandler Carruth87c44602011-07-01 23:49:12 +00001492 if (!isa<ObjCMethodDecl>(D)) {
John McCall711c52b2011-01-05 12:14:39 +00001493 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001494 << attr.getName() << ExpectedFunctionOrMethod;
John McCall711c52b2011-01-05 12:14:39 +00001495 return;
1496 }
1497
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001498 D->addAttr(::new (S.Context) NoReturnAttr(attr.getRange(), S.Context));
John McCall711c52b2011-01-05 12:14:39 +00001499}
1500
1501bool Sema::CheckNoReturnAttr(const AttributeList &attr) {
Ted Kremenek831efae2011-04-15 05:49:29 +00001502 if (attr.hasParameterOrArguments()) {
John McCall711c52b2011-01-05 12:14:39 +00001503 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1504 attr.setInvalid();
1505 return true;
1506 }
1507
1508 return false;
Ted Kremenekb7252322009-04-10 00:01:14 +00001509}
1510
Chandler Carruth1b03c872011-07-02 00:01:44 +00001511static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
1512 const AttributeList &Attr) {
Ted Kremenekb56c1cc2010-08-19 00:51:58 +00001513
1514 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
1515 // because 'analyzer_noreturn' does not impact the type.
1516
Chandler Carruth1731e202011-07-11 23:30:35 +00001517 if(!checkAttributeNumArgs(S, Attr, 0))
1518 return;
Ted Kremenekb56c1cc2010-08-19 00:51:58 +00001519
Chandler Carruth87c44602011-07-01 23:49:12 +00001520 if (!isFunctionOrMethod(D) && !isa<BlockDecl>(D)) {
1521 ValueDecl *VD = dyn_cast<ValueDecl>(D);
Ted Kremenekb56c1cc2010-08-19 00:51:58 +00001522 if (VD == 0 || (!VD->getType()->isBlockPointerType()
1523 && !VD->getType()->isFunctionPointerType())) {
1524 S.Diag(Attr.getLoc(),
1525 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type
1526 : diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001527 << Attr.getName() << ExpectedFunctionMethodOrBlock;
Ted Kremenekb56c1cc2010-08-19 00:51:58 +00001528 return;
1529 }
1530 }
1531
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001532 D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getRange(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00001533}
1534
John Thompson35cc9622010-08-09 21:53:52 +00001535// PS3 PPU-specific.
Chandler Carruth1b03c872011-07-02 00:01:44 +00001536static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
John Thompson35cc9622010-08-09 21:53:52 +00001537/*
1538 Returning a Vector Class in Registers
1539
Eric Christopherf48f3672010-12-01 22:13:54 +00001540 According to the PPU ABI specifications, a class with a single member of
1541 vector type is returned in memory when used as the return value of a function.
1542 This results in inefficient code when implementing vector classes. To return
1543 the value in a single vector register, add the vecreturn attribute to the
1544 class definition. This attribute is also applicable to struct types.
John Thompson35cc9622010-08-09 21:53:52 +00001545
1546 Example:
1547
1548 struct Vector
1549 {
1550 __vector float xyzw;
1551 } __attribute__((vecreturn));
1552
1553 Vector Add(Vector lhs, Vector rhs)
1554 {
1555 Vector result;
1556 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
1557 return result; // This will be returned in a register
1558 }
1559*/
Chandler Carruth87c44602011-07-01 23:49:12 +00001560 if (!isa<RecordDecl>(D)) {
John Thompson35cc9622010-08-09 21:53:52 +00001561 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001562 << Attr.getName() << ExpectedClass;
John Thompson35cc9622010-08-09 21:53:52 +00001563 return;
1564 }
1565
Chandler Carruth87c44602011-07-01 23:49:12 +00001566 if (D->getAttr<VecReturnAttr>()) {
John Thompson35cc9622010-08-09 21:53:52 +00001567 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn";
1568 return;
1569 }
1570
Chandler Carruth87c44602011-07-01 23:49:12 +00001571 RecordDecl *record = cast<RecordDecl>(D);
John Thompson01add592010-09-18 01:12:07 +00001572 int count = 0;
1573
1574 if (!isa<CXXRecordDecl>(record)) {
1575 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1576 return;
1577 }
1578
1579 if (!cast<CXXRecordDecl>(record)->isPOD()) {
1580 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
1581 return;
1582 }
1583
Eric Christopherf48f3672010-12-01 22:13:54 +00001584 for (RecordDecl::field_iterator iter = record->field_begin();
1585 iter != record->field_end(); iter++) {
John Thompson01add592010-09-18 01:12:07 +00001586 if ((count == 1) || !iter->getType()->isVectorType()) {
1587 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
1588 return;
1589 }
1590 count++;
1591 }
1592
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001593 D->addAttr(::new (S.Context) VecReturnAttr(Attr.getRange(), S.Context));
John Thompson35cc9622010-08-09 21:53:52 +00001594}
1595
Chandler Carruth1b03c872011-07-02 00:01:44 +00001596static void handleDependencyAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00001597 if (!isFunctionOrMethod(D) && !isa<ParmVarDecl>(D)) {
Sean Huntbbd37c62009-11-21 08:43:09 +00001598 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001599 << Attr.getName() << ExpectedFunctionMethodOrParameter;
Sean Huntbbd37c62009-11-21 08:43:09 +00001600 return;
1601 }
1602 // FIXME: Actually store the attribute on the declaration
1603}
1604
Chandler Carruth1b03c872011-07-02 00:01:44 +00001605static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Ted Kremenek73798892008-07-25 04:39:19 +00001606 // check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00001607 if (Attr.hasParameterOrArguments()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00001608 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Ted Kremenek73798892008-07-25 04:39:19 +00001609 return;
1610 }
Mike Stumpbf916502009-07-24 19:02:52 +00001611
Chandler Carruth87c44602011-07-01 23:49:12 +00001612 if (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isFunctionOrMethod(D) &&
Daniel Jasper568eae42012-06-13 18:31:09 +00001613 !isa<TypeDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001614 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001615 << Attr.getName() << ExpectedVariableFunctionOrLabel;
Ted Kremenek73798892008-07-25 04:39:19 +00001616 return;
1617 }
Mike Stumpbf916502009-07-24 19:02:52 +00001618
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001619 D->addAttr(::new (S.Context) UnusedAttr(Attr.getRange(), S.Context));
Ted Kremenek73798892008-07-25 04:39:19 +00001620}
1621
Rafael Espindolaf87cced2011-10-03 14:59:42 +00001622static void handleReturnsTwiceAttr(Sema &S, Decl *D,
1623 const AttributeList &Attr) {
1624 // check the attribute arguments.
1625 if (Attr.hasParameterOrArguments()) {
1626 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1627 return;
1628 }
1629
1630 if (!isa<FunctionDecl>(D)) {
1631 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
1632 << Attr.getName() << ExpectedFunction;
1633 return;
1634 }
1635
1636 D->addAttr(::new (S.Context) ReturnsTwiceAttr(Attr.getRange(), S.Context));
1637}
1638
Chandler Carruth1b03c872011-07-02 00:01:44 +00001639static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001640 // check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00001641 if (Attr.hasParameterOrArguments()) {
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001642 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
1643 return;
1644 }
Mike Stumpbf916502009-07-24 19:02:52 +00001645
Chandler Carruth87c44602011-07-01 23:49:12 +00001646 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Daniel Dunbar186204b2009-02-13 22:48:56 +00001647 if (VD->hasLocalStorage() || VD->hasExternalStorage()) {
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001648 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used";
1649 return;
1650 }
Chandler Carruth87c44602011-07-01 23:49:12 +00001651 } else if (!isFunctionOrMethod(D)) {
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001652 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001653 << Attr.getName() << ExpectedVariableOrFunction;
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001654 return;
1655 }
Mike Stumpbf916502009-07-24 19:02:52 +00001656
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001657 D->addAttr(::new (S.Context) UsedAttr(Attr.getRange(), S.Context));
Daniel Dunbarb805dad2009-02-13 19:23:53 +00001658}
1659
Chandler Carruth1b03c872011-07-02 00:01:44 +00001660static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001661 // check the attribute arguments.
John McCallbdc49d32011-03-02 12:15:05 +00001662 if (Attr.getNumArgs() > 1) {
1663 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001664 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001665 }
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001666
1667 int priority = 65535; // FIXME: Do not hardcode such constants.
1668 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001669 Expr *E = Attr.getArg(0);
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001670 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001671 if (E->isTypeDependent() || E->isValueDependent() ||
1672 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001673 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001674 << "constructor" << 1 << E->getSourceRange();
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001675 return;
1676 }
1677 priority = Idx.getZExtValue();
1678 }
Mike Stumpbf916502009-07-24 19:02:52 +00001679
Chandler Carruth87c44602011-07-01 23:49:12 +00001680 if (!isa<FunctionDecl>(D)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001681 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001682 << Attr.getName() << ExpectedFunction;
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001683 return;
1684 }
1685
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001686 D->addAttr(::new (S.Context) ConstructorAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00001687 priority));
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001688}
1689
Chandler Carruth1b03c872011-07-02 00:01:44 +00001690static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001691 // check the attribute arguments.
John McCallbdc49d32011-03-02 12:15:05 +00001692 if (Attr.getNumArgs() > 1) {
1693 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001694 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001695 }
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001696
1697 int priority = 65535; // FIXME: Do not hardcode such constants.
1698 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00001699 Expr *E = Attr.getArg(0);
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001700 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00001701 if (E->isTypeDependent() || E->isValueDependent() ||
1702 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001703 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00001704 << "destructor" << 1 << E->getSourceRange();
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001705 return;
1706 }
1707 priority = Idx.getZExtValue();
1708 }
Mike Stumpbf916502009-07-24 19:02:52 +00001709
Chandler Carruth87c44602011-07-01 23:49:12 +00001710 if (!isa<FunctionDecl>(D)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001711 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00001712 << Attr.getName() << ExpectedFunction;
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001713 return;
1714 }
1715
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001716 D->addAttr(::new (S.Context) DestructorAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00001717 priority));
Daniel Dunbar3068ae02008-07-31 22:40:48 +00001718}
1719
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00001720template <typename AttrTy>
1721static void handleAttrWithMessage(Sema &S, Decl *D, const AttributeList &Attr,
1722 const char *Name) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001723 unsigned NumArgs = Attr.getNumArgs();
1724 if (NumArgs > 1) {
John McCallbdc49d32011-03-02 12:15:05 +00001725 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001726 return;
1727 }
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00001728
1729 // Handle the case where the attribute has a text message.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001730 StringRef Str;
Chris Lattner951bbb22011-02-24 05:42:24 +00001731 if (NumArgs == 1) {
1732 StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0));
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001733 if (!SE) {
Chris Lattner951bbb22011-02-24 05:42:24 +00001734 S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string)
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00001735 << Name;
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001736 return;
1737 }
Chris Lattner951bbb22011-02-24 05:42:24 +00001738 Str = SE->getString();
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00001739 }
Mike Stumpbf916502009-07-24 19:02:52 +00001740
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00001741 D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str));
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00001742}
1743
Fariborz Jahanian742352a2011-07-06 19:24:05 +00001744static void handleArcWeakrefUnavailableAttr(Sema &S, Decl *D,
1745 const AttributeList &Attr) {
1746 unsigned NumArgs = Attr.getNumArgs();
1747 if (NumArgs > 0) {
1748 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1749 return;
1750 }
1751
1752 D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00001753 Attr.getRange(), S.Context));
Fariborz Jahanian742352a2011-07-06 19:24:05 +00001754}
1755
Patrick Beardb2f68202012-04-06 18:12:22 +00001756static void handleObjCRootClassAttr(Sema &S, Decl *D,
1757 const AttributeList &Attr) {
1758 if (!isa<ObjCInterfaceDecl>(D)) {
1759 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
1760 return;
1761 }
1762
1763 unsigned NumArgs = Attr.getNumArgs();
1764 if (NumArgs > 0) {
1765 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1766 return;
1767 }
1768
1769 D->addAttr(::new (S.Context) ObjCRootClassAttr(Attr.getRange(), S.Context));
1770}
1771
Ted Kremenek71207fc2012-01-05 22:47:47 +00001772static void handleObjCRequiresPropertyDefsAttr(Sema &S, Decl *D,
Fariborz Jahaniane23dcf32012-01-03 18:45:41 +00001773 const AttributeList &Attr) {
Fariborz Jahanian341b8be2012-01-03 22:52:32 +00001774 if (!isa<ObjCInterfaceDecl>(D)) {
1775 S.Diag(Attr.getLoc(), diag::err_suppress_autosynthesis);
1776 return;
1777 }
1778
Fariborz Jahaniane23dcf32012-01-03 18:45:41 +00001779 unsigned NumArgs = Attr.getNumArgs();
1780 if (NumArgs > 0) {
1781 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0;
1782 return;
1783 }
1784
Ted Kremenek71207fc2012-01-05 22:47:47 +00001785 D->addAttr(::new (S.Context) ObjCRequiresPropertyDefsAttr(
Fariborz Jahaniane23dcf32012-01-03 18:45:41 +00001786 Attr.getRange(), S.Context));
1787}
1788
Jordy Rosefad5de92012-05-08 03:27:22 +00001789static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
1790 IdentifierInfo *Platform,
1791 VersionTuple Introduced,
1792 VersionTuple Deprecated,
1793 VersionTuple Obsoleted) {
Rafael Espindola3b294362012-05-06 19:56:25 +00001794 StringRef PlatformName
1795 = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
1796 if (PlatformName.empty())
1797 PlatformName = Platform->getName();
1798
1799 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
1800 // of these steps are needed).
1801 if (!Introduced.empty() && !Deprecated.empty() &&
1802 !(Introduced <= Deprecated)) {
1803 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1804 << 1 << PlatformName << Deprecated.getAsString()
1805 << 0 << Introduced.getAsString();
1806 return true;
1807 }
1808
1809 if (!Introduced.empty() && !Obsoleted.empty() &&
1810 !(Introduced <= Obsoleted)) {
1811 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1812 << 2 << PlatformName << Obsoleted.getAsString()
1813 << 0 << Introduced.getAsString();
1814 return true;
1815 }
1816
1817 if (!Deprecated.empty() && !Obsoleted.empty() &&
1818 !(Deprecated <= Obsoleted)) {
1819 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
1820 << 2 << PlatformName << Obsoleted.getAsString()
1821 << 1 << Deprecated.getAsString();
1822 return true;
1823 }
1824
1825 return false;
1826}
1827
Rafael Espindola599f1b72012-05-13 03:25:18 +00001828AvailabilityAttr *Sema::mergeAvailabilityAttr(Decl *D, SourceRange Range,
1829 IdentifierInfo *Platform,
1830 VersionTuple Introduced,
1831 VersionTuple Deprecated,
1832 VersionTuple Obsoleted,
1833 bool IsUnavailable,
1834 StringRef Message) {
Rafael Espindola98ae8342012-05-10 02:50:16 +00001835 VersionTuple MergedIntroduced = Introduced;
1836 VersionTuple MergedDeprecated = Deprecated;
1837 VersionTuple MergedObsoleted = Obsoleted;
Rafael Espindola3b294362012-05-06 19:56:25 +00001838 bool FoundAny = false;
1839
Rafael Espindola98ae8342012-05-10 02:50:16 +00001840 if (D->hasAttrs()) {
1841 AttrVec &Attrs = D->getAttrs();
1842 for (unsigned i = 0, e = Attrs.size(); i != e;) {
1843 const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
1844 if (!OldAA) {
1845 ++i;
1846 continue;
1847 }
Rafael Espindola3b294362012-05-06 19:56:25 +00001848
Rafael Espindola98ae8342012-05-10 02:50:16 +00001849 IdentifierInfo *OldPlatform = OldAA->getPlatform();
1850 if (OldPlatform != Platform) {
1851 ++i;
1852 continue;
1853 }
1854
1855 FoundAny = true;
1856 VersionTuple OldIntroduced = OldAA->getIntroduced();
1857 VersionTuple OldDeprecated = OldAA->getDeprecated();
1858 VersionTuple OldObsoleted = OldAA->getObsoleted();
1859 bool OldIsUnavailable = OldAA->getUnavailable();
1860 StringRef OldMessage = OldAA->getMessage();
1861
1862 if ((!OldIntroduced.empty() && !Introduced.empty() &&
1863 OldIntroduced != Introduced) ||
1864 (!OldDeprecated.empty() && !Deprecated.empty() &&
1865 OldDeprecated != Deprecated) ||
1866 (!OldObsoleted.empty() && !Obsoleted.empty() &&
1867 OldObsoleted != Obsoleted) ||
1868 (OldIsUnavailable != IsUnavailable) ||
1869 (OldMessage != Message)) {
1870 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
1871 Diag(Range.getBegin(), diag::note_previous_attribute);
1872 Attrs.erase(Attrs.begin() + i);
1873 --e;
1874 continue;
1875 }
1876
1877 VersionTuple MergedIntroduced2 = MergedIntroduced;
1878 VersionTuple MergedDeprecated2 = MergedDeprecated;
1879 VersionTuple MergedObsoleted2 = MergedObsoleted;
1880
1881 if (MergedIntroduced2.empty())
1882 MergedIntroduced2 = OldIntroduced;
1883 if (MergedDeprecated2.empty())
1884 MergedDeprecated2 = OldDeprecated;
1885 if (MergedObsoleted2.empty())
1886 MergedObsoleted2 = OldObsoleted;
1887
1888 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
1889 MergedIntroduced2, MergedDeprecated2,
1890 MergedObsoleted2)) {
1891 Attrs.erase(Attrs.begin() + i);
1892 --e;
1893 continue;
1894 }
1895
1896 MergedIntroduced = MergedIntroduced2;
1897 MergedDeprecated = MergedDeprecated2;
1898 MergedObsoleted = MergedObsoleted2;
1899 ++i;
Rafael Espindola3b294362012-05-06 19:56:25 +00001900 }
Rafael Espindola3b294362012-05-06 19:56:25 +00001901 }
1902
1903 if (FoundAny &&
1904 MergedIntroduced == Introduced &&
1905 MergedDeprecated == Deprecated &&
1906 MergedObsoleted == Obsoleted)
Rafael Espindola599f1b72012-05-13 03:25:18 +00001907 return NULL;
Rafael Espindola3b294362012-05-06 19:56:25 +00001908
Rafael Espindola98ae8342012-05-10 02:50:16 +00001909 if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
Rafael Espindola3b294362012-05-06 19:56:25 +00001910 MergedDeprecated, MergedObsoleted)) {
Rafael Espindola599f1b72012-05-13 03:25:18 +00001911 return ::new (Context) AvailabilityAttr(Range, Context, Platform,
1912 Introduced, Deprecated,
1913 Obsoleted, IsUnavailable, Message);
Rafael Espindola3b294362012-05-06 19:56:25 +00001914 }
Rafael Espindola599f1b72012-05-13 03:25:18 +00001915 return NULL;
Rafael Espindola3b294362012-05-06 19:56:25 +00001916}
1917
Chandler Carruth1b03c872011-07-02 00:01:44 +00001918static void handleAvailabilityAttr(Sema &S, Decl *D,
1919 const AttributeList &Attr) {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001920 IdentifierInfo *Platform = Attr.getParameterName();
1921 SourceLocation PlatformLoc = Attr.getParameterLoc();
1922
Rafael Espindola3b294362012-05-06 19:56:25 +00001923 if (AvailabilityAttr::getPrettyPlatformName(Platform->getName()).empty())
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001924 S.Diag(PlatformLoc, diag::warn_availability_unknown_platform)
1925 << Platform;
1926
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001927 AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
1928 AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
1929 AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
Douglas Gregorb53e4172011-03-26 03:35:55 +00001930 bool IsUnavailable = Attr.getUnavailableLoc().isValid();
Fariborz Jahanian006e42f2011-12-10 00:28:41 +00001931 StringRef Str;
1932 const StringLiteral *SE =
1933 dyn_cast_or_null<const StringLiteral>(Attr.getMessageExpr());
1934 if (SE)
1935 Str = SE->getString();
Rafael Espindola3b294362012-05-06 19:56:25 +00001936
Rafael Espindola599f1b72012-05-13 03:25:18 +00001937 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(D, Attr.getRange(),
1938 Platform,
1939 Introduced.Version,
1940 Deprecated.Version,
1941 Obsoleted.Version,
1942 IsUnavailable, Str);
1943 if (NewAttr)
1944 D->addAttr(NewAttr);
Rafael Espindola98ae8342012-05-10 02:50:16 +00001945}
1946
Rafael Espindola599f1b72012-05-13 03:25:18 +00001947VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
1948 VisibilityAttr::VisibilityType Vis) {
Rafael Espindoladd44f342012-05-10 03:01:34 +00001949 if (isa<TypedefNameDecl>(D)) {
1950 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "visibility";
Rafael Espindola599f1b72012-05-13 03:25:18 +00001951 return NULL;
Rafael Espindoladd44f342012-05-10 03:01:34 +00001952 }
Rafael Espindola98ae8342012-05-10 02:50:16 +00001953 VisibilityAttr *ExistingAttr = D->getAttr<VisibilityAttr>();
1954 if (ExistingAttr) {
1955 VisibilityAttr::VisibilityType ExistingVis = ExistingAttr->getVisibility();
1956 if (ExistingVis == Vis)
Rafael Espindola599f1b72012-05-13 03:25:18 +00001957 return NULL;
Rafael Espindola98ae8342012-05-10 02:50:16 +00001958 Diag(ExistingAttr->getLocation(), diag::err_mismatched_visibility);
1959 Diag(Range.getBegin(), diag::note_previous_attribute);
1960 D->dropAttr<VisibilityAttr>();
1961 }
Rafael Espindola599f1b72012-05-13 03:25:18 +00001962 return ::new (Context) VisibilityAttr(Range, Context, Vis);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001963}
1964
Chandler Carruth1b03c872011-07-02 00:01:44 +00001965static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00001966 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00001967 if(!checkAttributeNumArgs(S, Attr, 1))
Chris Lattner6b6b5372008-06-26 18:38:35 +00001968 return;
Mike Stumpbf916502009-07-24 19:02:52 +00001969
Peter Collingbourne7a730022010-11-23 20:45:58 +00001970 Expr *Arg = Attr.getArg(0);
Chris Lattner6b6b5372008-06-26 18:38:35 +00001971 Arg = Arg->IgnoreParenCasts();
1972 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Mike Stumpbf916502009-07-24 19:02:52 +00001973
Douglas Gregor5cee1192011-07-27 05:40:30 +00001974 if (!Str || !Str->isAscii()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001975 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00001976 << "visibility" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00001977 return;
1978 }
Mike Stumpbf916502009-07-24 19:02:52 +00001979
Chris Lattner5f9e2722011-07-23 10:55:15 +00001980 StringRef TypeStr = Str->getString();
Sean Huntcf807c42010-08-18 23:23:40 +00001981 VisibilityAttr::VisibilityType type;
Mike Stumpbf916502009-07-24 19:02:52 +00001982
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001983 if (TypeStr == "default")
Sean Huntcf807c42010-08-18 23:23:40 +00001984 type = VisibilityAttr::Default;
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001985 else if (TypeStr == "hidden")
Sean Huntcf807c42010-08-18 23:23:40 +00001986 type = VisibilityAttr::Hidden;
Benjamin Kramerc96f4942010-01-23 18:16:35 +00001987 else if (TypeStr == "internal")
Sean Huntcf807c42010-08-18 23:23:40 +00001988 type = VisibilityAttr::Hidden; // FIXME
John McCall41887602012-01-29 01:20:30 +00001989 else if (TypeStr == "protected") {
1990 // Complain about attempts to use protected visibility on targets
1991 // (like Darwin) that don't support it.
1992 if (!S.Context.getTargetInfo().hasProtectedVisibility()) {
1993 S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
1994 type = VisibilityAttr::Default;
1995 } else {
1996 type = VisibilityAttr::Protected;
1997 }
1998 } else {
Chris Lattner08631c52008-11-23 21:45:46 +00001999 S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002000 return;
2001 }
Mike Stumpbf916502009-07-24 19:02:52 +00002002
Rafael Espindola599f1b72012-05-13 03:25:18 +00002003 VisibilityAttr *NewAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type);
2004 if (NewAttr)
2005 D->addAttr(NewAttr);
Chris Lattner6b6b5372008-06-26 18:38:35 +00002006}
2007
Chandler Carruth1b03c872011-07-02 00:01:44 +00002008static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
2009 const AttributeList &Attr) {
John McCalld5313b02011-03-02 11:33:24 +00002010 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl);
2011 if (!method) {
Chandler Carruth87c44602011-07-01 23:49:12 +00002012 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002013 << ExpectedMethod;
John McCalld5313b02011-03-02 11:33:24 +00002014 return;
2015 }
2016
Chandler Carruth87c44602011-07-01 23:49:12 +00002017 if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) {
2018 if (!Attr.getParameterName() && Attr.getNumArgs() == 1) {
2019 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
John McCalld5313b02011-03-02 11:33:24 +00002020 << "objc_method_family" << 1;
2021 } else {
Chandler Carruth87c44602011-07-01 23:49:12 +00002022 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
John McCalld5313b02011-03-02 11:33:24 +00002023 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002024 Attr.setInvalid();
John McCalld5313b02011-03-02 11:33:24 +00002025 return;
2026 }
2027
Chris Lattner5f9e2722011-07-23 10:55:15 +00002028 StringRef param = Attr.getParameterName()->getName();
John McCalld5313b02011-03-02 11:33:24 +00002029 ObjCMethodFamilyAttr::FamilyKind family;
2030 if (param == "none")
2031 family = ObjCMethodFamilyAttr::OMF_None;
2032 else if (param == "alloc")
2033 family = ObjCMethodFamilyAttr::OMF_alloc;
2034 else if (param == "copy")
2035 family = ObjCMethodFamilyAttr::OMF_copy;
2036 else if (param == "init")
2037 family = ObjCMethodFamilyAttr::OMF_init;
2038 else if (param == "mutableCopy")
2039 family = ObjCMethodFamilyAttr::OMF_mutableCopy;
2040 else if (param == "new")
2041 family = ObjCMethodFamilyAttr::OMF_new;
2042 else {
2043 // Just warn and ignore it. This is future-proof against new
2044 // families being used in system headers.
Chandler Carruth87c44602011-07-01 23:49:12 +00002045 S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family);
John McCalld5313b02011-03-02 11:33:24 +00002046 return;
2047 }
2048
John McCallf85e1932011-06-15 23:02:42 +00002049 if (family == ObjCMethodFamilyAttr::OMF_init &&
2050 !method->getResultType()->isObjCObjectPointerType()) {
2051 S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
2052 << method->getResultType();
2053 // Ignore the attribute.
2054 return;
2055 }
2056
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002057 method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
John McCallf85e1932011-06-15 23:02:42 +00002058 S.Context, family));
John McCalld5313b02011-03-02 11:33:24 +00002059}
2060
Chandler Carruth1b03c872011-07-02 00:01:44 +00002061static void handleObjCExceptionAttr(Sema &S, Decl *D,
2062 const AttributeList &Attr) {
Chandler Carruth1731e202011-07-11 23:30:35 +00002063 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner0db29ec2009-02-14 08:09:34 +00002064 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002065
Chris Lattner0db29ec2009-02-14 08:09:34 +00002066 ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D);
2067 if (OCI == 0) {
2068 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface);
2069 return;
2070 }
Mike Stumpbf916502009-07-24 19:02:52 +00002071
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002072 D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getRange(), S.Context));
Chris Lattner0db29ec2009-02-14 08:09:34 +00002073}
2074
Chandler Carruth1b03c872011-07-02 00:01:44 +00002075static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00002076 if (Attr.getNumArgs() != 0) {
John McCall2b7baf02010-05-28 18:25:28 +00002077 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00002078 return;
2079 }
Richard Smith162e1c12011-04-15 14:24:37 +00002080 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00002081 QualType T = TD->getUnderlyingType();
2082 if (!T->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00002083 !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00002084 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2085 return;
2086 }
2087 }
Fariborz Jahanian34276822012-05-31 23:18:32 +00002088 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2089 QualType T = PD->getType();
2090 if (!T->isPointerType() ||
2091 !T->getAs<PointerType>()->getPointeeType()->isRecordType()) {
2092 S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2093 return;
2094 }
2095 }
2096 else {
Ted Kremenekf6e88d72012-03-01 01:40:32 +00002097 // It is okay to include this attribute on properties, e.g.:
2098 //
2099 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2100 //
2101 // In this case it follows tradition and suppresses an error in the above
2102 // case.
Fariborz Jahanian9b2eb7b2011-11-29 01:48:40 +00002103 S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
Ted Kremenekf6e88d72012-03-01 01:40:32 +00002104 }
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002105 D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getRange(), S.Context));
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00002106}
2107
Mike Stumpbf916502009-07-24 19:02:52 +00002108static void
Chandler Carruth1b03c872011-07-02 00:01:44 +00002109handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Douglas Gregorf9201e02009-02-11 23:02:49 +00002110 if (Attr.getNumArgs() != 0) {
John McCall2b7baf02010-05-28 18:25:28 +00002111 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Douglas Gregorf9201e02009-02-11 23:02:49 +00002112 return;
2113 }
2114
2115 if (!isa<FunctionDecl>(D)) {
2116 S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function);
2117 return;
2118 }
2119
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002120 D->addAttr(::new (S.Context) OverloadableAttr(Attr.getRange(), S.Context));
Douglas Gregorf9201e02009-02-11 23:02:49 +00002121}
2122
Chandler Carruth1b03c872011-07-02 00:01:44 +00002123static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Mike Stumpbf916502009-07-24 19:02:52 +00002124 if (!Attr.getParameterName()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002125 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00002126 << "blocks" << 1;
Steve Naroff9eae5762008-09-18 16:44:58 +00002127 return;
2128 }
Mike Stumpbf916502009-07-24 19:02:52 +00002129
Steve Naroff9eae5762008-09-18 16:44:58 +00002130 if (Attr.getNumArgs() != 0) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002131 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Steve Naroff9eae5762008-09-18 16:44:58 +00002132 return;
2133 }
Mike Stumpbf916502009-07-24 19:02:52 +00002134
Sean Huntcf807c42010-08-18 23:23:40 +00002135 BlocksAttr::BlockType type;
Chris Lattner92e62b02008-11-20 04:42:34 +00002136 if (Attr.getParameterName()->isStr("byref"))
Steve Naroff9eae5762008-09-18 16:44:58 +00002137 type = BlocksAttr::ByRef;
2138 else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002139 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
Chris Lattner3c73c412008-11-19 08:23:25 +00002140 << "blocks" << Attr.getParameterName();
Steve Naroff9eae5762008-09-18 16:44:58 +00002141 return;
2142 }
Mike Stumpbf916502009-07-24 19:02:52 +00002143
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002144 D->addAttr(::new (S.Context) BlocksAttr(Attr.getRange(), S.Context, type));
Steve Naroff9eae5762008-09-18 16:44:58 +00002145}
2146
Chandler Carruth1b03c872011-07-02 00:01:44 +00002147static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Anders Carlsson77091822008-10-05 18:05:59 +00002148 // check the attribute arguments.
2149 if (Attr.getNumArgs() > 2) {
John McCallbdc49d32011-03-02 12:15:05 +00002150 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
Anders Carlsson77091822008-10-05 18:05:59 +00002151 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002152 }
2153
John McCall3323fad2011-09-09 07:56:05 +00002154 unsigned sentinel = 0;
Anders Carlsson77091822008-10-05 18:05:59 +00002155 if (Attr.getNumArgs() > 0) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00002156 Expr *E = Attr.getArg(0);
Anders Carlsson77091822008-10-05 18:05:59 +00002157 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002158 if (E->isTypeDependent() || E->isValueDependent() ||
2159 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002160 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00002161 << "sentinel" << 1 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00002162 return;
2163 }
Mike Stumpbf916502009-07-24 19:02:52 +00002164
John McCall3323fad2011-09-09 07:56:05 +00002165 if (Idx.isSigned() && Idx.isNegative()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002166 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2167 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00002168 return;
2169 }
John McCall3323fad2011-09-09 07:56:05 +00002170
2171 sentinel = Idx.getZExtValue();
Anders Carlsson77091822008-10-05 18:05:59 +00002172 }
2173
John McCall3323fad2011-09-09 07:56:05 +00002174 unsigned nullPos = 0;
Anders Carlsson77091822008-10-05 18:05:59 +00002175 if (Attr.getNumArgs() > 1) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00002176 Expr *E = Attr.getArg(1);
Anders Carlsson77091822008-10-05 18:05:59 +00002177 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002178 if (E->isTypeDependent() || E->isValueDependent() ||
2179 !E->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002180 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00002181 << "sentinel" << 2 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00002182 return;
2183 }
2184 nullPos = Idx.getZExtValue();
Mike Stumpbf916502009-07-24 19:02:52 +00002185
John McCall3323fad2011-09-09 07:56:05 +00002186 if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
Anders Carlsson77091822008-10-05 18:05:59 +00002187 // FIXME: This error message could be improved, it would be nice
2188 // to say what the bounds actually are.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002189 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2190 << E->getSourceRange();
Anders Carlsson77091822008-10-05 18:05:59 +00002191 return;
2192 }
2193 }
2194
Chandler Carruth87c44602011-07-01 23:49:12 +00002195 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
John McCall3323fad2011-09-09 07:56:05 +00002196 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
Chris Lattner897cd902009-03-17 23:03:47 +00002197 if (isa<FunctionNoProtoType>(FT)) {
2198 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2199 return;
2200 }
Mike Stumpbf916502009-07-24 19:02:52 +00002201
Chris Lattner897cd902009-03-17 23:03:47 +00002202 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00002203 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
Anders Carlsson77091822008-10-05 18:05:59 +00002204 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002205 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002206 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
Anders Carlsson77091822008-10-05 18:05:59 +00002207 if (!MD->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00002208 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
Anders Carlsson77091822008-10-05 18:05:59 +00002209 return;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002210 }
Eli Friedmana0b2ba12012-01-06 01:23:10 +00002211 } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
2212 if (!BD->isVariadic()) {
2213 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2214 return;
2215 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002216 } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002217 QualType Ty = V->getType();
Fariborz Jahaniandaf04152009-05-15 20:33:25 +00002218 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
Chandler Carruth87c44602011-07-01 23:49:12 +00002219 const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D)
Eric Christopherf48f3672010-12-01 22:13:54 +00002220 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002221 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
Fariborz Jahanian3bba33d2009-05-15 21:18:04 +00002222 int m = Ty->isFunctionPointerType() ? 0 : 1;
2223 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002224 return;
2225 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +00002226 } else {
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002227 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002228 << Attr.getName() << ExpectedFunctionMethodOrBlock;
Fariborz Jahanian2f7c3922009-05-14 20:53:39 +00002229 return;
2230 }
Anders Carlsson77091822008-10-05 18:05:59 +00002231 } else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002232 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002233 << Attr.getName() << ExpectedFunctionMethodOrBlock;
Anders Carlsson77091822008-10-05 18:05:59 +00002234 return;
2235 }
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002236 D->addAttr(::new (S.Context) SentinelAttr(Attr.getRange(), S.Context, sentinel,
Eric Christopherf48f3672010-12-01 22:13:54 +00002237 nullPos));
Anders Carlsson77091822008-10-05 18:05:59 +00002238}
2239
Chandler Carruth1b03c872011-07-02 00:01:44 +00002240static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner026dc962009-02-14 07:37:35 +00002241 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002242 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner026dc962009-02-14 07:37:35 +00002243 return;
Chris Lattner026dc962009-02-14 07:37:35 +00002244
Fariborz Jahanianf0317742010-03-30 18:22:15 +00002245 if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) {
Chris Lattner026dc962009-02-14 07:37:35 +00002246 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002247 << Attr.getName() << ExpectedFunctionOrMethod;
Chris Lattner026dc962009-02-14 07:37:35 +00002248 return;
2249 }
Mike Stumpbf916502009-07-24 19:02:52 +00002250
Fariborz Jahanianf0317742010-03-30 18:22:15 +00002251 if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) {
2252 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2253 << Attr.getName() << 0;
Nuno Lopesf8577982009-12-22 23:59:52 +00002254 return;
2255 }
Fariborz Jahanianf0317742010-03-30 18:22:15 +00002256 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2257 if (MD->getResultType()->isVoidType()) {
2258 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2259 << Attr.getName() << 1;
2260 return;
2261 }
2262
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002263 D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getRange(), S.Context));
Chris Lattner026dc962009-02-14 07:37:35 +00002264}
2265
Chandler Carruth1b03c872011-07-02 00:01:44 +00002266static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002267 // check the attribute arguments.
Chandler Carruth87c44602011-07-01 23:49:12 +00002268 if (Attr.hasParameterOrArguments()) {
2269 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002270 return;
2271 }
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002272
Chandler Carruth87c44602011-07-01 23:49:12 +00002273 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
Fariborz Jahanian13c7fcc2011-10-21 22:27:12 +00002274 if (isa<CXXRecordDecl>(D)) {
2275 D->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
2276 return;
2277 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002278 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2279 << Attr.getName() << ExpectedVariableOrFunction;
Fariborz Jahanianf23ecd92009-07-16 01:12:24 +00002280 return;
2281 }
2282
Chandler Carruth87c44602011-07-01 23:49:12 +00002283 NamedDecl *nd = cast<NamedDecl>(D);
John McCall332bb2a2011-02-08 22:35:49 +00002284
2285 // 'weak' only applies to declarations with external linkage.
2286 if (hasEffectivelyInternalLinkage(nd)) {
Chandler Carruth87c44602011-07-01 23:49:12 +00002287 S.Diag(Attr.getLoc(), diag::err_attribute_weak_static);
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002288 return;
2289 }
Mike Stumpbf916502009-07-24 19:02:52 +00002290
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002291 nd->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00002292}
2293
Chandler Carruth1b03c872011-07-02 00:01:44 +00002294static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002295 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002296 if (!checkAttributeNumArgs(S, Attr, 0))
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002297 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00002298
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002299
2300 // weak_import only applies to variable & function declarations.
2301 bool isDef = false;
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002302 if (!D->canBeWeakImported(isDef)) {
2303 if (isDef)
2304 S.Diag(Attr.getLoc(),
2305 diag::warn_attribute_weak_import_invalid_on_definition)
2306 << "weak_import" << 2 /*variable and function*/;
Douglas Gregordef86312011-03-23 13:27:51 +00002307 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002308 (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
Fariborz Jahanian90eed212011-10-26 23:59:12 +00002309 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
Douglas Gregordef86312011-03-23 13:27:51 +00002310 // Nothing to warn about here.
2311 } else
Fariborz Jahanianc0349742010-04-13 20:22:35 +00002312 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002313 << Attr.getName() << ExpectedVariableOrFunction;
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002314
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002315 return;
2316 }
2317
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002318 D->addAttr(::new (S.Context) WeakImportAttr(Attr.getRange(), S.Context));
Daniel Dunbar6e775db2009-03-06 06:39:57 +00002319}
2320
Chandler Carruth1b03c872011-07-02 00:01:44 +00002321static void handleReqdWorkGroupSize(Sema &S, Decl *D,
2322 const AttributeList &Attr) {
Nate Begeman6f3d8382009-06-26 06:32:41 +00002323 // Attribute has 3 arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002324 if (!checkAttributeNumArgs(S, Attr, 3))
Nate Begeman6f3d8382009-06-26 06:32:41 +00002325 return;
Nate Begeman6f3d8382009-06-26 06:32:41 +00002326
2327 unsigned WGSize[3];
2328 for (unsigned i = 0; i < 3; ++i) {
Peter Collingbourne7a730022010-11-23 20:45:58 +00002329 Expr *E = Attr.getArg(i);
Nate Begeman6f3d8382009-06-26 06:32:41 +00002330 llvm::APSInt ArgNum(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002331 if (E->isTypeDependent() || E->isValueDependent() ||
2332 !E->isIntegerConstantExpr(ArgNum, S.Context)) {
Nate Begeman6f3d8382009-06-26 06:32:41 +00002333 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2334 << "reqd_work_group_size" << E->getSourceRange();
2335 return;
2336 }
2337 WGSize[i] = (unsigned) ArgNum.getZExtValue();
2338 }
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002339 D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getRange(), S.Context,
Sean Huntcf807c42010-08-18 23:23:40 +00002340 WGSize[0], WGSize[1],
Nate Begeman6f3d8382009-06-26 06:32:41 +00002341 WGSize[2]));
2342}
2343
Rafael Espindola599f1b72012-05-13 03:25:18 +00002344SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2345 StringRef Name) {
Rafael Espindola420efd82012-05-13 02:42:42 +00002346 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2347 if (ExistingAttr->getName() == Name)
Rafael Espindola599f1b72012-05-13 03:25:18 +00002348 return NULL;
Rafael Espindola420efd82012-05-13 02:42:42 +00002349 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
2350 Diag(Range.getBegin(), diag::note_previous_attribute);
Rafael Espindola599f1b72012-05-13 03:25:18 +00002351 return NULL;
Rafael Espindola420efd82012-05-13 02:42:42 +00002352 }
Rafael Espindola599f1b72012-05-13 03:25:18 +00002353 return ::new (Context) SectionAttr(Range, Context, Name);
Rafael Espindola420efd82012-05-13 02:42:42 +00002354}
2355
Chandler Carruth1b03c872011-07-02 00:01:44 +00002356static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002357 // Attribute has no arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002358 if (!checkAttributeNumArgs(S, Attr, 1))
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002359 return;
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002360
2361 // Make sure that there is a string literal as the sections's single
2362 // argument.
Peter Collingbourne7a730022010-11-23 20:45:58 +00002363 Expr *ArgExpr = Attr.getArg(0);
Chris Lattner797c3c42009-08-10 19:03:04 +00002364 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002365 if (!SE) {
Chris Lattner797c3c42009-08-10 19:03:04 +00002366 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section";
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002367 return;
2368 }
Mike Stump1eb44332009-09-09 15:08:12 +00002369
Chris Lattner797c3c42009-08-10 19:03:04 +00002370 // If the target wants to validate the section specifier, make it happen.
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002371 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(SE->getString());
Chris Lattnera1e1dc72010-01-12 20:58:53 +00002372 if (!Error.empty()) {
2373 S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target)
2374 << Error;
Chris Lattner797c3c42009-08-10 19:03:04 +00002375 return;
2376 }
Mike Stump1eb44332009-09-09 15:08:12 +00002377
Chris Lattnera1e1dc72010-01-12 20:58:53 +00002378 // This attribute cannot be applied to local variables.
2379 if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) {
2380 S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable);
2381 return;
2382 }
Rafael Espindola599f1b72012-05-13 03:25:18 +00002383 SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(),
2384 SE->getString());
2385 if (NewAttr)
2386 D->addAttr(NewAttr);
Daniel Dunbar17f194f2009-02-12 17:28:23 +00002387}
2388
Chris Lattner6b6b5372008-06-26 18:38:35 +00002389
Chandler Carruth1b03c872011-07-02 00:01:44 +00002390static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002391 // check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00002392 if (Attr.hasParameterOrArguments()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002393 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002394 return;
2395 }
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002396
Chandler Carruth87c44602011-07-01 23:49:12 +00002397 if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) {
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002398 if (Existing->getLocation().isInvalid())
Argyrios Kyrtzidisffcc3102011-09-13 16:05:53 +00002399 Existing->setRange(Attr.getRange());
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002400 } else {
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002401 D->addAttr(::new (S.Context) NoThrowAttr(Attr.getRange(), S.Context));
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002402 }
Chris Lattner6b6b5372008-06-26 18:38:35 +00002403}
2404
Chandler Carruth1b03c872011-07-02 00:01:44 +00002405static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002406 // check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00002407 if (Attr.hasParameterOrArguments()) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002408 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002409 return;
2410 }
Mike Stumpbf916502009-07-24 19:02:52 +00002411
Chandler Carruth87c44602011-07-01 23:49:12 +00002412 if (ConstAttr *Existing = D->getAttr<ConstAttr>()) {
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002413 if (Existing->getLocation().isInvalid())
Argyrios Kyrtzidisffcc3102011-09-13 16:05:53 +00002414 Existing->setRange(Attr.getRange());
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002415 } else {
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002416 D->addAttr(::new (S.Context) ConstAttr(Attr.getRange(), S.Context));
Douglas Gregorb30cd4a2011-06-15 05:45:11 +00002417 }
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002418}
2419
Chandler Carruth1b03c872011-07-02 00:01:44 +00002420static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002421 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002422 if (!checkAttributeNumArgs(S, Attr, 0))
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002423 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002424
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002425 D->addAttr(::new (S.Context) PureAttr(Attr.getRange(), S.Context));
Anders Carlsson232eb7d2008-10-05 23:32:53 +00002426}
2427
Chandler Carruth1b03c872011-07-02 00:01:44 +00002428static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Mike Stumpbf916502009-07-24 19:02:52 +00002429 if (!Attr.getParameterName()) {
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002430 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2431 return;
2432 }
Mike Stumpbf916502009-07-24 19:02:52 +00002433
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002434 if (Attr.getNumArgs() != 0) {
2435 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2436 return;
2437 }
Mike Stumpbf916502009-07-24 19:02:52 +00002438
Chandler Carruth87c44602011-07-01 23:49:12 +00002439 VarDecl *VD = dyn_cast<VarDecl>(D);
Mike Stumpbf916502009-07-24 19:02:52 +00002440
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002441 if (!VD || !VD->hasLocalStorage()) {
2442 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup";
2443 return;
2444 }
Mike Stumpbf916502009-07-24 19:02:52 +00002445
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002446 // Look up the function
Douglas Gregorc83c6872010-04-15 22:33:43 +00002447 // FIXME: Lookup probably isn't looking in the right place
John McCallf36e02d2009-10-09 21:13:30 +00002448 NamedDecl *CleanupDecl
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00002449 = S.LookupSingleName(S.TUScope, Attr.getParameterName(),
2450 Attr.getParameterLoc(), Sema::LookupOrdinaryName);
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002451 if (!CleanupDecl) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00002452 S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) <<
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002453 Attr.getParameterName();
2454 return;
2455 }
Mike Stumpbf916502009-07-24 19:02:52 +00002456
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002457 FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl);
2458 if (!FD) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00002459 S.Diag(Attr.getParameterLoc(),
2460 diag::err_attribute_cleanup_arg_not_function)
2461 << Attr.getParameterName();
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002462 return;
2463 }
2464
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002465 if (FD->getNumParams() != 1) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00002466 S.Diag(Attr.getParameterLoc(),
2467 diag::err_attribute_cleanup_func_must_take_one_arg)
2468 << Attr.getParameterName();
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002469 return;
2470 }
Mike Stumpbf916502009-07-24 19:02:52 +00002471
Anders Carlsson89941c12009-02-07 23:16:50 +00002472 // We're currently more strict than GCC about what function types we accept.
2473 // If this ever proves to be a problem it should be easy to fix.
2474 QualType Ty = S.Context.getPointerType(VD->getType());
2475 QualType ParamTy = FD->getParamDecl(0)->getType();
Douglas Gregorb608b982011-01-28 02:26:04 +00002476 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
2477 ParamTy, Ty) != Sema::Compatible) {
Argyrios Kyrtzidisf0b0ccc2010-12-06 17:51:50 +00002478 S.Diag(Attr.getParameterLoc(),
Anders Carlsson89941c12009-02-07 23:16:50 +00002479 diag::err_attribute_cleanup_func_arg_incompatible_type) <<
2480 Attr.getParameterName() << ParamTy << Ty;
2481 return;
2482 }
Mike Stumpbf916502009-07-24 19:02:52 +00002483
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002484 D->addAttr(::new (S.Context) CleanupAttr(Attr.getRange(), S.Context, FD));
Eli Friedman5f2987c2012-02-02 03:46:19 +00002485 S.MarkFunctionReferenced(Attr.getParameterLoc(), FD);
Anders Carlssonf6e35d02009-01-31 01:16:18 +00002486}
2487
Mike Stumpbf916502009-07-24 19:02:52 +00002488/// Handle __attribute__((format_arg((idx)))) attribute based on
2489/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
Chandler Carruth1b03c872011-07-02 00:01:44 +00002490static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth1731e202011-07-11 23:30:35 +00002491 if (!checkAttributeNumArgs(S, Attr, 1))
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002492 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00002493
Chandler Carruth87c44602011-07-01 23:49:12 +00002494 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002495 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002496 << Attr.getName() << ExpectedFunction;
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002497 return;
2498 }
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002499
2500 // In C++ the implicit 'this' function parameter also counts, and they are
2501 // counted from one.
Chandler Carruth87c44602011-07-01 23:49:12 +00002502 bool HasImplicitThisParam = isInstanceMethod(D);
2503 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002504 unsigned FirstIdx = 1;
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002505
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002506 // checks for the 2nd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00002507 Expr *IdxExpr = Attr.getArg(0);
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002508 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002509 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2510 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002511 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
2512 << "format" << 2 << IdxExpr->getSourceRange();
2513 return;
2514 }
Mike Stumpbf916502009-07-24 19:02:52 +00002515
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002516 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
2517 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
2518 << "format" << 2 << IdxExpr->getSourceRange();
2519 return;
2520 }
Mike Stumpbf916502009-07-24 19:02:52 +00002521
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002522 unsigned ArgIdx = Idx.getZExtValue() - 1;
Mike Stumpbf916502009-07-24 19:02:52 +00002523
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002524 if (HasImplicitThisParam) {
2525 if (ArgIdx == 0) {
2526 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument)
2527 << "format_arg" << IdxExpr->getSourceRange();
2528 return;
2529 }
2530 ArgIdx--;
2531 }
2532
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002533 // make sure the format string is really a string
Chandler Carruth87c44602011-07-01 23:49:12 +00002534 QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
Mike Stumpbf916502009-07-24 19:02:52 +00002535
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002536 bool not_nsstring_type = !isNSStringType(Ty, S.Context);
2537 if (not_nsstring_type &&
2538 !isCFStringType(Ty, S.Context) &&
2539 (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00002540 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002541 // FIXME: Should highlight the actual expression that has the wrong type.
2542 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
Mike Stumpbf916502009-07-24 19:02:52 +00002543 << (not_nsstring_type ? "a string type" : "an NSString")
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002544 << IdxExpr->getSourceRange();
2545 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002546 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002547 Ty = getFunctionOrMethodResultType(D);
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002548 if (!isNSStringType(Ty, S.Context) &&
2549 !isCFStringType(Ty, S.Context) &&
2550 (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00002551 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002552 // FIXME: Should highlight the actual expression that has the wrong type.
2553 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
Mike Stumpbf916502009-07-24 19:02:52 +00002554 << (not_nsstring_type ? "string type" : "NSString")
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002555 << IdxExpr->getSourceRange();
2556 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002557 }
2558
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002559 D->addAttr(::new (S.Context) FormatArgAttr(Attr.getRange(), S.Context,
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002560 Idx.getZExtValue()));
Fariborz Jahanian5b160922009-05-20 17:41:43 +00002561}
2562
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002563enum FormatAttrKind {
2564 CFStringFormat,
2565 NSStringFormat,
2566 StrftimeFormat,
2567 SupportedFormat,
Chris Lattner3c989022010-03-22 21:08:50 +00002568 IgnoredFormat,
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002569 InvalidFormat
2570};
2571
2572/// getFormatAttrKind - Map from format attribute names to supported format
2573/// types.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002574static FormatAttrKind getFormatAttrKind(StringRef Format) {
Benjamin Kramerc51bb992012-05-16 12:44:25 +00002575 return llvm::StringSwitch<FormatAttrKind>(Format)
2576 // Check for formats that get handled specially.
2577 .Case("NSString", NSStringFormat)
2578 .Case("CFString", CFStringFormat)
2579 .Case("strftime", StrftimeFormat)
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002580
Benjamin Kramerc51bb992012-05-16 12:44:25 +00002581 // Otherwise, check for supported formats.
2582 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
2583 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
2584 .Case("kprintf", SupportedFormat) // OpenBSD.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002585
Benjamin Kramerc51bb992012-05-16 12:44:25 +00002586 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
2587 .Default(InvalidFormat);
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002588}
2589
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002590/// Handle __attribute__((init_priority(priority))) attributes based on
2591/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
Chandler Carruth1b03c872011-07-02 00:01:44 +00002592static void handleInitPriorityAttr(Sema &S, Decl *D,
2593 const AttributeList &Attr) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002594 if (!S.getLangOpts().CPlusPlus) {
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002595 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2596 return;
2597 }
2598
Chandler Carruth87c44602011-07-01 23:49:12 +00002599 if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) {
Fariborz Jahanianb9d5c222010-06-18 23:14:53 +00002600 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2601 Attr.setInvalid();
2602 return;
2603 }
Chandler Carruth87c44602011-07-01 23:49:12 +00002604 QualType T = dyn_cast<VarDecl>(D)->getType();
Fariborz Jahanianb9d5c222010-06-18 23:14:53 +00002605 if (S.Context.getAsArrayType(T))
2606 T = S.Context.getBaseElementType(T);
2607 if (!T->getAs<RecordType>()) {
2608 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
2609 Attr.setInvalid();
2610 return;
2611 }
2612
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002613 if (Attr.getNumArgs() != 1) {
2614 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2615 Attr.setInvalid();
2616 return;
2617 }
Peter Collingbourne7a730022010-11-23 20:45:58 +00002618 Expr *priorityExpr = Attr.getArg(0);
Fariborz Jahanianb9d5c222010-06-18 23:14:53 +00002619
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002620 llvm::APSInt priority(32);
2621 if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() ||
2622 !priorityExpr->isIntegerConstantExpr(priority, S.Context)) {
2623 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2624 << "init_priority" << priorityExpr->getSourceRange();
2625 Attr.setInvalid();
2626 return;
2627 }
Fariborz Jahanian9f967c52010-06-21 18:45:05 +00002628 unsigned prioritynum = priority.getZExtValue();
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002629 if (prioritynum < 101 || prioritynum > 65535) {
2630 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
2631 << priorityExpr->getSourceRange();
2632 Attr.setInvalid();
2633 return;
2634 }
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002635 D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00002636 prioritynum));
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00002637}
2638
Rafael Espindola599f1b72012-05-13 03:25:18 +00002639FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range, StringRef Format,
2640 int FormatIdx, int FirstArg) {
Rafael Espindolabf9da1f2012-05-11 00:36:07 +00002641 // Check whether we already have an equivalent format attribute.
2642 for (specific_attr_iterator<FormatAttr>
2643 i = D->specific_attr_begin<FormatAttr>(),
2644 e = D->specific_attr_end<FormatAttr>();
2645 i != e ; ++i) {
2646 FormatAttr *f = *i;
2647 if (f->getType() == Format &&
2648 f->getFormatIdx() == FormatIdx &&
2649 f->getFirstArg() == FirstArg) {
2650 // If we don't have a valid location for this attribute, adopt the
2651 // location.
2652 if (f->getLocation().isInvalid())
2653 f->setRange(Range);
Rafael Espindola599f1b72012-05-13 03:25:18 +00002654 return NULL;
Rafael Espindolabf9da1f2012-05-11 00:36:07 +00002655 }
2656 }
2657
Rafael Espindola599f1b72012-05-13 03:25:18 +00002658 return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
2659 FirstArg);
Rafael Espindolabf9da1f2012-05-11 00:36:07 +00002660}
2661
Mike Stumpbf916502009-07-24 19:02:52 +00002662/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
2663/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
Chandler Carruth1b03c872011-07-02 00:01:44 +00002664static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002665
Chris Lattner545dd342008-06-28 23:36:30 +00002666 if (!Attr.getParameterName()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002667 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Chris Lattner3c73c412008-11-19 08:23:25 +00002668 << "format" << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002669 return;
2670 }
2671
Chris Lattner545dd342008-06-28 23:36:30 +00002672 if (Attr.getNumArgs() != 2) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002673 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002674 return;
2675 }
2676
Chandler Carruth87c44602011-07-01 23:49:12 +00002677 if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002678 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002679 << Attr.getName() << ExpectedFunction;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002680 return;
2681 }
2682
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002683 // In C++ the implicit 'this' function parameter also counts, and they are
2684 // counted from one.
Chandler Carruth87c44602011-07-01 23:49:12 +00002685 bool HasImplicitThisParam = isInstanceMethod(D);
2686 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002687 unsigned FirstIdx = 1;
2688
Chris Lattner5f9e2722011-07-23 10:55:15 +00002689 StringRef Format = Attr.getParameterName()->getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002690
2691 // Normalize the argument, __foo__ becomes foo.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002692 if (Format.startswith("__") && Format.endswith("__"))
2693 Format = Format.substr(2, Format.size() - 4);
Chris Lattner6b6b5372008-06-26 18:38:35 +00002694
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002695 // Check for supported formats.
2696 FormatAttrKind Kind = getFormatAttrKind(Format);
Chris Lattner3c989022010-03-22 21:08:50 +00002697
2698 if (Kind == IgnoredFormat)
2699 return;
2700
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002701 if (Kind == InvalidFormat) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002702 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00002703 << "format" << Attr.getParameterName()->getName();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002704 return;
2705 }
2706
2707 // checks for the 2nd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00002708 Expr *IdxExpr = Attr.getArg(0);
Chris Lattner803d0802008-06-29 00:43:07 +00002709 llvm::APSInt Idx(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002710 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
2711 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002712 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00002713 << "format" << 2 << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002714 return;
2715 }
2716
2717 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002718 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner3c73c412008-11-19 08:23:25 +00002719 << "format" << 2 << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002720 return;
2721 }
2722
2723 // FIXME: Do we need to bounds check?
2724 unsigned ArgIdx = Idx.getZExtValue() - 1;
Mike Stumpbf916502009-07-24 19:02:52 +00002725
Sebastian Redl4a2614e2009-11-17 18:02:24 +00002726 if (HasImplicitThisParam) {
2727 if (ArgIdx == 0) {
Chandler Carruth07d7e7a2010-11-16 08:35:43 +00002728 S.Diag(Attr.getLoc(),
2729 diag::err_format_attribute_implicit_this_format_string)
2730 << IdxExpr->getSourceRange();
Sebastian Redl4a2614e2009-11-17 18:02:24 +00002731 return;
2732 }
2733 ArgIdx--;
2734 }
Mike Stump1eb44332009-09-09 15:08:12 +00002735
Chris Lattner6b6b5372008-06-26 18:38:35 +00002736 // make sure the format string is really a string
Chandler Carruth87c44602011-07-01 23:49:12 +00002737 QualType Ty = getFunctionOrMethodArgType(D, ArgIdx);
Chris Lattner6b6b5372008-06-26 18:38:35 +00002738
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002739 if (Kind == CFStringFormat) {
Daniel Dunbar085e8f72008-09-26 03:32:58 +00002740 if (!isCFStringType(Ty, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002741 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2742 << "a CFString" << IdxExpr->getSourceRange();
Daniel Dunbar085e8f72008-09-26 03:32:58 +00002743 return;
2744 }
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002745 } else if (Kind == NSStringFormat) {
Mike Stump390b4cc2009-05-16 07:39:55 +00002746 // FIXME: do we need to check if the type is NSString*? What are the
2747 // semantics?
Chris Lattner803d0802008-06-29 00:43:07 +00002748 if (!isNSStringType(Ty, S.Context)) {
Mike Stump390b4cc2009-05-16 07:39:55 +00002749 // FIXME: Should highlight the actual expression that has the wrong type.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002750 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2751 << "an NSString" << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002752 return;
Mike Stumpbf916502009-07-24 19:02:52 +00002753 }
Chris Lattner6b6b5372008-06-26 18:38:35 +00002754 } else if (!Ty->isPointerType() ||
Ted Kremenek6217b802009-07-29 21:53:49 +00002755 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
Mike Stump390b4cc2009-05-16 07:39:55 +00002756 // FIXME: Should highlight the actual expression that has the wrong type.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002757 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
2758 << "a string type" << IdxExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002759 return;
2760 }
2761
2762 // check the 3rd argument
Peter Collingbourne7a730022010-11-23 20:45:58 +00002763 Expr *FirstArgExpr = Attr.getArg(1);
Chris Lattner803d0802008-06-29 00:43:07 +00002764 llvm::APSInt FirstArg(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00002765 if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() ||
2766 !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002767 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
Chris Lattner3c73c412008-11-19 08:23:25 +00002768 << "format" << 3 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002769 return;
2770 }
2771
2772 // check if the function is variadic if the 3rd argument non-zero
2773 if (FirstArg != 0) {
Chandler Carruth87c44602011-07-01 23:49:12 +00002774 if (isFunctionOrMethodVariadic(D)) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002775 ++NumArgs; // +1 for ...
2776 } else {
Chandler Carruth87c44602011-07-01 23:49:12 +00002777 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
Chris Lattner6b6b5372008-06-26 18:38:35 +00002778 return;
2779 }
2780 }
2781
Chris Lattner3c73c412008-11-19 08:23:25 +00002782 // strftime requires FirstArg to be 0 because it doesn't read from any
2783 // variable the input is just the current time + the format string.
Daniel Dunbar2b0d9a22009-10-18 02:09:17 +00002784 if (Kind == StrftimeFormat) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002785 if (FirstArg != 0) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002786 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
2787 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002788 return;
2789 }
2790 // if 0 it disables parameter checking (to use with e.g. va_list)
2791 } else if (FirstArg != 0 && FirstArg != NumArgs) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002792 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
Chris Lattner3c73c412008-11-19 08:23:25 +00002793 << "format" << 3 << FirstArgExpr->getSourceRange();
Chris Lattner6b6b5372008-06-26 18:38:35 +00002794 return;
2795 }
2796
Rafael Espindola599f1b72012-05-13 03:25:18 +00002797 FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), Format,
2798 Idx.getZExtValue(),
2799 FirstArg.getZExtValue());
2800 if (NewAttr)
2801 D->addAttr(NewAttr);
Chris Lattner6b6b5372008-06-26 18:38:35 +00002802}
2803
Chandler Carruth1b03c872011-07-02 00:01:44 +00002804static void handleTransparentUnionAttr(Sema &S, Decl *D,
2805 const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002806 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002807 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner6b6b5372008-06-26 18:38:35 +00002808 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00002809
Chris Lattner6b6b5372008-06-26 18:38:35 +00002810
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002811 // Try to find the underlying union declaration.
2812 RecordDecl *RD = 0;
Chandler Carruth87c44602011-07-01 23:49:12 +00002813 TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002814 if (TD && TD->getUnderlyingType()->isUnionType())
2815 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
2816 else
Chandler Carruth87c44602011-07-01 23:49:12 +00002817 RD = dyn_cast<RecordDecl>(D);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002818
2819 if (!RD || !RD->isUnion()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00002820 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00002821 << Attr.getName() << ExpectedUnion;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002822 return;
2823 }
2824
John McCall5e1cdac2011-10-07 06:10:15 +00002825 if (!RD->isCompleteDefinition()) {
Mike Stumpbf916502009-07-24 19:02:52 +00002826 S.Diag(Attr.getLoc(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002827 diag::warn_transparent_union_attribute_not_definition);
2828 return;
2829 }
Chris Lattner6b6b5372008-06-26 18:38:35 +00002830
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002831 RecordDecl::field_iterator Field = RD->field_begin(),
2832 FieldEnd = RD->field_end();
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002833 if (Field == FieldEnd) {
2834 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
2835 return;
2836 }
Eli Friedmanbc887452008-09-02 05:19:23 +00002837
David Blaikie581deb32012-06-06 20:45:41 +00002838 FieldDecl *FirstField = *Field;
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002839 QualType FirstType = FirstField->getType();
Douglas Gregor90cd6722010-06-30 17:24:13 +00002840 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
Mike Stumpbf916502009-07-24 19:02:52 +00002841 S.Diag(FirstField->getLocation(),
Douglas Gregor90cd6722010-06-30 17:24:13 +00002842 diag::warn_transparent_union_attribute_floating)
2843 << FirstType->isVectorType() << FirstType;
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002844 return;
2845 }
2846
2847 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
2848 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
2849 for (; Field != FieldEnd; ++Field) {
2850 QualType FieldType = Field->getType();
2851 if (S.Context.getTypeSize(FieldType) != FirstSize ||
2852 S.Context.getTypeAlign(FieldType) != FirstAlign) {
2853 // Warn if we drop the attribute.
2854 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
Mike Stumpbf916502009-07-24 19:02:52 +00002855 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002856 : S.Context.getTypeAlign(FieldType);
Mike Stumpbf916502009-07-24 19:02:52 +00002857 S.Diag(Field->getLocation(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002858 diag::warn_transparent_union_attribute_field_size_align)
2859 << isSize << Field->getDeclName() << FieldBits;
2860 unsigned FirstBits = isSize? FirstSize : FirstAlign;
Mike Stumpbf916502009-07-24 19:02:52 +00002861 S.Diag(FirstField->getLocation(),
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002862 diag::note_transparent_union_first_field_size_align)
2863 << isSize << FirstBits;
Eli Friedmanbc887452008-09-02 05:19:23 +00002864 return;
2865 }
2866 }
2867
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002868 RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getRange(), S.Context));
Chris Lattner6b6b5372008-06-26 18:38:35 +00002869}
2870
Chandler Carruth1b03c872011-07-02 00:01:44 +00002871static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002872 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00002873 if (!checkAttributeNumArgs(S, Attr, 1))
Chris Lattner6b6b5372008-06-26 18:38:35 +00002874 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00002875
Peter Collingbourne7a730022010-11-23 20:45:58 +00002876 Expr *ArgExpr = Attr.getArg(0);
Chris Lattner797c3c42009-08-10 19:03:04 +00002877 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr);
Mike Stumpbf916502009-07-24 19:02:52 +00002878
Chris Lattner6b6b5372008-06-26 18:38:35 +00002879 // Make sure that there is a string literal as the annotation's single
2880 // argument.
2881 if (!SE) {
Chris Lattner797c3c42009-08-10 19:03:04 +00002882 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate";
Chris Lattner6b6b5372008-06-26 18:38:35 +00002883 return;
2884 }
Julien Lerouge77f68bb2011-09-09 22:41:49 +00002885
2886 // Don't duplicate annotations that are already set.
2887 for (specific_attr_iterator<AnnotateAttr>
2888 i = D->specific_attr_begin<AnnotateAttr>(),
2889 e = D->specific_attr_end<AnnotateAttr>(); i != e; ++i) {
2890 if ((*i)->getAnnotation() == SE->getString())
2891 return;
2892 }
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002893 D->addAttr(::new (S.Context) AnnotateAttr(Attr.getRange(), S.Context,
Eric Christopherf48f3672010-12-01 22:13:54 +00002894 SE->getString()));
Chris Lattner6b6b5372008-06-26 18:38:35 +00002895}
2896
Chandler Carruth1b03c872011-07-02 00:01:44 +00002897static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner6b6b5372008-06-26 18:38:35 +00002898 // check the attribute arguments.
Chris Lattner545dd342008-06-28 23:36:30 +00002899 if (Attr.getNumArgs() > 1) {
Chris Lattner3c73c412008-11-19 08:23:25 +00002900 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002901 return;
2902 }
Sean Huntbbd37c62009-11-21 08:43:09 +00002903
2904 //FIXME: The C++0x version of this attribute has more limited applicabilty
2905 // than GNU's, and should error out when it is used to specify a
2906 // weaker alignment, rather than being silently ignored.
Chris Lattner6b6b5372008-06-26 18:38:35 +00002907
Chris Lattner545dd342008-06-28 23:36:30 +00002908 if (Attr.getNumArgs() == 0) {
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002909 D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context, true, 0));
Chris Lattner6b6b5372008-06-26 18:38:35 +00002910 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002911 }
Mike Stumpbf916502009-07-24 19:02:52 +00002912
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002913 S.AddAlignedAttr(Attr.getRange(), D, Attr.getArg(0));
Chandler Carruth4ced79f2010-06-25 03:22:07 +00002914}
2915
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002916void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E) {
Peter Collingbourne0b64ba92011-10-23 20:07:52 +00002917 // FIXME: Handle pack-expansions here.
2918 if (DiagnoseUnexpandedParameterPack(E))
2919 return;
2920
Chandler Carruth4ced79f2010-06-25 03:22:07 +00002921 if (E->isTypeDependent() || E->isValueDependent()) {
2922 // Save dependent expressions in the AST to be instantiated.
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002923 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, E));
Chandler Carruth4ced79f2010-06-25 03:22:07 +00002924 return;
2925 }
2926
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002927 SourceLocation AttrLoc = AttrRange.getBegin();
Sean Huntcf807c42010-08-18 23:23:40 +00002928 // FIXME: Cache the number on the Attr object?
Chris Lattner49e2d342008-06-28 23:50:44 +00002929 llvm::APSInt Alignment(32);
Douglas Gregorab41fe92012-05-04 22:38:52 +00002930 ExprResult ICE
2931 = VerifyIntegerConstantExpression(E, &Alignment,
2932 diag::err_aligned_attribute_argument_not_int,
2933 /*AllowFold*/ false);
Richard Smith282e7e62012-02-04 09:53:13 +00002934 if (ICE.isInvalid())
Chris Lattner49e2d342008-06-28 23:50:44 +00002935 return;
Daniel Dunbar396b2a22009-02-16 23:37:57 +00002936 if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) {
Chandler Carruth4ced79f2010-06-25 03:22:07 +00002937 Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two)
2938 << E->getSourceRange();
Daniel Dunbar396b2a22009-02-16 23:37:57 +00002939 return;
2940 }
2941
Richard Smith282e7e62012-02-04 09:53:13 +00002942 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, ICE.take()));
Sean Huntcf807c42010-08-18 23:23:40 +00002943}
2944
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002945void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS) {
Sean Huntcf807c42010-08-18 23:23:40 +00002946 // FIXME: Cache the number on the Attr object if non-dependent?
2947 // FIXME: Perform checking of type validity
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00002948 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, false, TS));
Sean Huntcf807c42010-08-18 23:23:40 +00002949 return;
Chris Lattner6b6b5372008-06-26 18:38:35 +00002950}
Chris Lattnerfbf13472008-06-27 22:18:37 +00002951
Chandler Carruthd309c812011-07-01 23:49:16 +00002952/// handleModeAttr - This attribute modifies the width of a decl with primitive
Mike Stumpbf916502009-07-24 19:02:52 +00002953/// type.
Chris Lattnerfbf13472008-06-27 22:18:37 +00002954///
Mike Stumpbf916502009-07-24 19:02:52 +00002955/// Despite what would be logical, the mode attribute is a decl attribute, not a
2956/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
2957/// HImode, not an intermediate pointer.
Chandler Carruth1b03c872011-07-02 00:01:44 +00002958static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattnerfbf13472008-06-27 22:18:37 +00002959 // This attribute isn't documented, but glibc uses it. It changes
2960 // the width of an int or unsigned int to the specified size.
2961
2962 // Check that there aren't any arguments
Chandler Carruth1731e202011-07-11 23:30:35 +00002963 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattnerfbf13472008-06-27 22:18:37 +00002964 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00002965
Chris Lattnerfbf13472008-06-27 22:18:37 +00002966
2967 IdentifierInfo *Name = Attr.getParameterName();
2968 if (!Name) {
Chris Lattner0b2f4da2008-06-29 00:28:59 +00002969 S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name);
Chris Lattnerfbf13472008-06-27 22:18:37 +00002970 return;
2971 }
Daniel Dunbar210ae982009-10-18 02:09:24 +00002972
Chris Lattner5f9e2722011-07-23 10:55:15 +00002973 StringRef Str = Attr.getParameterName()->getName();
Chris Lattnerfbf13472008-06-27 22:18:37 +00002974
2975 // Normalize the attribute name, __foo__ becomes foo.
Daniel Dunbar210ae982009-10-18 02:09:24 +00002976 if (Str.startswith("__") && Str.endswith("__"))
2977 Str = Str.substr(2, Str.size() - 4);
Chris Lattnerfbf13472008-06-27 22:18:37 +00002978
2979 unsigned DestWidth = 0;
2980 bool IntegerMode = true;
Eli Friedman73397492009-03-03 06:41:03 +00002981 bool ComplexMode = false;
Daniel Dunbar210ae982009-10-18 02:09:24 +00002982 switch (Str.size()) {
Chris Lattnerfbf13472008-06-27 22:18:37 +00002983 case 2:
Eli Friedman73397492009-03-03 06:41:03 +00002984 switch (Str[0]) {
2985 case 'Q': DestWidth = 8; break;
2986 case 'H': DestWidth = 16; break;
2987 case 'S': DestWidth = 32; break;
2988 case 'D': DestWidth = 64; break;
2989 case 'X': DestWidth = 96; break;
2990 case 'T': DestWidth = 128; break;
2991 }
2992 if (Str[1] == 'F') {
2993 IntegerMode = false;
2994 } else if (Str[1] == 'C') {
2995 IntegerMode = false;
2996 ComplexMode = true;
2997 } else if (Str[1] != 'I') {
2998 DestWidth = 0;
2999 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00003000 break;
3001 case 4:
3002 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3003 // pointer on PIC16 and other embedded platforms.
Daniel Dunbar210ae982009-10-18 02:09:24 +00003004 if (Str == "word")
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003005 DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
Daniel Dunbar210ae982009-10-18 02:09:24 +00003006 else if (Str == "byte")
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003007 DestWidth = S.Context.getTargetInfo().getCharWidth();
Chris Lattnerfbf13472008-06-27 22:18:37 +00003008 break;
3009 case 7:
Daniel Dunbar210ae982009-10-18 02:09:24 +00003010 if (Str == "pointer")
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003011 DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
Chris Lattnerfbf13472008-06-27 22:18:37 +00003012 break;
3013 }
3014
3015 QualType OldTy;
Richard Smith162e1c12011-04-15 14:24:37 +00003016 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
Chris Lattnerfbf13472008-06-27 22:18:37 +00003017 OldTy = TD->getUnderlyingType();
3018 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3019 OldTy = VD->getType();
3020 else {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00003021 S.Diag(D->getLocation(), diag::err_attr_wrong_decl)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003022 << "mode" << Attr.getRange();
Chris Lattnerfbf13472008-06-27 22:18:37 +00003023 return;
3024 }
Eli Friedman73397492009-03-03 06:41:03 +00003025
John McCall183700f2009-09-21 23:43:11 +00003026 if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType())
Eli Friedman73397492009-03-03 06:41:03 +00003027 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive);
3028 else if (IntegerMode) {
Douglas Gregor2ade35e2010-06-16 00:17:44 +00003029 if (!OldTy->isIntegralOrEnumerationType())
Eli Friedman73397492009-03-03 06:41:03 +00003030 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3031 } else if (ComplexMode) {
3032 if (!OldTy->isComplexType())
3033 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3034 } else {
3035 if (!OldTy->isFloatingType())
3036 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type);
3037 }
3038
Mike Stump390b4cc2009-05-16 07:39:55 +00003039 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3040 // and friends, at least with glibc.
3041 // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong
3042 // width on unusual platforms.
Eli Friedmanf98aba32009-02-13 02:31:07 +00003043 // FIXME: Make sure floating-point mappings are accurate
3044 // FIXME: Support XF and TF types
Chris Lattnerfbf13472008-06-27 22:18:37 +00003045 QualType NewTy;
3046 switch (DestWidth) {
3047 case 0:
Chris Lattner3c73c412008-11-19 08:23:25 +00003048 S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003049 return;
3050 default:
Chris Lattner3c73c412008-11-19 08:23:25 +00003051 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003052 return;
3053 case 8:
Eli Friedman73397492009-03-03 06:41:03 +00003054 if (!IntegerMode) {
3055 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3056 return;
3057 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00003058 if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003059 NewTy = S.Context.SignedCharTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003060 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003061 NewTy = S.Context.UnsignedCharTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003062 break;
3063 case 16:
Eli Friedman73397492009-03-03 06:41:03 +00003064 if (!IntegerMode) {
3065 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3066 return;
3067 }
Chris Lattnerfbf13472008-06-27 22:18:37 +00003068 if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003069 NewTy = S.Context.ShortTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003070 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003071 NewTy = S.Context.UnsignedShortTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003072 break;
3073 case 32:
3074 if (!IntegerMode)
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003075 NewTy = S.Context.FloatTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003076 else if (OldTy->isSignedIntegerType())
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003077 NewTy = S.Context.IntTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003078 else
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003079 NewTy = S.Context.UnsignedIntTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003080 break;
3081 case 64:
3082 if (!IntegerMode)
Chris Lattner0b2f4da2008-06-29 00:28:59 +00003083 NewTy = S.Context.DoubleTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003084 else if (OldTy->isSignedIntegerType())
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003085 if (S.Context.getTargetInfo().getLongWidth() == 64)
Chandler Carruthaec7caa2010-01-26 06:39:24 +00003086 NewTy = S.Context.LongTy;
3087 else
3088 NewTy = S.Context.LongLongTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003089 else
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003090 if (S.Context.getTargetInfo().getLongWidth() == 64)
Chandler Carruthaec7caa2010-01-26 06:39:24 +00003091 NewTy = S.Context.UnsignedLongTy;
3092 else
3093 NewTy = S.Context.UnsignedLongLongTy;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003094 break;
Eli Friedman73397492009-03-03 06:41:03 +00003095 case 96:
3096 NewTy = S.Context.LongDoubleTy;
3097 break;
Eli Friedmanf98aba32009-02-13 02:31:07 +00003098 case 128:
3099 if (!IntegerMode) {
3100 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name;
3101 return;
3102 }
Anders Carlssonf5f7d862009-12-29 07:07:36 +00003103 if (OldTy->isSignedIntegerType())
3104 NewTy = S.Context.Int128Ty;
3105 else
3106 NewTy = S.Context.UnsignedInt128Ty;
Eli Friedman73397492009-03-03 06:41:03 +00003107 break;
Chris Lattnerfbf13472008-06-27 22:18:37 +00003108 }
3109
Eli Friedman73397492009-03-03 06:41:03 +00003110 if (ComplexMode) {
3111 NewTy = S.Context.getComplexType(NewTy);
Chris Lattnerfbf13472008-06-27 22:18:37 +00003112 }
3113
3114 // Install the new type.
Richard Smith162e1c12011-04-15 14:24:37 +00003115 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
John McCallba6a9bd2009-10-24 08:00:42 +00003116 // FIXME: preserve existing source info.
John McCalla93c9342009-12-07 02:54:59 +00003117 TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy));
John McCallba6a9bd2009-10-24 08:00:42 +00003118 } else
Chris Lattnerfbf13472008-06-27 22:18:37 +00003119 cast<ValueDecl>(D)->setType(NewTy);
3120}
Chris Lattner0744e5f2008-06-29 00:23:49 +00003121
Chandler Carruth1b03c872011-07-02 00:01:44 +00003122static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Anders Carlssond87df372009-02-13 06:46:13 +00003123 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003124 if (!checkAttributeNumArgs(S, Attr, 0))
Anders Carlssond87df372009-02-13 06:46:13 +00003125 return;
Anders Carlssone896d982009-02-13 08:11:52 +00003126
Chandler Carruth87c44602011-07-01 23:49:12 +00003127 if (!isFunctionOrMethod(D)) {
Anders Carlssond87df372009-02-13 06:46:13 +00003128 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003129 << Attr.getName() << ExpectedFunction;
Anders Carlssond87df372009-02-13 06:46:13 +00003130 return;
3131 }
Mike Stumpbf916502009-07-24 19:02:52 +00003132
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003133 D->addAttr(::new (S.Context) NoDebugAttr(Attr.getRange(), S.Context));
Anders Carlssond87df372009-02-13 06:46:13 +00003134}
3135
Chandler Carruth1b03c872011-07-02 00:01:44 +00003136static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Anders Carlsson5bab7882009-02-19 19:16:48 +00003137 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003138 if (!checkAttributeNumArgs(S, Attr, 0))
Anders Carlsson5bab7882009-02-19 19:16:48 +00003139 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00003140
Mike Stumpbf916502009-07-24 19:02:52 +00003141
Chandler Carruth87c44602011-07-01 23:49:12 +00003142 if (!isa<FunctionDecl>(D)) {
Anders Carlsson5bab7882009-02-19 19:16:48 +00003143 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003144 << Attr.getName() << ExpectedFunction;
Anders Carlsson5bab7882009-02-19 19:16:48 +00003145 return;
3146 }
Mike Stumpbf916502009-07-24 19:02:52 +00003147
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003148 D->addAttr(::new (S.Context) NoInlineAttr(Attr.getRange(), S.Context));
Anders Carlsson5bab7882009-02-19 19:16:48 +00003149}
3150
Chandler Carruth1b03c872011-07-02 00:01:44 +00003151static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D,
3152 const AttributeList &Attr) {
Chris Lattner7255a2d2010-06-22 00:03:40 +00003153 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003154 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner7255a2d2010-06-22 00:03:40 +00003155 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00003156
Chris Lattner7255a2d2010-06-22 00:03:40 +00003157
Chandler Carruth87c44602011-07-01 23:49:12 +00003158 if (!isa<FunctionDecl>(D)) {
Chris Lattner7255a2d2010-06-22 00:03:40 +00003159 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003160 << Attr.getName() << ExpectedFunction;
Chris Lattner7255a2d2010-06-22 00:03:40 +00003161 return;
3162 }
3163
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003164 D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getRange(),
Eric Christopherf48f3672010-12-01 22:13:54 +00003165 S.Context));
Chris Lattner7255a2d2010-06-22 00:03:40 +00003166}
3167
Chandler Carruth1b03c872011-07-02 00:01:44 +00003168static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003169 if (S.LangOpts.CUDA) {
3170 // check the attribute arguments.
Ted Kremenek831efae2011-04-15 05:49:29 +00003171 if (Attr.hasParameterOrArguments()) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003172 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3173 return;
3174 }
3175
Chandler Carruth87c44602011-07-01 23:49:12 +00003176 if (!isa<VarDecl>(D)) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003177 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003178 << Attr.getName() << ExpectedVariable;
Peter Collingbourneced76712010-12-01 03:15:31 +00003179 return;
3180 }
3181
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003182 D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getRange(), S.Context));
Peter Collingbourneced76712010-12-01 03:15:31 +00003183 } else {
3184 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant";
3185 }
3186}
3187
Chandler Carruth1b03c872011-07-02 00:01:44 +00003188static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003189 if (S.LangOpts.CUDA) {
3190 // check the attribute arguments.
3191 if (Attr.getNumArgs() != 0) {
3192 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3193 return;
3194 }
3195
Chandler Carruth87c44602011-07-01 23:49:12 +00003196 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003197 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003198 << Attr.getName() << ExpectedVariableOrFunction;
Peter Collingbourneced76712010-12-01 03:15:31 +00003199 return;
3200 }
3201
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003202 D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getRange(), S.Context));
Peter Collingbourneced76712010-12-01 03:15:31 +00003203 } else {
3204 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device";
3205 }
3206}
3207
Chandler Carruth1b03c872011-07-02 00:01:44 +00003208static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003209 if (S.LangOpts.CUDA) {
3210 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003211 if (!checkAttributeNumArgs(S, Attr, 0))
Peter Collingbourneced76712010-12-01 03:15:31 +00003212 return;
Peter Collingbourneced76712010-12-01 03:15:31 +00003213
Chandler Carruth87c44602011-07-01 23:49:12 +00003214 if (!isa<FunctionDecl>(D)) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003215 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003216 << Attr.getName() << ExpectedFunction;
Peter Collingbourneced76712010-12-01 03:15:31 +00003217 return;
3218 }
3219
Chandler Carruth87c44602011-07-01 23:49:12 +00003220 FunctionDecl *FD = cast<FunctionDecl>(D);
Peter Collingbourne2c2c8dd2010-12-12 23:02:57 +00003221 if (!FD->getResultType()->isVoidType()) {
Abramo Bagnara723df242010-12-14 22:11:44 +00003222 TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens();
Peter Collingbourne2c2c8dd2010-12-12 23:02:57 +00003223 if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) {
3224 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3225 << FD->getType()
3226 << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(),
3227 "void");
3228 } else {
3229 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
3230 << FD->getType();
3231 }
3232 return;
3233 }
3234
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003235 D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getRange(), S.Context));
Peter Collingbourneced76712010-12-01 03:15:31 +00003236 } else {
3237 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global";
3238 }
3239}
3240
Chandler Carruth1b03c872011-07-02 00:01:44 +00003241static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003242 if (S.LangOpts.CUDA) {
3243 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003244 if (!checkAttributeNumArgs(S, Attr, 0))
Peter Collingbourneced76712010-12-01 03:15:31 +00003245 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00003246
Peter Collingbourneced76712010-12-01 03:15:31 +00003247
Chandler Carruth87c44602011-07-01 23:49:12 +00003248 if (!isa<FunctionDecl>(D)) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003249 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003250 << Attr.getName() << ExpectedFunction;
Peter Collingbourneced76712010-12-01 03:15:31 +00003251 return;
3252 }
3253
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003254 D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getRange(), S.Context));
Peter Collingbourneced76712010-12-01 03:15:31 +00003255 } else {
3256 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host";
3257 }
3258}
3259
Chandler Carruth1b03c872011-07-02 00:01:44 +00003260static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003261 if (S.LangOpts.CUDA) {
3262 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003263 if (!checkAttributeNumArgs(S, Attr, 0))
Peter Collingbourneced76712010-12-01 03:15:31 +00003264 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00003265
Peter Collingbourneced76712010-12-01 03:15:31 +00003266
Chandler Carruth87c44602011-07-01 23:49:12 +00003267 if (!isa<VarDecl>(D)) {
Peter Collingbourneced76712010-12-01 03:15:31 +00003268 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003269 << Attr.getName() << ExpectedVariable;
Peter Collingbourneced76712010-12-01 03:15:31 +00003270 return;
3271 }
3272
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003273 D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getRange(), S.Context));
Peter Collingbourneced76712010-12-01 03:15:31 +00003274 } else {
3275 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared";
3276 }
3277}
3278
Chandler Carruth1b03c872011-07-02 00:01:44 +00003279static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chris Lattner26e25542009-04-14 16:30:50 +00003280 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003281 if (!checkAttributeNumArgs(S, Attr, 0))
Chris Lattner26e25542009-04-14 16:30:50 +00003282 return;
Mike Stumpbf916502009-07-24 19:02:52 +00003283
Chandler Carruth87c44602011-07-01 23:49:12 +00003284 FunctionDecl *Fn = dyn_cast<FunctionDecl>(D);
Chris Lattnerc5197432009-04-14 17:02:11 +00003285 if (Fn == 0) {
Chris Lattner26e25542009-04-14 16:30:50 +00003286 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003287 << Attr.getName() << ExpectedFunction;
Chris Lattner26e25542009-04-14 16:30:50 +00003288 return;
3289 }
Mike Stumpbf916502009-07-24 19:02:52 +00003290
Douglas Gregor0130f3c2009-10-27 21:01:01 +00003291 if (!Fn->isInlineSpecified()) {
Chris Lattnercf2a7212009-04-20 19:12:28 +00003292 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
Chris Lattnerc5197432009-04-14 17:02:11 +00003293 return;
3294 }
Mike Stumpbf916502009-07-24 19:02:52 +00003295
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003296 D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getRange(), S.Context));
Chris Lattner26e25542009-04-14 16:30:50 +00003297}
3298
Chandler Carruth1b03c872011-07-02 00:01:44 +00003299static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003300 if (hasDeclarator(D)) return;
Abramo Bagnarae215f722010-04-30 13:10:51 +00003301
Chandler Carruth87c44602011-07-01 23:49:12 +00003302 // Diagnostic is emitted elsewhere: here we store the (valid) Attr
John McCall711c52b2011-01-05 12:14:39 +00003303 // in the Decl node for syntactic reasoning, e.g., pretty-printing.
3304 CallingConv CC;
Chandler Carruth87c44602011-07-01 23:49:12 +00003305 if (S.CheckCallingConvAttr(Attr, CC))
John McCall711c52b2011-01-05 12:14:39 +00003306 return;
3307
Chandler Carruth87c44602011-07-01 23:49:12 +00003308 if (!isa<ObjCMethodDecl>(D)) {
3309 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3310 << Attr.getName() << ExpectedFunctionOrMethod;
John McCall711c52b2011-01-05 12:14:39 +00003311 return;
3312 }
3313
Chandler Carruth87c44602011-07-01 23:49:12 +00003314 switch (Attr.getKind()) {
Abramo Bagnarae215f722010-04-30 13:10:51 +00003315 case AttributeList::AT_fastcall:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003316 D->addAttr(::new (S.Context) FastCallAttr(Attr.getRange(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00003317 return;
3318 case AttributeList::AT_stdcall:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003319 D->addAttr(::new (S.Context) StdCallAttr(Attr.getRange(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00003320 return;
Douglas Gregorf813a2c2010-05-18 16:57:00 +00003321 case AttributeList::AT_thiscall:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003322 D->addAttr(::new (S.Context) ThisCallAttr(Attr.getRange(), S.Context));
Douglas Gregor04633eb2010-08-30 23:30:49 +00003323 return;
Abramo Bagnarae215f722010-04-30 13:10:51 +00003324 case AttributeList::AT_cdecl:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003325 D->addAttr(::new (S.Context) CDeclAttr(Attr.getRange(), S.Context));
Abramo Bagnarae215f722010-04-30 13:10:51 +00003326 return;
Dawn Perchik52fc3142010-09-03 01:29:35 +00003327 case AttributeList::AT_pascal:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003328 D->addAttr(::new (S.Context) PascalAttr(Attr.getRange(), S.Context));
Dawn Perchik52fc3142010-09-03 01:29:35 +00003329 return;
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003330 case AttributeList::AT_pcs: {
Chandler Carruth87c44602011-07-01 23:49:12 +00003331 Expr *Arg = Attr.getArg(0);
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003332 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Douglas Gregor5cee1192011-07-27 05:40:30 +00003333 if (!Str || !Str->isAscii()) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003334 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003335 << "pcs" << 1;
Chandler Carruth87c44602011-07-01 23:49:12 +00003336 Attr.setInvalid();
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003337 return;
3338 }
3339
Chris Lattner5f9e2722011-07-23 10:55:15 +00003340 StringRef StrRef = Str->getString();
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003341 PcsAttr::PCSType PCS;
3342 if (StrRef == "aapcs")
3343 PCS = PcsAttr::AAPCS;
3344 else if (StrRef == "aapcs-vfp")
3345 PCS = PcsAttr::AAPCS_VFP;
3346 else {
Chandler Carruth87c44602011-07-01 23:49:12 +00003347 S.Diag(Attr.getLoc(), diag::err_invalid_pcs);
3348 Attr.setInvalid();
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003349 return;
3350 }
3351
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003352 D->addAttr(::new (S.Context) PcsAttr(Attr.getRange(), S.Context, PCS));
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003353 }
Abramo Bagnarae215f722010-04-30 13:10:51 +00003354 default:
3355 llvm_unreachable("unexpected attribute kind");
Abramo Bagnarae215f722010-04-30 13:10:51 +00003356 }
3357}
3358
Chandler Carruth1b03c872011-07-02 00:01:44 +00003359static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){
Chandler Carruth56aeb402011-07-11 23:33:05 +00003360 assert(!Attr.isInvalid());
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003361 D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getRange(), S.Context));
Peter Collingbournef315fa82011-02-14 01:42:53 +00003362}
3363
John McCall711c52b2011-01-05 12:14:39 +00003364bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) {
3365 if (attr.isInvalid())
3366 return true;
3367
Ted Kremenek831efae2011-04-15 05:49:29 +00003368 if ((attr.getNumArgs() != 0 &&
3369 !(attr.getKind() == AttributeList::AT_pcs && attr.getNumArgs() == 1)) ||
3370 attr.getParameterName()) {
John McCall711c52b2011-01-05 12:14:39 +00003371 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0;
3372 attr.setInvalid();
3373 return true;
3374 }
3375
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003376 // TODO: diagnose uses of these conventions on the wrong target. Or, better
3377 // move to TargetAttributesSema one day.
John McCall711c52b2011-01-05 12:14:39 +00003378 switch (attr.getKind()) {
3379 case AttributeList::AT_cdecl: CC = CC_C; break;
3380 case AttributeList::AT_fastcall: CC = CC_X86FastCall; break;
3381 case AttributeList::AT_stdcall: CC = CC_X86StdCall; break;
3382 case AttributeList::AT_thiscall: CC = CC_X86ThisCall; break;
3383 case AttributeList::AT_pascal: CC = CC_X86Pascal; break;
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003384 case AttributeList::AT_pcs: {
3385 Expr *Arg = attr.getArg(0);
3386 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Douglas Gregor5cee1192011-07-27 05:40:30 +00003387 if (!Str || !Str->isAscii()) {
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003388 Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
3389 << "pcs" << 1;
3390 attr.setInvalid();
3391 return true;
3392 }
3393
Chris Lattner5f9e2722011-07-23 10:55:15 +00003394 StringRef StrRef = Str->getString();
Anton Korobeynikov414d8962011-04-14 20:06:49 +00003395 if (StrRef == "aapcs") {
3396 CC = CC_AAPCS;
3397 break;
3398 } else if (StrRef == "aapcs-vfp") {
3399 CC = CC_AAPCS_VFP;
3400 break;
3401 }
3402 // FALLS THROUGH
3403 }
David Blaikie7530c032012-01-17 06:56:22 +00003404 default: llvm_unreachable("unexpected attribute kind");
John McCall711c52b2011-01-05 12:14:39 +00003405 }
3406
3407 return false;
3408}
3409
Chandler Carruth1b03c872011-07-02 00:01:44 +00003410static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003411 if (hasDeclarator(D)) return;
John McCall711c52b2011-01-05 12:14:39 +00003412
3413 unsigned numParams;
Chandler Carruth87c44602011-07-01 23:49:12 +00003414 if (S.CheckRegparmAttr(Attr, numParams))
John McCall711c52b2011-01-05 12:14:39 +00003415 return;
3416
Chandler Carruth87c44602011-07-01 23:49:12 +00003417 if (!isa<ObjCMethodDecl>(D)) {
3418 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3419 << Attr.getName() << ExpectedFunctionOrMethod;
Fariborz Jahanianee760332009-03-27 18:38:55 +00003420 return;
3421 }
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003422
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003423 D->addAttr(::new (S.Context) RegparmAttr(Attr.getRange(), S.Context, numParams));
John McCall711c52b2011-01-05 12:14:39 +00003424}
3425
3426/// Checks a regparm attribute, returning true if it is ill-formed and
3427/// otherwise setting numParams to the appropriate value.
Chandler Carruth87c44602011-07-01 23:49:12 +00003428bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
3429 if (Attr.isInvalid())
John McCall711c52b2011-01-05 12:14:39 +00003430 return true;
3431
Chandler Carruth87c44602011-07-01 23:49:12 +00003432 if (Attr.getNumArgs() != 1) {
3433 Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
3434 Attr.setInvalid();
John McCall711c52b2011-01-05 12:14:39 +00003435 return true;
Fariborz Jahanianee760332009-03-27 18:38:55 +00003436 }
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003437
Chandler Carruth87c44602011-07-01 23:49:12 +00003438 Expr *NumParamsExpr = Attr.getArg(0);
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003439 llvm::APSInt NumParams(32);
Douglas Gregorac06a0e2010-05-18 23:01:22 +00003440 if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() ||
John McCall711c52b2011-01-05 12:14:39 +00003441 !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003442 Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003443 << "regparm" << NumParamsExpr->getSourceRange();
Chandler Carruth87c44602011-07-01 23:49:12 +00003444 Attr.setInvalid();
John McCall711c52b2011-01-05 12:14:39 +00003445 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003446 }
3447
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003448 if (Context.getTargetInfo().getRegParmMax() == 0) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003449 Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003450 << NumParamsExpr->getSourceRange();
Chandler Carruth87c44602011-07-01 23:49:12 +00003451 Attr.setInvalid();
John McCall711c52b2011-01-05 12:14:39 +00003452 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003453 }
3454
John McCall711c52b2011-01-05 12:14:39 +00003455 numParams = NumParams.getZExtValue();
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003456 if (numParams > Context.getTargetInfo().getRegParmMax()) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003457 Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00003458 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
Chandler Carruth87c44602011-07-01 23:49:12 +00003459 Attr.setInvalid();
John McCall711c52b2011-01-05 12:14:39 +00003460 return true;
Eli Friedman55d3aaf2009-03-27 21:06:47 +00003461 }
3462
John McCall711c52b2011-01-05 12:14:39 +00003463 return false;
Fariborz Jahanianee760332009-03-27 18:38:55 +00003464}
3465
Chandler Carruth1b03c872011-07-02 00:01:44 +00003466static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){
Peter Collingbourne7b381982010-12-12 23:03:07 +00003467 if (S.LangOpts.CUDA) {
3468 // check the attribute arguments.
3469 if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) {
John McCallbdc49d32011-03-02 12:15:05 +00003470 // FIXME: 0 is not okay.
3471 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2;
Peter Collingbourne7b381982010-12-12 23:03:07 +00003472 return;
3473 }
3474
Chandler Carruth87c44602011-07-01 23:49:12 +00003475 if (!isFunctionOrMethod(D)) {
Peter Collingbourne7b381982010-12-12 23:03:07 +00003476 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
John McCall883cc2c2011-03-02 12:29:23 +00003477 << Attr.getName() << ExpectedFunctionOrMethod;
Peter Collingbourne7b381982010-12-12 23:03:07 +00003478 return;
3479 }
3480
3481 Expr *MaxThreadsExpr = Attr.getArg(0);
3482 llvm::APSInt MaxThreads(32);
3483 if (MaxThreadsExpr->isTypeDependent() ||
3484 MaxThreadsExpr->isValueDependent() ||
3485 !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) {
3486 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3487 << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange();
3488 return;
3489 }
3490
3491 llvm::APSInt MinBlocks(32);
3492 if (Attr.getNumArgs() > 1) {
3493 Expr *MinBlocksExpr = Attr.getArg(1);
3494 if (MinBlocksExpr->isTypeDependent() ||
3495 MinBlocksExpr->isValueDependent() ||
3496 !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) {
3497 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int)
3498 << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange();
3499 return;
3500 }
3501 }
3502
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003503 D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getRange(), S.Context,
Peter Collingbourne7b381982010-12-12 23:03:07 +00003504 MaxThreads.getZExtValue(),
3505 MinBlocks.getZExtValue()));
3506 } else {
3507 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds";
3508 }
3509}
3510
Chris Lattner0744e5f2008-06-29 00:23:49 +00003511//===----------------------------------------------------------------------===//
Ted Kremenekb71368d2009-05-09 02:44:38 +00003512// Checker-specific attribute handlers.
3513//===----------------------------------------------------------------------===//
3514
John McCallc7ad3812011-01-25 03:31:58 +00003515static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
Douglas Gregor6c73a292011-10-09 22:26:49 +00003516 return type->isDependentType() ||
3517 type->isObjCObjectPointerType() ||
3518 S.Context.isObjCNSObjectType(type);
John McCallc7ad3812011-01-25 03:31:58 +00003519}
3520static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
Douglas Gregor6c73a292011-10-09 22:26:49 +00003521 return type->isDependentType() ||
3522 type->isPointerType() ||
3523 isValidSubjectOfNSAttribute(S, type);
John McCallc7ad3812011-01-25 03:31:58 +00003524}
3525
Chandler Carruth1b03c872011-07-02 00:01:44 +00003526static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003527 ParmVarDecl *param = dyn_cast<ParmVarDecl>(D);
John McCallc7ad3812011-01-25 03:31:58 +00003528 if (!param) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003529 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003530 << Attr.getRange() << Attr.getName() << ExpectedParameter;
John McCallc7ad3812011-01-25 03:31:58 +00003531 return;
3532 }
3533
3534 bool typeOK, cf;
Chandler Carruth87c44602011-07-01 23:49:12 +00003535 if (Attr.getKind() == AttributeList::AT_ns_consumed) {
John McCallc7ad3812011-01-25 03:31:58 +00003536 typeOK = isValidSubjectOfNSAttribute(S, param->getType());
3537 cf = false;
3538 } else {
3539 typeOK = isValidSubjectOfCFAttribute(S, param->getType());
3540 cf = true;
3541 }
3542
3543 if (!typeOK) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003544 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003545 << Attr.getRange() << Attr.getName() << cf;
John McCallc7ad3812011-01-25 03:31:58 +00003546 return;
3547 }
3548
3549 if (cf)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003550 param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getRange(), S.Context));
John McCallc7ad3812011-01-25 03:31:58 +00003551 else
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003552 param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getRange(), S.Context));
John McCallc7ad3812011-01-25 03:31:58 +00003553}
3554
Chandler Carruth1b03c872011-07-02 00:01:44 +00003555static void handleNSConsumesSelfAttr(Sema &S, Decl *D,
3556 const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003557 if (!isa<ObjCMethodDecl>(D)) {
3558 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003559 << Attr.getRange() << Attr.getName() << ExpectedMethod;
John McCallc7ad3812011-01-25 03:31:58 +00003560 return;
3561 }
3562
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003563 D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getRange(), S.Context));
John McCallc7ad3812011-01-25 03:31:58 +00003564}
3565
Chandler Carruth1b03c872011-07-02 00:01:44 +00003566static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
3567 const AttributeList &Attr) {
Ted Kremenekb71368d2009-05-09 02:44:38 +00003568
John McCallc7ad3812011-01-25 03:31:58 +00003569 QualType returnType;
Mike Stumpbf916502009-07-24 19:02:52 +00003570
Chandler Carruth87c44602011-07-01 23:49:12 +00003571 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
John McCallc7ad3812011-01-25 03:31:58 +00003572 returnType = MD->getResultType();
Chandler Carruth87c44602011-07-01 23:49:12 +00003573 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
Fariborz Jahanian831fb962011-06-25 00:17:46 +00003574 returnType = PD->getType();
David Blaikie4e4d0842012-03-11 07:00:24 +00003575 else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
Chandler Carruth87c44602011-07-01 23:49:12 +00003576 (Attr.getKind() == AttributeList::AT_ns_returns_retained))
John McCallf85e1932011-06-15 23:02:42 +00003577 return; // ignore: was handled as a type attribute
Chandler Carruth87c44602011-07-01 23:49:12 +00003578 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
John McCallc7ad3812011-01-25 03:31:58 +00003579 returnType = FD->getResultType();
Ted Kremenek5dc53c92009-05-13 21:07:32 +00003580 else {
Chandler Carruth87c44602011-07-01 23:49:12 +00003581 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003582 << Attr.getRange() << Attr.getName()
John McCall883cc2c2011-03-02 12:29:23 +00003583 << ExpectedFunctionOrMethod;
Ted Kremenekb71368d2009-05-09 02:44:38 +00003584 return;
3585 }
Mike Stumpbf916502009-07-24 19:02:52 +00003586
John McCallc7ad3812011-01-25 03:31:58 +00003587 bool typeOK;
3588 bool cf;
Chandler Carruth87c44602011-07-01 23:49:12 +00003589 switch (Attr.getKind()) {
David Blaikie7530c032012-01-17 06:56:22 +00003590 default: llvm_unreachable("invalid ownership attribute");
John McCallc7ad3812011-01-25 03:31:58 +00003591 case AttributeList::AT_ns_returns_autoreleased:
3592 case AttributeList::AT_ns_returns_retained:
3593 case AttributeList::AT_ns_returns_not_retained:
3594 typeOK = isValidSubjectOfNSAttribute(S, returnType);
3595 cf = false;
3596 break;
3597
3598 case AttributeList::AT_cf_returns_retained:
3599 case AttributeList::AT_cf_returns_not_retained:
3600 typeOK = isValidSubjectOfCFAttribute(S, returnType);
3601 cf = true;
3602 break;
3603 }
3604
3605 if (!typeOK) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003606 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003607 << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf;
Mike Stumpbf916502009-07-24 19:02:52 +00003608 return;
Ted Kremenek5dc53c92009-05-13 21:07:32 +00003609 }
Mike Stumpbf916502009-07-24 19:02:52 +00003610
Chandler Carruth87c44602011-07-01 23:49:12 +00003611 switch (Attr.getKind()) {
Ted Kremenekb71368d2009-05-09 02:44:38 +00003612 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00003613 llvm_unreachable("invalid ownership attribute");
John McCallc7ad3812011-01-25 03:31:58 +00003614 case AttributeList::AT_ns_returns_autoreleased:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003615 D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getRange(),
John McCallc7ad3812011-01-25 03:31:58 +00003616 S.Context));
3617 return;
Ted Kremenek31c780d2010-02-18 00:05:45 +00003618 case AttributeList::AT_cf_returns_not_retained:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003619 D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getRange(),
Eric Christopherf48f3672010-12-01 22:13:54 +00003620 S.Context));
Ted Kremenek31c780d2010-02-18 00:05:45 +00003621 return;
3622 case AttributeList::AT_ns_returns_not_retained:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003623 D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getRange(),
Eric Christopherf48f3672010-12-01 22:13:54 +00003624 S.Context));
Ted Kremenek31c780d2010-02-18 00:05:45 +00003625 return;
Ted Kremenekb71368d2009-05-09 02:44:38 +00003626 case AttributeList::AT_cf_returns_retained:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003627 D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getRange(),
Eric Christopherf48f3672010-12-01 22:13:54 +00003628 S.Context));
Ted Kremenekb71368d2009-05-09 02:44:38 +00003629 return;
3630 case AttributeList::AT_ns_returns_retained:
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003631 D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getRange(),
Eric Christopherf48f3672010-12-01 22:13:54 +00003632 S.Context));
Ted Kremenekb71368d2009-05-09 02:44:38 +00003633 return;
3634 };
3635}
3636
John McCalldc7c5ad2011-07-22 08:53:00 +00003637static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
3638 const AttributeList &attr) {
3639 SourceLocation loc = attr.getLoc();
3640
3641 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D);
3642
Fariborz Jahanian94d55d72012-04-21 17:51:44 +00003643 if (!method) {
Fariborz Jahanian0e78afb2012-04-20 22:00:46 +00003644 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003645 << SourceRange(loc, loc) << attr.getName() << ExpectedMethod;
John McCalldc7c5ad2011-07-22 08:53:00 +00003646 return;
3647 }
3648
3649 // Check that the method returns a normal pointer.
3650 QualType resultType = method->getResultType();
Fariborz Jahanianf2e59452011-09-30 20:50:23 +00003651
3652 if (!resultType->isReferenceType() &&
3653 (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
John McCalldc7c5ad2011-07-22 08:53:00 +00003654 S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
3655 << SourceRange(loc)
3656 << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2;
3657
3658 // Drop the attribute.
3659 return;
3660 }
3661
3662 method->addAttr(
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003663 ::new (S.Context) ObjCReturnsInnerPointerAttr(attr.getRange(), S.Context));
John McCalldc7c5ad2011-07-22 08:53:00 +00003664}
3665
John McCall8dfac0b2011-09-30 05:12:12 +00003666/// Handle cf_audited_transfer and cf_unknown_transfer.
3667static void handleCFTransferAttr(Sema &S, Decl *D, const AttributeList &A) {
3668 if (!isa<FunctionDecl>(D)) {
3669 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003670 << A.getRange() << A.getName() << ExpectedFunction;
John McCall8dfac0b2011-09-30 05:12:12 +00003671 return;
3672 }
3673
3674 bool IsAudited = (A.getKind() == AttributeList::AT_cf_audited_transfer);
3675
3676 // Check whether there's a conflicting attribute already present.
3677 Attr *Existing;
3678 if (IsAudited) {
3679 Existing = D->getAttr<CFUnknownTransferAttr>();
3680 } else {
3681 Existing = D->getAttr<CFAuditedTransferAttr>();
3682 }
3683 if (Existing) {
3684 S.Diag(D->getLocStart(), diag::err_attributes_are_not_compatible)
3685 << A.getName()
3686 << (IsAudited ? "cf_unknown_transfer" : "cf_audited_transfer")
3687 << A.getRange() << Existing->getRange();
3688 return;
3689 }
3690
3691 // All clear; add the attribute.
3692 if (IsAudited) {
3693 D->addAttr(
3694 ::new (S.Context) CFAuditedTransferAttr(A.getRange(), S.Context));
3695 } else {
3696 D->addAttr(
3697 ::new (S.Context) CFUnknownTransferAttr(A.getRange(), S.Context));
3698 }
3699}
3700
John McCallfe98da02011-09-29 07:17:38 +00003701static void handleNSBridgedAttr(Sema &S, Scope *Sc, Decl *D,
3702 const AttributeList &Attr) {
3703 RecordDecl *RD = dyn_cast<RecordDecl>(D);
3704 if (!RD || RD->isUnion()) {
3705 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003706 << Attr.getRange() << Attr.getName() << ExpectedStruct;
John McCallfe98da02011-09-29 07:17:38 +00003707 }
3708
3709 IdentifierInfo *ParmName = Attr.getParameterName();
3710
3711 // In Objective-C, verify that the type names an Objective-C type.
3712 // We don't want to check this outside of ObjC because people sometimes
3713 // do crazy C declarations of Objective-C types.
David Blaikie4e4d0842012-03-11 07:00:24 +00003714 if (ParmName && S.getLangOpts().ObjC1) {
John McCallfe98da02011-09-29 07:17:38 +00003715 // Check for an existing type with this name.
3716 LookupResult R(S, DeclarationName(ParmName), Attr.getParameterLoc(),
3717 Sema::LookupOrdinaryName);
3718 if (S.LookupName(R, Sc)) {
3719 NamedDecl *Target = R.getFoundDecl();
3720 if (Target && !isa<ObjCInterfaceDecl>(Target)) {
3721 S.Diag(D->getLocStart(), diag::err_ns_bridged_not_interface);
3722 S.Diag(Target->getLocStart(), diag::note_declared_at);
3723 }
3724 }
3725 }
3726
3727 D->addAttr(::new (S.Context) NSBridgedAttr(Attr.getRange(), S.Context,
3728 ParmName));
3729}
3730
Chandler Carruth1b03c872011-07-02 00:01:44 +00003731static void handleObjCOwnershipAttr(Sema &S, Decl *D,
3732 const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003733 if (hasDeclarator(D)) return;
John McCallf85e1932011-06-15 23:02:42 +00003734
Chandler Carruth87c44602011-07-01 23:49:12 +00003735 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003736 << Attr.getRange() << Attr.getName() << ExpectedVariable;
John McCallf85e1932011-06-15 23:02:42 +00003737}
3738
Chandler Carruth1b03c872011-07-02 00:01:44 +00003739static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
3740 const AttributeList &Attr) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003741 if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003742 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003743 << Attr.getRange() << Attr.getName() << ExpectedVariable;
John McCallf85e1932011-06-15 23:02:42 +00003744 return;
3745 }
3746
Chandler Carruth87c44602011-07-01 23:49:12 +00003747 ValueDecl *vd = cast<ValueDecl>(D);
John McCallf85e1932011-06-15 23:02:42 +00003748 QualType type = vd->getType();
3749
3750 if (!type->isDependentType() &&
3751 !type->isObjCLifetimeType()) {
Chandler Carruth87c44602011-07-01 23:49:12 +00003752 S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
John McCallf85e1932011-06-15 23:02:42 +00003753 << type;
3754 return;
3755 }
3756
3757 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
3758
3759 // If we have no lifetime yet, check the lifetime we're presumably
3760 // going to infer.
3761 if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
3762 lifetime = type->getObjCARCImplicitLifetime();
3763
3764 switch (lifetime) {
3765 case Qualifiers::OCL_None:
3766 assert(type->isDependentType() &&
3767 "didn't infer lifetime for non-dependent type?");
3768 break;
3769
3770 case Qualifiers::OCL_Weak: // meaningful
3771 case Qualifiers::OCL_Strong: // meaningful
3772 break;
3773
3774 case Qualifiers::OCL_ExplicitNone:
3775 case Qualifiers::OCL_Autoreleasing:
Chandler Carruth87c44602011-07-01 23:49:12 +00003776 S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
John McCallf85e1932011-06-15 23:02:42 +00003777 << (lifetime == Qualifiers::OCL_Autoreleasing);
3778 break;
3779 }
3780
Chandler Carruth87c44602011-07-01 23:49:12 +00003781 D->addAttr(::new (S.Context)
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003782 ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context));
John McCallf85e1932011-06-15 23:02:42 +00003783}
3784
Charles Davisf0122fe2010-02-16 18:27:26 +00003785static bool isKnownDeclSpecAttr(const AttributeList &Attr) {
Aaron Ballman94287722012-02-23 22:46:33 +00003786 switch (Attr.getKind()) {
3787 default:
3788 return false;
3789 case AttributeList::AT_dllimport:
3790 case AttributeList::AT_dllexport:
3791 case AttributeList::AT_uuid:
3792 case AttributeList::AT_deprecated:
3793 case AttributeList::AT_noreturn:
3794 case AttributeList::AT_nothrow:
3795 case AttributeList::AT_naked:
3796 case AttributeList::AT_noinline:
3797 return true;
3798 }
Francois Pichet11542142010-12-19 06:50:37 +00003799}
3800
3801//===----------------------------------------------------------------------===//
3802// Microsoft specific attribute handlers.
3803//===----------------------------------------------------------------------===//
3804
Chandler Carruth1b03c872011-07-02 00:01:44 +00003805static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
Francois Pichet62ec1f22011-09-17 17:15:52 +00003806 if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) {
Francois Pichet11542142010-12-19 06:50:37 +00003807 // check the attribute arguments.
Chandler Carruth1731e202011-07-11 23:30:35 +00003808 if (!checkAttributeNumArgs(S, Attr, 1))
Francois Pichet11542142010-12-19 06:50:37 +00003809 return;
Chandler Carruth1731e202011-07-11 23:30:35 +00003810
Francois Pichet11542142010-12-19 06:50:37 +00003811 Expr *Arg = Attr.getArg(0);
3812 StringLiteral *Str = dyn_cast<StringLiteral>(Arg);
Douglas Gregor5cee1192011-07-27 05:40:30 +00003813 if (!Str || !Str->isAscii()) {
Francois Pichetd3d3be92010-12-20 01:41:49 +00003814 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
3815 << "uuid" << 1;
3816 return;
3817 }
3818
Chris Lattner5f9e2722011-07-23 10:55:15 +00003819 StringRef StrRef = Str->getString();
Francois Pichetd3d3be92010-12-20 01:41:49 +00003820
3821 bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' &&
3822 StrRef.back() == '}';
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003823
Francois Pichetd3d3be92010-12-20 01:41:49 +00003824 // Validate GUID length.
3825 if (IsCurly && StrRef.size() != 38) {
3826 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3827 return;
3828 }
3829 if (!IsCurly && StrRef.size() != 36) {
3830 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3831 return;
3832 }
3833
Douglas Gregorf6b8b582012-03-14 16:55:17 +00003834 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
Francois Pichetd3d3be92010-12-20 01:41:49 +00003835 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
Chris Lattner5f9e2722011-07-23 10:55:15 +00003836 StringRef::iterator I = StrRef.begin();
Anders Carlssonf89e0422011-01-23 21:07:30 +00003837 if (IsCurly) // Skip the optional '{'
3838 ++I;
3839
3840 for (int i = 0; i < 36; ++i) {
Francois Pichetd3d3be92010-12-20 01:41:49 +00003841 if (i == 8 || i == 13 || i == 18 || i == 23) {
3842 if (*I != '-') {
3843 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3844 return;
3845 }
3846 } else if (!isxdigit(*I)) {
3847 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid);
3848 return;
3849 }
3850 I++;
3851 }
Francois Pichet11542142010-12-19 06:50:37 +00003852
Argyrios Kyrtzidis768d6ca2011-09-13 16:05:58 +00003853 D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context,
Francois Pichet11542142010-12-19 06:50:37 +00003854 Str->getString()));
Francois Pichetd3d3be92010-12-20 01:41:49 +00003855 } else
Francois Pichet11542142010-12-19 06:50:37 +00003856 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid";
Charles Davisf0122fe2010-02-16 18:27:26 +00003857}
3858
John McCallc052dbb2012-05-22 21:28:12 +00003859static void handleInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3860 if (S.LangOpts.MicrosoftExt) {
3861 AttributeList::Kind Kind = Attr.getKind();
3862 if (Kind == AttributeList::AT_single_inheritance)
3863 D->addAttr(
3864 ::new (S.Context) SingleInheritanceAttr(Attr.getRange(), S.Context));
3865 else if (Kind == AttributeList::AT_multiple_inheritance)
3866 D->addAttr(
3867 ::new (S.Context) MultipleInheritanceAttr(Attr.getRange(), S.Context));
3868 else if (Kind == AttributeList::AT_virtual_inheritance)
3869 D->addAttr(
3870 ::new (S.Context) VirtualInheritanceAttr(Attr.getRange(), S.Context));
3871 } else
3872 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3873}
3874
3875static void handlePortabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3876 if (S.LangOpts.MicrosoftExt) {
3877 AttributeList::Kind Kind = Attr.getKind();
3878 if (Kind == AttributeList::AT_ptr32)
3879 D->addAttr(
3880 ::new (S.Context) Ptr32Attr(Attr.getRange(), S.Context));
3881 else if (Kind == AttributeList::AT_ptr64)
3882 D->addAttr(
3883 ::new (S.Context) Ptr64Attr(Attr.getRange(), S.Context));
3884 else if (Kind == AttributeList::AT_w64)
3885 D->addAttr(
3886 ::new (S.Context) Win64Attr(Attr.getRange(), S.Context));
3887 } else
3888 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3889}
3890
Ted Kremenekb71368d2009-05-09 02:44:38 +00003891//===----------------------------------------------------------------------===//
Chris Lattner0744e5f2008-06-29 00:23:49 +00003892// Top Level Sema Entry Points
3893//===----------------------------------------------------------------------===//
3894
Chandler Carruth1b03c872011-07-02 00:01:44 +00003895static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
3896 const AttributeList &Attr) {
Peter Collingbourne60700392011-01-21 02:08:45 +00003897 switch (Attr.getKind()) {
Chandler Carruth1b03c872011-07-02 00:01:44 +00003898 case AttributeList::AT_device: handleDeviceAttr (S, D, Attr); break;
3899 case AttributeList::AT_host: handleHostAttr (S, D, Attr); break;
3900 case AttributeList::AT_overloadable:handleOverloadableAttr(S, D, Attr); break;
Peter Collingbourne60700392011-01-21 02:08:45 +00003901 default:
3902 break;
3903 }
3904}
Abramo Bagnarae215f722010-04-30 13:10:51 +00003905
Chandler Carruth1b03c872011-07-02 00:01:44 +00003906static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D,
3907 const AttributeList &Attr) {
Chris Lattner803d0802008-06-29 00:43:07 +00003908 switch (Attr.getKind()) {
Michael Hane53ac8a2012-03-07 00:12:16 +00003909 case AttributeList::AT_ibaction: handleIBAction(S, D, Attr); break;
3910 case AttributeList::AT_iboutlet: handleIBOutlet(S, D, Attr); break;
3911 case AttributeList::AT_iboutletcollection:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003912 handleIBOutletCollection(S, D, Attr); break;
Chris Lattner803d0802008-06-29 00:43:07 +00003913 case AttributeList::AT_address_space:
Peter Collingbourne207f4d82011-03-18 22:38:29 +00003914 case AttributeList::AT_opencl_image_access:
Fariborz Jahanianba372b82009-02-18 17:52:36 +00003915 case AttributeList::AT_objc_gc:
John Thompson6e132aa2009-12-04 21:51:28 +00003916 case AttributeList::AT_vector_size:
Bob Wilson4211bb62010-11-16 00:32:24 +00003917 case AttributeList::AT_neon_vector_type:
3918 case AttributeList::AT_neon_polyvector_type:
Mike Stumpbf916502009-07-24 19:02:52 +00003919 // Ignore these, these are type attributes, handled by
3920 // ProcessTypeAttributes.
Chris Lattner803d0802008-06-29 00:43:07 +00003921 break;
Peter Collingbourne60700392011-01-21 02:08:45 +00003922 case AttributeList::AT_device:
3923 case AttributeList::AT_host:
3924 case AttributeList::AT_overloadable:
3925 // Ignore, this is a non-inheritable attribute, handled
3926 // by ProcessNonInheritableDeclAttr.
3927 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00003928 case AttributeList::AT_alias: handleAliasAttr (S, D, Attr); break;
3929 case AttributeList::AT_aligned: handleAlignedAttr (S, D, Attr); break;
Nuno Lopes587de5b2012-05-24 00:22:00 +00003930 case AttributeList::AT_alloc_size: handleAllocSizeAttr (S, D, Attr); break;
Mike Stumpbf916502009-07-24 19:02:52 +00003931 case AttributeList::AT_always_inline:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003932 handleAlwaysInlineAttr (S, D, Attr); break;
Ted Kremenekb7252322009-04-10 00:01:14 +00003933 case AttributeList::AT_analyzer_noreturn:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003934 handleAnalyzerNoReturnAttr (S, D, Attr); break;
3935 case AttributeList::AT_annotate: handleAnnotateAttr (S, D, Attr); break;
3936 case AttributeList::AT_availability:handleAvailabilityAttr(S, D, Attr); break;
Sean Huntbbd37c62009-11-21 08:43:09 +00003937 case AttributeList::AT_carries_dependency:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003938 handleDependencyAttr (S, D, Attr); break;
3939 case AttributeList::AT_common: handleCommonAttr (S, D, Attr); break;
3940 case AttributeList::AT_constant: handleConstantAttr (S, D, Attr); break;
3941 case AttributeList::AT_constructor: handleConstructorAttr (S, D, Attr); break;
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00003942 case AttributeList::AT_deprecated:
3943 handleAttrWithMessage<DeprecatedAttr>(S, D, Attr, "deprecated");
3944 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00003945 case AttributeList::AT_destructor: handleDestructorAttr (S, D, Attr); break;
Chris Lattner803d0802008-06-29 00:43:07 +00003946 case AttributeList::AT_ext_vector_type:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003947 handleExtVectorTypeAttr(S, scope, D, Attr);
Chris Lattner803d0802008-06-29 00:43:07 +00003948 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00003949 case AttributeList::AT_format: handleFormatAttr (S, D, Attr); break;
3950 case AttributeList::AT_format_arg: handleFormatArgAttr (S, D, Attr); break;
3951 case AttributeList::AT_global: handleGlobalAttr (S, D, Attr); break;
3952 case AttributeList::AT_gnu_inline: handleGNUInlineAttr (S, D, Attr); break;
Peter Collingbourne7b381982010-12-12 23:03:07 +00003953 case AttributeList::AT_launch_bounds:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003954 handleLaunchBoundsAttr(S, D, Attr);
Peter Collingbourne7b381982010-12-12 23:03:07 +00003955 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00003956 case AttributeList::AT_mode: handleModeAttr (S, D, Attr); break;
3957 case AttributeList::AT_malloc: handleMallocAttr (S, D, Attr); break;
3958 case AttributeList::AT_may_alias: handleMayAliasAttr (S, D, Attr); break;
3959 case AttributeList::AT_nocommon: handleNoCommonAttr (S, D, Attr); break;
3960 case AttributeList::AT_nonnull: handleNonNullAttr (S, D, Attr); break;
Ted Kremenekdd0e4902010-07-31 01:52:11 +00003961 case AttributeList::AT_ownership_returns:
3962 case AttributeList::AT_ownership_takes:
3963 case AttributeList::AT_ownership_holds:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003964 handleOwnershipAttr (S, D, Attr); break;
Benjamin Krameree409a92012-05-12 21:10:52 +00003965 case AttributeList::AT_cold: handleColdAttr (S, D, Attr); break;
3966 case AttributeList::AT_hot: handleHotAttr (S, D, Attr); break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00003967 case AttributeList::AT_naked: handleNakedAttr (S, D, Attr); break;
3968 case AttributeList::AT_noreturn: handleNoReturnAttr (S, D, Attr); break;
3969 case AttributeList::AT_nothrow: handleNothrowAttr (S, D, Attr); break;
3970 case AttributeList::AT_shared: handleSharedAttr (S, D, Attr); break;
3971 case AttributeList::AT_vecreturn: handleVecReturnAttr (S, D, Attr); break;
Ted Kremenekb71368d2009-05-09 02:44:38 +00003972
Argyrios Kyrtzidisb8b03132011-06-24 00:08:59 +00003973 case AttributeList::AT_objc_ownership:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003974 handleObjCOwnershipAttr(S, D, Attr); break;
John McCallf85e1932011-06-15 23:02:42 +00003975 case AttributeList::AT_objc_precise_lifetime:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003976 handleObjCPreciseLifetimeAttr(S, D, Attr); break;
John McCallf85e1932011-06-15 23:02:42 +00003977
John McCalldc7c5ad2011-07-22 08:53:00 +00003978 case AttributeList::AT_objc_returns_inner_pointer:
3979 handleObjCReturnsInnerPointerAttr(S, D, Attr); break;
3980
John McCallfe98da02011-09-29 07:17:38 +00003981 case AttributeList::AT_ns_bridged:
3982 handleNSBridgedAttr(S, scope, D, Attr); break;
3983
John McCall8dfac0b2011-09-30 05:12:12 +00003984 case AttributeList::AT_cf_audited_transfer:
3985 case AttributeList::AT_cf_unknown_transfer:
3986 handleCFTransferAttr(S, D, Attr); break;
3987
Ted Kremenekb71368d2009-05-09 02:44:38 +00003988 // Checker-specific.
John McCallc7ad3812011-01-25 03:31:58 +00003989 case AttributeList::AT_cf_consumed:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003990 case AttributeList::AT_ns_consumed: handleNSConsumedAttr (S, D, Attr); break;
John McCallc7ad3812011-01-25 03:31:58 +00003991 case AttributeList::AT_ns_consumes_self:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003992 handleNSConsumesSelfAttr(S, D, Attr); break;
John McCallc7ad3812011-01-25 03:31:58 +00003993
3994 case AttributeList::AT_ns_returns_autoreleased:
Ted Kremenek31c780d2010-02-18 00:05:45 +00003995 case AttributeList::AT_ns_returns_not_retained:
3996 case AttributeList::AT_cf_returns_not_retained:
Ted Kremenekb71368d2009-05-09 02:44:38 +00003997 case AttributeList::AT_ns_returns_retained:
3998 case AttributeList::AT_cf_returns_retained:
Chandler Carruth1b03c872011-07-02 00:01:44 +00003999 handleNSReturnsRetainedAttr(S, D, Attr); break;
Ted Kremenekb71368d2009-05-09 02:44:38 +00004000
Michael Hane53ac8a2012-03-07 00:12:16 +00004001 case AttributeList::AT_reqd_work_group_size:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004002 handleReqdWorkGroupSize(S, D, Attr); break;
Nate Begeman6f3d8382009-06-26 06:32:41 +00004003
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00004004 case AttributeList::AT_init_priority:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004005 handleInitPriorityAttr(S, D, Attr); break;
Fariborz Jahanian521f12d2010-06-18 21:44:06 +00004006
Chandler Carruth1b03c872011-07-02 00:01:44 +00004007 case AttributeList::AT_packed: handlePackedAttr (S, D, Attr); break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00004008 case AttributeList::AT_section: handleSectionAttr (S, D, Attr); break;
Benjamin Kramerbc3260d2012-05-16 12:19:08 +00004009 case AttributeList::AT_unavailable:
4010 handleAttrWithMessage<UnavailableAttr>(S, D, Attr, "unavailable");
4011 break;
Michael Hane53ac8a2012-03-07 00:12:16 +00004012 case AttributeList::AT_objc_arc_weak_reference_unavailable:
Fariborz Jahanian742352a2011-07-06 19:24:05 +00004013 handleArcWeakrefUnavailableAttr (S, D, Attr);
4014 break;
Patrick Beardb2f68202012-04-06 18:12:22 +00004015 case AttributeList::AT_objc_root_class:
4016 handleObjCRootClassAttr(S, D, Attr);
4017 break;
Ted Kremenek71207fc2012-01-05 22:47:47 +00004018 case AttributeList::AT_objc_requires_property_definitions:
4019 handleObjCRequiresPropertyDefsAttr (S, D, Attr);
Fariborz Jahaniane23dcf32012-01-03 18:45:41 +00004020 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00004021 case AttributeList::AT_unused: handleUnusedAttr (S, D, Attr); break;
Rafael Espindolaf87cced2011-10-03 14:59:42 +00004022 case AttributeList::AT_returns_twice:
4023 handleReturnsTwiceAttr(S, D, Attr);
4024 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00004025 case AttributeList::AT_used: handleUsedAttr (S, D, Attr); break;
4026 case AttributeList::AT_visibility: handleVisibilityAttr (S, D, Attr); break;
4027 case AttributeList::AT_warn_unused_result: handleWarnUnusedResult(S, D, Attr);
Chris Lattner026dc962009-02-14 07:37:35 +00004028 break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00004029 case AttributeList::AT_weak: handleWeakAttr (S, D, Attr); break;
4030 case AttributeList::AT_weakref: handleWeakRefAttr (S, D, Attr); break;
4031 case AttributeList::AT_weak_import: handleWeakImportAttr (S, D, Attr); break;
Chris Lattner803d0802008-06-29 00:43:07 +00004032 case AttributeList::AT_transparent_union:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004033 handleTransparentUnionAttr(S, D, Attr);
Chris Lattner803d0802008-06-29 00:43:07 +00004034 break;
Chris Lattner0db29ec2009-02-14 08:09:34 +00004035 case AttributeList::AT_objc_exception:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004036 handleObjCExceptionAttr(S, D, Attr);
Chris Lattner0db29ec2009-02-14 08:09:34 +00004037 break;
John McCalld5313b02011-03-02 11:33:24 +00004038 case AttributeList::AT_objc_method_family:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004039 handleObjCMethodFamilyAttr(S, D, Attr);
John McCalld5313b02011-03-02 11:33:24 +00004040 break;
Michael Hane53ac8a2012-03-07 00:12:16 +00004041 case AttributeList::AT_NSObject: handleObjCNSObject (S, D, Attr); break;
Chandler Carruth1b03c872011-07-02 00:01:44 +00004042 case AttributeList::AT_blocks: handleBlocksAttr (S, D, Attr); break;
4043 case AttributeList::AT_sentinel: handleSentinelAttr (S, D, Attr); break;
4044 case AttributeList::AT_const: handleConstAttr (S, D, Attr); break;
4045 case AttributeList::AT_pure: handlePureAttr (S, D, Attr); break;
4046 case AttributeList::AT_cleanup: handleCleanupAttr (S, D, Attr); break;
4047 case AttributeList::AT_nodebug: handleNoDebugAttr (S, D, Attr); break;
4048 case AttributeList::AT_noinline: handleNoInlineAttr (S, D, Attr); break;
4049 case AttributeList::AT_regparm: handleRegparmAttr (S, D, Attr); break;
Mike Stumpbf916502009-07-24 19:02:52 +00004050 case AttributeList::IgnoredAttribute:
Anders Carlsson05f8e472009-02-13 08:16:43 +00004051 // Just ignore
4052 break;
Chris Lattner7255a2d2010-06-22 00:03:40 +00004053 case AttributeList::AT_no_instrument_function: // Interacts with -pg.
Chandler Carruth1b03c872011-07-02 00:01:44 +00004054 handleNoInstrumentFunctionAttr(S, D, Attr);
Chris Lattner7255a2d2010-06-22 00:03:40 +00004055 break;
John McCall04a67a62010-02-05 21:31:56 +00004056 case AttributeList::AT_stdcall:
4057 case AttributeList::AT_cdecl:
4058 case AttributeList::AT_fastcall:
Douglas Gregorf813a2c2010-05-18 16:57:00 +00004059 case AttributeList::AT_thiscall:
Dawn Perchik52fc3142010-09-03 01:29:35 +00004060 case AttributeList::AT_pascal:
Anton Korobeynikov414d8962011-04-14 20:06:49 +00004061 case AttributeList::AT_pcs:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004062 handleCallConvAttr(S, D, Attr);
John McCall04a67a62010-02-05 21:31:56 +00004063 break;
Peter Collingbournef315fa82011-02-14 01:42:53 +00004064 case AttributeList::AT_opencl_kernel_function:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004065 handleOpenCLKernelAttr(S, D, Attr);
Peter Collingbournef315fa82011-02-14 01:42:53 +00004066 break;
John McCallc052dbb2012-05-22 21:28:12 +00004067
4068 // Microsoft attributes:
4069 case AttributeList::AT_ms_struct:
4070 handleMsStructAttr(S, D, Attr);
4071 break;
Francois Pichet11542142010-12-19 06:50:37 +00004072 case AttributeList::AT_uuid:
Chandler Carruth1b03c872011-07-02 00:01:44 +00004073 handleUuidAttr(S, D, Attr);
Francois Pichet11542142010-12-19 06:50:37 +00004074 break;
John McCallc052dbb2012-05-22 21:28:12 +00004075 case AttributeList::AT_single_inheritance:
4076 case AttributeList::AT_multiple_inheritance:
4077 case AttributeList::AT_virtual_inheritance:
4078 handleInheritanceAttr(S, D, Attr);
4079 break;
4080 case AttributeList::AT_w64:
4081 case AttributeList::AT_ptr32:
4082 case AttributeList::AT_ptr64:
4083 handlePortabilityAttr(S, D, Attr);
4084 break;
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +00004085
4086 // Thread safety attributes:
4087 case AttributeList::AT_guarded_var:
4088 handleGuardedVarAttr(S, D, Attr);
4089 break;
4090 case AttributeList::AT_pt_guarded_var:
4091 handleGuardedVarAttr(S, D, Attr, /*pointer = */true);
4092 break;
4093 case AttributeList::AT_scoped_lockable:
4094 handleLockableAttr(S, D, Attr, /*scoped = */true);
4095 break;
Kostya Serebryany71efba02012-01-24 19:25:38 +00004096 case AttributeList::AT_no_address_safety_analysis:
4097 handleNoAddressSafetyAttr(S, D, Attr);
4098 break;
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +00004099 case AttributeList::AT_no_thread_safety_analysis:
4100 handleNoThreadSafetyAttr(S, D, Attr);
4101 break;
4102 case AttributeList::AT_lockable:
4103 handleLockableAttr(S, D, Attr);
4104 break;
Caitlin Sadowskidb33e142011-07-28 20:12:35 +00004105 case AttributeList::AT_guarded_by:
4106 handleGuardedByAttr(S, D, Attr);
4107 break;
4108 case AttributeList::AT_pt_guarded_by:
4109 handleGuardedByAttr(S, D, Attr, /*pointer = */true);
4110 break;
4111 case AttributeList::AT_exclusive_lock_function:
4112 handleLockFunAttr(S, D, Attr, /*exclusive = */true);
4113 break;
4114 case AttributeList::AT_exclusive_locks_required:
4115 handleLocksRequiredAttr(S, D, Attr, /*exclusive = */true);
4116 break;
4117 case AttributeList::AT_exclusive_trylock_function:
4118 handleTrylockFunAttr(S, D, Attr, /*exclusive = */true);
4119 break;
4120 case AttributeList::AT_lock_returned:
4121 handleLockReturnedAttr(S, D, Attr);
4122 break;
4123 case AttributeList::AT_locks_excluded:
4124 handleLocksExcludedAttr(S, D, Attr);
4125 break;
4126 case AttributeList::AT_shared_lock_function:
4127 handleLockFunAttr(S, D, Attr);
4128 break;
4129 case AttributeList::AT_shared_locks_required:
4130 handleLocksRequiredAttr(S, D, Attr);
4131 break;
4132 case AttributeList::AT_shared_trylock_function:
4133 handleTrylockFunAttr(S, D, Attr);
4134 break;
4135 case AttributeList::AT_unlock_function:
4136 handleUnlockFunAttr(S, D, Attr);
4137 break;
4138 case AttributeList::AT_acquired_before:
4139 handleAcquireOrderAttr(S, D, Attr, /*before = */true);
4140 break;
4141 case AttributeList::AT_acquired_after:
4142 handleAcquireOrderAttr(S, D, Attr, /*before = */false);
4143 break;
Caitlin Sadowskifdde9e72011-07-28 17:21:07 +00004144
Chris Lattner803d0802008-06-29 00:43:07 +00004145 default:
Anton Korobeynikov82d0a412010-01-10 12:58:08 +00004146 // Ask target about the attribute.
4147 const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema();
4148 if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S))
Chandler Carruth7d5c45e2010-07-08 09:42:26 +00004149 S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored)
4150 << Attr.getName();
Chris Lattner803d0802008-06-29 00:43:07 +00004151 break;
4152 }
4153}
4154
Peter Collingbourne60700392011-01-21 02:08:45 +00004155/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
4156/// the attribute applies to decls. If the attribute is a type attribute, just
4157/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to
4158/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4).
Chandler Carruth1b03c872011-07-02 00:01:44 +00004159static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
4160 const AttributeList &Attr,
Peter Collingbourne60700392011-01-21 02:08:45 +00004161 bool NonInheritable, bool Inheritable) {
4162 if (Attr.isInvalid())
4163 return;
4164
4165 if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr))
4166 // FIXME: Try to deal with other __declspec attributes!
4167 return;
4168
4169 if (NonInheritable)
Chandler Carruth1b03c872011-07-02 00:01:44 +00004170 ProcessNonInheritableDeclAttr(S, scope, D, Attr);
Peter Collingbourne60700392011-01-21 02:08:45 +00004171
4172 if (Inheritable)
Chandler Carruth1b03c872011-07-02 00:01:44 +00004173 ProcessInheritableDeclAttr(S, scope, D, Attr);
Peter Collingbourne60700392011-01-21 02:08:45 +00004174}
4175
Chris Lattner803d0802008-06-29 00:43:07 +00004176/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
4177/// attribute list to the specified decl, ignoring any type attributes.
Eric Christopherf48f3672010-12-01 22:13:54 +00004178void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
Peter Collingbourne60700392011-01-21 02:08:45 +00004179 const AttributeList *AttrList,
4180 bool NonInheritable, bool Inheritable) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00004181 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
Rafael Espindola98ae8342012-05-10 02:50:16 +00004182 ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable);
Rafael Espindola9b79fc92012-05-07 23:58:18 +00004183 }
Rafael Espindola11e8ce72010-02-23 22:00:30 +00004184
4185 // GCC accepts
4186 // static int a9 __attribute__((weakref));
4187 // but that looks really pointless. We reject it.
Peter Collingbourne60700392011-01-21 02:08:45 +00004188 if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
Rafael Espindola11e8ce72010-02-23 22:00:30 +00004189 Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) <<
Ted Kremenekdd0e4902010-07-31 01:52:11 +00004190 dyn_cast<NamedDecl>(D)->getNameAsString();
Rafael Espindola11e8ce72010-02-23 22:00:30 +00004191 return;
Chris Lattner803d0802008-06-29 00:43:07 +00004192 }
4193}
4194
Erik Verbruggen5f1c8222011-10-13 09:41:32 +00004195// Annotation attributes are the only attributes allowed after an access
4196// specifier.
4197bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4198 const AttributeList *AttrList) {
4199 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4200 if (l->getKind() == AttributeList::AT_annotate) {
4201 handleAnnotateAttr(*this, ASDecl, *l);
4202 } else {
4203 Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
4204 return true;
4205 }
4206 }
4207
4208 return false;
4209}
4210
John McCalle82247a2011-10-01 05:17:03 +00004211/// checkUnusedDeclAttributes - Check a list of attributes to see if it
4212/// contains any decl attributes that we should warn about.
4213static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
4214 for ( ; A; A = A->getNext()) {
4215 // Only warn if the attribute is an unignored, non-type attribute.
4216 if (A->isUsedAsTypeAttr()) continue;
4217 if (A->getKind() == AttributeList::IgnoredAttribute) continue;
4218
4219 if (A->getKind() == AttributeList::UnknownAttribute) {
4220 S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
4221 << A->getName() << A->getRange();
4222 } else {
4223 S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
4224 << A->getName() << A->getRange();
4225 }
4226 }
4227}
4228
4229/// checkUnusedDeclAttributes - Given a declarator which is not being
4230/// used to build a declaration, complain about any decl attributes
4231/// which might be lying around on it.
4232void Sema::checkUnusedDeclAttributes(Declarator &D) {
4233 ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
4234 ::checkUnusedDeclAttributes(*this, D.getAttributes());
4235 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
4236 ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
4237}
4238
Ryan Flynne25ff832009-07-30 03:15:39 +00004239/// DeclClonePragmaWeak - clone existing decl (maybe definition),
James Dennett1dfbd922012-06-14 21:40:34 +00004240/// \#pragma weak needs a non-definition decl and source may not have one.
Eli Friedman900693b2011-09-07 04:05:06 +00004241NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
4242 SourceLocation Loc) {
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00004243 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));
Ryan Flynne25ff832009-07-30 03:15:39 +00004244 NamedDecl *NewD = 0;
4245 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
Eli Friedman900693b2011-09-07 04:05:06 +00004246 FunctionDecl *NewFD;
4247 // FIXME: Missing call to CheckFunctionDeclaration().
4248 // FIXME: Mangling?
4249 // FIXME: Is the qualifier info correct?
4250 // FIXME: Is the DeclContext correct?
4251 NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
4252 Loc, Loc, DeclarationName(II),
4253 FD->getType(), FD->getTypeSourceInfo(),
4254 SC_None, SC_None,
4255 false/*isInlineSpecified*/,
4256 FD->hasPrototype(),
4257 false/*isConstexprSpecified*/);
4258 NewD = NewFD;
4259
4260 if (FD->getQualifier())
Douglas Gregorc22b5ff2011-02-25 02:25:35 +00004261 NewFD->setQualifierInfo(FD->getQualifierLoc());
Eli Friedman900693b2011-09-07 04:05:06 +00004262
4263 // Fake up parameter variables; they are declared as if this were
4264 // a typedef.
4265 QualType FDTy = FD->getType();
4266 if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
4267 SmallVector<ParmVarDecl*, 16> Params;
4268 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
4269 AE = FT->arg_type_end(); AI != AE; ++AI) {
4270 ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, *AI);
4271 Param->setScopeInfo(0, Params.size());
4272 Params.push_back(Param);
4273 }
David Blaikie4278c652011-09-21 18:16:56 +00004274 NewFD->setParams(Params);
John McCallb6217662010-03-15 10:12:16 +00004275 }
Ryan Flynne25ff832009-07-30 03:15:39 +00004276 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
4277 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00004278 VD->getInnerLocStart(), VD->getLocation(), II,
John McCalla93c9342009-12-07 02:54:59 +00004279 VD->getType(), VD->getTypeSourceInfo(),
Douglas Gregor16573fa2010-04-19 22:54:31 +00004280 VD->getStorageClass(),
4281 VD->getStorageClassAsWritten());
John McCallb6217662010-03-15 10:12:16 +00004282 if (VD->getQualifier()) {
4283 VarDecl *NewVD = cast<VarDecl>(NewD);
Douglas Gregorc22b5ff2011-02-25 02:25:35 +00004284 NewVD->setQualifierInfo(VD->getQualifierLoc());
John McCallb6217662010-03-15 10:12:16 +00004285 }
Ryan Flynne25ff832009-07-30 03:15:39 +00004286 }
4287 return NewD;
4288}
4289
James Dennett1dfbd922012-06-14 21:40:34 +00004290/// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
Ryan Flynne25ff832009-07-30 03:15:39 +00004291/// applied to it, possibly with an alias.
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00004292void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
Chris Lattnerc4f1fb12009-09-08 18:10:11 +00004293 if (W.getUsed()) return; // only do this once
4294 W.setUsed(true);
4295 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
4296 IdentifierInfo *NDId = ND->getIdentifier();
Eli Friedman900693b2011-09-07 04:05:06 +00004297 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
Sean Huntcf807c42010-08-18 23:23:40 +00004298 NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context,
4299 NDId->getName()));
4300 NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
Chris Lattnerc4f1fb12009-09-08 18:10:11 +00004301 WeakTopLevelDecl.push_back(NewD);
4302 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
4303 // to insert Decl at TU scope, sorry.
4304 DeclContext *SavedContext = CurContext;
4305 CurContext = Context.getTranslationUnitDecl();
4306 PushOnScopeChains(NewD, S);
4307 CurContext = SavedContext;
4308 } else { // just add weak to existing
Sean Huntcf807c42010-08-18 23:23:40 +00004309 ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context));
Ryan Flynne25ff832009-07-30 03:15:39 +00004310 }
4311}
4312
Chris Lattner0744e5f2008-06-29 00:23:49 +00004313/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
4314/// it, apply them to D. This is a bit tricky because PD can have attributes
4315/// specified in many different places, and we need to find and apply them all.
Peter Collingbourne60700392011-01-21 02:08:45 +00004316void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD,
4317 bool NonInheritable, bool Inheritable) {
John McCalld4aff0e2010-10-27 00:59:00 +00004318 // It's valid to "forward-declare" #pragma weak, in which case we
4319 // have to do this.
Douglas Gregor31e37b22011-07-28 18:09:57 +00004320 if (Inheritable) {
4321 LoadExternalWeakUndeclaredIdentifiers();
4322 if (!WeakUndeclaredIdentifiers.empty()) {
4323 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
4324 if (IdentifierInfo *Id = ND->getIdentifier()) {
4325 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I
4326 = WeakUndeclaredIdentifiers.find(Id);
4327 if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) {
4328 WeakInfo W = I->second;
4329 DeclApplyPragmaWeak(S, ND, W);
4330 WeakUndeclaredIdentifiers[Id] = W;
4331 }
John McCalld4aff0e2010-10-27 00:59:00 +00004332 }
Ryan Flynne25ff832009-07-30 03:15:39 +00004333 }
4334 }
4335 }
4336
Chris Lattner0744e5f2008-06-29 00:23:49 +00004337 // Apply decl attributes from the DeclSpec if present.
John McCall7f040a92010-12-24 02:08:15 +00004338 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
Peter Collingbourne60700392011-01-21 02:08:45 +00004339 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Mike Stumpbf916502009-07-24 19:02:52 +00004340
Chris Lattner0744e5f2008-06-29 00:23:49 +00004341 // Walk the declarator structure, applying decl attributes that were in a type
4342 // position to the decl itself. This handles cases like:
4343 // int *__attr__(x)** D;
4344 // when X is a decl attribute.
4345 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
4346 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
Peter Collingbourne60700392011-01-21 02:08:45 +00004347 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Mike Stumpbf916502009-07-24 19:02:52 +00004348
Chris Lattner0744e5f2008-06-29 00:23:49 +00004349 // Finally, apply any attributes on the decl itself.
4350 if (const AttributeList *Attrs = PD.getAttributes())
Peter Collingbourne60700392011-01-21 02:08:45 +00004351 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable);
Chris Lattner0744e5f2008-06-29 00:23:49 +00004352}
John McCall54abf7d2009-11-04 02:18:39 +00004353
John McCallf85e1932011-06-15 23:02:42 +00004354/// Is the given declaration allowed to use a forbidden type?
4355static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) {
4356 // Private ivars are always okay. Unfortunately, people don't
4357 // always properly make their ivars private, even in system headers.
4358 // Plus we need to make fields okay, too.
Fariborz Jahaniana6b33802011-09-26 21:23:35 +00004359 // Function declarations in sys headers will be marked unavailable.
4360 if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
4361 !isa<FunctionDecl>(decl))
John McCallf85e1932011-06-15 23:02:42 +00004362 return false;
4363
4364 // Require it to be declared in a system header.
4365 return S.Context.getSourceManager().isInSystemHeader(decl->getLocation());
4366}
4367
4368/// Handle a delayed forbidden-type diagnostic.
4369static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
4370 Decl *decl) {
4371 if (decl && isForbiddenTypeAllowed(S, decl)) {
4372 decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context,
4373 "this system declaration uses an unsupported type"));
4374 return;
4375 }
David Blaikie4e4d0842012-03-11 07:00:24 +00004376 if (S.getLangOpts().ObjCAutoRefCount)
Fariborz Jahanian175fb102011-10-03 22:11:57 +00004377 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
Benjamin Kramer48d798c2012-06-02 10:20:41 +00004378 // FIXME: we may want to suppress diagnostics for all
Fariborz Jahanian175fb102011-10-03 22:11:57 +00004379 // kind of forbidden type messages on unavailable functions.
4380 if (FD->hasAttr<UnavailableAttr>() &&
4381 diag.getForbiddenTypeDiagnostic() ==
4382 diag::err_arc_array_param_no_ownership) {
4383 diag.Triggered = true;
4384 return;
4385 }
4386 }
John McCallf85e1932011-06-15 23:02:42 +00004387
4388 S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
4389 << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
4390 diag.Triggered = true;
4391}
4392
John McCall92576642012-05-07 06:16:41 +00004393void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
4394 assert(DelayedDiagnostics.getCurrentPool());
John McCall13489672012-05-07 06:16:58 +00004395 DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
John McCall92576642012-05-07 06:16:41 +00004396 DelayedDiagnostics.popWithoutEmitting(state);
John McCalleee1d542011-02-14 07:13:47 +00004397
John McCall92576642012-05-07 06:16:41 +00004398 // When delaying diagnostics to run in the context of a parsed
4399 // declaration, we only want to actually emit anything if parsing
4400 // succeeds.
4401 if (!decl) return;
John McCalleee1d542011-02-14 07:13:47 +00004402
John McCall92576642012-05-07 06:16:41 +00004403 // We emit all the active diagnostics in this pool or any of its
4404 // parents. In general, we'll get one pool for the decl spec
4405 // and a child pool for each declarator; in a decl group like:
4406 // deprecated_typedef foo, *bar, baz();
4407 // only the declarator pops will be passed decls. This is correct;
4408 // we really do need to consider delayed diagnostics from the decl spec
4409 // for each of the different declarations.
John McCall13489672012-05-07 06:16:58 +00004410 const DelayedDiagnosticPool *pool = &poppedPool;
John McCall92576642012-05-07 06:16:41 +00004411 do {
John McCall13489672012-05-07 06:16:58 +00004412 for (DelayedDiagnosticPool::pool_iterator
John McCall92576642012-05-07 06:16:41 +00004413 i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
4414 // This const_cast is a bit lame. Really, Triggered should be mutable.
4415 DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
John McCalleee1d542011-02-14 07:13:47 +00004416 if (diag.Triggered)
John McCall2f514482010-01-27 03:50:35 +00004417 continue;
4418
John McCalleee1d542011-02-14 07:13:47 +00004419 switch (diag.Kind) {
John McCall2f514482010-01-27 03:50:35 +00004420 case DelayedDiagnostic::Deprecation:
John McCalle8c904f2012-01-26 20:04:03 +00004421 // Don't bother giving deprecation diagnostics if the decl is invalid.
4422 if (!decl->isInvalidDecl())
John McCall92576642012-05-07 06:16:41 +00004423 HandleDelayedDeprecationCheck(diag, decl);
John McCall2f514482010-01-27 03:50:35 +00004424 break;
4425
4426 case DelayedDiagnostic::Access:
John McCall92576642012-05-07 06:16:41 +00004427 HandleDelayedAccessCheck(diag, decl);
John McCall2f514482010-01-27 03:50:35 +00004428 break;
John McCallf85e1932011-06-15 23:02:42 +00004429
4430 case DelayedDiagnostic::ForbiddenType:
John McCall92576642012-05-07 06:16:41 +00004431 handleDelayedForbiddenType(*this, diag, decl);
John McCallf85e1932011-06-15 23:02:42 +00004432 break;
John McCall2f514482010-01-27 03:50:35 +00004433 }
4434 }
John McCall92576642012-05-07 06:16:41 +00004435 } while ((pool = pool->getParent()));
John McCall54abf7d2009-11-04 02:18:39 +00004436}
4437
John McCall13489672012-05-07 06:16:58 +00004438/// Given a set of delayed diagnostics, re-emit them as if they had
4439/// been delayed in the current context instead of in the given pool.
4440/// Essentially, this just moves them to the current pool.
4441void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
4442 DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
4443 assert(curPool && "re-emitting in undelayed context not supported");
4444 curPool->steal(pool);
4445}
4446
John McCall54abf7d2009-11-04 02:18:39 +00004447static bool isDeclDeprecated(Decl *D) {
4448 do {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00004449 if (D->isDeprecated())
John McCall54abf7d2009-11-04 02:18:39 +00004450 return true;
Argyrios Kyrtzidisc076e372011-10-06 23:23:27 +00004451 // A category implicitly has the availability of the interface.
4452 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D))
4453 return CatD->getClassInterface()->isDeprecated();
John McCall54abf7d2009-11-04 02:18:39 +00004454 } while ((D = cast_or_null<Decl>(D->getDeclContext())));
4455 return false;
4456}
4457
John McCall9c3087b2010-08-26 02:13:20 +00004458void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD,
John McCall2f514482010-01-27 03:50:35 +00004459 Decl *Ctx) {
4460 if (isDeclDeprecated(Ctx))
John McCall54abf7d2009-11-04 02:18:39 +00004461 return;
4462
John McCall2f514482010-01-27 03:50:35 +00004463 DD.Triggered = true;
Benjamin Kramerce2d1862010-10-09 15:49:00 +00004464 if (!DD.getDeprecationMessage().empty())
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00004465 Diag(DD.Loc, diag::warn_deprecated_message)
Benjamin Kramerce2d1862010-10-09 15:49:00 +00004466 << DD.getDeprecationDecl()->getDeclName()
4467 << DD.getDeprecationMessage();
Fariborz Jahanianb0a66152012-03-02 21:50:02 +00004468 else if (DD.getUnknownObjCClass()) {
4469 Diag(DD.Loc, diag::warn_deprecated_fwdclass_message)
4470 << DD.getDeprecationDecl()->getDeclName();
4471 Diag(DD.getUnknownObjCClass()->getLocation(), diag::note_forward_class);
4472 }
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00004473 else
4474 Diag(DD.Loc, diag::warn_deprecated)
Benjamin Kramerce2d1862010-10-09 15:49:00 +00004475 << DD.getDeprecationDecl()->getDeclName();
John McCall54abf7d2009-11-04 02:18:39 +00004476}
4477
Chris Lattner5f9e2722011-07-23 10:55:15 +00004478void Sema::EmitDeprecationWarning(NamedDecl *D, StringRef Message,
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00004479 SourceLocation Loc,
Fariborz Jahanian89ebaed2011-04-23 17:27:19 +00004480 const ObjCInterfaceDecl *UnknownObjCClass) {
John McCall54abf7d2009-11-04 02:18:39 +00004481 // Delay if we're currently parsing a declaration.
John McCalleee1d542011-02-14 07:13:47 +00004482 if (DelayedDiagnostics.shouldDelayDiagnostics()) {
Fariborz Jahanianb0a66152012-03-02 21:50:02 +00004483 DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D,
4484 UnknownObjCClass,
4485 Message));
John McCall54abf7d2009-11-04 02:18:39 +00004486 return;
4487 }
4488
4489 // Otherwise, don't warn if our current context is deprecated.
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +00004490 if (isDeclDeprecated(cast<Decl>(getCurLexicalContext())))
John McCall54abf7d2009-11-04 02:18:39 +00004491 return;
Fariborz Jahaniand6724362012-04-23 20:30:52 +00004492 if (!Message.empty()) {
Fariborz Jahanianc4b35cf2010-10-06 21:18:44 +00004493 Diag(Loc, diag::warn_deprecated_message) << D->getDeclName()
4494 << Message;
Fariborz Jahaniand6724362012-04-23 20:30:52 +00004495 Diag(D->getLocation(),
4496 isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
4497 : diag::note_previous_decl) << D->getDeclName();
4498 }
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00004499 else {
Fariborz Jahanian350e9562012-05-27 16:59:48 +00004500 if (!UnknownObjCClass) {
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00004501 Diag(Loc, diag::warn_deprecated) << D->getDeclName();
Fariborz Jahanian350e9562012-05-27 16:59:48 +00004502 Diag(D->getLocation(),
4503 isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at
4504 : diag::note_previous_decl) << D->getDeclName();
4505 }
Fariborz Jahanian89ebaed2011-04-23 17:27:19 +00004506 else {
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00004507 Diag(Loc, diag::warn_deprecated_fwdclass_message) << D->getDeclName();
Fariborz Jahanian89ebaed2011-04-23 17:27:19 +00004508 Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
4509 }
Fariborz Jahanian8e5fc9b2010-12-21 00:44:01 +00004510 }
John McCall54abf7d2009-11-04 02:18:39 +00004511}