SemaDeclAttr.cpp revision 722109c1b7718d3e8aab075ce65007b372822199
1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements decl-related attribute processing. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "TargetAttributesSema.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/Expr.h" 20#include "clang/Basic/TargetInfo.h" 21#include "clang/Sema/DeclSpec.h" 22#include "clang/Sema/DelayedDiagnostic.h" 23#include "llvm/ADT/StringExtras.h" 24using namespace clang; 25using namespace sema; 26 27//===----------------------------------------------------------------------===// 28// Helper functions 29//===----------------------------------------------------------------------===// 30 31static const FunctionType *getFunctionType(const Decl *d, 32 bool blocksToo = true) { 33 QualType Ty; 34 if (const ValueDecl *decl = dyn_cast<ValueDecl>(d)) 35 Ty = decl->getType(); 36 else if (const FieldDecl *decl = dyn_cast<FieldDecl>(d)) 37 Ty = decl->getType(); 38 else if (const TypedefDecl* decl = dyn_cast<TypedefDecl>(d)) 39 Ty = decl->getUnderlyingType(); 40 else 41 return 0; 42 43 if (Ty->isFunctionPointerType()) 44 Ty = Ty->getAs<PointerType>()->getPointeeType(); 45 else if (blocksToo && Ty->isBlockPointerType()) 46 Ty = Ty->getAs<BlockPointerType>()->getPointeeType(); 47 48 return Ty->getAs<FunctionType>(); 49} 50 51// FIXME: We should provide an abstraction around a method or function 52// to provide the following bits of information. 53 54/// isFunction - Return true if the given decl has function 55/// type (function or function-typed variable). 56static bool isFunction(const Decl *d) { 57 return getFunctionType(d, false) != NULL; 58} 59 60/// isFunctionOrMethod - Return true if the given decl has function 61/// type (function or function-typed variable) or an Objective-C 62/// method. 63static bool isFunctionOrMethod(const Decl *d) { 64 return isFunction(d)|| isa<ObjCMethodDecl>(d); 65} 66 67/// isFunctionOrMethodOrBlock - Return true if the given decl has function 68/// type (function or function-typed variable) or an Objective-C 69/// method or a block. 70static bool isFunctionOrMethodOrBlock(const Decl *d) { 71 if (isFunctionOrMethod(d)) 72 return true; 73 // check for block is more involved. 74 if (const VarDecl *V = dyn_cast<VarDecl>(d)) { 75 QualType Ty = V->getType(); 76 return Ty->isBlockPointerType(); 77 } 78 return isa<BlockDecl>(d); 79} 80 81/// hasFunctionProto - Return true if the given decl has a argument 82/// information. This decl should have already passed 83/// isFunctionOrMethod or isFunctionOrMethodOrBlock. 84static bool hasFunctionProto(const Decl *d) { 85 if (const FunctionType *FnTy = getFunctionType(d)) 86 return isa<FunctionProtoType>(FnTy); 87 else { 88 assert(isa<ObjCMethodDecl>(d) || isa<BlockDecl>(d)); 89 return true; 90 } 91} 92 93/// getFunctionOrMethodNumArgs - Return number of function or method 94/// arguments. It is an error to call this on a K&R function (use 95/// hasFunctionProto first). 96static unsigned getFunctionOrMethodNumArgs(const Decl *d) { 97 if (const FunctionType *FnTy = getFunctionType(d)) 98 return cast<FunctionProtoType>(FnTy)->getNumArgs(); 99 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 100 return BD->getNumParams(); 101 return cast<ObjCMethodDecl>(d)->param_size(); 102} 103 104static QualType getFunctionOrMethodArgType(const Decl *d, unsigned Idx) { 105 if (const FunctionType *FnTy = getFunctionType(d)) 106 return cast<FunctionProtoType>(FnTy)->getArgType(Idx); 107 if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 108 return BD->getParamDecl(Idx)->getType(); 109 110 return cast<ObjCMethodDecl>(d)->param_begin()[Idx]->getType(); 111} 112 113static QualType getFunctionOrMethodResultType(const Decl *d) { 114 if (const FunctionType *FnTy = getFunctionType(d)) 115 return cast<FunctionProtoType>(FnTy)->getResultType(); 116 return cast<ObjCMethodDecl>(d)->getResultType(); 117} 118 119static bool isFunctionOrMethodVariadic(const Decl *d) { 120 if (const FunctionType *FnTy = getFunctionType(d)) { 121 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy); 122 return proto->isVariadic(); 123 } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(d)) 124 return BD->isVariadic(); 125 else { 126 return cast<ObjCMethodDecl>(d)->isVariadic(); 127 } 128} 129 130static bool isInstanceMethod(const Decl *d) { 131 if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(d)) 132 return MethodDecl->isInstance(); 133 return false; 134} 135 136static inline bool isNSStringType(QualType T, ASTContext &Ctx) { 137 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>(); 138 if (!PT) 139 return false; 140 141 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface(); 142 if (!Cls) 143 return false; 144 145 IdentifierInfo* ClsName = Cls->getIdentifier(); 146 147 // FIXME: Should we walk the chain of classes? 148 return ClsName == &Ctx.Idents.get("NSString") || 149 ClsName == &Ctx.Idents.get("NSMutableString"); 150} 151 152static inline bool isCFStringType(QualType T, ASTContext &Ctx) { 153 const PointerType *PT = T->getAs<PointerType>(); 154 if (!PT) 155 return false; 156 157 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>(); 158 if (!RT) 159 return false; 160 161 const RecordDecl *RD = RT->getDecl(); 162 if (RD->getTagKind() != TTK_Struct) 163 return false; 164 165 return RD->getIdentifier() == &Ctx.Idents.get("__CFString"); 166} 167 168//===----------------------------------------------------------------------===// 169// Attribute Implementations 170//===----------------------------------------------------------------------===// 171 172// FIXME: All this manual attribute parsing code is gross. At the 173// least add some helper functions to check most argument patterns (# 174// and types of args). 175 176static void HandleExtVectorTypeAttr(Scope *scope, Decl *d, 177 const AttributeList &Attr, Sema &S) { 178 TypedefDecl *tDecl = dyn_cast<TypedefDecl>(d); 179 if (tDecl == 0) { 180 S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef); 181 return; 182 } 183 184 QualType curType = tDecl->getUnderlyingType(); 185 186 Expr *sizeExpr; 187 188 // Special case where the argument is a template id. 189 if (Attr.getParameterName()) { 190 CXXScopeSpec SS; 191 UnqualifiedId id; 192 id.setIdentifier(Attr.getParameterName(), Attr.getLoc()); 193 sizeExpr = S.ActOnIdExpression(scope, SS, id, false, false).takeAs<Expr>(); 194 } else { 195 // check the attribute arguments. 196 if (Attr.getNumArgs() != 1) { 197 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 198 return; 199 } 200 sizeExpr = Attr.getArg(0); 201 } 202 203 // Instantiate/Install the vector type, and let Sema build the type for us. 204 // This will run the reguired checks. 205 QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc()); 206 if (!T.isNull()) { 207 // FIXME: preserve the old source info. 208 tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T)); 209 210 // Remember this typedef decl, we will need it later for diagnostics. 211 S.ExtVectorDecls.push_back(tDecl); 212 } 213} 214 215static void HandlePackedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 216 // check the attribute arguments. 217 if (Attr.getNumArgs() > 0) { 218 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 219 return; 220 } 221 222 if (TagDecl *TD = dyn_cast<TagDecl>(d)) 223 TD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context)); 224 else if (FieldDecl *FD = dyn_cast<FieldDecl>(d)) { 225 // If the alignment is less than or equal to 8 bits, the packed attribute 226 // has no effect. 227 if (!FD->getType()->isIncompleteType() && 228 S.Context.getTypeAlign(FD->getType()) <= 8) 229 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type) 230 << Attr.getName() << FD->getType(); 231 else 232 FD->addAttr(::new (S.Context) PackedAttr(Attr.getLoc(), S.Context)); 233 } else 234 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 235} 236 237static void HandleIBAction(Decl *d, const AttributeList &Attr, Sema &S) { 238 // check the attribute arguments. 239 if (Attr.getNumArgs() > 0) { 240 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 241 return; 242 } 243 244 // The IBAction attributes only apply to instance methods. 245 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) 246 if (MD->isInstanceMethod()) { 247 d->addAttr(::new (S.Context) IBActionAttr(Attr.getLoc(), S.Context)); 248 return; 249 } 250 251 S.Diag(Attr.getLoc(), diag::err_attribute_ibaction) << Attr.getName(); 252} 253 254static void HandleIBOutlet(Decl *d, const AttributeList &Attr, Sema &S) { 255 // check the attribute arguments. 256 if (Attr.getNumArgs() > 0) { 257 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 258 return; 259 } 260 261 // The IBOutlet attributes only apply to instance variables of 262 // Objective-C classes. 263 if (isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d)) { 264 d->addAttr(::new (S.Context) IBOutletAttr(Attr.getLoc(), S.Context)); 265 return; 266 } 267 268 S.Diag(Attr.getLoc(), diag::err_attribute_iboutlet) << Attr.getName(); 269} 270 271static void HandleIBOutletCollection(Decl *d, const AttributeList &Attr, 272 Sema &S) { 273 274 // The iboutletcollection attribute can have zero or one arguments. 275 if (Attr.getParameterName() && Attr.getNumArgs() > 0) { 276 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 277 return; 278 } 279 280 // The IBOutletCollection attributes only apply to instance variables of 281 // Objective-C classes. 282 if (!(isa<ObjCIvarDecl>(d) || isa<ObjCPropertyDecl>(d))) { 283 S.Diag(Attr.getLoc(), diag::err_attribute_iboutlet) << Attr.getName(); 284 return; 285 } 286 if (const ValueDecl *VD = dyn_cast<ValueDecl>(d)) 287 if (!VD->getType()->getAs<ObjCObjectPointerType>()) { 288 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type) 289 << VD->getType() << 0; 290 return; 291 } 292 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(d)) 293 if (!PD->getType()->getAs<ObjCObjectPointerType>()) { 294 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_object_type) 295 << PD->getType() << 1; 296 return; 297 } 298 299 IdentifierInfo *II = Attr.getParameterName(); 300 if (!II) 301 II = &S.Context.Idents.get("id"); 302 303 ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(), 304 S.getScopeForContext(d->getDeclContext()->getParent())); 305 if (!TypeRep) { 306 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II; 307 return; 308 } 309 QualType QT = TypeRep.get(); 310 // Diagnose use of non-object type in iboutletcollection attribute. 311 // FIXME. Gnu attribute extension ignores use of builtin types in 312 // attributes. So, __attribute__((iboutletcollection(char))) will be 313 // treated as __attribute__((iboutletcollection())). 314 if (!QT->isObjCIdType() && !QT->isObjCClassType() && 315 !QT->isObjCObjectType()) { 316 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II; 317 return; 318 } 319 d->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getLoc(), S.Context, 320 QT)); 321} 322 323static void HandleNonNullAttr(Decl *d, const AttributeList &Attr, Sema &S) { 324 // GCC ignores the nonnull attribute on K&R style function prototypes, so we 325 // ignore it as well 326 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) { 327 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 328 << Attr.getName() << 0 /*function*/; 329 return; 330 } 331 332 // In C++ the implicit 'this' function parameter also counts, and they are 333 // counted from one. 334 bool HasImplicitThisParam = isInstanceMethod(d); 335 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam; 336 337 // The nonnull attribute only applies to pointers. 338 llvm::SmallVector<unsigned, 10> NonNullArgs; 339 340 for (AttributeList::arg_iterator I=Attr.arg_begin(), 341 E=Attr.arg_end(); I!=E; ++I) { 342 343 344 // The argument must be an integer constant expression. 345 Expr *Ex = *I; 346 llvm::APSInt ArgNum(32); 347 if (Ex->isTypeDependent() || Ex->isValueDependent() || 348 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) { 349 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 350 << "nonnull" << Ex->getSourceRange(); 351 return; 352 } 353 354 unsigned x = (unsigned) ArgNum.getZExtValue(); 355 356 if (x < 1 || x > NumArgs) { 357 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 358 << "nonnull" << I.getArgNum() << Ex->getSourceRange(); 359 return; 360 } 361 362 --x; 363 if (HasImplicitThisParam) { 364 if (x == 0) { 365 S.Diag(Attr.getLoc(), 366 diag::err_attribute_invalid_implicit_this_argument) 367 << "nonnull" << Ex->getSourceRange(); 368 return; 369 } 370 --x; 371 } 372 373 // Is the function argument a pointer type? 374 QualType T = getFunctionOrMethodArgType(d, x); 375 if (!T->isAnyPointerType() && !T->isBlockPointerType()) { 376 // FIXME: Should also highlight argument in decl. 377 S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only) 378 << "nonnull" << Ex->getSourceRange(); 379 continue; 380 } 381 382 NonNullArgs.push_back(x); 383 } 384 385 // If no arguments were specified to __attribute__((nonnull)) then all pointer 386 // arguments have a nonnull attribute. 387 if (NonNullArgs.empty()) { 388 for (unsigned I = 0, E = getFunctionOrMethodNumArgs(d); I != E; ++I) { 389 QualType T = getFunctionOrMethodArgType(d, I); 390 if (T->isAnyPointerType() || T->isBlockPointerType()) 391 NonNullArgs.push_back(I); 392 else if (const RecordType *UT = T->getAsUnionType()) { 393 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) { 394 RecordDecl *UD = UT->getDecl(); 395 for (RecordDecl::field_iterator it = UD->field_begin(), 396 itend = UD->field_end(); it != itend; ++it) { 397 T = it->getType(); 398 if (T->isAnyPointerType() || T->isBlockPointerType()) { 399 NonNullArgs.push_back(I); 400 break; 401 } 402 } 403 } 404 } 405 } 406 407 // No pointer arguments? 408 if (NonNullArgs.empty()) { 409 // Warn the trivial case only if attribute is not coming from a 410 // macro instantiation. 411 if (Attr.getLoc().isFileID()) 412 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers); 413 return; 414 } 415 } 416 417 unsigned* start = &NonNullArgs[0]; 418 unsigned size = NonNullArgs.size(); 419 llvm::array_pod_sort(start, start + size); 420 d->addAttr(::new (S.Context) NonNullAttr(Attr.getLoc(), S.Context, start, 421 size)); 422} 423 424static void HandleOwnershipAttr(Decl *d, const AttributeList &AL, Sema &S) { 425 // This attribute must be applied to a function declaration. 426 // The first argument to the attribute must be a string, 427 // the name of the resource, for example "malloc". 428 // The following arguments must be argument indexes, the arguments must be 429 // of integer type for Returns, otherwise of pointer type. 430 // The difference between Holds and Takes is that a pointer may still be used 431 // after being held. free() should be __attribute((ownership_takes)), whereas 432 // a list append function may well be __attribute((ownership_holds)). 433 434 if (!AL.getParameterName()) { 435 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string) 436 << AL.getName()->getName() << 1; 437 return; 438 } 439 // Figure out our Kind, and check arguments while we're at it. 440 OwnershipAttr::OwnershipKind K; 441 switch (AL.getKind()) { 442 case AttributeList::AT_ownership_takes: 443 K = OwnershipAttr::Takes; 444 if (AL.getNumArgs() < 1) { 445 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 446 return; 447 } 448 break; 449 case AttributeList::AT_ownership_holds: 450 K = OwnershipAttr::Holds; 451 if (AL.getNumArgs() < 1) { 452 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 453 return; 454 } 455 break; 456 case AttributeList::AT_ownership_returns: 457 K = OwnershipAttr::Returns; 458 if (AL.getNumArgs() > 1) { 459 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) 460 << AL.getNumArgs() + 1; 461 return; 462 } 463 break; 464 default: 465 // This should never happen given how we are called. 466 llvm_unreachable("Unknown ownership attribute"); 467 } 468 469 if (!isFunction(d) || !hasFunctionProto(d)) { 470 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL.getName() 471 << 0 /*function*/; 472 return; 473 } 474 475 // In C++ the implicit 'this' function parameter also counts, and they are 476 // counted from one. 477 bool HasImplicitThisParam = isInstanceMethod(d); 478 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam; 479 480 llvm::StringRef Module = AL.getParameterName()->getName(); 481 482 // Normalize the argument, __foo__ becomes foo. 483 if (Module.startswith("__") && Module.endswith("__")) 484 Module = Module.substr(2, Module.size() - 4); 485 486 llvm::SmallVector<unsigned, 10> OwnershipArgs; 487 488 for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E; 489 ++I) { 490 491 Expr *IdxExpr = *I; 492 llvm::APSInt ArgNum(32); 493 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() 494 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) { 495 S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int) 496 << AL.getName()->getName() << IdxExpr->getSourceRange(); 497 continue; 498 } 499 500 unsigned x = (unsigned) ArgNum.getZExtValue(); 501 502 if (x > NumArgs || x < 1) { 503 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 504 << AL.getName()->getName() << x << IdxExpr->getSourceRange(); 505 continue; 506 } 507 --x; 508 if (HasImplicitThisParam) { 509 if (x == 0) { 510 S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument) 511 << "ownership" << IdxExpr->getSourceRange(); 512 return; 513 } 514 --x; 515 } 516 517 switch (K) { 518 case OwnershipAttr::Takes: 519 case OwnershipAttr::Holds: { 520 // Is the function argument a pointer type? 521 QualType T = getFunctionOrMethodArgType(d, x); 522 if (!T->isAnyPointerType() && !T->isBlockPointerType()) { 523 // FIXME: Should also highlight argument in decl. 524 S.Diag(AL.getLoc(), diag::err_ownership_type) 525 << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds") 526 << "pointer" 527 << IdxExpr->getSourceRange(); 528 continue; 529 } 530 break; 531 } 532 case OwnershipAttr::Returns: { 533 if (AL.getNumArgs() > 1) { 534 // Is the function argument an integer type? 535 Expr *IdxExpr = AL.getArg(0); 536 llvm::APSInt ArgNum(32); 537 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() 538 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) { 539 S.Diag(AL.getLoc(), diag::err_ownership_type) 540 << "ownership_returns" << "integer" 541 << IdxExpr->getSourceRange(); 542 return; 543 } 544 } 545 break; 546 } 547 default: 548 llvm_unreachable("Unknown ownership attribute"); 549 } // switch 550 551 // Check we don't have a conflict with another ownership attribute. 552 for (specific_attr_iterator<OwnershipAttr> 553 i = d->specific_attr_begin<OwnershipAttr>(), 554 e = d->specific_attr_end<OwnershipAttr>(); 555 i != e; ++i) { 556 if ((*i)->getOwnKind() != K) { 557 for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end(); 558 I!=E; ++I) { 559 if (x == *I) { 560 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) 561 << AL.getName()->getName() << "ownership_*"; 562 } 563 } 564 } 565 } 566 OwnershipArgs.push_back(x); 567 } 568 569 unsigned* start = OwnershipArgs.data(); 570 unsigned size = OwnershipArgs.size(); 571 llvm::array_pod_sort(start, start + size); 572 573 if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) { 574 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 575 return; 576 } 577 578 d->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module, 579 start, size)); 580} 581 582static bool isStaticVarOrStaticFunciton(Decl *D) { 583 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 584 return VD->getStorageClass() == SC_Static; 585 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 586 return FD->getStorageClass() == SC_Static; 587 return false; 588} 589 590static void HandleWeakRefAttr(Decl *d, const AttributeList &Attr, Sema &S) { 591 // Check the attribute arguments. 592 if (Attr.getNumArgs() > 1) { 593 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 594 return; 595 } 596 597 // gcc rejects 598 // class c { 599 // static int a __attribute__((weakref ("v2"))); 600 // static int b() __attribute__((weakref ("f3"))); 601 // }; 602 // and ignores the attributes of 603 // void f(void) { 604 // static int a __attribute__((weakref ("v2"))); 605 // } 606 // we reject them 607 const DeclContext *Ctx = d->getDeclContext()->getRedeclContext(); 608 if (!Ctx->isFileContext()) { 609 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) << 610 dyn_cast<NamedDecl>(d)->getNameAsString(); 611 return; 612 } 613 614 // The GCC manual says 615 // 616 // At present, a declaration to which `weakref' is attached can only 617 // be `static'. 618 // 619 // It also says 620 // 621 // Without a TARGET, 622 // given as an argument to `weakref' or to `alias', `weakref' is 623 // equivalent to `weak'. 624 // 625 // gcc 4.4.1 will accept 626 // int a7 __attribute__((weakref)); 627 // as 628 // int a7 __attribute__((weak)); 629 // This looks like a bug in gcc. We reject that for now. We should revisit 630 // it if this behaviour is actually used. 631 632 if (!isStaticVarOrStaticFunciton(d)) { 633 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static) << 634 dyn_cast<NamedDecl>(d)->getNameAsString(); 635 return; 636 } 637 638 // GCC rejects 639 // static ((alias ("y"), weakref)). 640 // Should we? How to check that weakref is before or after alias? 641 642 if (Attr.getNumArgs() == 1) { 643 Expr *Arg = Attr.getArg(0); 644 Arg = Arg->IgnoreParenCasts(); 645 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 646 647 if (Str == 0 || Str->isWide()) { 648 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 649 << "weakref" << 1; 650 return; 651 } 652 // GCC will accept anything as the argument of weakref. Should we 653 // check for an existing decl? 654 d->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context, 655 Str->getString())); 656 } 657 658 d->addAttr(::new (S.Context) WeakRefAttr(Attr.getLoc(), S.Context)); 659} 660 661static void HandleAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) { 662 // check the attribute arguments. 663 if (Attr.getNumArgs() != 1) { 664 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 665 return; 666 } 667 668 Expr *Arg = Attr.getArg(0); 669 Arg = Arg->IgnoreParenCasts(); 670 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 671 672 if (Str == 0 || Str->isWide()) { 673 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 674 << "alias" << 1; 675 return; 676 } 677 678 // FIXME: check if target symbol exists in current file 679 680 d->addAttr(::new (S.Context) AliasAttr(Attr.getLoc(), S.Context, 681 Str->getString())); 682} 683 684static void HandleNakedAttr(Decl *d, const AttributeList &Attr, 685 Sema &S) { 686 // Check the attribute arguments. 687 if (Attr.getNumArgs() != 0) { 688 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 689 return; 690 } 691 692 if (!isa<FunctionDecl>(d)) { 693 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 694 << Attr.getName() << 0 /*function*/; 695 return; 696 } 697 698 d->addAttr(::new (S.Context) NakedAttr(Attr.getLoc(), S.Context)); 699} 700 701static void HandleAlwaysInlineAttr(Decl *d, const AttributeList &Attr, 702 Sema &S) { 703 // Check the attribute arguments. 704 if (Attr.getNumArgs() != 0) { 705 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 706 return; 707 } 708 709 if (!isa<FunctionDecl>(d)) { 710 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 711 << Attr.getName() << 0 /*function*/; 712 return; 713 } 714 715 d->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getLoc(), S.Context)); 716} 717 718static void HandleMallocAttr(Decl *d, const AttributeList &Attr, Sema &S) { 719 // Check the attribute arguments. 720 if (Attr.getNumArgs() != 0) { 721 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 722 return; 723 } 724 725 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) { 726 QualType RetTy = FD->getResultType(); 727 if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) { 728 d->addAttr(::new (S.Context) MallocAttr(Attr.getLoc(), S.Context)); 729 return; 730 } 731 } 732 733 S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only); 734} 735 736static void HandleMayAliasAttr(Decl *d, const AttributeList &Attr, Sema &S) { 737 // check the attribute arguments. 738 if (Attr.getNumArgs() != 0) { 739 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 740 return; 741 } 742 743 d->addAttr(::new (S.Context) MayAliasAttr(Attr.getLoc(), S.Context)); 744} 745 746static void HandleNoCommonAttr(Decl *d, const AttributeList &Attr, Sema &S) { 747 assert(Attr.isInvalid() == false); 748 if (isa<VarDecl>(d)) 749 d->addAttr(::new (S.Context) NoCommonAttr(Attr.getLoc(), S.Context)); 750 else 751 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 752 << Attr.getName() << 12 /* variable */; 753} 754 755static void HandleCommonAttr(Decl *d, const AttributeList &Attr, Sema &S) { 756 assert(Attr.isInvalid() == false); 757 if (isa<VarDecl>(d)) 758 d->addAttr(::new (S.Context) CommonAttr(Attr.getLoc(), S.Context)); 759 else 760 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 761 << Attr.getName() << 12 /* variable */; 762} 763 764static void HandleNoReturnAttr(Decl *d, const AttributeList &Attr, Sema &S) { 765 /* Diagnostics (if any) was emitted by Sema::ProcessFnAttr(). */ 766 assert(Attr.isInvalid() == false); 767 d->addAttr(::new (S.Context) NoReturnAttr(Attr.getLoc(), S.Context)); 768} 769 770static void HandleAnalyzerNoReturnAttr(Decl *d, const AttributeList &Attr, 771 Sema &S) { 772 773 // The checking path for 'noreturn' and 'analyzer_noreturn' are different 774 // because 'analyzer_noreturn' does not impact the type. 775 776 if (Attr.getNumArgs() != 0) { 777 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 778 return; 779 } 780 781 if (!isFunctionOrMethod(d) && !isa<BlockDecl>(d)) { 782 ValueDecl *VD = dyn_cast<ValueDecl>(d); 783 if (VD == 0 || (!VD->getType()->isBlockPointerType() 784 && !VD->getType()->isFunctionPointerType())) { 785 S.Diag(Attr.getLoc(), 786 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 787 : diag::warn_attribute_wrong_decl_type) 788 << Attr.getName() << 0 /*function*/; 789 return; 790 } 791 } 792 793 d->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getLoc(), S.Context)); 794} 795 796// PS3 PPU-specific. 797static void HandleVecReturnAttr(Decl *d, const AttributeList &Attr, 798 Sema &S) { 799/* 800 Returning a Vector Class in Registers 801 802 According to the PPU ABI specifications, a class with a single member of 803 vector type is returned in memory when used as the return value of a function. 804 This results in inefficient code when implementing vector classes. To return 805 the value in a single vector register, add the vecreturn attribute to the 806 class definition. This attribute is also applicable to struct types. 807 808 Example: 809 810 struct Vector 811 { 812 __vector float xyzw; 813 } __attribute__((vecreturn)); 814 815 Vector Add(Vector lhs, Vector rhs) 816 { 817 Vector result; 818 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw); 819 return result; // This will be returned in a register 820 } 821*/ 822 if (!isa<RecordDecl>(d)) { 823 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 824 << Attr.getName() << 9 /*class*/; 825 return; 826 } 827 828 if (d->getAttr<VecReturnAttr>()) { 829 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn"; 830 return; 831 } 832 833 RecordDecl *record = cast<RecordDecl>(d); 834 int count = 0; 835 836 if (!isa<CXXRecordDecl>(record)) { 837 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 838 return; 839 } 840 841 if (!cast<CXXRecordDecl>(record)->isPOD()) { 842 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record); 843 return; 844 } 845 846 for (RecordDecl::field_iterator iter = record->field_begin(); 847 iter != record->field_end(); iter++) { 848 if ((count == 1) || !iter->getType()->isVectorType()) { 849 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 850 return; 851 } 852 count++; 853 } 854 855 d->addAttr(::new (S.Context) VecReturnAttr(Attr.getLoc(), S.Context)); 856} 857 858static void HandleDependencyAttr(Decl *d, const AttributeList &Attr, Sema &S) { 859 if (!isFunctionOrMethod(d) && !isa<ParmVarDecl>(d)) { 860 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 861 << Attr.getName() << 8 /*function, method, or parameter*/; 862 return; 863 } 864 // FIXME: Actually store the attribute on the declaration 865} 866 867static void HandleUnusedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 868 // check the attribute arguments. 869 if (Attr.getNumArgs() != 0) { 870 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 871 return; 872 } 873 874 if (!isa<VarDecl>(d) && !isa<ObjCIvarDecl>(d) && !isFunctionOrMethod(d) && 875 !isa<TypeDecl>(d)) { 876 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 877 << Attr.getName() << 2 /*variable and function*/; 878 return; 879 } 880 881 d->addAttr(::new (S.Context) UnusedAttr(Attr.getLoc(), S.Context)); 882} 883 884static void HandleUsedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 885 // check the attribute arguments. 886 if (Attr.getNumArgs() != 0) { 887 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 888 return; 889 } 890 891 if (const VarDecl *VD = dyn_cast<VarDecl>(d)) { 892 if (VD->hasLocalStorage() || VD->hasExternalStorage()) { 893 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used"; 894 return; 895 } 896 } else if (!isFunctionOrMethod(d)) { 897 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 898 << Attr.getName() << 2 /*variable and function*/; 899 return; 900 } 901 902 d->addAttr(::new (S.Context) UsedAttr(Attr.getLoc(), S.Context)); 903} 904 905static void HandleConstructorAttr(Decl *d, const AttributeList &Attr, Sema &S) { 906 // check the attribute arguments. 907 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) { 908 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 909 << "0 or 1"; 910 return; 911 } 912 913 int priority = 65535; // FIXME: Do not hardcode such constants. 914 if (Attr.getNumArgs() > 0) { 915 Expr *E = Attr.getArg(0); 916 llvm::APSInt Idx(32); 917 if (E->isTypeDependent() || E->isValueDependent() || 918 !E->isIntegerConstantExpr(Idx, S.Context)) { 919 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 920 << "constructor" << 1 << E->getSourceRange(); 921 return; 922 } 923 priority = Idx.getZExtValue(); 924 } 925 926 if (!isa<FunctionDecl>(d)) { 927 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 928 << Attr.getName() << 0 /*function*/; 929 return; 930 } 931 932 d->addAttr(::new (S.Context) ConstructorAttr(Attr.getLoc(), S.Context, 933 priority)); 934} 935 936static void HandleDestructorAttr(Decl *d, const AttributeList &Attr, Sema &S) { 937 // check the attribute arguments. 938 if (Attr.getNumArgs() != 0 && Attr.getNumArgs() != 1) { 939 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 940 << "0 or 1"; 941 return; 942 } 943 944 int priority = 65535; // FIXME: Do not hardcode such constants. 945 if (Attr.getNumArgs() > 0) { 946 Expr *E = Attr.getArg(0); 947 llvm::APSInt Idx(32); 948 if (E->isTypeDependent() || E->isValueDependent() || 949 !E->isIntegerConstantExpr(Idx, S.Context)) { 950 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 951 << "destructor" << 1 << E->getSourceRange(); 952 return; 953 } 954 priority = Idx.getZExtValue(); 955 } 956 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 d->addAttr(::new (S.Context) DestructorAttr(Attr.getLoc(), S.Context, 964 priority)); 965} 966 967static void HandleDeprecatedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 968 // check the attribute arguments. 969 int noArgs = Attr.getNumArgs(); 970 if (noArgs > 1) { 971 S.Diag(Attr.getLoc(), 972 diag::err_attribute_wrong_number_arguments) << "0 or 1"; 973 return; 974 } 975 // Handle the case where deprecated attribute has a text message. 976 StringLiteral *SE; 977 if (noArgs == 1) { 978 Expr *ArgExpr = Attr.getArg(0); 979 SE = dyn_cast<StringLiteral>(ArgExpr); 980 if (!SE) { 981 S.Diag(ArgExpr->getLocStart(), 982 diag::err_attribute_not_string) << "deprecated"; 983 return; 984 } 985 } 986 else 987 SE = StringLiteral::CreateEmpty(S.Context, 1); 988 989 d->addAttr(::new (S.Context) DeprecatedAttr(Attr.getLoc(), S.Context, 990 SE->getString())); 991} 992 993static void HandleUnavailableAttr(Decl *d, const AttributeList &Attr, Sema &S) { 994 // check the attribute arguments. 995 int noArgs = Attr.getNumArgs(); 996 if (noArgs > 1) { 997 S.Diag(Attr.getLoc(), 998 diag::err_attribute_wrong_number_arguments) << "0 or 1"; 999 return; 1000 } 1001 // Handle the case where unavailable attribute has a text message. 1002 StringLiteral *SE; 1003 if (noArgs == 1) { 1004 Expr *ArgExpr = Attr.getArg(0); 1005 SE = dyn_cast<StringLiteral>(ArgExpr); 1006 if (!SE) { 1007 S.Diag(ArgExpr->getLocStart(), 1008 diag::err_attribute_not_string) << "unavailable"; 1009 return; 1010 } 1011 } 1012 else 1013 SE = StringLiteral::CreateEmpty(S.Context, 1); 1014 d->addAttr(::new (S.Context) UnavailableAttr(Attr.getLoc(), S.Context, 1015 SE->getString())); 1016} 1017 1018static void HandleVisibilityAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1019 // check the attribute arguments. 1020 if (Attr.getNumArgs() != 1) { 1021 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1022 return; 1023 } 1024 1025 Expr *Arg = Attr.getArg(0); 1026 Arg = Arg->IgnoreParenCasts(); 1027 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 1028 1029 if (Str == 0 || Str->isWide()) { 1030 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1031 << "visibility" << 1; 1032 return; 1033 } 1034 1035 llvm::StringRef TypeStr = Str->getString(); 1036 VisibilityAttr::VisibilityType type; 1037 1038 if (TypeStr == "default") 1039 type = VisibilityAttr::Default; 1040 else if (TypeStr == "hidden") 1041 type = VisibilityAttr::Hidden; 1042 else if (TypeStr == "internal") 1043 type = VisibilityAttr::Hidden; // FIXME 1044 else if (TypeStr == "protected") 1045 type = VisibilityAttr::Protected; 1046 else { 1047 S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr; 1048 return; 1049 } 1050 1051 d->addAttr(::new (S.Context) VisibilityAttr(Attr.getLoc(), S.Context, type)); 1052} 1053 1054static void HandleObjCExceptionAttr(Decl *D, const AttributeList &Attr, 1055 Sema &S) { 1056 if (Attr.getNumArgs() != 0) { 1057 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1058 return; 1059 } 1060 1061 ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D); 1062 if (OCI == 0) { 1063 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface); 1064 return; 1065 } 1066 1067 D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getLoc(), S.Context)); 1068} 1069 1070static void HandleObjCNSObject(Decl *D, const AttributeList &Attr, Sema &S) { 1071 if (Attr.getNumArgs() != 0) { 1072 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1073 return; 1074 } 1075 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { 1076 QualType T = TD->getUnderlyingType(); 1077 if (!T->isPointerType() || 1078 !T->getAs<PointerType>()->getPointeeType()->isRecordType()) { 1079 S.Diag(TD->getLocation(), diag::err_nsobject_attribute); 1080 return; 1081 } 1082 } 1083 D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getLoc(), S.Context)); 1084} 1085 1086static void 1087HandleOverloadableAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1088 if (Attr.getNumArgs() != 0) { 1089 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1090 return; 1091 } 1092 1093 if (!isa<FunctionDecl>(D)) { 1094 S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function); 1095 return; 1096 } 1097 1098 D->addAttr(::new (S.Context) OverloadableAttr(Attr.getLoc(), S.Context)); 1099} 1100 1101static void HandleBlocksAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1102 if (!Attr.getParameterName()) { 1103 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1104 << "blocks" << 1; 1105 return; 1106 } 1107 1108 if (Attr.getNumArgs() != 0) { 1109 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1110 return; 1111 } 1112 1113 BlocksAttr::BlockType type; 1114 if (Attr.getParameterName()->isStr("byref")) 1115 type = BlocksAttr::ByRef; 1116 else { 1117 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 1118 << "blocks" << Attr.getParameterName(); 1119 return; 1120 } 1121 1122 d->addAttr(::new (S.Context) BlocksAttr(Attr.getLoc(), S.Context, type)); 1123} 1124 1125static void HandleSentinelAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1126 // check the attribute arguments. 1127 if (Attr.getNumArgs() > 2) { 1128 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 1129 << "0, 1 or 2"; 1130 return; 1131 } 1132 1133 int sentinel = 0; 1134 if (Attr.getNumArgs() > 0) { 1135 Expr *E = Attr.getArg(0); 1136 llvm::APSInt Idx(32); 1137 if (E->isTypeDependent() || E->isValueDependent() || 1138 !E->isIntegerConstantExpr(Idx, S.Context)) { 1139 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1140 << "sentinel" << 1 << E->getSourceRange(); 1141 return; 1142 } 1143 sentinel = Idx.getZExtValue(); 1144 1145 if (sentinel < 0) { 1146 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero) 1147 << E->getSourceRange(); 1148 return; 1149 } 1150 } 1151 1152 int nullPos = 0; 1153 if (Attr.getNumArgs() > 1) { 1154 Expr *E = Attr.getArg(1); 1155 llvm::APSInt Idx(32); 1156 if (E->isTypeDependent() || E->isValueDependent() || 1157 !E->isIntegerConstantExpr(Idx, S.Context)) { 1158 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1159 << "sentinel" << 2 << E->getSourceRange(); 1160 return; 1161 } 1162 nullPos = Idx.getZExtValue(); 1163 1164 if (nullPos > 1 || nullPos < 0) { 1165 // FIXME: This error message could be improved, it would be nice 1166 // to say what the bounds actually are. 1167 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one) 1168 << E->getSourceRange(); 1169 return; 1170 } 1171 } 1172 1173 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) { 1174 const FunctionType *FT = FD->getType()->getAs<FunctionType>(); 1175 assert(FT && "FunctionDecl has non-function type?"); 1176 1177 if (isa<FunctionNoProtoType>(FT)) { 1178 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments); 1179 return; 1180 } 1181 1182 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 1183 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 1184 return; 1185 } 1186 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) { 1187 if (!MD->isVariadic()) { 1188 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 1189 return; 1190 } 1191 } else if (isa<BlockDecl>(d)) { 1192 // Note! BlockDecl is typeless. Variadic diagnostics will be issued by the 1193 // caller. 1194 ; 1195 } else if (const VarDecl *V = dyn_cast<VarDecl>(d)) { 1196 QualType Ty = V->getType(); 1197 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 1198 const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(d) 1199 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 1200 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 1201 int m = Ty->isFunctionPointerType() ? 0 : 1; 1202 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m; 1203 return; 1204 } 1205 } else { 1206 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1207 << Attr.getName() << 6 /*function, method or block */; 1208 return; 1209 } 1210 } else { 1211 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1212 << Attr.getName() << 6 /*function, method or block */; 1213 return; 1214 } 1215 d->addAttr(::new (S.Context) SentinelAttr(Attr.getLoc(), S.Context, sentinel, 1216 nullPos)); 1217} 1218 1219static void HandleWarnUnusedResult(Decl *D, const AttributeList &Attr, Sema &S) { 1220 // check the attribute arguments. 1221 if (Attr.getNumArgs() != 0) { 1222 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1223 return; 1224 } 1225 1226 if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) { 1227 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1228 << Attr.getName() << 0 /*function*/; 1229 return; 1230 } 1231 1232 if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) { 1233 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method) 1234 << Attr.getName() << 0; 1235 return; 1236 } 1237 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 1238 if (MD->getResultType()->isVoidType()) { 1239 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method) 1240 << Attr.getName() << 1; 1241 return; 1242 } 1243 1244 D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getLoc(), S.Context)); 1245} 1246 1247static void HandleWeakAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1248 // check the attribute arguments. 1249 if (Attr.getNumArgs() != 0) { 1250 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1251 return; 1252 } 1253 1254 /* weak only applies to non-static declarations */ 1255 if (isStaticVarOrStaticFunciton(D)) { 1256 S.Diag(Attr.getLoc(), diag::err_attribute_weak_static) << 1257 dyn_cast<NamedDecl>(D)->getNameAsString(); 1258 return; 1259 } 1260 1261 // TODO: could also be applied to methods? 1262 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) { 1263 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1264 << Attr.getName() << 2 /*variable and function*/; 1265 return; 1266 } 1267 1268 D->addAttr(::new (S.Context) WeakAttr(Attr.getLoc(), S.Context)); 1269} 1270 1271static void HandleWeakImportAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1272 // check the attribute arguments. 1273 if (Attr.getNumArgs() != 0) { 1274 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1275 return; 1276 } 1277 1278 // weak_import only applies to variable & function declarations. 1279 bool isDef = false; 1280 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 1281 isDef = (!VD->hasExternalStorage() || VD->getInit()); 1282 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1283 isDef = FD->hasBody(); 1284 } else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D)) { 1285 // We ignore weak import on properties and methods 1286 return; 1287 } else if (!(S.LangOpts.ObjCNonFragileABI && isa<ObjCInterfaceDecl>(D))) { 1288 // Don't issue the warning for darwin as target; yet, ignore the attribute. 1289 if (S.Context.Target.getTriple().getOS() != llvm::Triple::Darwin || 1290 !isa<ObjCInterfaceDecl>(D)) 1291 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1292 << Attr.getName() << 2 /*variable and function*/; 1293 return; 1294 } 1295 1296 // Merge should handle any subsequent violations. 1297 if (isDef) { 1298 S.Diag(Attr.getLoc(), 1299 diag::warn_attribute_weak_import_invalid_on_definition) 1300 << "weak_import" << 2 /*variable and function*/; 1301 return; 1302 } 1303 1304 D->addAttr(::new (S.Context) WeakImportAttr(Attr.getLoc(), S.Context)); 1305} 1306 1307static void HandleReqdWorkGroupSize(Decl *D, const AttributeList &Attr, 1308 Sema &S) { 1309 // Attribute has 3 arguments. 1310 if (Attr.getNumArgs() != 3) { 1311 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1312 return; 1313 } 1314 1315 unsigned WGSize[3]; 1316 for (unsigned i = 0; i < 3; ++i) { 1317 Expr *E = Attr.getArg(i); 1318 llvm::APSInt ArgNum(32); 1319 if (E->isTypeDependent() || E->isValueDependent() || 1320 !E->isIntegerConstantExpr(ArgNum, S.Context)) { 1321 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1322 << "reqd_work_group_size" << E->getSourceRange(); 1323 return; 1324 } 1325 WGSize[i] = (unsigned) ArgNum.getZExtValue(); 1326 } 1327 D->addAttr(::new (S.Context) ReqdWorkGroupSizeAttr(Attr.getLoc(), S.Context, 1328 WGSize[0], WGSize[1], 1329 WGSize[2])); 1330} 1331 1332static void HandleSectionAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1333 // Attribute has no arguments. 1334 if (Attr.getNumArgs() != 1) { 1335 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1336 return; 1337 } 1338 1339 // Make sure that there is a string literal as the sections's single 1340 // argument. 1341 Expr *ArgExpr = Attr.getArg(0); 1342 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 1343 if (!SE) { 1344 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section"; 1345 return; 1346 } 1347 1348 // If the target wants to validate the section specifier, make it happen. 1349 std::string Error = S.Context.Target.isValidSectionSpecifier(SE->getString()); 1350 if (!Error.empty()) { 1351 S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target) 1352 << Error; 1353 return; 1354 } 1355 1356 // This attribute cannot be applied to local variables. 1357 if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) { 1358 S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable); 1359 return; 1360 } 1361 1362 D->addAttr(::new (S.Context) SectionAttr(Attr.getLoc(), S.Context, 1363 SE->getString())); 1364} 1365 1366 1367static void HandleNothrowAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1368 // check the attribute arguments. 1369 if (Attr.getNumArgs() != 0) { 1370 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1371 return; 1372 } 1373 1374 d->addAttr(::new (S.Context) NoThrowAttr(Attr.getLoc(), S.Context)); 1375} 1376 1377static void HandleConstAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1378 // check the attribute arguments. 1379 if (Attr.getNumArgs() != 0) { 1380 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1381 return; 1382 } 1383 1384 d->addAttr(::new (S.Context) ConstAttr(Attr.getLoc(), S.Context)); 1385} 1386 1387static void HandlePureAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1388 // check the attribute arguments. 1389 if (Attr.getNumArgs() != 0) { 1390 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1391 return; 1392 } 1393 1394 d->addAttr(::new (S.Context) PureAttr(Attr.getLoc(), S.Context)); 1395} 1396 1397static void HandleCleanupAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1398 if (!Attr.getParameterName()) { 1399 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1400 return; 1401 } 1402 1403 if (Attr.getNumArgs() != 0) { 1404 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1405 return; 1406 } 1407 1408 VarDecl *VD = dyn_cast<VarDecl>(d); 1409 1410 if (!VD || !VD->hasLocalStorage()) { 1411 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup"; 1412 return; 1413 } 1414 1415 // Look up the function 1416 // FIXME: Lookup probably isn't looking in the right place 1417 // FIXME: The lookup source location should be in the attribute, not the 1418 // start of the attribute. 1419 NamedDecl *CleanupDecl 1420 = S.LookupSingleName(S.TUScope, Attr.getParameterName(), Attr.getLoc(), 1421 Sema::LookupOrdinaryName); 1422 if (!CleanupDecl) { 1423 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_found) << 1424 Attr.getParameterName(); 1425 return; 1426 } 1427 1428 FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl); 1429 if (!FD) { 1430 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_arg_not_function) << 1431 Attr.getParameterName(); 1432 return; 1433 } 1434 1435 if (FD->getNumParams() != 1) { 1436 S.Diag(Attr.getLoc(), diag::err_attribute_cleanup_func_must_take_one_arg) << 1437 Attr.getParameterName(); 1438 return; 1439 } 1440 1441 // We're currently more strict than GCC about what function types we accept. 1442 // If this ever proves to be a problem it should be easy to fix. 1443 QualType Ty = S.Context.getPointerType(VD->getType()); 1444 QualType ParamTy = FD->getParamDecl(0)->getType(); 1445 if (S.CheckAssignmentConstraints(ParamTy, Ty) != Sema::Compatible) { 1446 S.Diag(Attr.getLoc(), 1447 diag::err_attribute_cleanup_func_arg_incompatible_type) << 1448 Attr.getParameterName() << ParamTy << Ty; 1449 return; 1450 } 1451 1452 d->addAttr(::new (S.Context) CleanupAttr(Attr.getLoc(), S.Context, FD)); 1453} 1454 1455/// Handle __attribute__((format_arg((idx)))) attribute based on 1456/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 1457static void HandleFormatArgAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1458 if (Attr.getNumArgs() != 1) { 1459 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1460 return; 1461 } 1462 if (!isFunctionOrMethod(d) || !hasFunctionProto(d)) { 1463 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1464 << Attr.getName() << 0 /*function*/; 1465 return; 1466 } 1467 1468 // In C++ the implicit 'this' function parameter also counts, and they are 1469 // counted from one. 1470 bool HasImplicitThisParam = isInstanceMethod(d); 1471 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam; 1472 unsigned FirstIdx = 1; 1473 1474 // checks for the 2nd argument 1475 Expr *IdxExpr = Attr.getArg(0); 1476 llvm::APSInt Idx(32); 1477 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 1478 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 1479 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1480 << "format" << 2 << IdxExpr->getSourceRange(); 1481 return; 1482 } 1483 1484 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 1485 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1486 << "format" << 2 << IdxExpr->getSourceRange(); 1487 return; 1488 } 1489 1490 unsigned ArgIdx = Idx.getZExtValue() - 1; 1491 1492 if (HasImplicitThisParam) { 1493 if (ArgIdx == 0) { 1494 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument) 1495 << "format_arg" << IdxExpr->getSourceRange(); 1496 return; 1497 } 1498 ArgIdx--; 1499 } 1500 1501 // make sure the format string is really a string 1502 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx); 1503 1504 bool not_nsstring_type = !isNSStringType(Ty, S.Context); 1505 if (not_nsstring_type && 1506 !isCFStringType(Ty, S.Context) && 1507 (!Ty->isPointerType() || 1508 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 1509 // FIXME: Should highlight the actual expression that has the wrong type. 1510 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1511 << (not_nsstring_type ? "a string type" : "an NSString") 1512 << IdxExpr->getSourceRange(); 1513 return; 1514 } 1515 Ty = getFunctionOrMethodResultType(d); 1516 if (!isNSStringType(Ty, S.Context) && 1517 !isCFStringType(Ty, S.Context) && 1518 (!Ty->isPointerType() || 1519 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 1520 // FIXME: Should highlight the actual expression that has the wrong type. 1521 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not) 1522 << (not_nsstring_type ? "string type" : "NSString") 1523 << IdxExpr->getSourceRange(); 1524 return; 1525 } 1526 1527 d->addAttr(::new (S.Context) FormatArgAttr(Attr.getLoc(), S.Context, 1528 Idx.getZExtValue())); 1529} 1530 1531enum FormatAttrKind { 1532 CFStringFormat, 1533 NSStringFormat, 1534 StrftimeFormat, 1535 SupportedFormat, 1536 IgnoredFormat, 1537 InvalidFormat 1538}; 1539 1540/// getFormatAttrKind - Map from format attribute names to supported format 1541/// types. 1542static FormatAttrKind getFormatAttrKind(llvm::StringRef Format) { 1543 // Check for formats that get handled specially. 1544 if (Format == "NSString") 1545 return NSStringFormat; 1546 if (Format == "CFString") 1547 return CFStringFormat; 1548 if (Format == "strftime") 1549 return StrftimeFormat; 1550 1551 // Otherwise, check for supported formats. 1552 if (Format == "scanf" || Format == "printf" || Format == "printf0" || 1553 Format == "strfmon" || Format == "cmn_err" || Format == "strftime" || 1554 Format == "NSString" || Format == "CFString" || Format == "vcmn_err" || 1555 Format == "zcmn_err") 1556 return SupportedFormat; 1557 1558 if (Format == "gcc_diag" || Format == "gcc_cdiag" || 1559 Format == "gcc_cxxdiag" || Format == "gcc_tdiag") 1560 return IgnoredFormat; 1561 1562 return InvalidFormat; 1563} 1564 1565/// Handle __attribute__((init_priority(priority))) attributes based on 1566/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html 1567static void HandleInitPriorityAttr(Decl *d, const AttributeList &Attr, 1568 Sema &S) { 1569 if (!S.getLangOptions().CPlusPlus) { 1570 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 1571 return; 1572 } 1573 1574 if (!isa<VarDecl>(d) || S.getCurFunctionOrMethodDecl()) { 1575 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr); 1576 Attr.setInvalid(); 1577 return; 1578 } 1579 QualType T = dyn_cast<VarDecl>(d)->getType(); 1580 if (S.Context.getAsArrayType(T)) 1581 T = S.Context.getBaseElementType(T); 1582 if (!T->getAs<RecordType>()) { 1583 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr); 1584 Attr.setInvalid(); 1585 return; 1586 } 1587 1588 if (Attr.getNumArgs() != 1) { 1589 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1590 Attr.setInvalid(); 1591 return; 1592 } 1593 Expr *priorityExpr = Attr.getArg(0); 1594 1595 llvm::APSInt priority(32); 1596 if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() || 1597 !priorityExpr->isIntegerConstantExpr(priority, S.Context)) { 1598 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1599 << "init_priority" << priorityExpr->getSourceRange(); 1600 Attr.setInvalid(); 1601 return; 1602 } 1603 unsigned prioritynum = priority.getZExtValue(); 1604 if (prioritynum < 101 || prioritynum > 65535) { 1605 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range) 1606 << priorityExpr->getSourceRange(); 1607 Attr.setInvalid(); 1608 return; 1609 } 1610 d->addAttr(::new (S.Context) InitPriorityAttr(Attr.getLoc(), S.Context, 1611 prioritynum)); 1612} 1613 1614/// Handle __attribute__((format(type,idx,firstarg))) attributes based on 1615/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 1616static void HandleFormatAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1617 1618 if (!Attr.getParameterName()) { 1619 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1620 << "format" << 1; 1621 return; 1622 } 1623 1624 if (Attr.getNumArgs() != 2) { 1625 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3; 1626 return; 1627 } 1628 1629 if (!isFunctionOrMethodOrBlock(d) || !hasFunctionProto(d)) { 1630 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1631 << Attr.getName() << 0 /*function*/; 1632 return; 1633 } 1634 1635 // In C++ the implicit 'this' function parameter also counts, and they are 1636 // counted from one. 1637 bool HasImplicitThisParam = isInstanceMethod(d); 1638 unsigned NumArgs = getFunctionOrMethodNumArgs(d) + HasImplicitThisParam; 1639 unsigned FirstIdx = 1; 1640 1641 llvm::StringRef Format = Attr.getParameterName()->getName(); 1642 1643 // Normalize the argument, __foo__ becomes foo. 1644 if (Format.startswith("__") && Format.endswith("__")) 1645 Format = Format.substr(2, Format.size() - 4); 1646 1647 // Check for supported formats. 1648 FormatAttrKind Kind = getFormatAttrKind(Format); 1649 1650 if (Kind == IgnoredFormat) 1651 return; 1652 1653 if (Kind == InvalidFormat) { 1654 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 1655 << "format" << Attr.getParameterName()->getName(); 1656 return; 1657 } 1658 1659 // checks for the 2nd argument 1660 Expr *IdxExpr = Attr.getArg(0); 1661 llvm::APSInt Idx(32); 1662 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 1663 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 1664 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1665 << "format" << 2 << IdxExpr->getSourceRange(); 1666 return; 1667 } 1668 1669 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 1670 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1671 << "format" << 2 << IdxExpr->getSourceRange(); 1672 return; 1673 } 1674 1675 // FIXME: Do we need to bounds check? 1676 unsigned ArgIdx = Idx.getZExtValue() - 1; 1677 1678 if (HasImplicitThisParam) { 1679 if (ArgIdx == 0) { 1680 S.Diag(Attr.getLoc(), 1681 diag::err_format_attribute_implicit_this_format_string) 1682 << IdxExpr->getSourceRange(); 1683 return; 1684 } 1685 ArgIdx--; 1686 } 1687 1688 // make sure the format string is really a string 1689 QualType Ty = getFunctionOrMethodArgType(d, ArgIdx); 1690 1691 if (Kind == CFStringFormat) { 1692 if (!isCFStringType(Ty, S.Context)) { 1693 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1694 << "a CFString" << IdxExpr->getSourceRange(); 1695 return; 1696 } 1697 } else if (Kind == NSStringFormat) { 1698 // FIXME: do we need to check if the type is NSString*? What are the 1699 // semantics? 1700 if (!isNSStringType(Ty, S.Context)) { 1701 // FIXME: Should highlight the actual expression that has the wrong type. 1702 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1703 << "an NSString" << IdxExpr->getSourceRange(); 1704 return; 1705 } 1706 } else if (!Ty->isPointerType() || 1707 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) { 1708 // FIXME: Should highlight the actual expression that has the wrong type. 1709 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 1710 << "a string type" << IdxExpr->getSourceRange(); 1711 return; 1712 } 1713 1714 // check the 3rd argument 1715 Expr *FirstArgExpr = Attr.getArg(1); 1716 llvm::APSInt FirstArg(32); 1717 if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() || 1718 !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) { 1719 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1720 << "format" << 3 << FirstArgExpr->getSourceRange(); 1721 return; 1722 } 1723 1724 // check if the function is variadic if the 3rd argument non-zero 1725 if (FirstArg != 0) { 1726 if (isFunctionOrMethodVariadic(d)) { 1727 ++NumArgs; // +1 for ... 1728 } else { 1729 S.Diag(d->getLocation(), diag::err_format_attribute_requires_variadic); 1730 return; 1731 } 1732 } 1733 1734 // strftime requires FirstArg to be 0 because it doesn't read from any 1735 // variable the input is just the current time + the format string. 1736 if (Kind == StrftimeFormat) { 1737 if (FirstArg != 0) { 1738 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter) 1739 << FirstArgExpr->getSourceRange(); 1740 return; 1741 } 1742 // if 0 it disables parameter checking (to use with e.g. va_list) 1743 } else if (FirstArg != 0 && FirstArg != NumArgs) { 1744 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1745 << "format" << 3 << FirstArgExpr->getSourceRange(); 1746 return; 1747 } 1748 1749 d->addAttr(::new (S.Context) FormatAttr(Attr.getLoc(), S.Context, Format, 1750 Idx.getZExtValue(), 1751 FirstArg.getZExtValue())); 1752} 1753 1754static void HandleTransparentUnionAttr(Decl *d, const AttributeList &Attr, 1755 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 // Try to find the underlying union declaration. 1763 RecordDecl *RD = 0; 1764 TypedefDecl *TD = dyn_cast<TypedefDecl>(d); 1765 if (TD && TD->getUnderlyingType()->isUnionType()) 1766 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl(); 1767 else 1768 RD = dyn_cast<RecordDecl>(d); 1769 1770 if (!RD || !RD->isUnion()) { 1771 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1772 << Attr.getName() << 1 /*union*/; 1773 return; 1774 } 1775 1776 if (!RD->isDefinition()) { 1777 S.Diag(Attr.getLoc(), 1778 diag::warn_transparent_union_attribute_not_definition); 1779 return; 1780 } 1781 1782 RecordDecl::field_iterator Field = RD->field_begin(), 1783 FieldEnd = RD->field_end(); 1784 if (Field == FieldEnd) { 1785 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields); 1786 return; 1787 } 1788 1789 FieldDecl *FirstField = *Field; 1790 QualType FirstType = FirstField->getType(); 1791 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) { 1792 S.Diag(FirstField->getLocation(), 1793 diag::warn_transparent_union_attribute_floating) 1794 << FirstType->isVectorType() << FirstType; 1795 return; 1796 } 1797 1798 uint64_t FirstSize = S.Context.getTypeSize(FirstType); 1799 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType); 1800 for (; Field != FieldEnd; ++Field) { 1801 QualType FieldType = Field->getType(); 1802 if (S.Context.getTypeSize(FieldType) != FirstSize || 1803 S.Context.getTypeAlign(FieldType) != FirstAlign) { 1804 // Warn if we drop the attribute. 1805 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize; 1806 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType) 1807 : S.Context.getTypeAlign(FieldType); 1808 S.Diag(Field->getLocation(), 1809 diag::warn_transparent_union_attribute_field_size_align) 1810 << isSize << Field->getDeclName() << FieldBits; 1811 unsigned FirstBits = isSize? FirstSize : FirstAlign; 1812 S.Diag(FirstField->getLocation(), 1813 diag::note_transparent_union_first_field_size_align) 1814 << isSize << FirstBits; 1815 return; 1816 } 1817 } 1818 1819 RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getLoc(), S.Context)); 1820} 1821 1822static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) { 1823 // check the attribute arguments. 1824 if (Attr.getNumArgs() != 1) { 1825 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1826 return; 1827 } 1828 Expr *ArgExpr = Attr.getArg(0); 1829 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 1830 1831 // Make sure that there is a string literal as the annotation's single 1832 // argument. 1833 if (!SE) { 1834 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate"; 1835 return; 1836 } 1837 d->addAttr(::new (S.Context) AnnotateAttr(Attr.getLoc(), S.Context, 1838 SE->getString())); 1839} 1840 1841static void HandleAlignedAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1842 // check the attribute arguments. 1843 if (Attr.getNumArgs() > 1) { 1844 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1845 return; 1846 } 1847 1848 //FIXME: The C++0x version of this attribute has more limited applicabilty 1849 // than GNU's, and should error out when it is used to specify a 1850 // weaker alignment, rather than being silently ignored. 1851 1852 if (Attr.getNumArgs() == 0) { 1853 D->addAttr(::new (S.Context) AlignedAttr(Attr.getLoc(), S.Context, true, 0)); 1854 return; 1855 } 1856 1857 S.AddAlignedAttr(Attr.getLoc(), D, Attr.getArg(0)); 1858} 1859 1860void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, Expr *E) { 1861 if (E->isTypeDependent() || E->isValueDependent()) { 1862 // Save dependent expressions in the AST to be instantiated. 1863 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E)); 1864 return; 1865 } 1866 1867 // FIXME: Cache the number on the Attr object? 1868 llvm::APSInt Alignment(32); 1869 if (!E->isIntegerConstantExpr(Alignment, Context)) { 1870 Diag(AttrLoc, diag::err_attribute_argument_not_int) 1871 << "aligned" << E->getSourceRange(); 1872 return; 1873 } 1874 if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) { 1875 Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two) 1876 << E->getSourceRange(); 1877 return; 1878 } 1879 1880 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, true, E)); 1881} 1882 1883void Sema::AddAlignedAttr(SourceLocation AttrLoc, Decl *D, TypeSourceInfo *TS) { 1884 // FIXME: Cache the number on the Attr object if non-dependent? 1885 // FIXME: Perform checking of type validity 1886 D->addAttr(::new (Context) AlignedAttr(AttrLoc, Context, false, TS)); 1887 return; 1888} 1889 1890/// HandleModeAttr - This attribute modifies the width of a decl with primitive 1891/// type. 1892/// 1893/// Despite what would be logical, the mode attribute is a decl attribute, not a 1894/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be 1895/// HImode, not an intermediate pointer. 1896static void HandleModeAttr(Decl *D, const AttributeList &Attr, Sema &S) { 1897 // This attribute isn't documented, but glibc uses it. It changes 1898 // the width of an int or unsigned int to the specified size. 1899 1900 // Check that there aren't any arguments 1901 if (Attr.getNumArgs() != 0) { 1902 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1903 return; 1904 } 1905 1906 IdentifierInfo *Name = Attr.getParameterName(); 1907 if (!Name) { 1908 S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name); 1909 return; 1910 } 1911 1912 llvm::StringRef Str = Attr.getParameterName()->getName(); 1913 1914 // Normalize the attribute name, __foo__ becomes foo. 1915 if (Str.startswith("__") && Str.endswith("__")) 1916 Str = Str.substr(2, Str.size() - 4); 1917 1918 unsigned DestWidth = 0; 1919 bool IntegerMode = true; 1920 bool ComplexMode = false; 1921 switch (Str.size()) { 1922 case 2: 1923 switch (Str[0]) { 1924 case 'Q': DestWidth = 8; break; 1925 case 'H': DestWidth = 16; break; 1926 case 'S': DestWidth = 32; break; 1927 case 'D': DestWidth = 64; break; 1928 case 'X': DestWidth = 96; break; 1929 case 'T': DestWidth = 128; break; 1930 } 1931 if (Str[1] == 'F') { 1932 IntegerMode = false; 1933 } else if (Str[1] == 'C') { 1934 IntegerMode = false; 1935 ComplexMode = true; 1936 } else if (Str[1] != 'I') { 1937 DestWidth = 0; 1938 } 1939 break; 1940 case 4: 1941 // FIXME: glibc uses 'word' to define register_t; this is narrower than a 1942 // pointer on PIC16 and other embedded platforms. 1943 if (Str == "word") 1944 DestWidth = S.Context.Target.getPointerWidth(0); 1945 else if (Str == "byte") 1946 DestWidth = S.Context.Target.getCharWidth(); 1947 break; 1948 case 7: 1949 if (Str == "pointer") 1950 DestWidth = S.Context.Target.getPointerWidth(0); 1951 break; 1952 } 1953 1954 QualType OldTy; 1955 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) 1956 OldTy = TD->getUnderlyingType(); 1957 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) 1958 OldTy = VD->getType(); 1959 else { 1960 S.Diag(D->getLocation(), diag::err_attr_wrong_decl) 1961 << "mode" << SourceRange(Attr.getLoc(), Attr.getLoc()); 1962 return; 1963 } 1964 1965 if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType()) 1966 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive); 1967 else if (IntegerMode) { 1968 if (!OldTy->isIntegralOrEnumerationType()) 1969 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1970 } else if (ComplexMode) { 1971 if (!OldTy->isComplexType()) 1972 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1973 } else { 1974 if (!OldTy->isFloatingType()) 1975 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 1976 } 1977 1978 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t 1979 // and friends, at least with glibc. 1980 // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong 1981 // width on unusual platforms. 1982 // FIXME: Make sure floating-point mappings are accurate 1983 // FIXME: Support XF and TF types 1984 QualType NewTy; 1985 switch (DestWidth) { 1986 case 0: 1987 S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name; 1988 return; 1989 default: 1990 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1991 return; 1992 case 8: 1993 if (!IntegerMode) { 1994 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 1995 return; 1996 } 1997 if (OldTy->isSignedIntegerType()) 1998 NewTy = S.Context.SignedCharTy; 1999 else 2000 NewTy = S.Context.UnsignedCharTy; 2001 break; 2002 case 16: 2003 if (!IntegerMode) { 2004 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 2005 return; 2006 } 2007 if (OldTy->isSignedIntegerType()) 2008 NewTy = S.Context.ShortTy; 2009 else 2010 NewTy = S.Context.UnsignedShortTy; 2011 break; 2012 case 32: 2013 if (!IntegerMode) 2014 NewTy = S.Context.FloatTy; 2015 else if (OldTy->isSignedIntegerType()) 2016 NewTy = S.Context.IntTy; 2017 else 2018 NewTy = S.Context.UnsignedIntTy; 2019 break; 2020 case 64: 2021 if (!IntegerMode) 2022 NewTy = S.Context.DoubleTy; 2023 else if (OldTy->isSignedIntegerType()) 2024 if (S.Context.Target.getLongWidth() == 64) 2025 NewTy = S.Context.LongTy; 2026 else 2027 NewTy = S.Context.LongLongTy; 2028 else 2029 if (S.Context.Target.getLongWidth() == 64) 2030 NewTy = S.Context.UnsignedLongTy; 2031 else 2032 NewTy = S.Context.UnsignedLongLongTy; 2033 break; 2034 case 96: 2035 NewTy = S.Context.LongDoubleTy; 2036 break; 2037 case 128: 2038 if (!IntegerMode) { 2039 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 2040 return; 2041 } 2042 if (OldTy->isSignedIntegerType()) 2043 NewTy = S.Context.Int128Ty; 2044 else 2045 NewTy = S.Context.UnsignedInt128Ty; 2046 break; 2047 } 2048 2049 if (ComplexMode) { 2050 NewTy = S.Context.getComplexType(NewTy); 2051 } 2052 2053 // Install the new type. 2054 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { 2055 // FIXME: preserve existing source info. 2056 TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy)); 2057 } else 2058 cast<ValueDecl>(D)->setType(NewTy); 2059} 2060 2061static void HandleNoDebugAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2062 // check the attribute arguments. 2063 if (Attr.getNumArgs() > 0) { 2064 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2065 return; 2066 } 2067 2068 if (!isFunctionOrMethod(d)) { 2069 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2070 << Attr.getName() << 0 /*function*/; 2071 return; 2072 } 2073 2074 d->addAttr(::new (S.Context) NoDebugAttr(Attr.getLoc(), S.Context)); 2075} 2076 2077static void HandleNoInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2078 // check the attribute arguments. 2079 if (Attr.getNumArgs() != 0) { 2080 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2081 return; 2082 } 2083 2084 if (!isa<FunctionDecl>(d)) { 2085 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2086 << Attr.getName() << 0 /*function*/; 2087 return; 2088 } 2089 2090 d->addAttr(::new (S.Context) NoInlineAttr(Attr.getLoc(), S.Context)); 2091} 2092 2093static void HandleNoInstrumentFunctionAttr(Decl *d, const AttributeList &Attr, 2094 Sema &S) { 2095 // check the attribute arguments. 2096 if (Attr.getNumArgs() != 0) { 2097 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2098 return; 2099 } 2100 2101 if (!isa<FunctionDecl>(d)) { 2102 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2103 << Attr.getName() << 0 /*function*/; 2104 return; 2105 } 2106 2107 d->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getLoc(), 2108 S.Context)); 2109} 2110 2111static void HandleConstantAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2112 if (S.LangOpts.CUDA) { 2113 // check the attribute arguments. 2114 if (Attr.getNumArgs() != 0) { 2115 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2116 return; 2117 } 2118 2119 if (!isa<VarDecl>(d)) { 2120 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2121 << Attr.getName() << 12 /*variable*/; 2122 return; 2123 } 2124 2125 d->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getLoc(), S.Context)); 2126 } else { 2127 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant"; 2128 } 2129} 2130 2131static void HandleDeviceAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2132 if (S.LangOpts.CUDA) { 2133 // check the attribute arguments. 2134 if (Attr.getNumArgs() != 0) { 2135 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2136 return; 2137 } 2138 2139 if (!isa<FunctionDecl>(d) && !isa<VarDecl>(d)) { 2140 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2141 << Attr.getName() << 2 /*variable and function*/; 2142 return; 2143 } 2144 2145 d->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getLoc(), S.Context)); 2146 } else { 2147 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device"; 2148 } 2149} 2150 2151static void HandleGlobalAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2152 if (S.LangOpts.CUDA) { 2153 // check the attribute arguments. 2154 if (Attr.getNumArgs() != 0) { 2155 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2156 return; 2157 } 2158 2159 if (!isa<FunctionDecl>(d)) { 2160 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2161 << Attr.getName() << 0 /*function*/; 2162 return; 2163 } 2164 2165 d->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getLoc(), S.Context)); 2166 } else { 2167 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global"; 2168 } 2169} 2170 2171static void HandleHostAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2172 if (S.LangOpts.CUDA) { 2173 // check the attribute arguments. 2174 if (Attr.getNumArgs() != 0) { 2175 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2176 return; 2177 } 2178 2179 if (!isa<FunctionDecl>(d)) { 2180 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2181 << Attr.getName() << 0 /*function*/; 2182 return; 2183 } 2184 2185 d->addAttr(::new (S.Context) CUDAHostAttr(Attr.getLoc(), S.Context)); 2186 } else { 2187 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host"; 2188 } 2189} 2190 2191static void HandleSharedAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2192 if (S.LangOpts.CUDA) { 2193 // check the attribute arguments. 2194 if (Attr.getNumArgs() != 0) { 2195 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2196 return; 2197 } 2198 2199 if (!isa<VarDecl>(d)) { 2200 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2201 << Attr.getName() << 12 /*variable*/; 2202 return; 2203 } 2204 2205 d->addAttr(::new (S.Context) CUDASharedAttr(Attr.getLoc(), S.Context)); 2206 } else { 2207 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared"; 2208 } 2209} 2210 2211static void HandleGNUInlineAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2212 // check the attribute arguments. 2213 if (Attr.getNumArgs() != 0) { 2214 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2215 return; 2216 } 2217 2218 FunctionDecl *Fn = dyn_cast<FunctionDecl>(d); 2219 if (Fn == 0) { 2220 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2221 << Attr.getName() << 0 /*function*/; 2222 return; 2223 } 2224 2225 if (!Fn->isInlineSpecified()) { 2226 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline); 2227 return; 2228 } 2229 2230 d->addAttr(::new (S.Context) GNUInlineAttr(Attr.getLoc(), S.Context)); 2231} 2232 2233static void HandleCallConvAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2234 // Diagnostic is emitted elsewhere: here we store the (valid) Attr 2235 // in the Decl node for syntactic reasoning, e.g., pretty-printing. 2236 assert(Attr.isInvalid() == false); 2237 2238 switch (Attr.getKind()) { 2239 case AttributeList::AT_fastcall: 2240 d->addAttr(::new (S.Context) FastCallAttr(Attr.getLoc(), S.Context)); 2241 return; 2242 case AttributeList::AT_stdcall: 2243 d->addAttr(::new (S.Context) StdCallAttr(Attr.getLoc(), S.Context)); 2244 return; 2245 case AttributeList::AT_thiscall: 2246 d->addAttr(::new (S.Context) ThisCallAttr(Attr.getLoc(), S.Context)); 2247 return; 2248 case AttributeList::AT_cdecl: 2249 d->addAttr(::new (S.Context) CDeclAttr(Attr.getLoc(), S.Context)); 2250 return; 2251 case AttributeList::AT_pascal: 2252 d->addAttr(::new (S.Context) PascalAttr(Attr.getLoc(), S.Context)); 2253 return; 2254 default: 2255 llvm_unreachable("unexpected attribute kind"); 2256 return; 2257 } 2258} 2259 2260static void HandleRegparmAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2261 // check the attribute arguments. 2262 if (Attr.getNumArgs() != 1) { 2263 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2264 return; 2265 } 2266 2267 if (!isFunctionOrMethod(d)) { 2268 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2269 << Attr.getName() << 0 /*function*/; 2270 return; 2271 } 2272 2273 Expr *NumParamsExpr = Attr.getArg(0); 2274 llvm::APSInt NumParams(32); 2275 if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() || 2276 !NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) { 2277 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 2278 << "regparm" << NumParamsExpr->getSourceRange(); 2279 return; 2280 } 2281 2282 if (S.Context.Target.getRegParmMax() == 0) { 2283 S.Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform) 2284 << NumParamsExpr->getSourceRange(); 2285 return; 2286 } 2287 2288 if (NumParams.getLimitedValue(255) > S.Context.Target.getRegParmMax()) { 2289 S.Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number) 2290 << S.Context.Target.getRegParmMax() << NumParamsExpr->getSourceRange(); 2291 return; 2292 } 2293 2294 d->addAttr(::new (S.Context) RegparmAttr(Attr.getLoc(), S.Context, 2295 NumParams.getZExtValue())); 2296} 2297 2298static void HandleFinalAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2299 // check the attribute arguments. 2300 if (Attr.getNumArgs() != 0) { 2301 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2302 return; 2303 } 2304 2305 if (!isa<CXXRecordDecl>(d) 2306 && (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual())) { 2307 S.Diag(Attr.getLoc(), 2308 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 2309 : diag::warn_attribute_wrong_decl_type) 2310 << Attr.getName() << 7 /*virtual method or class*/; 2311 return; 2312 } 2313 2314 // FIXME: Conform to C++0x redeclaration rules. 2315 2316 if (d->getAttr<FinalAttr>()) { 2317 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "final"; 2318 return; 2319 } 2320 2321 d->addAttr(::new (S.Context) FinalAttr(Attr.getLoc(), S.Context)); 2322} 2323 2324//===----------------------------------------------------------------------===// 2325// C++0x member checking attributes 2326//===----------------------------------------------------------------------===// 2327 2328static void HandleBaseCheckAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2329 if (Attr.getNumArgs() != 0) { 2330 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2331 return; 2332 } 2333 2334 if (!isa<CXXRecordDecl>(d)) { 2335 S.Diag(Attr.getLoc(), 2336 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 2337 : diag::warn_attribute_wrong_decl_type) 2338 << Attr.getName() << 9 /*class*/; 2339 return; 2340 } 2341 2342 if (d->getAttr<BaseCheckAttr>()) { 2343 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "base_check"; 2344 return; 2345 } 2346 2347 d->addAttr(::new (S.Context) BaseCheckAttr(Attr.getLoc(), S.Context)); 2348} 2349 2350static void HandleHidingAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2351 if (Attr.getNumArgs() != 0) { 2352 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2353 return; 2354 } 2355 2356 if (!isa<RecordDecl>(d->getDeclContext())) { 2357 // FIXME: It's not the type that's the problem 2358 S.Diag(Attr.getLoc(), 2359 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 2360 : diag::warn_attribute_wrong_decl_type) 2361 << Attr.getName() << 11 /*member*/; 2362 return; 2363 } 2364 2365 // FIXME: Conform to C++0x redeclaration rules. 2366 2367 if (d->getAttr<HidingAttr>()) { 2368 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "hiding"; 2369 return; 2370 } 2371 2372 d->addAttr(::new (S.Context) HidingAttr(Attr.getLoc(), S.Context)); 2373} 2374 2375static void HandleOverrideAttr(Decl *d, const AttributeList &Attr, Sema &S) { 2376 if (Attr.getNumArgs() != 0) { 2377 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2378 return; 2379 } 2380 2381 if (!isa<CXXMethodDecl>(d) || !cast<CXXMethodDecl>(d)->isVirtual()) { 2382 // FIXME: It's not the type that's the problem 2383 S.Diag(Attr.getLoc(), 2384 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 2385 : diag::warn_attribute_wrong_decl_type) 2386 << Attr.getName() << 10 /*virtual method*/; 2387 return; 2388 } 2389 2390 // FIXME: Conform to C++0x redeclaration rules. 2391 2392 if (d->getAttr<OverrideAttr>()) { 2393 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "override"; 2394 return; 2395 } 2396 2397 d->addAttr(::new (S.Context) OverrideAttr(Attr.getLoc(), S.Context)); 2398} 2399 2400//===----------------------------------------------------------------------===// 2401// Checker-specific attribute handlers. 2402//===----------------------------------------------------------------------===// 2403 2404static void HandleNSReturnsRetainedAttr(Decl *d, const AttributeList &Attr, 2405 Sema &S) { 2406 2407 QualType RetTy; 2408 2409 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(d)) 2410 RetTy = MD->getResultType(); 2411 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(d)) 2412 RetTy = FD->getResultType(); 2413 else { 2414 SourceLocation L = Attr.getLoc(); 2415 S.Diag(d->getLocStart(), diag::warn_attribute_wrong_decl_type) 2416 << SourceRange(L, L) << Attr.getName() << 3 /* function or method */; 2417 return; 2418 } 2419 2420 if (!(S.Context.isObjCNSObjectType(RetTy) || RetTy->getAs<PointerType>() 2421 || RetTy->getAs<ObjCObjectPointerType>())) { 2422 SourceLocation L = Attr.getLoc(); 2423 S.Diag(d->getLocStart(), diag::warn_ns_attribute_wrong_return_type) 2424 << SourceRange(L, L) << Attr.getName(); 2425 return; 2426 } 2427 2428 switch (Attr.getKind()) { 2429 default: 2430 assert(0 && "invalid ownership attribute"); 2431 return; 2432 case AttributeList::AT_cf_returns_not_retained: 2433 d->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getLoc(), 2434 S.Context)); 2435 return; 2436 case AttributeList::AT_ns_returns_not_retained: 2437 d->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getLoc(), 2438 S.Context)); 2439 return; 2440 case AttributeList::AT_cf_returns_retained: 2441 d->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getLoc(), 2442 S.Context)); 2443 return; 2444 case AttributeList::AT_ns_returns_retained: 2445 d->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getLoc(), 2446 S.Context)); 2447 return; 2448 }; 2449} 2450 2451static bool isKnownDeclSpecAttr(const AttributeList &Attr) { 2452 return Attr.getKind() == AttributeList::AT_dllimport || 2453 Attr.getKind() == AttributeList::AT_dllexport; 2454} 2455 2456//===----------------------------------------------------------------------===// 2457// Top Level Sema Entry Points 2458//===----------------------------------------------------------------------===// 2459 2460/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if 2461/// the attribute applies to decls. If the attribute is a type attribute, just 2462/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to 2463/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4). 2464static void ProcessDeclAttribute(Scope *scope, Decl *D, 2465 const AttributeList &Attr, Sema &S) { 2466 if (Attr.isInvalid()) 2467 return; 2468 2469 if (Attr.isDeclspecAttribute() && !isKnownDeclSpecAttr(Attr)) 2470 // FIXME: Try to deal with other __declspec attributes! 2471 return; 2472 switch (Attr.getKind()) { 2473 case AttributeList::AT_IBAction: HandleIBAction(D, Attr, S); break; 2474 case AttributeList::AT_IBOutlet: HandleIBOutlet(D, Attr, S); break; 2475 case AttributeList::AT_IBOutletCollection: 2476 HandleIBOutletCollection(D, Attr, S); break; 2477 case AttributeList::AT_address_space: 2478 case AttributeList::AT_objc_gc: 2479 case AttributeList::AT_vector_size: 2480 case AttributeList::AT_neon_vector_type: 2481 case AttributeList::AT_neon_polyvector_type: 2482 // Ignore these, these are type attributes, handled by 2483 // ProcessTypeAttributes. 2484 break; 2485 case AttributeList::AT_alias: HandleAliasAttr (D, Attr, S); break; 2486 case AttributeList::AT_aligned: HandleAlignedAttr (D, Attr, S); break; 2487 case AttributeList::AT_always_inline: 2488 HandleAlwaysInlineAttr (D, Attr, S); break; 2489 case AttributeList::AT_analyzer_noreturn: 2490 HandleAnalyzerNoReturnAttr (D, Attr, S); break; 2491 case AttributeList::AT_annotate: HandleAnnotateAttr (D, Attr, S); break; 2492 case AttributeList::AT_base_check: HandleBaseCheckAttr (D, Attr, S); break; 2493 case AttributeList::AT_carries_dependency: 2494 HandleDependencyAttr (D, Attr, S); break; 2495 case AttributeList::AT_common: HandleCommonAttr (D, Attr, S); break; 2496 case AttributeList::AT_constant: HandleConstantAttr (D, Attr, S); break; 2497 case AttributeList::AT_constructor: HandleConstructorAttr (D, Attr, S); break; 2498 case AttributeList::AT_deprecated: HandleDeprecatedAttr (D, Attr, S); break; 2499 case AttributeList::AT_destructor: HandleDestructorAttr (D, Attr, S); break; 2500 case AttributeList::AT_device: HandleDeviceAttr (D, Attr, S); break; 2501 case AttributeList::AT_ext_vector_type: 2502 HandleExtVectorTypeAttr(scope, D, Attr, S); 2503 break; 2504 case AttributeList::AT_final: HandleFinalAttr (D, Attr, S); break; 2505 case AttributeList::AT_format: HandleFormatAttr (D, Attr, S); break; 2506 case AttributeList::AT_format_arg: HandleFormatArgAttr (D, Attr, S); break; 2507 case AttributeList::AT_global: HandleGlobalAttr (D, Attr, S); break; 2508 case AttributeList::AT_gnu_inline: HandleGNUInlineAttr (D, Attr, S); break; 2509 case AttributeList::AT_hiding: HandleHidingAttr (D, Attr, S); break; 2510 case AttributeList::AT_host: HandleHostAttr (D, Attr, S); break; 2511 case AttributeList::AT_mode: HandleModeAttr (D, Attr, S); break; 2512 case AttributeList::AT_malloc: HandleMallocAttr (D, Attr, S); break; 2513 case AttributeList::AT_may_alias: HandleMayAliasAttr (D, Attr, S); break; 2514 case AttributeList::AT_nocommon: HandleNoCommonAttr (D, Attr, S); break; 2515 case AttributeList::AT_nonnull: HandleNonNullAttr (D, Attr, S); break; 2516 case AttributeList::AT_ownership_returns: 2517 case AttributeList::AT_ownership_takes: 2518 case AttributeList::AT_ownership_holds: 2519 HandleOwnershipAttr (D, Attr, S); break; 2520 case AttributeList::AT_naked: HandleNakedAttr (D, Attr, S); break; 2521 case AttributeList::AT_noreturn: HandleNoReturnAttr (D, Attr, S); break; 2522 case AttributeList::AT_nothrow: HandleNothrowAttr (D, Attr, S); break; 2523 case AttributeList::AT_override: HandleOverrideAttr (D, Attr, S); break; 2524 case AttributeList::AT_shared: HandleSharedAttr (D, Attr, S); break; 2525 case AttributeList::AT_vecreturn: HandleVecReturnAttr (D, Attr, S); break; 2526 2527 // Checker-specific. 2528 case AttributeList::AT_ns_returns_not_retained: 2529 case AttributeList::AT_cf_returns_not_retained: 2530 case AttributeList::AT_ns_returns_retained: 2531 case AttributeList::AT_cf_returns_retained: 2532 HandleNSReturnsRetainedAttr(D, Attr, S); break; 2533 2534 case AttributeList::AT_reqd_wg_size: 2535 HandleReqdWorkGroupSize(D, Attr, S); break; 2536 2537 case AttributeList::AT_init_priority: 2538 HandleInitPriorityAttr(D, Attr, S); break; 2539 2540 case AttributeList::AT_packed: HandlePackedAttr (D, Attr, S); break; 2541 case AttributeList::AT_section: HandleSectionAttr (D, Attr, S); break; 2542 case AttributeList::AT_unavailable: HandleUnavailableAttr (D, Attr, S); break; 2543 case AttributeList::AT_unused: HandleUnusedAttr (D, Attr, S); break; 2544 case AttributeList::AT_used: HandleUsedAttr (D, Attr, S); break; 2545 case AttributeList::AT_visibility: HandleVisibilityAttr (D, Attr, S); break; 2546 case AttributeList::AT_warn_unused_result: HandleWarnUnusedResult(D,Attr,S); 2547 break; 2548 case AttributeList::AT_weak: HandleWeakAttr (D, Attr, S); break; 2549 case AttributeList::AT_weakref: HandleWeakRefAttr (D, Attr, S); break; 2550 case AttributeList::AT_weak_import: HandleWeakImportAttr (D, Attr, S); break; 2551 case AttributeList::AT_transparent_union: 2552 HandleTransparentUnionAttr(D, Attr, S); 2553 break; 2554 case AttributeList::AT_objc_exception: 2555 HandleObjCExceptionAttr(D, Attr, S); 2556 break; 2557 case AttributeList::AT_overloadable:HandleOverloadableAttr(D, Attr, S); break; 2558 case AttributeList::AT_nsobject: HandleObjCNSObject (D, Attr, S); break; 2559 case AttributeList::AT_blocks: HandleBlocksAttr (D, Attr, S); break; 2560 case AttributeList::AT_sentinel: HandleSentinelAttr (D, Attr, S); break; 2561 case AttributeList::AT_const: HandleConstAttr (D, Attr, S); break; 2562 case AttributeList::AT_pure: HandlePureAttr (D, Attr, S); break; 2563 case AttributeList::AT_cleanup: HandleCleanupAttr (D, Attr, S); break; 2564 case AttributeList::AT_nodebug: HandleNoDebugAttr (D, Attr, S); break; 2565 case AttributeList::AT_noinline: HandleNoInlineAttr (D, Attr, S); break; 2566 case AttributeList::AT_regparm: HandleRegparmAttr (D, Attr, S); break; 2567 case AttributeList::IgnoredAttribute: 2568 // Just ignore 2569 break; 2570 case AttributeList::AT_no_instrument_function: // Interacts with -pg. 2571 HandleNoInstrumentFunctionAttr(D, Attr, S); 2572 break; 2573 case AttributeList::AT_stdcall: 2574 case AttributeList::AT_cdecl: 2575 case AttributeList::AT_fastcall: 2576 case AttributeList::AT_thiscall: 2577 case AttributeList::AT_pascal: 2578 HandleCallConvAttr(D, Attr, S); 2579 break; 2580 default: 2581 // Ask target about the attribute. 2582 const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema(); 2583 if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S)) 2584 S.Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored) 2585 << Attr.getName(); 2586 break; 2587 } 2588} 2589 2590/// ProcessDeclAttributeList - Apply all the decl attributes in the specified 2591/// attribute list to the specified decl, ignoring any type attributes. 2592void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, 2593 const AttributeList *AttrList) { 2594 for (const AttributeList* l = AttrList; l; l = l->getNext()) { 2595 ProcessDeclAttribute(S, D, *l, *this); 2596 } 2597 2598 // GCC accepts 2599 // static int a9 __attribute__((weakref)); 2600 // but that looks really pointless. We reject it. 2601 if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) { 2602 Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) << 2603 dyn_cast<NamedDecl>(D)->getNameAsString(); 2604 return; 2605 } 2606} 2607 2608/// DeclClonePragmaWeak - clone existing decl (maybe definition), 2609/// #pragma weak needs a non-definition decl and source may not have one 2610NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II) { 2611 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND)); 2612 NamedDecl *NewD = 0; 2613 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 2614 NewD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(), 2615 FD->getLocation(), DeclarationName(II), 2616 FD->getType(), FD->getTypeSourceInfo()); 2617 if (FD->getQualifier()) { 2618 FunctionDecl *NewFD = cast<FunctionDecl>(NewD); 2619 NewFD->setQualifierInfo(FD->getQualifier(), FD->getQualifierRange()); 2620 } 2621 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) { 2622 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(), 2623 VD->getLocation(), II, 2624 VD->getType(), VD->getTypeSourceInfo(), 2625 VD->getStorageClass(), 2626 VD->getStorageClassAsWritten()); 2627 if (VD->getQualifier()) { 2628 VarDecl *NewVD = cast<VarDecl>(NewD); 2629 NewVD->setQualifierInfo(VD->getQualifier(), VD->getQualifierRange()); 2630 } 2631 } 2632 return NewD; 2633} 2634 2635/// DeclApplyPragmaWeak - A declaration (maybe definition) needs #pragma weak 2636/// applied to it, possibly with an alias. 2637void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) { 2638 if (W.getUsed()) return; // only do this once 2639 W.setUsed(true); 2640 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...)) 2641 IdentifierInfo *NDId = ND->getIdentifier(); 2642 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias()); 2643 NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context, 2644 NDId->getName())); 2645 NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context)); 2646 WeakTopLevelDecl.push_back(NewD); 2647 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin 2648 // to insert Decl at TU scope, sorry. 2649 DeclContext *SavedContext = CurContext; 2650 CurContext = Context.getTranslationUnitDecl(); 2651 PushOnScopeChains(NewD, S); 2652 CurContext = SavedContext; 2653 } else { // just add weak to existing 2654 ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context)); 2655 } 2656} 2657 2658/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in 2659/// it, apply them to D. This is a bit tricky because PD can have attributes 2660/// specified in many different places, and we need to find and apply them all. 2661void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) { 2662 // It's valid to "forward-declare" #pragma weak, in which case we 2663 // have to do this. 2664 if (!WeakUndeclaredIdentifiers.empty()) { 2665 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 2666 if (IdentifierInfo *Id = ND->getIdentifier()) { 2667 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I 2668 = WeakUndeclaredIdentifiers.find(Id); 2669 if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) { 2670 WeakInfo W = I->second; 2671 DeclApplyPragmaWeak(S, ND, W); 2672 WeakUndeclaredIdentifiers[Id] = W; 2673 } 2674 } 2675 } 2676 } 2677 2678 // Apply decl attributes from the DeclSpec if present. 2679 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes()) 2680 ProcessDeclAttributeList(S, D, Attrs); 2681 2682 // Walk the declarator structure, applying decl attributes that were in a type 2683 // position to the decl itself. This handles cases like: 2684 // int *__attr__(x)** D; 2685 // when X is a decl attribute. 2686 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i) 2687 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs()) 2688 ProcessDeclAttributeList(S, D, Attrs); 2689 2690 // Finally, apply any attributes on the decl itself. 2691 if (const AttributeList *Attrs = PD.getAttributes()) 2692 ProcessDeclAttributeList(S, D, Attrs); 2693} 2694 2695/// PushParsingDeclaration - Enter a new "scope" of deprecation 2696/// warnings. 2697/// 2698/// The state token we use is the start index of this scope 2699/// on the warning stack. 2700Sema::ParsingDeclStackState Sema::PushParsingDeclaration() { 2701 ParsingDeclDepth++; 2702 return (ParsingDeclStackState) DelayedDiagnostics.size(); 2703} 2704 2705void Sema::PopParsingDeclaration(ParsingDeclStackState S, Decl *D) { 2706 assert(ParsingDeclDepth > 0 && "empty ParsingDeclaration stack"); 2707 ParsingDeclDepth--; 2708 2709 if (DelayedDiagnostics.empty()) 2710 return; 2711 2712 unsigned SavedIndex = (unsigned) S; 2713 assert(SavedIndex <= DelayedDiagnostics.size() && 2714 "saved index is out of bounds"); 2715 2716 unsigned E = DelayedDiagnostics.size(); 2717 2718 // We only want to actually emit delayed diagnostics when we 2719 // successfully parsed a decl. 2720 if (D) { 2721 // We really do want to start with 0 here. We get one push for a 2722 // decl spec and another for each declarator; in a decl group like: 2723 // deprecated_typedef foo, *bar, baz(); 2724 // only the declarator pops will be passed decls. This is correct; 2725 // we really do need to consider delayed diagnostics from the decl spec 2726 // for each of the different declarations. 2727 for (unsigned I = 0; I != E; ++I) { 2728 if (DelayedDiagnostics[I].Triggered) 2729 continue; 2730 2731 switch (DelayedDiagnostics[I].Kind) { 2732 case DelayedDiagnostic::Deprecation: 2733 HandleDelayedDeprecationCheck(DelayedDiagnostics[I], D); 2734 break; 2735 2736 case DelayedDiagnostic::Access: 2737 HandleDelayedAccessCheck(DelayedDiagnostics[I], D); 2738 break; 2739 } 2740 } 2741 } 2742 2743 // Destroy all the delayed diagnostics we're about to pop off. 2744 for (unsigned I = SavedIndex; I != E; ++I) 2745 DelayedDiagnostics[I].destroy(); 2746 2747 DelayedDiagnostics.set_size(SavedIndex); 2748} 2749 2750static bool isDeclDeprecated(Decl *D) { 2751 do { 2752 if (D->hasAttr<DeprecatedAttr>()) 2753 return true; 2754 } while ((D = cast_or_null<Decl>(D->getDeclContext()))); 2755 return false; 2756} 2757 2758void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD, 2759 Decl *Ctx) { 2760 if (isDeclDeprecated(Ctx)) 2761 return; 2762 2763 DD.Triggered = true; 2764 if (!DD.getDeprecationMessage().empty()) 2765 Diag(DD.Loc, diag::warn_deprecated_message) 2766 << DD.getDeprecationDecl()->getDeclName() 2767 << DD.getDeprecationMessage(); 2768 else 2769 Diag(DD.Loc, diag::warn_deprecated) 2770 << DD.getDeprecationDecl()->getDeclName(); 2771} 2772 2773void Sema::EmitDeprecationWarning(NamedDecl *D, llvm::StringRef Message, 2774 SourceLocation Loc) { 2775 // Delay if we're currently parsing a declaration. 2776 if (ParsingDeclDepth) { 2777 DelayedDiagnostics.push_back(DelayedDiagnostic::makeDeprecation(Loc, D, 2778 Message)); 2779 return; 2780 } 2781 2782 // Otherwise, don't warn if our current context is deprecated. 2783 if (isDeclDeprecated(cast<Decl>(CurContext))) 2784 return; 2785 if (!Message.empty()) 2786 Diag(Loc, diag::warn_deprecated_message) << D->getDeclName() 2787 << Message; 2788 else 2789 Diag(Loc, diag::warn_deprecated) << D->getDeclName(); 2790} 2791