SemaDeclAttr.cpp revision 0b4db3e08a201c35f0011489bd5cd5d39bbe54fb
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/CXXInheritance.h" 18#include "clang/AST/DeclCXX.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/DeclObjC.h" 21#include "clang/AST/Expr.h" 22#include "clang/Basic/SourceManager.h" 23#include "clang/Basic/TargetInfo.h" 24#include "clang/Sema/DeclSpec.h" 25#include "clang/Sema/DelayedDiagnostic.h" 26#include "clang/Sema/Lookup.h" 27#include "llvm/ADT/StringExtras.h" 28using namespace clang; 29using namespace sema; 30 31/// These constants match the enumerated choices of 32/// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type. 33enum AttributeDeclKind { 34 ExpectedFunction, 35 ExpectedUnion, 36 ExpectedVariableOrFunction, 37 ExpectedFunctionOrMethod, 38 ExpectedParameter, 39 ExpectedFunctionMethodOrBlock, 40 ExpectedFunctionMethodOrParameter, 41 ExpectedClass, 42 ExpectedVariable, 43 ExpectedMethod, 44 ExpectedVariableFunctionOrLabel, 45 ExpectedFieldOrGlobalVar, 46 ExpectedStruct, 47 ExpectedTLSVar 48}; 49 50//===----------------------------------------------------------------------===// 51// Helper functions 52//===----------------------------------------------------------------------===// 53 54static const FunctionType *getFunctionType(const Decl *D, 55 bool blocksToo = true) { 56 QualType Ty; 57 if (const ValueDecl *decl = dyn_cast<ValueDecl>(D)) 58 Ty = decl->getType(); 59 else if (const FieldDecl *decl = dyn_cast<FieldDecl>(D)) 60 Ty = decl->getType(); 61 else if (const TypedefNameDecl* decl = dyn_cast<TypedefNameDecl>(D)) 62 Ty = decl->getUnderlyingType(); 63 else 64 return 0; 65 66 if (Ty->isFunctionPointerType()) 67 Ty = Ty->getAs<PointerType>()->getPointeeType(); 68 else if (blocksToo && Ty->isBlockPointerType()) 69 Ty = Ty->getAs<BlockPointerType>()->getPointeeType(); 70 71 return Ty->getAs<FunctionType>(); 72} 73 74// FIXME: We should provide an abstraction around a method or function 75// to provide the following bits of information. 76 77/// isFunction - Return true if the given decl has function 78/// type (function or function-typed variable). 79static bool isFunction(const Decl *D) { 80 return getFunctionType(D, false) != NULL; 81} 82 83/// isFunctionOrMethod - Return true if the given decl has function 84/// type (function or function-typed variable) or an Objective-C 85/// method. 86static bool isFunctionOrMethod(const Decl *D) { 87 return isFunction(D) || isa<ObjCMethodDecl>(D); 88} 89 90/// isFunctionOrMethodOrBlock - Return true if the given decl has function 91/// type (function or function-typed variable) or an Objective-C 92/// method or a block. 93static bool isFunctionOrMethodOrBlock(const Decl *D) { 94 if (isFunctionOrMethod(D)) 95 return true; 96 // check for block is more involved. 97 if (const VarDecl *V = dyn_cast<VarDecl>(D)) { 98 QualType Ty = V->getType(); 99 return Ty->isBlockPointerType(); 100 } 101 return isa<BlockDecl>(D); 102} 103 104/// Return true if the given decl has a declarator that should have 105/// been processed by Sema::GetTypeForDeclarator. 106static bool hasDeclarator(const Decl *D) { 107 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl. 108 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) || 109 isa<ObjCPropertyDecl>(D); 110} 111 112/// hasFunctionProto - Return true if the given decl has a argument 113/// information. This decl should have already passed 114/// isFunctionOrMethod or isFunctionOrMethodOrBlock. 115static bool hasFunctionProto(const Decl *D) { 116 if (const FunctionType *FnTy = getFunctionType(D)) 117 return isa<FunctionProtoType>(FnTy); 118 else { 119 assert(isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D)); 120 return true; 121 } 122} 123 124/// getFunctionOrMethodNumArgs - Return number of function or method 125/// arguments. It is an error to call this on a K&R function (use 126/// hasFunctionProto first). 127static unsigned getFunctionOrMethodNumArgs(const Decl *D) { 128 if (const FunctionType *FnTy = getFunctionType(D)) 129 return cast<FunctionProtoType>(FnTy)->getNumArgs(); 130 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) 131 return BD->getNumParams(); 132 return cast<ObjCMethodDecl>(D)->param_size(); 133} 134 135static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) { 136 if (const FunctionType *FnTy = getFunctionType(D)) 137 return cast<FunctionProtoType>(FnTy)->getArgType(Idx); 138 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) 139 return BD->getParamDecl(Idx)->getType(); 140 141 return cast<ObjCMethodDecl>(D)->param_begin()[Idx]->getType(); 142} 143 144static QualType getFunctionOrMethodResultType(const Decl *D) { 145 if (const FunctionType *FnTy = getFunctionType(D)) 146 return cast<FunctionProtoType>(FnTy)->getResultType(); 147 return cast<ObjCMethodDecl>(D)->getResultType(); 148} 149 150static bool isFunctionOrMethodVariadic(const Decl *D) { 151 if (const FunctionType *FnTy = getFunctionType(D)) { 152 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy); 153 return proto->isVariadic(); 154 } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) 155 return BD->isVariadic(); 156 else { 157 return cast<ObjCMethodDecl>(D)->isVariadic(); 158 } 159} 160 161static bool isInstanceMethod(const Decl *D) { 162 if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) 163 return MethodDecl->isInstance(); 164 return false; 165} 166 167static inline bool isNSStringType(QualType T, ASTContext &Ctx) { 168 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>(); 169 if (!PT) 170 return false; 171 172 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface(); 173 if (!Cls) 174 return false; 175 176 IdentifierInfo* ClsName = Cls->getIdentifier(); 177 178 // FIXME: Should we walk the chain of classes? 179 return ClsName == &Ctx.Idents.get("NSString") || 180 ClsName == &Ctx.Idents.get("NSMutableString"); 181} 182 183static inline bool isCFStringType(QualType T, ASTContext &Ctx) { 184 const PointerType *PT = T->getAs<PointerType>(); 185 if (!PT) 186 return false; 187 188 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>(); 189 if (!RT) 190 return false; 191 192 const RecordDecl *RD = RT->getDecl(); 193 if (RD->getTagKind() != TTK_Struct) 194 return false; 195 196 return RD->getIdentifier() == &Ctx.Idents.get("__CFString"); 197} 198 199/// \brief Check if the attribute has exactly as many args as Num. May 200/// output an error. 201static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr, 202 unsigned int Num) { 203 if (Attr.getNumArgs() != Num) { 204 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num; 205 return false; 206 } 207 208 return true; 209} 210 211 212/// \brief Check if the attribute has at least as many args as Num. May 213/// output an error. 214static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr, 215 unsigned int Num) { 216 if (Attr.getNumArgs() < Num) { 217 S.Diag(Attr.getLoc(), diag::err_attribute_too_few_arguments) << Num; 218 return false; 219 } 220 221 return true; 222} 223 224/// \brief Check if IdxExpr is a valid argument index for a function or 225/// instance method D. May output an error. 226/// 227/// \returns true if IdxExpr is a valid index. 228static bool checkFunctionOrMethodArgumentIndex(Sema &S, const Decl *D, 229 StringRef AttrName, 230 SourceLocation AttrLoc, 231 unsigned AttrArgNum, 232 const Expr *IdxExpr, 233 uint64_t &Idx) 234{ 235 assert(isFunctionOrMethod(D) && hasFunctionProto(D)); 236 237 // In C++ the implicit 'this' function parameter also counts. 238 // Parameters are counted from one. 239 const bool HasImplicitThisParam = isInstanceMethod(D); 240 const unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 241 const unsigned FirstIdx = 1; 242 243 llvm::APSInt IdxInt; 244 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 245 !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) { 246 S.Diag(AttrLoc, diag::err_attribute_argument_n_not_int) 247 << AttrName << AttrArgNum << IdxExpr->getSourceRange(); 248 return false; 249 } 250 251 Idx = IdxInt.getLimitedValue(); 252 if (Idx < FirstIdx || (!isFunctionOrMethodVariadic(D) && Idx > NumArgs)) { 253 S.Diag(AttrLoc, diag::err_attribute_argument_out_of_bounds) 254 << AttrName << AttrArgNum << IdxExpr->getSourceRange(); 255 return false; 256 } 257 Idx--; // Convert to zero-based. 258 if (HasImplicitThisParam) { 259 if (Idx == 0) { 260 S.Diag(AttrLoc, 261 diag::err_attribute_invalid_implicit_this_argument) 262 << AttrName << IdxExpr->getSourceRange(); 263 return false; 264 } 265 --Idx; 266 } 267 268 return true; 269} 270 271/// 272/// \brief Check if passed in Decl is a field or potentially shared global var 273/// \return true if the Decl is a field or potentially shared global variable 274/// 275static bool mayBeSharedVariable(const Decl *D) { 276 if (isa<FieldDecl>(D)) 277 return true; 278 if (const VarDecl *vd = dyn_cast<VarDecl>(D)) 279 return (vd->hasGlobalStorage() && !(vd->isThreadSpecified())); 280 281 return false; 282} 283 284/// \brief Check if the passed-in expression is of type int or bool. 285static bool isIntOrBool(Expr *Exp) { 286 QualType QT = Exp->getType(); 287 return QT->isBooleanType() || QT->isIntegerType(); 288} 289 290 291// Check to see if the type is a smart pointer of some kind. We assume 292// it's a smart pointer if it defines both operator-> and operator*. 293static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) { 294 DeclContextLookupConstResult Res1 = RT->getDecl()->lookup( 295 S.Context.DeclarationNames.getCXXOperatorName(OO_Star)); 296 if (Res1.first == Res1.second) 297 return false; 298 299 DeclContextLookupConstResult Res2 = RT->getDecl()->lookup( 300 S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow)); 301 if (Res2.first == Res2.second) 302 return false; 303 304 return true; 305} 306 307/// \brief Check if passed in Decl is a pointer type. 308/// Note that this function may produce an error message. 309/// \return true if the Decl is a pointer type; false otherwise 310static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, 311 const AttributeList &Attr) { 312 if (const ValueDecl *vd = dyn_cast<ValueDecl>(D)) { 313 QualType QT = vd->getType(); 314 if (QT->isAnyPointerType()) 315 return true; 316 317 if (const RecordType *RT = QT->getAs<RecordType>()) { 318 // If it's an incomplete type, it could be a smart pointer; skip it. 319 // (We don't want to force template instantiation if we can avoid it, 320 // since that would alter the order in which templates are instantiated.) 321 if (RT->isIncompleteType()) 322 return true; 323 324 if (threadSafetyCheckIsSmartPointer(S, RT)) 325 return true; 326 } 327 328 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer) 329 << Attr.getName()->getName() << QT; 330 } else { 331 S.Diag(Attr.getLoc(), diag::err_attribute_can_be_applied_only_to_value_decl) 332 << Attr.getName(); 333 } 334 return false; 335} 336 337/// \brief Checks that the passed in QualType either is of RecordType or points 338/// to RecordType. Returns the relevant RecordType, null if it does not exit. 339static const RecordType *getRecordType(QualType QT) { 340 if (const RecordType *RT = QT->getAs<RecordType>()) 341 return RT; 342 343 // Now check if we point to record type. 344 if (const PointerType *PT = QT->getAs<PointerType>()) 345 return PT->getPointeeType()->getAs<RecordType>(); 346 347 return 0; 348} 349 350 351static bool checkBaseClassIsLockableCallback(const CXXBaseSpecifier *Specifier, 352 CXXBasePath &Path, void *Unused) { 353 const RecordType *RT = Specifier->getType()->getAs<RecordType>(); 354 if (RT->getDecl()->getAttr<LockableAttr>()) 355 return true; 356 return false; 357} 358 359 360/// \brief Thread Safety Analysis: Checks that the passed in RecordType 361/// resolves to a lockable object. 362static void checkForLockableRecord(Sema &S, Decl *D, const AttributeList &Attr, 363 QualType Ty) { 364 const RecordType *RT = getRecordType(Ty); 365 366 // Warn if could not get record type for this argument. 367 if (!RT) { 368 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_class) 369 << Attr.getName() << Ty.getAsString(); 370 return; 371 } 372 373 // Don't check for lockable if the class hasn't been defined yet. 374 if (RT->isIncompleteType()) 375 return; 376 377 // Allow smart pointers to be used as lockable objects. 378 // FIXME -- Check the type that the smart pointer points to. 379 if (threadSafetyCheckIsSmartPointer(S, RT)) 380 return; 381 382 // Check if the type is lockable. 383 RecordDecl *RD = RT->getDecl(); 384 if (RD->getAttr<LockableAttr>()) 385 return; 386 387 // Else check if any base classes are lockable. 388 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 389 CXXBasePaths BPaths(false, false); 390 if (CRD->lookupInBases(checkBaseClassIsLockableCallback, 0, BPaths)) 391 return; 392 } 393 394 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable) 395 << Attr.getName() << Ty.getAsString(); 396} 397 398/// \brief Thread Safety Analysis: Checks that all attribute arguments, starting 399/// from Sidx, resolve to a lockable object. 400/// \param Sidx The attribute argument index to start checking with. 401/// \param ParamIdxOk Whether an argument can be indexing into a function 402/// parameter list. 403static void checkAttrArgsAreLockableObjs(Sema &S, Decl *D, 404 const AttributeList &Attr, 405 SmallVectorImpl<Expr*> &Args, 406 int Sidx = 0, 407 bool ParamIdxOk = false) { 408 for(unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) { 409 Expr *ArgExp = Attr.getArg(Idx); 410 411 if (ArgExp->isTypeDependent()) { 412 // FIXME -- need to check this again on template instantiation 413 Args.push_back(ArgExp); 414 continue; 415 } 416 417 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) { 418 if (StrLit->getLength() == 0 || 419 StrLit->getString() == StringRef("*")) { 420 // Pass empty strings to the analyzer without warnings. 421 // Treat "*" as the universal lock. 422 Args.push_back(ArgExp); 423 continue; 424 } 425 426 // We allow constant strings to be used as a placeholder for expressions 427 // that are not valid C++ syntax, but warn that they are ignored. 428 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) << 429 Attr.getName(); 430 Args.push_back(ArgExp); 431 continue; 432 } 433 434 QualType ArgTy = ArgExp->getType(); 435 436 // A pointer to member expression of the form &MyClass::mu is treated 437 // specially -- we need to look at the type of the member. 438 if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp)) 439 if (UOp->getOpcode() == UO_AddrOf) 440 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr())) 441 if (DRE->getDecl()->isCXXInstanceMember()) 442 ArgTy = DRE->getDecl()->getType(); 443 444 // First see if we can just cast to record type, or point to record type. 445 const RecordType *RT = getRecordType(ArgTy); 446 447 // Now check if we index into a record type function param. 448 if(!RT && ParamIdxOk) { 449 FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 450 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp); 451 if(FD && IL) { 452 unsigned int NumParams = FD->getNumParams(); 453 llvm::APInt ArgValue = IL->getValue(); 454 uint64_t ParamIdxFromOne = ArgValue.getZExtValue(); 455 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1; 456 if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) { 457 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range) 458 << Attr.getName() << Idx + 1 << NumParams; 459 continue; 460 } 461 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType(); 462 } 463 } 464 465 checkForLockableRecord(S, D, Attr, ArgTy); 466 467 Args.push_back(ArgExp); 468 } 469} 470 471//===----------------------------------------------------------------------===// 472// Attribute Implementations 473//===----------------------------------------------------------------------===// 474 475// FIXME: All this manual attribute parsing code is gross. At the 476// least add some helper functions to check most argument patterns (# 477// and types of args). 478 479enum ThreadAttributeDeclKind { 480 ThreadExpectedFieldOrGlobalVar, 481 ThreadExpectedFunctionOrMethod, 482 ThreadExpectedClassOrStruct 483}; 484 485static bool checkGuardedVarAttrCommon(Sema &S, Decl *D, 486 const AttributeList &Attr) { 487 assert(!Attr.isInvalid()); 488 489 if (!checkAttributeNumArgs(S, Attr, 0)) 490 return false; 491 492 // D must be either a member field or global (potentially shared) variable. 493 if (!mayBeSharedVariable(D)) { 494 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 495 << Attr.getName() << ThreadExpectedFieldOrGlobalVar; 496 return false; 497 } 498 499 return true; 500} 501 502static void handleGuardedVarAttr(Sema &S, Decl *D, const AttributeList &Attr) { 503 if (!checkGuardedVarAttrCommon(S, D, Attr)) 504 return; 505 506 D->addAttr(::new (S.Context) GuardedVarAttr(Attr.getRange(), S.Context)); 507} 508 509static void handlePtGuardedVarAttr(Sema &S, Decl *D, 510 const AttributeList &Attr) { 511 if (!checkGuardedVarAttrCommon(S, D, Attr)) 512 return; 513 514 if (!threadSafetyCheckIsPointer(S, D, Attr)) 515 return; 516 517 D->addAttr(::new (S.Context) PtGuardedVarAttr(Attr.getRange(), S.Context)); 518} 519 520static bool checkGuardedByAttrCommon(Sema &S, Decl *D, 521 const AttributeList &Attr, 522 Expr* &Arg) { 523 assert(!Attr.isInvalid()); 524 525 if (!checkAttributeNumArgs(S, Attr, 1)) 526 return false; 527 528 // D must be either a member field or global (potentially shared) variable. 529 if (!mayBeSharedVariable(D)) { 530 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 531 << Attr.getName() << ThreadExpectedFieldOrGlobalVar; 532 return false; 533 } 534 535 SmallVector<Expr*, 1> Args; 536 // check that all arguments are lockable objects 537 checkAttrArgsAreLockableObjs(S, D, Attr, Args); 538 unsigned Size = Args.size(); 539 if (Size != 1) 540 return false; 541 542 Arg = Args[0]; 543 544 return true; 545} 546 547static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) { 548 Expr *Arg = 0; 549 if (!checkGuardedByAttrCommon(S, D, Attr, Arg)) 550 return; 551 552 D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg)); 553} 554 555static void handlePtGuardedByAttr(Sema &S, Decl *D, 556 const AttributeList &Attr) { 557 Expr *Arg = 0; 558 if (!checkGuardedByAttrCommon(S, D, Attr, Arg)) 559 return; 560 561 if (!threadSafetyCheckIsPointer(S, D, Attr)) 562 return; 563 564 D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(), 565 S.Context, Arg)); 566} 567 568static bool checkLockableAttrCommon(Sema &S, Decl *D, 569 const AttributeList &Attr) { 570 assert(!Attr.isInvalid()); 571 572 if (!checkAttributeNumArgs(S, Attr, 0)) 573 return false; 574 575 // FIXME: Lockable structs for C code. 576 if (!isa<CXXRecordDecl>(D)) { 577 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 578 << Attr.getName() << ThreadExpectedClassOrStruct; 579 return false; 580 } 581 582 return true; 583} 584 585static void handleLockableAttr(Sema &S, Decl *D, const AttributeList &Attr) { 586 if (!checkLockableAttrCommon(S, D, Attr)) 587 return; 588 589 D->addAttr(::new (S.Context) LockableAttr(Attr.getRange(), S.Context)); 590} 591 592static void handleScopedLockableAttr(Sema &S, Decl *D, 593 const AttributeList &Attr) { 594 if (!checkLockableAttrCommon(S, D, Attr)) 595 return; 596 597 D->addAttr(::new (S.Context) ScopedLockableAttr(Attr.getRange(), S.Context)); 598} 599 600static void handleNoThreadSafetyAttr(Sema &S, Decl *D, 601 const AttributeList &Attr) { 602 assert(!Attr.isInvalid()); 603 604 if (!checkAttributeNumArgs(S, Attr, 0)) 605 return; 606 607 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 608 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 609 << Attr.getName() << ThreadExpectedFunctionOrMethod; 610 return; 611 } 612 613 D->addAttr(::new (S.Context) NoThreadSafetyAnalysisAttr(Attr.getRange(), 614 S.Context)); 615} 616 617static void handleNoAddressSafetyAttr(Sema &S, Decl *D, 618 const AttributeList &Attr) { 619 assert(!Attr.isInvalid()); 620 621 if (!checkAttributeNumArgs(S, Attr, 0)) 622 return; 623 624 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 625 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 626 << Attr.getName() << ExpectedFunctionOrMethod; 627 return; 628 } 629 630 D->addAttr(::new (S.Context) NoAddressSafetyAnalysisAttr(Attr.getRange(), 631 S.Context)); 632} 633 634static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, 635 const AttributeList &Attr, 636 SmallVector<Expr*, 1> &Args) { 637 assert(!Attr.isInvalid()); 638 639 if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) 640 return false; 641 642 // D must be either a member field or global (potentially shared) variable. 643 ValueDecl *VD = dyn_cast<ValueDecl>(D); 644 if (!VD || !mayBeSharedVariable(D)) { 645 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 646 << Attr.getName() << ThreadExpectedFieldOrGlobalVar; 647 return false; 648 } 649 650 // Check that this attribute only applies to lockable types. 651 QualType QT = VD->getType(); 652 if (!QT->isDependentType()) { 653 const RecordType *RT = getRecordType(QT); 654 if (!RT || !RT->getDecl()->getAttr<LockableAttr>()) { 655 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable) 656 << Attr.getName(); 657 return false; 658 } 659 } 660 661 // Check that all arguments are lockable objects. 662 checkAttrArgsAreLockableObjs(S, D, Attr, Args); 663 if (Args.size() == 0) 664 return false; 665 666 return true; 667} 668 669static void handleAcquiredAfterAttr(Sema &S, Decl *D, 670 const AttributeList &Attr) { 671 SmallVector<Expr*, 1> Args; 672 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args)) 673 return; 674 675 Expr **StartArg = &Args[0]; 676 D->addAttr(::new (S.Context) AcquiredAfterAttr(Attr.getRange(), S.Context, 677 StartArg, Args.size())); 678} 679 680static void handleAcquiredBeforeAttr(Sema &S, Decl *D, 681 const AttributeList &Attr) { 682 SmallVector<Expr*, 1> Args; 683 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args)) 684 return; 685 686 Expr **StartArg = &Args[0]; 687 D->addAttr(::new (S.Context) AcquiredBeforeAttr(Attr.getRange(), S.Context, 688 StartArg, Args.size())); 689} 690 691static bool checkLockFunAttrCommon(Sema &S, Decl *D, 692 const AttributeList &Attr, 693 SmallVector<Expr*, 1> &Args) { 694 assert(!Attr.isInvalid()); 695 696 // zero or more arguments ok 697 698 // check that the attribute is applied to a function 699 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 700 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 701 << Attr.getName() << ThreadExpectedFunctionOrMethod; 702 return false; 703 } 704 705 // check that all arguments are lockable objects 706 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true); 707 708 return true; 709} 710 711static void handleSharedLockFunctionAttr(Sema &S, Decl *D, 712 const AttributeList &Attr) { 713 SmallVector<Expr*, 1> Args; 714 if (!checkLockFunAttrCommon(S, D, Attr, Args)) 715 return; 716 717 unsigned Size = Args.size(); 718 Expr **StartArg = Size == 0 ? 0 : &Args[0]; 719 D->addAttr(::new (S.Context) SharedLockFunctionAttr(Attr.getRange(), 720 S.Context, 721 StartArg, Size)); 722} 723 724static void handleExclusiveLockFunctionAttr(Sema &S, Decl *D, 725 const AttributeList &Attr) { 726 SmallVector<Expr*, 1> Args; 727 if (!checkLockFunAttrCommon(S, D, Attr, Args)) 728 return; 729 730 unsigned Size = Args.size(); 731 Expr **StartArg = Size == 0 ? 0 : &Args[0]; 732 D->addAttr(::new (S.Context) ExclusiveLockFunctionAttr(Attr.getRange(), 733 S.Context, 734 StartArg, Size)); 735} 736 737static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, 738 const AttributeList &Attr, 739 SmallVector<Expr*, 2> &Args) { 740 assert(!Attr.isInvalid()); 741 742 if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) 743 return false; 744 745 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 746 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 747 << Attr.getName() << ThreadExpectedFunctionOrMethod; 748 return false; 749 } 750 751 if (!isIntOrBool(Attr.getArg(0))) { 752 S.Diag(Attr.getLoc(), diag::err_attribute_first_argument_not_int_or_bool) 753 << Attr.getName(); 754 return false; 755 } 756 757 // check that all arguments are lockable objects 758 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 1); 759 760 return true; 761} 762 763static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D, 764 const AttributeList &Attr) { 765 SmallVector<Expr*, 2> Args; 766 if (!checkTryLockFunAttrCommon(S, D, Attr, Args)) 767 return; 768 769 unsigned Size = Args.size(); 770 Expr **StartArg = Size == 0 ? 0 : &Args[0]; 771 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(Attr.getRange(), 772 S.Context, 773 Attr.getArg(0), 774 StartArg, Size)); 775} 776 777static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D, 778 const AttributeList &Attr) { 779 SmallVector<Expr*, 2> Args; 780 if (!checkTryLockFunAttrCommon(S, D, Attr, Args)) 781 return; 782 783 unsigned Size = Args.size(); 784 Expr **StartArg = Size == 0 ? 0 : &Args[0]; 785 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(Attr.getRange(), 786 S.Context, 787 Attr.getArg(0), 788 StartArg, Size)); 789} 790 791static bool checkLocksRequiredCommon(Sema &S, Decl *D, 792 const AttributeList &Attr, 793 SmallVector<Expr*, 1> &Args) { 794 assert(!Attr.isInvalid()); 795 796 if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) 797 return false; 798 799 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 800 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 801 << Attr.getName() << ThreadExpectedFunctionOrMethod; 802 return false; 803 } 804 805 // check that all arguments are lockable objects 806 checkAttrArgsAreLockableObjs(S, D, Attr, Args); 807 if (Args.size() == 0) 808 return false; 809 810 return true; 811} 812 813static void handleExclusiveLocksRequiredAttr(Sema &S, Decl *D, 814 const AttributeList &Attr) { 815 SmallVector<Expr*, 1> Args; 816 if (!checkLocksRequiredCommon(S, D, Attr, Args)) 817 return; 818 819 Expr **StartArg = &Args[0]; 820 D->addAttr(::new (S.Context) ExclusiveLocksRequiredAttr(Attr.getRange(), 821 S.Context, 822 StartArg, 823 Args.size())); 824} 825 826static void handleSharedLocksRequiredAttr(Sema &S, Decl *D, 827 const AttributeList &Attr) { 828 SmallVector<Expr*, 1> Args; 829 if (!checkLocksRequiredCommon(S, D, Attr, Args)) 830 return; 831 832 Expr **StartArg = &Args[0]; 833 D->addAttr(::new (S.Context) SharedLocksRequiredAttr(Attr.getRange(), 834 S.Context, 835 StartArg, 836 Args.size())); 837} 838 839static void handleUnlockFunAttr(Sema &S, Decl *D, 840 const AttributeList &Attr) { 841 assert(!Attr.isInvalid()); 842 843 // zero or more arguments ok 844 845 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 846 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 847 << Attr.getName() << ThreadExpectedFunctionOrMethod; 848 return; 849 } 850 851 // check that all arguments are lockable objects 852 SmallVector<Expr*, 1> Args; 853 checkAttrArgsAreLockableObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true); 854 unsigned Size = Args.size(); 855 Expr **StartArg = Size == 0 ? 0 : &Args[0]; 856 857 D->addAttr(::new (S.Context) UnlockFunctionAttr(Attr.getRange(), S.Context, 858 StartArg, Size)); 859} 860 861static void handleLockReturnedAttr(Sema &S, Decl *D, 862 const AttributeList &Attr) { 863 assert(!Attr.isInvalid()); 864 865 if (!checkAttributeNumArgs(S, Attr, 1)) 866 return; 867 Expr *Arg = Attr.getArg(0); 868 869 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 870 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 871 << Attr.getName() << ThreadExpectedFunctionOrMethod; 872 return; 873 } 874 875 if (Arg->isTypeDependent()) 876 return; 877 878 // check that the argument is lockable object 879 SmallVector<Expr*, 1> Args; 880 checkAttrArgsAreLockableObjs(S, D, Attr, Args); 881 unsigned Size = Args.size(); 882 if (Size == 0) 883 return; 884 885 D->addAttr(::new (S.Context) LockReturnedAttr(Attr.getRange(), S.Context, 886 Args[0])); 887} 888 889static void handleLocksExcludedAttr(Sema &S, Decl *D, 890 const AttributeList &Attr) { 891 assert(!Attr.isInvalid()); 892 893 if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) 894 return; 895 896 if (!isa<FunctionDecl>(D) && !isa<FunctionTemplateDecl>(D)) { 897 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) 898 << Attr.getName() << ThreadExpectedFunctionOrMethod; 899 return; 900 } 901 902 // check that all arguments are lockable objects 903 SmallVector<Expr*, 1> Args; 904 checkAttrArgsAreLockableObjs(S, D, Attr, Args); 905 unsigned Size = Args.size(); 906 if (Size == 0) 907 return; 908 Expr **StartArg = &Args[0]; 909 910 D->addAttr(::new (S.Context) LocksExcludedAttr(Attr.getRange(), S.Context, 911 StartArg, Size)); 912} 913 914 915static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D, 916 const AttributeList &Attr) { 917 TypedefNameDecl *tDecl = dyn_cast<TypedefNameDecl>(D); 918 if (tDecl == 0) { 919 S.Diag(Attr.getLoc(), diag::err_typecheck_ext_vector_not_typedef); 920 return; 921 } 922 923 QualType curType = tDecl->getUnderlyingType(); 924 925 Expr *sizeExpr; 926 927 // Special case where the argument is a template id. 928 if (Attr.getParameterName()) { 929 CXXScopeSpec SS; 930 SourceLocation TemplateKWLoc; 931 UnqualifiedId id; 932 id.setIdentifier(Attr.getParameterName(), Attr.getLoc()); 933 934 ExprResult Size = S.ActOnIdExpression(scope, SS, TemplateKWLoc, id, 935 false, false); 936 if (Size.isInvalid()) 937 return; 938 939 sizeExpr = Size.get(); 940 } else { 941 // check the attribute arguments. 942 if (!checkAttributeNumArgs(S, Attr, 1)) 943 return; 944 945 sizeExpr = Attr.getArg(0); 946 } 947 948 // Instantiate/Install the vector type, and let Sema build the type for us. 949 // This will run the reguired checks. 950 QualType T = S.BuildExtVectorType(curType, sizeExpr, Attr.getLoc()); 951 if (!T.isNull()) { 952 // FIXME: preserve the old source info. 953 tDecl->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(T)); 954 955 // Remember this typedef decl, we will need it later for diagnostics. 956 S.ExtVectorDecls.push_back(tDecl); 957 } 958} 959 960static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 961 // check the attribute arguments. 962 if (!checkAttributeNumArgs(S, Attr, 0)) 963 return; 964 965 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 966 TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context)); 967 else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 968 // If the alignment is less than or equal to 8 bits, the packed attribute 969 // has no effect. 970 if (!FD->getType()->isIncompleteType() && 971 S.Context.getTypeAlign(FD->getType()) <= 8) 972 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type) 973 << Attr.getName() << FD->getType(); 974 else 975 FD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context)); 976 } else 977 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 978} 979 980static void handleMsStructAttr(Sema &S, Decl *D, const AttributeList &Attr) { 981 if (TagDecl *TD = dyn_cast<TagDecl>(D)) 982 TD->addAttr(::new (S.Context) MsStructAttr(Attr.getRange(), S.Context)); 983 else 984 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 985} 986 987static void handleIBAction(Sema &S, Decl *D, const AttributeList &Attr) { 988 // check the attribute arguments. 989 if (!checkAttributeNumArgs(S, Attr, 0)) 990 return; 991 992 // The IBAction attributes only apply to instance methods. 993 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 994 if (MD->isInstanceMethod()) { 995 D->addAttr(::new (S.Context) IBActionAttr(Attr.getRange(), S.Context)); 996 return; 997 } 998 999 S.Diag(Attr.getLoc(), diag::warn_attribute_ibaction) << Attr.getName(); 1000} 1001 1002static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) { 1003 // The IBOutlet/IBOutletCollection attributes only apply to instance 1004 // variables or properties of Objective-C classes. The outlet must also 1005 // have an object reference type. 1006 if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) { 1007 if (!VD->getType()->getAs<ObjCObjectPointerType>()) { 1008 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type) 1009 << Attr.getName() << VD->getType() << 0; 1010 return false; 1011 } 1012 } 1013 else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) { 1014 if (!PD->getType()->getAs<ObjCObjectPointerType>()) { 1015 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type) 1016 << Attr.getName() << PD->getType() << 1; 1017 return false; 1018 } 1019 } 1020 else { 1021 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName(); 1022 return false; 1023 } 1024 1025 return true; 1026} 1027 1028static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) { 1029 // check the attribute arguments. 1030 if (!checkAttributeNumArgs(S, Attr, 0)) 1031 return; 1032 1033 if (!checkIBOutletCommon(S, D, Attr)) 1034 return; 1035 1036 D->addAttr(::new (S.Context) IBOutletAttr(Attr.getRange(), S.Context)); 1037} 1038 1039static void handleIBOutletCollection(Sema &S, Decl *D, 1040 const AttributeList &Attr) { 1041 1042 // The iboutletcollection attribute can have zero or one arguments. 1043 if (Attr.getParameterName() && Attr.getNumArgs() > 0) { 1044 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1045 return; 1046 } 1047 1048 if (!checkIBOutletCommon(S, D, Attr)) 1049 return; 1050 1051 IdentifierInfo *II = Attr.getParameterName(); 1052 if (!II) 1053 II = &S.Context.Idents.get("NSObject"); 1054 1055 ParsedType TypeRep = S.getTypeName(*II, Attr.getLoc(), 1056 S.getScopeForContext(D->getDeclContext()->getParent())); 1057 if (!TypeRep) { 1058 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II; 1059 return; 1060 } 1061 QualType QT = TypeRep.get(); 1062 // Diagnose use of non-object type in iboutletcollection attribute. 1063 // FIXME. Gnu attribute extension ignores use of builtin types in 1064 // attributes. So, __attribute__((iboutletcollection(char))) will be 1065 // treated as __attribute__((iboutletcollection())). 1066 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) { 1067 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << II; 1068 return; 1069 } 1070 D->addAttr(::new (S.Context) IBOutletCollectionAttr(Attr.getRange(),S.Context, 1071 QT, Attr.getParameterLoc())); 1072} 1073 1074static void possibleTransparentUnionPointerType(QualType &T) { 1075 if (const RecordType *UT = T->getAsUnionType()) 1076 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) { 1077 RecordDecl *UD = UT->getDecl(); 1078 for (RecordDecl::field_iterator it = UD->field_begin(), 1079 itend = UD->field_end(); it != itend; ++it) { 1080 QualType QT = it->getType(); 1081 if (QT->isAnyPointerType() || QT->isBlockPointerType()) { 1082 T = QT; 1083 return; 1084 } 1085 } 1086 } 1087} 1088 1089static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1090 if (!isFunctionOrMethod(D)) { 1091 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1092 << "alloc_size" << ExpectedFunctionOrMethod; 1093 return; 1094 } 1095 1096 if (!checkAttributeAtLeastNumArgs(S, Attr, 1)) 1097 return; 1098 1099 // In C++ the implicit 'this' function parameter also counts, and they are 1100 // counted from one. 1101 bool HasImplicitThisParam = isInstanceMethod(D); 1102 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 1103 1104 SmallVector<unsigned, 8> SizeArgs; 1105 1106 for (AttributeList::arg_iterator I = Attr.arg_begin(), 1107 E = Attr.arg_end(); I!=E; ++I) { 1108 // The argument must be an integer constant expression. 1109 Expr *Ex = *I; 1110 llvm::APSInt ArgNum; 1111 if (Ex->isTypeDependent() || Ex->isValueDependent() || 1112 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) { 1113 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1114 << "alloc_size" << Ex->getSourceRange(); 1115 return; 1116 } 1117 1118 uint64_t x = ArgNum.getZExtValue(); 1119 1120 if (x < 1 || x > NumArgs) { 1121 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1122 << "alloc_size" << I.getArgNum() << Ex->getSourceRange(); 1123 return; 1124 } 1125 1126 --x; 1127 if (HasImplicitThisParam) { 1128 if (x == 0) { 1129 S.Diag(Attr.getLoc(), 1130 diag::err_attribute_invalid_implicit_this_argument) 1131 << "alloc_size" << Ex->getSourceRange(); 1132 return; 1133 } 1134 --x; 1135 } 1136 1137 // check if the function argument is of an integer type 1138 QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType(); 1139 if (!T->isIntegerType()) { 1140 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1141 << "alloc_size" << Ex->getSourceRange(); 1142 return; 1143 } 1144 1145 SizeArgs.push_back(x); 1146 } 1147 1148 // check if the function returns a pointer 1149 if (!getFunctionType(D)->getResultType()->isAnyPointerType()) { 1150 S.Diag(Attr.getLoc(), diag::warn_ns_attribute_wrong_return_type) 1151 << "alloc_size" << 0 /*function*/<< 1 /*pointer*/ << D->getSourceRange(); 1152 } 1153 1154 D->addAttr(::new (S.Context) AllocSizeAttr(Attr.getRange(), S.Context, 1155 SizeArgs.data(), SizeArgs.size())); 1156} 1157 1158static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1159 // GCC ignores the nonnull attribute on K&R style function prototypes, so we 1160 // ignore it as well 1161 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) { 1162 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1163 << Attr.getName() << ExpectedFunction; 1164 return; 1165 } 1166 1167 // In C++ the implicit 'this' function parameter also counts, and they are 1168 // counted from one. 1169 bool HasImplicitThisParam = isInstanceMethod(D); 1170 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 1171 1172 // The nonnull attribute only applies to pointers. 1173 SmallVector<unsigned, 10> NonNullArgs; 1174 1175 for (AttributeList::arg_iterator I=Attr.arg_begin(), 1176 E=Attr.arg_end(); I!=E; ++I) { 1177 1178 1179 // The argument must be an integer constant expression. 1180 Expr *Ex = *I; 1181 llvm::APSInt ArgNum(32); 1182 if (Ex->isTypeDependent() || Ex->isValueDependent() || 1183 !Ex->isIntegerConstantExpr(ArgNum, S.Context)) { 1184 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 1185 << "nonnull" << Ex->getSourceRange(); 1186 return; 1187 } 1188 1189 unsigned x = (unsigned) ArgNum.getZExtValue(); 1190 1191 if (x < 1 || x > NumArgs) { 1192 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 1193 << "nonnull" << I.getArgNum() << Ex->getSourceRange(); 1194 return; 1195 } 1196 1197 --x; 1198 if (HasImplicitThisParam) { 1199 if (x == 0) { 1200 S.Diag(Attr.getLoc(), 1201 diag::err_attribute_invalid_implicit_this_argument) 1202 << "nonnull" << Ex->getSourceRange(); 1203 return; 1204 } 1205 --x; 1206 } 1207 1208 // Is the function argument a pointer type? 1209 QualType T = getFunctionOrMethodArgType(D, x).getNonReferenceType(); 1210 possibleTransparentUnionPointerType(T); 1211 1212 if (!T->isAnyPointerType() && !T->isBlockPointerType()) { 1213 // FIXME: Should also highlight argument in decl. 1214 S.Diag(Attr.getLoc(), diag::warn_nonnull_pointers_only) 1215 << "nonnull" << Ex->getSourceRange(); 1216 continue; 1217 } 1218 1219 NonNullArgs.push_back(x); 1220 } 1221 1222 // If no arguments were specified to __attribute__((nonnull)) then all pointer 1223 // arguments have a nonnull attribute. 1224 if (NonNullArgs.empty()) { 1225 for (unsigned I = 0, E = getFunctionOrMethodNumArgs(D); I != E; ++I) { 1226 QualType T = getFunctionOrMethodArgType(D, I).getNonReferenceType(); 1227 possibleTransparentUnionPointerType(T); 1228 if (T->isAnyPointerType() || T->isBlockPointerType()) 1229 NonNullArgs.push_back(I); 1230 } 1231 1232 // No pointer arguments? 1233 if (NonNullArgs.empty()) { 1234 // Warn the trivial case only if attribute is not coming from a 1235 // macro instantiation. 1236 if (Attr.getLoc().isFileID()) 1237 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers); 1238 return; 1239 } 1240 } 1241 1242 unsigned* start = &NonNullArgs[0]; 1243 unsigned size = NonNullArgs.size(); 1244 llvm::array_pod_sort(start, start + size); 1245 D->addAttr(::new (S.Context) NonNullAttr(Attr.getRange(), S.Context, start, 1246 size)); 1247} 1248 1249static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) { 1250 // This attribute must be applied to a function declaration. 1251 // The first argument to the attribute must be a string, 1252 // the name of the resource, for example "malloc". 1253 // The following arguments must be argument indexes, the arguments must be 1254 // of integer type for Returns, otherwise of pointer type. 1255 // The difference between Holds and Takes is that a pointer may still be used 1256 // after being held. free() should be __attribute((ownership_takes)), whereas 1257 // a list append function may well be __attribute((ownership_holds)). 1258 1259 if (!AL.getParameterName()) { 1260 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_not_string) 1261 << AL.getName()->getName() << 1; 1262 return; 1263 } 1264 // Figure out our Kind, and check arguments while we're at it. 1265 OwnershipAttr::OwnershipKind K; 1266 switch (AL.getKind()) { 1267 case AttributeList::AT_ownership_takes: 1268 K = OwnershipAttr::Takes; 1269 if (AL.getNumArgs() < 1) { 1270 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 1271 return; 1272 } 1273 break; 1274 case AttributeList::AT_ownership_holds: 1275 K = OwnershipAttr::Holds; 1276 if (AL.getNumArgs() < 1) { 1277 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 1278 return; 1279 } 1280 break; 1281 case AttributeList::AT_ownership_returns: 1282 K = OwnershipAttr::Returns; 1283 if (AL.getNumArgs() > 1) { 1284 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) 1285 << AL.getNumArgs() + 1; 1286 return; 1287 } 1288 break; 1289 default: 1290 // This should never happen given how we are called. 1291 llvm_unreachable("Unknown ownership attribute"); 1292 } 1293 1294 if (!isFunction(D) || !hasFunctionProto(D)) { 1295 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 1296 << AL.getName() << ExpectedFunction; 1297 return; 1298 } 1299 1300 // In C++ the implicit 'this' function parameter also counts, and they are 1301 // counted from one. 1302 bool HasImplicitThisParam = isInstanceMethod(D); 1303 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 1304 1305 StringRef Module = AL.getParameterName()->getName(); 1306 1307 // Normalize the argument, __foo__ becomes foo. 1308 if (Module.startswith("__") && Module.endswith("__")) 1309 Module = Module.substr(2, Module.size() - 4); 1310 1311 SmallVector<unsigned, 10> OwnershipArgs; 1312 1313 for (AttributeList::arg_iterator I = AL.arg_begin(), E = AL.arg_end(); I != E; 1314 ++I) { 1315 1316 Expr *IdxExpr = *I; 1317 llvm::APSInt ArgNum(32); 1318 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() 1319 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) { 1320 S.Diag(AL.getLoc(), diag::err_attribute_argument_not_int) 1321 << AL.getName()->getName() << IdxExpr->getSourceRange(); 1322 continue; 1323 } 1324 1325 unsigned x = (unsigned) ArgNum.getZExtValue(); 1326 1327 if (x > NumArgs || x < 1) { 1328 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 1329 << AL.getName()->getName() << x << IdxExpr->getSourceRange(); 1330 continue; 1331 } 1332 --x; 1333 if (HasImplicitThisParam) { 1334 if (x == 0) { 1335 S.Diag(AL.getLoc(), diag::err_attribute_invalid_implicit_this_argument) 1336 << "ownership" << IdxExpr->getSourceRange(); 1337 return; 1338 } 1339 --x; 1340 } 1341 1342 switch (K) { 1343 case OwnershipAttr::Takes: 1344 case OwnershipAttr::Holds: { 1345 // Is the function argument a pointer type? 1346 QualType T = getFunctionOrMethodArgType(D, x); 1347 if (!T->isAnyPointerType() && !T->isBlockPointerType()) { 1348 // FIXME: Should also highlight argument in decl. 1349 S.Diag(AL.getLoc(), diag::err_ownership_type) 1350 << ((K==OwnershipAttr::Takes)?"ownership_takes":"ownership_holds") 1351 << "pointer" 1352 << IdxExpr->getSourceRange(); 1353 continue; 1354 } 1355 break; 1356 } 1357 case OwnershipAttr::Returns: { 1358 if (AL.getNumArgs() > 1) { 1359 // Is the function argument an integer type? 1360 Expr *IdxExpr = AL.getArg(0); 1361 llvm::APSInt ArgNum(32); 1362 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() 1363 || !IdxExpr->isIntegerConstantExpr(ArgNum, S.Context)) { 1364 S.Diag(AL.getLoc(), diag::err_ownership_type) 1365 << "ownership_returns" << "integer" 1366 << IdxExpr->getSourceRange(); 1367 return; 1368 } 1369 } 1370 break; 1371 } 1372 } // switch 1373 1374 // Check we don't have a conflict with another ownership attribute. 1375 for (specific_attr_iterator<OwnershipAttr> 1376 i = D->specific_attr_begin<OwnershipAttr>(), 1377 e = D->specific_attr_end<OwnershipAttr>(); 1378 i != e; ++i) { 1379 if ((*i)->getOwnKind() != K) { 1380 for (const unsigned *I = (*i)->args_begin(), *E = (*i)->args_end(); 1381 I!=E; ++I) { 1382 if (x == *I) { 1383 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) 1384 << AL.getName()->getName() << "ownership_*"; 1385 } 1386 } 1387 } 1388 } 1389 OwnershipArgs.push_back(x); 1390 } 1391 1392 unsigned* start = OwnershipArgs.data(); 1393 unsigned size = OwnershipArgs.size(); 1394 llvm::array_pod_sort(start, start + size); 1395 1396 if (K != OwnershipAttr::Returns && OwnershipArgs.empty()) { 1397 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << 2; 1398 return; 1399 } 1400 1401 D->addAttr(::new (S.Context) OwnershipAttr(AL.getLoc(), S.Context, K, Module, 1402 start, size)); 1403} 1404 1405/// Whether this declaration has internal linkage for the purposes of 1406/// things that want to complain about things not have internal linkage. 1407static bool hasEffectivelyInternalLinkage(NamedDecl *D) { 1408 switch (D->getLinkage()) { 1409 case NoLinkage: 1410 case InternalLinkage: 1411 return true; 1412 1413 // Template instantiations that go from external to unique-external 1414 // shouldn't get diagnosed. 1415 case UniqueExternalLinkage: 1416 return true; 1417 1418 case ExternalLinkage: 1419 return false; 1420 } 1421 llvm_unreachable("unknown linkage kind!"); 1422} 1423 1424static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1425 // Check the attribute arguments. 1426 if (Attr.getNumArgs() > 1) { 1427 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1428 return; 1429 } 1430 1431 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) { 1432 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 1433 << Attr.getName() << ExpectedVariableOrFunction; 1434 return; 1435 } 1436 1437 NamedDecl *nd = cast<NamedDecl>(D); 1438 1439 // gcc rejects 1440 // class c { 1441 // static int a __attribute__((weakref ("v2"))); 1442 // static int b() __attribute__((weakref ("f3"))); 1443 // }; 1444 // and ignores the attributes of 1445 // void f(void) { 1446 // static int a __attribute__((weakref ("v2"))); 1447 // } 1448 // we reject them 1449 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext(); 1450 if (!Ctx->isFileContext()) { 1451 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context) << 1452 nd->getNameAsString(); 1453 return; 1454 } 1455 1456 // The GCC manual says 1457 // 1458 // At present, a declaration to which `weakref' is attached can only 1459 // be `static'. 1460 // 1461 // It also says 1462 // 1463 // Without a TARGET, 1464 // given as an argument to `weakref' or to `alias', `weakref' is 1465 // equivalent to `weak'. 1466 // 1467 // gcc 4.4.1 will accept 1468 // int a7 __attribute__((weakref)); 1469 // as 1470 // int a7 __attribute__((weak)); 1471 // This looks like a bug in gcc. We reject that for now. We should revisit 1472 // it if this behaviour is actually used. 1473 1474 if (!hasEffectivelyInternalLinkage(nd)) { 1475 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_static); 1476 return; 1477 } 1478 1479 // GCC rejects 1480 // static ((alias ("y"), weakref)). 1481 // Should we? How to check that weakref is before or after alias? 1482 1483 if (Attr.getNumArgs() == 1) { 1484 Expr *Arg = Attr.getArg(0); 1485 Arg = Arg->IgnoreParenCasts(); 1486 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 1487 1488 if (!Str || !Str->isAscii()) { 1489 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1490 << "weakref" << 1; 1491 return; 1492 } 1493 // GCC will accept anything as the argument of weakref. Should we 1494 // check for an existing decl? 1495 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, 1496 Str->getString())); 1497 } 1498 1499 D->addAttr(::new (S.Context) WeakRefAttr(Attr.getRange(), S.Context)); 1500} 1501 1502static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1503 // check the attribute arguments. 1504 if (Attr.getNumArgs() != 1) { 1505 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1506 return; 1507 } 1508 1509 Expr *Arg = Attr.getArg(0); 1510 Arg = Arg->IgnoreParenCasts(); 1511 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 1512 1513 if (!Str || !Str->isAscii()) { 1514 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1515 << "alias" << 1; 1516 return; 1517 } 1518 1519 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) { 1520 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin); 1521 return; 1522 } 1523 1524 // FIXME: check if target symbol exists in current file 1525 1526 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, 1527 Str->getString())); 1528} 1529 1530static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1531 // Check the attribute arguments. 1532 if (!checkAttributeNumArgs(S, Attr, 0)) 1533 return; 1534 1535 if (!isa<FunctionDecl>(D)) { 1536 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1537 << Attr.getName() << ExpectedFunction; 1538 return; 1539 } 1540 1541 if (D->hasAttr<HotAttr>()) { 1542 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 1543 << Attr.getName() << "hot"; 1544 return; 1545 } 1546 1547 D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context)); 1548} 1549 1550static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1551 // Check the attribute arguments. 1552 if (!checkAttributeNumArgs(S, Attr, 0)) 1553 return; 1554 1555 if (!isa<FunctionDecl>(D)) { 1556 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1557 << Attr.getName() << ExpectedFunction; 1558 return; 1559 } 1560 1561 if (D->hasAttr<ColdAttr>()) { 1562 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 1563 << Attr.getName() << "cold"; 1564 return; 1565 } 1566 1567 D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context)); 1568} 1569 1570static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1571 // Check the attribute arguments. 1572 if (!checkAttributeNumArgs(S, Attr, 0)) 1573 return; 1574 1575 if (!isa<FunctionDecl>(D)) { 1576 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1577 << Attr.getName() << ExpectedFunction; 1578 return; 1579 } 1580 1581 D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context)); 1582} 1583 1584static void handleAlwaysInlineAttr(Sema &S, Decl *D, 1585 const AttributeList &Attr) { 1586 // Check the attribute arguments. 1587 if (Attr.hasParameterOrArguments()) { 1588 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1589 return; 1590 } 1591 1592 if (!isa<FunctionDecl>(D)) { 1593 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1594 << Attr.getName() << ExpectedFunction; 1595 return; 1596 } 1597 1598 D->addAttr(::new (S.Context) AlwaysInlineAttr(Attr.getRange(), S.Context)); 1599} 1600 1601static void handleTLSModelAttr(Sema &S, Decl *D, 1602 const AttributeList &Attr) { 1603 // Check the attribute arguments. 1604 if (Attr.getNumArgs() != 1) { 1605 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1606 return; 1607 } 1608 1609 Expr *Arg = Attr.getArg(0); 1610 Arg = Arg->IgnoreParenCasts(); 1611 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 1612 1613 // Check that it is a string. 1614 if (!Str) { 1615 S.Diag(Attr.getLoc(), diag::err_attribute_not_string) << "tls_model"; 1616 return; 1617 } 1618 1619 if (!isa<VarDecl>(D) || !cast<VarDecl>(D)->isThreadSpecified()) { 1620 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 1621 << Attr.getName() << ExpectedTLSVar; 1622 return; 1623 } 1624 1625 // Check that the value. 1626 StringRef Model = Str->getString(); 1627 if (Model != "global-dynamic" && Model != "local-dynamic" 1628 && Model != "initial-exec" && Model != "local-exec") { 1629 S.Diag(Attr.getLoc(), diag::err_attr_tlsmodel_arg); 1630 return; 1631 } 1632 1633 D->addAttr(::new (S.Context) TLSModelAttr(Attr.getRange(), S.Context, 1634 Model)); 1635} 1636 1637static void handleMallocAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1638 // Check the attribute arguments. 1639 if (Attr.hasParameterOrArguments()) { 1640 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1641 return; 1642 } 1643 1644 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1645 QualType RetTy = FD->getResultType(); 1646 if (RetTy->isAnyPointerType() || RetTy->isBlockPointerType()) { 1647 D->addAttr(::new (S.Context) MallocAttr(Attr.getRange(), S.Context)); 1648 return; 1649 } 1650 } 1651 1652 S.Diag(Attr.getLoc(), diag::warn_attribute_malloc_pointer_only); 1653} 1654 1655static void handleMayAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1656 // check the attribute arguments. 1657 if (!checkAttributeNumArgs(S, Attr, 0)) 1658 return; 1659 1660 D->addAttr(::new (S.Context) MayAliasAttr(Attr.getRange(), S.Context)); 1661} 1662 1663static void handleNoCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1664 assert(!Attr.isInvalid()); 1665 if (isa<VarDecl>(D)) 1666 D->addAttr(::new (S.Context) NoCommonAttr(Attr.getRange(), S.Context)); 1667 else 1668 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1669 << Attr.getName() << ExpectedVariable; 1670} 1671 1672static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1673 assert(!Attr.isInvalid()); 1674 if (isa<VarDecl>(D)) 1675 D->addAttr(::new (S.Context) CommonAttr(Attr.getRange(), S.Context)); 1676 else 1677 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1678 << Attr.getName() << ExpectedVariable; 1679} 1680 1681static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &attr) { 1682 if (hasDeclarator(D)) return; 1683 1684 if (S.CheckNoReturnAttr(attr)) return; 1685 1686 if (!isa<ObjCMethodDecl>(D)) { 1687 S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1688 << attr.getName() << ExpectedFunctionOrMethod; 1689 return; 1690 } 1691 1692 D->addAttr(::new (S.Context) NoReturnAttr(attr.getRange(), S.Context)); 1693} 1694 1695bool Sema::CheckNoReturnAttr(const AttributeList &attr) { 1696 if (attr.hasParameterOrArguments()) { 1697 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1698 attr.setInvalid(); 1699 return true; 1700 } 1701 1702 return false; 1703} 1704 1705static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, 1706 const AttributeList &Attr) { 1707 1708 // The checking path for 'noreturn' and 'analyzer_noreturn' are different 1709 // because 'analyzer_noreturn' does not impact the type. 1710 1711 if(!checkAttributeNumArgs(S, Attr, 0)) 1712 return; 1713 1714 if (!isFunctionOrMethod(D) && !isa<BlockDecl>(D)) { 1715 ValueDecl *VD = dyn_cast<ValueDecl>(D); 1716 if (VD == 0 || (!VD->getType()->isBlockPointerType() 1717 && !VD->getType()->isFunctionPointerType())) { 1718 S.Diag(Attr.getLoc(), 1719 Attr.isCXX0XAttribute() ? diag::err_attribute_wrong_decl_type 1720 : diag::warn_attribute_wrong_decl_type) 1721 << Attr.getName() << ExpectedFunctionMethodOrBlock; 1722 return; 1723 } 1724 } 1725 1726 D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(Attr.getRange(), S.Context)); 1727} 1728 1729// PS3 PPU-specific. 1730static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1731/* 1732 Returning a Vector Class in Registers 1733 1734 According to the PPU ABI specifications, a class with a single member of 1735 vector type is returned in memory when used as the return value of a function. 1736 This results in inefficient code when implementing vector classes. To return 1737 the value in a single vector register, add the vecreturn attribute to the 1738 class definition. This attribute is also applicable to struct types. 1739 1740 Example: 1741 1742 struct Vector 1743 { 1744 __vector float xyzw; 1745 } __attribute__((vecreturn)); 1746 1747 Vector Add(Vector lhs, Vector rhs) 1748 { 1749 Vector result; 1750 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw); 1751 return result; // This will be returned in a register 1752 } 1753*/ 1754 if (!isa<RecordDecl>(D)) { 1755 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 1756 << Attr.getName() << ExpectedClass; 1757 return; 1758 } 1759 1760 if (D->getAttr<VecReturnAttr>()) { 1761 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << "vecreturn"; 1762 return; 1763 } 1764 1765 RecordDecl *record = cast<RecordDecl>(D); 1766 int count = 0; 1767 1768 if (!isa<CXXRecordDecl>(record)) { 1769 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 1770 return; 1771 } 1772 1773 if (!cast<CXXRecordDecl>(record)->isPOD()) { 1774 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record); 1775 return; 1776 } 1777 1778 for (RecordDecl::field_iterator iter = record->field_begin(); 1779 iter != record->field_end(); iter++) { 1780 if ((count == 1) || !iter->getType()->isVectorType()) { 1781 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 1782 return; 1783 } 1784 count++; 1785 } 1786 1787 D->addAttr(::new (S.Context) VecReturnAttr(Attr.getRange(), S.Context)); 1788} 1789 1790static void handleDependencyAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1791 if (!isFunctionOrMethod(D) && !isa<ParmVarDecl>(D)) { 1792 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 1793 << Attr.getName() << ExpectedFunctionMethodOrParameter; 1794 return; 1795 } 1796 // FIXME: Actually store the attribute on the declaration 1797} 1798 1799static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1800 // check the attribute arguments. 1801 if (Attr.hasParameterOrArguments()) { 1802 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1803 return; 1804 } 1805 1806 if (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isFunctionOrMethod(D) && 1807 !isa<TypeDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D)) { 1808 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1809 << Attr.getName() << ExpectedVariableFunctionOrLabel; 1810 return; 1811 } 1812 1813 D->addAttr(::new (S.Context) UnusedAttr(Attr.getRange(), S.Context)); 1814} 1815 1816static void handleReturnsTwiceAttr(Sema &S, Decl *D, 1817 const AttributeList &Attr) { 1818 // check the attribute arguments. 1819 if (Attr.hasParameterOrArguments()) { 1820 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1821 return; 1822 } 1823 1824 if (!isa<FunctionDecl>(D)) { 1825 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1826 << Attr.getName() << ExpectedFunction; 1827 return; 1828 } 1829 1830 D->addAttr(::new (S.Context) ReturnsTwiceAttr(Attr.getRange(), S.Context)); 1831} 1832 1833static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1834 // check the attribute arguments. 1835 if (Attr.hasParameterOrArguments()) { 1836 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 1837 return; 1838 } 1839 1840 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1841 if (VD->hasLocalStorage() || VD->hasExternalStorage()) { 1842 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "used"; 1843 return; 1844 } 1845 } else if (!isFunctionOrMethod(D)) { 1846 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1847 << Attr.getName() << ExpectedVariableOrFunction; 1848 return; 1849 } 1850 1851 D->addAttr(::new (S.Context) UsedAttr(Attr.getRange(), S.Context)); 1852} 1853 1854static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1855 // check the attribute arguments. 1856 if (Attr.getNumArgs() > 1) { 1857 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1; 1858 return; 1859 } 1860 1861 int priority = 65535; // FIXME: Do not hardcode such constants. 1862 if (Attr.getNumArgs() > 0) { 1863 Expr *E = Attr.getArg(0); 1864 llvm::APSInt Idx(32); 1865 if (E->isTypeDependent() || E->isValueDependent() || 1866 !E->isIntegerConstantExpr(Idx, S.Context)) { 1867 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1868 << "constructor" << 1 << E->getSourceRange(); 1869 return; 1870 } 1871 priority = Idx.getZExtValue(); 1872 } 1873 1874 if (!isa<FunctionDecl>(D)) { 1875 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1876 << Attr.getName() << ExpectedFunction; 1877 return; 1878 } 1879 1880 D->addAttr(::new (S.Context) ConstructorAttr(Attr.getRange(), S.Context, 1881 priority)); 1882} 1883 1884static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) { 1885 // check the attribute arguments. 1886 if (Attr.getNumArgs() > 1) { 1887 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1; 1888 return; 1889 } 1890 1891 int priority = 65535; // FIXME: Do not hardcode such constants. 1892 if (Attr.getNumArgs() > 0) { 1893 Expr *E = Attr.getArg(0); 1894 llvm::APSInt Idx(32); 1895 if (E->isTypeDependent() || E->isValueDependent() || 1896 !E->isIntegerConstantExpr(Idx, S.Context)) { 1897 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 1898 << "destructor" << 1 << E->getSourceRange(); 1899 return; 1900 } 1901 priority = Idx.getZExtValue(); 1902 } 1903 1904 if (!isa<FunctionDecl>(D)) { 1905 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 1906 << Attr.getName() << ExpectedFunction; 1907 return; 1908 } 1909 1910 D->addAttr(::new (S.Context) DestructorAttr(Attr.getRange(), S.Context, 1911 priority)); 1912} 1913 1914template <typename AttrTy> 1915static void handleAttrWithMessage(Sema &S, Decl *D, const AttributeList &Attr, 1916 const char *Name) { 1917 unsigned NumArgs = Attr.getNumArgs(); 1918 if (NumArgs > 1) { 1919 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 1; 1920 return; 1921 } 1922 1923 // Handle the case where the attribute has a text message. 1924 StringRef Str; 1925 if (NumArgs == 1) { 1926 StringLiteral *SE = dyn_cast<StringLiteral>(Attr.getArg(0)); 1927 if (!SE) { 1928 S.Diag(Attr.getArg(0)->getLocStart(), diag::err_attribute_not_string) 1929 << Name; 1930 return; 1931 } 1932 Str = SE->getString(); 1933 } 1934 1935 D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str)); 1936} 1937 1938static void handleArcWeakrefUnavailableAttr(Sema &S, Decl *D, 1939 const AttributeList &Attr) { 1940 unsigned NumArgs = Attr.getNumArgs(); 1941 if (NumArgs > 0) { 1942 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0; 1943 return; 1944 } 1945 1946 D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr( 1947 Attr.getRange(), S.Context)); 1948} 1949 1950static void handleObjCRootClassAttr(Sema &S, Decl *D, 1951 const AttributeList &Attr) { 1952 if (!isa<ObjCInterfaceDecl>(D)) { 1953 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface); 1954 return; 1955 } 1956 1957 unsigned NumArgs = Attr.getNumArgs(); 1958 if (NumArgs > 0) { 1959 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0; 1960 return; 1961 } 1962 1963 D->addAttr(::new (S.Context) ObjCRootClassAttr(Attr.getRange(), S.Context)); 1964} 1965 1966static void handleObjCRequiresPropertyDefsAttr(Sema &S, Decl *D, 1967 const AttributeList &Attr) { 1968 if (!isa<ObjCInterfaceDecl>(D)) { 1969 S.Diag(Attr.getLoc(), diag::err_suppress_autosynthesis); 1970 return; 1971 } 1972 1973 unsigned NumArgs = Attr.getNumArgs(); 1974 if (NumArgs > 0) { 1975 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 0; 1976 return; 1977 } 1978 1979 D->addAttr(::new (S.Context) ObjCRequiresPropertyDefsAttr( 1980 Attr.getRange(), S.Context)); 1981} 1982 1983static bool checkAvailabilityAttr(Sema &S, SourceRange Range, 1984 IdentifierInfo *Platform, 1985 VersionTuple Introduced, 1986 VersionTuple Deprecated, 1987 VersionTuple Obsoleted) { 1988 StringRef PlatformName 1989 = AvailabilityAttr::getPrettyPlatformName(Platform->getName()); 1990 if (PlatformName.empty()) 1991 PlatformName = Platform->getName(); 1992 1993 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all 1994 // of these steps are needed). 1995 if (!Introduced.empty() && !Deprecated.empty() && 1996 !(Introduced <= Deprecated)) { 1997 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 1998 << 1 << PlatformName << Deprecated.getAsString() 1999 << 0 << Introduced.getAsString(); 2000 return true; 2001 } 2002 2003 if (!Introduced.empty() && !Obsoleted.empty() && 2004 !(Introduced <= Obsoleted)) { 2005 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 2006 << 2 << PlatformName << Obsoleted.getAsString() 2007 << 0 << Introduced.getAsString(); 2008 return true; 2009 } 2010 2011 if (!Deprecated.empty() && !Obsoleted.empty() && 2012 !(Deprecated <= Obsoleted)) { 2013 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 2014 << 2 << PlatformName << Obsoleted.getAsString() 2015 << 1 << Deprecated.getAsString(); 2016 return true; 2017 } 2018 2019 return false; 2020} 2021 2022AvailabilityAttr *Sema::mergeAvailabilityAttr(Decl *D, SourceRange Range, 2023 IdentifierInfo *Platform, 2024 VersionTuple Introduced, 2025 VersionTuple Deprecated, 2026 VersionTuple Obsoleted, 2027 bool IsUnavailable, 2028 StringRef Message) { 2029 VersionTuple MergedIntroduced = Introduced; 2030 VersionTuple MergedDeprecated = Deprecated; 2031 VersionTuple MergedObsoleted = Obsoleted; 2032 bool FoundAny = false; 2033 2034 if (D->hasAttrs()) { 2035 AttrVec &Attrs = D->getAttrs(); 2036 for (unsigned i = 0, e = Attrs.size(); i != e;) { 2037 const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]); 2038 if (!OldAA) { 2039 ++i; 2040 continue; 2041 } 2042 2043 IdentifierInfo *OldPlatform = OldAA->getPlatform(); 2044 if (OldPlatform != Platform) { 2045 ++i; 2046 continue; 2047 } 2048 2049 FoundAny = true; 2050 VersionTuple OldIntroduced = OldAA->getIntroduced(); 2051 VersionTuple OldDeprecated = OldAA->getDeprecated(); 2052 VersionTuple OldObsoleted = OldAA->getObsoleted(); 2053 bool OldIsUnavailable = OldAA->getUnavailable(); 2054 StringRef OldMessage = OldAA->getMessage(); 2055 2056 if ((!OldIntroduced.empty() && !Introduced.empty() && 2057 OldIntroduced != Introduced) || 2058 (!OldDeprecated.empty() && !Deprecated.empty() && 2059 OldDeprecated != Deprecated) || 2060 (!OldObsoleted.empty() && !Obsoleted.empty() && 2061 OldObsoleted != Obsoleted) || 2062 (OldIsUnavailable != IsUnavailable) || 2063 (OldMessage != Message)) { 2064 Diag(OldAA->getLocation(), diag::warn_mismatched_availability); 2065 Diag(Range.getBegin(), diag::note_previous_attribute); 2066 Attrs.erase(Attrs.begin() + i); 2067 --e; 2068 continue; 2069 } 2070 2071 VersionTuple MergedIntroduced2 = MergedIntroduced; 2072 VersionTuple MergedDeprecated2 = MergedDeprecated; 2073 VersionTuple MergedObsoleted2 = MergedObsoleted; 2074 2075 if (MergedIntroduced2.empty()) 2076 MergedIntroduced2 = OldIntroduced; 2077 if (MergedDeprecated2.empty()) 2078 MergedDeprecated2 = OldDeprecated; 2079 if (MergedObsoleted2.empty()) 2080 MergedObsoleted2 = OldObsoleted; 2081 2082 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform, 2083 MergedIntroduced2, MergedDeprecated2, 2084 MergedObsoleted2)) { 2085 Attrs.erase(Attrs.begin() + i); 2086 --e; 2087 continue; 2088 } 2089 2090 MergedIntroduced = MergedIntroduced2; 2091 MergedDeprecated = MergedDeprecated2; 2092 MergedObsoleted = MergedObsoleted2; 2093 ++i; 2094 } 2095 } 2096 2097 if (FoundAny && 2098 MergedIntroduced == Introduced && 2099 MergedDeprecated == Deprecated && 2100 MergedObsoleted == Obsoleted) 2101 return NULL; 2102 2103 if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced, 2104 MergedDeprecated, MergedObsoleted)) { 2105 return ::new (Context) AvailabilityAttr(Range, Context, Platform, 2106 Introduced, Deprecated, 2107 Obsoleted, IsUnavailable, Message); 2108 } 2109 return NULL; 2110} 2111 2112static void handleAvailabilityAttr(Sema &S, Decl *D, 2113 const AttributeList &Attr) { 2114 IdentifierInfo *Platform = Attr.getParameterName(); 2115 SourceLocation PlatformLoc = Attr.getParameterLoc(); 2116 2117 if (AvailabilityAttr::getPrettyPlatformName(Platform->getName()).empty()) 2118 S.Diag(PlatformLoc, diag::warn_availability_unknown_platform) 2119 << Platform; 2120 2121 AvailabilityChange Introduced = Attr.getAvailabilityIntroduced(); 2122 AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated(); 2123 AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted(); 2124 bool IsUnavailable = Attr.getUnavailableLoc().isValid(); 2125 StringRef Str; 2126 const StringLiteral *SE = 2127 dyn_cast_or_null<const StringLiteral>(Attr.getMessageExpr()); 2128 if (SE) 2129 Str = SE->getString(); 2130 2131 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(D, Attr.getRange(), 2132 Platform, 2133 Introduced.Version, 2134 Deprecated.Version, 2135 Obsoleted.Version, 2136 IsUnavailable, Str); 2137 if (NewAttr) 2138 D->addAttr(NewAttr); 2139} 2140 2141VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range, 2142 VisibilityAttr::VisibilityType Vis) { 2143 if (isa<TypedefNameDecl>(D)) { 2144 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "visibility"; 2145 return NULL; 2146 } 2147 VisibilityAttr *ExistingAttr = D->getAttr<VisibilityAttr>(); 2148 if (ExistingAttr) { 2149 VisibilityAttr::VisibilityType ExistingVis = ExistingAttr->getVisibility(); 2150 if (ExistingVis == Vis) 2151 return NULL; 2152 Diag(ExistingAttr->getLocation(), diag::err_mismatched_visibility); 2153 Diag(Range.getBegin(), diag::note_previous_attribute); 2154 D->dropAttr<VisibilityAttr>(); 2155 } 2156 return ::new (Context) VisibilityAttr(Range, Context, Vis); 2157} 2158 2159static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2160 // check the attribute arguments. 2161 if(!checkAttributeNumArgs(S, Attr, 1)) 2162 return; 2163 2164 Expr *Arg = Attr.getArg(0); 2165 Arg = Arg->IgnoreParenCasts(); 2166 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 2167 2168 if (!Str || !Str->isAscii()) { 2169 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 2170 << "visibility" << 1; 2171 return; 2172 } 2173 2174 StringRef TypeStr = Str->getString(); 2175 VisibilityAttr::VisibilityType type; 2176 2177 if (TypeStr == "default") 2178 type = VisibilityAttr::Default; 2179 else if (TypeStr == "hidden") 2180 type = VisibilityAttr::Hidden; 2181 else if (TypeStr == "internal") 2182 type = VisibilityAttr::Hidden; // FIXME 2183 else if (TypeStr == "protected") { 2184 // Complain about attempts to use protected visibility on targets 2185 // (like Darwin) that don't support it. 2186 if (!S.Context.getTargetInfo().hasProtectedVisibility()) { 2187 S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility); 2188 type = VisibilityAttr::Default; 2189 } else { 2190 type = VisibilityAttr::Protected; 2191 } 2192 } else { 2193 S.Diag(Attr.getLoc(), diag::warn_attribute_unknown_visibility) << TypeStr; 2194 return; 2195 } 2196 2197 VisibilityAttr *NewAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type); 2198 if (NewAttr) 2199 D->addAttr(NewAttr); 2200} 2201 2202static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl, 2203 const AttributeList &Attr) { 2204 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(decl); 2205 if (!method) { 2206 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 2207 << ExpectedMethod; 2208 return; 2209 } 2210 2211 if (Attr.getNumArgs() != 0 || !Attr.getParameterName()) { 2212 if (!Attr.getParameterName() && Attr.getNumArgs() == 1) { 2213 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 2214 << "objc_method_family" << 1; 2215 } else { 2216 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2217 } 2218 Attr.setInvalid(); 2219 return; 2220 } 2221 2222 StringRef param = Attr.getParameterName()->getName(); 2223 ObjCMethodFamilyAttr::FamilyKind family; 2224 if (param == "none") 2225 family = ObjCMethodFamilyAttr::OMF_None; 2226 else if (param == "alloc") 2227 family = ObjCMethodFamilyAttr::OMF_alloc; 2228 else if (param == "copy") 2229 family = ObjCMethodFamilyAttr::OMF_copy; 2230 else if (param == "init") 2231 family = ObjCMethodFamilyAttr::OMF_init; 2232 else if (param == "mutableCopy") 2233 family = ObjCMethodFamilyAttr::OMF_mutableCopy; 2234 else if (param == "new") 2235 family = ObjCMethodFamilyAttr::OMF_new; 2236 else { 2237 // Just warn and ignore it. This is future-proof against new 2238 // families being used in system headers. 2239 S.Diag(Attr.getParameterLoc(), diag::warn_unknown_method_family); 2240 return; 2241 } 2242 2243 if (family == ObjCMethodFamilyAttr::OMF_init && 2244 !method->getResultType()->isObjCObjectPointerType()) { 2245 S.Diag(method->getLocation(), diag::err_init_method_bad_return_type) 2246 << method->getResultType(); 2247 // Ignore the attribute. 2248 return; 2249 } 2250 2251 method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(), 2252 S.Context, family)); 2253} 2254 2255static void handleObjCExceptionAttr(Sema &S, Decl *D, 2256 const AttributeList &Attr) { 2257 if (!checkAttributeNumArgs(S, Attr, 0)) 2258 return; 2259 2260 ObjCInterfaceDecl *OCI = dyn_cast<ObjCInterfaceDecl>(D); 2261 if (OCI == 0) { 2262 S.Diag(Attr.getLoc(), diag::err_attribute_requires_objc_interface); 2263 return; 2264 } 2265 2266 D->addAttr(::new (S.Context) ObjCExceptionAttr(Attr.getRange(), S.Context)); 2267} 2268 2269static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) { 2270 if (Attr.getNumArgs() != 0) { 2271 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2272 return; 2273 } 2274 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 2275 QualType T = TD->getUnderlyingType(); 2276 if (!T->isCARCBridgableType()) { 2277 S.Diag(TD->getLocation(), diag::err_nsobject_attribute); 2278 return; 2279 } 2280 } 2281 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) { 2282 QualType T = PD->getType(); 2283 if (!T->isCARCBridgableType()) { 2284 S.Diag(PD->getLocation(), diag::err_nsobject_attribute); 2285 return; 2286 } 2287 } 2288 else { 2289 // It is okay to include this attribute on properties, e.g.: 2290 // 2291 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject)); 2292 // 2293 // In this case it follows tradition and suppresses an error in the above 2294 // case. 2295 S.Diag(D->getLocation(), diag::warn_nsobject_attribute); 2296 } 2297 D->addAttr(::new (S.Context) ObjCNSObjectAttr(Attr.getRange(), S.Context)); 2298} 2299 2300static void 2301handleOverloadableAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2302 if (Attr.getNumArgs() != 0) { 2303 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2304 return; 2305 } 2306 2307 if (!isa<FunctionDecl>(D)) { 2308 S.Diag(Attr.getLoc(), diag::err_attribute_overloadable_not_function); 2309 return; 2310 } 2311 2312 D->addAttr(::new (S.Context) OverloadableAttr(Attr.getRange(), S.Context)); 2313} 2314 2315static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2316 if (!Attr.getParameterName()) { 2317 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 2318 << "blocks" << 1; 2319 return; 2320 } 2321 2322 if (Attr.getNumArgs() != 0) { 2323 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2324 return; 2325 } 2326 2327 BlocksAttr::BlockType type; 2328 if (Attr.getParameterName()->isStr("byref")) 2329 type = BlocksAttr::ByRef; 2330 else { 2331 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 2332 << "blocks" << Attr.getParameterName(); 2333 return; 2334 } 2335 2336 D->addAttr(::new (S.Context) BlocksAttr(Attr.getRange(), S.Context, type)); 2337} 2338 2339static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2340 // check the attribute arguments. 2341 if (Attr.getNumArgs() > 2) { 2342 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2; 2343 return; 2344 } 2345 2346 unsigned sentinel = 0; 2347 if (Attr.getNumArgs() > 0) { 2348 Expr *E = Attr.getArg(0); 2349 llvm::APSInt Idx(32); 2350 if (E->isTypeDependent() || E->isValueDependent() || 2351 !E->isIntegerConstantExpr(Idx, S.Context)) { 2352 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 2353 << "sentinel" << 1 << E->getSourceRange(); 2354 return; 2355 } 2356 2357 if (Idx.isSigned() && Idx.isNegative()) { 2358 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero) 2359 << E->getSourceRange(); 2360 return; 2361 } 2362 2363 sentinel = Idx.getZExtValue(); 2364 } 2365 2366 unsigned nullPos = 0; 2367 if (Attr.getNumArgs() > 1) { 2368 Expr *E = Attr.getArg(1); 2369 llvm::APSInt Idx(32); 2370 if (E->isTypeDependent() || E->isValueDependent() || 2371 !E->isIntegerConstantExpr(Idx, S.Context)) { 2372 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 2373 << "sentinel" << 2 << E->getSourceRange(); 2374 return; 2375 } 2376 nullPos = Idx.getZExtValue(); 2377 2378 if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) { 2379 // FIXME: This error message could be improved, it would be nice 2380 // to say what the bounds actually are. 2381 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one) 2382 << E->getSourceRange(); 2383 return; 2384 } 2385 } 2386 2387 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2388 const FunctionType *FT = FD->getType()->castAs<FunctionType>(); 2389 if (isa<FunctionNoProtoType>(FT)) { 2390 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments); 2391 return; 2392 } 2393 2394 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 2395 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 2396 return; 2397 } 2398 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 2399 if (!MD->isVariadic()) { 2400 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 2401 return; 2402 } 2403 } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) { 2404 if (!BD->isVariadic()) { 2405 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1; 2406 return; 2407 } 2408 } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) { 2409 QualType Ty = V->getType(); 2410 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 2411 const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D) 2412 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 2413 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 2414 int m = Ty->isFunctionPointerType() ? 0 : 1; 2415 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m; 2416 return; 2417 } 2418 } else { 2419 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2420 << Attr.getName() << ExpectedFunctionMethodOrBlock; 2421 return; 2422 } 2423 } else { 2424 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2425 << Attr.getName() << ExpectedFunctionMethodOrBlock; 2426 return; 2427 } 2428 D->addAttr(::new (S.Context) SentinelAttr(Attr.getRange(), S.Context, sentinel, 2429 nullPos)); 2430} 2431 2432static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) { 2433 // check the attribute arguments. 2434 if (!checkAttributeNumArgs(S, Attr, 0)) 2435 return; 2436 2437 if (!isFunction(D) && !isa<ObjCMethodDecl>(D)) { 2438 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2439 << Attr.getName() << ExpectedFunctionOrMethod; 2440 return; 2441 } 2442 2443 if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) { 2444 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method) 2445 << Attr.getName() << 0; 2446 return; 2447 } 2448 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 2449 if (MD->getResultType()->isVoidType()) { 2450 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method) 2451 << Attr.getName() << 1; 2452 return; 2453 } 2454 2455 D->addAttr(::new (S.Context) WarnUnusedResultAttr(Attr.getRange(), S.Context)); 2456} 2457 2458static void handleWeakAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2459 // check the attribute arguments. 2460 if (Attr.hasParameterOrArguments()) { 2461 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2462 return; 2463 } 2464 2465 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) { 2466 if (isa<CXXRecordDecl>(D)) { 2467 D->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context)); 2468 return; 2469 } 2470 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2471 << Attr.getName() << ExpectedVariableOrFunction; 2472 return; 2473 } 2474 2475 NamedDecl *nd = cast<NamedDecl>(D); 2476 2477 // 'weak' only applies to declarations with external linkage. 2478 if (hasEffectivelyInternalLinkage(nd)) { 2479 S.Diag(Attr.getLoc(), diag::err_attribute_weak_static); 2480 return; 2481 } 2482 2483 nd->addAttr(::new (S.Context) WeakAttr(Attr.getRange(), S.Context)); 2484} 2485 2486static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2487 // check the attribute arguments. 2488 if (!checkAttributeNumArgs(S, Attr, 0)) 2489 return; 2490 2491 2492 // weak_import only applies to variable & function declarations. 2493 bool isDef = false; 2494 if (!D->canBeWeakImported(isDef)) { 2495 if (isDef) 2496 S.Diag(Attr.getLoc(), 2497 diag::warn_attribute_weak_import_invalid_on_definition) 2498 << "weak_import" << 2 /*variable and function*/; 2499 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) || 2500 (S.Context.getTargetInfo().getTriple().isOSDarwin() && 2501 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) { 2502 // Nothing to warn about here. 2503 } else 2504 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2505 << Attr.getName() << ExpectedVariableOrFunction; 2506 2507 return; 2508 } 2509 2510 D->addAttr(::new (S.Context) WeakImportAttr(Attr.getRange(), S.Context)); 2511} 2512 2513// Handles reqd_work_group_size and work_group_size_hint. 2514static void handleWorkGroupSize(Sema &S, Decl *D, 2515 const AttributeList &Attr) { 2516 assert(Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize 2517 || Attr.getKind() == AttributeList::AT_WorkGroupSizeHint); 2518 2519 // Attribute has 3 arguments. 2520 if (!checkAttributeNumArgs(S, Attr, 3)) return; 2521 2522 unsigned WGSize[3]; 2523 for (unsigned i = 0; i < 3; ++i) { 2524 Expr *E = Attr.getArg(i); 2525 llvm::APSInt ArgNum(32); 2526 if (E->isTypeDependent() || E->isValueDependent() || 2527 !E->isIntegerConstantExpr(ArgNum, S.Context)) { 2528 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 2529 << Attr.getName()->getName() << E->getSourceRange(); 2530 return; 2531 } 2532 WGSize[i] = (unsigned) ArgNum.getZExtValue(); 2533 } 2534 2535 if (Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize 2536 && D->hasAttr<ReqdWorkGroupSizeAttr>()) { 2537 ReqdWorkGroupSizeAttr *A = D->getAttr<ReqdWorkGroupSizeAttr>(); 2538 if (!(A->getXDim() == WGSize[0] && 2539 A->getYDim() == WGSize[1] && 2540 A->getZDim() == WGSize[2])) { 2541 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << 2542 Attr.getName(); 2543 } 2544 } 2545 2546 if (Attr.getKind() == AttributeList::AT_WorkGroupSizeHint 2547 && D->hasAttr<WorkGroupSizeHintAttr>()) { 2548 WorkGroupSizeHintAttr *A = D->getAttr<WorkGroupSizeHintAttr>(); 2549 if (!(A->getXDim() == WGSize[0] && 2550 A->getYDim() == WGSize[1] && 2551 A->getZDim() == WGSize[2])) { 2552 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << 2553 Attr.getName(); 2554 } 2555 } 2556 2557 if (Attr.getKind() == AttributeList::AT_ReqdWorkGroupSize) 2558 D->addAttr(::new (S.Context) 2559 ReqdWorkGroupSizeAttr(Attr.getRange(), S.Context, 2560 WGSize[0], WGSize[1], WGSize[2])); 2561 else 2562 D->addAttr(::new (S.Context) 2563 WorkGroupSizeHintAttr(Attr.getRange(), S.Context, 2564 WGSize[0], WGSize[1], WGSize[2])); 2565} 2566 2567SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range, 2568 StringRef Name) { 2569 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) { 2570 if (ExistingAttr->getName() == Name) 2571 return NULL; 2572 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section); 2573 Diag(Range.getBegin(), diag::note_previous_attribute); 2574 return NULL; 2575 } 2576 return ::new (Context) SectionAttr(Range, Context, Name); 2577} 2578 2579static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2580 // Attribute has no arguments. 2581 if (!checkAttributeNumArgs(S, Attr, 1)) 2582 return; 2583 2584 // Make sure that there is a string literal as the sections's single 2585 // argument. 2586 Expr *ArgExpr = Attr.getArg(0); 2587 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 2588 if (!SE) { 2589 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) << "section"; 2590 return; 2591 } 2592 2593 // If the target wants to validate the section specifier, make it happen. 2594 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(SE->getString()); 2595 if (!Error.empty()) { 2596 S.Diag(SE->getLocStart(), diag::err_attribute_section_invalid_for_target) 2597 << Error; 2598 return; 2599 } 2600 2601 // This attribute cannot be applied to local variables. 2602 if (isa<VarDecl>(D) && cast<VarDecl>(D)->hasLocalStorage()) { 2603 S.Diag(SE->getLocStart(), diag::err_attribute_section_local_variable); 2604 return; 2605 } 2606 SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(), 2607 SE->getString()); 2608 if (NewAttr) 2609 D->addAttr(NewAttr); 2610} 2611 2612 2613static void handleNothrowAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2614 // check the attribute arguments. 2615 if (Attr.hasParameterOrArguments()) { 2616 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2617 return; 2618 } 2619 2620 if (NoThrowAttr *Existing = D->getAttr<NoThrowAttr>()) { 2621 if (Existing->getLocation().isInvalid()) 2622 Existing->setRange(Attr.getRange()); 2623 } else { 2624 D->addAttr(::new (S.Context) NoThrowAttr(Attr.getRange(), S.Context)); 2625 } 2626} 2627 2628static void handleConstAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2629 // check the attribute arguments. 2630 if (Attr.hasParameterOrArguments()) { 2631 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 2632 return; 2633 } 2634 2635 if (ConstAttr *Existing = D->getAttr<ConstAttr>()) { 2636 if (Existing->getLocation().isInvalid()) 2637 Existing->setRange(Attr.getRange()); 2638 } else { 2639 D->addAttr(::new (S.Context) ConstAttr(Attr.getRange(), S.Context)); 2640 } 2641} 2642 2643static void handlePureAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2644 // check the attribute arguments. 2645 if (!checkAttributeNumArgs(S, Attr, 0)) 2646 return; 2647 2648 D->addAttr(::new (S.Context) PureAttr(Attr.getRange(), S.Context)); 2649} 2650 2651static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2652 if (!Attr.getParameterName()) { 2653 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2654 return; 2655 } 2656 2657 if (Attr.getNumArgs() != 0) { 2658 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2659 return; 2660 } 2661 2662 VarDecl *VD = dyn_cast<VarDecl>(D); 2663 2664 if (!VD || !VD->hasLocalStorage()) { 2665 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "cleanup"; 2666 return; 2667 } 2668 2669 // Look up the function 2670 // FIXME: Lookup probably isn't looking in the right place 2671 NamedDecl *CleanupDecl 2672 = S.LookupSingleName(S.TUScope, Attr.getParameterName(), 2673 Attr.getParameterLoc(), Sema::LookupOrdinaryName); 2674 if (!CleanupDecl) { 2675 S.Diag(Attr.getParameterLoc(), diag::err_attribute_cleanup_arg_not_found) << 2676 Attr.getParameterName(); 2677 return; 2678 } 2679 2680 FunctionDecl *FD = dyn_cast<FunctionDecl>(CleanupDecl); 2681 if (!FD) { 2682 S.Diag(Attr.getParameterLoc(), 2683 diag::err_attribute_cleanup_arg_not_function) 2684 << Attr.getParameterName(); 2685 return; 2686 } 2687 2688 if (FD->getNumParams() != 1) { 2689 S.Diag(Attr.getParameterLoc(), 2690 diag::err_attribute_cleanup_func_must_take_one_arg) 2691 << Attr.getParameterName(); 2692 return; 2693 } 2694 2695 // We're currently more strict than GCC about what function types we accept. 2696 // If this ever proves to be a problem it should be easy to fix. 2697 QualType Ty = S.Context.getPointerType(VD->getType()); 2698 QualType ParamTy = FD->getParamDecl(0)->getType(); 2699 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(), 2700 ParamTy, Ty) != Sema::Compatible) { 2701 S.Diag(Attr.getParameterLoc(), 2702 diag::err_attribute_cleanup_func_arg_incompatible_type) << 2703 Attr.getParameterName() << ParamTy << Ty; 2704 return; 2705 } 2706 2707 D->addAttr(::new (S.Context) CleanupAttr(Attr.getRange(), S.Context, FD)); 2708 S.MarkFunctionReferenced(Attr.getParameterLoc(), FD); 2709} 2710 2711/// Handle __attribute__((format_arg((idx)))) attribute based on 2712/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 2713static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2714 if (!checkAttributeNumArgs(S, Attr, 1)) 2715 return; 2716 2717 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) { 2718 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2719 << Attr.getName() << ExpectedFunction; 2720 return; 2721 } 2722 2723 // In C++ the implicit 'this' function parameter also counts, and they are 2724 // counted from one. 2725 bool HasImplicitThisParam = isInstanceMethod(D); 2726 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 2727 unsigned FirstIdx = 1; 2728 2729 // checks for the 2nd argument 2730 Expr *IdxExpr = Attr.getArg(0); 2731 llvm::APSInt Idx(32); 2732 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 2733 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 2734 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 2735 << "format" << 2 << IdxExpr->getSourceRange(); 2736 return; 2737 } 2738 2739 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 2740 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 2741 << "format" << 2 << IdxExpr->getSourceRange(); 2742 return; 2743 } 2744 2745 unsigned ArgIdx = Idx.getZExtValue() - 1; 2746 2747 if (HasImplicitThisParam) { 2748 if (ArgIdx == 0) { 2749 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_implicit_this_argument) 2750 << "format_arg" << IdxExpr->getSourceRange(); 2751 return; 2752 } 2753 ArgIdx--; 2754 } 2755 2756 // make sure the format string is really a string 2757 QualType Ty = getFunctionOrMethodArgType(D, ArgIdx); 2758 2759 bool not_nsstring_type = !isNSStringType(Ty, S.Context); 2760 if (not_nsstring_type && 2761 !isCFStringType(Ty, S.Context) && 2762 (!Ty->isPointerType() || 2763 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 2764 // FIXME: Should highlight the actual expression that has the wrong type. 2765 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 2766 << (not_nsstring_type ? "a string type" : "an NSString") 2767 << IdxExpr->getSourceRange(); 2768 return; 2769 } 2770 Ty = getFunctionOrMethodResultType(D); 2771 if (!isNSStringType(Ty, S.Context) && 2772 !isCFStringType(Ty, S.Context) && 2773 (!Ty->isPointerType() || 2774 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) { 2775 // FIXME: Should highlight the actual expression that has the wrong type. 2776 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not) 2777 << (not_nsstring_type ? "string type" : "NSString") 2778 << IdxExpr->getSourceRange(); 2779 return; 2780 } 2781 2782 D->addAttr(::new (S.Context) FormatArgAttr(Attr.getRange(), S.Context, 2783 Idx.getZExtValue())); 2784} 2785 2786enum FormatAttrKind { 2787 CFStringFormat, 2788 NSStringFormat, 2789 StrftimeFormat, 2790 SupportedFormat, 2791 IgnoredFormat, 2792 InvalidFormat 2793}; 2794 2795/// getFormatAttrKind - Map from format attribute names to supported format 2796/// types. 2797static FormatAttrKind getFormatAttrKind(StringRef Format) { 2798 return llvm::StringSwitch<FormatAttrKind>(Format) 2799 // Check for formats that get handled specially. 2800 .Case("NSString", NSStringFormat) 2801 .Case("CFString", CFStringFormat) 2802 .Case("strftime", StrftimeFormat) 2803 2804 // Otherwise, check for supported formats. 2805 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat) 2806 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat) 2807 .Case("kprintf", SupportedFormat) // OpenBSD. 2808 2809 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat) 2810 .Default(InvalidFormat); 2811} 2812 2813/// Handle __attribute__((init_priority(priority))) attributes based on 2814/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html 2815static void handleInitPriorityAttr(Sema &S, Decl *D, 2816 const AttributeList &Attr) { 2817 if (!S.getLangOpts().CPlusPlus) { 2818 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 2819 return; 2820 } 2821 2822 if (!isa<VarDecl>(D) || S.getCurFunctionOrMethodDecl()) { 2823 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr); 2824 Attr.setInvalid(); 2825 return; 2826 } 2827 QualType T = dyn_cast<VarDecl>(D)->getType(); 2828 if (S.Context.getAsArrayType(T)) 2829 T = S.Context.getBaseElementType(T); 2830 if (!T->getAs<RecordType>()) { 2831 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr); 2832 Attr.setInvalid(); 2833 return; 2834 } 2835 2836 if (Attr.getNumArgs() != 1) { 2837 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 2838 Attr.setInvalid(); 2839 return; 2840 } 2841 Expr *priorityExpr = Attr.getArg(0); 2842 2843 llvm::APSInt priority(32); 2844 if (priorityExpr->isTypeDependent() || priorityExpr->isValueDependent() || 2845 !priorityExpr->isIntegerConstantExpr(priority, S.Context)) { 2846 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 2847 << "init_priority" << priorityExpr->getSourceRange(); 2848 Attr.setInvalid(); 2849 return; 2850 } 2851 unsigned prioritynum = priority.getZExtValue(); 2852 if (prioritynum < 101 || prioritynum > 65535) { 2853 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range) 2854 << priorityExpr->getSourceRange(); 2855 Attr.setInvalid(); 2856 return; 2857 } 2858 D->addAttr(::new (S.Context) InitPriorityAttr(Attr.getRange(), S.Context, 2859 prioritynum)); 2860} 2861 2862FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range, StringRef Format, 2863 int FormatIdx, int FirstArg) { 2864 // Check whether we already have an equivalent format attribute. 2865 for (specific_attr_iterator<FormatAttr> 2866 i = D->specific_attr_begin<FormatAttr>(), 2867 e = D->specific_attr_end<FormatAttr>(); 2868 i != e ; ++i) { 2869 FormatAttr *f = *i; 2870 if (f->getType() == Format && 2871 f->getFormatIdx() == FormatIdx && 2872 f->getFirstArg() == FirstArg) { 2873 // If we don't have a valid location for this attribute, adopt the 2874 // location. 2875 if (f->getLocation().isInvalid()) 2876 f->setRange(Range); 2877 return NULL; 2878 } 2879 } 2880 2881 return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx, 2882 FirstArg); 2883} 2884 2885/// Handle __attribute__((format(type,idx,firstarg))) attributes based on 2886/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 2887static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) { 2888 2889 if (!Attr.getParameterName()) { 2890 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 2891 << "format" << 1; 2892 return; 2893 } 2894 2895 if (Attr.getNumArgs() != 2) { 2896 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 3; 2897 return; 2898 } 2899 2900 if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) { 2901 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 2902 << Attr.getName() << ExpectedFunction; 2903 return; 2904 } 2905 2906 // In C++ the implicit 'this' function parameter also counts, and they are 2907 // counted from one. 2908 bool HasImplicitThisParam = isInstanceMethod(D); 2909 unsigned NumArgs = getFunctionOrMethodNumArgs(D) + HasImplicitThisParam; 2910 unsigned FirstIdx = 1; 2911 2912 StringRef Format = Attr.getParameterName()->getName(); 2913 2914 // Normalize the argument, __foo__ becomes foo. 2915 if (Format.startswith("__") && Format.endswith("__")) 2916 Format = Format.substr(2, Format.size() - 4); 2917 2918 // Check for supported formats. 2919 FormatAttrKind Kind = getFormatAttrKind(Format); 2920 2921 if (Kind == IgnoredFormat) 2922 return; 2923 2924 if (Kind == InvalidFormat) { 2925 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 2926 << "format" << Attr.getParameterName()->getName(); 2927 return; 2928 } 2929 2930 // checks for the 2nd argument 2931 Expr *IdxExpr = Attr.getArg(0); 2932 llvm::APSInt Idx(32); 2933 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 2934 !IdxExpr->isIntegerConstantExpr(Idx, S.Context)) { 2935 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 2936 << "format" << 2 << IdxExpr->getSourceRange(); 2937 return; 2938 } 2939 2940 if (Idx.getZExtValue() < FirstIdx || Idx.getZExtValue() > NumArgs) { 2941 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 2942 << "format" << 2 << IdxExpr->getSourceRange(); 2943 return; 2944 } 2945 2946 // FIXME: Do we need to bounds check? 2947 unsigned ArgIdx = Idx.getZExtValue() - 1; 2948 2949 if (HasImplicitThisParam) { 2950 if (ArgIdx == 0) { 2951 S.Diag(Attr.getLoc(), 2952 diag::err_format_attribute_implicit_this_format_string) 2953 << IdxExpr->getSourceRange(); 2954 return; 2955 } 2956 ArgIdx--; 2957 } 2958 2959 // make sure the format string is really a string 2960 QualType Ty = getFunctionOrMethodArgType(D, ArgIdx); 2961 2962 if (Kind == CFStringFormat) { 2963 if (!isCFStringType(Ty, S.Context)) { 2964 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 2965 << "a CFString" << IdxExpr->getSourceRange(); 2966 return; 2967 } 2968 } else if (Kind == NSStringFormat) { 2969 // FIXME: do we need to check if the type is NSString*? What are the 2970 // semantics? 2971 if (!isNSStringType(Ty, S.Context)) { 2972 // FIXME: Should highlight the actual expression that has the wrong type. 2973 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 2974 << "an NSString" << IdxExpr->getSourceRange(); 2975 return; 2976 } 2977 } else if (!Ty->isPointerType() || 2978 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) { 2979 // FIXME: Should highlight the actual expression that has the wrong type. 2980 S.Diag(Attr.getLoc(), diag::err_format_attribute_not) 2981 << "a string type" << IdxExpr->getSourceRange(); 2982 return; 2983 } 2984 2985 // check the 3rd argument 2986 Expr *FirstArgExpr = Attr.getArg(1); 2987 llvm::APSInt FirstArg(32); 2988 if (FirstArgExpr->isTypeDependent() || FirstArgExpr->isValueDependent() || 2989 !FirstArgExpr->isIntegerConstantExpr(FirstArg, S.Context)) { 2990 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 2991 << "format" << 3 << FirstArgExpr->getSourceRange(); 2992 return; 2993 } 2994 2995 // check if the function is variadic if the 3rd argument non-zero 2996 if (FirstArg != 0) { 2997 if (isFunctionOrMethodVariadic(D)) { 2998 ++NumArgs; // +1 for ... 2999 } else { 3000 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic); 3001 return; 3002 } 3003 } 3004 3005 // strftime requires FirstArg to be 0 because it doesn't read from any 3006 // variable the input is just the current time + the format string. 3007 if (Kind == StrftimeFormat) { 3008 if (FirstArg != 0) { 3009 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter) 3010 << FirstArgExpr->getSourceRange(); 3011 return; 3012 } 3013 // if 0 it disables parameter checking (to use with e.g. va_list) 3014 } else if (FirstArg != 0 && FirstArg != NumArgs) { 3015 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds) 3016 << "format" << 3 << FirstArgExpr->getSourceRange(); 3017 return; 3018 } 3019 3020 FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), Format, 3021 Idx.getZExtValue(), 3022 FirstArg.getZExtValue()); 3023 if (NewAttr) 3024 D->addAttr(NewAttr); 3025} 3026 3027static void handleTransparentUnionAttr(Sema &S, Decl *D, 3028 const AttributeList &Attr) { 3029 // check the attribute arguments. 3030 if (!checkAttributeNumArgs(S, Attr, 0)) 3031 return; 3032 3033 3034 // Try to find the underlying union declaration. 3035 RecordDecl *RD = 0; 3036 TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D); 3037 if (TD && TD->getUnderlyingType()->isUnionType()) 3038 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl(); 3039 else 3040 RD = dyn_cast<RecordDecl>(D); 3041 3042 if (!RD || !RD->isUnion()) { 3043 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3044 << Attr.getName() << ExpectedUnion; 3045 return; 3046 } 3047 3048 if (!RD->isCompleteDefinition()) { 3049 S.Diag(Attr.getLoc(), 3050 diag::warn_transparent_union_attribute_not_definition); 3051 return; 3052 } 3053 3054 RecordDecl::field_iterator Field = RD->field_begin(), 3055 FieldEnd = RD->field_end(); 3056 if (Field == FieldEnd) { 3057 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields); 3058 return; 3059 } 3060 3061 FieldDecl *FirstField = *Field; 3062 QualType FirstType = FirstField->getType(); 3063 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) { 3064 S.Diag(FirstField->getLocation(), 3065 diag::warn_transparent_union_attribute_floating) 3066 << FirstType->isVectorType() << FirstType; 3067 return; 3068 } 3069 3070 uint64_t FirstSize = S.Context.getTypeSize(FirstType); 3071 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType); 3072 for (; Field != FieldEnd; ++Field) { 3073 QualType FieldType = Field->getType(); 3074 if (S.Context.getTypeSize(FieldType) != FirstSize || 3075 S.Context.getTypeAlign(FieldType) != FirstAlign) { 3076 // Warn if we drop the attribute. 3077 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize; 3078 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType) 3079 : S.Context.getTypeAlign(FieldType); 3080 S.Diag(Field->getLocation(), 3081 diag::warn_transparent_union_attribute_field_size_align) 3082 << isSize << Field->getDeclName() << FieldBits; 3083 unsigned FirstBits = isSize? FirstSize : FirstAlign; 3084 S.Diag(FirstField->getLocation(), 3085 diag::note_transparent_union_first_field_size_align) 3086 << isSize << FirstBits; 3087 return; 3088 } 3089 } 3090 3091 RD->addAttr(::new (S.Context) TransparentUnionAttr(Attr.getRange(), S.Context)); 3092} 3093 3094static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3095 // check the attribute arguments. 3096 if (!checkAttributeNumArgs(S, Attr, 1)) 3097 return; 3098 3099 Expr *ArgExpr = Attr.getArg(0); 3100 StringLiteral *SE = dyn_cast<StringLiteral>(ArgExpr); 3101 3102 // Make sure that there is a string literal as the annotation's single 3103 // argument. 3104 if (!SE) { 3105 S.Diag(ArgExpr->getLocStart(), diag::err_attribute_not_string) <<"annotate"; 3106 return; 3107 } 3108 3109 // Don't duplicate annotations that are already set. 3110 for (specific_attr_iterator<AnnotateAttr> 3111 i = D->specific_attr_begin<AnnotateAttr>(), 3112 e = D->specific_attr_end<AnnotateAttr>(); i != e; ++i) { 3113 if ((*i)->getAnnotation() == SE->getString()) 3114 return; 3115 } 3116 D->addAttr(::new (S.Context) AnnotateAttr(Attr.getRange(), S.Context, 3117 SE->getString())); 3118} 3119 3120static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3121 // check the attribute arguments. 3122 if (Attr.getNumArgs() > 1) { 3123 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 3124 return; 3125 } 3126 3127 //FIXME: The C++0x version of this attribute has more limited applicabilty 3128 // than GNU's, and should error out when it is used to specify a 3129 // weaker alignment, rather than being silently ignored. 3130 3131 if (Attr.getNumArgs() == 0) { 3132 D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context, 3133 true, 0, Attr.isDeclspecAttribute())); 3134 return; 3135 } 3136 3137 S.AddAlignedAttr(Attr.getRange(), D, Attr.getArg(0), 3138 Attr.isDeclspecAttribute()); 3139} 3140 3141void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, 3142 bool isDeclSpec) { 3143 // FIXME: Handle pack-expansions here. 3144 if (DiagnoseUnexpandedParameterPack(E)) 3145 return; 3146 3147 if (E->isTypeDependent() || E->isValueDependent()) { 3148 // Save dependent expressions in the AST to be instantiated. 3149 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, E, 3150 isDeclSpec)); 3151 return; 3152 } 3153 3154 SourceLocation AttrLoc = AttrRange.getBegin(); 3155 // FIXME: Cache the number on the Attr object? 3156 llvm::APSInt Alignment(32); 3157 ExprResult ICE 3158 = VerifyIntegerConstantExpression(E, &Alignment, 3159 diag::err_aligned_attribute_argument_not_int, 3160 /*AllowFold*/ false); 3161 if (ICE.isInvalid()) 3162 return; 3163 if (!llvm::isPowerOf2_64(Alignment.getZExtValue())) { 3164 Diag(AttrLoc, diag::err_attribute_aligned_not_power_of_two) 3165 << E->getSourceRange(); 3166 return; 3167 } 3168 if (isDeclSpec) { 3169 // We've already verified it's a power of 2, now let's make sure it's 3170 // 8192 or less. 3171 if (Alignment.getZExtValue() > 8192) { 3172 Diag(AttrLoc, diag::err_attribute_aligned_greater_than_8192) 3173 << E->getSourceRange(); 3174 return; 3175 } 3176 } 3177 3178 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, true, ICE.take(), 3179 isDeclSpec)); 3180} 3181 3182void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS, 3183 bool isDeclSpec) { 3184 // FIXME: Cache the number on the Attr object if non-dependent? 3185 // FIXME: Perform checking of type validity 3186 D->addAttr(::new (Context) AlignedAttr(AttrRange, Context, false, TS, 3187 isDeclSpec)); 3188 return; 3189} 3190 3191/// handleModeAttr - This attribute modifies the width of a decl with primitive 3192/// type. 3193/// 3194/// Despite what would be logical, the mode attribute is a decl attribute, not a 3195/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be 3196/// HImode, not an intermediate pointer. 3197static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3198 // This attribute isn't documented, but glibc uses it. It changes 3199 // the width of an int or unsigned int to the specified size. 3200 3201 // Check that there aren't any arguments 3202 if (!checkAttributeNumArgs(S, Attr, 0)) 3203 return; 3204 3205 3206 IdentifierInfo *Name = Attr.getParameterName(); 3207 if (!Name) { 3208 S.Diag(Attr.getLoc(), diag::err_attribute_missing_parameter_name); 3209 return; 3210 } 3211 3212 StringRef Str = Attr.getParameterName()->getName(); 3213 3214 // Normalize the attribute name, __foo__ becomes foo. 3215 if (Str.startswith("__") && Str.endswith("__")) 3216 Str = Str.substr(2, Str.size() - 4); 3217 3218 unsigned DestWidth = 0; 3219 bool IntegerMode = true; 3220 bool ComplexMode = false; 3221 switch (Str.size()) { 3222 case 2: 3223 switch (Str[0]) { 3224 case 'Q': DestWidth = 8; break; 3225 case 'H': DestWidth = 16; break; 3226 case 'S': DestWidth = 32; break; 3227 case 'D': DestWidth = 64; break; 3228 case 'X': DestWidth = 96; break; 3229 case 'T': DestWidth = 128; break; 3230 } 3231 if (Str[1] == 'F') { 3232 IntegerMode = false; 3233 } else if (Str[1] == 'C') { 3234 IntegerMode = false; 3235 ComplexMode = true; 3236 } else if (Str[1] != 'I') { 3237 DestWidth = 0; 3238 } 3239 break; 3240 case 4: 3241 // FIXME: glibc uses 'word' to define register_t; this is narrower than a 3242 // pointer on PIC16 and other embedded platforms. 3243 if (Str == "word") 3244 DestWidth = S.Context.getTargetInfo().getPointerWidth(0); 3245 else if (Str == "byte") 3246 DestWidth = S.Context.getTargetInfo().getCharWidth(); 3247 break; 3248 case 7: 3249 if (Str == "pointer") 3250 DestWidth = S.Context.getTargetInfo().getPointerWidth(0); 3251 break; 3252 } 3253 3254 QualType OldTy; 3255 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) 3256 OldTy = TD->getUnderlyingType(); 3257 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) 3258 OldTy = VD->getType(); 3259 else { 3260 S.Diag(D->getLocation(), diag::err_attr_wrong_decl) 3261 << "mode" << Attr.getRange(); 3262 return; 3263 } 3264 3265 if (!OldTy->getAs<BuiltinType>() && !OldTy->isComplexType()) 3266 S.Diag(Attr.getLoc(), diag::err_mode_not_primitive); 3267 else if (IntegerMode) { 3268 if (!OldTy->isIntegralOrEnumerationType()) 3269 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 3270 } else if (ComplexMode) { 3271 if (!OldTy->isComplexType()) 3272 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 3273 } else { 3274 if (!OldTy->isFloatingType()) 3275 S.Diag(Attr.getLoc(), diag::err_mode_wrong_type); 3276 } 3277 3278 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t 3279 // and friends, at least with glibc. 3280 // FIXME: Make sure 32/64-bit integers don't get defined to types of the wrong 3281 // width on unusual platforms. 3282 // FIXME: Make sure floating-point mappings are accurate 3283 // FIXME: Support XF and TF types 3284 QualType NewTy; 3285 switch (DestWidth) { 3286 case 0: 3287 S.Diag(Attr.getLoc(), diag::err_unknown_machine_mode) << Name; 3288 return; 3289 default: 3290 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 3291 return; 3292 case 8: 3293 if (!IntegerMode) { 3294 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 3295 return; 3296 } 3297 if (OldTy->isSignedIntegerType()) 3298 NewTy = S.Context.SignedCharTy; 3299 else 3300 NewTy = S.Context.UnsignedCharTy; 3301 break; 3302 case 16: 3303 if (!IntegerMode) { 3304 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 3305 return; 3306 } 3307 if (OldTy->isSignedIntegerType()) 3308 NewTy = S.Context.ShortTy; 3309 else 3310 NewTy = S.Context.UnsignedShortTy; 3311 break; 3312 case 32: 3313 if (!IntegerMode) 3314 NewTy = S.Context.FloatTy; 3315 else if (OldTy->isSignedIntegerType()) 3316 NewTy = S.Context.IntTy; 3317 else 3318 NewTy = S.Context.UnsignedIntTy; 3319 break; 3320 case 64: 3321 if (!IntegerMode) 3322 NewTy = S.Context.DoubleTy; 3323 else if (OldTy->isSignedIntegerType()) 3324 if (S.Context.getTargetInfo().getLongWidth() == 64) 3325 NewTy = S.Context.LongTy; 3326 else 3327 NewTy = S.Context.LongLongTy; 3328 else 3329 if (S.Context.getTargetInfo().getLongWidth() == 64) 3330 NewTy = S.Context.UnsignedLongTy; 3331 else 3332 NewTy = S.Context.UnsignedLongLongTy; 3333 break; 3334 case 96: 3335 NewTy = S.Context.LongDoubleTy; 3336 break; 3337 case 128: 3338 if (!IntegerMode) { 3339 S.Diag(Attr.getLoc(), diag::err_unsupported_machine_mode) << Name; 3340 return; 3341 } 3342 if (OldTy->isSignedIntegerType()) 3343 NewTy = S.Context.Int128Ty; 3344 else 3345 NewTy = S.Context.UnsignedInt128Ty; 3346 break; 3347 } 3348 3349 if (ComplexMode) { 3350 NewTy = S.Context.getComplexType(NewTy); 3351 } 3352 3353 // Install the new type. 3354 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 3355 // FIXME: preserve existing source info. 3356 TD->setTypeSourceInfo(S.Context.getTrivialTypeSourceInfo(NewTy)); 3357 } else 3358 cast<ValueDecl>(D)->setType(NewTy); 3359} 3360 3361static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3362 // check the attribute arguments. 3363 if (!checkAttributeNumArgs(S, Attr, 0)) 3364 return; 3365 3366 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 3367 if (!VD->hasGlobalStorage()) 3368 S.Diag(Attr.getLoc(), 3369 diag::warn_attribute_requires_functions_or_static_globals) 3370 << Attr.getName(); 3371 } else if (!isFunctionOrMethod(D)) { 3372 S.Diag(Attr.getLoc(), 3373 diag::warn_attribute_requires_functions_or_static_globals) 3374 << Attr.getName(); 3375 return; 3376 } 3377 3378 D->addAttr(::new (S.Context) NoDebugAttr(Attr.getRange(), S.Context)); 3379} 3380 3381static void handleNoInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3382 // check the attribute arguments. 3383 if (!checkAttributeNumArgs(S, Attr, 0)) 3384 return; 3385 3386 3387 if (!isa<FunctionDecl>(D)) { 3388 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3389 << Attr.getName() << ExpectedFunction; 3390 return; 3391 } 3392 3393 D->addAttr(::new (S.Context) NoInlineAttr(Attr.getRange(), S.Context)); 3394} 3395 3396static void handleNoInstrumentFunctionAttr(Sema &S, Decl *D, 3397 const AttributeList &Attr) { 3398 // check the attribute arguments. 3399 if (!checkAttributeNumArgs(S, Attr, 0)) 3400 return; 3401 3402 3403 if (!isa<FunctionDecl>(D)) { 3404 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3405 << Attr.getName() << ExpectedFunction; 3406 return; 3407 } 3408 3409 D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(Attr.getRange(), 3410 S.Context)); 3411} 3412 3413static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3414 if (S.LangOpts.CUDA) { 3415 // check the attribute arguments. 3416 if (Attr.hasParameterOrArguments()) { 3417 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 3418 return; 3419 } 3420 3421 if (!isa<VarDecl>(D)) { 3422 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3423 << Attr.getName() << ExpectedVariable; 3424 return; 3425 } 3426 3427 D->addAttr(::new (S.Context) CUDAConstantAttr(Attr.getRange(), S.Context)); 3428 } else { 3429 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "constant"; 3430 } 3431} 3432 3433static void handleDeviceAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3434 if (S.LangOpts.CUDA) { 3435 // check the attribute arguments. 3436 if (Attr.getNumArgs() != 0) { 3437 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 3438 return; 3439 } 3440 3441 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) { 3442 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3443 << Attr.getName() << ExpectedVariableOrFunction; 3444 return; 3445 } 3446 3447 D->addAttr(::new (S.Context) CUDADeviceAttr(Attr.getRange(), S.Context)); 3448 } else { 3449 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "device"; 3450 } 3451} 3452 3453static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3454 if (S.LangOpts.CUDA) { 3455 // check the attribute arguments. 3456 if (!checkAttributeNumArgs(S, Attr, 0)) 3457 return; 3458 3459 if (!isa<FunctionDecl>(D)) { 3460 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3461 << Attr.getName() << ExpectedFunction; 3462 return; 3463 } 3464 3465 FunctionDecl *FD = cast<FunctionDecl>(D); 3466 if (!FD->getResultType()->isVoidType()) { 3467 TypeLoc TL = FD->getTypeSourceInfo()->getTypeLoc().IgnoreParens(); 3468 if (FunctionTypeLoc* FTL = dyn_cast<FunctionTypeLoc>(&TL)) { 3469 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return) 3470 << FD->getType() 3471 << FixItHint::CreateReplacement(FTL->getResultLoc().getSourceRange(), 3472 "void"); 3473 } else { 3474 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return) 3475 << FD->getType(); 3476 } 3477 return; 3478 } 3479 3480 D->addAttr(::new (S.Context) CUDAGlobalAttr(Attr.getRange(), S.Context)); 3481 } else { 3482 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "global"; 3483 } 3484} 3485 3486static void handleHostAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3487 if (S.LangOpts.CUDA) { 3488 // check the attribute arguments. 3489 if (!checkAttributeNumArgs(S, Attr, 0)) 3490 return; 3491 3492 3493 if (!isa<FunctionDecl>(D)) { 3494 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3495 << Attr.getName() << ExpectedFunction; 3496 return; 3497 } 3498 3499 D->addAttr(::new (S.Context) CUDAHostAttr(Attr.getRange(), S.Context)); 3500 } else { 3501 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "host"; 3502 } 3503} 3504 3505static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3506 if (S.LangOpts.CUDA) { 3507 // check the attribute arguments. 3508 if (!checkAttributeNumArgs(S, Attr, 0)) 3509 return; 3510 3511 3512 if (!isa<VarDecl>(D)) { 3513 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3514 << Attr.getName() << ExpectedVariable; 3515 return; 3516 } 3517 3518 D->addAttr(::new (S.Context) CUDASharedAttr(Attr.getRange(), S.Context)); 3519 } else { 3520 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "shared"; 3521 } 3522} 3523 3524static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3525 // check the attribute arguments. 3526 if (!checkAttributeNumArgs(S, Attr, 0)) 3527 return; 3528 3529 FunctionDecl *Fn = dyn_cast<FunctionDecl>(D); 3530 if (Fn == 0) { 3531 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3532 << Attr.getName() << ExpectedFunction; 3533 return; 3534 } 3535 3536 if (!Fn->isInlineSpecified()) { 3537 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline); 3538 return; 3539 } 3540 3541 D->addAttr(::new (S.Context) GNUInlineAttr(Attr.getRange(), S.Context)); 3542} 3543 3544static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3545 if (hasDeclarator(D)) return; 3546 3547 // Diagnostic is emitted elsewhere: here we store the (valid) Attr 3548 // in the Decl node for syntactic reasoning, e.g., pretty-printing. 3549 CallingConv CC; 3550 if (S.CheckCallingConvAttr(Attr, CC)) 3551 return; 3552 3553 if (!isa<ObjCMethodDecl>(D)) { 3554 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3555 << Attr.getName() << ExpectedFunctionOrMethod; 3556 return; 3557 } 3558 3559 switch (Attr.getKind()) { 3560 case AttributeList::AT_FastCall: 3561 D->addAttr(::new (S.Context) FastCallAttr(Attr.getRange(), S.Context)); 3562 return; 3563 case AttributeList::AT_StdCall: 3564 D->addAttr(::new (S.Context) StdCallAttr(Attr.getRange(), S.Context)); 3565 return; 3566 case AttributeList::AT_ThisCall: 3567 D->addAttr(::new (S.Context) ThisCallAttr(Attr.getRange(), S.Context)); 3568 return; 3569 case AttributeList::AT_CDecl: 3570 D->addAttr(::new (S.Context) CDeclAttr(Attr.getRange(), S.Context)); 3571 return; 3572 case AttributeList::AT_Pascal: 3573 D->addAttr(::new (S.Context) PascalAttr(Attr.getRange(), S.Context)); 3574 return; 3575 case AttributeList::AT_Pcs: { 3576 PcsAttr::PCSType PCS; 3577 switch (CC) { 3578 case CC_AAPCS: 3579 PCS = PcsAttr::AAPCS; 3580 break; 3581 case CC_AAPCS_VFP: 3582 PCS = PcsAttr::AAPCS_VFP; 3583 break; 3584 default: 3585 llvm_unreachable("unexpected calling convention in pcs attribute"); 3586 } 3587 3588 D->addAttr(::new (S.Context) PcsAttr(Attr.getRange(), S.Context, PCS)); 3589 } 3590 default: 3591 llvm_unreachable("unexpected attribute kind"); 3592 } 3593} 3594 3595static void handleOpenCLKernelAttr(Sema &S, Decl *D, const AttributeList &Attr){ 3596 assert(!Attr.isInvalid()); 3597 D->addAttr(::new (S.Context) OpenCLKernelAttr(Attr.getRange(), S.Context)); 3598} 3599 3600bool Sema::CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC) { 3601 if (attr.isInvalid()) 3602 return true; 3603 3604 unsigned ReqArgs = attr.getKind() == AttributeList::AT_Pcs ? 1 : 0; 3605 if (attr.getNumArgs() != ReqArgs || attr.getParameterName()) { 3606 Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << ReqArgs; 3607 attr.setInvalid(); 3608 return true; 3609 } 3610 3611 // TODO: diagnose uses of these conventions on the wrong target. Or, better 3612 // move to TargetAttributesSema one day. 3613 switch (attr.getKind()) { 3614 case AttributeList::AT_CDecl: CC = CC_C; break; 3615 case AttributeList::AT_FastCall: CC = CC_X86FastCall; break; 3616 case AttributeList::AT_StdCall: CC = CC_X86StdCall; break; 3617 case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break; 3618 case AttributeList::AT_Pascal: CC = CC_X86Pascal; break; 3619 case AttributeList::AT_Pcs: { 3620 Expr *Arg = attr.getArg(0); 3621 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 3622 if (!Str || !Str->isAscii()) { 3623 Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string) 3624 << "pcs" << 1; 3625 attr.setInvalid(); 3626 return true; 3627 } 3628 3629 StringRef StrRef = Str->getString(); 3630 if (StrRef == "aapcs") { 3631 CC = CC_AAPCS; 3632 break; 3633 } else if (StrRef == "aapcs-vfp") { 3634 CC = CC_AAPCS_VFP; 3635 break; 3636 } 3637 3638 attr.setInvalid(); 3639 Diag(attr.getLoc(), diag::err_invalid_pcs); 3640 return true; 3641 } 3642 default: llvm_unreachable("unexpected attribute kind"); 3643 } 3644 3645 return false; 3646} 3647 3648static void handleRegparmAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3649 if (hasDeclarator(D)) return; 3650 3651 unsigned numParams; 3652 if (S.CheckRegparmAttr(Attr, numParams)) 3653 return; 3654 3655 if (!isa<ObjCMethodDecl>(D)) { 3656 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3657 << Attr.getName() << ExpectedFunctionOrMethod; 3658 return; 3659 } 3660 3661 D->addAttr(::new (S.Context) RegparmAttr(Attr.getRange(), S.Context, numParams)); 3662} 3663 3664/// Checks a regparm attribute, returning true if it is ill-formed and 3665/// otherwise setting numParams to the appropriate value. 3666bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) { 3667 if (Attr.isInvalid()) 3668 return true; 3669 3670 if (Attr.getNumArgs() != 1) { 3671 Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 3672 Attr.setInvalid(); 3673 return true; 3674 } 3675 3676 Expr *NumParamsExpr = Attr.getArg(0); 3677 llvm::APSInt NumParams(32); 3678 if (NumParamsExpr->isTypeDependent() || NumParamsExpr->isValueDependent() || 3679 !NumParamsExpr->isIntegerConstantExpr(NumParams, Context)) { 3680 Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 3681 << "regparm" << NumParamsExpr->getSourceRange(); 3682 Attr.setInvalid(); 3683 return true; 3684 } 3685 3686 if (Context.getTargetInfo().getRegParmMax() == 0) { 3687 Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform) 3688 << NumParamsExpr->getSourceRange(); 3689 Attr.setInvalid(); 3690 return true; 3691 } 3692 3693 numParams = NumParams.getZExtValue(); 3694 if (numParams > Context.getTargetInfo().getRegParmMax()) { 3695 Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number) 3696 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange(); 3697 Attr.setInvalid(); 3698 return true; 3699 } 3700 3701 return false; 3702} 3703 3704static void handleLaunchBoundsAttr(Sema &S, Decl *D, const AttributeList &Attr){ 3705 if (S.LangOpts.CUDA) { 3706 // check the attribute arguments. 3707 if (Attr.getNumArgs() != 1 && Attr.getNumArgs() != 2) { 3708 // FIXME: 0 is not okay. 3709 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments) << 2; 3710 return; 3711 } 3712 3713 if (!isFunctionOrMethod(D)) { 3714 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) 3715 << Attr.getName() << ExpectedFunctionOrMethod; 3716 return; 3717 } 3718 3719 Expr *MaxThreadsExpr = Attr.getArg(0); 3720 llvm::APSInt MaxThreads(32); 3721 if (MaxThreadsExpr->isTypeDependent() || 3722 MaxThreadsExpr->isValueDependent() || 3723 !MaxThreadsExpr->isIntegerConstantExpr(MaxThreads, S.Context)) { 3724 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 3725 << "launch_bounds" << 1 << MaxThreadsExpr->getSourceRange(); 3726 return; 3727 } 3728 3729 llvm::APSInt MinBlocks(32); 3730 if (Attr.getNumArgs() > 1) { 3731 Expr *MinBlocksExpr = Attr.getArg(1); 3732 if (MinBlocksExpr->isTypeDependent() || 3733 MinBlocksExpr->isValueDependent() || 3734 !MinBlocksExpr->isIntegerConstantExpr(MinBlocks, S.Context)) { 3735 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_int) 3736 << "launch_bounds" << 2 << MinBlocksExpr->getSourceRange(); 3737 return; 3738 } 3739 } 3740 3741 D->addAttr(::new (S.Context) CUDALaunchBoundsAttr(Attr.getRange(), S.Context, 3742 MaxThreads.getZExtValue(), 3743 MinBlocks.getZExtValue())); 3744 } else { 3745 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "launch_bounds"; 3746 } 3747} 3748 3749static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D, 3750 const AttributeList &Attr) { 3751 StringRef AttrName = Attr.getName()->getName(); 3752 if (!Attr.getParameterName()) { 3753 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier) 3754 << Attr.getName() << /* arg num = */ 1; 3755 return; 3756 } 3757 3758 if (Attr.getNumArgs() != 2) { 3759 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 3760 << /* required args = */ 3; 3761 return; 3762 } 3763 3764 IdentifierInfo *ArgumentKind = Attr.getParameterName(); 3765 3766 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) { 3767 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type) 3768 << Attr.getName() << ExpectedFunctionOrMethod; 3769 return; 3770 } 3771 3772 uint64_t ArgumentIdx; 3773 if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName, 3774 Attr.getLoc(), 2, 3775 Attr.getArg(0), ArgumentIdx)) 3776 return; 3777 3778 uint64_t TypeTagIdx; 3779 if (!checkFunctionOrMethodArgumentIndex(S, D, AttrName, 3780 Attr.getLoc(), 3, 3781 Attr.getArg(1), TypeTagIdx)) 3782 return; 3783 3784 bool IsPointer = (AttrName == "pointer_with_type_tag"); 3785 if (IsPointer) { 3786 // Ensure that buffer has a pointer type. 3787 QualType BufferTy = getFunctionOrMethodArgType(D, ArgumentIdx); 3788 if (!BufferTy->isPointerType()) { 3789 S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only) 3790 << AttrName; 3791 } 3792 } 3793 3794 D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(Attr.getRange(), 3795 S.Context, 3796 ArgumentKind, 3797 ArgumentIdx, 3798 TypeTagIdx, 3799 IsPointer)); 3800} 3801 3802static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D, 3803 const AttributeList &Attr) { 3804 IdentifierInfo *PointerKind = Attr.getParameterName(); 3805 if (!PointerKind) { 3806 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_identifier) 3807 << "type_tag_for_datatype" << 1; 3808 return; 3809 } 3810 3811 QualType MatchingCType = S.GetTypeFromParser(Attr.getMatchingCType(), NULL); 3812 3813 D->addAttr(::new (S.Context) TypeTagForDatatypeAttr( 3814 Attr.getRange(), 3815 S.Context, 3816 PointerKind, 3817 MatchingCType, 3818 Attr.getLayoutCompatible(), 3819 Attr.getMustBeNull())); 3820} 3821 3822//===----------------------------------------------------------------------===// 3823// Checker-specific attribute handlers. 3824//===----------------------------------------------------------------------===// 3825 3826static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) { 3827 return type->isDependentType() || 3828 type->isObjCObjectPointerType() || 3829 S.Context.isObjCNSObjectType(type); 3830} 3831static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) { 3832 return type->isDependentType() || 3833 type->isPointerType() || 3834 isValidSubjectOfNSAttribute(S, type); 3835} 3836 3837static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) { 3838 ParmVarDecl *param = dyn_cast<ParmVarDecl>(D); 3839 if (!param) { 3840 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type) 3841 << Attr.getRange() << Attr.getName() << ExpectedParameter; 3842 return; 3843 } 3844 3845 bool typeOK, cf; 3846 if (Attr.getKind() == AttributeList::AT_NSConsumed) { 3847 typeOK = isValidSubjectOfNSAttribute(S, param->getType()); 3848 cf = false; 3849 } else { 3850 typeOK = isValidSubjectOfCFAttribute(S, param->getType()); 3851 cf = true; 3852 } 3853 3854 if (!typeOK) { 3855 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type) 3856 << Attr.getRange() << Attr.getName() << cf; 3857 return; 3858 } 3859 3860 if (cf) 3861 param->addAttr(::new (S.Context) CFConsumedAttr(Attr.getRange(), S.Context)); 3862 else 3863 param->addAttr(::new (S.Context) NSConsumedAttr(Attr.getRange(), S.Context)); 3864} 3865 3866static void handleNSConsumesSelfAttr(Sema &S, Decl *D, 3867 const AttributeList &Attr) { 3868 if (!isa<ObjCMethodDecl>(D)) { 3869 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type) 3870 << Attr.getRange() << Attr.getName() << ExpectedMethod; 3871 return; 3872 } 3873 3874 D->addAttr(::new (S.Context) NSConsumesSelfAttr(Attr.getRange(), S.Context)); 3875} 3876 3877static void handleNSReturnsRetainedAttr(Sema &S, Decl *D, 3878 const AttributeList &Attr) { 3879 3880 QualType returnType; 3881 3882 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) 3883 returnType = MD->getResultType(); 3884 else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) && 3885 (Attr.getKind() == AttributeList::AT_NSReturnsRetained)) 3886 return; // ignore: was handled as a type attribute 3887 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) 3888 returnType = PD->getType(); 3889 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 3890 returnType = FD->getResultType(); 3891 else { 3892 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type) 3893 << Attr.getRange() << Attr.getName() 3894 << ExpectedFunctionOrMethod; 3895 return; 3896 } 3897 3898 bool typeOK; 3899 bool cf; 3900 switch (Attr.getKind()) { 3901 default: llvm_unreachable("invalid ownership attribute"); 3902 case AttributeList::AT_NSReturnsAutoreleased: 3903 case AttributeList::AT_NSReturnsRetained: 3904 case AttributeList::AT_NSReturnsNotRetained: 3905 typeOK = isValidSubjectOfNSAttribute(S, returnType); 3906 cf = false; 3907 break; 3908 3909 case AttributeList::AT_CFReturnsRetained: 3910 case AttributeList::AT_CFReturnsNotRetained: 3911 typeOK = isValidSubjectOfCFAttribute(S, returnType); 3912 cf = true; 3913 break; 3914 } 3915 3916 if (!typeOK) { 3917 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type) 3918 << Attr.getRange() << Attr.getName() << isa<ObjCMethodDecl>(D) << cf; 3919 return; 3920 } 3921 3922 switch (Attr.getKind()) { 3923 default: 3924 llvm_unreachable("invalid ownership attribute"); 3925 case AttributeList::AT_NSReturnsAutoreleased: 3926 D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(Attr.getRange(), 3927 S.Context)); 3928 return; 3929 case AttributeList::AT_CFReturnsNotRetained: 3930 D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(Attr.getRange(), 3931 S.Context)); 3932 return; 3933 case AttributeList::AT_NSReturnsNotRetained: 3934 D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(Attr.getRange(), 3935 S.Context)); 3936 return; 3937 case AttributeList::AT_CFReturnsRetained: 3938 D->addAttr(::new (S.Context) CFReturnsRetainedAttr(Attr.getRange(), 3939 S.Context)); 3940 return; 3941 case AttributeList::AT_NSReturnsRetained: 3942 D->addAttr(::new (S.Context) NSReturnsRetainedAttr(Attr.getRange(), 3943 S.Context)); 3944 return; 3945 }; 3946} 3947 3948static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D, 3949 const AttributeList &attr) { 3950 SourceLocation loc = attr.getLoc(); 3951 3952 ObjCMethodDecl *method = dyn_cast<ObjCMethodDecl>(D); 3953 3954 if (!method) { 3955 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type) 3956 << SourceRange(loc, loc) << attr.getName() << ExpectedMethod; 3957 return; 3958 } 3959 3960 // Check that the method returns a normal pointer. 3961 QualType resultType = method->getResultType(); 3962 3963 if (!resultType->isReferenceType() && 3964 (!resultType->isPointerType() || resultType->isObjCRetainableType())) { 3965 S.Diag(method->getLocStart(), diag::warn_ns_attribute_wrong_return_type) 3966 << SourceRange(loc) 3967 << attr.getName() << /*method*/ 1 << /*non-retainable pointer*/ 2; 3968 3969 // Drop the attribute. 3970 return; 3971 } 3972 3973 method->addAttr( 3974 ::new (S.Context) ObjCReturnsInnerPointerAttr(attr.getRange(), S.Context)); 3975} 3976 3977/// Handle cf_audited_transfer and cf_unknown_transfer. 3978static void handleCFTransferAttr(Sema &S, Decl *D, const AttributeList &A) { 3979 if (!isa<FunctionDecl>(D)) { 3980 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type) 3981 << A.getRange() << A.getName() << ExpectedFunction; 3982 return; 3983 } 3984 3985 bool IsAudited = (A.getKind() == AttributeList::AT_CFAuditedTransfer); 3986 3987 // Check whether there's a conflicting attribute already present. 3988 Attr *Existing; 3989 if (IsAudited) { 3990 Existing = D->getAttr<CFUnknownTransferAttr>(); 3991 } else { 3992 Existing = D->getAttr<CFAuditedTransferAttr>(); 3993 } 3994 if (Existing) { 3995 S.Diag(D->getLocStart(), diag::err_attributes_are_not_compatible) 3996 << A.getName() 3997 << (IsAudited ? "cf_unknown_transfer" : "cf_audited_transfer") 3998 << A.getRange() << Existing->getRange(); 3999 return; 4000 } 4001 4002 // All clear; add the attribute. 4003 if (IsAudited) { 4004 D->addAttr( 4005 ::new (S.Context) CFAuditedTransferAttr(A.getRange(), S.Context)); 4006 } else { 4007 D->addAttr( 4008 ::new (S.Context) CFUnknownTransferAttr(A.getRange(), S.Context)); 4009 } 4010} 4011 4012static void handleNSBridgedAttr(Sema &S, Scope *Sc, Decl *D, 4013 const AttributeList &Attr) { 4014 RecordDecl *RD = dyn_cast<RecordDecl>(D); 4015 if (!RD || RD->isUnion()) { 4016 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type) 4017 << Attr.getRange() << Attr.getName() << ExpectedStruct; 4018 } 4019 4020 IdentifierInfo *ParmName = Attr.getParameterName(); 4021 4022 // In Objective-C, verify that the type names an Objective-C type. 4023 // We don't want to check this outside of ObjC because people sometimes 4024 // do crazy C declarations of Objective-C types. 4025 if (ParmName && S.getLangOpts().ObjC1) { 4026 // Check for an existing type with this name. 4027 LookupResult R(S, DeclarationName(ParmName), Attr.getParameterLoc(), 4028 Sema::LookupOrdinaryName); 4029 if (S.LookupName(R, Sc)) { 4030 NamedDecl *Target = R.getFoundDecl(); 4031 if (Target && !isa<ObjCInterfaceDecl>(Target)) { 4032 S.Diag(D->getLocStart(), diag::err_ns_bridged_not_interface); 4033 S.Diag(Target->getLocStart(), diag::note_declared_at); 4034 } 4035 } 4036 } 4037 4038 D->addAttr(::new (S.Context) NSBridgedAttr(Attr.getRange(), S.Context, 4039 ParmName)); 4040} 4041 4042static void handleObjCOwnershipAttr(Sema &S, Decl *D, 4043 const AttributeList &Attr) { 4044 if (hasDeclarator(D)) return; 4045 4046 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type) 4047 << Attr.getRange() << Attr.getName() << ExpectedVariable; 4048} 4049 4050static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D, 4051 const AttributeList &Attr) { 4052 if (!isa<VarDecl>(D) && !isa<FieldDecl>(D)) { 4053 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type) 4054 << Attr.getRange() << Attr.getName() << ExpectedVariable; 4055 return; 4056 } 4057 4058 ValueDecl *vd = cast<ValueDecl>(D); 4059 QualType type = vd->getType(); 4060 4061 if (!type->isDependentType() && 4062 !type->isObjCLifetimeType()) { 4063 S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type) 4064 << type; 4065 return; 4066 } 4067 4068 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime(); 4069 4070 // If we have no lifetime yet, check the lifetime we're presumably 4071 // going to infer. 4072 if (lifetime == Qualifiers::OCL_None && !type->isDependentType()) 4073 lifetime = type->getObjCARCImplicitLifetime(); 4074 4075 switch (lifetime) { 4076 case Qualifiers::OCL_None: 4077 assert(type->isDependentType() && 4078 "didn't infer lifetime for non-dependent type?"); 4079 break; 4080 4081 case Qualifiers::OCL_Weak: // meaningful 4082 case Qualifiers::OCL_Strong: // meaningful 4083 break; 4084 4085 case Qualifiers::OCL_ExplicitNone: 4086 case Qualifiers::OCL_Autoreleasing: 4087 S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless) 4088 << (lifetime == Qualifiers::OCL_Autoreleasing); 4089 break; 4090 } 4091 4092 D->addAttr(::new (S.Context) 4093 ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context)); 4094} 4095 4096//===----------------------------------------------------------------------===// 4097// Microsoft specific attribute handlers. 4098//===----------------------------------------------------------------------===// 4099 4100static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) { 4101 if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) { 4102 // check the attribute arguments. 4103 if (!checkAttributeNumArgs(S, Attr, 1)) 4104 return; 4105 4106 Expr *Arg = Attr.getArg(0); 4107 StringLiteral *Str = dyn_cast<StringLiteral>(Arg); 4108 if (!Str || !Str->isAscii()) { 4109 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 4110 << "uuid" << 1; 4111 return; 4112 } 4113 4114 StringRef StrRef = Str->getString(); 4115 4116 bool IsCurly = StrRef.size() > 1 && StrRef.front() == '{' && 4117 StrRef.back() == '}'; 4118 4119 // Validate GUID length. 4120 if (IsCurly && StrRef.size() != 38) { 4121 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid); 4122 return; 4123 } 4124 if (!IsCurly && StrRef.size() != 36) { 4125 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid); 4126 return; 4127 } 4128 4129 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or 4130 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" 4131 StringRef::iterator I = StrRef.begin(); 4132 if (IsCurly) // Skip the optional '{' 4133 ++I; 4134 4135 for (int i = 0; i < 36; ++i) { 4136 if (i == 8 || i == 13 || i == 18 || i == 23) { 4137 if (*I != '-') { 4138 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid); 4139 return; 4140 } 4141 } else if (!isxdigit(*I)) { 4142 S.Diag(Attr.getLoc(), diag::err_attribute_uuid_malformed_guid); 4143 return; 4144 } 4145 I++; 4146 } 4147 4148 D->addAttr(::new (S.Context) UuidAttr(Attr.getRange(), S.Context, 4149 Str->getString())); 4150 } else 4151 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << "uuid"; 4152} 4153 4154static void handleInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) { 4155 if (S.LangOpts.MicrosoftExt) { 4156 AttributeList::Kind Kind = Attr.getKind(); 4157 if (Kind == AttributeList::AT_SingleInheritance) 4158 D->addAttr( 4159 ::new (S.Context) SingleInheritanceAttr(Attr.getRange(), S.Context)); 4160 else if (Kind == AttributeList::AT_MultipleInheritance) 4161 D->addAttr( 4162 ::new (S.Context) MultipleInheritanceAttr(Attr.getRange(), S.Context)); 4163 else if (Kind == AttributeList::AT_VirtualInheritance) 4164 D->addAttr( 4165 ::new (S.Context) VirtualInheritanceAttr(Attr.getRange(), S.Context)); 4166 } else 4167 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 4168} 4169 4170static void handlePortabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) { 4171 if (S.LangOpts.MicrosoftExt) { 4172 AttributeList::Kind Kind = Attr.getKind(); 4173 if (Kind == AttributeList::AT_Ptr32) 4174 D->addAttr( 4175 ::new (S.Context) Ptr32Attr(Attr.getRange(), S.Context)); 4176 else if (Kind == AttributeList::AT_Ptr64) 4177 D->addAttr( 4178 ::new (S.Context) Ptr64Attr(Attr.getRange(), S.Context)); 4179 else if (Kind == AttributeList::AT_Win64) 4180 D->addAttr( 4181 ::new (S.Context) Win64Attr(Attr.getRange(), S.Context)); 4182 } else 4183 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 4184} 4185 4186static void handleForceInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) { 4187 if (S.LangOpts.MicrosoftExt) 4188 D->addAttr(::new (S.Context) ForceInlineAttr(Attr.getRange(), S.Context)); 4189 else 4190 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); 4191} 4192 4193//===----------------------------------------------------------------------===// 4194// Top Level Sema Entry Points 4195//===----------------------------------------------------------------------===// 4196 4197static void ProcessNonInheritableDeclAttr(Sema &S, Scope *scope, Decl *D, 4198 const AttributeList &Attr) { 4199 switch (Attr.getKind()) { 4200 case AttributeList::AT_CUDADevice: handleDeviceAttr (S, D, Attr); break; 4201 case AttributeList::AT_CUDAHost: handleHostAttr (S, D, Attr); break; 4202 case AttributeList::AT_Overloadable:handleOverloadableAttr(S, D, Attr); break; 4203 default: 4204 break; 4205 } 4206} 4207 4208static void ProcessInheritableDeclAttr(Sema &S, Scope *scope, Decl *D, 4209 const AttributeList &Attr) { 4210 switch (Attr.getKind()) { 4211 case AttributeList::AT_IBAction: handleIBAction(S, D, Attr); break; 4212 case AttributeList::AT_IBOutlet: handleIBOutlet(S, D, Attr); break; 4213 case AttributeList::AT_IBOutletCollection: 4214 handleIBOutletCollection(S, D, Attr); break; 4215 case AttributeList::AT_AddressSpace: 4216 case AttributeList::AT_OpenCLImageAccess: 4217 case AttributeList::AT_ObjCGC: 4218 case AttributeList::AT_VectorSize: 4219 case AttributeList::AT_NeonVectorType: 4220 case AttributeList::AT_NeonPolyVectorType: 4221 // Ignore these, these are type attributes, handled by 4222 // ProcessTypeAttributes. 4223 break; 4224 case AttributeList::AT_CUDADevice: 4225 case AttributeList::AT_CUDAHost: 4226 case AttributeList::AT_Overloadable: 4227 // Ignore, this is a non-inheritable attribute, handled 4228 // by ProcessNonInheritableDeclAttr. 4229 break; 4230 case AttributeList::AT_Alias: handleAliasAttr (S, D, Attr); break; 4231 case AttributeList::AT_Aligned: handleAlignedAttr (S, D, Attr); break; 4232 case AttributeList::AT_AllocSize: handleAllocSizeAttr (S, D, Attr); break; 4233 case AttributeList::AT_AlwaysInline: 4234 handleAlwaysInlineAttr (S, D, Attr); break; 4235 case AttributeList::AT_AnalyzerNoReturn: 4236 handleAnalyzerNoReturnAttr (S, D, Attr); break; 4237 case AttributeList::AT_TLSModel: handleTLSModelAttr (S, D, Attr); break; 4238 case AttributeList::AT_Annotate: handleAnnotateAttr (S, D, Attr); break; 4239 case AttributeList::AT_Availability:handleAvailabilityAttr(S, D, Attr); break; 4240 case AttributeList::AT_CarriesDependency: 4241 handleDependencyAttr (S, D, Attr); break; 4242 case AttributeList::AT_Common: handleCommonAttr (S, D, Attr); break; 4243 case AttributeList::AT_CUDAConstant:handleConstantAttr (S, D, Attr); break; 4244 case AttributeList::AT_Constructor: handleConstructorAttr (S, D, Attr); break; 4245 case AttributeList::AT_Deprecated: 4246 handleAttrWithMessage<DeprecatedAttr>(S, D, Attr, "deprecated"); 4247 break; 4248 case AttributeList::AT_Destructor: handleDestructorAttr (S, D, Attr); break; 4249 case AttributeList::AT_ExtVectorType: 4250 handleExtVectorTypeAttr(S, scope, D, Attr); 4251 break; 4252 case AttributeList::AT_Format: handleFormatAttr (S, D, Attr); break; 4253 case AttributeList::AT_FormatArg: handleFormatArgAttr (S, D, Attr); break; 4254 case AttributeList::AT_CUDAGlobal: handleGlobalAttr (S, D, Attr); break; 4255 case AttributeList::AT_GNUInline: handleGNUInlineAttr (S, D, Attr); break; 4256 case AttributeList::AT_CUDALaunchBounds: 4257 handleLaunchBoundsAttr(S, D, Attr); 4258 break; 4259 case AttributeList::AT_Mode: handleModeAttr (S, D, Attr); break; 4260 case AttributeList::AT_Malloc: handleMallocAttr (S, D, Attr); break; 4261 case AttributeList::AT_MayAlias: handleMayAliasAttr (S, D, Attr); break; 4262 case AttributeList::AT_NoCommon: handleNoCommonAttr (S, D, Attr); break; 4263 case AttributeList::AT_NonNull: handleNonNullAttr (S, D, Attr); break; 4264 case AttributeList::AT_ownership_returns: 4265 case AttributeList::AT_ownership_takes: 4266 case AttributeList::AT_ownership_holds: 4267 handleOwnershipAttr (S, D, Attr); break; 4268 case AttributeList::AT_Cold: handleColdAttr (S, D, Attr); break; 4269 case AttributeList::AT_Hot: handleHotAttr (S, D, Attr); break; 4270 case AttributeList::AT_Naked: handleNakedAttr (S, D, Attr); break; 4271 case AttributeList::AT_NoReturn: handleNoReturnAttr (S, D, Attr); break; 4272 case AttributeList::AT_NoThrow: handleNothrowAttr (S, D, Attr); break; 4273 case AttributeList::AT_CUDAShared: handleSharedAttr (S, D, Attr); break; 4274 case AttributeList::AT_VecReturn: handleVecReturnAttr (S, D, Attr); break; 4275 4276 case AttributeList::AT_ObjCOwnership: 4277 handleObjCOwnershipAttr(S, D, Attr); break; 4278 case AttributeList::AT_ObjCPreciseLifetime: 4279 handleObjCPreciseLifetimeAttr(S, D, Attr); break; 4280 4281 case AttributeList::AT_ObjCReturnsInnerPointer: 4282 handleObjCReturnsInnerPointerAttr(S, D, Attr); break; 4283 4284 case AttributeList::AT_NSBridged: 4285 handleNSBridgedAttr(S, scope, D, Attr); break; 4286 4287 case AttributeList::AT_CFAuditedTransfer: 4288 case AttributeList::AT_CFUnknownTransfer: 4289 handleCFTransferAttr(S, D, Attr); break; 4290 4291 // Checker-specific. 4292 case AttributeList::AT_CFConsumed: 4293 case AttributeList::AT_NSConsumed: handleNSConsumedAttr (S, D, Attr); break; 4294 case AttributeList::AT_NSConsumesSelf: 4295 handleNSConsumesSelfAttr(S, D, Attr); break; 4296 4297 case AttributeList::AT_NSReturnsAutoreleased: 4298 case AttributeList::AT_NSReturnsNotRetained: 4299 case AttributeList::AT_CFReturnsNotRetained: 4300 case AttributeList::AT_NSReturnsRetained: 4301 case AttributeList::AT_CFReturnsRetained: 4302 handleNSReturnsRetainedAttr(S, D, Attr); break; 4303 4304 case AttributeList::AT_WorkGroupSizeHint: 4305 case AttributeList::AT_ReqdWorkGroupSize: 4306 handleWorkGroupSize(S, D, Attr); break; 4307 4308 case AttributeList::AT_InitPriority: 4309 handleInitPriorityAttr(S, D, Attr); break; 4310 4311 case AttributeList::AT_Packed: handlePackedAttr (S, D, Attr); break; 4312 case AttributeList::AT_Section: handleSectionAttr (S, D, Attr); break; 4313 case AttributeList::AT_Unavailable: 4314 handleAttrWithMessage<UnavailableAttr>(S, D, Attr, "unavailable"); 4315 break; 4316 case AttributeList::AT_ArcWeakrefUnavailable: 4317 handleArcWeakrefUnavailableAttr (S, D, Attr); 4318 break; 4319 case AttributeList::AT_ObjCRootClass: 4320 handleObjCRootClassAttr(S, D, Attr); 4321 break; 4322 case AttributeList::AT_ObjCRequiresPropertyDefs: 4323 handleObjCRequiresPropertyDefsAttr (S, D, Attr); 4324 break; 4325 case AttributeList::AT_Unused: handleUnusedAttr (S, D, Attr); break; 4326 case AttributeList::AT_ReturnsTwice: 4327 handleReturnsTwiceAttr(S, D, Attr); 4328 break; 4329 case AttributeList::AT_Used: handleUsedAttr (S, D, Attr); break; 4330 case AttributeList::AT_Visibility: handleVisibilityAttr (S, D, Attr); break; 4331 case AttributeList::AT_WarnUnusedResult: handleWarnUnusedResult(S, D, Attr); 4332 break; 4333 case AttributeList::AT_Weak: handleWeakAttr (S, D, Attr); break; 4334 case AttributeList::AT_WeakRef: handleWeakRefAttr (S, D, Attr); break; 4335 case AttributeList::AT_WeakImport: handleWeakImportAttr (S, D, Attr); break; 4336 case AttributeList::AT_TransparentUnion: 4337 handleTransparentUnionAttr(S, D, Attr); 4338 break; 4339 case AttributeList::AT_ObjCException: 4340 handleObjCExceptionAttr(S, D, Attr); 4341 break; 4342 case AttributeList::AT_ObjCMethodFamily: 4343 handleObjCMethodFamilyAttr(S, D, Attr); 4344 break; 4345 case AttributeList::AT_ObjCNSObject:handleObjCNSObject (S, D, Attr); break; 4346 case AttributeList::AT_Blocks: handleBlocksAttr (S, D, Attr); break; 4347 case AttributeList::AT_Sentinel: handleSentinelAttr (S, D, Attr); break; 4348 case AttributeList::AT_Const: handleConstAttr (S, D, Attr); break; 4349 case AttributeList::AT_Pure: handlePureAttr (S, D, Attr); break; 4350 case AttributeList::AT_Cleanup: handleCleanupAttr (S, D, Attr); break; 4351 case AttributeList::AT_NoDebug: handleNoDebugAttr (S, D, Attr); break; 4352 case AttributeList::AT_NoInline: handleNoInlineAttr (S, D, Attr); break; 4353 case AttributeList::AT_Regparm: handleRegparmAttr (S, D, Attr); break; 4354 case AttributeList::IgnoredAttribute: 4355 // Just ignore 4356 break; 4357 case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg. 4358 handleNoInstrumentFunctionAttr(S, D, Attr); 4359 break; 4360 case AttributeList::AT_StdCall: 4361 case AttributeList::AT_CDecl: 4362 case AttributeList::AT_FastCall: 4363 case AttributeList::AT_ThisCall: 4364 case AttributeList::AT_Pascal: 4365 case AttributeList::AT_Pcs: 4366 handleCallConvAttr(S, D, Attr); 4367 break; 4368 case AttributeList::AT_OpenCLKernel: 4369 handleOpenCLKernelAttr(S, D, Attr); 4370 break; 4371 4372 // Microsoft attributes: 4373 case AttributeList::AT_MsStruct: 4374 handleMsStructAttr(S, D, Attr); 4375 break; 4376 case AttributeList::AT_Uuid: 4377 handleUuidAttr(S, D, Attr); 4378 break; 4379 case AttributeList::AT_SingleInheritance: 4380 case AttributeList::AT_MultipleInheritance: 4381 case AttributeList::AT_VirtualInheritance: 4382 handleInheritanceAttr(S, D, Attr); 4383 break; 4384 case AttributeList::AT_Win64: 4385 case AttributeList::AT_Ptr32: 4386 case AttributeList::AT_Ptr64: 4387 handlePortabilityAttr(S, D, Attr); 4388 break; 4389 case AttributeList::AT_ForceInline: 4390 handleForceInlineAttr(S, D, Attr); 4391 break; 4392 4393 // Thread safety attributes: 4394 case AttributeList::AT_GuardedVar: 4395 handleGuardedVarAttr(S, D, Attr); 4396 break; 4397 case AttributeList::AT_PtGuardedVar: 4398 handlePtGuardedVarAttr(S, D, Attr); 4399 break; 4400 case AttributeList::AT_ScopedLockable: 4401 handleScopedLockableAttr(S, D, Attr); 4402 break; 4403 case AttributeList::AT_NoAddressSafetyAnalysis: 4404 handleNoAddressSafetyAttr(S, D, Attr); 4405 break; 4406 case AttributeList::AT_NoThreadSafetyAnalysis: 4407 handleNoThreadSafetyAttr(S, D, Attr); 4408 break; 4409 case AttributeList::AT_Lockable: 4410 handleLockableAttr(S, D, Attr); 4411 break; 4412 case AttributeList::AT_GuardedBy: 4413 handleGuardedByAttr(S, D, Attr); 4414 break; 4415 case AttributeList::AT_PtGuardedBy: 4416 handlePtGuardedByAttr(S, D, Attr); 4417 break; 4418 case AttributeList::AT_ExclusiveLockFunction: 4419 handleExclusiveLockFunctionAttr(S, D, Attr); 4420 break; 4421 case AttributeList::AT_ExclusiveLocksRequired: 4422 handleExclusiveLocksRequiredAttr(S, D, Attr); 4423 break; 4424 case AttributeList::AT_ExclusiveTrylockFunction: 4425 handleExclusiveTrylockFunctionAttr(S, D, Attr); 4426 break; 4427 case AttributeList::AT_LockReturned: 4428 handleLockReturnedAttr(S, D, Attr); 4429 break; 4430 case AttributeList::AT_LocksExcluded: 4431 handleLocksExcludedAttr(S, D, Attr); 4432 break; 4433 case AttributeList::AT_SharedLockFunction: 4434 handleSharedLockFunctionAttr(S, D, Attr); 4435 break; 4436 case AttributeList::AT_SharedLocksRequired: 4437 handleSharedLocksRequiredAttr(S, D, Attr); 4438 break; 4439 case AttributeList::AT_SharedTrylockFunction: 4440 handleSharedTrylockFunctionAttr(S, D, Attr); 4441 break; 4442 case AttributeList::AT_UnlockFunction: 4443 handleUnlockFunAttr(S, D, Attr); 4444 break; 4445 case AttributeList::AT_AcquiredBefore: 4446 handleAcquiredBeforeAttr(S, D, Attr); 4447 break; 4448 case AttributeList::AT_AcquiredAfter: 4449 handleAcquiredAfterAttr(S, D, Attr); 4450 break; 4451 4452 // Type safety attributes. 4453 case AttributeList::AT_ArgumentWithTypeTag: 4454 handleArgumentWithTypeTagAttr(S, D, Attr); 4455 break; 4456 case AttributeList::AT_TypeTagForDatatype: 4457 handleTypeTagForDatatypeAttr(S, D, Attr); 4458 break; 4459 4460 default: 4461 // Ask target about the attribute. 4462 const TargetAttributesSema &TargetAttrs = S.getTargetAttributesSema(); 4463 if (!TargetAttrs.ProcessDeclAttribute(scope, D, Attr, S)) 4464 S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute() ? 4465 diag::warn_unhandled_ms_attribute_ignored : 4466 diag::warn_unknown_attribute_ignored) << Attr.getName(); 4467 break; 4468 } 4469} 4470 4471/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if 4472/// the attribute applies to decls. If the attribute is a type attribute, just 4473/// silently ignore it if a GNU attribute. FIXME: Applying a C++0x attribute to 4474/// the wrong thing is illegal (C++0x [dcl.attr.grammar]/4). 4475static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, 4476 const AttributeList &Attr, 4477 bool NonInheritable, bool Inheritable) { 4478 if (Attr.isInvalid()) 4479 return; 4480 4481 // Type attributes are still treated as declaration attributes by 4482 // ParseMicrosoftTypeAttributes and ParseBorlandTypeAttributes. We don't 4483 // want to process them, however, because we will simply warn about ignoring 4484 // them. So instead, we will bail out early. 4485 if (Attr.isMSTypespecAttribute()) 4486 return; 4487 4488 if (NonInheritable) 4489 ProcessNonInheritableDeclAttr(S, scope, D, Attr); 4490 4491 if (Inheritable) 4492 ProcessInheritableDeclAttr(S, scope, D, Attr); 4493} 4494 4495/// ProcessDeclAttributeList - Apply all the decl attributes in the specified 4496/// attribute list to the specified decl, ignoring any type attributes. 4497void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, 4498 const AttributeList *AttrList, 4499 bool NonInheritable, bool Inheritable) { 4500 for (const AttributeList* l = AttrList; l; l = l->getNext()) { 4501 ProcessDeclAttribute(*this, S, D, *l, NonInheritable, Inheritable); 4502 } 4503 4504 // GCC accepts 4505 // static int a9 __attribute__((weakref)); 4506 // but that looks really pointless. We reject it. 4507 if (Inheritable && D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) { 4508 Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias) << 4509 dyn_cast<NamedDecl>(D)->getNameAsString(); 4510 return; 4511 } 4512} 4513 4514// Annotation attributes are the only attributes allowed after an access 4515// specifier. 4516bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, 4517 const AttributeList *AttrList) { 4518 for (const AttributeList* l = AttrList; l; l = l->getNext()) { 4519 if (l->getKind() == AttributeList::AT_Annotate) { 4520 handleAnnotateAttr(*this, ASDecl, *l); 4521 } else { 4522 Diag(l->getLoc(), diag::err_only_annotate_after_access_spec); 4523 return true; 4524 } 4525 } 4526 4527 return false; 4528} 4529 4530/// checkUnusedDeclAttributes - Check a list of attributes to see if it 4531/// contains any decl attributes that we should warn about. 4532static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) { 4533 for ( ; A; A = A->getNext()) { 4534 // Only warn if the attribute is an unignored, non-type attribute. 4535 if (A->isUsedAsTypeAttr()) continue; 4536 if (A->getKind() == AttributeList::IgnoredAttribute) continue; 4537 4538 if (A->getKind() == AttributeList::UnknownAttribute) { 4539 S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored) 4540 << A->getName() << A->getRange(); 4541 } else { 4542 S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl) 4543 << A->getName() << A->getRange(); 4544 } 4545 } 4546} 4547 4548/// checkUnusedDeclAttributes - Given a declarator which is not being 4549/// used to build a declaration, complain about any decl attributes 4550/// which might be lying around on it. 4551void Sema::checkUnusedDeclAttributes(Declarator &D) { 4552 ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList()); 4553 ::checkUnusedDeclAttributes(*this, D.getAttributes()); 4554 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) 4555 ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs()); 4556} 4557 4558/// DeclClonePragmaWeak - clone existing decl (maybe definition), 4559/// \#pragma weak needs a non-definition decl and source may not have one. 4560NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, 4561 SourceLocation Loc) { 4562 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND)); 4563 NamedDecl *NewD = 0; 4564 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 4565 FunctionDecl *NewFD; 4566 // FIXME: Missing call to CheckFunctionDeclaration(). 4567 // FIXME: Mangling? 4568 // FIXME: Is the qualifier info correct? 4569 // FIXME: Is the DeclContext correct? 4570 NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(), 4571 Loc, Loc, DeclarationName(II), 4572 FD->getType(), FD->getTypeSourceInfo(), 4573 SC_None, SC_None, 4574 false/*isInlineSpecified*/, 4575 FD->hasPrototype(), 4576 false/*isConstexprSpecified*/); 4577 NewD = NewFD; 4578 4579 if (FD->getQualifier()) 4580 NewFD->setQualifierInfo(FD->getQualifierLoc()); 4581 4582 // Fake up parameter variables; they are declared as if this were 4583 // a typedef. 4584 QualType FDTy = FD->getType(); 4585 if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) { 4586 SmallVector<ParmVarDecl*, 16> Params; 4587 for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(), 4588 AE = FT->arg_type_end(); AI != AE; ++AI) { 4589 ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, *AI); 4590 Param->setScopeInfo(0, Params.size()); 4591 Params.push_back(Param); 4592 } 4593 NewFD->setParams(Params); 4594 } 4595 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) { 4596 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(), 4597 VD->getInnerLocStart(), VD->getLocation(), II, 4598 VD->getType(), VD->getTypeSourceInfo(), 4599 VD->getStorageClass(), 4600 VD->getStorageClassAsWritten()); 4601 if (VD->getQualifier()) { 4602 VarDecl *NewVD = cast<VarDecl>(NewD); 4603 NewVD->setQualifierInfo(VD->getQualifierLoc()); 4604 } 4605 } 4606 return NewD; 4607} 4608 4609/// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak 4610/// applied to it, possibly with an alias. 4611void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) { 4612 if (W.getUsed()) return; // only do this once 4613 W.setUsed(true); 4614 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...)) 4615 IdentifierInfo *NDId = ND->getIdentifier(); 4616 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation()); 4617 NewD->addAttr(::new (Context) AliasAttr(W.getLocation(), Context, 4618 NDId->getName())); 4619 NewD->addAttr(::new (Context) WeakAttr(W.getLocation(), Context)); 4620 WeakTopLevelDecl.push_back(NewD); 4621 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin 4622 // to insert Decl at TU scope, sorry. 4623 DeclContext *SavedContext = CurContext; 4624 CurContext = Context.getTranslationUnitDecl(); 4625 PushOnScopeChains(NewD, S); 4626 CurContext = SavedContext; 4627 } else { // just add weak to existing 4628 ND->addAttr(::new (Context) WeakAttr(W.getLocation(), Context)); 4629 } 4630} 4631 4632/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in 4633/// it, apply them to D. This is a bit tricky because PD can have attributes 4634/// specified in many different places, and we need to find and apply them all. 4635void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD, 4636 bool NonInheritable, bool Inheritable) { 4637 // It's valid to "forward-declare" #pragma weak, in which case we 4638 // have to do this. 4639 if (Inheritable) { 4640 LoadExternalWeakUndeclaredIdentifiers(); 4641 if (!WeakUndeclaredIdentifiers.empty()) { 4642 if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) { 4643 if (IdentifierInfo *Id = ND->getIdentifier()) { 4644 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator I 4645 = WeakUndeclaredIdentifiers.find(Id); 4646 if (I != WeakUndeclaredIdentifiers.end() && ND->hasLinkage()) { 4647 WeakInfo W = I->second; 4648 DeclApplyPragmaWeak(S, ND, W); 4649 WeakUndeclaredIdentifiers[Id] = W; 4650 } 4651 } 4652 } 4653 } 4654 } 4655 4656 // Apply decl attributes from the DeclSpec if present. 4657 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList()) 4658 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable); 4659 4660 // Walk the declarator structure, applying decl attributes that were in a type 4661 // position to the decl itself. This handles cases like: 4662 // int *__attr__(x)** D; 4663 // when X is a decl attribute. 4664 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i) 4665 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs()) 4666 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable); 4667 4668 // Finally, apply any attributes on the decl itself. 4669 if (const AttributeList *Attrs = PD.getAttributes()) 4670 ProcessDeclAttributeList(S, D, Attrs, NonInheritable, Inheritable); 4671} 4672 4673/// Is the given declaration allowed to use a forbidden type? 4674static bool isForbiddenTypeAllowed(Sema &S, Decl *decl) { 4675 // Private ivars are always okay. Unfortunately, people don't 4676 // always properly make their ivars private, even in system headers. 4677 // Plus we need to make fields okay, too. 4678 // Function declarations in sys headers will be marked unavailable. 4679 if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) && 4680 !isa<FunctionDecl>(decl)) 4681 return false; 4682 4683 // Require it to be declared in a system header. 4684 return S.Context.getSourceManager().isInSystemHeader(decl->getLocation()); 4685} 4686 4687/// Handle a delayed forbidden-type diagnostic. 4688static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag, 4689 Decl *decl) { 4690 if (decl && isForbiddenTypeAllowed(S, decl)) { 4691 decl->addAttr(new (S.Context) UnavailableAttr(diag.Loc, S.Context, 4692 "this system declaration uses an unsupported type")); 4693 return; 4694 } 4695 if (S.getLangOpts().ObjCAutoRefCount) 4696 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) { 4697 // FIXME: we may want to suppress diagnostics for all 4698 // kind of forbidden type messages on unavailable functions. 4699 if (FD->hasAttr<UnavailableAttr>() && 4700 diag.getForbiddenTypeDiagnostic() == 4701 diag::err_arc_array_param_no_ownership) { 4702 diag.Triggered = true; 4703 return; 4704 } 4705 } 4706 4707 S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic()) 4708 << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument(); 4709 diag.Triggered = true; 4710} 4711 4712void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) { 4713 assert(DelayedDiagnostics.getCurrentPool()); 4714 DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool(); 4715 DelayedDiagnostics.popWithoutEmitting(state); 4716 4717 // When delaying diagnostics to run in the context of a parsed 4718 // declaration, we only want to actually emit anything if parsing 4719 // succeeds. 4720 if (!decl) return; 4721 4722 // We emit all the active diagnostics in this pool or any of its 4723 // parents. In general, we'll get one pool for the decl spec 4724 // and a child pool for each declarator; in a decl group like: 4725 // deprecated_typedef foo, *bar, baz(); 4726 // only the declarator pops will be passed decls. This is correct; 4727 // we really do need to consider delayed diagnostics from the decl spec 4728 // for each of the different declarations. 4729 const DelayedDiagnosticPool *pool = &poppedPool; 4730 do { 4731 for (DelayedDiagnosticPool::pool_iterator 4732 i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) { 4733 // This const_cast is a bit lame. Really, Triggered should be mutable. 4734 DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i); 4735 if (diag.Triggered) 4736 continue; 4737 4738 switch (diag.Kind) { 4739 case DelayedDiagnostic::Deprecation: 4740 // Don't bother giving deprecation diagnostics if the decl is invalid. 4741 if (!decl->isInvalidDecl()) 4742 HandleDelayedDeprecationCheck(diag, decl); 4743 break; 4744 4745 case DelayedDiagnostic::Access: 4746 HandleDelayedAccessCheck(diag, decl); 4747 break; 4748 4749 case DelayedDiagnostic::ForbiddenType: 4750 handleDelayedForbiddenType(*this, diag, decl); 4751 break; 4752 } 4753 } 4754 } while ((pool = pool->getParent())); 4755} 4756 4757/// Given a set of delayed diagnostics, re-emit them as if they had 4758/// been delayed in the current context instead of in the given pool. 4759/// Essentially, this just moves them to the current pool. 4760void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) { 4761 DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool(); 4762 assert(curPool && "re-emitting in undelayed context not supported"); 4763 curPool->steal(pool); 4764} 4765 4766static bool isDeclDeprecated(Decl *D) { 4767 do { 4768 if (D->isDeprecated()) 4769 return true; 4770 // A category implicitly has the availability of the interface. 4771 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(D)) 4772 return CatD->getClassInterface()->isDeprecated(); 4773 } while ((D = cast_or_null<Decl>(D->getDeclContext()))); 4774 return false; 4775} 4776 4777static void 4778DoEmitDeprecationWarning(Sema &S, const NamedDecl *D, StringRef Message, 4779 SourceLocation Loc, 4780 const ObjCInterfaceDecl *UnknownObjCClass) { 4781 DeclarationName Name = D->getDeclName(); 4782 if (!Message.empty()) { 4783 S.Diag(Loc, diag::warn_deprecated_message) << Name << Message; 4784 S.Diag(D->getLocation(), 4785 isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at 4786 : diag::note_previous_decl) << Name; 4787 } else if (!UnknownObjCClass) { 4788 S.Diag(Loc, diag::warn_deprecated) << D->getDeclName(); 4789 S.Diag(D->getLocation(), 4790 isa<ObjCMethodDecl>(D) ? diag::note_method_declared_at 4791 : diag::note_previous_decl) << Name; 4792 } else { 4793 S.Diag(Loc, diag::warn_deprecated_fwdclass_message) << Name; 4794 S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class); 4795 } 4796} 4797 4798void Sema::HandleDelayedDeprecationCheck(DelayedDiagnostic &DD, 4799 Decl *Ctx) { 4800 if (isDeclDeprecated(Ctx)) 4801 return; 4802 4803 DD.Triggered = true; 4804 DoEmitDeprecationWarning(*this, DD.getDeprecationDecl(), 4805 DD.getDeprecationMessage(), DD.Loc, 4806 DD.getUnknownObjCClass()); 4807} 4808 4809void Sema::EmitDeprecationWarning(NamedDecl *D, StringRef Message, 4810 SourceLocation Loc, 4811 const ObjCInterfaceDecl *UnknownObjCClass) { 4812 // Delay if we're currently parsing a declaration. 4813 if (DelayedDiagnostics.shouldDelayDiagnostics()) { 4814 DelayedDiagnostics.add(DelayedDiagnostic::makeDeprecation(Loc, D, 4815 UnknownObjCClass, 4816 Message)); 4817 return; 4818 } 4819 4820 // Otherwise, don't warn if our current context is deprecated. 4821 if (isDeclDeprecated(cast<Decl>(getCurLexicalContext()))) 4822 return; 4823 DoEmitDeprecationWarning(*this, D, Message, Loc, UnknownObjCClass); 4824} 4825