SemaDeclAttr.cpp revision f1e57ada1f48d70b9bb9b2585be1644baf534907
1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements decl-related attribute processing. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Sema.h" 15#include "TargetAttributesSema.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/Expr.h" 19#include "clang/Basic/TargetInfo.h" 20#include "clang/Parse/DeclSpec.h" 21#include "llvm/ADT/StringExtras.h" 22using namespace clang; 23 24//===----------------------------------------------------------------------===// 25// Helper functions 26//===----------------------------------------------------------------------===// 27 28static const FunctionType *getFunctionType(const Decl *d, 29 bool blocksToo = true) { 30 QualType Ty; 31 if (const ValueDecl *decl = dyn_cast<ValueDecl>(d)) 32 Ty = decl->getType(); 33 else if (const FieldDecl *decl = dyn_cast<FieldDecl>(d)) 34 Ty = decl->getType(); 35 else if (const TypedefDecl* decl = dyn_cast<TypedefDecl>(d)) 36 Ty = decl->getUnderlyingType(); 37 else 38 return 0; 39 40 if (Ty->isFunctionPointerType()) 41 Ty = Ty->getAs<PointerType>()->getPointeeType(); 42 else if (blocksToo && Ty->isBlockPointerType()) 43 Ty = Ty->getAs<BlockPointerType>()->getPointeeType(); 44 45 return Ty->getAs<FunctionType>(); 46} 47 48// FIXME: We should provide an abstraction around a method or function 49// to provide the following bits of information. 50 51/// isFunction - Return true if the given decl has function 52/// type (function or function-typed variable). 53static bool isFunction(const Decl *d) { 54 return getFunctionType(d, false) != NULL; 55} 56 57/// isFunctionOrMethod - Return true if the given decl has function 58/// type (function or function-typed variable) or an Objective-C 59/// method. 60static bool isFunctionOrMethod(const Decl *d) { 61 return isFunction(d)|| isa<ObjCMethodDecl>(d); 62} 63 64/// isFunctionOrMethodOrBlock - Return true if the given decl has function 65/// type (function or function-typed variable) or an Objective-C 66/// method or a block. 67static bool isFunctionOrMethodOrBlock(const Decl *d) { 68 if (isFunctionOrMethod(d)) 69 return true; 70 // check for block is more involved. 71 if (const VarDecl *V = dyn_cast<VarDecl>(d)) { 72 QualType Ty = V->getType(); 73 return Ty->isBlockPointerType(); 74 } 75 return isa<BlockDecl>(d); 76} 77 78/// hasFunctionProto - Return true if the given decl has a argument 79/// information. This decl should have already passed 80/// isFunctionOrMethod or isFunctionOrMethodOrBlock. 81static bool hasFunctionProto(const Decl *d) { 82 if (const FunctionType *FnTy = getFunctionType(d)) 83 return isa<FunctionProtoType>(FnTy); 84 else { 85 assert(isa<ObjCMethodDecl>(d) || isa<BlockDecl>(d)); 86 return true; 87 } 88} 89 90/// getFunctionOrMethodNumArgs - Return number of function or method 91/// arguments. It is an error to call this on a K&R function (use 92/// hasFunctionProto first). 93static unsigned getFunctionOrMethodNumArgs(const Decl *d) { 94 if (const FunctionType *FnTy = getFunctionType(d)) 95 return cast<FunctionProtoType>(FnTy)->getNumArgs(); 96 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 97 return BD->getNumParams(); 98 return cast<ObjCMethodDecl>(d)->param_size(); 99} 100 101static QualType getFunctionOrMethodArgType(const Decl *d, unsigned Idx) { 102 if (const FunctionType *FnTy = getFunctionType(d)) 103 return cast<FunctionProtoType>(FnTy)->getArgType(Idx); 104 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 105 return BD->getParamDecl(Idx)->getType(); 106 107 return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType(); 108} 109 110static QualType getFunctionOrMethodResultType(const Decl *d) { 111 if (const FunctionType *FnTy = getFunctionType(d)) 112 return cast<FunctionProtoType>(FnTy)->getResultType(); 113 return cast<ObjCMethodDecl>(d)->getResultType(); 114} 115 116static bool isFunctionOrMethodVariadic(const Decl *d) { 117 if (const FunctionType *FnTy = getFunctionType(d)) { 118 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy); 119 return proto->isVariadic(); 120 } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 121 return BD->IsVariadic(); 122 else { 123 return cast<ObjCMethodDecl>(d)->isVariadic(); 124 } 125} 126 127static inline bool isNSStringType(QualType T, ASTContext &Ctx) { 128 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>(); 129 if (!PT) 130 return false; 131 132 const ObjCInterfaceType *ClsT =PT->getPointeeType()->getAs<ObjCInterfaceType>(); 133 if (!ClsT) 134 return false; 135 136 IdentifierInfo* ClsName = ClsT->getDecl()->getIdentifier(); 137 138 // FIXME: Should we walk the chain of classes? 139 return ClsName == &Ctx.Idents.get("NSString") || 140 ClsName == &Ctx.Idents.get("NSMutableString"); 141} 142 143static inline bool isCFStringType(QualType T, ASTContext &Ctx) { 144 const PointerType *PT = T->getAs<PointerType>(); 145 if (!PT) 146 return false; 147 148 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>(); 149 if (!RT) 150 return false; 151 152 const RecordDecl *RD = RT->getDecl(); 153 if (RD->getTagKind() != TagDecl::TK_struct) 154 return false; 155 156 return RD->getIdentifier() == &Ctx.Idents.get("__CFString"); 157} 158 159//===----------------------------------------------------------------------===// 160// Attribute Implementations 161//===----------------------------------------------------------------------===// 162 163// FIXME: All this manual attribute parsing code is gross. At the 164// least add some helper functions to check most argument patterns (# 165// and types of args). 166 167static void HandleExtVectorTypeAttr(Scope *scope, Decl *d, 168 const AttributeList &Attr, Sema &S) { 169 TypedefDecl *tDecl = dyn_cast<TypedefDecl>(d); 170 if (tDecl == 0) { 171 S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef); 172 return; 173 } 174 175 QualType curType = tDecl->getUnderlyingType(); 176 177 Expr *sizeExpr; 178 179 // Special case where the argument is a template id. 180 if (Attr.getParameterName()) { 181 CXXScopeSpec SS; 182 UnqualifiedId id; 183 id.setIdentifier(Attr.getParameterName(), Attr.getLoc()); 184 sizeExpr = S.ActOnIdExpression(scope, SS, id, false, false).takeAs<Expr>(); 185 } else { 186 // check the attribute arguments. 187 if (Attr.getNumArgs() != 1) { 188 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 189 return; 190 } 191 sizeExpr = static_cast<Expr *>(Attr.getArg(0)); 192 } 193 194 // Instantiate/Install the vector type, and let Sema build the type for us. 195 // This will run the reguired checks. 196 QualType T = S.BuildExtVectorType(curType, S.Owned(sizeExpr), Attr.getLoc()); 197 if (!T.isNull()) { 198 // FIXME: preserve the old source info. 199 tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T)); 200 201 // Remember this typedef decl, we will need it later for diagnostics. 202 S.ExtVectorDecls.push_back(tDecl); 203 } 204} 205 206static void HandlePackedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 207 // check the attribute arguments. 208 if (Attr.getNumArgs() > 0) { 209 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 210 return; 211 } 212 213 if (TagDecl *TD = dyn_cast<TagDecl>(d)) 214 TD->addAttr(::new (S.Context) PackedAttr); 215 else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) { 216 // If the alignment is less than or equal to 8 bits, the packed attribute 217 // has no effect. 218 if (!FD->getType()->isIncompleteType() && 219 S.Context.getTypeAlign(FD->getType()) <= 8) 220 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type) 221 << Attr.getName() << FD->getType(); 222 else 223 FD->addAttr(::new (S.Context) PackedAttr); 224 } else 225 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 226} 227 228static void HandleIBOutletAttr(Decl *d, const AttributeList &Attr, Sema &S) { 229 // check the attribute arguments. 230 if (Attr.getNumArgs() > 0) { 231 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 232 return; 233 } 234 235 // The IBOutlet attribute only applies to instance variables of Objective-C 236 // classes. 237 if (isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d)) 238 d->addAttr(::new (S.Context) IBOutletAttr()); 239 else 240 S.Diag(Attr.getLoc(), diag::err_attribute_iboutlet); 241} 242 243static void HandleNonNullAttr(Decl *d, const AttributeList &Attr, Sema &S) { 244 // GCC ignores the nonnull attribute on K&R style function prototypes, so we 245 // ignore it as well 246 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) { 247 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 248 << Attr.getName() << 0 /*function*/; 249 return; 250 } 251 252 unsigned NumArgs = getFunctionOrMethodNumArgs(d); 253 254 // The nonnull attribute only applies to pointers. 255 llvm::SmallVector<unsigned, 10> NonNullArgs; 256 257 for (AttributeList::arg_iterator I=Attr.arg_begin(), 258 E=Attr.arg_end(); I!=E; ++I) { 259 260 261 // The argument must be an integer constant expression. 262 Expr *Ex = static_cast<Expr *>(*I); 263 llvm::APSInt ArgNum(32); 264 if (!Ex->isIntegerConstantExpr(ArgNum, S.Context)) { 265 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 266 << "nonnull" << Ex->getSourceRange(); 267 return; 268 } 269 270 unsigned x = (unsigned) ArgNum.getZExtValue(); 271 272 if (x < 1 || x > NumArgs) { 273 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 274 << "nonnull" << I.getArgNum() << Ex->getSourceRange(); 275 return; 276 } 277 278 --x; 279 280 // Is the function argument a pointer type? 281 QualType T = getFunctionOrMethodArgType(d, x); 282 if (!T->isAnyPointerType() && !T->isBlockPointerType()) { 283 // FIXME: Should also highlight argument in decl. 284 S.Diag(Attr.getLoc(), diag::err_nonnull_pointers_only) 285 << "nonnull" << Ex->getSourceRange(); 286 continue; 287 } 288 289 NonNullArgs.push_back(x); 290 } 291 292 // If no arguments were specified to __attribute__((nonnull)) then all pointer 293 // arguments have a nonnull attribute. 294 if (NonNullArgs.empty()) { 295 for (unsigned I = 0, E = getFunctionOrMethodNumArgs(d); I != E; ++I) { 296 QualType T = getFunctionOrMethodArgType(d, I); 297 if (T->isAnyPointerType() || T->isBlockPointerType()) 298 NonNullArgs.push_back(I); 299 } 300 301 if (NonNullArgs.empty()) { 302 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers); 303 return; 304 } 305 } 306 307 unsigned* start = &NonNullArgs[0]; 308 unsigned size = NonNullArgs.size(); 309 std::sort(start, start + size); 310 d->addAttr(::new (S.Context) NonNullAttr(start, size)); 311} 312 313static void HandleAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) { 314 // check the attribute arguments. 315 if (Attr.getNumArgs() != 1) { 316 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 317 return; 318 } 319 320 Expr *Arg = static_cast<Expr*>(Attr.getArg(0)); 321 Arg = Arg->IgnoreParenCasts(); 322 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 323 324 if (Str == 0 || Str->isWide()) { 325 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 326 << "alias" << 1; 327 return; 328 } 329 330 // FIXME: check if target symbol exists in current file 331 332 d->addAttr(::new (S.Context) AliasAttr(Str->getString())); 333} 334 335static void HandleAlwaysInlineAttr(Decl *d, const AttributeList &Attr, 336 Sema &S) { 337 // check the attribute arguments. 338 if (Attr.getNumArgs() != 0) { 339 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 340 return; 341 } 342 343 if (!isa<FunctionDecl>(d)) { 344 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 345 << Attr.getName() << 0 /*function*/; 346 return; 347 } 348 349 d->addAttr(::new (S.Context) AlwaysInlineAttr()); 350} 351 352static void HandleMallocAttr(Decl *d, const AttributeList &Attr, Sema &S) { 353 // check the attribute arguments. 354 if (Attr.getNumArgs() != 0) { 355 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 356 return; 357 } 358 359 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) { 360 QualType RetTy = FD->getResultType(); 361 if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) { 362 d->addAttr(::new (S.Context) MallocAttr()); 363 return; 364 } 365 } 366 367 S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only); 368} 369 370static bool HandleCommonNoReturnAttr(Decl *d, const AttributeList &Attr, 371 Sema &S) { 372 // check the attribute arguments. 373 if (Attr.getNumArgs() != 0) { 374 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 375 return false; 376 } 377 378 if (!isFunctionOrMethod(d) && !isa<BlockDecl>(d)) { 379 ValueDecl *VD = dyn_cast<ValueDecl>(d); 380 if (VD == 0 || (!VD->getType()->isBlockPointerType() 381 && !VD->getType()->isFunctionPointerType())) { 382 S.Diag(Attr.getLoc(), 383 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 384 : diag::warn_attribute_wrong_decl_type) 385 << Attr.getName() << 0 /*function*/; 386 return false; 387 } 388 } 389 390 return true; 391} 392 393static void HandleNoReturnAttr(Decl *d, const AttributeList &Attr, Sema &S) { 394 if (HandleCommonNoReturnAttr(d, Attr, S)) 395 d->addAttr(::new (S.Context) NoReturnAttr()); 396} 397 398static void HandleAnalyzerNoReturnAttr(Decl *d, const AttributeList &Attr, 399 Sema &S) { 400 if (HandleCommonNoReturnAttr(d, Attr, S)) 401 d->addAttr(::new (S.Context) AnalyzerNoReturnAttr()); 402} 403 404static void HandleDependencyAttr(Decl *d, const AttributeList &Attr, Sema &S) { 405 if (!isFunctionOrMethod(d) && !isa<ParmVarDecl>(d)) { 406 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 407 << Attr.getName() << 8; /*function, method, or parameter*/ 408 return; 409 } 410 // FIXME: Actually store the attribute on the declaration 411} 412 413static void HandleUnusedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 414 // check the attribute arguments. 415 if (Attr.getNumArgs() != 0) { 416 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 417 return; 418 } 419 420 if (!isa<VarDecl>(d) && !isFunctionOrMethod(d)) { 421 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 422 << Attr.getName() << 2 /*variable and function*/; 423 return; 424 } 425 426 d->addAttr(::new (S.Context) UnusedAttr()); 427} 428 429static void HandleUsedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 430 // check the attribute arguments. 431 if (Attr.getNumArgs() != 0) { 432 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 433 return; 434 } 435 436 if (const VarDecl *VD = dyn_cast<VarDecl>(d)) { 437 if (VD->hasLocalStorage() || VD->hasExternalStorage()) { 438 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used"; 439 return; 440 } 441 } else if (!isFunctionOrMethod(d)) { 442 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 443 << Attr.getName() << 2 /*variable and function*/; 444 return; 445 } 446 447 d->addAttr(::new (S.Context) UsedAttr()); 448} 449 450static void HandleConstructorAttr(Decl *d, const AttributeList &Attr, Sema &S) { 451 // check the attribute arguments. 452 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) { 453 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 454 << "0 or 1"; 455 return; 456 } 457 458 int priority = 65535; // FIXME: Do not hardcode such constants. 459 if (Attr.getNumArgs() > 0) { 460 Expr *E = static_cast<Expr *>(Attr.getArg(0)); 461 llvm::APSInt Idx(32); 462 if (!E->isIntegerConstantExpr(Idx, S.Context)) { 463 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 464 << "constructor" << 1 << E->getSourceRange(); 465 return; 466 } 467 priority = Idx.getZExtValue(); 468 } 469 470 if (!isa<FunctionDecl>(d)) { 471 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 472 << Attr.getName() << 0 /*function*/; 473 return; 474 } 475 476 d->addAttr(::new (S.Context) ConstructorAttr(priority)); 477} 478 479static void HandleDestructorAttr(Decl *d, const AttributeList &Attr, Sema &S) { 480 // check the attribute arguments. 481 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) { 482 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 483 << "0 or 1"; 484 return; 485 } 486 487 int priority = 65535; // FIXME: Do not hardcode such constants. 488 if (Attr.getNumArgs() > 0) { 489 Expr *E = static_cast<Expr *>(Attr.getArg(0)); 490 llvm::APSInt Idx(32); 491 if (!E->isIntegerConstantExpr(Idx, S.Context)) { 492 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 493 << "destructor" << 1 << E->getSourceRange(); 494 return; 495 } 496 priority = Idx.getZExtValue(); 497 } 498 499 if (!isa<FunctionDecl>(d)) { 500 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 501 << Attr.getName() << 0 /*function*/; 502 return; 503 } 504 505 d->addAttr(::new (S.Context) DestructorAttr(priority)); 506} 507 508static void HandleDeprecatedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 509 // check the attribute arguments. 510 if (Attr.getNumArgs() != 0) { 511 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 512 return; 513 } 514 515 d->addAttr(::new (S.Context) DeprecatedAttr()); 516} 517 518static void HandleUnavailableAttr(Decl *d, const AttributeList &Attr, Sema &S) { 519 // check the attribute arguments. 520 if (Attr.getNumArgs() != 0) { 521 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 522 return; 523 } 524 525 d->addAttr(::new (S.Context) UnavailableAttr()); 526} 527 528static void HandleVisibilityAttr(Decl *d, const AttributeList &Attr, Sema &S) { 529 // check the attribute arguments. 530 if (Attr.getNumArgs() != 1) { 531 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 532 return; 533 } 534 535 Expr *Arg = static_cast<Expr*>(Attr.getArg(0)); 536 Arg = Arg->IgnoreParenCasts(); 537 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 538 539 if (Str == 0 || Str->isWide()) { 540 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 541 << "visibility" << 1; 542 return; 543 } 544 545 llvm::StringRef TypeStr = Str->getString(); 546 VisibilityAttr::VisibilityTypes type; 547 548 if (TypeStr == "default") 549 type = VisibilityAttr::DefaultVisibility; 550 else if (TypeStr == "hidden") 551 type = VisibilityAttr::HiddenVisibility; 552 else if (TypeStr == "internal") 553 type = VisibilityAttr::HiddenVisibility; // FIXME 554 else if (TypeStr == "protected") 555 type = VisibilityAttr::ProtectedVisibility; 556 else { 557 S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr; 558 return; 559 } 560 561 d->addAttr(::new (S.Context) VisibilityAttr(type)); 562} 563 564static void HandleObjCExceptionAttr(Decl *D, const AttributeList &Attr, 565 Sema &S) { 566 if (Attr.getNumArgs() != 0) { 567 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 568 return; 569 } 570 571 ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D); 572 if (OCI == 0) { 573 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface); 574 return; 575 } 576 577 D->addAttr(::new (S.Context) ObjCExceptionAttr()); 578} 579 580static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) { 581 if (Attr.getNumArgs() != 0) { 582 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 583 return; 584 } 585 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { 586 QualType T = TD->getUnderlyingType(); 587 if (!T->isPointerType() || 588 !T->getAs<PointerType>()->getPointeeType()->isRecordType()) { 589 S.Diag(TD->getLocation(), diag::err_nsobject_attribute); 590 return; 591 } 592 } 593 D->addAttr(::new (S.Context) ObjCNSObjectAttr()); 594} 595 596static void 597HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) { 598 if (Attr.getNumArgs() != 0) { 599 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 600 return; 601 } 602 603 if (!isa<FunctionDecl>(D)) { 604 S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function); 605 return; 606 } 607 608 D->addAttr(::new (S.Context) OverloadableAttr()); 609} 610 611static void HandleBlocksAttr(Decl *d, const AttributeList &Attr, Sema &S) { 612 if (!Attr.getParameterName()) { 613 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 614 << "blocks" << 1; 615 return; 616 } 617 618 if (Attr.getNumArgs() != 0) { 619 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 620 return; 621 } 622 623 BlocksAttr::BlocksAttrTypes type; 624 if (Attr.getParameterName()->isStr("byref")) 625 type = BlocksAttr::ByRef; 626 else { 627 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 628 << "blocks" << Attr.getParameterName(); 629 return; 630 } 631 632 d->addAttr(::new (S.Context) BlocksAttr(type)); 633} 634 635static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) { 636 // check the attribute arguments. 637 if (Attr.getNumArgs() > 2) { 638 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 639 << "0, 1 or 2"; 640 return; 641 } 642 643 int sentinel = 0; 644 if (Attr.getNumArgs() > 0) { 645 Expr *E = static_cast<Expr *>(Attr.getArg(0)); 646 llvm::APSInt Idx(32); 647 if (!E->isIntegerConstantExpr(Idx, S.Context)) { 648 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 649 << "sentinel" << 1 << E->getSourceRange(); 650 return; 651 } 652 sentinel = Idx.getZExtValue(); 653 654 if (sentinel < 0) { 655 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero) 656 << E->getSourceRange(); 657 return; 658 } 659 } 660 661 int nullPos = 0; 662 if (Attr.getNumArgs() > 1) { 663 Expr *E = static_cast<Expr *>(Attr.getArg(1)); 664 llvm::APSInt Idx(32); 665 if (!E->isIntegerConstantExpr(Idx, S.Context)) { 666 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 667 << "sentinel" << 2 << E->getSourceRange(); 668 return; 669 } 670 nullPos = Idx.getZExtValue(); 671 672 if (nullPos > 1 || nullPos < 0) { 673 // FIXME: This error message could be improved, it would be nice 674 // to say what the bounds actually are. 675 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one) 676 << E->getSourceRange(); 677 return; 678 } 679 } 680 681 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) { 682 const FunctionType *FT = FD->getType()->getAs<FunctionType>(); 683 assert(FT && "FunctionDecl has non-function type?"); 684 685 if (isa<FunctionNoProtoType>(FT)) { 686 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments); 687 return; 688 } 689 690 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 691 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 692 return; 693 } 694 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) { 695 if (!MD->isVariadic()) { 696 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 697 return; 698 } 699 } else if (isa<BlockDecl>(d)) { 700 // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the 701 // caller. 702 ; 703 } else if (const VarDecl *V = dyn_cast<VarDecl>(d)) { 704 QualType Ty = V->getType(); 705 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 706 const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(d) 707 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 708 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 709 int m = Ty->isFunctionPointerType() ? 0 : 1; 710 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m; 711 return; 712 } 713 } else { 714 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 715 << Attr.getName() << 6 /*function, method or block */; 716 return; 717 } 718 } else { 719 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 720 << Attr.getName() << 6 /*function, method or block */; 721 return; 722 } 723 d->addAttr(::new (S.Context) SentinelAttr(sentinel, nullPos)); 724} 725 726static void HandleWarnUnusedResult(Decl *D, const AttributeList &Attr, Sema &S) { 727 // check the attribute arguments. 728 if (Attr.getNumArgs() != 0) { 729 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 730 return; 731 } 732 733 if (!isFunctionOrMethod(D)) { 734 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 735 << Attr.getName() << 0 /*function*/; 736 return; 737 } 738 739 if (getFunctionType(D)->getResultType()->isVoidType()) { 740 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function) 741 << Attr.getName(); 742 return; 743 } 744 745 D->addAttr(::new (S.Context) WarnUnusedResultAttr()); 746} 747 748static void HandleWeakAttr(Decl *D, const AttributeList &Attr, Sema &S) { 749 // check the attribute arguments. 750 if (Attr.getNumArgs() != 0) { 751 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 752 return; 753 } 754 755 /* weak only applies to non-static declarations */ 756 bool isStatic = false; 757 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 758 isStatic = VD->getStorageClass() == VarDecl::Static; 759 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 760 isStatic = FD->getStorageClass() == FunctionDecl::Static; 761 } 762 if (isStatic) { 763 S.Diag(Attr.getLoc(), diag::err_attribute_weak_static) << 764 dyn_cast<NamedDecl>(D)->getNameAsString(); 765 return; 766 } 767 768 // TODO: could also be applied to methods? 769 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) { 770 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 771 << Attr.getName() << 2 /*variable and function*/; 772 return; 773 } 774 775 D->addAttr(::new (S.Context) WeakAttr()); 776} 777 778static void HandleWeakImportAttr(Decl *D, const AttributeList &Attr, Sema &S) { 779 // check the attribute arguments. 780 if (Attr.getNumArgs() != 0) { 781 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 782 return; 783 } 784 785 // weak_import only applies to variable & function declarations. 786 bool isDef = false; 787 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 788 isDef = (!VD->hasExternalStorage() || VD->getInit()); 789 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 790 isDef = FD->getBody(); 791 } else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D)) { 792 // We ignore weak import on properties and methods 793 return; 794 } else if (!(S.LangOpts.ObjCNonFragileABI && isa<ObjCInterfaceDecl>(D))) { 795 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 796 << Attr.getName() << 2 /*variable and function*/; 797 return; 798 } 799 800 // Merge should handle any subsequent violations. 801 if (isDef) { 802 S.Diag(Attr.getLoc(), 803 diag::warn_attribute_weak_import_invalid_on_definition) 804 << "weak_import" << 2 /*variable and function*/; 805 return; 806 } 807 808 D->addAttr(::new (S.Context) WeakImportAttr()); 809} 810 811static void HandleDLLImportAttr(Decl *D, const AttributeList &Attr, Sema &S) { 812 // check the attribute arguments. 813 if (Attr.getNumArgs() != 0) { 814 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 815 return; 816 } 817 818 // Attribute can be applied only to functions or variables. 819 if (isa<VarDecl>(D)) { 820 D->addAttr(::new (S.Context) DLLImportAttr()); 821 return; 822 } 823 824 FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 825 if (!FD) { 826 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 827 << Attr.getName() << 2 /*variable and function*/; 828 return; 829 } 830 831 // Currently, the dllimport attribute is ignored for inlined functions. 832 // Warning is emitted. 833 if (FD->isInlineSpecified()) { 834 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllimport"; 835 return; 836 } 837 838 // The attribute is also overridden by a subsequent declaration as dllexport. 839 // Warning is emitted. 840 for (AttributeList *nextAttr = Attr.getNext(); nextAttr; 841 nextAttr = nextAttr->getNext()) { 842 if (nextAttr->getKind() == AttributeList::AT_dllexport) { 843 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllimport"; 844 return; 845 } 846 } 847 848 if (D->getAttr<DLLExportAttr>()) { 849 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllimport"; 850 return; 851 } 852 853 D->addAttr(::new (S.Context) DLLImportAttr()); 854} 855 856static void HandleDLLExportAttr(Decl *D, const AttributeList &Attr, Sema &S) { 857 // check the attribute arguments. 858 if (Attr.getNumArgs() != 0) { 859 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 860 return; 861 } 862 863 // Attribute can be applied only to functions or variables. 864 if (isa<VarDecl>(D)) { 865 D->addAttr(::new (S.Context) DLLExportAttr()); 866 return; 867 } 868 869 FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 870 if (!FD) { 871 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 872 << Attr.getName() << 2 /*variable and function*/; 873 return; 874 } 875 876 // Currently, the dllexport attribute is ignored for inlined functions, unless 877 // the -fkeep-inline-functions flag has been used. Warning is emitted; 878 if (FD->isInlineSpecified()) { 879 // FIXME: ... unless the -fkeep-inline-functions flag has been used. 880 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "dllexport"; 881 return; 882 } 883 884 D->addAttr(::new (S.Context) DLLExportAttr()); 885} 886 887static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr, 888 Sema &S) { 889 // Attribute has 3 arguments. 890 if (Attr.getNumArgs() != 3) { 891 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 892 return; 893 } 894 895 unsigned WGSize[3]; 896 for (unsigned i = 0; i < 3; ++i) { 897 Expr *E = static_cast<Expr *>(Attr.getArg(i)); 898 llvm::APSInt ArgNum(32); 899 if (!E->isIntegerConstantExpr(ArgNum, S.Context)) { 900 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 901 << "reqd_work_group_size" << E->getSourceRange(); 902 return; 903 } 904 WGSize[i] = (unsigned) ArgNum.getZExtValue(); 905 } 906 D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(WGSize[0], WGSize[1], 907 WGSize[2])); 908} 909 910static void HandleSectionAttr(Decl *D, const AttributeList &Attr, Sema &S) { 911 // Attribute has no arguments. 912 if (Attr.getNumArgs() != 1) { 913 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 914 return; 915 } 916 917 // Make sure that there is a string literal as the sections's single 918 // argument. 919 Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0)); 920 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 921 if (!SE) { 922 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section"; 923 return; 924 } 925 926 // If the target wants to validate the section specifier, make it happen. 927 std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString()); 928 if (!Error.empty()) { 929 S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target) 930 << Error; 931 return; 932 } 933 934 // This attribute cannot be applied to local variables. 935 if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) { 936 S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable); 937 return; 938 } 939 940 D->addAttr(::new (S.Context) SectionAttr(SE->getString())); 941} 942 943static void HandleCDeclAttr(Decl *d, const AttributeList &Attr, Sema &S) { 944 // Attribute has no arguments. 945 if (Attr.getNumArgs() != 0) { 946 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 947 return; 948 } 949 950 // Attribute can be applied only to functions. 951 // If we try to apply it to a function pointer, don't warn, but don't 952 // do anything, either. All the function-pointer stuff is handled in 953 // SemaType.cpp. 954 ValueDecl *VD = dyn_cast<ValueDecl>(d); 955 if (VD && VD->getType()->isFunctionPointerType()) 956 return; 957 if (!isa<FunctionDecl>(d)) { 958 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 959 << Attr.getName() << 0 /*function*/; 960 return; 961 } 962 963 // cdecl and fastcall attributes are mutually incompatible. 964 if (d->getAttr<FastCallAttr>()) { 965 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 966 << "cdecl" << "fastcall"; 967 return; 968 } 969 970 // cdecl and stdcall attributes are mutually incompatible. 971 if (d->getAttr<StdCallAttr>()) { 972 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 973 << "cdecl" << "stdcall"; 974 return; 975 } 976 977 d->addAttr(::new (S.Context) CDeclAttr()); 978} 979 980 981static void HandleStdCallAttr(Decl *d, const AttributeList &Attr, Sema &S) { 982 // Attribute has no arguments. 983 if (Attr.getNumArgs() != 0) { 984 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 985 return; 986 } 987 988 // Attribute can be applied only to functions. 989 // If we try to apply it to a function pointer, don't warn, but don't 990 // do anything, either. All the function-pointer stuff is handled in 991 // SemaType.cpp. 992 ValueDecl *VD = dyn_cast<ValueDecl>(d); 993 if (VD && VD->getType()->isFunctionPointerType()) 994 return; 995 if (!isa<FunctionDecl>(d)) { 996 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 997 << Attr.getName() << 0 /*function*/; 998 return; 999 } 1000 1001 // stdcall and fastcall attributes are mutually incompatible. 1002 if (d->getAttr<FastCallAttr>()) { 1003 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 1004 << "stdcall" << "fastcall"; 1005 return; 1006 } 1007 1008 d->addAttr(::new (S.Context) StdCallAttr()); 1009} 1010 1011/// Diagnose the use of a non-standard calling convention on the given 1012/// function. 1013static void DiagnoseCConv(FunctionDecl *D, const char *CConv, 1014 SourceLocation Loc, Sema &S) { 1015 if (!D->hasPrototype()) { 1016 S.Diag(Loc, diag::err_cconv_knr) << CConv; 1017 return; 1018 } 1019 1020 const FunctionProtoType *T = D->getType()->getAs<FunctionProtoType>(); 1021 if (T->isVariadic()) { 1022 S.Diag(Loc, diag::err_cconv_varargs) << CConv; 1023 return; 1024 } 1025} 1026 1027static void HandleFastCallAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1028 // Attribute has no arguments. 1029 if (Attr.getNumArgs() != 0) { 1030 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1031 return; 1032 } 1033 1034 // If we try to apply it to a function pointer, don't warn, but don't 1035 // do anything, either. All the function-pointer stuff is handled in 1036 // SemaType.cpp. 1037 ValueDecl *VD = dyn_cast<ValueDecl>(d); 1038 if (VD && VD->getType()->isFunctionPointerType()) 1039 return; 1040 if (!isa<FunctionDecl>(d)) { 1041 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1042 << Attr.getName() << 0 /*function*/; 1043 return; 1044 } 1045 1046 DiagnoseCConv(cast<FunctionDecl>(d), "fastcall", Attr.getLoc(), S); 1047 1048 // stdcall and fastcall attributes are mutually incompatible. 1049 if (d->getAttr<StdCallAttr>()) { 1050 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 1051 << "fastcall" << "stdcall"; 1052 return; 1053 } 1054 1055 d->addAttr(::new (S.Context) FastCallAttr()); 1056} 1057 1058static void HandleNothrowAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1059 // check the attribute arguments. 1060 if (Attr.getNumArgs() != 0) { 1061 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1062 return; 1063 } 1064 1065 d->addAttr(::new (S.Context) NoThrowAttr()); 1066} 1067 1068static void HandleConstAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1069 // check the attribute arguments. 1070 if (Attr.getNumArgs() != 0) { 1071 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1072 return; 1073 } 1074 1075 d->addAttr(::new (S.Context) ConstAttr()); 1076} 1077 1078static void HandlePureAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1079 // check the attribute arguments. 1080 if (Attr.getNumArgs() != 0) { 1081 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1082 return; 1083 } 1084 1085 d->addAttr(::new (S.Context) PureAttr()); 1086} 1087 1088static void HandleCleanupAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1089 if (!Attr.getParameterName()) { 1090 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1091 return; 1092 } 1093 1094 if (Attr.getNumArgs() != 0) { 1095 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1096 return; 1097 } 1098 1099 VarDecl *VD = dyn_cast<VarDecl>(d); 1100 1101 if (!VD || !VD->hasLocalStorage()) { 1102 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup"; 1103 return; 1104 } 1105 1106 // Look up the function 1107 NamedDecl *CleanupDecl 1108 = S.LookupSingleName(S.TUScope, Attr.getParameterName(), 1109 Sema::LookupOrdinaryName); 1110 if (!CleanupDecl) { 1111 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_found) << 1112 Attr.getParameterName(); 1113 return; 1114 } 1115 1116 FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl); 1117 if (!FD) { 1118 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_function) << 1119 Attr.getParameterName(); 1120 return; 1121 } 1122 1123 if (FD->getNumParams() != 1) { 1124 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_func_must_take_one_arg) << 1125 Attr.getParameterName(); 1126 return; 1127 } 1128 1129 // We're currently more strict than GCC about what function types we accept. 1130 // If this ever proves to be a problem it should be easy to fix. 1131 QualType Ty = S.Context.getPointerType(VD->getType()); 1132 QualType ParamTy = FD->getParamDecl(0)->getType(); 1133 if (S.CheckAssignmentConstraints(ParamTy, Ty) != Sema::Compatible) { 1134 S.Diag(Attr.getLoc(), 1135 diag::err_attribute_cleanup_func_arg_incompatible_type) << 1136 Attr.getParameterName() << ParamTy << Ty; 1137 return; 1138 } 1139 1140 d->addAttr(::new (S.Context) CleanupAttr(FD)); 1141} 1142 1143/// Handle __attribute__((format_arg((idx)))) attribute based on 1144/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 1145static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1146 if (Attr.getNumArgs() != 1) { 1147 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1148 return; 1149 } 1150 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) { 1151 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1152 << Attr.getName() << 0 /*function*/; 1153 return; 1154 } 1155 // FIXME: in C++ the implicit 'this' function parameter also counts. this is 1156 // needed in order to be compatible with GCC the index must start with 1. 1157 unsigned NumArgs = getFunctionOrMethodNumArgs(d); 1158 unsigned FirstIdx = 1; 1159 // checks for the 2nd argument 1160 Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0)); 1161 llvm::APSInt Idx(32); 1162 if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 1163 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1164 << "format" << 2 << IdxExpr->getSourceRange(); 1165 return; 1166 } 1167 1168 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 1169 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1170 << "format" << 2 << IdxExpr->getSourceRange(); 1171 return; 1172 } 1173 1174 unsigned ArgIdx = Idx.getZExtValue() - 1; 1175 1176 // make sure the format string is really a string 1177 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx); 1178 1179 bool not_nsstring_type = !isNSStringType(Ty, S.Context); 1180 if (not_nsstring_type && 1181 !isCFStringType(Ty, S.Context) && 1182 (!Ty->isPointerType() || 1183 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 1184 // FIXME: Should highlight the actual expression that has the wrong type. 1185 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1186 << (not_nsstring_type ? "a string type" : "an NSString") 1187 << IdxExpr->getSourceRange(); 1188 return; 1189 } 1190 Ty = getFunctionOrMethodResultType(d); 1191 if (!isNSStringType(Ty, S.Context) && 1192 !isCFStringType(Ty, S.Context) && 1193 (!Ty->isPointerType() || 1194 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 1195 // FIXME: Should highlight the actual expression that has the wrong type. 1196 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not) 1197 << (not_nsstring_type ? "string type" : "NSString") 1198 << IdxExpr->getSourceRange(); 1199 return; 1200 } 1201 1202 d->addAttr(::new (S.Context) FormatArgAttr(Idx.getZExtValue())); 1203} 1204 1205enum FormatAttrKind { 1206 CFStringFormat, 1207 NSStringFormat, 1208 StrftimeFormat, 1209 SupportedFormat, 1210 InvalidFormat 1211}; 1212 1213/// getFormatAttrKind - Map from format attribute names to supported format 1214/// types. 1215static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) { 1216 // Check for formats that get handled specially. 1217 if (Format == "NSString") 1218 return NSStringFormat; 1219 if (Format == "CFString") 1220 return CFStringFormat; 1221 if (Format == "strftime") 1222 return StrftimeFormat; 1223 1224 // Otherwise, check for supported formats. 1225 if (Format == "scanf" || Format == "printf" || Format == "printf0" || 1226 Format == "strfmon" || Format == "cmn_err" || Format == "strftime" || 1227 Format == "NSString" || Format == "CFString" || Format == "vcmn_err" || 1228 Format == "zcmn_err") 1229 return SupportedFormat; 1230 1231 return InvalidFormat; 1232} 1233 1234/// Handle __attribute__((format(type,idx,firstarg))) attributes based on 1235/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 1236static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1237 1238 if (!Attr.getParameterName()) { 1239 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1240 << "format" << 1; 1241 return; 1242 } 1243 1244 if (Attr.getNumArgs() != 2) { 1245 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3; 1246 return; 1247 } 1248 1249 if (!isFunctionOrMethodOrBlock(d) || !hasFunctionProto(d)) { 1250 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1251 << Attr.getName() << 0 /*function*/; 1252 return; 1253 } 1254 1255 unsigned NumArgs = getFunctionOrMethodNumArgs(d); 1256 unsigned FirstIdx = 1; 1257 1258 llvm::StringRef Format = Attr.getParameterName()->getName(); 1259 1260 // Normalize the argument, __foo__ becomes foo. 1261 if (Format.startswith("__") && Format.endswith("__")) 1262 Format = Format.substr(2, Format.size() - 4); 1263 1264 // Check for supported formats. 1265 FormatAttrKind Kind = getFormatAttrKind(Format); 1266 if (Kind == InvalidFormat) { 1267 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 1268 << "format" << Attr.getParameterName()->getName(); 1269 return; 1270 } 1271 1272 // checks for the 2nd argument 1273 Expr *IdxExpr = static_cast<Expr *>(Attr.getArg(0)); 1274 llvm::APSInt Idx(32); 1275 if (!IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 1276 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1277 << "format" << 2 << IdxExpr->getSourceRange(); 1278 return; 1279 } 1280 1281 // FIXME: We should handle the implicit 'this' parameter in a more generic 1282 // way that can be used for other arguments. 1283 bool HasImplicitThisParam = false; 1284 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(d)) { 1285 if (MD->isInstance()) { 1286 HasImplicitThisParam = true; 1287 NumArgs++; 1288 } 1289 } 1290 1291 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 1292 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1293 << "format" << 2 << IdxExpr->getSourceRange(); 1294 return; 1295 } 1296 1297 // FIXME: Do we need to bounds check? 1298 unsigned ArgIdx = Idx.getZExtValue() - 1; 1299 1300 if (HasImplicitThisParam) { 1301 if (ArgIdx == 0) { 1302 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1303 << "a string type" << IdxExpr->getSourceRange(); 1304 return; 1305 } 1306 ArgIdx--; 1307 } 1308 1309 // make sure the format string is really a string 1310 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx); 1311 1312 if (Kind == CFStringFormat) { 1313 if (!isCFStringType(Ty, S.Context)) { 1314 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1315 << "a CFString" << IdxExpr->getSourceRange(); 1316 return; 1317 } 1318 } else if (Kind == NSStringFormat) { 1319 // FIXME: do we need to check if the type is NSString*? What are the 1320 // semantics? 1321 if (!isNSStringType(Ty, S.Context)) { 1322 // FIXME: Should highlight the actual expression that has the wrong type. 1323 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1324 << "an NSString" << IdxExpr->getSourceRange(); 1325 return; 1326 } 1327 } else if (!Ty->isPointerType() || 1328 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) { 1329 // FIXME: Should highlight the actual expression that has the wrong type. 1330 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1331 << "a string type" << IdxExpr->getSourceRange(); 1332 return; 1333 } 1334 1335 // check the 3rd argument 1336 Expr *FirstArgExpr = static_cast<Expr *>(Attr.getArg(1)); 1337 llvm::APSInt FirstArg(32); 1338 if (!FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) { 1339 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1340 << "format" << 3 << FirstArgExpr->getSourceRange(); 1341 return; 1342 } 1343 1344 // check if the function is variadic if the 3rd argument non-zero 1345 if (FirstArg != 0) { 1346 if (isFunctionOrMethodVariadic(d)) { 1347 ++NumArgs; // +1 for ... 1348 } else { 1349 S.Diag(d->getLocation(), diag::err_format_attribute_requires_variadic); 1350 return; 1351 } 1352 } 1353 1354 // strftime requires FirstArg to be 0 because it doesn't read from any 1355 // variable the input is just the current time + the format string. 1356 if (Kind == StrftimeFormat) { 1357 if (FirstArg != 0) { 1358 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter) 1359 << FirstArgExpr->getSourceRange(); 1360 return; 1361 } 1362 // if 0 it disables parameter checking (to use with e.g. va_list) 1363 } else if (FirstArg != 0 && FirstArg != NumArgs) { 1364 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1365 << "format" << 3 << FirstArgExpr->getSourceRange(); 1366 return; 1367 } 1368 1369 d->addAttr(::new (S.Context) FormatAttr(Format, Idx.getZExtValue(), 1370 FirstArg.getZExtValue())); 1371} 1372 1373static void HandleTransparentUnionAttr(Decl *d, const AttributeList &Attr, 1374 Sema &S) { 1375 // check the attribute arguments. 1376 if (Attr.getNumArgs() != 0) { 1377 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1378 return; 1379 } 1380 1381 // Try to find the underlying union declaration. 1382 RecordDecl *RD = 0; 1383 TypedefDecl *TD = dyn_cast<TypedefDecl>(d); 1384 if (TD && TD->getUnderlyingType()->isUnionType()) 1385 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl(); 1386 else 1387 RD = dyn_cast<RecordDecl>(d); 1388 1389 if (!RD || !RD->isUnion()) { 1390 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1391 << Attr.getName() << 1 /*union*/; 1392 return; 1393 } 1394 1395 if (!RD->isDefinition()) { 1396 S.Diag(Attr.getLoc(), 1397 diag::warn_transparent_union_attribute_not_definition); 1398 return; 1399 } 1400 1401 RecordDecl::field_iterator Field = RD->field_begin(), 1402 FieldEnd = RD->field_end(); 1403 if (Field == FieldEnd) { 1404 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields); 1405 return; 1406 } 1407 1408 FieldDecl *FirstField = *Field; 1409 QualType FirstType = FirstField->getType(); 1410 if (FirstType->isFloatingType() || FirstType->isVectorType()) { 1411 S.Diag(FirstField->getLocation(), 1412 diag::warn_transparent_union_attribute_floating); 1413 return; 1414 } 1415 1416 uint64_t FirstSize = S.Context.getTypeSize(FirstType); 1417 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType); 1418 for (; Field != FieldEnd; ++Field) { 1419 QualType FieldType = Field->getType(); 1420 if (S.Context.getTypeSize(FieldType) != FirstSize || 1421 S.Context.getTypeAlign(FieldType) != FirstAlign) { 1422 // Warn if we drop the attribute. 1423 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize; 1424 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType) 1425 : S.Context.getTypeAlign(FieldType); 1426 S.Diag(Field->getLocation(), 1427 diag::warn_transparent_union_attribute_field_size_align) 1428 << isSize << Field->getDeclName() << FieldBits; 1429 unsigned FirstBits = isSize? FirstSize : FirstAlign; 1430 S.Diag(FirstField->getLocation(), 1431 diag::note_transparent_union_first_field_size_align) 1432 << isSize << FirstBits; 1433 return; 1434 } 1435 } 1436 1437 RD->addAttr(::new (S.Context) TransparentUnionAttr()); 1438} 1439 1440static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1441 // check the attribute arguments. 1442 if (Attr.getNumArgs() != 1) { 1443 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1444 return; 1445 } 1446 Expr *ArgExpr = static_cast<Expr *>(Attr.getArg(0)); 1447 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 1448 1449 // Make sure that there is a string literal as the annotation's single 1450 // argument. 1451 if (!SE) { 1452 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate"; 1453 return; 1454 } 1455 d->addAttr(::new (S.Context) AnnotateAttr(SE->getString())); 1456} 1457 1458static void HandleAlignedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1459 // check the attribute arguments. 1460 if (Attr.getNumArgs() > 1) { 1461 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1462 return; 1463 } 1464 1465 //FIXME: The C++0x version of this attribute has more limited applicabilty 1466 // than GNU's, and should error out when it is used to specify a 1467 // weaker alignment, rather than being silently ignored. 1468 1469 unsigned Align = 0; 1470 if (Attr.getNumArgs() == 0) { 1471 // FIXME: This should be the target specific maximum alignment. 1472 // (For now we just use 128 bits which is the maximum on X86). 1473 Align = 128; 1474 d->addAttr(::new (S.Context) AlignedAttr(Align)); 1475 return; 1476 } 1477 1478 Expr *alignmentExpr = static_cast<Expr *>(Attr.getArg(0)); 1479 llvm::APSInt Alignment(32); 1480 if (!alignmentExpr->isIntegerConstantExpr(Alignment, S.Context)) { 1481 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1482 << "aligned" << alignmentExpr->getSourceRange(); 1483 return; 1484 } 1485 if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) { 1486 S.Diag(Attr.getLoc(), diag::err_attribute_aligned_not_power_of_two) 1487 << alignmentExpr->getSourceRange(); 1488 return; 1489 } 1490 1491 d->addAttr(::new (S.Context) AlignedAttr(Alignment.getZExtValue() * 8)); 1492} 1493 1494/// HandleModeAttr - This attribute modifies the width of a decl with primitive 1495/// type. 1496/// 1497/// Despite what would be logical, the mode attribute is a decl attribute, not a 1498/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be 1499/// HImode, not an intermediate pointer. 1500static void HandleModeAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1501 // This attribute isn't documented, but glibc uses it. It changes 1502 // the width of an int or unsigned int to the specified size. 1503 1504 // Check that there aren't any arguments 1505 if (Attr.getNumArgs() != 0) { 1506 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1507 return; 1508 } 1509 1510 IdentifierInfo *Name = Attr.getParameterName(); 1511 if (!Name) { 1512 S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name); 1513 return; 1514 } 1515 1516 llvm::StringRef Str = Attr.getParameterName()->getName(); 1517 1518 // Normalize the attribute name, __foo__ becomes foo. 1519 if (Str.startswith("__") && Str.endswith("__")) 1520 Str = Str.substr(2, Str.size() - 4); 1521 1522 unsigned DestWidth = 0; 1523 bool IntegerMode = true; 1524 bool ComplexMode = false; 1525 switch (Str.size()) { 1526 case 2: 1527 switch (Str[0]) { 1528 case 'Q': DestWidth = 8; break; 1529 case 'H': DestWidth = 16; break; 1530 case 'S': DestWidth = 32; break; 1531 case 'D': DestWidth = 64; break; 1532 case 'X': DestWidth = 96; break; 1533 case 'T': DestWidth = 128; break; 1534 } 1535 if (Str[1] == 'F') { 1536 IntegerMode = false; 1537 } else if (Str[1] == 'C') { 1538 IntegerMode = false; 1539 ComplexMode = true; 1540 } else if (Str[1] != 'I') { 1541 DestWidth = 0; 1542 } 1543 break; 1544 case 4: 1545 // FIXME: glibc uses 'word' to define register_t; this is narrower than a 1546 // pointer on PIC16 and other embedded platforms. 1547 if (Str == "word") 1548 DestWidth = S.Context.Target.getPointerWidth(0); 1549 else if (Str == "byte") 1550 DestWidth = S.Context.Target.getCharWidth(); 1551 break; 1552 case 7: 1553 if (Str == "pointer") 1554 DestWidth = S.Context.Target.getPointerWidth(0); 1555 break; 1556 } 1557 1558 QualType OldTy; 1559 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) 1560 OldTy = TD->getUnderlyingType(); 1561 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) 1562 OldTy = VD->getType(); 1563 else { 1564 S.Diag(D->getLocation(), diag::err_attr_wrong_decl) 1565 << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc()); 1566 return; 1567 } 1568 1569 if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType()) 1570 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive); 1571 else if (IntegerMode) { 1572 if (!OldTy->isIntegralType()) 1573 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1574 } else if (ComplexMode) { 1575 if (!OldTy->isComplexType()) 1576 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1577 } else { 1578 if (!OldTy->isFloatingType()) 1579 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1580 } 1581 1582 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t 1583 // and friends, at least with glibc. 1584 // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong 1585 // width on unusual platforms. 1586 // FIXME: Make sure floating-point mappings are accurate 1587 // FIXME: Support XF and TF types 1588 QualType NewTy; 1589 switch (DestWidth) { 1590 case 0: 1591 S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name; 1592 return; 1593 default: 1594 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1595 return; 1596 case 8: 1597 if (!IntegerMode) { 1598 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1599 return; 1600 } 1601 if (OldTy->isSignedIntegerType()) 1602 NewTy = S.Context.SignedCharTy; 1603 else 1604 NewTy = S.Context.UnsignedCharTy; 1605 break; 1606 case 16: 1607 if (!IntegerMode) { 1608 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1609 return; 1610 } 1611 if (OldTy->isSignedIntegerType()) 1612 NewTy = S.Context.ShortTy; 1613 else 1614 NewTy = S.Context.UnsignedShortTy; 1615 break; 1616 case 32: 1617 if (!IntegerMode) 1618 NewTy = S.Context.FloatTy; 1619 else if (OldTy->isSignedIntegerType()) 1620 NewTy = S.Context.IntTy; 1621 else 1622 NewTy = S.Context.UnsignedIntTy; 1623 break; 1624 case 64: 1625 if (!IntegerMode) 1626 NewTy = S.Context.DoubleTy; 1627 else if (OldTy->isSignedIntegerType()) 1628 if (S.Context.Target.getLongWidth() == 64) 1629 NewTy = S.Context.LongTy; 1630 else 1631 NewTy = S.Context.LongLongTy; 1632 else 1633 if (S.Context.Target.getLongWidth() == 64) 1634 NewTy = S.Context.UnsignedLongTy; 1635 else 1636 NewTy = S.Context.UnsignedLongLongTy; 1637 break; 1638 case 96: 1639 NewTy = S.Context.LongDoubleTy; 1640 break; 1641 case 128: 1642 if (!IntegerMode) { 1643 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1644 return; 1645 } 1646 if (OldTy->isSignedIntegerType()) 1647 NewTy = S.Context.Int128Ty; 1648 else 1649 NewTy = S.Context.UnsignedInt128Ty; 1650 break; 1651 } 1652 1653 if (ComplexMode) { 1654 NewTy = S.Context.getComplexType(NewTy); 1655 } 1656 1657 // Install the new type. 1658 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { 1659 // FIXME: preserve existing source info. 1660 TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy)); 1661 } else 1662 cast<ValueDecl>(D)->setType(NewTy); 1663} 1664 1665static void HandleNoDebugAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1666 // check the attribute arguments. 1667 if (Attr.getNumArgs() > 0) { 1668 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1669 return; 1670 } 1671 1672 if (!isFunctionOrMethod(d)) { 1673 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1674 << Attr.getName() << 0 /*function*/; 1675 return; 1676 } 1677 1678 d->addAttr(::new (S.Context) NoDebugAttr()); 1679} 1680 1681static void HandleNoInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1682 // check the attribute arguments. 1683 if (Attr.getNumArgs() != 0) { 1684 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1685 return; 1686 } 1687 1688 if (!isa<FunctionDecl>(d)) { 1689 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1690 << Attr.getName() << 0 /*function*/; 1691 return; 1692 } 1693 1694 d->addAttr(::new (S.Context) NoInlineAttr()); 1695} 1696 1697static void HandleGNUInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1698 // check the attribute arguments. 1699 if (Attr.getNumArgs() != 0) { 1700 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1701 return; 1702 } 1703 1704 FunctionDecl *Fn = dyn_cast<FunctionDecl>(d); 1705 if (Fn == 0) { 1706 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1707 << Attr.getName() << 0 /*function*/; 1708 return; 1709 } 1710 1711 if (!Fn->isInlineSpecified()) { 1712 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline); 1713 return; 1714 } 1715 1716 d->addAttr(::new (S.Context) GNUInlineAttr()); 1717} 1718 1719static void HandleRegparmAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1720 // check the attribute arguments. 1721 if (Attr.getNumArgs() != 1) { 1722 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1723 return; 1724 } 1725 1726 if (!isFunctionOrMethod(d)) { 1727 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1728 << Attr.getName() << 0 /*function*/; 1729 return; 1730 } 1731 1732 Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArg(0)); 1733 llvm::APSInt NumParams(32); 1734 if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) { 1735 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1736 << "regparm" << NumParamsExpr->getSourceRange(); 1737 return; 1738 } 1739 1740 if (S.Context.Target.getRegParmMax() == 0) { 1741 S.Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform) 1742 << NumParamsExpr->getSourceRange(); 1743 return; 1744 } 1745 1746 if (NumParams.getLimitedValue(255) > S.Context.Target.getRegParmMax()) { 1747 S.Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number) 1748 << S.Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange(); 1749 return; 1750 } 1751 1752 d->addAttr(::new (S.Context) RegparmAttr(NumParams.getZExtValue())); 1753} 1754 1755static void HandleFinalAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1756 // check the attribute arguments. 1757 if (Attr.getNumArgs() != 0) { 1758 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1759 return; 1760 } 1761 1762 if (!isa<CXXRecordDecl>(d) 1763 && (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual())) { 1764 S.Diag(Attr.getLoc(), 1765 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 1766 : diag::warn_attribute_wrong_decl_type) 1767 << Attr.getName() << 7 /*virtual method or class*/; 1768 return; 1769 } 1770 1771 // FIXME: Conform to C++0x redeclaration rules. 1772 1773 if (d->getAttr<FinalAttr>()) { 1774 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "final"; 1775 return; 1776 } 1777 1778 d->addAttr(::new (S.Context) FinalAttr()); 1779} 1780 1781//===----------------------------------------------------------------------===// 1782// C++0x member checking attributes 1783//===----------------------------------------------------------------------===// 1784 1785static void HandleBaseCheckAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1786 if (Attr.getNumArgs() != 0) { 1787 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1788 return; 1789 } 1790 1791 if (!isa<CXXRecordDecl>(d)) { 1792 S.Diag(Attr.getLoc(), 1793 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 1794 : diag::warn_attribute_wrong_decl_type) 1795 << Attr.getName() << 9 /*class*/; 1796 return; 1797 } 1798 1799 if (d->getAttr<BaseCheckAttr>()) { 1800 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "base_check"; 1801 return; 1802 } 1803 1804 d->addAttr(::new (S.Context) BaseCheckAttr()); 1805} 1806 1807static void HandleHidingAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1808 if (Attr.getNumArgs() != 0) { 1809 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1810 return; 1811 } 1812 1813 if (!isa<RecordDecl>(d->getDeclContext())) { 1814 // FIXME: It's not the type that's the problem 1815 S.Diag(Attr.getLoc(), 1816 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 1817 : diag::warn_attribute_wrong_decl_type) 1818 << Attr.getName() << 11 /*member*/; 1819 return; 1820 } 1821 1822 // FIXME: Conform to C++0x redeclaration rules. 1823 1824 if (d->getAttr<HidingAttr>()) { 1825 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "hiding"; 1826 return; 1827 } 1828 1829 d->addAttr(::new (S.Context) HidingAttr()); 1830} 1831 1832static void HandleOverrideAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1833 if (Attr.getNumArgs() != 0) { 1834 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1835 return; 1836 } 1837 1838 if (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual()) { 1839 // FIXME: It's not the type that's the problem 1840 S.Diag(Attr.getLoc(), 1841 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 1842 : diag::warn_attribute_wrong_decl_type) 1843 << Attr.getName() << 10 /*virtual method*/; 1844 return; 1845 } 1846 1847 // FIXME: Conform to C++0x redeclaration rules. 1848 1849 if (d->getAttr<OverrideAttr>()) { 1850 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "override"; 1851 return; 1852 } 1853 1854 d->addAttr(::new (S.Context) OverrideAttr()); 1855} 1856 1857//===----------------------------------------------------------------------===// 1858// Checker-specific attribute handlers. 1859//===----------------------------------------------------------------------===// 1860 1861static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &Attr, 1862 Sema &S) { 1863 1864 QualType RetTy; 1865 1866 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) 1867 RetTy = MD->getResultType(); 1868 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) 1869 RetTy = FD->getResultType(); 1870 else { 1871 SourceLocation L = Attr.getLoc(); 1872 S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type) 1873 << SourceRange(L, L) << Attr.getName() << 3 /* function or method */; 1874 return; 1875 } 1876 1877 if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAs<PointerType>() 1878 || RetTy->getAs<ObjCObjectPointerType>())) { 1879 SourceLocation L = Attr.getLoc(); 1880 S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_return_type) 1881 << SourceRange(L, L) << Attr.getName(); 1882 return; 1883 } 1884 1885 switch (Attr.getKind()) { 1886 default: 1887 assert(0 && "invalid ownership attribute"); 1888 return; 1889 case AttributeList::AT_cf_returns_retained: 1890 d->addAttr(::new (S.Context) CFReturnsRetainedAttr()); 1891 return; 1892 case AttributeList::AT_ns_returns_retained: 1893 d->addAttr(::new (S.Context) NSReturnsRetainedAttr()); 1894 return; 1895 }; 1896} 1897 1898//===----------------------------------------------------------------------===// 1899// Top Level Sema Entry Points 1900//===----------------------------------------------------------------------===// 1901 1902/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if 1903/// the attribute applies to decls. If the attribute is a type attribute, just 1904/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to 1905/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4). 1906static void ProcessDeclAttribute(Scope *scope, Decl *D, 1907 const AttributeList &Attr, Sema &S) { 1908 if (Attr.isDeclspecAttribute()) 1909 // FIXME: Try to deal with __declspec attributes! 1910 return; 1911 switch (Attr.getKind()) { 1912 case AttributeList::AT_IBOutlet: HandleIBOutletAttr (D, Attr, S); break; 1913 case AttributeList::AT_address_space: 1914 case AttributeList::AT_objc_gc: 1915 case AttributeList::AT_vector_size: 1916 // Ignore these, these are type attributes, handled by 1917 // ProcessTypeAttributes. 1918 break; 1919 case AttributeList::AT_alias: HandleAliasAttr (D, Attr, S); break; 1920 case AttributeList::AT_aligned: HandleAlignedAttr (D, Attr, S); break; 1921 case AttributeList::AT_always_inline: 1922 HandleAlwaysInlineAttr (D, Attr, S); break; 1923 case AttributeList::AT_analyzer_noreturn: 1924 HandleAnalyzerNoReturnAttr (D, Attr, S); break; 1925 case AttributeList::AT_annotate: HandleAnnotateAttr (D, Attr, S); break; 1926 case AttributeList::AT_base_check: HandleBaseCheckAttr (D, Attr, S); break; 1927 case AttributeList::AT_carries_dependency: 1928 HandleDependencyAttr (D, Attr, S); break; 1929 case AttributeList::AT_cdecl: HandleCDeclAttr (D, Attr, S); break; 1930 case AttributeList::AT_constructor: HandleConstructorAttr (D, Attr, S); break; 1931 case AttributeList::AT_deprecated: HandleDeprecatedAttr (D, Attr, S); break; 1932 case AttributeList::AT_destructor: HandleDestructorAttr (D, Attr, S); break; 1933 case AttributeList::AT_dllexport: HandleDLLExportAttr (D, Attr, S); break; 1934 case AttributeList::AT_dllimport: HandleDLLImportAttr (D, Attr, S); break; 1935 case AttributeList::AT_ext_vector_type: 1936 HandleExtVectorTypeAttr(scope, D, Attr, S); 1937 break; 1938 case AttributeList::AT_fastcall: HandleFastCallAttr (D, Attr, S); break; 1939 case AttributeList::AT_final: HandleFinalAttr (D, Attr, S); break; 1940 case AttributeList::AT_format: HandleFormatAttr (D, Attr, S); break; 1941 case AttributeList::AT_format_arg: HandleFormatArgAttr (D, Attr, S); break; 1942 case AttributeList::AT_gnu_inline: HandleGNUInlineAttr (D, Attr, S); break; 1943 case AttributeList::AT_hiding: HandleHidingAttr (D, Attr, S); break; 1944 case AttributeList::AT_mode: HandleModeAttr (D, Attr, S); break; 1945 case AttributeList::AT_malloc: HandleMallocAttr (D, Attr, S); break; 1946 case AttributeList::AT_nonnull: HandleNonNullAttr (D, Attr, S); break; 1947 case AttributeList::AT_noreturn: HandleNoReturnAttr (D, Attr, S); break; 1948 case AttributeList::AT_nothrow: HandleNothrowAttr (D, Attr, S); break; 1949 case AttributeList::AT_override: HandleOverrideAttr (D, Attr, S); break; 1950 1951 // Checker-specific. 1952 case AttributeList::AT_ns_returns_retained: 1953 case AttributeList::AT_cf_returns_retained: 1954 HandleNSReturnsRetainedAttr(D, Attr, S); break; 1955 1956 case AttributeList::AT_reqd_wg_size: 1957 HandleReqdWorkGroupSize(D, Attr, S); break; 1958 1959 case AttributeList::AT_packed: HandlePackedAttr (D, Attr, S); break; 1960 case AttributeList::AT_section: HandleSectionAttr (D, Attr, S); break; 1961 case AttributeList::AT_stdcall: HandleStdCallAttr (D, Attr, S); break; 1962 case AttributeList::AT_unavailable: HandleUnavailableAttr (D, Attr, S); break; 1963 case AttributeList::AT_unused: HandleUnusedAttr (D, Attr, S); break; 1964 case AttributeList::AT_used: HandleUsedAttr (D, Attr, S); break; 1965 case AttributeList::AT_visibility: HandleVisibilityAttr (D, Attr, S); break; 1966 case AttributeList::AT_warn_unused_result: HandleWarnUnusedResult(D,Attr,S); 1967 break; 1968 case AttributeList::AT_weak: HandleWeakAttr (D, Attr, S); break; 1969 case AttributeList::AT_weak_import: HandleWeakImportAttr (D, Attr, S); break; 1970 case AttributeList::AT_transparent_union: 1971 HandleTransparentUnionAttr(D, Attr, S); 1972 break; 1973 case AttributeList::AT_objc_exception: 1974 HandleObjCExceptionAttr(D, Attr, S); 1975 break; 1976 case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break; 1977 case AttributeList::AT_nsobject: HandleObjCNSObject (D, Attr, S); break; 1978 case AttributeList::AT_blocks: HandleBlocksAttr (D, Attr, S); break; 1979 case AttributeList::AT_sentinel: HandleSentinelAttr (D, Attr, S); break; 1980 case AttributeList::AT_const: HandleConstAttr (D, Attr, S); break; 1981 case AttributeList::AT_pure: HandlePureAttr (D, Attr, S); break; 1982 case AttributeList::AT_cleanup: HandleCleanupAttr (D, Attr, S); break; 1983 case AttributeList::AT_nodebug: HandleNoDebugAttr (D, Attr, S); break; 1984 case AttributeList::AT_noinline: HandleNoInlineAttr (D, Attr, S); break; 1985 case AttributeList::AT_regparm: HandleRegparmAttr (D, Attr, S); break; 1986 case AttributeList::IgnoredAttribute: 1987 case AttributeList::AT_no_instrument_function: // Interacts with -pg. 1988 // Just ignore 1989 break; 1990 default: 1991 // Ask target about the attribute. 1992 const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema(); 1993 if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S)) 1994 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 1995 break; 1996 } 1997} 1998 1999/// ProcessDeclAttributeList - Apply all the decl attributes in the specified 2000/// attribute list to the specified decl, ignoring any type attributes. 2001void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList) { 2002 while (AttrList) { 2003 ProcessDeclAttribute(S, D, *AttrList, *this); 2004 AttrList = AttrList->getNext(); 2005 } 2006} 2007 2008/// DeclClonePragmaWeak - clone existing decl (maybe definition), 2009/// #pragma weak needs a non-definition decl and source may not have one 2010NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) { 2011 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND)); 2012 NamedDecl *NewD = 0; 2013 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 2014 NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(), 2015 FD->getLocation(), DeclarationName(II), 2016 FD->getType(), FD->getTypeSourceInfo()); 2017 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) { 2018 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(), 2019 VD->getLocation(), II, 2020 VD->getType(), VD->getTypeSourceInfo(), 2021 VD->getStorageClass()); 2022 } 2023 return NewD; 2024} 2025 2026/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak 2027/// applied to it, possibly with an alias. 2028void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) { 2029 if (W.getUsed()) return; // only do this once 2030 W.setUsed(true); 2031 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...)) 2032 IdentifierInfo *NDId = ND->getIdentifier(); 2033 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias()); 2034 NewD->addAttr(::new (Context) AliasAttr(NDId->getName())); 2035 NewD->addAttr(::new (Context) WeakAttr()); 2036 WeakTopLevelDecl.push_back(NewD); 2037 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin 2038 // to insert Decl at TU scope, sorry. 2039 DeclContext *SavedContext = CurContext; 2040 CurContext = Context.getTranslationUnitDecl(); 2041 PushOnScopeChains(NewD, S); 2042 CurContext = SavedContext; 2043 } else { // just add weak to existing 2044 ND->addAttr(::new (Context) WeakAttr()); 2045 } 2046} 2047 2048/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in 2049/// it, apply them to D. This is a bit tricky because PD can have attributes 2050/// specified in many different places, and we need to find and apply them all. 2051void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) { 2052 // Handle #pragma weak 2053 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 2054 if (ND->hasLinkage()) { 2055 WeakInfo W = WeakUndeclaredIdentifiers.lookup(ND->getIdentifier()); 2056 if (W != WeakInfo()) { 2057 // Identifier referenced by #pragma weak before it was declared 2058 DeclApplyPragmaWeak(S, ND, W); 2059 WeakUndeclaredIdentifiers[ND->getIdentifier()] = W; 2060 } 2061 } 2062 } 2063 2064 // Apply decl attributes from the DeclSpec if present. 2065 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes()) 2066 ProcessDeclAttributeList(S, D, Attrs); 2067 2068 // Walk the declarator structure, applying decl attributes that were in a type 2069 // position to the decl itself. This handles cases like: 2070 // int *__attr__(x)** D; 2071 // when X is a decl attribute. 2072 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i) 2073 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs()) 2074 ProcessDeclAttributeList(S, D, Attrs); 2075 2076 // Finally, apply any attributes on the decl itself. 2077 if (const AttributeList *Attrs = PD.getAttributes()) 2078 ProcessDeclAttributeList(S, D, Attrs); 2079} 2080 2081/// PushParsingDeclaration - Enter a new "scope" of deprecation 2082/// warnings. 2083/// 2084/// The state token we use is the start index of this scope 2085/// on the warning stack. 2086Action::ParsingDeclStackState Sema::PushParsingDeclaration() { 2087 ParsingDeclDepth++; 2088 return (ParsingDeclStackState) DelayedDiagnostics.size(); 2089} 2090 2091void Sema::PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy Ctx) { 2092 assert(ParsingDeclDepth > 0 && "empty ParsingDeclaration stack"); 2093 ParsingDeclDepth--; 2094 2095 if (DelayedDiagnostics.empty()) 2096 return; 2097 2098 unsigned SavedIndex = (unsigned) S; 2099 assert(SavedIndex <= DelayedDiagnostics.size() && 2100 "saved index is out of bounds"); 2101 2102 // We only want to actually emit delayed diagnostics when we 2103 // successfully parsed a decl. 2104 Decl *D = Ctx ? Ctx.getAs<Decl>() : 0; 2105 if (D) { 2106 // We really do want to start with 0 here. We get one push for a 2107 // decl spec and another for each declarator; in a decl group like: 2108 // deprecated_typedef foo, *bar, baz(); 2109 // only the declarator pops will be passed decls. This is correct; 2110 // we really do need to consider delayed diagnostics from the decl spec 2111 // for each of the different declarations. 2112 for (unsigned I = 0, E = DelayedDiagnostics.size(); I != E; ++I) { 2113 if (DelayedDiagnostics[I].Triggered) 2114 continue; 2115 2116 switch (DelayedDiagnostics[I].Kind) { 2117 case DelayedDiagnostic::Deprecation: 2118 HandleDelayedDeprecationCheck(DelayedDiagnostics[I], D); 2119 break; 2120 2121 case DelayedDiagnostic::Access: 2122 HandleDelayedAccessCheck(DelayedDiagnostics[I], D); 2123 break; 2124 } 2125 } 2126 } 2127 2128 DelayedDiagnostics.set_size(SavedIndex); 2129} 2130 2131static bool isDeclDeprecated(Decl *D) { 2132 do { 2133 if (D->hasAttr<DeprecatedAttr>()) 2134 return true; 2135 } while ((D = cast_or_null<Decl>(D->getDeclContext()))); 2136 return false; 2137} 2138 2139void Sema::HandleDelayedDeprecationCheck(Sema::DelayedDiagnostic &DD, 2140 Decl *Ctx) { 2141 if (isDeclDeprecated(Ctx)) 2142 return; 2143 2144 DD.Triggered = true; 2145 Diag(DD.Loc, diag::warn_deprecated) 2146 << DD.DeprecationData.Decl->getDeclName(); 2147} 2148 2149void Sema::EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc) { 2150 // Delay if we're currently parsing a declaration. 2151 if (ParsingDeclDepth) { 2152 DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D)); 2153 return; 2154 } 2155 2156 // Otherwise, don't warn if our current context is deprecated. 2157 if (isDeclDeprecated(cast<Decl>(CurContext))) 2158 return; 2159 2160 Diag(Loc, diag::warn_deprecated) << D->getDeclName(); 2161} 2162