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