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