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