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