1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file implements decl-related attribute processing. 10// 11//===----------------------------------------------------------------------===// 12 13#include "clang/AST/ASTConsumer.h" 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/ASTMutationListener.h" 16#include "clang/AST/CXXInheritance.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/Expr.h" 21#include "clang/AST/ExprCXX.h" 22#include "clang/AST/Mangle.h" 23#include "clang/AST/RecursiveASTVisitor.h" 24#include "clang/AST/Type.h" 25#include "clang/Basic/CharInfo.h" 26#include "clang/Basic/SourceLocation.h" 27#include "clang/Basic/SourceManager.h" 28#include "clang/Basic/TargetBuiltins.h" 29#include "clang/Basic/TargetInfo.h" 30#include "clang/Lex/Preprocessor.h" 31#include "clang/Sema/DeclSpec.h" 32#include "clang/Sema/DelayedDiagnostic.h" 33#include "clang/Sema/Initialization.h" 34#include "clang/Sema/Lookup.h" 35#include "clang/Sema/ParsedAttr.h" 36#include "clang/Sema/Scope.h" 37#include "clang/Sema/ScopeInfo.h" 38#include "clang/Sema/SemaInternal.h" 39#include "llvm/ADT/Optional.h" 40#include "llvm/ADT/STLExtras.h" 41#include "llvm/ADT/StringExtras.h" 42#include "llvm/IR/Assumptions.h" 43#include "llvm/MC/MCSectionMachO.h" 44#include "llvm/Support/Error.h" 45#include "llvm/Support/MathExtras.h" 46#include "llvm/Support/raw_ostream.h" 47 48using namespace clang; 49using namespace sema; 50 51namespace AttributeLangSupport { 52 enum LANG { 53 C, 54 Cpp, 55 ObjC 56 }; 57} // end namespace AttributeLangSupport 58 59//===----------------------------------------------------------------------===// 60// Helper functions 61//===----------------------------------------------------------------------===// 62 63/// isFunctionOrMethod - Return true if the given decl has function 64/// type (function or function-typed variable) or an Objective-C 65/// method. 66static bool isFunctionOrMethod(const Decl *D) { 67 return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D); 68} 69 70/// Return true if the given decl has function type (function or 71/// function-typed variable) or an Objective-C method or a block. 72static bool isFunctionOrMethodOrBlock(const Decl *D) { 73 return isFunctionOrMethod(D) || isa<BlockDecl>(D); 74} 75 76/// Return true if the given decl has a declarator that should have 77/// been processed by Sema::GetTypeForDeclarator. 78static bool hasDeclarator(const Decl *D) { 79 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl. 80 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) || 81 isa<ObjCPropertyDecl>(D); 82} 83 84/// hasFunctionProto - Return true if the given decl has a argument 85/// information. This decl should have already passed 86/// isFunctionOrMethod or isFunctionOrMethodOrBlock. 87static bool hasFunctionProto(const Decl *D) { 88 if (const FunctionType *FnTy = D->getFunctionType()) 89 return isa<FunctionProtoType>(FnTy); 90 return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D); 91} 92 93/// getFunctionOrMethodNumParams - Return number of function or method 94/// parameters. It is an error to call this on a K&R function (use 95/// hasFunctionProto first). 96static unsigned getFunctionOrMethodNumParams(const Decl *D) { 97 if (const FunctionType *FnTy = D->getFunctionType()) 98 return cast<FunctionProtoType>(FnTy)->getNumParams(); 99 if (const auto *BD = dyn_cast<BlockDecl>(D)) 100 return BD->getNumParams(); 101 return cast<ObjCMethodDecl>(D)->param_size(); 102} 103 104static const ParmVarDecl *getFunctionOrMethodParam(const Decl *D, 105 unsigned Idx) { 106 if (const auto *FD = dyn_cast<FunctionDecl>(D)) 107 return FD->getParamDecl(Idx); 108 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) 109 return MD->getParamDecl(Idx); 110 if (const auto *BD = dyn_cast<BlockDecl>(D)) 111 return BD->getParamDecl(Idx); 112 return nullptr; 113} 114 115static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) { 116 if (const FunctionType *FnTy = D->getFunctionType()) 117 return cast<FunctionProtoType>(FnTy)->getParamType(Idx); 118 if (const auto *BD = dyn_cast<BlockDecl>(D)) 119 return BD->getParamDecl(Idx)->getType(); 120 121 return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType(); 122} 123 124static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) { 125 if (auto *PVD = getFunctionOrMethodParam(D, Idx)) 126 return PVD->getSourceRange(); 127 return SourceRange(); 128} 129 130static QualType getFunctionOrMethodResultType(const Decl *D) { 131 if (const FunctionType *FnTy = D->getFunctionType()) 132 return FnTy->getReturnType(); 133 return cast<ObjCMethodDecl>(D)->getReturnType(); 134} 135 136static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) { 137 if (const auto *FD = dyn_cast<FunctionDecl>(D)) 138 return FD->getReturnTypeSourceRange(); 139 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) 140 return MD->getReturnTypeSourceRange(); 141 return SourceRange(); 142} 143 144static bool isFunctionOrMethodVariadic(const Decl *D) { 145 if (const FunctionType *FnTy = D->getFunctionType()) 146 return cast<FunctionProtoType>(FnTy)->isVariadic(); 147 if (const auto *BD = dyn_cast<BlockDecl>(D)) 148 return BD->isVariadic(); 149 return cast<ObjCMethodDecl>(D)->isVariadic(); 150} 151 152static bool isInstanceMethod(const Decl *D) { 153 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D)) 154 return MethodDecl->isInstance(); 155 return false; 156} 157 158static inline bool isNSStringType(QualType T, ASTContext &Ctx, 159 bool AllowNSAttributedString = false) { 160 const auto *PT = T->getAs<ObjCObjectPointerType>(); 161 if (!PT) 162 return false; 163 164 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface(); 165 if (!Cls) 166 return false; 167 168 IdentifierInfo* ClsName = Cls->getIdentifier(); 169 170 if (AllowNSAttributedString && 171 ClsName == &Ctx.Idents.get("NSAttributedString")) 172 return true; 173 // FIXME: Should we walk the chain of classes? 174 return ClsName == &Ctx.Idents.get("NSString") || 175 ClsName == &Ctx.Idents.get("NSMutableString"); 176} 177 178static inline bool isCFStringType(QualType T, ASTContext &Ctx) { 179 const auto *PT = T->getAs<PointerType>(); 180 if (!PT) 181 return false; 182 183 const auto *RT = PT->getPointeeType()->getAs<RecordType>(); 184 if (!RT) 185 return false; 186 187 const RecordDecl *RD = RT->getDecl(); 188 if (RD->getTagKind() != TTK_Struct) 189 return false; 190 191 return RD->getIdentifier() == &Ctx.Idents.get("__CFString"); 192} 193 194static unsigned getNumAttributeArgs(const ParsedAttr &AL) { 195 // FIXME: Include the type in the argument list. 196 return AL.getNumArgs() + AL.hasParsedType(); 197} 198 199/// A helper function to provide Attribute Location for the Attr types 200/// AND the ParsedAttr. 201template <typename AttrInfo> 202static std::enable_if_t<std::is_base_of<Attr, AttrInfo>::value, SourceLocation> 203getAttrLoc(const AttrInfo &AL) { 204 return AL.getLocation(); 205} 206static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); } 207 208/// If Expr is a valid integer constant, get the value of the integer 209/// expression and return success or failure. May output an error. 210/// 211/// Negative argument is implicitly converted to unsigned, unless 212/// \p StrictlyUnsigned is true. 213template <typename AttrInfo> 214static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr, 215 uint32_t &Val, unsigned Idx = UINT_MAX, 216 bool StrictlyUnsigned = false) { 217 Optional<llvm::APSInt> I = llvm::APSInt(32); 218 if (Expr->isTypeDependent() || Expr->isValueDependent() || 219 !(I = Expr->getIntegerConstantExpr(S.Context))) { 220 if (Idx != UINT_MAX) 221 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type) 222 << &AI << Idx << AANT_ArgumentIntegerConstant 223 << Expr->getSourceRange(); 224 else 225 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type) 226 << &AI << AANT_ArgumentIntegerConstant << Expr->getSourceRange(); 227 return false; 228 } 229 230 if (!I->isIntN(32)) { 231 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large) 232 << I->toString(10, false) << 32 << /* Unsigned */ 1; 233 return false; 234 } 235 236 if (StrictlyUnsigned && I->isSigned() && I->isNegative()) { 237 S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer) 238 << &AI << /*non-negative*/ 1; 239 return false; 240 } 241 242 Val = (uint32_t)I->getZExtValue(); 243 return true; 244} 245 246/// Wrapper around checkUInt32Argument, with an extra check to be sure 247/// that the result will fit into a regular (signed) int. All args have the same 248/// purpose as they do in checkUInt32Argument. 249template <typename AttrInfo> 250static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr, 251 int &Val, unsigned Idx = UINT_MAX) { 252 uint32_t UVal; 253 if (!checkUInt32Argument(S, AI, Expr, UVal, Idx)) 254 return false; 255 256 if (UVal > (uint32_t)std::numeric_limits<int>::max()) { 257 llvm::APSInt I(32); // for toString 258 I = UVal; 259 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large) 260 << I.toString(10, false) << 32 << /* Unsigned */ 0; 261 return false; 262 } 263 264 Val = UVal; 265 return true; 266} 267 268/// Diagnose mutually exclusive attributes when present on a given 269/// declaration. Returns true if diagnosed. 270template <typename AttrTy> 271static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) { 272 if (const auto *A = D->getAttr<AttrTy>()) { 273 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A; 274 S.Diag(A->getLocation(), diag::note_conflicting_attribute); 275 return true; 276 } 277 return false; 278} 279 280template <typename AttrTy> 281static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) { 282 if (const auto *A = D->getAttr<AttrTy>()) { 283 S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible) << &AL 284 << A; 285 S.Diag(A->getLocation(), diag::note_conflicting_attribute); 286 return true; 287 } 288 return false; 289} 290 291/// Check if IdxExpr is a valid parameter index for a function or 292/// instance method D. May output an error. 293/// 294/// \returns true if IdxExpr is a valid index. 295template <typename AttrInfo> 296static bool checkFunctionOrMethodParameterIndex( 297 Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum, 298 const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) { 299 assert(isFunctionOrMethodOrBlock(D)); 300 301 // In C++ the implicit 'this' function parameter also counts. 302 // Parameters are counted from one. 303 bool HP = hasFunctionProto(D); 304 bool HasImplicitThisParam = isInstanceMethod(D); 305 bool IV = HP && isFunctionOrMethodVariadic(D); 306 unsigned NumParams = 307 (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam; 308 309 Optional<llvm::APSInt> IdxInt; 310 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() || 311 !(IdxInt = IdxExpr->getIntegerConstantExpr(S.Context))) { 312 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type) 313 << &AI << AttrArgNum << AANT_ArgumentIntegerConstant 314 << IdxExpr->getSourceRange(); 315 return false; 316 } 317 318 unsigned IdxSource = IdxInt->getLimitedValue(UINT_MAX); 319 if (IdxSource < 1 || (!IV && IdxSource > NumParams)) { 320 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds) 321 << &AI << AttrArgNum << IdxExpr->getSourceRange(); 322 return false; 323 } 324 if (HasImplicitThisParam && !CanIndexImplicitThis) { 325 if (IdxSource == 1) { 326 S.Diag(getAttrLoc(AI), diag::err_attribute_invalid_implicit_this_argument) 327 << &AI << IdxExpr->getSourceRange(); 328 return false; 329 } 330 } 331 332 Idx = ParamIdx(IdxSource, D); 333 return true; 334} 335 336/// Check if the argument \p ArgNum of \p Attr is a ASCII string literal. 337/// If not emit an error and return false. If the argument is an identifier it 338/// will emit an error with a fixit hint and treat it as if it was a string 339/// literal. 340bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum, 341 StringRef &Str, 342 SourceLocation *ArgLocation) { 343 // Look for identifiers. If we have one emit a hint to fix it to a literal. 344 if (AL.isArgIdent(ArgNum)) { 345 IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum); 346 Diag(Loc->Loc, diag::err_attribute_argument_type) 347 << AL << AANT_ArgumentString 348 << FixItHint::CreateInsertion(Loc->Loc, "\"") 349 << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\""); 350 Str = Loc->Ident->getName(); 351 if (ArgLocation) 352 *ArgLocation = Loc->Loc; 353 return true; 354 } 355 356 // Now check for an actual string literal. 357 Expr *ArgExpr = AL.getArgAsExpr(ArgNum); 358 const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts()); 359 if (ArgLocation) 360 *ArgLocation = ArgExpr->getBeginLoc(); 361 362 if (!Literal || !Literal->isAscii()) { 363 Diag(ArgExpr->getBeginLoc(), diag::err_attribute_argument_type) 364 << AL << AANT_ArgumentString; 365 return false; 366 } 367 368 Str = Literal->getString(); 369 return true; 370} 371 372/// Applies the given attribute to the Decl without performing any 373/// additional semantic checking. 374template <typename AttrType> 375static void handleSimpleAttribute(Sema &S, Decl *D, 376 const AttributeCommonInfo &CI) { 377 D->addAttr(::new (S.Context) AttrType(S.Context, CI)); 378} 379 380template <typename... DiagnosticArgs> 381static const Sema::SemaDiagnosticBuilder& 382appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr) { 383 return Bldr; 384} 385 386template <typename T, typename... DiagnosticArgs> 387static const Sema::SemaDiagnosticBuilder& 388appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr, T &&ExtraArg, 389 DiagnosticArgs &&... ExtraArgs) { 390 return appendDiagnostics(Bldr << std::forward<T>(ExtraArg), 391 std::forward<DiagnosticArgs>(ExtraArgs)...); 392} 393 394/// Add an attribute @c AttrType to declaration @c D, provided that 395/// @c PassesCheck is true. 396/// Otherwise, emit diagnostic @c DiagID, passing in all parameters 397/// specified in @c ExtraArgs. 398template <typename AttrType, typename... DiagnosticArgs> 399static void handleSimpleAttributeOrDiagnose(Sema &S, Decl *D, 400 const AttributeCommonInfo &CI, 401 bool PassesCheck, unsigned DiagID, 402 DiagnosticArgs &&... ExtraArgs) { 403 if (!PassesCheck) { 404 Sema::SemaDiagnosticBuilder DB = S.Diag(D->getBeginLoc(), DiagID); 405 appendDiagnostics(DB, std::forward<DiagnosticArgs>(ExtraArgs)...); 406 return; 407 } 408 handleSimpleAttribute<AttrType>(S, D, CI); 409} 410 411/// Check if the passed-in expression is of type int or bool. 412static bool isIntOrBool(Expr *Exp) { 413 QualType QT = Exp->getType(); 414 return QT->isBooleanType() || QT->isIntegerType(); 415} 416 417 418// Check to see if the type is a smart pointer of some kind. We assume 419// it's a smart pointer if it defines both operator-> and operator*. 420static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) { 421 auto IsOverloadedOperatorPresent = [&S](const RecordDecl *Record, 422 OverloadedOperatorKind Op) { 423 DeclContextLookupResult Result = 424 Record->lookup(S.Context.DeclarationNames.getCXXOperatorName(Op)); 425 return !Result.empty(); 426 }; 427 428 const RecordDecl *Record = RT->getDecl(); 429 bool foundStarOperator = IsOverloadedOperatorPresent(Record, OO_Star); 430 bool foundArrowOperator = IsOverloadedOperatorPresent(Record, OO_Arrow); 431 if (foundStarOperator && foundArrowOperator) 432 return true; 433 434 const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record); 435 if (!CXXRecord) 436 return false; 437 438 for (auto BaseSpecifier : CXXRecord->bases()) { 439 if (!foundStarOperator) 440 foundStarOperator = IsOverloadedOperatorPresent( 441 BaseSpecifier.getType()->getAsRecordDecl(), OO_Star); 442 if (!foundArrowOperator) 443 foundArrowOperator = IsOverloadedOperatorPresent( 444 BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow); 445 } 446 447 if (foundStarOperator && foundArrowOperator) 448 return true; 449 450 return false; 451} 452 453/// Check if passed in Decl is a pointer type. 454/// Note that this function may produce an error message. 455/// \return true if the Decl is a pointer type; false otherwise 456static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D, 457 const ParsedAttr &AL) { 458 const auto *VD = cast<ValueDecl>(D); 459 QualType QT = VD->getType(); 460 if (QT->isAnyPointerType()) 461 return true; 462 463 if (const auto *RT = QT->getAs<RecordType>()) { 464 // If it's an incomplete type, it could be a smart pointer; skip it. 465 // (We don't want to force template instantiation if we can avoid it, 466 // since that would alter the order in which templates are instantiated.) 467 if (RT->isIncompleteType()) 468 return true; 469 470 if (threadSafetyCheckIsSmartPointer(S, RT)) 471 return true; 472 } 473 474 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT; 475 return false; 476} 477 478/// Checks that the passed in QualType either is of RecordType or points 479/// to RecordType. Returns the relevant RecordType, null if it does not exit. 480static const RecordType *getRecordType(QualType QT) { 481 if (const auto *RT = QT->getAs<RecordType>()) 482 return RT; 483 484 // Now check if we point to record type. 485 if (const auto *PT = QT->getAs<PointerType>()) 486 return PT->getPointeeType()->getAs<RecordType>(); 487 488 return nullptr; 489} 490 491template <typename AttrType> 492static bool checkRecordDeclForAttr(const RecordDecl *RD) { 493 // Check if the record itself has the attribute. 494 if (RD->hasAttr<AttrType>()) 495 return true; 496 497 // Else check if any base classes have the attribute. 498 if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) { 499 if (!CRD->forallBases([](const CXXRecordDecl *Base) { 500 return !Base->hasAttr<AttrType>(); 501 })) 502 return true; 503 } 504 return false; 505} 506 507static bool checkRecordTypeForCapability(Sema &S, QualType Ty) { 508 const RecordType *RT = getRecordType(Ty); 509 510 if (!RT) 511 return false; 512 513 // Don't check for the capability if the class hasn't been defined yet. 514 if (RT->isIncompleteType()) 515 return true; 516 517 // Allow smart pointers to be used as capability objects. 518 // FIXME -- Check the type that the smart pointer points to. 519 if (threadSafetyCheckIsSmartPointer(S, RT)) 520 return true; 521 522 return checkRecordDeclForAttr<CapabilityAttr>(RT->getDecl()); 523} 524 525static bool checkTypedefTypeForCapability(QualType Ty) { 526 const auto *TD = Ty->getAs<TypedefType>(); 527 if (!TD) 528 return false; 529 530 TypedefNameDecl *TN = TD->getDecl(); 531 if (!TN) 532 return false; 533 534 return TN->hasAttr<CapabilityAttr>(); 535} 536 537static bool typeHasCapability(Sema &S, QualType Ty) { 538 if (checkTypedefTypeForCapability(Ty)) 539 return true; 540 541 if (checkRecordTypeForCapability(S, Ty)) 542 return true; 543 544 return false; 545} 546 547static bool isCapabilityExpr(Sema &S, const Expr *Ex) { 548 // Capability expressions are simple expressions involving the boolean logic 549 // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once 550 // a DeclRefExpr is found, its type should be checked to determine whether it 551 // is a capability or not. 552 553 if (const auto *E = dyn_cast<CastExpr>(Ex)) 554 return isCapabilityExpr(S, E->getSubExpr()); 555 else if (const auto *E = dyn_cast<ParenExpr>(Ex)) 556 return isCapabilityExpr(S, E->getSubExpr()); 557 else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) { 558 if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf || 559 E->getOpcode() == UO_Deref) 560 return isCapabilityExpr(S, E->getSubExpr()); 561 return false; 562 } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) { 563 if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr) 564 return isCapabilityExpr(S, E->getLHS()) && 565 isCapabilityExpr(S, E->getRHS()); 566 return false; 567 } 568 569 return typeHasCapability(S, Ex->getType()); 570} 571 572/// Checks that all attribute arguments, starting from Sidx, resolve to 573/// a capability object. 574/// \param Sidx The attribute argument index to start checking with. 575/// \param ParamIdxOk Whether an argument can be indexing into a function 576/// parameter list. 577static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D, 578 const ParsedAttr &AL, 579 SmallVectorImpl<Expr *> &Args, 580 unsigned Sidx = 0, 581 bool ParamIdxOk = false) { 582 if (Sidx == AL.getNumArgs()) { 583 // If we don't have any capability arguments, the attribute implicitly 584 // refers to 'this'. So we need to make sure that 'this' exists, i.e. we're 585 // a non-static method, and that the class is a (scoped) capability. 586 const auto *MD = dyn_cast<const CXXMethodDecl>(D); 587 if (MD && !MD->isStatic()) { 588 const CXXRecordDecl *RD = MD->getParent(); 589 // FIXME -- need to check this again on template instantiation 590 if (!checkRecordDeclForAttr<CapabilityAttr>(RD) && 591 !checkRecordDeclForAttr<ScopedLockableAttr>(RD)) 592 S.Diag(AL.getLoc(), 593 diag::warn_thread_attribute_not_on_capability_member) 594 << AL << MD->getParent(); 595 } else { 596 S.Diag(AL.getLoc(), diag::warn_thread_attribute_not_on_non_static_member) 597 << AL; 598 } 599 } 600 601 for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) { 602 Expr *ArgExp = AL.getArgAsExpr(Idx); 603 604 if (ArgExp->isTypeDependent()) { 605 // FIXME -- need to check this again on template instantiation 606 Args.push_back(ArgExp); 607 continue; 608 } 609 610 if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) { 611 if (StrLit->getLength() == 0 || 612 (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) { 613 // Pass empty strings to the analyzer without warnings. 614 // Treat "*" as the universal lock. 615 Args.push_back(ArgExp); 616 continue; 617 } 618 619 // We allow constant strings to be used as a placeholder for expressions 620 // that are not valid C++ syntax, but warn that they are ignored. 621 S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL; 622 Args.push_back(ArgExp); 623 continue; 624 } 625 626 QualType ArgTy = ArgExp->getType(); 627 628 // A pointer to member expression of the form &MyClass::mu is treated 629 // specially -- we need to look at the type of the member. 630 if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp)) 631 if (UOp->getOpcode() == UO_AddrOf) 632 if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr())) 633 if (DRE->getDecl()->isCXXInstanceMember()) 634 ArgTy = DRE->getDecl()->getType(); 635 636 // First see if we can just cast to record type, or pointer to record type. 637 const RecordType *RT = getRecordType(ArgTy); 638 639 // Now check if we index into a record type function param. 640 if(!RT && ParamIdxOk) { 641 const auto *FD = dyn_cast<FunctionDecl>(D); 642 const auto *IL = dyn_cast<IntegerLiteral>(ArgExp); 643 if(FD && IL) { 644 unsigned int NumParams = FD->getNumParams(); 645 llvm::APInt ArgValue = IL->getValue(); 646 uint64_t ParamIdxFromOne = ArgValue.getZExtValue(); 647 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1; 648 if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) { 649 S.Diag(AL.getLoc(), 650 diag::err_attribute_argument_out_of_bounds_extra_info) 651 << AL << Idx + 1 << NumParams; 652 continue; 653 } 654 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType(); 655 } 656 } 657 658 // If the type does not have a capability, see if the components of the 659 // expression have capabilities. This allows for writing C code where the 660 // capability may be on the type, and the expression is a capability 661 // boolean logic expression. Eg) requires_capability(A || B && !C) 662 if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp)) 663 S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable) 664 << AL << ArgTy; 665 666 Args.push_back(ArgExp); 667 } 668} 669 670//===----------------------------------------------------------------------===// 671// Attribute Implementations 672//===----------------------------------------------------------------------===// 673 674static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 675 if (!threadSafetyCheckIsPointer(S, D, AL)) 676 return; 677 678 D->addAttr(::new (S.Context) PtGuardedVarAttr(S.Context, AL)); 679} 680 681static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, 682 Expr *&Arg) { 683 SmallVector<Expr *, 1> Args; 684 // check that all arguments are lockable objects 685 checkAttrArgsAreCapabilityObjs(S, D, AL, Args); 686 unsigned Size = Args.size(); 687 if (Size != 1) 688 return false; 689 690 Arg = Args[0]; 691 692 return true; 693} 694 695static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 696 Expr *Arg = nullptr; 697 if (!checkGuardedByAttrCommon(S, D, AL, Arg)) 698 return; 699 700 D->addAttr(::new (S.Context) GuardedByAttr(S.Context, AL, Arg)); 701} 702 703static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 704 Expr *Arg = nullptr; 705 if (!checkGuardedByAttrCommon(S, D, AL, Arg)) 706 return; 707 708 if (!threadSafetyCheckIsPointer(S, D, AL)) 709 return; 710 711 D->addAttr(::new (S.Context) PtGuardedByAttr(S.Context, AL, Arg)); 712} 713 714static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, 715 SmallVectorImpl<Expr *> &Args) { 716 if (!AL.checkAtLeastNumArgs(S, 1)) 717 return false; 718 719 // Check that this attribute only applies to lockable types. 720 QualType QT = cast<ValueDecl>(D)->getType(); 721 if (!QT->isDependentType() && !typeHasCapability(S, QT)) { 722 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL; 723 return false; 724 } 725 726 // Check that all arguments are lockable objects. 727 checkAttrArgsAreCapabilityObjs(S, D, AL, Args); 728 if (Args.empty()) 729 return false; 730 731 return true; 732} 733 734static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 735 SmallVector<Expr *, 1> Args; 736 if (!checkAcquireOrderAttrCommon(S, D, AL, Args)) 737 return; 738 739 Expr **StartArg = &Args[0]; 740 D->addAttr(::new (S.Context) 741 AcquiredAfterAttr(S.Context, AL, StartArg, Args.size())); 742} 743 744static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 745 SmallVector<Expr *, 1> Args; 746 if (!checkAcquireOrderAttrCommon(S, D, AL, Args)) 747 return; 748 749 Expr **StartArg = &Args[0]; 750 D->addAttr(::new (S.Context) 751 AcquiredBeforeAttr(S.Context, AL, StartArg, Args.size())); 752} 753 754static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, 755 SmallVectorImpl<Expr *> &Args) { 756 // zero or more arguments ok 757 // check that all arguments are lockable objects 758 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true); 759 760 return true; 761} 762 763static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 764 SmallVector<Expr *, 1> Args; 765 if (!checkLockFunAttrCommon(S, D, AL, Args)) 766 return; 767 768 unsigned Size = Args.size(); 769 Expr **StartArg = Size == 0 ? nullptr : &Args[0]; 770 D->addAttr(::new (S.Context) 771 AssertSharedLockAttr(S.Context, AL, StartArg, Size)); 772} 773 774static void handleAssertExclusiveLockAttr(Sema &S, Decl *D, 775 const ParsedAttr &AL) { 776 SmallVector<Expr *, 1> Args; 777 if (!checkLockFunAttrCommon(S, D, AL, Args)) 778 return; 779 780 unsigned Size = Args.size(); 781 Expr **StartArg = Size == 0 ? nullptr : &Args[0]; 782 D->addAttr(::new (S.Context) 783 AssertExclusiveLockAttr(S.Context, AL, StartArg, Size)); 784} 785 786/// Checks to be sure that the given parameter number is in bounds, and 787/// is an integral type. Will emit appropriate diagnostics if this returns 788/// false. 789/// 790/// AttrArgNo is used to actually retrieve the argument, so it's base-0. 791template <typename AttrInfo> 792static bool checkParamIsIntegerType(Sema &S, const Decl *D, const AttrInfo &AI, 793 unsigned AttrArgNo) { 794 assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument"); 795 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo); 796 ParamIdx Idx; 797 if (!checkFunctionOrMethodParameterIndex(S, D, AI, AttrArgNo + 1, AttrArg, 798 Idx)) 799 return false; 800 801 QualType ParamTy = getFunctionOrMethodParamType(D, Idx.getASTIndex()); 802 if (!ParamTy->isIntegerType() && !ParamTy->isCharType()) { 803 SourceLocation SrcLoc = AttrArg->getBeginLoc(); 804 S.Diag(SrcLoc, diag::err_attribute_integers_only) 805 << AI << getFunctionOrMethodParamRange(D, Idx.getASTIndex()); 806 return false; 807 } 808 return true; 809} 810 811static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 812 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 2)) 813 return; 814 815 assert(isFunctionOrMethod(D) && hasFunctionProto(D)); 816 817 QualType RetTy = getFunctionOrMethodResultType(D); 818 if (!RetTy->isPointerType()) { 819 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL; 820 return; 821 } 822 823 const Expr *SizeExpr = AL.getArgAsExpr(0); 824 int SizeArgNoVal; 825 // Parameter indices are 1-indexed, hence Index=1 826 if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Idx=*/1)) 827 return; 828 if (!checkParamIsIntegerType(S, D, AL, /*AttrArgNo=*/0)) 829 return; 830 ParamIdx SizeArgNo(SizeArgNoVal, D); 831 832 ParamIdx NumberArgNo; 833 if (AL.getNumArgs() == 2) { 834 const Expr *NumberExpr = AL.getArgAsExpr(1); 835 int Val; 836 // Parameter indices are 1-based, hence Index=2 837 if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Idx=*/2)) 838 return; 839 if (!checkParamIsIntegerType(S, D, AL, /*AttrArgNo=*/1)) 840 return; 841 NumberArgNo = ParamIdx(Val, D); 842 } 843 844 D->addAttr(::new (S.Context) 845 AllocSizeAttr(S.Context, AL, SizeArgNo, NumberArgNo)); 846} 847 848static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL, 849 SmallVectorImpl<Expr *> &Args) { 850 if (!AL.checkAtLeastNumArgs(S, 1)) 851 return false; 852 853 if (!isIntOrBool(AL.getArgAsExpr(0))) { 854 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 855 << AL << 1 << AANT_ArgumentIntOrBool; 856 return false; 857 } 858 859 // check that all arguments are lockable objects 860 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1); 861 862 return true; 863} 864 865static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D, 866 const ParsedAttr &AL) { 867 SmallVector<Expr*, 2> Args; 868 if (!checkTryLockFunAttrCommon(S, D, AL, Args)) 869 return; 870 871 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr( 872 S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size())); 873} 874 875static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D, 876 const ParsedAttr &AL) { 877 SmallVector<Expr*, 2> Args; 878 if (!checkTryLockFunAttrCommon(S, D, AL, Args)) 879 return; 880 881 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr( 882 S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size())); 883} 884 885static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 886 // check that the argument is lockable object 887 SmallVector<Expr*, 1> Args; 888 checkAttrArgsAreCapabilityObjs(S, D, AL, Args); 889 unsigned Size = Args.size(); 890 if (Size == 0) 891 return; 892 893 D->addAttr(::new (S.Context) LockReturnedAttr(S.Context, AL, Args[0])); 894} 895 896static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 897 if (!AL.checkAtLeastNumArgs(S, 1)) 898 return; 899 900 // check that all arguments are lockable objects 901 SmallVector<Expr*, 1> Args; 902 checkAttrArgsAreCapabilityObjs(S, D, AL, Args); 903 unsigned Size = Args.size(); 904 if (Size == 0) 905 return; 906 Expr **StartArg = &Args[0]; 907 908 D->addAttr(::new (S.Context) 909 LocksExcludedAttr(S.Context, AL, StartArg, Size)); 910} 911 912static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL, 913 Expr *&Cond, StringRef &Msg) { 914 Cond = AL.getArgAsExpr(0); 915 if (!Cond->isTypeDependent()) { 916 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond); 917 if (Converted.isInvalid()) 918 return false; 919 Cond = Converted.get(); 920 } 921 922 if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg)) 923 return false; 924 925 if (Msg.empty()) 926 Msg = "<no message provided>"; 927 928 SmallVector<PartialDiagnosticAt, 8> Diags; 929 if (isa<FunctionDecl>(D) && !Cond->isValueDependent() && 930 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D), 931 Diags)) { 932 S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr) << AL; 933 for (const PartialDiagnosticAt &PDiag : Diags) 934 S.Diag(PDiag.first, PDiag.second); 935 return false; 936 } 937 return true; 938} 939 940static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 941 S.Diag(AL.getLoc(), diag::ext_clang_enable_if); 942 943 Expr *Cond; 944 StringRef Msg; 945 if (checkFunctionConditionAttr(S, D, AL, Cond, Msg)) 946 D->addAttr(::new (S.Context) EnableIfAttr(S.Context, AL, Cond, Msg)); 947} 948 949namespace { 950/// Determines if a given Expr references any of the given function's 951/// ParmVarDecls, or the function's implicit `this` parameter (if applicable). 952class ArgumentDependenceChecker 953 : public RecursiveASTVisitor<ArgumentDependenceChecker> { 954#ifndef NDEBUG 955 const CXXRecordDecl *ClassType; 956#endif 957 llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms; 958 bool Result; 959 960public: 961 ArgumentDependenceChecker(const FunctionDecl *FD) { 962#ifndef NDEBUG 963 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) 964 ClassType = MD->getParent(); 965 else 966 ClassType = nullptr; 967#endif 968 Parms.insert(FD->param_begin(), FD->param_end()); 969 } 970 971 bool referencesArgs(Expr *E) { 972 Result = false; 973 TraverseStmt(E); 974 return Result; 975 } 976 977 bool VisitCXXThisExpr(CXXThisExpr *E) { 978 assert(E->getType()->getPointeeCXXRecordDecl() == ClassType && 979 "`this` doesn't refer to the enclosing class?"); 980 Result = true; 981 return false; 982 } 983 984 bool VisitDeclRefExpr(DeclRefExpr *DRE) { 985 if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) 986 if (Parms.count(PVD)) { 987 Result = true; 988 return false; 989 } 990 return true; 991 } 992}; 993} 994 995static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 996 S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if); 997 998 Expr *Cond; 999 StringRef Msg; 1000 if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg)) 1001 return; 1002 1003 StringRef DiagTypeStr; 1004 if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr)) 1005 return; 1006 1007 DiagnoseIfAttr::DiagnosticType DiagType; 1008 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) { 1009 S.Diag(AL.getArgAsExpr(2)->getBeginLoc(), 1010 diag::err_diagnose_if_invalid_diagnostic_type); 1011 return; 1012 } 1013 1014 bool ArgDependent = false; 1015 if (const auto *FD = dyn_cast<FunctionDecl>(D)) 1016 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond); 1017 D->addAttr(::new (S.Context) DiagnoseIfAttr( 1018 S.Context, AL, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D))); 1019} 1020 1021static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1022 static constexpr const StringRef kWildcard = "*"; 1023 1024 llvm::SmallVector<StringRef, 16> Names; 1025 bool HasWildcard = false; 1026 1027 const auto AddBuiltinName = [&Names, &HasWildcard](StringRef Name) { 1028 if (Name == kWildcard) 1029 HasWildcard = true; 1030 Names.push_back(Name); 1031 }; 1032 1033 // Add previously defined attributes. 1034 if (const auto *NBA = D->getAttr<NoBuiltinAttr>()) 1035 for (StringRef BuiltinName : NBA->builtinNames()) 1036 AddBuiltinName(BuiltinName); 1037 1038 // Add current attributes. 1039 if (AL.getNumArgs() == 0) 1040 AddBuiltinName(kWildcard); 1041 else 1042 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) { 1043 StringRef BuiltinName; 1044 SourceLocation LiteralLoc; 1045 if (!S.checkStringLiteralArgumentAttr(AL, I, BuiltinName, &LiteralLoc)) 1046 return; 1047 1048 if (Builtin::Context::isBuiltinFunc(BuiltinName)) 1049 AddBuiltinName(BuiltinName); 1050 else 1051 S.Diag(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name) 1052 << BuiltinName << AL; 1053 } 1054 1055 // Repeating the same attribute is fine. 1056 llvm::sort(Names); 1057 Names.erase(std::unique(Names.begin(), Names.end()), Names.end()); 1058 1059 // Empty no_builtin must be on its own. 1060 if (HasWildcard && Names.size() > 1) 1061 S.Diag(D->getLocation(), 1062 diag::err_attribute_no_builtin_wildcard_or_builtin_name) 1063 << AL; 1064 1065 if (D->hasAttr<NoBuiltinAttr>()) 1066 D->dropAttr<NoBuiltinAttr>(); 1067 D->addAttr(::new (S.Context) 1068 NoBuiltinAttr(S.Context, AL, Names.data(), Names.size())); 1069} 1070 1071static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1072 if (D->hasAttr<PassObjectSizeAttr>()) { 1073 S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL; 1074 return; 1075 } 1076 1077 Expr *E = AL.getArgAsExpr(0); 1078 uint32_t Type; 1079 if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1)) 1080 return; 1081 1082 // pass_object_size's argument is passed in as the second argument of 1083 // __builtin_object_size. So, it has the same constraints as that second 1084 // argument; namely, it must be in the range [0, 3]. 1085 if (Type > 3) { 1086 S.Diag(E->getBeginLoc(), diag::err_attribute_argument_out_of_range) 1087 << AL << 0 << 3 << E->getSourceRange(); 1088 return; 1089 } 1090 1091 // pass_object_size is only supported on constant pointer parameters; as a 1092 // kindness to users, we allow the parameter to be non-const for declarations. 1093 // At this point, we have no clue if `D` belongs to a function declaration or 1094 // definition, so we defer the constness check until later. 1095 if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) { 1096 S.Diag(D->getBeginLoc(), diag::err_attribute_pointers_only) << AL << 1; 1097 return; 1098 } 1099 1100 D->addAttr(::new (S.Context) PassObjectSizeAttr(S.Context, AL, (int)Type)); 1101} 1102 1103static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1104 ConsumableAttr::ConsumedState DefaultState; 1105 1106 if (AL.isArgIdent(0)) { 1107 IdentifierLoc *IL = AL.getArgAsIdent(0); 1108 if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(), 1109 DefaultState)) { 1110 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL 1111 << IL->Ident; 1112 return; 1113 } 1114 } else { 1115 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1116 << AL << AANT_ArgumentIdentifier; 1117 return; 1118 } 1119 1120 D->addAttr(::new (S.Context) ConsumableAttr(S.Context, AL, DefaultState)); 1121} 1122 1123static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD, 1124 const ParsedAttr &AL) { 1125 QualType ThisType = MD->getThisType()->getPointeeType(); 1126 1127 if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) { 1128 if (!RD->hasAttr<ConsumableAttr>()) { 1129 S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) << RD; 1130 1131 return false; 1132 } 1133 } 1134 1135 return true; 1136} 1137 1138static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1139 if (!AL.checkAtLeastNumArgs(S, 1)) 1140 return; 1141 1142 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL)) 1143 return; 1144 1145 SmallVector<CallableWhenAttr::ConsumedState, 3> States; 1146 for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) { 1147 CallableWhenAttr::ConsumedState CallableState; 1148 1149 StringRef StateString; 1150 SourceLocation Loc; 1151 if (AL.isArgIdent(ArgIndex)) { 1152 IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex); 1153 StateString = Ident->Ident->getName(); 1154 Loc = Ident->Loc; 1155 } else { 1156 if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc)) 1157 return; 1158 } 1159 1160 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString, 1161 CallableState)) { 1162 S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString; 1163 return; 1164 } 1165 1166 States.push_back(CallableState); 1167 } 1168 1169 D->addAttr(::new (S.Context) 1170 CallableWhenAttr(S.Context, AL, States.data(), States.size())); 1171} 1172 1173static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1174 ParamTypestateAttr::ConsumedState ParamState; 1175 1176 if (AL.isArgIdent(0)) { 1177 IdentifierLoc *Ident = AL.getArgAsIdent(0); 1178 StringRef StateString = Ident->Ident->getName(); 1179 1180 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString, 1181 ParamState)) { 1182 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) 1183 << AL << StateString; 1184 return; 1185 } 1186 } else { 1187 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1188 << AL << AANT_ArgumentIdentifier; 1189 return; 1190 } 1191 1192 // FIXME: This check is currently being done in the analysis. It can be 1193 // enabled here only after the parser propagates attributes at 1194 // template specialization definition, not declaration. 1195 //QualType ReturnType = cast<ParmVarDecl>(D)->getType(); 1196 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl(); 1197 // 1198 //if (!RD || !RD->hasAttr<ConsumableAttr>()) { 1199 // S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) << 1200 // ReturnType.getAsString(); 1201 // return; 1202 //} 1203 1204 D->addAttr(::new (S.Context) ParamTypestateAttr(S.Context, AL, ParamState)); 1205} 1206 1207static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1208 ReturnTypestateAttr::ConsumedState ReturnState; 1209 1210 if (AL.isArgIdent(0)) { 1211 IdentifierLoc *IL = AL.getArgAsIdent(0); 1212 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(), 1213 ReturnState)) { 1214 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL 1215 << IL->Ident; 1216 return; 1217 } 1218 } else { 1219 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1220 << AL << AANT_ArgumentIdentifier; 1221 return; 1222 } 1223 1224 // FIXME: This check is currently being done in the analysis. It can be 1225 // enabled here only after the parser propagates attributes at 1226 // template specialization definition, not declaration. 1227 //QualType ReturnType; 1228 // 1229 //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) { 1230 // ReturnType = Param->getType(); 1231 // 1232 //} else if (const CXXConstructorDecl *Constructor = 1233 // dyn_cast<CXXConstructorDecl>(D)) { 1234 // ReturnType = Constructor->getThisType()->getPointeeType(); 1235 // 1236 //} else { 1237 // 1238 // ReturnType = cast<FunctionDecl>(D)->getCallResultType(); 1239 //} 1240 // 1241 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl(); 1242 // 1243 //if (!RD || !RD->hasAttr<ConsumableAttr>()) { 1244 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) << 1245 // ReturnType.getAsString(); 1246 // return; 1247 //} 1248 1249 D->addAttr(::new (S.Context) ReturnTypestateAttr(S.Context, AL, ReturnState)); 1250} 1251 1252static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1253 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL)) 1254 return; 1255 1256 SetTypestateAttr::ConsumedState NewState; 1257 if (AL.isArgIdent(0)) { 1258 IdentifierLoc *Ident = AL.getArgAsIdent(0); 1259 StringRef Param = Ident->Ident->getName(); 1260 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) { 1261 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL 1262 << Param; 1263 return; 1264 } 1265 } else { 1266 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1267 << AL << AANT_ArgumentIdentifier; 1268 return; 1269 } 1270 1271 D->addAttr(::new (S.Context) SetTypestateAttr(S.Context, AL, NewState)); 1272} 1273 1274static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1275 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL)) 1276 return; 1277 1278 TestTypestateAttr::ConsumedState TestState; 1279 if (AL.isArgIdent(0)) { 1280 IdentifierLoc *Ident = AL.getArgAsIdent(0); 1281 StringRef Param = Ident->Ident->getName(); 1282 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) { 1283 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL 1284 << Param; 1285 return; 1286 } 1287 } else { 1288 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1289 << AL << AANT_ArgumentIdentifier; 1290 return; 1291 } 1292 1293 D->addAttr(::new (S.Context) TestTypestateAttr(S.Context, AL, TestState)); 1294} 1295 1296static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1297 // Remember this typedef decl, we will need it later for diagnostics. 1298 S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D)); 1299} 1300 1301static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1302 if (auto *TD = dyn_cast<TagDecl>(D)) 1303 TD->addAttr(::new (S.Context) PackedAttr(S.Context, AL)); 1304 else if (auto *FD = dyn_cast<FieldDecl>(D)) { 1305 bool BitfieldByteAligned = (!FD->getType()->isDependentType() && 1306 !FD->getType()->isIncompleteType() && 1307 FD->isBitField() && 1308 S.Context.getTypeAlign(FD->getType()) <= 8); 1309 1310 if (S.getASTContext().getTargetInfo().getTriple().isPS4()) { 1311 if (BitfieldByteAligned) 1312 // The PS4 target needs to maintain ABI backwards compatibility. 1313 S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type) 1314 << AL << FD->getType(); 1315 else 1316 FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL)); 1317 } else { 1318 // Report warning about changed offset in the newer compiler versions. 1319 if (BitfieldByteAligned) 1320 S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield); 1321 1322 FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL)); 1323 } 1324 1325 } else 1326 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL; 1327} 1328 1329static void handlePreferredName(Sema &S, Decl *D, const ParsedAttr &AL) { 1330 auto *RD = cast<CXXRecordDecl>(D); 1331 ClassTemplateDecl *CTD = RD->getDescribedClassTemplate(); 1332 assert(CTD && "attribute does not appertain to this declaration"); 1333 1334 ParsedType PT = AL.getTypeArg(); 1335 TypeSourceInfo *TSI = nullptr; 1336 QualType T = S.GetTypeFromParser(PT, &TSI); 1337 if (!TSI) 1338 TSI = S.Context.getTrivialTypeSourceInfo(T, AL.getLoc()); 1339 1340 if (!T.hasQualifiers() && T->isTypedefNameType()) { 1341 // Find the template name, if this type names a template specialization. 1342 const TemplateDecl *Template = nullptr; 1343 if (const auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>( 1344 T->getAsCXXRecordDecl())) { 1345 Template = CTSD->getSpecializedTemplate(); 1346 } else if (const auto *TST = T->getAs<TemplateSpecializationType>()) { 1347 while (TST && TST->isTypeAlias()) 1348 TST = TST->getAliasedType()->getAs<TemplateSpecializationType>(); 1349 if (TST) 1350 Template = TST->getTemplateName().getAsTemplateDecl(); 1351 } 1352 1353 if (Template && declaresSameEntity(Template, CTD)) { 1354 D->addAttr(::new (S.Context) PreferredNameAttr(S.Context, AL, TSI)); 1355 return; 1356 } 1357 } 1358 1359 S.Diag(AL.getLoc(), diag::err_attribute_preferred_name_arg_invalid) 1360 << T << CTD; 1361 if (const auto *TT = T->getAs<TypedefType>()) 1362 S.Diag(TT->getDecl()->getLocation(), diag::note_entity_declared_at) 1363 << TT->getDecl(); 1364} 1365 1366static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) { 1367 // The IBOutlet/IBOutletCollection attributes only apply to instance 1368 // variables or properties of Objective-C classes. The outlet must also 1369 // have an object reference type. 1370 if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) { 1371 if (!VD->getType()->getAs<ObjCObjectPointerType>()) { 1372 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type) 1373 << AL << VD->getType() << 0; 1374 return false; 1375 } 1376 } 1377 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) { 1378 if (!PD->getType()->getAs<ObjCObjectPointerType>()) { 1379 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type) 1380 << AL << PD->getType() << 1; 1381 return false; 1382 } 1383 } 1384 else { 1385 S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL; 1386 return false; 1387 } 1388 1389 return true; 1390} 1391 1392static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) { 1393 if (!checkIBOutletCommon(S, D, AL)) 1394 return; 1395 1396 D->addAttr(::new (S.Context) IBOutletAttr(S.Context, AL)); 1397} 1398 1399static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) { 1400 1401 // The iboutletcollection attribute can have zero or one arguments. 1402 if (AL.getNumArgs() > 1) { 1403 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1; 1404 return; 1405 } 1406 1407 if (!checkIBOutletCommon(S, D, AL)) 1408 return; 1409 1410 ParsedType PT; 1411 1412 if (AL.hasParsedType()) 1413 PT = AL.getTypeArg(); 1414 else { 1415 PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(), 1416 S.getScopeForContext(D->getDeclContext()->getParent())); 1417 if (!PT) { 1418 S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject"; 1419 return; 1420 } 1421 } 1422 1423 TypeSourceInfo *QTLoc = nullptr; 1424 QualType QT = S.GetTypeFromParser(PT, &QTLoc); 1425 if (!QTLoc) 1426 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc()); 1427 1428 // Diagnose use of non-object type in iboutletcollection attribute. 1429 // FIXME. Gnu attribute extension ignores use of builtin types in 1430 // attributes. So, __attribute__((iboutletcollection(char))) will be 1431 // treated as __attribute__((iboutletcollection())). 1432 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) { 1433 S.Diag(AL.getLoc(), 1434 QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype 1435 : diag::err_iboutletcollection_type) << QT; 1436 return; 1437 } 1438 1439 D->addAttr(::new (S.Context) IBOutletCollectionAttr(S.Context, AL, QTLoc)); 1440} 1441 1442bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) { 1443 if (RefOkay) { 1444 if (T->isReferenceType()) 1445 return true; 1446 } else { 1447 T = T.getNonReferenceType(); 1448 } 1449 1450 // The nonnull attribute, and other similar attributes, can be applied to a 1451 // transparent union that contains a pointer type. 1452 if (const RecordType *UT = T->getAsUnionType()) { 1453 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) { 1454 RecordDecl *UD = UT->getDecl(); 1455 for (const auto *I : UD->fields()) { 1456 QualType QT = I->getType(); 1457 if (QT->isAnyPointerType() || QT->isBlockPointerType()) 1458 return true; 1459 } 1460 } 1461 } 1462 1463 return T->isAnyPointerType() || T->isBlockPointerType(); 1464} 1465 1466static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL, 1467 SourceRange AttrParmRange, 1468 SourceRange TypeRange, 1469 bool isReturnValue = false) { 1470 if (!S.isValidPointerAttrType(T)) { 1471 if (isReturnValue) 1472 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) 1473 << AL << AttrParmRange << TypeRange; 1474 else 1475 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only) 1476 << AL << AttrParmRange << TypeRange << 0; 1477 return false; 1478 } 1479 return true; 1480} 1481 1482static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1483 SmallVector<ParamIdx, 8> NonNullArgs; 1484 for (unsigned I = 0; I < AL.getNumArgs(); ++I) { 1485 Expr *Ex = AL.getArgAsExpr(I); 1486 ParamIdx Idx; 1487 if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx)) 1488 return; 1489 1490 // Is the function argument a pointer type? 1491 if (Idx.getASTIndex() < getFunctionOrMethodNumParams(D) && 1492 !attrNonNullArgCheck( 1493 S, getFunctionOrMethodParamType(D, Idx.getASTIndex()), AL, 1494 Ex->getSourceRange(), 1495 getFunctionOrMethodParamRange(D, Idx.getASTIndex()))) 1496 continue; 1497 1498 NonNullArgs.push_back(Idx); 1499 } 1500 1501 // If no arguments were specified to __attribute__((nonnull)) then all pointer 1502 // arguments have a nonnull attribute; warn if there aren't any. Skip this 1503 // check if the attribute came from a macro expansion or a template 1504 // instantiation. 1505 if (NonNullArgs.empty() && AL.getLoc().isFileID() && 1506 !S.inTemplateInstantiation()) { 1507 bool AnyPointers = isFunctionOrMethodVariadic(D); 1508 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D); 1509 I != E && !AnyPointers; ++I) { 1510 QualType T = getFunctionOrMethodParamType(D, I); 1511 if (T->isDependentType() || S.isValidPointerAttrType(T)) 1512 AnyPointers = true; 1513 } 1514 1515 if (!AnyPointers) 1516 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers); 1517 } 1518 1519 ParamIdx *Start = NonNullArgs.data(); 1520 unsigned Size = NonNullArgs.size(); 1521 llvm::array_pod_sort(Start, Start + Size); 1522 D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, Start, Size)); 1523} 1524 1525static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D, 1526 const ParsedAttr &AL) { 1527 if (AL.getNumArgs() > 0) { 1528 if (D->getFunctionType()) { 1529 handleNonNullAttr(S, D, AL); 1530 } else { 1531 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args) 1532 << D->getSourceRange(); 1533 } 1534 return; 1535 } 1536 1537 // Is the argument a pointer type? 1538 if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(), 1539 D->getSourceRange())) 1540 return; 1541 1542 D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, nullptr, 0)); 1543} 1544 1545static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1546 QualType ResultType = getFunctionOrMethodResultType(D); 1547 SourceRange SR = getFunctionOrMethodResultSourceRange(D); 1548 if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR, 1549 /* isReturnValue */ true)) 1550 return; 1551 1552 D->addAttr(::new (S.Context) ReturnsNonNullAttr(S.Context, AL)); 1553} 1554 1555static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1556 if (D->isInvalidDecl()) 1557 return; 1558 1559 // noescape only applies to pointer types. 1560 QualType T = cast<ParmVarDecl>(D)->getType(); 1561 if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) { 1562 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only) 1563 << AL << AL.getRange() << 0; 1564 return; 1565 } 1566 1567 D->addAttr(::new (S.Context) NoEscapeAttr(S.Context, AL)); 1568} 1569 1570static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1571 Expr *E = AL.getArgAsExpr(0), 1572 *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr; 1573 S.AddAssumeAlignedAttr(D, AL, E, OE); 1574} 1575 1576static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1577 S.AddAllocAlignAttr(D, AL, AL.getArgAsExpr(0)); 1578} 1579 1580void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 1581 Expr *OE) { 1582 QualType ResultType = getFunctionOrMethodResultType(D); 1583 SourceRange SR = getFunctionOrMethodResultSourceRange(D); 1584 1585 AssumeAlignedAttr TmpAttr(Context, CI, E, OE); 1586 SourceLocation AttrLoc = TmpAttr.getLocation(); 1587 1588 if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) { 1589 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only) 1590 << &TmpAttr << TmpAttr.getRange() << SR; 1591 return; 1592 } 1593 1594 if (!E->isValueDependent()) { 1595 Optional<llvm::APSInt> I = llvm::APSInt(64); 1596 if (!(I = E->getIntegerConstantExpr(Context))) { 1597 if (OE) 1598 Diag(AttrLoc, diag::err_attribute_argument_n_type) 1599 << &TmpAttr << 1 << AANT_ArgumentIntegerConstant 1600 << E->getSourceRange(); 1601 else 1602 Diag(AttrLoc, diag::err_attribute_argument_type) 1603 << &TmpAttr << AANT_ArgumentIntegerConstant 1604 << E->getSourceRange(); 1605 return; 1606 } 1607 1608 if (!I->isPowerOf2()) { 1609 Diag(AttrLoc, diag::err_alignment_not_power_of_two) 1610 << E->getSourceRange(); 1611 return; 1612 } 1613 1614 if (*I > Sema::MaximumAlignment) 1615 Diag(CI.getLoc(), diag::warn_assume_aligned_too_great) 1616 << CI.getRange() << Sema::MaximumAlignment; 1617 } 1618 1619 if (OE && !OE->isValueDependent() && !OE->isIntegerConstantExpr(Context)) { 1620 Diag(AttrLoc, diag::err_attribute_argument_n_type) 1621 << &TmpAttr << 2 << AANT_ArgumentIntegerConstant 1622 << OE->getSourceRange(); 1623 return; 1624 } 1625 1626 D->addAttr(::new (Context) AssumeAlignedAttr(Context, CI, E, OE)); 1627} 1628 1629void Sema::AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, 1630 Expr *ParamExpr) { 1631 QualType ResultType = getFunctionOrMethodResultType(D); 1632 1633 AllocAlignAttr TmpAttr(Context, CI, ParamIdx()); 1634 SourceLocation AttrLoc = CI.getLoc(); 1635 1636 if (!ResultType->isDependentType() && 1637 !isValidPointerAttrType(ResultType, /* RefOkay */ true)) { 1638 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only) 1639 << &TmpAttr << CI.getRange() << getFunctionOrMethodResultSourceRange(D); 1640 return; 1641 } 1642 1643 ParamIdx Idx; 1644 const auto *FuncDecl = cast<FunctionDecl>(D); 1645 if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr, 1646 /*AttrArgNum=*/1, ParamExpr, Idx)) 1647 return; 1648 1649 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex()); 1650 if (!Ty->isDependentType() && !Ty->isIntegralType(Context) && 1651 !Ty->isAlignValT()) { 1652 Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only) 1653 << &TmpAttr 1654 << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange(); 1655 return; 1656 } 1657 1658 D->addAttr(::new (Context) AllocAlignAttr(Context, CI, Idx)); 1659} 1660 1661/// Check if \p AssumptionStr is a known assumption and warn if not. 1662static void checkAssumptionAttr(Sema &S, SourceLocation Loc, 1663 StringRef AssumptionStr) { 1664 if (llvm::KnownAssumptionStrings.count(AssumptionStr)) 1665 return; 1666 1667 unsigned BestEditDistance = 3; 1668 StringRef Suggestion; 1669 for (const auto &KnownAssumptionIt : llvm::KnownAssumptionStrings) { 1670 unsigned EditDistance = 1671 AssumptionStr.edit_distance(KnownAssumptionIt.getKey()); 1672 if (EditDistance < BestEditDistance) { 1673 Suggestion = KnownAssumptionIt.getKey(); 1674 BestEditDistance = EditDistance; 1675 } 1676 } 1677 1678 if (!Suggestion.empty()) 1679 S.Diag(Loc, diag::warn_assume_attribute_string_unknown_suggested) 1680 << AssumptionStr << Suggestion; 1681 else 1682 S.Diag(Loc, diag::warn_assume_attribute_string_unknown) << AssumptionStr; 1683} 1684 1685static void handleAssumumptionAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1686 // Handle the case where the attribute has a text message. 1687 StringRef Str; 1688 SourceLocation AttrStrLoc; 1689 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &AttrStrLoc)) 1690 return; 1691 1692 checkAssumptionAttr(S, AttrStrLoc, Str); 1693 1694 D->addAttr(::new (S.Context) AssumptionAttr(S.Context, AL, Str)); 1695} 1696 1697/// Normalize the attribute, __foo__ becomes foo. 1698/// Returns true if normalization was applied. 1699static bool normalizeName(StringRef &AttrName) { 1700 if (AttrName.size() > 4 && AttrName.startswith("__") && 1701 AttrName.endswith("__")) { 1702 AttrName = AttrName.drop_front(2).drop_back(2); 1703 return true; 1704 } 1705 return false; 1706} 1707 1708static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1709 // This attribute must be applied to a function declaration. The first 1710 // argument to the attribute must be an identifier, the name of the resource, 1711 // for example: malloc. The following arguments must be argument indexes, the 1712 // arguments must be of integer type for Returns, otherwise of pointer type. 1713 // The difference between Holds and Takes is that a pointer may still be used 1714 // after being held. free() should be __attribute((ownership_takes)), whereas 1715 // a list append function may well be __attribute((ownership_holds)). 1716 1717 if (!AL.isArgIdent(0)) { 1718 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 1719 << AL << 1 << AANT_ArgumentIdentifier; 1720 return; 1721 } 1722 1723 // Figure out our Kind. 1724 OwnershipAttr::OwnershipKind K = 1725 OwnershipAttr(S.Context, AL, nullptr, nullptr, 0).getOwnKind(); 1726 1727 // Check arguments. 1728 switch (K) { 1729 case OwnershipAttr::Takes: 1730 case OwnershipAttr::Holds: 1731 if (AL.getNumArgs() < 2) { 1732 S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments) << AL << 2; 1733 return; 1734 } 1735 break; 1736 case OwnershipAttr::Returns: 1737 if (AL.getNumArgs() > 2) { 1738 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1; 1739 return; 1740 } 1741 break; 1742 } 1743 1744 IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident; 1745 1746 StringRef ModuleName = Module->getName(); 1747 if (normalizeName(ModuleName)) { 1748 Module = &S.PP.getIdentifierTable().get(ModuleName); 1749 } 1750 1751 SmallVector<ParamIdx, 8> OwnershipArgs; 1752 for (unsigned i = 1; i < AL.getNumArgs(); ++i) { 1753 Expr *Ex = AL.getArgAsExpr(i); 1754 ParamIdx Idx; 1755 if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx)) 1756 return; 1757 1758 // Is the function argument a pointer type? 1759 QualType T = getFunctionOrMethodParamType(D, Idx.getASTIndex()); 1760 int Err = -1; // No error 1761 switch (K) { 1762 case OwnershipAttr::Takes: 1763 case OwnershipAttr::Holds: 1764 if (!T->isAnyPointerType() && !T->isBlockPointerType()) 1765 Err = 0; 1766 break; 1767 case OwnershipAttr::Returns: 1768 if (!T->isIntegerType()) 1769 Err = 1; 1770 break; 1771 } 1772 if (-1 != Err) { 1773 S.Diag(AL.getLoc(), diag::err_ownership_type) << AL << Err 1774 << Ex->getSourceRange(); 1775 return; 1776 } 1777 1778 // Check we don't have a conflict with another ownership attribute. 1779 for (const auto *I : D->specific_attrs<OwnershipAttr>()) { 1780 // Cannot have two ownership attributes of different kinds for the same 1781 // index. 1782 if (I->getOwnKind() != K && I->args_end() != 1783 std::find(I->args_begin(), I->args_end(), Idx)) { 1784 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << I; 1785 return; 1786 } else if (K == OwnershipAttr::Returns && 1787 I->getOwnKind() == OwnershipAttr::Returns) { 1788 // A returns attribute conflicts with any other returns attribute using 1789 // a different index. 1790 if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) { 1791 S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch) 1792 << I->args_begin()->getSourceIndex(); 1793 if (I->args_size()) 1794 S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch) 1795 << Idx.getSourceIndex() << Ex->getSourceRange(); 1796 return; 1797 } 1798 } 1799 } 1800 OwnershipArgs.push_back(Idx); 1801 } 1802 1803 ParamIdx *Start = OwnershipArgs.data(); 1804 unsigned Size = OwnershipArgs.size(); 1805 llvm::array_pod_sort(Start, Start + Size); 1806 D->addAttr(::new (S.Context) 1807 OwnershipAttr(S.Context, AL, Module, Start, Size)); 1808} 1809 1810static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1811 // Check the attribute arguments. 1812 if (AL.getNumArgs() > 1) { 1813 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1; 1814 return; 1815 } 1816 1817 // gcc rejects 1818 // class c { 1819 // static int a __attribute__((weakref ("v2"))); 1820 // static int b() __attribute__((weakref ("f3"))); 1821 // }; 1822 // and ignores the attributes of 1823 // void f(void) { 1824 // static int a __attribute__((weakref ("v2"))); 1825 // } 1826 // we reject them 1827 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext(); 1828 if (!Ctx->isFileContext()) { 1829 S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context) 1830 << cast<NamedDecl>(D); 1831 return; 1832 } 1833 1834 // The GCC manual says 1835 // 1836 // At present, a declaration to which `weakref' is attached can only 1837 // be `static'. 1838 // 1839 // It also says 1840 // 1841 // Without a TARGET, 1842 // given as an argument to `weakref' or to `alias', `weakref' is 1843 // equivalent to `weak'. 1844 // 1845 // gcc 4.4.1 will accept 1846 // int a7 __attribute__((weakref)); 1847 // as 1848 // int a7 __attribute__((weak)); 1849 // This looks like a bug in gcc. We reject that for now. We should revisit 1850 // it if this behaviour is actually used. 1851 1852 // GCC rejects 1853 // static ((alias ("y"), weakref)). 1854 // Should we? How to check that weakref is before or after alias? 1855 1856 // FIXME: it would be good for us to keep the WeakRefAttr as-written instead 1857 // of transforming it into an AliasAttr. The WeakRefAttr never uses the 1858 // StringRef parameter it was given anyway. 1859 StringRef Str; 1860 if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str)) 1861 // GCC will accept anything as the argument of weakref. Should we 1862 // check for an existing decl? 1863 D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str)); 1864 1865 D->addAttr(::new (S.Context) WeakRefAttr(S.Context, AL)); 1866} 1867 1868static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1869 StringRef Str; 1870 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str)) 1871 return; 1872 1873 // Aliases should be on declarations, not definitions. 1874 const auto *FD = cast<FunctionDecl>(D); 1875 if (FD->isThisDeclarationADefinition()) { 1876 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1; 1877 return; 1878 } 1879 1880 D->addAttr(::new (S.Context) IFuncAttr(S.Context, AL, Str)); 1881} 1882 1883static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1884 StringRef Str; 1885 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str)) 1886 return; 1887 1888 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) { 1889 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin); 1890 return; 1891 } 1892 if (S.Context.getTargetInfo().getTriple().isNVPTX()) { 1893 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx); 1894 } 1895 1896 // Aliases should be on declarations, not definitions. 1897 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 1898 if (FD->isThisDeclarationADefinition()) { 1899 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0; 1900 return; 1901 } 1902 } else { 1903 const auto *VD = cast<VarDecl>(D); 1904 if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) { 1905 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0; 1906 return; 1907 } 1908 } 1909 1910 // Mark target used to prevent unneeded-internal-declaration warnings. 1911 if (!S.LangOpts.CPlusPlus) { 1912 // FIXME: demangle Str for C++, as the attribute refers to the mangled 1913 // linkage name, not the pre-mangled identifier. 1914 const DeclarationNameInfo target(&S.Context.Idents.get(Str), AL.getLoc()); 1915 LookupResult LR(S, target, Sema::LookupOrdinaryName); 1916 if (S.LookupQualifiedName(LR, S.getCurLexicalContext())) 1917 for (NamedDecl *ND : LR) 1918 ND->markUsed(S.Context); 1919 } 1920 1921 D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str)); 1922} 1923 1924static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1925 StringRef Model; 1926 SourceLocation LiteralLoc; 1927 // Check that it is a string. 1928 if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc)) 1929 return; 1930 1931 // Check that the value. 1932 if (Model != "global-dynamic" && Model != "local-dynamic" 1933 && Model != "initial-exec" && Model != "local-exec") { 1934 S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg); 1935 return; 1936 } 1937 1938 if (S.Context.getTargetInfo().getTriple().isOSAIX() && 1939 Model != "global-dynamic") { 1940 S.Diag(LiteralLoc, diag::err_aix_attr_unsupported_tls_model) << Model; 1941 return; 1942 } 1943 1944 D->addAttr(::new (S.Context) TLSModelAttr(S.Context, AL, Model)); 1945} 1946 1947static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1948 QualType ResultType = getFunctionOrMethodResultType(D); 1949 if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) { 1950 D->addAttr(::new (S.Context) RestrictAttr(S.Context, AL)); 1951 return; 1952 } 1953 1954 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) 1955 << AL << getFunctionOrMethodResultSourceRange(D); 1956} 1957 1958static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 1959 FunctionDecl *FD = cast<FunctionDecl>(D); 1960 1961 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) { 1962 if (MD->getParent()->isLambda()) { 1963 S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL; 1964 return; 1965 } 1966 } 1967 1968 if (!AL.checkAtLeastNumArgs(S, 1)) 1969 return; 1970 1971 SmallVector<IdentifierInfo *, 8> CPUs; 1972 for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) { 1973 if (!AL.isArgIdent(ArgNo)) { 1974 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 1975 << AL << AANT_ArgumentIdentifier; 1976 return; 1977 } 1978 1979 IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo); 1980 StringRef CPUName = CPUArg->Ident->getName().trim(); 1981 1982 if (!S.Context.getTargetInfo().validateCPUSpecificCPUDispatch(CPUName)) { 1983 S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value) 1984 << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch); 1985 return; 1986 } 1987 1988 const TargetInfo &Target = S.Context.getTargetInfo(); 1989 if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) { 1990 return Target.CPUSpecificManglingCharacter(CPUName) == 1991 Target.CPUSpecificManglingCharacter(Cur->getName()); 1992 })) { 1993 S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries); 1994 return; 1995 } 1996 CPUs.push_back(CPUArg->Ident); 1997 } 1998 1999 FD->setIsMultiVersion(true); 2000 if (AL.getKind() == ParsedAttr::AT_CPUSpecific) 2001 D->addAttr(::new (S.Context) 2002 CPUSpecificAttr(S.Context, AL, CPUs.data(), CPUs.size())); 2003 else 2004 D->addAttr(::new (S.Context) 2005 CPUDispatchAttr(S.Context, AL, CPUs.data(), CPUs.size())); 2006} 2007 2008static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2009 if (S.LangOpts.CPlusPlus) { 2010 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang) 2011 << AL << AttributeLangSupport::Cpp; 2012 return; 2013 } 2014 2015 D->addAttr(::new (S.Context) CommonAttr(S.Context, AL)); 2016} 2017 2018static void handleCmseNSEntryAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2019 if (S.LangOpts.CPlusPlus && !D->getDeclContext()->isExternCContext()) { 2020 S.Diag(AL.getLoc(), diag::err_attribute_not_clinkage) << AL; 2021 return; 2022 } 2023 2024 const auto *FD = cast<FunctionDecl>(D); 2025 if (!FD->isExternallyVisible()) { 2026 S.Diag(AL.getLoc(), diag::warn_attribute_cmse_entry_static); 2027 return; 2028 } 2029 2030 D->addAttr(::new (S.Context) CmseNSEntryAttr(S.Context, AL)); 2031} 2032 2033static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2034 if (AL.isDeclspecAttribute()) { 2035 const auto &Triple = S.getASTContext().getTargetInfo().getTriple(); 2036 const auto &Arch = Triple.getArch(); 2037 if (Arch != llvm::Triple::x86 && 2038 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) { 2039 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch) 2040 << AL << Triple.getArchName(); 2041 return; 2042 } 2043 } 2044 2045 D->addAttr(::new (S.Context) NakedAttr(S.Context, AL)); 2046} 2047 2048static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) { 2049 if (hasDeclarator(D)) return; 2050 2051 if (!isa<ObjCMethodDecl>(D)) { 2052 S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type) 2053 << Attrs << ExpectedFunctionOrMethod; 2054 return; 2055 } 2056 2057 D->addAttr(::new (S.Context) NoReturnAttr(S.Context, Attrs)); 2058} 2059 2060static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) { 2061 if (!S.getLangOpts().CFProtectionBranch) 2062 S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored); 2063 else 2064 handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs); 2065} 2066 2067bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) { 2068 if (!Attrs.checkExactlyNumArgs(*this, 0)) { 2069 Attrs.setInvalid(); 2070 return true; 2071 } 2072 2073 return false; 2074} 2075 2076bool Sema::CheckAttrTarget(const ParsedAttr &AL) { 2077 // Check whether the attribute is valid on the current target. 2078 if (!AL.existsInTarget(Context.getTargetInfo())) { 2079 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) 2080 << AL << AL.getRange(); 2081 AL.setInvalid(); 2082 return true; 2083 } 2084 2085 return false; 2086} 2087 2088static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2089 2090 // The checking path for 'noreturn' and 'analyzer_noreturn' are different 2091 // because 'analyzer_noreturn' does not impact the type. 2092 if (!isFunctionOrMethodOrBlock(D)) { 2093 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2094 if (!VD || (!VD->getType()->isBlockPointerType() && 2095 !VD->getType()->isFunctionPointerType())) { 2096 S.Diag(AL.getLoc(), AL.isCXX11Attribute() 2097 ? diag::err_attribute_wrong_decl_type 2098 : diag::warn_attribute_wrong_decl_type) 2099 << AL << ExpectedFunctionMethodOrBlock; 2100 return; 2101 } 2102 } 2103 2104 D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(S.Context, AL)); 2105} 2106 2107// PS3 PPU-specific. 2108static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2109 /* 2110 Returning a Vector Class in Registers 2111 2112 According to the PPU ABI specifications, a class with a single member of 2113 vector type is returned in memory when used as the return value of a 2114 function. 2115 This results in inefficient code when implementing vector classes. To return 2116 the value in a single vector register, add the vecreturn attribute to the 2117 class definition. This attribute is also applicable to struct types. 2118 2119 Example: 2120 2121 struct Vector 2122 { 2123 __vector float xyzw; 2124 } __attribute__((vecreturn)); 2125 2126 Vector Add(Vector lhs, Vector rhs) 2127 { 2128 Vector result; 2129 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw); 2130 return result; // This will be returned in a register 2131 } 2132 */ 2133 if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) { 2134 S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A; 2135 return; 2136 } 2137 2138 const auto *R = cast<RecordDecl>(D); 2139 int count = 0; 2140 2141 if (!isa<CXXRecordDecl>(R)) { 2142 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 2143 return; 2144 } 2145 2146 if (!cast<CXXRecordDecl>(R)->isPOD()) { 2147 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record); 2148 return; 2149 } 2150 2151 for (const auto *I : R->fields()) { 2152 if ((count == 1) || !I->getType()->isVectorType()) { 2153 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member); 2154 return; 2155 } 2156 count++; 2157 } 2158 2159 D->addAttr(::new (S.Context) VecReturnAttr(S.Context, AL)); 2160} 2161 2162static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D, 2163 const ParsedAttr &AL) { 2164 if (isa<ParmVarDecl>(D)) { 2165 // [[carries_dependency]] can only be applied to a parameter if it is a 2166 // parameter of a function declaration or lambda. 2167 if (!(Scope->getFlags() & clang::Scope::FunctionDeclarationScope)) { 2168 S.Diag(AL.getLoc(), 2169 diag::err_carries_dependency_param_not_function_decl); 2170 return; 2171 } 2172 } 2173 2174 D->addAttr(::new (S.Context) CarriesDependencyAttr(S.Context, AL)); 2175} 2176 2177static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2178 bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName(); 2179 2180 // If this is spelled as the standard C++17 attribute, but not in C++17, warn 2181 // about using it as an extension. 2182 if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr) 2183 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL; 2184 2185 D->addAttr(::new (S.Context) UnusedAttr(S.Context, AL)); 2186} 2187 2188static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2189 uint32_t priority = ConstructorAttr::DefaultPriority; 2190 if (AL.getNumArgs() && 2191 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority)) 2192 return; 2193 2194 D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, priority)); 2195} 2196 2197static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2198 uint32_t priority = DestructorAttr::DefaultPriority; 2199 if (AL.getNumArgs() && 2200 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority)) 2201 return; 2202 2203 D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, priority)); 2204} 2205 2206template <typename AttrTy> 2207static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) { 2208 // Handle the case where the attribute has a text message. 2209 StringRef Str; 2210 if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str)) 2211 return; 2212 2213 D->addAttr(::new (S.Context) AttrTy(S.Context, AL, Str)); 2214} 2215 2216static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D, 2217 const ParsedAttr &AL) { 2218 if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) { 2219 S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition) 2220 << AL << AL.getRange(); 2221 return; 2222 } 2223 2224 D->addAttr(::new (S.Context) ObjCExplicitProtocolImplAttr(S.Context, AL)); 2225} 2226 2227static bool checkAvailabilityAttr(Sema &S, SourceRange Range, 2228 IdentifierInfo *Platform, 2229 VersionTuple Introduced, 2230 VersionTuple Deprecated, 2231 VersionTuple Obsoleted) { 2232 StringRef PlatformName 2233 = AvailabilityAttr::getPrettyPlatformName(Platform->getName()); 2234 if (PlatformName.empty()) 2235 PlatformName = Platform->getName(); 2236 2237 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all 2238 // of these steps are needed). 2239 if (!Introduced.empty() && !Deprecated.empty() && 2240 !(Introduced <= Deprecated)) { 2241 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 2242 << 1 << PlatformName << Deprecated.getAsString() 2243 << 0 << Introduced.getAsString(); 2244 return true; 2245 } 2246 2247 if (!Introduced.empty() && !Obsoleted.empty() && 2248 !(Introduced <= Obsoleted)) { 2249 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 2250 << 2 << PlatformName << Obsoleted.getAsString() 2251 << 0 << Introduced.getAsString(); 2252 return true; 2253 } 2254 2255 if (!Deprecated.empty() && !Obsoleted.empty() && 2256 !(Deprecated <= Obsoleted)) { 2257 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) 2258 << 2 << PlatformName << Obsoleted.getAsString() 2259 << 1 << Deprecated.getAsString(); 2260 return true; 2261 } 2262 2263 return false; 2264} 2265 2266/// Check whether the two versions match. 2267/// 2268/// If either version tuple is empty, then they are assumed to match. If 2269/// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y. 2270static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y, 2271 bool BeforeIsOkay) { 2272 if (X.empty() || Y.empty()) 2273 return true; 2274 2275 if (X == Y) 2276 return true; 2277 2278 if (BeforeIsOkay && X < Y) 2279 return true; 2280 2281 return false; 2282} 2283 2284AvailabilityAttr *Sema::mergeAvailabilityAttr( 2285 NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform, 2286 bool Implicit, VersionTuple Introduced, VersionTuple Deprecated, 2287 VersionTuple Obsoleted, bool IsUnavailable, StringRef Message, 2288 bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK, 2289 int Priority) { 2290 VersionTuple MergedIntroduced = Introduced; 2291 VersionTuple MergedDeprecated = Deprecated; 2292 VersionTuple MergedObsoleted = Obsoleted; 2293 bool FoundAny = false; 2294 bool OverrideOrImpl = false; 2295 switch (AMK) { 2296 case AMK_None: 2297 case AMK_Redeclaration: 2298 OverrideOrImpl = false; 2299 break; 2300 2301 case AMK_Override: 2302 case AMK_ProtocolImplementation: 2303 case AMK_OptionalProtocolImplementation: 2304 OverrideOrImpl = true; 2305 break; 2306 } 2307 2308 if (D->hasAttrs()) { 2309 AttrVec &Attrs = D->getAttrs(); 2310 for (unsigned i = 0, e = Attrs.size(); i != e;) { 2311 const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]); 2312 if (!OldAA) { 2313 ++i; 2314 continue; 2315 } 2316 2317 IdentifierInfo *OldPlatform = OldAA->getPlatform(); 2318 if (OldPlatform != Platform) { 2319 ++i; 2320 continue; 2321 } 2322 2323 // If there is an existing availability attribute for this platform that 2324 // has a lower priority use the existing one and discard the new 2325 // attribute. 2326 if (OldAA->getPriority() < Priority) 2327 return nullptr; 2328 2329 // If there is an existing attribute for this platform that has a higher 2330 // priority than the new attribute then erase the old one and continue 2331 // processing the attributes. 2332 if (OldAA->getPriority() > Priority) { 2333 Attrs.erase(Attrs.begin() + i); 2334 --e; 2335 continue; 2336 } 2337 2338 FoundAny = true; 2339 VersionTuple OldIntroduced = OldAA->getIntroduced(); 2340 VersionTuple OldDeprecated = OldAA->getDeprecated(); 2341 VersionTuple OldObsoleted = OldAA->getObsoleted(); 2342 bool OldIsUnavailable = OldAA->getUnavailable(); 2343 2344 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) || 2345 !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) || 2346 !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) || 2347 !(OldIsUnavailable == IsUnavailable || 2348 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) { 2349 if (OverrideOrImpl) { 2350 int Which = -1; 2351 VersionTuple FirstVersion; 2352 VersionTuple SecondVersion; 2353 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) { 2354 Which = 0; 2355 FirstVersion = OldIntroduced; 2356 SecondVersion = Introduced; 2357 } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) { 2358 Which = 1; 2359 FirstVersion = Deprecated; 2360 SecondVersion = OldDeprecated; 2361 } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) { 2362 Which = 2; 2363 FirstVersion = Obsoleted; 2364 SecondVersion = OldObsoleted; 2365 } 2366 2367 if (Which == -1) { 2368 Diag(OldAA->getLocation(), 2369 diag::warn_mismatched_availability_override_unavail) 2370 << AvailabilityAttr::getPrettyPlatformName(Platform->getName()) 2371 << (AMK == AMK_Override); 2372 } else if (Which != 1 && AMK == AMK_OptionalProtocolImplementation) { 2373 // Allow different 'introduced' / 'obsoleted' availability versions 2374 // on a method that implements an optional protocol requirement. It 2375 // makes less sense to allow this for 'deprecated' as the user can't 2376 // see if the method is 'deprecated' as 'respondsToSelector' will 2377 // still return true when the method is deprecated. 2378 ++i; 2379 continue; 2380 } else { 2381 Diag(OldAA->getLocation(), 2382 diag::warn_mismatched_availability_override) 2383 << Which 2384 << AvailabilityAttr::getPrettyPlatformName(Platform->getName()) 2385 << FirstVersion.getAsString() << SecondVersion.getAsString() 2386 << (AMK == AMK_Override); 2387 } 2388 if (AMK == AMK_Override) 2389 Diag(CI.getLoc(), diag::note_overridden_method); 2390 else 2391 Diag(CI.getLoc(), diag::note_protocol_method); 2392 } else { 2393 Diag(OldAA->getLocation(), diag::warn_mismatched_availability); 2394 Diag(CI.getLoc(), diag::note_previous_attribute); 2395 } 2396 2397 Attrs.erase(Attrs.begin() + i); 2398 --e; 2399 continue; 2400 } 2401 2402 VersionTuple MergedIntroduced2 = MergedIntroduced; 2403 VersionTuple MergedDeprecated2 = MergedDeprecated; 2404 VersionTuple MergedObsoleted2 = MergedObsoleted; 2405 2406 if (MergedIntroduced2.empty()) 2407 MergedIntroduced2 = OldIntroduced; 2408 if (MergedDeprecated2.empty()) 2409 MergedDeprecated2 = OldDeprecated; 2410 if (MergedObsoleted2.empty()) 2411 MergedObsoleted2 = OldObsoleted; 2412 2413 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform, 2414 MergedIntroduced2, MergedDeprecated2, 2415 MergedObsoleted2)) { 2416 Attrs.erase(Attrs.begin() + i); 2417 --e; 2418 continue; 2419 } 2420 2421 MergedIntroduced = MergedIntroduced2; 2422 MergedDeprecated = MergedDeprecated2; 2423 MergedObsoleted = MergedObsoleted2; 2424 ++i; 2425 } 2426 } 2427 2428 if (FoundAny && 2429 MergedIntroduced == Introduced && 2430 MergedDeprecated == Deprecated && 2431 MergedObsoleted == Obsoleted) 2432 return nullptr; 2433 2434 // Only create a new attribute if !OverrideOrImpl, but we want to do 2435 // the checking. 2436 if (!checkAvailabilityAttr(*this, CI.getRange(), Platform, MergedIntroduced, 2437 MergedDeprecated, MergedObsoleted) && 2438 !OverrideOrImpl) { 2439 auto *Avail = ::new (Context) AvailabilityAttr( 2440 Context, CI, Platform, Introduced, Deprecated, Obsoleted, IsUnavailable, 2441 Message, IsStrict, Replacement, Priority); 2442 Avail->setImplicit(Implicit); 2443 return Avail; 2444 } 2445 return nullptr; 2446} 2447 2448static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2449 if (!AL.checkExactlyNumArgs(S, 1)) 2450 return; 2451 IdentifierLoc *Platform = AL.getArgAsIdent(0); 2452 2453 IdentifierInfo *II = Platform->Ident; 2454 if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty()) 2455 S.Diag(Platform->Loc, diag::warn_availability_unknown_platform) 2456 << Platform->Ident; 2457 2458 auto *ND = dyn_cast<NamedDecl>(D); 2459 if (!ND) // We warned about this already, so just return. 2460 return; 2461 2462 AvailabilityChange Introduced = AL.getAvailabilityIntroduced(); 2463 AvailabilityChange Deprecated = AL.getAvailabilityDeprecated(); 2464 AvailabilityChange Obsoleted = AL.getAvailabilityObsoleted(); 2465 bool IsUnavailable = AL.getUnavailableLoc().isValid(); 2466 bool IsStrict = AL.getStrictLoc().isValid(); 2467 StringRef Str; 2468 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getMessageExpr())) 2469 Str = SE->getString(); 2470 StringRef Replacement; 2471 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getReplacementExpr())) 2472 Replacement = SE->getString(); 2473 2474 if (II->isStr("swift")) { 2475 if (Introduced.isValid() || Obsoleted.isValid() || 2476 (!IsUnavailable && !Deprecated.isValid())) { 2477 S.Diag(AL.getLoc(), 2478 diag::warn_availability_swift_unavailable_deprecated_only); 2479 return; 2480 } 2481 } 2482 2483 int PriorityModifier = AL.isPragmaClangAttribute() 2484 ? Sema::AP_PragmaClangAttribute 2485 : Sema::AP_Explicit; 2486 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr( 2487 ND, AL, II, false /*Implicit*/, Introduced.Version, Deprecated.Version, 2488 Obsoleted.Version, IsUnavailable, Str, IsStrict, Replacement, 2489 Sema::AMK_None, PriorityModifier); 2490 if (NewAttr) 2491 D->addAttr(NewAttr); 2492 2493 // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning 2494 // matches before the start of the watchOS platform. 2495 if (S.Context.getTargetInfo().getTriple().isWatchOS()) { 2496 IdentifierInfo *NewII = nullptr; 2497 if (II->getName() == "ios") 2498 NewII = &S.Context.Idents.get("watchos"); 2499 else if (II->getName() == "ios_app_extension") 2500 NewII = &S.Context.Idents.get("watchos_app_extension"); 2501 2502 if (NewII) { 2503 auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple { 2504 if (Version.empty()) 2505 return Version; 2506 auto Major = Version.getMajor(); 2507 auto NewMajor = Major >= 9 ? Major - 7 : 0; 2508 if (NewMajor >= 2) { 2509 if (Version.getMinor().hasValue()) { 2510 if (Version.getSubminor().hasValue()) 2511 return VersionTuple(NewMajor, Version.getMinor().getValue(), 2512 Version.getSubminor().getValue()); 2513 else 2514 return VersionTuple(NewMajor, Version.getMinor().getValue()); 2515 } 2516 return VersionTuple(NewMajor); 2517 } 2518 2519 return VersionTuple(2, 0); 2520 }; 2521 2522 auto NewIntroduced = adjustWatchOSVersion(Introduced.Version); 2523 auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version); 2524 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version); 2525 2526 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr( 2527 ND, AL, NewII, true /*Implicit*/, NewIntroduced, NewDeprecated, 2528 NewObsoleted, IsUnavailable, Str, IsStrict, Replacement, 2529 Sema::AMK_None, 2530 PriorityModifier + Sema::AP_InferredFromOtherPlatform); 2531 if (NewAttr) 2532 D->addAttr(NewAttr); 2533 } 2534 } else if (S.Context.getTargetInfo().getTriple().isTvOS()) { 2535 // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning 2536 // matches before the start of the tvOS platform. 2537 IdentifierInfo *NewII = nullptr; 2538 if (II->getName() == "ios") 2539 NewII = &S.Context.Idents.get("tvos"); 2540 else if (II->getName() == "ios_app_extension") 2541 NewII = &S.Context.Idents.get("tvos_app_extension"); 2542 2543 if (NewII) { 2544 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr( 2545 ND, AL, NewII, true /*Implicit*/, Introduced.Version, 2546 Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict, 2547 Replacement, Sema::AMK_None, 2548 PriorityModifier + Sema::AP_InferredFromOtherPlatform); 2549 if (NewAttr) 2550 D->addAttr(NewAttr); 2551 } 2552 } 2553} 2554 2555static void handleExternalSourceSymbolAttr(Sema &S, Decl *D, 2556 const ParsedAttr &AL) { 2557 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 3)) 2558 return; 2559 2560 StringRef Language; 2561 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(0))) 2562 Language = SE->getString(); 2563 StringRef DefinedIn; 2564 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(1))) 2565 DefinedIn = SE->getString(); 2566 bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr; 2567 2568 D->addAttr(::new (S.Context) ExternalSourceSymbolAttr( 2569 S.Context, AL, Language, DefinedIn, IsGeneratedDeclaration)); 2570} 2571 2572template <class T> 2573static T *mergeVisibilityAttr(Sema &S, Decl *D, const AttributeCommonInfo &CI, 2574 typename T::VisibilityType value) { 2575 T *existingAttr = D->getAttr<T>(); 2576 if (existingAttr) { 2577 typename T::VisibilityType existingValue = existingAttr->getVisibility(); 2578 if (existingValue == value) 2579 return nullptr; 2580 S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility); 2581 S.Diag(CI.getLoc(), diag::note_previous_attribute); 2582 D->dropAttr<T>(); 2583 } 2584 return ::new (S.Context) T(S.Context, CI, value); 2585} 2586 2587VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, 2588 const AttributeCommonInfo &CI, 2589 VisibilityAttr::VisibilityType Vis) { 2590 return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, CI, Vis); 2591} 2592 2593TypeVisibilityAttr * 2594Sema::mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI, 2595 TypeVisibilityAttr::VisibilityType Vis) { 2596 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, CI, Vis); 2597} 2598 2599static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL, 2600 bool isTypeVisibility) { 2601 // Visibility attributes don't mean anything on a typedef. 2602 if (isa<TypedefNameDecl>(D)) { 2603 S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL; 2604 return; 2605 } 2606 2607 // 'type_visibility' can only go on a type or namespace. 2608 if (isTypeVisibility && 2609 !(isa<TagDecl>(D) || 2610 isa<ObjCInterfaceDecl>(D) || 2611 isa<NamespaceDecl>(D))) { 2612 S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type) 2613 << AL << ExpectedTypeOrNamespace; 2614 return; 2615 } 2616 2617 // Check that the argument is a string literal. 2618 StringRef TypeStr; 2619 SourceLocation LiteralLoc; 2620 if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc)) 2621 return; 2622 2623 VisibilityAttr::VisibilityType type; 2624 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) { 2625 S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL 2626 << TypeStr; 2627 return; 2628 } 2629 2630 // Complain about attempts to use protected visibility on targets 2631 // (like Darwin) that don't support it. 2632 if (type == VisibilityAttr::Protected && 2633 !S.Context.getTargetInfo().hasProtectedVisibility()) { 2634 S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility); 2635 type = VisibilityAttr::Default; 2636 } 2637 2638 Attr *newAttr; 2639 if (isTypeVisibility) { 2640 newAttr = S.mergeTypeVisibilityAttr( 2641 D, AL, (TypeVisibilityAttr::VisibilityType)type); 2642 } else { 2643 newAttr = S.mergeVisibilityAttr(D, AL, type); 2644 } 2645 if (newAttr) 2646 D->addAttr(newAttr); 2647} 2648 2649static void handleObjCDirectAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2650 // objc_direct cannot be set on methods declared in the context of a protocol 2651 if (isa<ObjCProtocolDecl>(D->getDeclContext())) { 2652 S.Diag(AL.getLoc(), diag::err_objc_direct_on_protocol) << false; 2653 return; 2654 } 2655 2656 if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) { 2657 handleSimpleAttribute<ObjCDirectAttr>(S, D, AL); 2658 } else { 2659 S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL; 2660 } 2661} 2662 2663static void handleObjCDirectMembersAttr(Sema &S, Decl *D, 2664 const ParsedAttr &AL) { 2665 if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) { 2666 handleSimpleAttribute<ObjCDirectMembersAttr>(S, D, AL); 2667 } else { 2668 S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL; 2669 } 2670} 2671 2672static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2673 const auto *M = cast<ObjCMethodDecl>(D); 2674 if (!AL.isArgIdent(0)) { 2675 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 2676 << AL << 1 << AANT_ArgumentIdentifier; 2677 return; 2678 } 2679 2680 IdentifierLoc *IL = AL.getArgAsIdent(0); 2681 ObjCMethodFamilyAttr::FamilyKind F; 2682 if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) { 2683 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident; 2684 return; 2685 } 2686 2687 if (F == ObjCMethodFamilyAttr::OMF_init && 2688 !M->getReturnType()->isObjCObjectPointerType()) { 2689 S.Diag(M->getLocation(), diag::err_init_method_bad_return_type) 2690 << M->getReturnType(); 2691 // Ignore the attribute. 2692 return; 2693 } 2694 2695 D->addAttr(new (S.Context) ObjCMethodFamilyAttr(S.Context, AL, F)); 2696} 2697 2698static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) { 2699 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) { 2700 QualType T = TD->getUnderlyingType(); 2701 if (!T->isCARCBridgableType()) { 2702 S.Diag(TD->getLocation(), diag::err_nsobject_attribute); 2703 return; 2704 } 2705 } 2706 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) { 2707 QualType T = PD->getType(); 2708 if (!T->isCARCBridgableType()) { 2709 S.Diag(PD->getLocation(), diag::err_nsobject_attribute); 2710 return; 2711 } 2712 } 2713 else { 2714 // It is okay to include this attribute on properties, e.g.: 2715 // 2716 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject)); 2717 // 2718 // In this case it follows tradition and suppresses an error in the above 2719 // case. 2720 S.Diag(D->getLocation(), diag::warn_nsobject_attribute); 2721 } 2722 D->addAttr(::new (S.Context) ObjCNSObjectAttr(S.Context, AL)); 2723} 2724 2725static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) { 2726 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) { 2727 QualType T = TD->getUnderlyingType(); 2728 if (!T->isObjCObjectPointerType()) { 2729 S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute); 2730 return; 2731 } 2732 } else { 2733 S.Diag(D->getLocation(), diag::warn_independentclass_attribute); 2734 return; 2735 } 2736 D->addAttr(::new (S.Context) ObjCIndependentClassAttr(S.Context, AL)); 2737} 2738 2739static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2740 if (!AL.isArgIdent(0)) { 2741 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 2742 << AL << 1 << AANT_ArgumentIdentifier; 2743 return; 2744 } 2745 2746 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 2747 BlocksAttr::BlockType type; 2748 if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) { 2749 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II; 2750 return; 2751 } 2752 2753 D->addAttr(::new (S.Context) BlocksAttr(S.Context, AL, type)); 2754} 2755 2756static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2757 unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel; 2758 if (AL.getNumArgs() > 0) { 2759 Expr *E = AL.getArgAsExpr(0); 2760 Optional<llvm::APSInt> Idx = llvm::APSInt(32); 2761 if (E->isTypeDependent() || E->isValueDependent() || 2762 !(Idx = E->getIntegerConstantExpr(S.Context))) { 2763 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 2764 << AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange(); 2765 return; 2766 } 2767 2768 if (Idx->isSigned() && Idx->isNegative()) { 2769 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero) 2770 << E->getSourceRange(); 2771 return; 2772 } 2773 2774 sentinel = Idx->getZExtValue(); 2775 } 2776 2777 unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos; 2778 if (AL.getNumArgs() > 1) { 2779 Expr *E = AL.getArgAsExpr(1); 2780 Optional<llvm::APSInt> Idx = llvm::APSInt(32); 2781 if (E->isTypeDependent() || E->isValueDependent() || 2782 !(Idx = E->getIntegerConstantExpr(S.Context))) { 2783 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 2784 << AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange(); 2785 return; 2786 } 2787 nullPos = Idx->getZExtValue(); 2788 2789 if ((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) { 2790 // FIXME: This error message could be improved, it would be nice 2791 // to say what the bounds actually are. 2792 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one) 2793 << E->getSourceRange(); 2794 return; 2795 } 2796 } 2797 2798 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 2799 const FunctionType *FT = FD->getType()->castAs<FunctionType>(); 2800 if (isa<FunctionNoProtoType>(FT)) { 2801 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments); 2802 return; 2803 } 2804 2805 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 2806 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 2807 return; 2808 } 2809 } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) { 2810 if (!MD->isVariadic()) { 2811 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0; 2812 return; 2813 } 2814 } else if (const auto *BD = dyn_cast<BlockDecl>(D)) { 2815 if (!BD->isVariadic()) { 2816 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1; 2817 return; 2818 } 2819 } else if (const auto *V = dyn_cast<VarDecl>(D)) { 2820 QualType Ty = V->getType(); 2821 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 2822 const FunctionType *FT = Ty->isFunctionPointerType() 2823 ? D->getFunctionType() 2824 : Ty->castAs<BlockPointerType>() 2825 ->getPointeeType() 2826 ->castAs<FunctionType>(); 2827 if (!cast<FunctionProtoType>(FT)->isVariadic()) { 2828 int m = Ty->isFunctionPointerType() ? 0 : 1; 2829 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m; 2830 return; 2831 } 2832 } else { 2833 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 2834 << AL << ExpectedFunctionMethodOrBlock; 2835 return; 2836 } 2837 } else { 2838 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 2839 << AL << ExpectedFunctionMethodOrBlock; 2840 return; 2841 } 2842 D->addAttr(::new (S.Context) SentinelAttr(S.Context, AL, sentinel, nullPos)); 2843} 2844 2845static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) { 2846 if (D->getFunctionType() && 2847 D->getFunctionType()->getReturnType()->isVoidType() && 2848 !isa<CXXConstructorDecl>(D)) { 2849 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0; 2850 return; 2851 } 2852 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) 2853 if (MD->getReturnType()->isVoidType()) { 2854 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1; 2855 return; 2856 } 2857 2858 StringRef Str; 2859 if ((AL.isCXX11Attribute() || AL.isC2xAttribute()) && !AL.getScopeName()) { 2860 // The standard attribute cannot be applied to variable declarations such 2861 // as a function pointer. 2862 if (isa<VarDecl>(D)) 2863 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str) 2864 << AL << "functions, classes, or enumerations"; 2865 2866 // If this is spelled as the standard C++17 attribute, but not in C++17, 2867 // warn about using it as an extension. If there are attribute arguments, 2868 // then claim it's a C++2a extension instead. 2869 // FIXME: If WG14 does not seem likely to adopt the same feature, add an 2870 // extension warning for C2x mode. 2871 const LangOptions &LO = S.getLangOpts(); 2872 if (AL.getNumArgs() == 1) { 2873 if (LO.CPlusPlus && !LO.CPlusPlus20) 2874 S.Diag(AL.getLoc(), diag::ext_cxx20_attr) << AL; 2875 2876 // Since this this is spelled [[nodiscard]], get the optional string 2877 // literal. If in C++ mode, but not in C++2a mode, diagnose as an 2878 // extension. 2879 // FIXME: C2x should support this feature as well, even as an extension. 2880 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, nullptr)) 2881 return; 2882 } else if (LO.CPlusPlus && !LO.CPlusPlus17) 2883 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL; 2884 } 2885 2886 D->addAttr(::new (S.Context) WarnUnusedResultAttr(S.Context, AL, Str)); 2887} 2888 2889static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 2890 // weak_import only applies to variable & function declarations. 2891 bool isDef = false; 2892 if (!D->canBeWeakImported(isDef)) { 2893 if (isDef) 2894 S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition) 2895 << "weak_import"; 2896 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) || 2897 (S.Context.getTargetInfo().getTriple().isOSDarwin() && 2898 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) { 2899 // Nothing to warn about here. 2900 } else 2901 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 2902 << AL << ExpectedVariableOrFunction; 2903 2904 return; 2905 } 2906 2907 D->addAttr(::new (S.Context) WeakImportAttr(S.Context, AL)); 2908} 2909 2910// Handles reqd_work_group_size and work_group_size_hint. 2911template <typename WorkGroupAttr> 2912static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) { 2913 uint32_t WGSize[3]; 2914 for (unsigned i = 0; i < 3; ++i) { 2915 const Expr *E = AL.getArgAsExpr(i); 2916 if (!checkUInt32Argument(S, AL, E, WGSize[i], i, 2917 /*StrictlyUnsigned=*/true)) 2918 return; 2919 if (WGSize[i] == 0) { 2920 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero) 2921 << AL << E->getSourceRange(); 2922 return; 2923 } 2924 } 2925 2926 WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>(); 2927 if (Existing && !(Existing->getXDim() == WGSize[0] && 2928 Existing->getYDim() == WGSize[1] && 2929 Existing->getZDim() == WGSize[2])) 2930 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL; 2931 2932 D->addAttr(::new (S.Context) 2933 WorkGroupAttr(S.Context, AL, WGSize[0], WGSize[1], WGSize[2])); 2934} 2935 2936// Handles intel_reqd_sub_group_size. 2937static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) { 2938 uint32_t SGSize; 2939 const Expr *E = AL.getArgAsExpr(0); 2940 if (!checkUInt32Argument(S, AL, E, SGSize)) 2941 return; 2942 if (SGSize == 0) { 2943 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero) 2944 << AL << E->getSourceRange(); 2945 return; 2946 } 2947 2948 OpenCLIntelReqdSubGroupSizeAttr *Existing = 2949 D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>(); 2950 if (Existing && Existing->getSubGroupSize() != SGSize) 2951 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL; 2952 2953 D->addAttr(::new (S.Context) 2954 OpenCLIntelReqdSubGroupSizeAttr(S.Context, AL, SGSize)); 2955} 2956 2957static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) { 2958 if (!AL.hasParsedType()) { 2959 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1; 2960 return; 2961 } 2962 2963 TypeSourceInfo *ParmTSI = nullptr; 2964 QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI); 2965 assert(ParmTSI && "no type source info for attribute argument"); 2966 2967 if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() && 2968 (ParmType->isBooleanType() || 2969 !ParmType->isIntegralType(S.getASTContext()))) { 2970 S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) << 2 << AL; 2971 return; 2972 } 2973 2974 if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) { 2975 if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) { 2976 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL; 2977 return; 2978 } 2979 } 2980 2981 D->addAttr(::new (S.Context) VecTypeHintAttr(S.Context, AL, ParmTSI)); 2982} 2983 2984SectionAttr *Sema::mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI, 2985 StringRef Name) { 2986 // Explicit or partial specializations do not inherit 2987 // the section attribute from the primary template. 2988 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 2989 if (CI.getAttributeSpellingListIndex() == SectionAttr::Declspec_allocate && 2990 FD->isFunctionTemplateSpecialization()) 2991 return nullptr; 2992 } 2993 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) { 2994 if (ExistingAttr->getName() == Name) 2995 return nullptr; 2996 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section) 2997 << 1 /*section*/; 2998 Diag(CI.getLoc(), diag::note_previous_attribute); 2999 return nullptr; 3000 } 3001 return ::new (Context) SectionAttr(Context, CI, Name); 3002} 3003 3004/// Used to implement to perform semantic checking on 3005/// attribute((section("foo"))) specifiers. 3006/// 3007/// In this case, "foo" is passed in to be checked. If the section 3008/// specifier is invalid, return an Error that indicates the problem. 3009/// 3010/// This is a simple quality of implementation feature to catch errors 3011/// and give good diagnostics in cases when the assembler or code generator 3012/// would otherwise reject the section specifier. 3013llvm::Error Sema::isValidSectionSpecifier(StringRef SecName) { 3014 if (!Context.getTargetInfo().getTriple().isOSDarwin()) 3015 return llvm::Error::success(); 3016 3017 // Let MCSectionMachO validate this. 3018 StringRef Segment, Section; 3019 unsigned TAA, StubSize; 3020 bool HasTAA; 3021 return llvm::MCSectionMachO::ParseSectionSpecifier(SecName, Segment, Section, 3022 TAA, HasTAA, StubSize); 3023} 3024 3025bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) { 3026 if (llvm::Error E = isValidSectionSpecifier(SecName)) { 3027 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) 3028 << toString(std::move(E)) << 1 /*'section'*/; 3029 return false; 3030 } 3031 return true; 3032} 3033 3034static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3035 // Make sure that there is a string literal as the sections's single 3036 // argument. 3037 StringRef Str; 3038 SourceLocation LiteralLoc; 3039 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc)) 3040 return; 3041 3042 if (!S.checkSectionName(LiteralLoc, Str)) 3043 return; 3044 3045 SectionAttr *NewAttr = S.mergeSectionAttr(D, AL, Str); 3046 if (NewAttr) { 3047 D->addAttr(NewAttr); 3048 if (isa<FunctionDecl, FunctionTemplateDecl, ObjCMethodDecl, 3049 ObjCPropertyDecl>(D)) 3050 S.UnifySection(NewAttr->getName(), 3051 ASTContext::PSF_Execute | ASTContext::PSF_Read, 3052 cast<NamedDecl>(D)); 3053 } 3054} 3055 3056// This is used for `__declspec(code_seg("segname"))` on a decl. 3057// `#pragma code_seg("segname")` uses checkSectionName() instead. 3058static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc, 3059 StringRef CodeSegName) { 3060 if (llvm::Error E = S.isValidSectionSpecifier(CodeSegName)) { 3061 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) 3062 << toString(std::move(E)) << 0 /*'code-seg'*/; 3063 return false; 3064 } 3065 3066 return true; 3067} 3068 3069CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI, 3070 StringRef Name) { 3071 // Explicit or partial specializations do not inherit 3072 // the code_seg attribute from the primary template. 3073 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 3074 if (FD->isFunctionTemplateSpecialization()) 3075 return nullptr; 3076 } 3077 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) { 3078 if (ExistingAttr->getName() == Name) 3079 return nullptr; 3080 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section) 3081 << 0 /*codeseg*/; 3082 Diag(CI.getLoc(), diag::note_previous_attribute); 3083 return nullptr; 3084 } 3085 return ::new (Context) CodeSegAttr(Context, CI, Name); 3086} 3087 3088static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3089 StringRef Str; 3090 SourceLocation LiteralLoc; 3091 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc)) 3092 return; 3093 if (!checkCodeSegName(S, LiteralLoc, Str)) 3094 return; 3095 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) { 3096 if (!ExistingAttr->isImplicit()) { 3097 S.Diag(AL.getLoc(), 3098 ExistingAttr->getName() == Str 3099 ? diag::warn_duplicate_codeseg_attribute 3100 : diag::err_conflicting_codeseg_attribute); 3101 return; 3102 } 3103 D->dropAttr<CodeSegAttr>(); 3104 } 3105 if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL, Str)) 3106 D->addAttr(CSA); 3107} 3108 3109// Check for things we'd like to warn about. Multiversioning issues are 3110// handled later in the process, once we know how many exist. 3111bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) { 3112 enum FirstParam { Unsupported, Duplicate, Unknown }; 3113 enum SecondParam { None, Architecture, Tune }; 3114 if (AttrStr.find("fpmath=") != StringRef::npos) 3115 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3116 << Unsupported << None << "fpmath="; 3117 3118 // Diagnose use of tune if target doesn't support it. 3119 if (!Context.getTargetInfo().supportsTargetAttributeTune() && 3120 AttrStr.find("tune=") != StringRef::npos) 3121 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3122 << Unsupported << None << "tune="; 3123 3124 ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr); 3125 3126 if (!ParsedAttrs.Architecture.empty() && 3127 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture)) 3128 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3129 << Unknown << Architecture << ParsedAttrs.Architecture; 3130 3131 if (!ParsedAttrs.Tune.empty() && 3132 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Tune)) 3133 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3134 << Unknown << Tune << ParsedAttrs.Tune; 3135 3136 if (ParsedAttrs.DuplicateArchitecture) 3137 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3138 << Duplicate << None << "arch="; 3139 if (ParsedAttrs.DuplicateTune) 3140 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3141 << Duplicate << None << "tune="; 3142 3143 for (const auto &Feature : ParsedAttrs.Features) { 3144 auto CurFeature = StringRef(Feature).drop_front(); // remove + or -. 3145 if (!Context.getTargetInfo().isValidFeatureName(CurFeature)) 3146 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3147 << Unsupported << None << CurFeature; 3148 } 3149 3150 TargetInfo::BranchProtectionInfo BPI; 3151 StringRef Error; 3152 if (!ParsedAttrs.BranchProtection.empty() && 3153 !Context.getTargetInfo().validateBranchProtection( 3154 ParsedAttrs.BranchProtection, BPI, Error)) { 3155 if (Error.empty()) 3156 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute) 3157 << Unsupported << None << "branch-protection"; 3158 else 3159 return Diag(LiteralLoc, diag::err_invalid_branch_protection_spec) 3160 << Error; 3161 } 3162 3163 return false; 3164} 3165 3166static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3167 StringRef Str; 3168 SourceLocation LiteralLoc; 3169 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) || 3170 S.checkTargetAttr(LiteralLoc, Str)) 3171 return; 3172 3173 TargetAttr *NewAttr = ::new (S.Context) TargetAttr(S.Context, AL, Str); 3174 D->addAttr(NewAttr); 3175} 3176 3177static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3178 Expr *E = AL.getArgAsExpr(0); 3179 uint32_t VecWidth; 3180 if (!checkUInt32Argument(S, AL, E, VecWidth)) { 3181 AL.setInvalid(); 3182 return; 3183 } 3184 3185 MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>(); 3186 if (Existing && Existing->getVectorWidth() != VecWidth) { 3187 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL; 3188 return; 3189 } 3190 3191 D->addAttr(::new (S.Context) MinVectorWidthAttr(S.Context, AL, VecWidth)); 3192} 3193 3194static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3195 Expr *E = AL.getArgAsExpr(0); 3196 SourceLocation Loc = E->getExprLoc(); 3197 FunctionDecl *FD = nullptr; 3198 DeclarationNameInfo NI; 3199 3200 // gcc only allows for simple identifiers. Since we support more than gcc, we 3201 // will warn the user. 3202 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) { 3203 if (DRE->hasQualifier()) 3204 S.Diag(Loc, diag::warn_cleanup_ext); 3205 FD = dyn_cast<FunctionDecl>(DRE->getDecl()); 3206 NI = DRE->getNameInfo(); 3207 if (!FD) { 3208 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1 3209 << NI.getName(); 3210 return; 3211 } 3212 } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 3213 if (ULE->hasExplicitTemplateArgs()) 3214 S.Diag(Loc, diag::warn_cleanup_ext); 3215 FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true); 3216 NI = ULE->getNameInfo(); 3217 if (!FD) { 3218 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2 3219 << NI.getName(); 3220 if (ULE->getType() == S.Context.OverloadTy) 3221 S.NoteAllOverloadCandidates(ULE); 3222 return; 3223 } 3224 } else { 3225 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0; 3226 return; 3227 } 3228 3229 if (FD->getNumParams() != 1) { 3230 S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg) 3231 << NI.getName(); 3232 return; 3233 } 3234 3235 // We're currently more strict than GCC about what function types we accept. 3236 // If this ever proves to be a problem it should be easy to fix. 3237 QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType()); 3238 QualType ParamTy = FD->getParamDecl(0)->getType(); 3239 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(), 3240 ParamTy, Ty) != Sema::Compatible) { 3241 S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type) 3242 << NI.getName() << ParamTy << Ty; 3243 return; 3244 } 3245 3246 D->addAttr(::new (S.Context) CleanupAttr(S.Context, AL, FD)); 3247} 3248 3249static void handleEnumExtensibilityAttr(Sema &S, Decl *D, 3250 const ParsedAttr &AL) { 3251 if (!AL.isArgIdent(0)) { 3252 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 3253 << AL << 0 << AANT_ArgumentIdentifier; 3254 return; 3255 } 3256 3257 EnumExtensibilityAttr::Kind ExtensibilityKind; 3258 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 3259 if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(), 3260 ExtensibilityKind)) { 3261 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II; 3262 return; 3263 } 3264 3265 D->addAttr(::new (S.Context) 3266 EnumExtensibilityAttr(S.Context, AL, ExtensibilityKind)); 3267} 3268 3269/// Handle __attribute__((format_arg((idx)))) attribute based on 3270/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 3271static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3272 Expr *IdxExpr = AL.getArgAsExpr(0); 3273 ParamIdx Idx; 3274 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx)) 3275 return; 3276 3277 // Make sure the format string is really a string. 3278 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex()); 3279 3280 bool NotNSStringTy = !isNSStringType(Ty, S.Context); 3281 if (NotNSStringTy && 3282 !isCFStringType(Ty, S.Context) && 3283 (!Ty->isPointerType() || 3284 !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) { 3285 S.Diag(AL.getLoc(), diag::err_format_attribute_not) 3286 << "a string type" << IdxExpr->getSourceRange() 3287 << getFunctionOrMethodParamRange(D, 0); 3288 return; 3289 } 3290 Ty = getFunctionOrMethodResultType(D); 3291 if (!isNSStringType(Ty, S.Context, /*AllowNSAttributedString=*/true) && 3292 !isCFStringType(Ty, S.Context) && 3293 (!Ty->isPointerType() || 3294 !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) { 3295 S.Diag(AL.getLoc(), diag::err_format_attribute_result_not) 3296 << (NotNSStringTy ? "string type" : "NSString") 3297 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0); 3298 return; 3299 } 3300 3301 D->addAttr(::new (S.Context) FormatArgAttr(S.Context, AL, Idx)); 3302} 3303 3304enum FormatAttrKind { 3305 CFStringFormat, 3306 NSStringFormat, 3307 StrftimeFormat, 3308 SupportedFormat, 3309 IgnoredFormat, 3310 InvalidFormat 3311}; 3312 3313/// getFormatAttrKind - Map from format attribute names to supported format 3314/// types. 3315static FormatAttrKind getFormatAttrKind(StringRef Format) { 3316 return llvm::StringSwitch<FormatAttrKind>(Format) 3317 // Check for formats that get handled specially. 3318 .Case("NSString", NSStringFormat) 3319 .Case("CFString", CFStringFormat) 3320 .Case("strftime", StrftimeFormat) 3321 3322 // Otherwise, check for supported formats. 3323 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat) 3324 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat) 3325 .Case("kprintf", SupportedFormat) // OpenBSD. 3326 .Case("freebsd_kprintf", SupportedFormat) // FreeBSD. 3327 .Case("os_trace", SupportedFormat) 3328 .Case("os_log", SupportedFormat) 3329 3330 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat) 3331 .Default(InvalidFormat); 3332} 3333 3334/// Handle __attribute__((init_priority(priority))) attributes based on 3335/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html 3336static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3337 if (!S.getLangOpts().CPlusPlus) { 3338 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL; 3339 return; 3340 } 3341 3342 if (S.getCurFunctionOrMethodDecl()) { 3343 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr); 3344 AL.setInvalid(); 3345 return; 3346 } 3347 QualType T = cast<VarDecl>(D)->getType(); 3348 if (S.Context.getAsArrayType(T)) 3349 T = S.Context.getBaseElementType(T); 3350 if (!T->getAs<RecordType>()) { 3351 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr); 3352 AL.setInvalid(); 3353 return; 3354 } 3355 3356 Expr *E = AL.getArgAsExpr(0); 3357 uint32_t prioritynum; 3358 if (!checkUInt32Argument(S, AL, E, prioritynum)) { 3359 AL.setInvalid(); 3360 return; 3361 } 3362 3363 // Only perform the priority check if the attribute is outside of a system 3364 // header. Values <= 100 are reserved for the implementation, and libc++ 3365 // benefits from being able to specify values in that range. 3366 if ((prioritynum < 101 || prioritynum > 65535) && 3367 !S.getSourceManager().isInSystemHeader(AL.getLoc())) { 3368 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range) 3369 << E->getSourceRange() << AL << 101 << 65535; 3370 AL.setInvalid(); 3371 return; 3372 } 3373 D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum)); 3374} 3375 3376FormatAttr *Sema::mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI, 3377 IdentifierInfo *Format, int FormatIdx, 3378 int FirstArg) { 3379 // Check whether we already have an equivalent format attribute. 3380 for (auto *F : D->specific_attrs<FormatAttr>()) { 3381 if (F->getType() == Format && 3382 F->getFormatIdx() == FormatIdx && 3383 F->getFirstArg() == FirstArg) { 3384 // If we don't have a valid location for this attribute, adopt the 3385 // location. 3386 if (F->getLocation().isInvalid()) 3387 F->setRange(CI.getRange()); 3388 return nullptr; 3389 } 3390 } 3391 3392 return ::new (Context) FormatAttr(Context, CI, Format, FormatIdx, FirstArg); 3393} 3394 3395/// Handle __attribute__((format(type,idx,firstarg))) attributes based on 3396/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 3397static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3398 if (!AL.isArgIdent(0)) { 3399 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 3400 << AL << 1 << AANT_ArgumentIdentifier; 3401 return; 3402 } 3403 3404 // In C++ the implicit 'this' function parameter also counts, and they are 3405 // counted from one. 3406 bool HasImplicitThisParam = isInstanceMethod(D); 3407 unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam; 3408 3409 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 3410 StringRef Format = II->getName(); 3411 3412 if (normalizeName(Format)) { 3413 // If we've modified the string name, we need a new identifier for it. 3414 II = &S.Context.Idents.get(Format); 3415 } 3416 3417 // Check for supported formats. 3418 FormatAttrKind Kind = getFormatAttrKind(Format); 3419 3420 if (Kind == IgnoredFormat) 3421 return; 3422 3423 if (Kind == InvalidFormat) { 3424 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) 3425 << AL << II->getName(); 3426 return; 3427 } 3428 3429 // checks for the 2nd argument 3430 Expr *IdxExpr = AL.getArgAsExpr(1); 3431 uint32_t Idx; 3432 if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2)) 3433 return; 3434 3435 if (Idx < 1 || Idx > NumArgs) { 3436 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 3437 << AL << 2 << IdxExpr->getSourceRange(); 3438 return; 3439 } 3440 3441 // FIXME: Do we need to bounds check? 3442 unsigned ArgIdx = Idx - 1; 3443 3444 if (HasImplicitThisParam) { 3445 if (ArgIdx == 0) { 3446 S.Diag(AL.getLoc(), 3447 diag::err_format_attribute_implicit_this_format_string) 3448 << IdxExpr->getSourceRange(); 3449 return; 3450 } 3451 ArgIdx--; 3452 } 3453 3454 // make sure the format string is really a string 3455 QualType Ty = getFunctionOrMethodParamType(D, ArgIdx); 3456 3457 if (Kind == CFStringFormat) { 3458 if (!isCFStringType(Ty, S.Context)) { 3459 S.Diag(AL.getLoc(), diag::err_format_attribute_not) 3460 << "a CFString" << IdxExpr->getSourceRange() 3461 << getFunctionOrMethodParamRange(D, ArgIdx); 3462 return; 3463 } 3464 } else if (Kind == NSStringFormat) { 3465 // FIXME: do we need to check if the type is NSString*? What are the 3466 // semantics? 3467 if (!isNSStringType(Ty, S.Context)) { 3468 S.Diag(AL.getLoc(), diag::err_format_attribute_not) 3469 << "an NSString" << IdxExpr->getSourceRange() 3470 << getFunctionOrMethodParamRange(D, ArgIdx); 3471 return; 3472 } 3473 } else if (!Ty->isPointerType() || 3474 !Ty->castAs<PointerType>()->getPointeeType()->isCharType()) { 3475 S.Diag(AL.getLoc(), diag::err_format_attribute_not) 3476 << "a string type" << IdxExpr->getSourceRange() 3477 << getFunctionOrMethodParamRange(D, ArgIdx); 3478 return; 3479 } 3480 3481 // check the 3rd argument 3482 Expr *FirstArgExpr = AL.getArgAsExpr(2); 3483 uint32_t FirstArg; 3484 if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3)) 3485 return; 3486 3487 // check if the function is variadic if the 3rd argument non-zero 3488 if (FirstArg != 0) { 3489 if (isFunctionOrMethodVariadic(D)) { 3490 ++NumArgs; // +1 for ... 3491 } else { 3492 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic); 3493 return; 3494 } 3495 } 3496 3497 // strftime requires FirstArg to be 0 because it doesn't read from any 3498 // variable the input is just the current time + the format string. 3499 if (Kind == StrftimeFormat) { 3500 if (FirstArg != 0) { 3501 S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter) 3502 << FirstArgExpr->getSourceRange(); 3503 return; 3504 } 3505 // if 0 it disables parameter checking (to use with e.g. va_list) 3506 } else if (FirstArg != 0 && FirstArg != NumArgs) { 3507 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 3508 << AL << 3 << FirstArgExpr->getSourceRange(); 3509 return; 3510 } 3511 3512 FormatAttr *NewAttr = S.mergeFormatAttr(D, AL, II, Idx, FirstArg); 3513 if (NewAttr) 3514 D->addAttr(NewAttr); 3515} 3516 3517/// Handle __attribute__((callback(CalleeIdx, PayloadIdx0, ...))) attributes. 3518static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3519 // The index that identifies the callback callee is mandatory. 3520 if (AL.getNumArgs() == 0) { 3521 S.Diag(AL.getLoc(), diag::err_callback_attribute_no_callee) 3522 << AL.getRange(); 3523 return; 3524 } 3525 3526 bool HasImplicitThisParam = isInstanceMethod(D); 3527 int32_t NumArgs = getFunctionOrMethodNumParams(D); 3528 3529 FunctionDecl *FD = D->getAsFunction(); 3530 assert(FD && "Expected a function declaration!"); 3531 3532 llvm::StringMap<int> NameIdxMapping; 3533 NameIdxMapping["__"] = -1; 3534 3535 NameIdxMapping["this"] = 0; 3536 3537 int Idx = 1; 3538 for (const ParmVarDecl *PVD : FD->parameters()) 3539 NameIdxMapping[PVD->getName()] = Idx++; 3540 3541 auto UnknownName = NameIdxMapping.end(); 3542 3543 SmallVector<int, 8> EncodingIndices; 3544 for (unsigned I = 0, E = AL.getNumArgs(); I < E; ++I) { 3545 SourceRange SR; 3546 int32_t ArgIdx; 3547 3548 if (AL.isArgIdent(I)) { 3549 IdentifierLoc *IdLoc = AL.getArgAsIdent(I); 3550 auto It = NameIdxMapping.find(IdLoc->Ident->getName()); 3551 if (It == UnknownName) { 3552 S.Diag(AL.getLoc(), diag::err_callback_attribute_argument_unknown) 3553 << IdLoc->Ident << IdLoc->Loc; 3554 return; 3555 } 3556 3557 SR = SourceRange(IdLoc->Loc); 3558 ArgIdx = It->second; 3559 } else if (AL.isArgExpr(I)) { 3560 Expr *IdxExpr = AL.getArgAsExpr(I); 3561 3562 // If the expression is not parseable as an int32_t we have a problem. 3563 if (!checkUInt32Argument(S, AL, IdxExpr, (uint32_t &)ArgIdx, I + 1, 3564 false)) { 3565 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 3566 << AL << (I + 1) << IdxExpr->getSourceRange(); 3567 return; 3568 } 3569 3570 // Check oob, excluding the special values, 0 and -1. 3571 if (ArgIdx < -1 || ArgIdx > NumArgs) { 3572 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 3573 << AL << (I + 1) << IdxExpr->getSourceRange(); 3574 return; 3575 } 3576 3577 SR = IdxExpr->getSourceRange(); 3578 } else { 3579 llvm_unreachable("Unexpected ParsedAttr argument type!"); 3580 } 3581 3582 if (ArgIdx == 0 && !HasImplicitThisParam) { 3583 S.Diag(AL.getLoc(), diag::err_callback_implicit_this_not_available) 3584 << (I + 1) << SR; 3585 return; 3586 } 3587 3588 // Adjust for the case we do not have an implicit "this" parameter. In this 3589 // case we decrease all positive values by 1 to get LLVM argument indices. 3590 if (!HasImplicitThisParam && ArgIdx > 0) 3591 ArgIdx -= 1; 3592 3593 EncodingIndices.push_back(ArgIdx); 3594 } 3595 3596 int CalleeIdx = EncodingIndices.front(); 3597 // Check if the callee index is proper, thus not "this" and not "unknown". 3598 // This means the "CalleeIdx" has to be non-negative if "HasImplicitThisParam" 3599 // is false and positive if "HasImplicitThisParam" is true. 3600 if (CalleeIdx < (int)HasImplicitThisParam) { 3601 S.Diag(AL.getLoc(), diag::err_callback_attribute_invalid_callee) 3602 << AL.getRange(); 3603 return; 3604 } 3605 3606 // Get the callee type, note the index adjustment as the AST doesn't contain 3607 // the this type (which the callee cannot reference anyway!). 3608 const Type *CalleeType = 3609 getFunctionOrMethodParamType(D, CalleeIdx - HasImplicitThisParam) 3610 .getTypePtr(); 3611 if (!CalleeType || !CalleeType->isFunctionPointerType()) { 3612 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type) 3613 << AL.getRange(); 3614 return; 3615 } 3616 3617 const Type *CalleeFnType = 3618 CalleeType->getPointeeType()->getUnqualifiedDesugaredType(); 3619 3620 // TODO: Check the type of the callee arguments. 3621 3622 const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType); 3623 if (!CalleeFnProtoType) { 3624 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type) 3625 << AL.getRange(); 3626 return; 3627 } 3628 3629 if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) { 3630 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) 3631 << AL << (unsigned)(EncodingIndices.size() - 1); 3632 return; 3633 } 3634 3635 if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) { 3636 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) 3637 << AL << (unsigned)(EncodingIndices.size() - 1); 3638 return; 3639 } 3640 3641 if (CalleeFnProtoType->isVariadic()) { 3642 S.Diag(AL.getLoc(), diag::err_callback_callee_is_variadic) << AL.getRange(); 3643 return; 3644 } 3645 3646 // Do not allow multiple callback attributes. 3647 if (D->hasAttr<CallbackAttr>()) { 3648 S.Diag(AL.getLoc(), diag::err_callback_attribute_multiple) << AL.getRange(); 3649 return; 3650 } 3651 3652 D->addAttr(::new (S.Context) CallbackAttr( 3653 S.Context, AL, EncodingIndices.data(), EncodingIndices.size())); 3654} 3655 3656static bool isFunctionLike(const Type &T) { 3657 // Check for explicit function types. 3658 // 'called_once' is only supported in Objective-C and it has 3659 // function pointers and block pointers. 3660 return T.isFunctionPointerType() || T.isBlockPointerType(); 3661} 3662 3663/// Handle 'called_once' attribute. 3664static void handleCalledOnceAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3665 // 'called_once' only applies to parameters representing functions. 3666 QualType T = cast<ParmVarDecl>(D)->getType(); 3667 3668 if (!isFunctionLike(*T)) { 3669 S.Diag(AL.getLoc(), diag::err_called_once_attribute_wrong_type); 3670 return; 3671 } 3672 3673 D->addAttr(::new (S.Context) CalledOnceAttr(S.Context, AL)); 3674} 3675 3676static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3677 // Try to find the underlying union declaration. 3678 RecordDecl *RD = nullptr; 3679 const auto *TD = dyn_cast<TypedefNameDecl>(D); 3680 if (TD && TD->getUnderlyingType()->isUnionType()) 3681 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl(); 3682 else 3683 RD = dyn_cast<RecordDecl>(D); 3684 3685 if (!RD || !RD->isUnion()) { 3686 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL 3687 << ExpectedUnion; 3688 return; 3689 } 3690 3691 if (!RD->isCompleteDefinition()) { 3692 if (!RD->isBeingDefined()) 3693 S.Diag(AL.getLoc(), 3694 diag::warn_transparent_union_attribute_not_definition); 3695 return; 3696 } 3697 3698 RecordDecl::field_iterator Field = RD->field_begin(), 3699 FieldEnd = RD->field_end(); 3700 if (Field == FieldEnd) { 3701 S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields); 3702 return; 3703 } 3704 3705 FieldDecl *FirstField = *Field; 3706 QualType FirstType = FirstField->getType(); 3707 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) { 3708 S.Diag(FirstField->getLocation(), 3709 diag::warn_transparent_union_attribute_floating) 3710 << FirstType->isVectorType() << FirstType; 3711 return; 3712 } 3713 3714 if (FirstType->isIncompleteType()) 3715 return; 3716 uint64_t FirstSize = S.Context.getTypeSize(FirstType); 3717 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType); 3718 for (; Field != FieldEnd; ++Field) { 3719 QualType FieldType = Field->getType(); 3720 if (FieldType->isIncompleteType()) 3721 return; 3722 // FIXME: this isn't fully correct; we also need to test whether the 3723 // members of the union would all have the same calling convention as the 3724 // first member of the union. Checking just the size and alignment isn't 3725 // sufficient (consider structs passed on the stack instead of in registers 3726 // as an example). 3727 if (S.Context.getTypeSize(FieldType) != FirstSize || 3728 S.Context.getTypeAlign(FieldType) > FirstAlign) { 3729 // Warn if we drop the attribute. 3730 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize; 3731 unsigned FieldBits = isSize ? S.Context.getTypeSize(FieldType) 3732 : S.Context.getTypeAlign(FieldType); 3733 S.Diag(Field->getLocation(), 3734 diag::warn_transparent_union_attribute_field_size_align) 3735 << isSize << *Field << FieldBits; 3736 unsigned FirstBits = isSize ? FirstSize : FirstAlign; 3737 S.Diag(FirstField->getLocation(), 3738 diag::note_transparent_union_first_field_size_align) 3739 << isSize << FirstBits; 3740 return; 3741 } 3742 } 3743 3744 RD->addAttr(::new (S.Context) TransparentUnionAttr(S.Context, AL)); 3745} 3746 3747void Sema::AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, 3748 StringRef Str, MutableArrayRef<Expr *> Args) { 3749 auto *Attr = AnnotateAttr::Create(Context, Str, Args.data(), Args.size(), CI); 3750 llvm::SmallVector<PartialDiagnosticAt, 8> Notes; 3751 for (unsigned Idx = 0; Idx < Attr->args_size(); Idx++) { 3752 Expr *&E = Attr->args_begin()[Idx]; 3753 assert(E && "error are handled before"); 3754 if (E->isValueDependent() || E->isTypeDependent()) 3755 continue; 3756 3757 if (E->getType()->isArrayType()) 3758 E = ImpCastExprToType(E, Context.getPointerType(E->getType()), 3759 clang::CK_ArrayToPointerDecay) 3760 .get(); 3761 if (E->getType()->isFunctionType()) 3762 E = ImplicitCastExpr::Create(Context, 3763 Context.getPointerType(E->getType()), 3764 clang::CK_FunctionToPointerDecay, E, nullptr, 3765 VK_RValue, FPOptionsOverride()); 3766 if (E->isLValue()) 3767 E = ImplicitCastExpr::Create(Context, E->getType().getNonReferenceType(), 3768 clang::CK_LValueToRValue, E, nullptr, 3769 VK_RValue, FPOptionsOverride()); 3770 3771 Expr::EvalResult Eval; 3772 Notes.clear(); 3773 Eval.Diag = &Notes; 3774 3775 bool Result = 3776 E->EvaluateAsConstantExpr(Eval, Context); 3777 3778 /// Result means the expression can be folded to a constant. 3779 /// Note.empty() means the expression is a valid constant expression in the 3780 /// current language mode. 3781 if (!Result || !Notes.empty()) { 3782 Diag(E->getBeginLoc(), diag::err_attribute_argument_n_type) 3783 << CI << (Idx + 1) << AANT_ArgumentConstantExpr; 3784 for (auto &Note : Notes) 3785 Diag(Note.first, Note.second); 3786 return; 3787 } 3788 assert(Eval.Val.hasValue()); 3789 E = ConstantExpr::Create(Context, E, Eval.Val); 3790 } 3791 D->addAttr(Attr); 3792} 3793 3794static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3795 // Make sure that there is a string literal as the annotation's first 3796 // argument. 3797 StringRef Str; 3798 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str)) 3799 return; 3800 3801 llvm::SmallVector<Expr *, 4> Args; 3802 Args.reserve(AL.getNumArgs() - 1); 3803 for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) { 3804 assert(!AL.isArgIdent(Idx)); 3805 Args.push_back(AL.getArgAsExpr(Idx)); 3806 } 3807 3808 S.AddAnnotationAttr(D, AL, Str, Args); 3809} 3810 3811static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3812 S.AddAlignValueAttr(D, AL, AL.getArgAsExpr(0)); 3813} 3814 3815void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) { 3816 AlignValueAttr TmpAttr(Context, CI, E); 3817 SourceLocation AttrLoc = CI.getLoc(); 3818 3819 QualType T; 3820 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) 3821 T = TD->getUnderlyingType(); 3822 else if (const auto *VD = dyn_cast<ValueDecl>(D)) 3823 T = VD->getType(); 3824 else 3825 llvm_unreachable("Unknown decl type for align_value"); 3826 3827 if (!T->isDependentType() && !T->isAnyPointerType() && 3828 !T->isReferenceType() && !T->isMemberPointerType()) { 3829 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only) 3830 << &TmpAttr << T << D->getSourceRange(); 3831 return; 3832 } 3833 3834 if (!E->isValueDependent()) { 3835 llvm::APSInt Alignment; 3836 ExprResult ICE = VerifyIntegerConstantExpression( 3837 E, &Alignment, diag::err_align_value_attribute_argument_not_int); 3838 if (ICE.isInvalid()) 3839 return; 3840 3841 if (!Alignment.isPowerOf2()) { 3842 Diag(AttrLoc, diag::err_alignment_not_power_of_two) 3843 << E->getSourceRange(); 3844 return; 3845 } 3846 3847 D->addAttr(::new (Context) AlignValueAttr(Context, CI, ICE.get())); 3848 return; 3849 } 3850 3851 // Save dependent expressions in the AST to be instantiated. 3852 D->addAttr(::new (Context) AlignValueAttr(Context, CI, E)); 3853} 3854 3855static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 3856 // check the attribute arguments. 3857 if (AL.getNumArgs() > 1) { 3858 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1; 3859 return; 3860 } 3861 3862 if (AL.getNumArgs() == 0) { 3863 D->addAttr(::new (S.Context) AlignedAttr(S.Context, AL, true, nullptr)); 3864 return; 3865 } 3866 3867 Expr *E = AL.getArgAsExpr(0); 3868 if (AL.isPackExpansion() && !E->containsUnexpandedParameterPack()) { 3869 S.Diag(AL.getEllipsisLoc(), 3870 diag::err_pack_expansion_without_parameter_packs); 3871 return; 3872 } 3873 3874 if (!AL.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E)) 3875 return; 3876 3877 S.AddAlignedAttr(D, AL, E, AL.isPackExpansion()); 3878} 3879 3880void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, 3881 bool IsPackExpansion) { 3882 AlignedAttr TmpAttr(Context, CI, true, E); 3883 SourceLocation AttrLoc = CI.getLoc(); 3884 3885 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements. 3886 if (TmpAttr.isAlignas()) { 3887 // C++11 [dcl.align]p1: 3888 // An alignment-specifier may be applied to a variable or to a class 3889 // data member, but it shall not be applied to a bit-field, a function 3890 // parameter, the formal parameter of a catch clause, or a variable 3891 // declared with the register storage class specifier. An 3892 // alignment-specifier may also be applied to the declaration of a class 3893 // or enumeration type. 3894 // C11 6.7.5/2: 3895 // An alignment attribute shall not be specified in a declaration of 3896 // a typedef, or a bit-field, or a function, or a parameter, or an 3897 // object declared with the register storage-class specifier. 3898 int DiagKind = -1; 3899 if (isa<ParmVarDecl>(D)) { 3900 DiagKind = 0; 3901 } else if (const auto *VD = dyn_cast<VarDecl>(D)) { 3902 if (VD->getStorageClass() == SC_Register) 3903 DiagKind = 1; 3904 if (VD->isExceptionVariable()) 3905 DiagKind = 2; 3906 } else if (const auto *FD = dyn_cast<FieldDecl>(D)) { 3907 if (FD->isBitField()) 3908 DiagKind = 3; 3909 } else if (!isa<TagDecl>(D)) { 3910 Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr 3911 << (TmpAttr.isC11() ? ExpectedVariableOrField 3912 : ExpectedVariableFieldOrTag); 3913 return; 3914 } 3915 if (DiagKind != -1) { 3916 Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type) 3917 << &TmpAttr << DiagKind; 3918 return; 3919 } 3920 } 3921 3922 if (E->isValueDependent()) { 3923 // We can't support a dependent alignment on a non-dependent type, 3924 // because we have no way to model that a type is "alignment-dependent" 3925 // but not dependent in any other way. 3926 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) { 3927 if (!TND->getUnderlyingType()->isDependentType()) { 3928 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name) 3929 << E->getSourceRange(); 3930 return; 3931 } 3932 } 3933 3934 // Save dependent expressions in the AST to be instantiated. 3935 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, E); 3936 AA->setPackExpansion(IsPackExpansion); 3937 D->addAttr(AA); 3938 return; 3939 } 3940 3941 // FIXME: Cache the number on the AL object? 3942 llvm::APSInt Alignment; 3943 ExprResult ICE = VerifyIntegerConstantExpression( 3944 E, &Alignment, diag::err_aligned_attribute_argument_not_int); 3945 if (ICE.isInvalid()) 3946 return; 3947 3948 uint64_t AlignVal = Alignment.getZExtValue(); 3949 3950 // C++11 [dcl.align]p2: 3951 // -- if the constant expression evaluates to zero, the alignment 3952 // specifier shall have no effect 3953 // C11 6.7.5p6: 3954 // An alignment specification of zero has no effect. 3955 if (!(TmpAttr.isAlignas() && !Alignment)) { 3956 if (!llvm::isPowerOf2_64(AlignVal)) { 3957 Diag(AttrLoc, diag::err_alignment_not_power_of_two) 3958 << E->getSourceRange(); 3959 return; 3960 } 3961 } 3962 3963 unsigned MaximumAlignment = Sema::MaximumAlignment; 3964 if (Context.getTargetInfo().getTriple().isOSBinFormatCOFF()) 3965 MaximumAlignment = std::min(MaximumAlignment, 8192u); 3966 if (AlignVal > MaximumAlignment) { 3967 Diag(AttrLoc, diag::err_attribute_aligned_too_great) 3968 << MaximumAlignment << E->getSourceRange(); 3969 return; 3970 } 3971 3972 if (Context.getTargetInfo().isTLSSupported()) { 3973 unsigned MaxTLSAlign = 3974 Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign()) 3975 .getQuantity(); 3976 const auto *VD = dyn_cast<VarDecl>(D); 3977 if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD && 3978 VD->getTLSKind() != VarDecl::TLS_None) { 3979 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum) 3980 << (unsigned)AlignVal << VD << MaxTLSAlign; 3981 return; 3982 } 3983 } 3984 3985 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, ICE.get()); 3986 AA->setPackExpansion(IsPackExpansion); 3987 D->addAttr(AA); 3988} 3989 3990void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, 3991 TypeSourceInfo *TS, bool IsPackExpansion) { 3992 // FIXME: Cache the number on the AL object if non-dependent? 3993 // FIXME: Perform checking of type validity 3994 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS); 3995 AA->setPackExpansion(IsPackExpansion); 3996 D->addAttr(AA); 3997} 3998 3999void Sema::CheckAlignasUnderalignment(Decl *D) { 4000 assert(D->hasAttrs() && "no attributes on decl"); 4001 4002 QualType UnderlyingTy, DiagTy; 4003 if (const auto *VD = dyn_cast<ValueDecl>(D)) { 4004 UnderlyingTy = DiagTy = VD->getType(); 4005 } else { 4006 UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D)); 4007 if (const auto *ED = dyn_cast<EnumDecl>(D)) 4008 UnderlyingTy = ED->getIntegerType(); 4009 } 4010 if (DiagTy->isDependentType() || DiagTy->isIncompleteType()) 4011 return; 4012 4013 // C++11 [dcl.align]p5, C11 6.7.5/4: 4014 // The combined effect of all alignment attributes in a declaration shall 4015 // not specify an alignment that is less strict than the alignment that 4016 // would otherwise be required for the entity being declared. 4017 AlignedAttr *AlignasAttr = nullptr; 4018 AlignedAttr *LastAlignedAttr = nullptr; 4019 unsigned Align = 0; 4020 for (auto *I : D->specific_attrs<AlignedAttr>()) { 4021 if (I->isAlignmentDependent()) 4022 return; 4023 if (I->isAlignas()) 4024 AlignasAttr = I; 4025 Align = std::max(Align, I->getAlignment(Context)); 4026 LastAlignedAttr = I; 4027 } 4028 4029 if (Align && DiagTy->isSizelessType()) { 4030 Diag(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type) 4031 << LastAlignedAttr << DiagTy; 4032 } else if (AlignasAttr && Align) { 4033 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align); 4034 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy); 4035 if (NaturalAlign > RequestedAlign) 4036 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned) 4037 << DiagTy << (unsigned)NaturalAlign.getQuantity(); 4038 } 4039} 4040 4041bool Sema::checkMSInheritanceAttrOnDefinition( 4042 CXXRecordDecl *RD, SourceRange Range, bool BestCase, 4043 MSInheritanceModel ExplicitModel) { 4044 assert(RD->hasDefinition() && "RD has no definition!"); 4045 4046 // We may not have seen base specifiers or any virtual methods yet. We will 4047 // have to wait until the record is defined to catch any mismatches. 4048 if (!RD->getDefinition()->isCompleteDefinition()) 4049 return false; 4050 4051 // The unspecified model never matches what a definition could need. 4052 if (ExplicitModel == MSInheritanceModel::Unspecified) 4053 return false; 4054 4055 if (BestCase) { 4056 if (RD->calculateInheritanceModel() == ExplicitModel) 4057 return false; 4058 } else { 4059 if (RD->calculateInheritanceModel() <= ExplicitModel) 4060 return false; 4061 } 4062 4063 Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance) 4064 << 0 /*definition*/; 4065 Diag(RD->getDefinition()->getLocation(), diag::note_defined_here) << RD; 4066 return true; 4067} 4068 4069/// parseModeAttrArg - Parses attribute mode string and returns parsed type 4070/// attribute. 4071static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth, 4072 bool &IntegerMode, bool &ComplexMode, 4073 bool &ExplicitIEEE) { 4074 IntegerMode = true; 4075 ComplexMode = false; 4076 switch (Str.size()) { 4077 case 2: 4078 switch (Str[0]) { 4079 case 'Q': 4080 DestWidth = 8; 4081 break; 4082 case 'H': 4083 DestWidth = 16; 4084 break; 4085 case 'S': 4086 DestWidth = 32; 4087 break; 4088 case 'D': 4089 DestWidth = 64; 4090 break; 4091 case 'X': 4092 DestWidth = 96; 4093 break; 4094 case 'K': // KFmode - IEEE quad precision (__float128) 4095 ExplicitIEEE = true; 4096 DestWidth = Str[1] == 'I' ? 0 : 128; 4097 break; 4098 case 'T': 4099 ExplicitIEEE = false; 4100 DestWidth = 128; 4101 break; 4102 } 4103 if (Str[1] == 'F') { 4104 IntegerMode = false; 4105 } else if (Str[1] == 'C') { 4106 IntegerMode = false; 4107 ComplexMode = true; 4108 } else if (Str[1] != 'I') { 4109 DestWidth = 0; 4110 } 4111 break; 4112 case 4: 4113 // FIXME: glibc uses 'word' to define register_t; this is narrower than a 4114 // pointer on PIC16 and other embedded platforms. 4115 if (Str == "word") 4116 DestWidth = S.Context.getTargetInfo().getRegisterWidth(); 4117 else if (Str == "byte") 4118 DestWidth = S.Context.getTargetInfo().getCharWidth(); 4119 break; 4120 case 7: 4121 if (Str == "pointer") 4122 DestWidth = S.Context.getTargetInfo().getPointerWidth(0); 4123 break; 4124 case 11: 4125 if (Str == "unwind_word") 4126 DestWidth = S.Context.getTargetInfo().getUnwindWordWidth(); 4127 break; 4128 } 4129} 4130 4131/// handleModeAttr - This attribute modifies the width of a decl with primitive 4132/// type. 4133/// 4134/// Despite what would be logical, the mode attribute is a decl attribute, not a 4135/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be 4136/// HImode, not an intermediate pointer. 4137static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4138 // This attribute isn't documented, but glibc uses it. It changes 4139 // the width of an int or unsigned int to the specified size. 4140 if (!AL.isArgIdent(0)) { 4141 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 4142 << AL << AANT_ArgumentIdentifier; 4143 return; 4144 } 4145 4146 IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident; 4147 4148 S.AddModeAttr(D, AL, Name); 4149} 4150 4151void Sema::AddModeAttr(Decl *D, const AttributeCommonInfo &CI, 4152 IdentifierInfo *Name, bool InInstantiation) { 4153 StringRef Str = Name->getName(); 4154 normalizeName(Str); 4155 SourceLocation AttrLoc = CI.getLoc(); 4156 4157 unsigned DestWidth = 0; 4158 bool IntegerMode = true; 4159 bool ComplexMode = false; 4160 bool ExplicitIEEE = false; 4161 llvm::APInt VectorSize(64, 0); 4162 if (Str.size() >= 4 && Str[0] == 'V') { 4163 // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2). 4164 size_t StrSize = Str.size(); 4165 size_t VectorStringLength = 0; 4166 while ((VectorStringLength + 1) < StrSize && 4167 isdigit(Str[VectorStringLength + 1])) 4168 ++VectorStringLength; 4169 if (VectorStringLength && 4170 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) && 4171 VectorSize.isPowerOf2()) { 4172 parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth, 4173 IntegerMode, ComplexMode, ExplicitIEEE); 4174 // Avoid duplicate warning from template instantiation. 4175 if (!InInstantiation) 4176 Diag(AttrLoc, diag::warn_vector_mode_deprecated); 4177 } else { 4178 VectorSize = 0; 4179 } 4180 } 4181 4182 if (!VectorSize) 4183 parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode, 4184 ExplicitIEEE); 4185 4186 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t 4187 // and friends, at least with glibc. 4188 // FIXME: Make sure floating-point mappings are accurate 4189 // FIXME: Support XF and TF types 4190 if (!DestWidth) { 4191 Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name; 4192 return; 4193 } 4194 4195 QualType OldTy; 4196 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) 4197 OldTy = TD->getUnderlyingType(); 4198 else if (const auto *ED = dyn_cast<EnumDecl>(D)) { 4199 // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'. 4200 // Try to get type from enum declaration, default to int. 4201 OldTy = ED->getIntegerType(); 4202 if (OldTy.isNull()) 4203 OldTy = Context.IntTy; 4204 } else 4205 OldTy = cast<ValueDecl>(D)->getType(); 4206 4207 if (OldTy->isDependentType()) { 4208 D->addAttr(::new (Context) ModeAttr(Context, CI, Name)); 4209 return; 4210 } 4211 4212 // Base type can also be a vector type (see PR17453). 4213 // Distinguish between base type and base element type. 4214 QualType OldElemTy = OldTy; 4215 if (const auto *VT = OldTy->getAs<VectorType>()) 4216 OldElemTy = VT->getElementType(); 4217 4218 // GCC allows 'mode' attribute on enumeration types (even incomplete), except 4219 // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete 4220 // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected. 4221 if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) && 4222 VectorSize.getBoolValue()) { 4223 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << CI.getRange(); 4224 return; 4225 } 4226 bool IntegralOrAnyEnumType = (OldElemTy->isIntegralOrEnumerationType() && 4227 !OldElemTy->isExtIntType()) || 4228 OldElemTy->getAs<EnumType>(); 4229 4230 if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() && 4231 !IntegralOrAnyEnumType) 4232 Diag(AttrLoc, diag::err_mode_not_primitive); 4233 else if (IntegerMode) { 4234 if (!IntegralOrAnyEnumType) 4235 Diag(AttrLoc, diag::err_mode_wrong_type); 4236 } else if (ComplexMode) { 4237 if (!OldElemTy->isComplexType()) 4238 Diag(AttrLoc, diag::err_mode_wrong_type); 4239 } else { 4240 if (!OldElemTy->isFloatingType()) 4241 Diag(AttrLoc, diag::err_mode_wrong_type); 4242 } 4243 4244 QualType NewElemTy; 4245 4246 if (IntegerMode) 4247 NewElemTy = Context.getIntTypeForBitwidth(DestWidth, 4248 OldElemTy->isSignedIntegerType()); 4249 else 4250 NewElemTy = Context.getRealTypeForBitwidth(DestWidth, ExplicitIEEE); 4251 4252 if (NewElemTy.isNull()) { 4253 Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name; 4254 return; 4255 } 4256 4257 if (ComplexMode) { 4258 NewElemTy = Context.getComplexType(NewElemTy); 4259 } 4260 4261 QualType NewTy = NewElemTy; 4262 if (VectorSize.getBoolValue()) { 4263 NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(), 4264 VectorType::GenericVector); 4265 } else if (const auto *OldVT = OldTy->getAs<VectorType>()) { 4266 // Complex machine mode does not support base vector types. 4267 if (ComplexMode) { 4268 Diag(AttrLoc, diag::err_complex_mode_vector_type); 4269 return; 4270 } 4271 unsigned NumElements = Context.getTypeSize(OldElemTy) * 4272 OldVT->getNumElements() / 4273 Context.getTypeSize(NewElemTy); 4274 NewTy = 4275 Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind()); 4276 } 4277 4278 if (NewTy.isNull()) { 4279 Diag(AttrLoc, diag::err_mode_wrong_type); 4280 return; 4281 } 4282 4283 // Install the new type. 4284 if (auto *TD = dyn_cast<TypedefNameDecl>(D)) 4285 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy); 4286 else if (auto *ED = dyn_cast<EnumDecl>(D)) 4287 ED->setIntegerType(NewTy); 4288 else 4289 cast<ValueDecl>(D)->setType(NewTy); 4290 4291 D->addAttr(::new (Context) ModeAttr(Context, CI, Name)); 4292} 4293 4294static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4295 D->addAttr(::new (S.Context) NoDebugAttr(S.Context, AL)); 4296} 4297 4298AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, 4299 const AttributeCommonInfo &CI, 4300 const IdentifierInfo *Ident) { 4301 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) { 4302 Diag(CI.getLoc(), diag::warn_attribute_ignored) << Ident; 4303 Diag(Optnone->getLocation(), diag::note_conflicting_attribute); 4304 return nullptr; 4305 } 4306 4307 if (D->hasAttr<AlwaysInlineAttr>()) 4308 return nullptr; 4309 4310 return ::new (Context) AlwaysInlineAttr(Context, CI); 4311} 4312 4313InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D, 4314 const ParsedAttr &AL) { 4315 if (const auto *VD = dyn_cast<VarDecl>(D)) { 4316 // Attribute applies to Var but not any subclass of it (like ParmVar, 4317 // ImplicitParm or VarTemplateSpecialization). 4318 if (VD->getKind() != Decl::Var) { 4319 Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 4320 << AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass 4321 : ExpectedVariableOrFunction); 4322 return nullptr; 4323 } 4324 // Attribute does not apply to non-static local variables. 4325 if (VD->hasLocalStorage()) { 4326 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage); 4327 return nullptr; 4328 } 4329 } 4330 4331 return ::new (Context) InternalLinkageAttr(Context, AL); 4332} 4333InternalLinkageAttr * 4334Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) { 4335 if (const auto *VD = dyn_cast<VarDecl>(D)) { 4336 // Attribute applies to Var but not any subclass of it (like ParmVar, 4337 // ImplicitParm or VarTemplateSpecialization). 4338 if (VD->getKind() != Decl::Var) { 4339 Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type) 4340 << &AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass 4341 : ExpectedVariableOrFunction); 4342 return nullptr; 4343 } 4344 // Attribute does not apply to non-static local variables. 4345 if (VD->hasLocalStorage()) { 4346 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage); 4347 return nullptr; 4348 } 4349 } 4350 4351 return ::new (Context) InternalLinkageAttr(Context, AL); 4352} 4353 4354MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI) { 4355 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) { 4356 Diag(CI.getLoc(), diag::warn_attribute_ignored) << "'minsize'"; 4357 Diag(Optnone->getLocation(), diag::note_conflicting_attribute); 4358 return nullptr; 4359 } 4360 4361 if (D->hasAttr<MinSizeAttr>()) 4362 return nullptr; 4363 4364 return ::new (Context) MinSizeAttr(Context, CI); 4365} 4366 4367SwiftNameAttr *Sema::mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, 4368 StringRef Name) { 4369 if (const auto *PrevSNA = D->getAttr<SwiftNameAttr>()) { 4370 if (PrevSNA->getName() != Name && !PrevSNA->isImplicit()) { 4371 Diag(PrevSNA->getLocation(), diag::err_attributes_are_not_compatible) 4372 << PrevSNA << &SNA; 4373 Diag(SNA.getLoc(), diag::note_conflicting_attribute); 4374 } 4375 4376 D->dropAttr<SwiftNameAttr>(); 4377 } 4378 return ::new (Context) SwiftNameAttr(Context, SNA, Name); 4379} 4380 4381OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, 4382 const AttributeCommonInfo &CI) { 4383 if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) { 4384 Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline; 4385 Diag(CI.getLoc(), diag::note_conflicting_attribute); 4386 D->dropAttr<AlwaysInlineAttr>(); 4387 } 4388 if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) { 4389 Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize; 4390 Diag(CI.getLoc(), diag::note_conflicting_attribute); 4391 D->dropAttr<MinSizeAttr>(); 4392 } 4393 4394 if (D->hasAttr<OptimizeNoneAttr>()) 4395 return nullptr; 4396 4397 return ::new (Context) OptimizeNoneAttr(Context, CI); 4398} 4399 4400static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4401 if (AlwaysInlineAttr *Inline = 4402 S.mergeAlwaysInlineAttr(D, AL, AL.getAttrName())) 4403 D->addAttr(Inline); 4404} 4405 4406static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4407 if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(D, AL)) 4408 D->addAttr(MinSize); 4409} 4410 4411static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4412 if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(D, AL)) 4413 D->addAttr(Optnone); 4414} 4415 4416static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4417 const auto *VD = cast<VarDecl>(D); 4418 if (VD->hasLocalStorage()) { 4419 S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev); 4420 return; 4421 } 4422 // constexpr variable may already get an implicit constant attr, which should 4423 // be replaced by the explicit constant attr. 4424 if (auto *A = D->getAttr<CUDAConstantAttr>()) { 4425 if (!A->isImplicit()) 4426 return; 4427 D->dropAttr<CUDAConstantAttr>(); 4428 } 4429 D->addAttr(::new (S.Context) CUDAConstantAttr(S.Context, AL)); 4430} 4431 4432static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4433 const auto *VD = cast<VarDecl>(D); 4434 // extern __shared__ is only allowed on arrays with no length (e.g. 4435 // "int x[]"). 4436 if (!S.getLangOpts().GPURelocatableDeviceCode && VD->hasExternalStorage() && 4437 !isa<IncompleteArrayType>(VD->getType())) { 4438 S.Diag(AL.getLoc(), diag::err_cuda_extern_shared) << VD; 4439 return; 4440 } 4441 if (S.getLangOpts().CUDA && VD->hasLocalStorage() && 4442 S.CUDADiagIfHostCode(AL.getLoc(), diag::err_cuda_host_shared) 4443 << S.CurrentCUDATarget()) 4444 return; 4445 D->addAttr(::new (S.Context) CUDASharedAttr(S.Context, AL)); 4446} 4447 4448static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4449 const auto *FD = cast<FunctionDecl>(D); 4450 if (!FD->getReturnType()->isVoidType() && 4451 !FD->getReturnType()->getAs<AutoType>() && 4452 !FD->getReturnType()->isInstantiationDependentType()) { 4453 SourceRange RTRange = FD->getReturnTypeSourceRange(); 4454 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return) 4455 << FD->getType() 4456 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void") 4457 : FixItHint()); 4458 return; 4459 } 4460 if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) { 4461 if (Method->isInstance()) { 4462 S.Diag(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method) 4463 << Method; 4464 return; 4465 } 4466 S.Diag(Method->getBeginLoc(), diag::warn_kern_is_method) << Method; 4467 } 4468 // Only warn for "inline" when compiling for host, to cut down on noise. 4469 if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice) 4470 S.Diag(FD->getBeginLoc(), diag::warn_kern_is_inline) << FD; 4471 4472 D->addAttr(::new (S.Context) CUDAGlobalAttr(S.Context, AL)); 4473 // In host compilation the kernel is emitted as a stub function, which is 4474 // a helper function for launching the kernel. The instructions in the helper 4475 // function has nothing to do with the source code of the kernel. Do not emit 4476 // debug info for the stub function to avoid confusing the debugger. 4477 if (S.LangOpts.HIP && !S.LangOpts.CUDAIsDevice) 4478 D->addAttr(NoDebugAttr::CreateImplicit(S.Context)); 4479} 4480 4481static void handleDeviceAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4482 if (const auto *VD = dyn_cast<VarDecl>(D)) { 4483 if (VD->hasLocalStorage()) { 4484 S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev); 4485 return; 4486 } 4487 } 4488 4489 if (auto *A = D->getAttr<CUDADeviceAttr>()) { 4490 if (!A->isImplicit()) 4491 return; 4492 D->dropAttr<CUDADeviceAttr>(); 4493 } 4494 D->addAttr(::new (S.Context) CUDADeviceAttr(S.Context, AL)); 4495} 4496 4497static void handleManagedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4498 if (const auto *VD = dyn_cast<VarDecl>(D)) { 4499 if (VD->hasLocalStorage()) { 4500 S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev); 4501 return; 4502 } 4503 } 4504 if (!D->hasAttr<HIPManagedAttr>()) 4505 D->addAttr(::new (S.Context) HIPManagedAttr(S.Context, AL)); 4506 if (!D->hasAttr<CUDADeviceAttr>()) 4507 D->addAttr(CUDADeviceAttr::CreateImplicit(S.Context)); 4508} 4509 4510static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4511 const auto *Fn = cast<FunctionDecl>(D); 4512 if (!Fn->isInlineSpecified()) { 4513 S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline); 4514 return; 4515 } 4516 4517 if (S.LangOpts.CPlusPlus && Fn->getStorageClass() != SC_Extern) 4518 S.Diag(AL.getLoc(), diag::warn_gnu_inline_cplusplus_without_extern); 4519 4520 D->addAttr(::new (S.Context) GNUInlineAttr(S.Context, AL)); 4521} 4522 4523static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4524 if (hasDeclarator(D)) return; 4525 4526 // Diagnostic is emitted elsewhere: here we store the (valid) AL 4527 // in the Decl node for syntactic reasoning, e.g., pretty-printing. 4528 CallingConv CC; 4529 if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr)) 4530 return; 4531 4532 if (!isa<ObjCMethodDecl>(D)) { 4533 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 4534 << AL << ExpectedFunctionOrMethod; 4535 return; 4536 } 4537 4538 switch (AL.getKind()) { 4539 case ParsedAttr::AT_FastCall: 4540 D->addAttr(::new (S.Context) FastCallAttr(S.Context, AL)); 4541 return; 4542 case ParsedAttr::AT_StdCall: 4543 D->addAttr(::new (S.Context) StdCallAttr(S.Context, AL)); 4544 return; 4545 case ParsedAttr::AT_ThisCall: 4546 D->addAttr(::new (S.Context) ThisCallAttr(S.Context, AL)); 4547 return; 4548 case ParsedAttr::AT_CDecl: 4549 D->addAttr(::new (S.Context) CDeclAttr(S.Context, AL)); 4550 return; 4551 case ParsedAttr::AT_Pascal: 4552 D->addAttr(::new (S.Context) PascalAttr(S.Context, AL)); 4553 return; 4554 case ParsedAttr::AT_SwiftCall: 4555 D->addAttr(::new (S.Context) SwiftCallAttr(S.Context, AL)); 4556 return; 4557 case ParsedAttr::AT_VectorCall: 4558 D->addAttr(::new (S.Context) VectorCallAttr(S.Context, AL)); 4559 return; 4560 case ParsedAttr::AT_MSABI: 4561 D->addAttr(::new (S.Context) MSABIAttr(S.Context, AL)); 4562 return; 4563 case ParsedAttr::AT_SysVABI: 4564 D->addAttr(::new (S.Context) SysVABIAttr(S.Context, AL)); 4565 return; 4566 case ParsedAttr::AT_RegCall: 4567 D->addAttr(::new (S.Context) RegCallAttr(S.Context, AL)); 4568 return; 4569 case ParsedAttr::AT_Pcs: { 4570 PcsAttr::PCSType PCS; 4571 switch (CC) { 4572 case CC_AAPCS: 4573 PCS = PcsAttr::AAPCS; 4574 break; 4575 case CC_AAPCS_VFP: 4576 PCS = PcsAttr::AAPCS_VFP; 4577 break; 4578 default: 4579 llvm_unreachable("unexpected calling convention in pcs attribute"); 4580 } 4581 4582 D->addAttr(::new (S.Context) PcsAttr(S.Context, AL, PCS)); 4583 return; 4584 } 4585 case ParsedAttr::AT_AArch64VectorPcs: 4586 D->addAttr(::new (S.Context) AArch64VectorPcsAttr(S.Context, AL)); 4587 return; 4588 case ParsedAttr::AT_IntelOclBicc: 4589 D->addAttr(::new (S.Context) IntelOclBiccAttr(S.Context, AL)); 4590 return; 4591 case ParsedAttr::AT_PreserveMost: 4592 D->addAttr(::new (S.Context) PreserveMostAttr(S.Context, AL)); 4593 return; 4594 case ParsedAttr::AT_PreserveAll: 4595 D->addAttr(::new (S.Context) PreserveAllAttr(S.Context, AL)); 4596 return; 4597 default: 4598 llvm_unreachable("unexpected attribute kind"); 4599 } 4600} 4601 4602static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4603 if (!AL.checkAtLeastNumArgs(S, 1)) 4604 return; 4605 4606 std::vector<StringRef> DiagnosticIdentifiers; 4607 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) { 4608 StringRef RuleName; 4609 4610 if (!S.checkStringLiteralArgumentAttr(AL, I, RuleName, nullptr)) 4611 return; 4612 4613 // FIXME: Warn if the rule name is unknown. This is tricky because only 4614 // clang-tidy knows about available rules. 4615 DiagnosticIdentifiers.push_back(RuleName); 4616 } 4617 D->addAttr(::new (S.Context) 4618 SuppressAttr(S.Context, AL, DiagnosticIdentifiers.data(), 4619 DiagnosticIdentifiers.size())); 4620} 4621 4622static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 4623 TypeSourceInfo *DerefTypeLoc = nullptr; 4624 QualType ParmType; 4625 if (AL.hasParsedType()) { 4626 ParmType = S.GetTypeFromParser(AL.getTypeArg(), &DerefTypeLoc); 4627 4628 unsigned SelectIdx = ~0U; 4629 if (ParmType->isReferenceType()) 4630 SelectIdx = 0; 4631 else if (ParmType->isArrayType()) 4632 SelectIdx = 1; 4633 4634 if (SelectIdx != ~0U) { 4635 S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) 4636 << SelectIdx << AL; 4637 return; 4638 } 4639 } 4640 4641 // To check if earlier decl attributes do not conflict the newly parsed ones 4642 // we always add (and check) the attribute to the cannonical decl. We need 4643 // to repeat the check for attribute mutual exclusion because we're attaching 4644 // all of the attributes to the canonical declaration rather than the current 4645 // declaration. 4646 D = D->getCanonicalDecl(); 4647 if (AL.getKind() == ParsedAttr::AT_Owner) { 4648 if (checkAttrMutualExclusion<PointerAttr>(S, D, AL)) 4649 return; 4650 if (const auto *OAttr = D->getAttr<OwnerAttr>()) { 4651 const Type *ExistingDerefType = OAttr->getDerefTypeLoc() 4652 ? OAttr->getDerefType().getTypePtr() 4653 : nullptr; 4654 if (ExistingDerefType != ParmType.getTypePtrOrNull()) { 4655 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) 4656 << AL << OAttr; 4657 S.Diag(OAttr->getLocation(), diag::note_conflicting_attribute); 4658 } 4659 return; 4660 } 4661 for (Decl *Redecl : D->redecls()) { 4662 Redecl->addAttr(::new (S.Context) OwnerAttr(S.Context, AL, DerefTypeLoc)); 4663 } 4664 } else { 4665 if (checkAttrMutualExclusion<OwnerAttr>(S, D, AL)) 4666 return; 4667 if (const auto *PAttr = D->getAttr<PointerAttr>()) { 4668 const Type *ExistingDerefType = PAttr->getDerefTypeLoc() 4669 ? PAttr->getDerefType().getTypePtr() 4670 : nullptr; 4671 if (ExistingDerefType != ParmType.getTypePtrOrNull()) { 4672 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) 4673 << AL << PAttr; 4674 S.Diag(PAttr->getLocation(), diag::note_conflicting_attribute); 4675 } 4676 return; 4677 } 4678 for (Decl *Redecl : D->redecls()) { 4679 Redecl->addAttr(::new (S.Context) 4680 PointerAttr(S.Context, AL, DerefTypeLoc)); 4681 } 4682 } 4683} 4684 4685bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC, 4686 const FunctionDecl *FD) { 4687 if (Attrs.isInvalid()) 4688 return true; 4689 4690 if (Attrs.hasProcessingCache()) { 4691 CC = (CallingConv) Attrs.getProcessingCache(); 4692 return false; 4693 } 4694 4695 unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0; 4696 if (!Attrs.checkExactlyNumArgs(*this, ReqArgs)) { 4697 Attrs.setInvalid(); 4698 return true; 4699 } 4700 4701 // TODO: diagnose uses of these conventions on the wrong target. 4702 switch (Attrs.getKind()) { 4703 case ParsedAttr::AT_CDecl: 4704 CC = CC_C; 4705 break; 4706 case ParsedAttr::AT_FastCall: 4707 CC = CC_X86FastCall; 4708 break; 4709 case ParsedAttr::AT_StdCall: 4710 CC = CC_X86StdCall; 4711 break; 4712 case ParsedAttr::AT_ThisCall: 4713 CC = CC_X86ThisCall; 4714 break; 4715 case ParsedAttr::AT_Pascal: 4716 CC = CC_X86Pascal; 4717 break; 4718 case ParsedAttr::AT_SwiftCall: 4719 CC = CC_Swift; 4720 break; 4721 case ParsedAttr::AT_VectorCall: 4722 CC = CC_X86VectorCall; 4723 break; 4724 case ParsedAttr::AT_AArch64VectorPcs: 4725 CC = CC_AArch64VectorCall; 4726 break; 4727 case ParsedAttr::AT_RegCall: 4728 CC = CC_X86RegCall; 4729 break; 4730 case ParsedAttr::AT_MSABI: 4731 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C : 4732 CC_Win64; 4733 break; 4734 case ParsedAttr::AT_SysVABI: 4735 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV : 4736 CC_C; 4737 break; 4738 case ParsedAttr::AT_Pcs: { 4739 StringRef StrRef; 4740 if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) { 4741 Attrs.setInvalid(); 4742 return true; 4743 } 4744 if (StrRef == "aapcs") { 4745 CC = CC_AAPCS; 4746 break; 4747 } else if (StrRef == "aapcs-vfp") { 4748 CC = CC_AAPCS_VFP; 4749 break; 4750 } 4751 4752 Attrs.setInvalid(); 4753 Diag(Attrs.getLoc(), diag::err_invalid_pcs); 4754 return true; 4755 } 4756 case ParsedAttr::AT_IntelOclBicc: 4757 CC = CC_IntelOclBicc; 4758 break; 4759 case ParsedAttr::AT_PreserveMost: 4760 CC = CC_PreserveMost; 4761 break; 4762 case ParsedAttr::AT_PreserveAll: 4763 CC = CC_PreserveAll; 4764 break; 4765 default: llvm_unreachable("unexpected attribute kind"); 4766 } 4767 4768 TargetInfo::CallingConvCheckResult A = TargetInfo::CCCR_OK; 4769 const TargetInfo &TI = Context.getTargetInfo(); 4770 // CUDA functions may have host and/or device attributes which indicate 4771 // their targeted execution environment, therefore the calling convention 4772 // of functions in CUDA should be checked against the target deduced based 4773 // on their host/device attributes. 4774 if (LangOpts.CUDA) { 4775 auto *Aux = Context.getAuxTargetInfo(); 4776 auto CudaTarget = IdentifyCUDATarget(FD); 4777 bool CheckHost = false, CheckDevice = false; 4778 switch (CudaTarget) { 4779 case CFT_HostDevice: 4780 CheckHost = true; 4781 CheckDevice = true; 4782 break; 4783 case CFT_Host: 4784 CheckHost = true; 4785 break; 4786 case CFT_Device: 4787 case CFT_Global: 4788 CheckDevice = true; 4789 break; 4790 case CFT_InvalidTarget: 4791 llvm_unreachable("unexpected cuda target"); 4792 } 4793 auto *HostTI = LangOpts.CUDAIsDevice ? Aux : &TI; 4794 auto *DeviceTI = LangOpts.CUDAIsDevice ? &TI : Aux; 4795 if (CheckHost && HostTI) 4796 A = HostTI->checkCallingConvention(CC); 4797 if (A == TargetInfo::CCCR_OK && CheckDevice && DeviceTI) 4798 A = DeviceTI->checkCallingConvention(CC); 4799 } else { 4800 A = TI.checkCallingConvention(CC); 4801 } 4802 4803 switch (A) { 4804 case TargetInfo::CCCR_OK: 4805 break; 4806 4807 case TargetInfo::CCCR_Ignore: 4808 // Treat an ignored convention as if it was an explicit C calling convention 4809 // attribute. For example, __stdcall on Win x64 functions as __cdecl, so 4810 // that command line flags that change the default convention to 4811 // __vectorcall don't affect declarations marked __stdcall. 4812 CC = CC_C; 4813 break; 4814 4815 case TargetInfo::CCCR_Error: 4816 Diag(Attrs.getLoc(), diag::error_cconv_unsupported) 4817 << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget; 4818 break; 4819 4820 case TargetInfo::CCCR_Warning: { 4821 Diag(Attrs.getLoc(), diag::warn_cconv_unsupported) 4822 << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget; 4823 4824 // This convention is not valid for the target. Use the default function or 4825 // method calling convention. 4826 bool IsCXXMethod = false, IsVariadic = false; 4827 if (FD) { 4828 IsCXXMethod = FD->isCXXInstanceMember(); 4829 IsVariadic = FD->isVariadic(); 4830 } 4831 CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod); 4832 break; 4833 } 4834 } 4835 4836 Attrs.setProcessingCache((unsigned) CC); 4837 return false; 4838} 4839 4840/// Pointer-like types in the default address space. 4841static bool isValidSwiftContextType(QualType Ty) { 4842 if (!Ty->hasPointerRepresentation()) 4843 return Ty->isDependentType(); 4844 return Ty->getPointeeType().getAddressSpace() == LangAS::Default; 4845} 4846 4847/// Pointers and references in the default address space. 4848static bool isValidSwiftIndirectResultType(QualType Ty) { 4849 if (const auto *PtrType = Ty->getAs<PointerType>()) { 4850 Ty = PtrType->getPointeeType(); 4851 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) { 4852 Ty = RefType->getPointeeType(); 4853 } else { 4854 return Ty->isDependentType(); 4855 } 4856 return Ty.getAddressSpace() == LangAS::Default; 4857} 4858 4859/// Pointers and references to pointers in the default address space. 4860static bool isValidSwiftErrorResultType(QualType Ty) { 4861 if (const auto *PtrType = Ty->getAs<PointerType>()) { 4862 Ty = PtrType->getPointeeType(); 4863 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) { 4864 Ty = RefType->getPointeeType(); 4865 } else { 4866 return Ty->isDependentType(); 4867 } 4868 if (!Ty.getQualifiers().empty()) 4869 return false; 4870 return isValidSwiftContextType(Ty); 4871} 4872 4873void Sema::AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, 4874 ParameterABI abi) { 4875 4876 QualType type = cast<ParmVarDecl>(D)->getType(); 4877 4878 if (auto existingAttr = D->getAttr<ParameterABIAttr>()) { 4879 if (existingAttr->getABI() != abi) { 4880 Diag(CI.getLoc(), diag::err_attributes_are_not_compatible) 4881 << getParameterABISpelling(abi) << existingAttr; 4882 Diag(existingAttr->getLocation(), diag::note_conflicting_attribute); 4883 return; 4884 } 4885 } 4886 4887 switch (abi) { 4888 case ParameterABI::Ordinary: 4889 llvm_unreachable("explicit attribute for ordinary parameter ABI?"); 4890 4891 case ParameterABI::SwiftContext: 4892 if (!isValidSwiftContextType(type)) { 4893 Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type) 4894 << getParameterABISpelling(abi) << /*pointer to pointer */ 0 << type; 4895 } 4896 D->addAttr(::new (Context) SwiftContextAttr(Context, CI)); 4897 return; 4898 4899 case ParameterABI::SwiftErrorResult: 4900 if (!isValidSwiftErrorResultType(type)) { 4901 Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type) 4902 << getParameterABISpelling(abi) << /*pointer to pointer */ 1 << type; 4903 } 4904 D->addAttr(::new (Context) SwiftErrorResultAttr(Context, CI)); 4905 return; 4906 4907 case ParameterABI::SwiftIndirectResult: 4908 if (!isValidSwiftIndirectResultType(type)) { 4909 Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type) 4910 << getParameterABISpelling(abi) << /*pointer*/ 0 << type; 4911 } 4912 D->addAttr(::new (Context) SwiftIndirectResultAttr(Context, CI)); 4913 return; 4914 } 4915 llvm_unreachable("bad parameter ABI attribute"); 4916} 4917 4918/// Checks a regparm attribute, returning true if it is ill-formed and 4919/// otherwise setting numParams to the appropriate value. 4920bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) { 4921 if (AL.isInvalid()) 4922 return true; 4923 4924 if (!AL.checkExactlyNumArgs(*this, 1)) { 4925 AL.setInvalid(); 4926 return true; 4927 } 4928 4929 uint32_t NP; 4930 Expr *NumParamsExpr = AL.getArgAsExpr(0); 4931 if (!checkUInt32Argument(*this, AL, NumParamsExpr, NP)) { 4932 AL.setInvalid(); 4933 return true; 4934 } 4935 4936 if (Context.getTargetInfo().getRegParmMax() == 0) { 4937 Diag(AL.getLoc(), diag::err_attribute_regparm_wrong_platform) 4938 << NumParamsExpr->getSourceRange(); 4939 AL.setInvalid(); 4940 return true; 4941 } 4942 4943 numParams = NP; 4944 if (numParams > Context.getTargetInfo().getRegParmMax()) { 4945 Diag(AL.getLoc(), diag::err_attribute_regparm_invalid_number) 4946 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange(); 4947 AL.setInvalid(); 4948 return true; 4949 } 4950 4951 return false; 4952} 4953 4954// Checks whether an argument of launch_bounds attribute is 4955// acceptable, performs implicit conversion to Rvalue, and returns 4956// non-nullptr Expr result on success. Otherwise, it returns nullptr 4957// and may output an error. 4958static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E, 4959 const CUDALaunchBoundsAttr &AL, 4960 const unsigned Idx) { 4961 if (S.DiagnoseUnexpandedParameterPack(E)) 4962 return nullptr; 4963 4964 // Accept template arguments for now as they depend on something else. 4965 // We'll get to check them when they eventually get instantiated. 4966 if (E->isValueDependent()) 4967 return E; 4968 4969 Optional<llvm::APSInt> I = llvm::APSInt(64); 4970 if (!(I = E->getIntegerConstantExpr(S.Context))) { 4971 S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type) 4972 << &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange(); 4973 return nullptr; 4974 } 4975 // Make sure we can fit it in 32 bits. 4976 if (!I->isIntN(32)) { 4977 S.Diag(E->getExprLoc(), diag::err_ice_too_large) 4978 << I->toString(10, false) << 32 << /* Unsigned */ 1; 4979 return nullptr; 4980 } 4981 if (*I < 0) 4982 S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative) 4983 << &AL << Idx << E->getSourceRange(); 4984 4985 // We may need to perform implicit conversion of the argument. 4986 InitializedEntity Entity = InitializedEntity::InitializeParameter( 4987 S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false); 4988 ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E); 4989 assert(!ValArg.isInvalid() && 4990 "Unexpected PerformCopyInitialization() failure."); 4991 4992 return ValArg.getAs<Expr>(); 4993} 4994 4995void Sema::AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI, 4996 Expr *MaxThreads, Expr *MinBlocks) { 4997 CUDALaunchBoundsAttr TmpAttr(Context, CI, MaxThreads, MinBlocks); 4998 MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0); 4999 if (MaxThreads == nullptr) 5000 return; 5001 5002 if (MinBlocks) { 5003 MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1); 5004 if (MinBlocks == nullptr) 5005 return; 5006 } 5007 5008 D->addAttr(::new (Context) 5009 CUDALaunchBoundsAttr(Context, CI, MaxThreads, MinBlocks)); 5010} 5011 5012static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5013 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 2)) 5014 return; 5015 5016 S.AddLaunchBoundsAttr(D, AL, AL.getArgAsExpr(0), 5017 AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr); 5018} 5019 5020static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D, 5021 const ParsedAttr &AL) { 5022 if (!AL.isArgIdent(0)) { 5023 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 5024 << AL << /* arg num = */ 1 << AANT_ArgumentIdentifier; 5025 return; 5026 } 5027 5028 ParamIdx ArgumentIdx; 5029 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, AL.getArgAsExpr(1), 5030 ArgumentIdx)) 5031 return; 5032 5033 ParamIdx TypeTagIdx; 5034 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 3, AL.getArgAsExpr(2), 5035 TypeTagIdx)) 5036 return; 5037 5038 bool IsPointer = AL.getAttrName()->getName() == "pointer_with_type_tag"; 5039 if (IsPointer) { 5040 // Ensure that buffer has a pointer type. 5041 unsigned ArgumentIdxAST = ArgumentIdx.getASTIndex(); 5042 if (ArgumentIdxAST >= getFunctionOrMethodNumParams(D) || 5043 !getFunctionOrMethodParamType(D, ArgumentIdxAST)->isPointerType()) 5044 S.Diag(AL.getLoc(), diag::err_attribute_pointers_only) << AL << 0; 5045 } 5046 5047 D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr( 5048 S.Context, AL, AL.getArgAsIdent(0)->Ident, ArgumentIdx, TypeTagIdx, 5049 IsPointer)); 5050} 5051 5052static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D, 5053 const ParsedAttr &AL) { 5054 if (!AL.isArgIdent(0)) { 5055 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 5056 << AL << 1 << AANT_ArgumentIdentifier; 5057 return; 5058 } 5059 5060 if (!AL.checkExactlyNumArgs(S, 1)) 5061 return; 5062 5063 if (!isa<VarDecl>(D)) { 5064 S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type) 5065 << AL << ExpectedVariable; 5066 return; 5067 } 5068 5069 IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident; 5070 TypeSourceInfo *MatchingCTypeLoc = nullptr; 5071 S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc); 5072 assert(MatchingCTypeLoc && "no type source info for attribute argument"); 5073 5074 D->addAttr(::new (S.Context) TypeTagForDatatypeAttr( 5075 S.Context, AL, PointerKind, MatchingCTypeLoc, AL.getLayoutCompatible(), 5076 AL.getMustBeNull())); 5077} 5078 5079static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5080 ParamIdx ArgCount; 5081 5082 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0), 5083 ArgCount, 5084 true /* CanIndexImplicitThis */)) 5085 return; 5086 5087 // ArgCount isn't a parameter index [0;n), it's a count [1;n] 5088 D->addAttr(::new (S.Context) 5089 XRayLogArgsAttr(S.Context, AL, ArgCount.getSourceIndex())); 5090} 5091 5092static void handlePatchableFunctionEntryAttr(Sema &S, Decl *D, 5093 const ParsedAttr &AL) { 5094 uint32_t Count = 0, Offset = 0; 5095 if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Count, 0, true)) 5096 return; 5097 if (AL.getNumArgs() == 2) { 5098 Expr *Arg = AL.getArgAsExpr(1); 5099 if (!checkUInt32Argument(S, AL, Arg, Offset, 1, true)) 5100 return; 5101 if (Count < Offset) { 5102 S.Diag(getAttrLoc(AL), diag::err_attribute_argument_out_of_range) 5103 << &AL << 0 << Count << Arg->getBeginLoc(); 5104 return; 5105 } 5106 } 5107 D->addAttr(::new (S.Context) 5108 PatchableFunctionEntryAttr(S.Context, AL, Count, Offset)); 5109} 5110 5111namespace { 5112struct IntrinToName { 5113 uint32_t Id; 5114 int32_t FullName; 5115 int32_t ShortName; 5116}; 5117} // unnamed namespace 5118 5119static bool ArmBuiltinAliasValid(unsigned BuiltinID, StringRef AliasName, 5120 ArrayRef<IntrinToName> Map, 5121 const char *IntrinNames) { 5122 if (AliasName.startswith("__arm_")) 5123 AliasName = AliasName.substr(6); 5124 const IntrinToName *It = std::lower_bound( 5125 Map.begin(), Map.end(), BuiltinID, 5126 [](const IntrinToName &L, unsigned Id) { return L.Id < Id; }); 5127 if (It == Map.end() || It->Id != BuiltinID) 5128 return false; 5129 StringRef FullName(&IntrinNames[It->FullName]); 5130 if (AliasName == FullName) 5131 return true; 5132 if (It->ShortName == -1) 5133 return false; 5134 StringRef ShortName(&IntrinNames[It->ShortName]); 5135 return AliasName == ShortName; 5136} 5137 5138static bool ArmMveAliasValid(unsigned BuiltinID, StringRef AliasName) { 5139#include "clang/Basic/arm_mve_builtin_aliases.inc" 5140 // The included file defines: 5141 // - ArrayRef<IntrinToName> Map 5142 // - const char IntrinNames[] 5143 return ArmBuiltinAliasValid(BuiltinID, AliasName, Map, IntrinNames); 5144} 5145 5146static bool ArmCdeAliasValid(unsigned BuiltinID, StringRef AliasName) { 5147#include "clang/Basic/arm_cde_builtin_aliases.inc" 5148 return ArmBuiltinAliasValid(BuiltinID, AliasName, Map, IntrinNames); 5149} 5150 5151static bool ArmSveAliasValid(unsigned BuiltinID, StringRef AliasName) { 5152 return BuiltinID >= AArch64::FirstSVEBuiltin && 5153 BuiltinID <= AArch64::LastSVEBuiltin; 5154} 5155 5156static void handleArmBuiltinAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5157 if (!AL.isArgIdent(0)) { 5158 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 5159 << AL << 1 << AANT_ArgumentIdentifier; 5160 return; 5161 } 5162 5163 IdentifierInfo *Ident = AL.getArgAsIdent(0)->Ident; 5164 unsigned BuiltinID = Ident->getBuiltinID(); 5165 StringRef AliasName = cast<FunctionDecl>(D)->getIdentifier()->getName(); 5166 5167 bool IsAArch64 = S.Context.getTargetInfo().getTriple().isAArch64(); 5168 if ((IsAArch64 && !ArmSveAliasValid(BuiltinID, AliasName)) || 5169 (!IsAArch64 && !ArmMveAliasValid(BuiltinID, AliasName) && 5170 !ArmCdeAliasValid(BuiltinID, AliasName))) { 5171 S.Diag(AL.getLoc(), diag::err_attribute_arm_builtin_alias); 5172 return; 5173 } 5174 5175 D->addAttr(::new (S.Context) ArmBuiltinAliasAttr(S.Context, AL, Ident)); 5176} 5177 5178static bool RISCVAliasValid(unsigned BuiltinID, StringRef AliasName) { 5179 return BuiltinID >= Builtin::FirstTSBuiltin && 5180 BuiltinID < RISCV::LastTSBuiltin; 5181} 5182 5183static void handleBuiltinAliasAttr(Sema &S, Decl *D, 5184 const ParsedAttr &AL) { 5185 if (!AL.isArgIdent(0)) { 5186 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 5187 << AL << 1 << AANT_ArgumentIdentifier; 5188 return; 5189 } 5190 5191 IdentifierInfo *Ident = AL.getArgAsIdent(0)->Ident; 5192 unsigned BuiltinID = Ident->getBuiltinID(); 5193 StringRef AliasName = cast<FunctionDecl>(D)->getIdentifier()->getName(); 5194 5195 bool IsAArch64 = S.Context.getTargetInfo().getTriple().isAArch64(); 5196 bool IsARM = S.Context.getTargetInfo().getTriple().isARM(); 5197 bool IsRISCV = S.Context.getTargetInfo().getTriple().isRISCV(); 5198 if ((IsAArch64 && !ArmSveAliasValid(BuiltinID, AliasName)) || 5199 (IsARM && !ArmMveAliasValid(BuiltinID, AliasName) && 5200 !ArmCdeAliasValid(BuiltinID, AliasName)) || 5201 (IsRISCV && !RISCVAliasValid(BuiltinID, AliasName)) || 5202 (!IsAArch64 && !IsARM && !IsRISCV)) { 5203 S.Diag(AL.getLoc(), diag::err_attribute_builtin_alias) << AL; 5204 return; 5205 } 5206 5207 D->addAttr(::new (S.Context) BuiltinAliasAttr(S.Context, AL, Ident)); 5208} 5209 5210//===----------------------------------------------------------------------===// 5211// Checker-specific attribute handlers. 5212//===----------------------------------------------------------------------===// 5213static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) { 5214 return QT->isDependentType() || QT->isObjCRetainableType(); 5215} 5216 5217static bool isValidSubjectOfNSAttribute(QualType QT) { 5218 return QT->isDependentType() || QT->isObjCObjectPointerType() || 5219 QT->isObjCNSObjectType(); 5220} 5221 5222static bool isValidSubjectOfCFAttribute(QualType QT) { 5223 return QT->isDependentType() || QT->isPointerType() || 5224 isValidSubjectOfNSAttribute(QT); 5225} 5226 5227static bool isValidSubjectOfOSAttribute(QualType QT) { 5228 if (QT->isDependentType()) 5229 return true; 5230 QualType PT = QT->getPointeeType(); 5231 return !PT.isNull() && PT->getAsCXXRecordDecl() != nullptr; 5232} 5233 5234void Sema::AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI, 5235 RetainOwnershipKind K, 5236 bool IsTemplateInstantiation) { 5237 ValueDecl *VD = cast<ValueDecl>(D); 5238 switch (K) { 5239 case RetainOwnershipKind::OS: 5240 handleSimpleAttributeOrDiagnose<OSConsumedAttr>( 5241 *this, VD, CI, isValidSubjectOfOSAttribute(VD->getType()), 5242 diag::warn_ns_attribute_wrong_parameter_type, 5243 /*ExtraArgs=*/CI.getRange(), "os_consumed", /*pointers*/ 1); 5244 return; 5245 case RetainOwnershipKind::NS: 5246 handleSimpleAttributeOrDiagnose<NSConsumedAttr>( 5247 *this, VD, CI, isValidSubjectOfNSAttribute(VD->getType()), 5248 5249 // These attributes are normally just advisory, but in ARC, ns_consumed 5250 // is significant. Allow non-dependent code to contain inappropriate 5251 // attributes even in ARC, but require template instantiations to be 5252 // set up correctly. 5253 ((IsTemplateInstantiation && getLangOpts().ObjCAutoRefCount) 5254 ? diag::err_ns_attribute_wrong_parameter_type 5255 : diag::warn_ns_attribute_wrong_parameter_type), 5256 /*ExtraArgs=*/CI.getRange(), "ns_consumed", /*objc pointers*/ 0); 5257 return; 5258 case RetainOwnershipKind::CF: 5259 handleSimpleAttributeOrDiagnose<CFConsumedAttr>( 5260 *this, VD, CI, isValidSubjectOfCFAttribute(VD->getType()), 5261 diag::warn_ns_attribute_wrong_parameter_type, 5262 /*ExtraArgs=*/CI.getRange(), "cf_consumed", /*pointers*/ 1); 5263 return; 5264 } 5265} 5266 5267static Sema::RetainOwnershipKind 5268parsedAttrToRetainOwnershipKind(const ParsedAttr &AL) { 5269 switch (AL.getKind()) { 5270 case ParsedAttr::AT_CFConsumed: 5271 case ParsedAttr::AT_CFReturnsRetained: 5272 case ParsedAttr::AT_CFReturnsNotRetained: 5273 return Sema::RetainOwnershipKind::CF; 5274 case ParsedAttr::AT_OSConsumesThis: 5275 case ParsedAttr::AT_OSConsumed: 5276 case ParsedAttr::AT_OSReturnsRetained: 5277 case ParsedAttr::AT_OSReturnsNotRetained: 5278 case ParsedAttr::AT_OSReturnsRetainedOnZero: 5279 case ParsedAttr::AT_OSReturnsRetainedOnNonZero: 5280 return Sema::RetainOwnershipKind::OS; 5281 case ParsedAttr::AT_NSConsumesSelf: 5282 case ParsedAttr::AT_NSConsumed: 5283 case ParsedAttr::AT_NSReturnsRetained: 5284 case ParsedAttr::AT_NSReturnsNotRetained: 5285 case ParsedAttr::AT_NSReturnsAutoreleased: 5286 return Sema::RetainOwnershipKind::NS; 5287 default: 5288 llvm_unreachable("Wrong argument supplied"); 5289 } 5290} 5291 5292bool Sema::checkNSReturnsRetainedReturnType(SourceLocation Loc, QualType QT) { 5293 if (isValidSubjectOfNSReturnsRetainedAttribute(QT)) 5294 return false; 5295 5296 Diag(Loc, diag::warn_ns_attribute_wrong_return_type) 5297 << "'ns_returns_retained'" << 0 << 0; 5298 return true; 5299} 5300 5301/// \return whether the parameter is a pointer to OSObject pointer. 5302static bool isValidOSObjectOutParameter(const Decl *D) { 5303 const auto *PVD = dyn_cast<ParmVarDecl>(D); 5304 if (!PVD) 5305 return false; 5306 QualType QT = PVD->getType(); 5307 QualType PT = QT->getPointeeType(); 5308 return !PT.isNull() && isValidSubjectOfOSAttribute(PT); 5309} 5310 5311static void handleXReturnsXRetainedAttr(Sema &S, Decl *D, 5312 const ParsedAttr &AL) { 5313 QualType ReturnType; 5314 Sema::RetainOwnershipKind K = parsedAttrToRetainOwnershipKind(AL); 5315 5316 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) { 5317 ReturnType = MD->getReturnType(); 5318 } else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) && 5319 (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) { 5320 return; // ignore: was handled as a type attribute 5321 } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) { 5322 ReturnType = PD->getType(); 5323 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 5324 ReturnType = FD->getReturnType(); 5325 } else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) { 5326 // Attributes on parameters are used for out-parameters, 5327 // passed as pointers-to-pointers. 5328 unsigned DiagID = K == Sema::RetainOwnershipKind::CF 5329 ? /*pointer-to-CF-pointer*/2 5330 : /*pointer-to-OSObject-pointer*/3; 5331 ReturnType = Param->getType()->getPointeeType(); 5332 if (ReturnType.isNull()) { 5333 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type) 5334 << AL << DiagID << AL.getRange(); 5335 return; 5336 } 5337 } else if (AL.isUsedAsTypeAttr()) { 5338 return; 5339 } else { 5340 AttributeDeclKind ExpectedDeclKind; 5341 switch (AL.getKind()) { 5342 default: llvm_unreachable("invalid ownership attribute"); 5343 case ParsedAttr::AT_NSReturnsRetained: 5344 case ParsedAttr::AT_NSReturnsAutoreleased: 5345 case ParsedAttr::AT_NSReturnsNotRetained: 5346 ExpectedDeclKind = ExpectedFunctionOrMethod; 5347 break; 5348 5349 case ParsedAttr::AT_OSReturnsRetained: 5350 case ParsedAttr::AT_OSReturnsNotRetained: 5351 case ParsedAttr::AT_CFReturnsRetained: 5352 case ParsedAttr::AT_CFReturnsNotRetained: 5353 ExpectedDeclKind = ExpectedFunctionMethodOrParameter; 5354 break; 5355 } 5356 S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type) 5357 << AL.getRange() << AL << ExpectedDeclKind; 5358 return; 5359 } 5360 5361 bool TypeOK; 5362 bool Cf; 5363 unsigned ParmDiagID = 2; // Pointer-to-CF-pointer 5364 switch (AL.getKind()) { 5365 default: llvm_unreachable("invalid ownership attribute"); 5366 case ParsedAttr::AT_NSReturnsRetained: 5367 TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType); 5368 Cf = false; 5369 break; 5370 5371 case ParsedAttr::AT_NSReturnsAutoreleased: 5372 case ParsedAttr::AT_NSReturnsNotRetained: 5373 TypeOK = isValidSubjectOfNSAttribute(ReturnType); 5374 Cf = false; 5375 break; 5376 5377 case ParsedAttr::AT_CFReturnsRetained: 5378 case ParsedAttr::AT_CFReturnsNotRetained: 5379 TypeOK = isValidSubjectOfCFAttribute(ReturnType); 5380 Cf = true; 5381 break; 5382 5383 case ParsedAttr::AT_OSReturnsRetained: 5384 case ParsedAttr::AT_OSReturnsNotRetained: 5385 TypeOK = isValidSubjectOfOSAttribute(ReturnType); 5386 Cf = true; 5387 ParmDiagID = 3; // Pointer-to-OSObject-pointer 5388 break; 5389 } 5390 5391 if (!TypeOK) { 5392 if (AL.isUsedAsTypeAttr()) 5393 return; 5394 5395 if (isa<ParmVarDecl>(D)) { 5396 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type) 5397 << AL << ParmDiagID << AL.getRange(); 5398 } else { 5399 // Needs to be kept in sync with warn_ns_attribute_wrong_return_type. 5400 enum : unsigned { 5401 Function, 5402 Method, 5403 Property 5404 } SubjectKind = Function; 5405 if (isa<ObjCMethodDecl>(D)) 5406 SubjectKind = Method; 5407 else if (isa<ObjCPropertyDecl>(D)) 5408 SubjectKind = Property; 5409 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type) 5410 << AL << SubjectKind << Cf << AL.getRange(); 5411 } 5412 return; 5413 } 5414 5415 switch (AL.getKind()) { 5416 default: 5417 llvm_unreachable("invalid ownership attribute"); 5418 case ParsedAttr::AT_NSReturnsAutoreleased: 5419 handleSimpleAttribute<NSReturnsAutoreleasedAttr>(S, D, AL); 5420 return; 5421 case ParsedAttr::AT_CFReturnsNotRetained: 5422 handleSimpleAttribute<CFReturnsNotRetainedAttr>(S, D, AL); 5423 return; 5424 case ParsedAttr::AT_NSReturnsNotRetained: 5425 handleSimpleAttribute<NSReturnsNotRetainedAttr>(S, D, AL); 5426 return; 5427 case ParsedAttr::AT_CFReturnsRetained: 5428 handleSimpleAttribute<CFReturnsRetainedAttr>(S, D, AL); 5429 return; 5430 case ParsedAttr::AT_NSReturnsRetained: 5431 handleSimpleAttribute<NSReturnsRetainedAttr>(S, D, AL); 5432 return; 5433 case ParsedAttr::AT_OSReturnsRetained: 5434 handleSimpleAttribute<OSReturnsRetainedAttr>(S, D, AL); 5435 return; 5436 case ParsedAttr::AT_OSReturnsNotRetained: 5437 handleSimpleAttribute<OSReturnsNotRetainedAttr>(S, D, AL); 5438 return; 5439 }; 5440} 5441 5442static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D, 5443 const ParsedAttr &Attrs) { 5444 const int EP_ObjCMethod = 1; 5445 const int EP_ObjCProperty = 2; 5446 5447 SourceLocation loc = Attrs.getLoc(); 5448 QualType resultType; 5449 if (isa<ObjCMethodDecl>(D)) 5450 resultType = cast<ObjCMethodDecl>(D)->getReturnType(); 5451 else 5452 resultType = cast<ObjCPropertyDecl>(D)->getType(); 5453 5454 if (!resultType->isReferenceType() && 5455 (!resultType->isPointerType() || resultType->isObjCRetainableType())) { 5456 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type) 5457 << SourceRange(loc) << Attrs 5458 << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty) 5459 << /*non-retainable pointer*/ 2; 5460 5461 // Drop the attribute. 5462 return; 5463 } 5464 5465 D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(S.Context, Attrs)); 5466} 5467 5468static void handleObjCRequiresSuperAttr(Sema &S, Decl *D, 5469 const ParsedAttr &Attrs) { 5470 const auto *Method = cast<ObjCMethodDecl>(D); 5471 5472 const DeclContext *DC = Method->getDeclContext(); 5473 if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) { 5474 S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs 5475 << 0; 5476 S.Diag(PDecl->getLocation(), diag::note_protocol_decl); 5477 return; 5478 } 5479 if (Method->getMethodFamily() == OMF_dealloc) { 5480 S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs 5481 << 1; 5482 return; 5483 } 5484 5485 D->addAttr(::new (S.Context) ObjCRequiresSuperAttr(S.Context, Attrs)); 5486} 5487 5488static void handleNSErrorDomain(Sema &S, Decl *D, const ParsedAttr &AL) { 5489 auto *E = AL.getArgAsExpr(0); 5490 auto Loc = E ? E->getBeginLoc() : AL.getLoc(); 5491 5492 auto *DRE = dyn_cast<DeclRefExpr>(AL.getArgAsExpr(0)); 5493 if (!DRE) { 5494 S.Diag(Loc, diag::err_nserrordomain_invalid_decl) << 0; 5495 return; 5496 } 5497 5498 auto *VD = dyn_cast<VarDecl>(DRE->getDecl()); 5499 if (!VD) { 5500 S.Diag(Loc, diag::err_nserrordomain_invalid_decl) << 1 << DRE->getDecl(); 5501 return; 5502 } 5503 5504 if (!isNSStringType(VD->getType(), S.Context) && 5505 !isCFStringType(VD->getType(), S.Context)) { 5506 S.Diag(Loc, diag::err_nserrordomain_wrong_type) << VD; 5507 return; 5508 } 5509 5510 D->addAttr(::new (S.Context) NSErrorDomainAttr(S.Context, AL, VD)); 5511} 5512 5513static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5514 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr; 5515 5516 if (!Parm) { 5517 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0; 5518 return; 5519 } 5520 5521 // Typedefs only allow objc_bridge(id) and have some additional checking. 5522 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) { 5523 if (!Parm->Ident->isStr("id")) { 5524 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_id) << AL; 5525 return; 5526 } 5527 5528 // Only allow 'cv void *'. 5529 QualType T = TD->getUnderlyingType(); 5530 if (!T->isVoidPointerType()) { 5531 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_void_pointer); 5532 return; 5533 } 5534 } 5535 5536 D->addAttr(::new (S.Context) ObjCBridgeAttr(S.Context, AL, Parm->Ident)); 5537} 5538 5539static void handleObjCBridgeMutableAttr(Sema &S, Decl *D, 5540 const ParsedAttr &AL) { 5541 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr; 5542 5543 if (!Parm) { 5544 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0; 5545 return; 5546 } 5547 5548 D->addAttr(::new (S.Context) 5549 ObjCBridgeMutableAttr(S.Context, AL, Parm->Ident)); 5550} 5551 5552static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D, 5553 const ParsedAttr &AL) { 5554 IdentifierInfo *RelatedClass = 5555 AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr; 5556 if (!RelatedClass) { 5557 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0; 5558 return; 5559 } 5560 IdentifierInfo *ClassMethod = 5561 AL.getArgAsIdent(1) ? AL.getArgAsIdent(1)->Ident : nullptr; 5562 IdentifierInfo *InstanceMethod = 5563 AL.getArgAsIdent(2) ? AL.getArgAsIdent(2)->Ident : nullptr; 5564 D->addAttr(::new (S.Context) ObjCBridgeRelatedAttr( 5565 S.Context, AL, RelatedClass, ClassMethod, InstanceMethod)); 5566} 5567 5568static void handleObjCDesignatedInitializer(Sema &S, Decl *D, 5569 const ParsedAttr &AL) { 5570 DeclContext *Ctx = D->getDeclContext(); 5571 5572 // This attribute can only be applied to methods in interfaces or class 5573 // extensions. 5574 if (!isa<ObjCInterfaceDecl>(Ctx) && 5575 !(isa<ObjCCategoryDecl>(Ctx) && 5576 cast<ObjCCategoryDecl>(Ctx)->IsClassExtension())) { 5577 S.Diag(D->getLocation(), diag::err_designated_init_attr_non_init); 5578 return; 5579 } 5580 5581 ObjCInterfaceDecl *IFace; 5582 if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(Ctx)) 5583 IFace = CatDecl->getClassInterface(); 5584 else 5585 IFace = cast<ObjCInterfaceDecl>(Ctx); 5586 5587 if (!IFace) 5588 return; 5589 5590 IFace->setHasDesignatedInitializers(); 5591 D->addAttr(::new (S.Context) ObjCDesignatedInitializerAttr(S.Context, AL)); 5592} 5593 5594static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) { 5595 StringRef MetaDataName; 5596 if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName)) 5597 return; 5598 D->addAttr(::new (S.Context) 5599 ObjCRuntimeNameAttr(S.Context, AL, MetaDataName)); 5600} 5601 5602// When a user wants to use objc_boxable with a union or struct 5603// but they don't have access to the declaration (legacy/third-party code) 5604// then they can 'enable' this feature with a typedef: 5605// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct; 5606static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) { 5607 bool notify = false; 5608 5609 auto *RD = dyn_cast<RecordDecl>(D); 5610 if (RD && RD->getDefinition()) { 5611 RD = RD->getDefinition(); 5612 notify = true; 5613 } 5614 5615 if (RD) { 5616 ObjCBoxableAttr *BoxableAttr = 5617 ::new (S.Context) ObjCBoxableAttr(S.Context, AL); 5618 RD->addAttr(BoxableAttr); 5619 if (notify) { 5620 // we need to notify ASTReader/ASTWriter about 5621 // modification of existing declaration 5622 if (ASTMutationListener *L = S.getASTMutationListener()) 5623 L->AddedAttributeToRecord(BoxableAttr, RD); 5624 } 5625 } 5626} 5627 5628static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5629 if (hasDeclarator(D)) return; 5630 5631 S.Diag(D->getBeginLoc(), diag::err_attribute_wrong_decl_type) 5632 << AL.getRange() << AL << ExpectedVariable; 5633} 5634 5635static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D, 5636 const ParsedAttr &AL) { 5637 const auto *VD = cast<ValueDecl>(D); 5638 QualType QT = VD->getType(); 5639 5640 if (!QT->isDependentType() && 5641 !QT->isObjCLifetimeType()) { 5642 S.Diag(AL.getLoc(), diag::err_objc_precise_lifetime_bad_type) 5643 << QT; 5644 return; 5645 } 5646 5647 Qualifiers::ObjCLifetime Lifetime = QT.getObjCLifetime(); 5648 5649 // If we have no lifetime yet, check the lifetime we're presumably 5650 // going to infer. 5651 if (Lifetime == Qualifiers::OCL_None && !QT->isDependentType()) 5652 Lifetime = QT->getObjCARCImplicitLifetime(); 5653 5654 switch (Lifetime) { 5655 case Qualifiers::OCL_None: 5656 assert(QT->isDependentType() && 5657 "didn't infer lifetime for non-dependent type?"); 5658 break; 5659 5660 case Qualifiers::OCL_Weak: // meaningful 5661 case Qualifiers::OCL_Strong: // meaningful 5662 break; 5663 5664 case Qualifiers::OCL_ExplicitNone: 5665 case Qualifiers::OCL_Autoreleasing: 5666 S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless) 5667 << (Lifetime == Qualifiers::OCL_Autoreleasing); 5668 break; 5669 } 5670 5671 D->addAttr(::new (S.Context) ObjCPreciseLifetimeAttr(S.Context, AL)); 5672} 5673 5674static void handleSwiftAttrAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 5675 // Make sure that there is a string literal as the annotation's single 5676 // argument. 5677 StringRef Str; 5678 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str)) 5679 return; 5680 5681 D->addAttr(::new (S.Context) SwiftAttrAttr(S.Context, AL, Str)); 5682} 5683 5684static void handleSwiftBridge(Sema &S, Decl *D, const ParsedAttr &AL) { 5685 // Make sure that there is a string literal as the annotation's single 5686 // argument. 5687 StringRef BT; 5688 if (!S.checkStringLiteralArgumentAttr(AL, 0, BT)) 5689 return; 5690 5691 // Warn about duplicate attributes if they have different arguments, but drop 5692 // any duplicate attributes regardless. 5693 if (const auto *Other = D->getAttr<SwiftBridgeAttr>()) { 5694 if (Other->getSwiftType() != BT) 5695 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL; 5696 return; 5697 } 5698 5699 D->addAttr(::new (S.Context) SwiftBridgeAttr(S.Context, AL, BT)); 5700} 5701 5702static bool isErrorParameter(Sema &S, QualType QT) { 5703 const auto *PT = QT->getAs<PointerType>(); 5704 if (!PT) 5705 return false; 5706 5707 QualType Pointee = PT->getPointeeType(); 5708 5709 // Check for NSError**. 5710 if (const auto *OPT = Pointee->getAs<ObjCObjectPointerType>()) 5711 if (const auto *ID = OPT->getInterfaceDecl()) 5712 if (ID->getIdentifier() == S.getNSErrorIdent()) 5713 return true; 5714 5715 // Check for CFError**. 5716 if (const auto *PT = Pointee->getAs<PointerType>()) 5717 if (const auto *RT = PT->getPointeeType()->getAs<RecordType>()) 5718 if (S.isCFError(RT->getDecl())) 5719 return true; 5720 5721 return false; 5722} 5723 5724static void handleSwiftError(Sema &S, Decl *D, const ParsedAttr &AL) { 5725 auto hasErrorParameter = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool { 5726 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D); I != E; ++I) { 5727 if (isErrorParameter(S, getFunctionOrMethodParamType(D, I))) 5728 return true; 5729 } 5730 5731 S.Diag(AL.getLoc(), diag::err_attr_swift_error_no_error_parameter) 5732 << AL << isa<ObjCMethodDecl>(D); 5733 return false; 5734 }; 5735 5736 auto hasPointerResult = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool { 5737 // - C, ObjC, and block pointers are definitely okay. 5738 // - References are definitely not okay. 5739 // - nullptr_t is weird, but acceptable. 5740 QualType RT = getFunctionOrMethodResultType(D); 5741 if (RT->hasPointerRepresentation() && !RT->isReferenceType()) 5742 return true; 5743 5744 S.Diag(AL.getLoc(), diag::err_attr_swift_error_return_type) 5745 << AL << AL.getArgAsIdent(0)->Ident->getName() << isa<ObjCMethodDecl>(D) 5746 << /*pointer*/ 1; 5747 return false; 5748 }; 5749 5750 auto hasIntegerResult = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool { 5751 QualType RT = getFunctionOrMethodResultType(D); 5752 if (RT->isIntegralType(S.Context)) 5753 return true; 5754 5755 S.Diag(AL.getLoc(), diag::err_attr_swift_error_return_type) 5756 << AL << AL.getArgAsIdent(0)->Ident->getName() << isa<ObjCMethodDecl>(D) 5757 << /*integral*/ 0; 5758 return false; 5759 }; 5760 5761 if (D->isInvalidDecl()) 5762 return; 5763 5764 IdentifierLoc *Loc = AL.getArgAsIdent(0); 5765 SwiftErrorAttr::ConventionKind Convention; 5766 if (!SwiftErrorAttr::ConvertStrToConventionKind(Loc->Ident->getName(), 5767 Convention)) { 5768 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) 5769 << AL << Loc->Ident; 5770 return; 5771 } 5772 5773 switch (Convention) { 5774 case SwiftErrorAttr::None: 5775 // No additional validation required. 5776 break; 5777 5778 case SwiftErrorAttr::NonNullError: 5779 if (!hasErrorParameter(S, D, AL)) 5780 return; 5781 break; 5782 5783 case SwiftErrorAttr::NullResult: 5784 if (!hasErrorParameter(S, D, AL) || !hasPointerResult(S, D, AL)) 5785 return; 5786 break; 5787 5788 case SwiftErrorAttr::NonZeroResult: 5789 case SwiftErrorAttr::ZeroResult: 5790 if (!hasErrorParameter(S, D, AL) || !hasIntegerResult(S, D, AL)) 5791 return; 5792 break; 5793 } 5794 5795 D->addAttr(::new (S.Context) SwiftErrorAttr(S.Context, AL, Convention)); 5796} 5797 5798static void checkSwiftAsyncErrorBlock(Sema &S, Decl *D, 5799 const SwiftAsyncErrorAttr *ErrorAttr, 5800 const SwiftAsyncAttr *AsyncAttr) { 5801 if (AsyncAttr->getKind() == SwiftAsyncAttr::None) { 5802 if (ErrorAttr->getConvention() != SwiftAsyncErrorAttr::None) { 5803 S.Diag(AsyncAttr->getLocation(), 5804 diag::err_swift_async_error_without_swift_async) 5805 << AsyncAttr << isa<ObjCMethodDecl>(D); 5806 } 5807 return; 5808 } 5809 5810 const ParmVarDecl *HandlerParam = getFunctionOrMethodParam( 5811 D, AsyncAttr->getCompletionHandlerIndex().getASTIndex()); 5812 // handleSwiftAsyncAttr already verified the type is correct, so no need to 5813 // double-check it here. 5814 const auto *FuncTy = HandlerParam->getType() 5815 ->castAs<BlockPointerType>() 5816 ->getPointeeType() 5817 ->getAs<FunctionProtoType>(); 5818 ArrayRef<QualType> BlockParams; 5819 if (FuncTy) 5820 BlockParams = FuncTy->getParamTypes(); 5821 5822 switch (ErrorAttr->getConvention()) { 5823 case SwiftAsyncErrorAttr::ZeroArgument: 5824 case SwiftAsyncErrorAttr::NonZeroArgument: { 5825 uint32_t ParamIdx = ErrorAttr->getHandlerParamIdx(); 5826 if (ParamIdx == 0 || ParamIdx > BlockParams.size()) { 5827 S.Diag(ErrorAttr->getLocation(), 5828 diag::err_attribute_argument_out_of_bounds) << ErrorAttr << 2; 5829 return; 5830 } 5831 QualType ErrorParam = BlockParams[ParamIdx - 1]; 5832 if (!ErrorParam->isIntegralType(S.Context)) { 5833 StringRef ConvStr = 5834 ErrorAttr->getConvention() == SwiftAsyncErrorAttr::ZeroArgument 5835 ? "zero_argument" 5836 : "nonzero_argument"; 5837 S.Diag(ErrorAttr->getLocation(), diag::err_swift_async_error_non_integral) 5838 << ErrorAttr << ConvStr << ParamIdx << ErrorParam; 5839 return; 5840 } 5841 break; 5842 } 5843 case SwiftAsyncErrorAttr::NonNullError: { 5844 bool AnyErrorParams = false; 5845 for (QualType Param : BlockParams) { 5846 // Check for NSError *. 5847 if (const auto *ObjCPtrTy = Param->getAs<ObjCObjectPointerType>()) { 5848 if (const auto *ID = ObjCPtrTy->getInterfaceDecl()) { 5849 if (ID->getIdentifier() == S.getNSErrorIdent()) { 5850 AnyErrorParams = true; 5851 break; 5852 } 5853 } 5854 } 5855 // Check for CFError *. 5856 if (const auto *PtrTy = Param->getAs<PointerType>()) { 5857 if (const auto *RT = PtrTy->getPointeeType()->getAs<RecordType>()) { 5858 if (S.isCFError(RT->getDecl())) { 5859 AnyErrorParams = true; 5860 break; 5861 } 5862 } 5863 } 5864 } 5865 5866 if (!AnyErrorParams) { 5867 S.Diag(ErrorAttr->getLocation(), 5868 diag::err_swift_async_error_no_error_parameter) 5869 << ErrorAttr << isa<ObjCMethodDecl>(D); 5870 return; 5871 } 5872 break; 5873 } 5874 case SwiftAsyncErrorAttr::None: 5875 break; 5876 } 5877} 5878 5879static void handleSwiftAsyncError(Sema &S, Decl *D, const ParsedAttr &AL) { 5880 IdentifierLoc *IDLoc = AL.getArgAsIdent(0); 5881 SwiftAsyncErrorAttr::ConventionKind ConvKind; 5882 if (!SwiftAsyncErrorAttr::ConvertStrToConventionKind(IDLoc->Ident->getName(), 5883 ConvKind)) { 5884 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) 5885 << AL << IDLoc->Ident; 5886 return; 5887 } 5888 5889 uint32_t ParamIdx = 0; 5890 switch (ConvKind) { 5891 case SwiftAsyncErrorAttr::ZeroArgument: 5892 case SwiftAsyncErrorAttr::NonZeroArgument: { 5893 if (!AL.checkExactlyNumArgs(S, 2)) 5894 return; 5895 5896 Expr *IdxExpr = AL.getArgAsExpr(1); 5897 if (!checkUInt32Argument(S, AL, IdxExpr, ParamIdx)) 5898 return; 5899 break; 5900 } 5901 case SwiftAsyncErrorAttr::NonNullError: 5902 case SwiftAsyncErrorAttr::None: { 5903 if (!AL.checkExactlyNumArgs(S, 1)) 5904 return; 5905 break; 5906 } 5907 } 5908 5909 auto *ErrorAttr = 5910 ::new (S.Context) SwiftAsyncErrorAttr(S.Context, AL, ConvKind, ParamIdx); 5911 D->addAttr(ErrorAttr); 5912 5913 if (auto *AsyncAttr = D->getAttr<SwiftAsyncAttr>()) 5914 checkSwiftAsyncErrorBlock(S, D, ErrorAttr, AsyncAttr); 5915} 5916 5917// For a function, this will validate a compound Swift name, e.g. 5918// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and 5919// the function will output the number of parameter names, and whether this is a 5920// single-arg initializer. 5921// 5922// For a type, enum constant, property, or variable declaration, this will 5923// validate either a simple identifier, or a qualified 5924// <code>context.identifier</code> name. 5925static bool 5926validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, 5927 StringRef Name, unsigned &SwiftParamCount, 5928 bool &IsSingleParamInit) { 5929 SwiftParamCount = 0; 5930 IsSingleParamInit = false; 5931 5932 // Check whether this will be mapped to a getter or setter of a property. 5933 bool IsGetter = false, IsSetter = false; 5934 if (Name.startswith("getter:")) { 5935 IsGetter = true; 5936 Name = Name.substr(7); 5937 } else if (Name.startswith("setter:")) { 5938 IsSetter = true; 5939 Name = Name.substr(7); 5940 } 5941 5942 if (Name.back() != ')') { 5943 S.Diag(Loc, diag::warn_attr_swift_name_function) << AL; 5944 return false; 5945 } 5946 5947 bool IsMember = false; 5948 StringRef ContextName, BaseName, Parameters; 5949 5950 std::tie(BaseName, Parameters) = Name.split('('); 5951 5952 // Split at the first '.', if it exists, which separates the context name 5953 // from the base name. 5954 std::tie(ContextName, BaseName) = BaseName.split('.'); 5955 if (BaseName.empty()) { 5956 BaseName = ContextName; 5957 ContextName = StringRef(); 5958 } else if (ContextName.empty() || !isValidIdentifier(ContextName)) { 5959 S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) 5960 << AL << /*context*/ 1; 5961 return false; 5962 } else { 5963 IsMember = true; 5964 } 5965 5966 if (!isValidIdentifier(BaseName) || BaseName == "_") { 5967 S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) 5968 << AL << /*basename*/ 0; 5969 return false; 5970 } 5971 5972 bool IsSubscript = BaseName == "subscript"; 5973 // A subscript accessor must be a getter or setter. 5974 if (IsSubscript && !IsGetter && !IsSetter) { 5975 S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) 5976 << AL << /* getter or setter */ 0; 5977 return false; 5978 } 5979 5980 if (Parameters.empty()) { 5981 S.Diag(Loc, diag::warn_attr_swift_name_missing_parameters) << AL; 5982 return false; 5983 } 5984 5985 assert(Parameters.back() == ')' && "expected ')'"); 5986 Parameters = Parameters.drop_back(); // ')' 5987 5988 if (Parameters.empty()) { 5989 // Setters and subscripts must have at least one parameter. 5990 if (IsSubscript) { 5991 S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) 5992 << AL << /* have at least one parameter */1; 5993 return false; 5994 } 5995 5996 if (IsSetter) { 5997 S.Diag(Loc, diag::warn_attr_swift_name_setter_parameters) << AL; 5998 return false; 5999 } 6000 6001 return true; 6002 } 6003 6004 if (Parameters.back() != ':') { 6005 S.Diag(Loc, diag::warn_attr_swift_name_function) << AL; 6006 return false; 6007 } 6008 6009 StringRef CurrentParam; 6010 llvm::Optional<unsigned> SelfLocation; 6011 unsigned NewValueCount = 0; 6012 llvm::Optional<unsigned> NewValueLocation; 6013 do { 6014 std::tie(CurrentParam, Parameters) = Parameters.split(':'); 6015 6016 if (!isValidIdentifier(CurrentParam)) { 6017 S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) 6018 << AL << /*parameter*/2; 6019 return false; 6020 } 6021 6022 if (IsMember && CurrentParam == "self") { 6023 // "self" indicates the "self" argument for a member. 6024 6025 // More than one "self"? 6026 if (SelfLocation) { 6027 S.Diag(Loc, diag::warn_attr_swift_name_multiple_selfs) << AL; 6028 return false; 6029 } 6030 6031 // The "self" location is the current parameter. 6032 SelfLocation = SwiftParamCount; 6033 } else if (CurrentParam == "newValue") { 6034 // "newValue" indicates the "newValue" argument for a setter. 6035 6036 // There should only be one 'newValue', but it's only significant for 6037 // subscript accessors, so don't error right away. 6038 ++NewValueCount; 6039 6040 NewValueLocation = SwiftParamCount; 6041 } 6042 6043 ++SwiftParamCount; 6044 } while (!Parameters.empty()); 6045 6046 // Only instance subscripts are currently supported. 6047 if (IsSubscript && !SelfLocation) { 6048 S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) 6049 << AL << /*have a 'self:' parameter*/2; 6050 return false; 6051 } 6052 6053 IsSingleParamInit = 6054 SwiftParamCount == 1 && BaseName == "init" && CurrentParam != "_"; 6055 6056 // Check the number of parameters for a getter/setter. 6057 if (IsGetter || IsSetter) { 6058 // Setters have one parameter for the new value. 6059 unsigned NumExpectedParams = IsGetter ? 0 : 1; 6060 unsigned ParamDiag = 6061 IsGetter ? diag::warn_attr_swift_name_getter_parameters 6062 : diag::warn_attr_swift_name_setter_parameters; 6063 6064 // Instance methods have one parameter for "self". 6065 if (SelfLocation) 6066 ++NumExpectedParams; 6067 6068 // Subscripts may have additional parameters beyond the expected params for 6069 // the index. 6070 if (IsSubscript) { 6071 if (SwiftParamCount < NumExpectedParams) { 6072 S.Diag(Loc, ParamDiag) << AL; 6073 return false; 6074 } 6075 6076 // A subscript setter must explicitly label its newValue parameter to 6077 // distinguish it from index parameters. 6078 if (IsSetter) { 6079 if (!NewValueLocation) { 6080 S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_no_newValue) 6081 << AL; 6082 return false; 6083 } 6084 if (NewValueCount > 1) { 6085 S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_multiple_newValues) 6086 << AL; 6087 return false; 6088 } 6089 } else { 6090 // Subscript getters should have no 'newValue:' parameter. 6091 if (NewValueLocation) { 6092 S.Diag(Loc, diag::warn_attr_swift_name_subscript_getter_newValue) 6093 << AL; 6094 return false; 6095 } 6096 } 6097 } else { 6098 // Property accessors must have exactly the number of expected params. 6099 if (SwiftParamCount != NumExpectedParams) { 6100 S.Diag(Loc, ParamDiag) << AL; 6101 return false; 6102 } 6103 } 6104 } 6105 6106 return true; 6107} 6108 6109bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, 6110 const ParsedAttr &AL, bool IsAsync) { 6111 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) { 6112 ArrayRef<ParmVarDecl*> Params; 6113 unsigned ParamCount; 6114 6115 if (const auto *Method = dyn_cast<ObjCMethodDecl>(D)) { 6116 ParamCount = Method->getSelector().getNumArgs(); 6117 Params = Method->parameters().slice(0, ParamCount); 6118 } else { 6119 const auto *F = cast<FunctionDecl>(D); 6120 6121 ParamCount = F->getNumParams(); 6122 Params = F->parameters(); 6123 6124 if (!F->hasWrittenPrototype()) { 6125 Diag(Loc, diag::warn_attribute_wrong_decl_type) << AL 6126 << ExpectedFunctionWithProtoType; 6127 return false; 6128 } 6129 } 6130 6131 // The async name drops the last callback parameter. 6132 if (IsAsync) { 6133 if (ParamCount == 0) { 6134 Diag(Loc, diag::warn_attr_swift_name_decl_missing_params) 6135 << AL << isa<ObjCMethodDecl>(D); 6136 return false; 6137 } 6138 ParamCount -= 1; 6139 } 6140 6141 unsigned SwiftParamCount; 6142 bool IsSingleParamInit; 6143 if (!validateSwiftFunctionName(*this, AL, Loc, Name, 6144 SwiftParamCount, IsSingleParamInit)) 6145 return false; 6146 6147 bool ParamCountValid; 6148 if (SwiftParamCount == ParamCount) { 6149 ParamCountValid = true; 6150 } else if (SwiftParamCount > ParamCount) { 6151 ParamCountValid = IsSingleParamInit && ParamCount == 0; 6152 } else { 6153 // We have fewer Swift parameters than Objective-C parameters, but that 6154 // might be because we've transformed some of them. Check for potential 6155 // "out" parameters and err on the side of not warning. 6156 unsigned MaybeOutParamCount = 6157 std::count_if(Params.begin(), Params.end(), 6158 [](const ParmVarDecl *Param) -> bool { 6159 QualType ParamTy = Param->getType(); 6160 if (ParamTy->isReferenceType() || ParamTy->isPointerType()) 6161 return !ParamTy->getPointeeType().isConstQualified(); 6162 return false; 6163 }); 6164 6165 ParamCountValid = SwiftParamCount + MaybeOutParamCount >= ParamCount; 6166 } 6167 6168 if (!ParamCountValid) { 6169 Diag(Loc, diag::warn_attr_swift_name_num_params) 6170 << (SwiftParamCount > ParamCount) << AL << ParamCount 6171 << SwiftParamCount; 6172 return false; 6173 } 6174 } else if ((isa<EnumConstantDecl>(D) || isa<ObjCProtocolDecl>(D) || 6175 isa<ObjCInterfaceDecl>(D) || isa<ObjCPropertyDecl>(D) || 6176 isa<VarDecl>(D) || isa<TypedefNameDecl>(D) || isa<TagDecl>(D) || 6177 isa<IndirectFieldDecl>(D) || isa<FieldDecl>(D)) && 6178 !IsAsync) { 6179 StringRef ContextName, BaseName; 6180 6181 std::tie(ContextName, BaseName) = Name.split('.'); 6182 if (BaseName.empty()) { 6183 BaseName = ContextName; 6184 ContextName = StringRef(); 6185 } else if (!isValidIdentifier(ContextName)) { 6186 Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL 6187 << /*context*/1; 6188 return false; 6189 } 6190 6191 if (!isValidIdentifier(BaseName)) { 6192 Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL 6193 << /*basename*/0; 6194 return false; 6195 } 6196 } else { 6197 Diag(Loc, diag::warn_attr_swift_name_decl_kind) << AL; 6198 return false; 6199 } 6200 return true; 6201} 6202 6203static void handleSwiftName(Sema &S, Decl *D, const ParsedAttr &AL) { 6204 StringRef Name; 6205 SourceLocation Loc; 6206 if (!S.checkStringLiteralArgumentAttr(AL, 0, Name, &Loc)) 6207 return; 6208 6209 if (!S.DiagnoseSwiftName(D, Name, Loc, AL, /*IsAsync=*/false)) 6210 return; 6211 6212 D->addAttr(::new (S.Context) SwiftNameAttr(S.Context, AL, Name)); 6213} 6214 6215static void handleSwiftAsyncName(Sema &S, Decl *D, const ParsedAttr &AL) { 6216 StringRef Name; 6217 SourceLocation Loc; 6218 if (!S.checkStringLiteralArgumentAttr(AL, 0, Name, &Loc)) 6219 return; 6220 6221 if (!S.DiagnoseSwiftName(D, Name, Loc, AL, /*IsAsync=*/true)) 6222 return; 6223 6224 D->addAttr(::new (S.Context) SwiftAsyncNameAttr(S.Context, AL, Name)); 6225} 6226 6227static void handleSwiftNewType(Sema &S, Decl *D, const ParsedAttr &AL) { 6228 // Make sure that there is an identifier as the annotation's single argument. 6229 if (!AL.checkExactlyNumArgs(S, 1)) 6230 return; 6231 6232 if (!AL.isArgIdent(0)) { 6233 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 6234 << AL << AANT_ArgumentIdentifier; 6235 return; 6236 } 6237 6238 SwiftNewTypeAttr::NewtypeKind Kind; 6239 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 6240 if (!SwiftNewTypeAttr::ConvertStrToNewtypeKind(II->getName(), Kind)) { 6241 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II; 6242 return; 6243 } 6244 6245 if (!isa<TypedefNameDecl>(D)) { 6246 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str) 6247 << AL << "typedefs"; 6248 return; 6249 } 6250 6251 D->addAttr(::new (S.Context) SwiftNewTypeAttr(S.Context, AL, Kind)); 6252} 6253 6254static void handleSwiftAsyncAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6255 if (!AL.isArgIdent(0)) { 6256 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type) 6257 << AL << 1 << AANT_ArgumentIdentifier; 6258 return; 6259 } 6260 6261 SwiftAsyncAttr::Kind Kind; 6262 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 6263 if (!SwiftAsyncAttr::ConvertStrToKind(II->getName(), Kind)) { 6264 S.Diag(AL.getLoc(), diag::err_swift_async_no_access) << AL << II; 6265 return; 6266 } 6267 6268 ParamIdx Idx; 6269 if (Kind == SwiftAsyncAttr::None) { 6270 // If this is 'none', then there shouldn't be any additional arguments. 6271 if (!AL.checkExactlyNumArgs(S, 1)) 6272 return; 6273 } else { 6274 // Non-none swift_async requires a completion handler index argument. 6275 if (!AL.checkExactlyNumArgs(S, 2)) 6276 return; 6277 6278 Expr *HandlerIdx = AL.getArgAsExpr(1); 6279 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, HandlerIdx, Idx)) 6280 return; 6281 6282 const ParmVarDecl *CompletionBlock = 6283 getFunctionOrMethodParam(D, Idx.getASTIndex()); 6284 QualType CompletionBlockType = CompletionBlock->getType(); 6285 if (!CompletionBlockType->isBlockPointerType()) { 6286 S.Diag(CompletionBlock->getLocation(), 6287 diag::err_swift_async_bad_block_type) 6288 << CompletionBlock->getType(); 6289 return; 6290 } 6291 QualType BlockTy = 6292 CompletionBlockType->castAs<BlockPointerType>()->getPointeeType(); 6293 if (!BlockTy->castAs<FunctionType>()->getReturnType()->isVoidType()) { 6294 S.Diag(CompletionBlock->getLocation(), 6295 diag::err_swift_async_bad_block_type) 6296 << CompletionBlock->getType(); 6297 return; 6298 } 6299 } 6300 6301 auto *AsyncAttr = 6302 ::new (S.Context) SwiftAsyncAttr(S.Context, AL, Kind, Idx); 6303 D->addAttr(AsyncAttr); 6304 6305 if (auto *ErrorAttr = D->getAttr<SwiftAsyncErrorAttr>()) 6306 checkSwiftAsyncErrorBlock(S, D, ErrorAttr, AsyncAttr); 6307} 6308 6309//===----------------------------------------------------------------------===// 6310// Microsoft specific attribute handlers. 6311//===----------------------------------------------------------------------===// 6312 6313UuidAttr *Sema::mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI, 6314 StringRef UuidAsWritten, MSGuidDecl *GuidDecl) { 6315 if (const auto *UA = D->getAttr<UuidAttr>()) { 6316 if (declaresSameEntity(UA->getGuidDecl(), GuidDecl)) 6317 return nullptr; 6318 if (!UA->getGuid().empty()) { 6319 Diag(UA->getLocation(), diag::err_mismatched_uuid); 6320 Diag(CI.getLoc(), diag::note_previous_uuid); 6321 D->dropAttr<UuidAttr>(); 6322 } 6323 } 6324 6325 return ::new (Context) UuidAttr(Context, CI, UuidAsWritten, GuidDecl); 6326} 6327 6328static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6329 if (!S.LangOpts.CPlusPlus) { 6330 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang) 6331 << AL << AttributeLangSupport::C; 6332 return; 6333 } 6334 6335 StringRef OrigStrRef; 6336 SourceLocation LiteralLoc; 6337 if (!S.checkStringLiteralArgumentAttr(AL, 0, OrigStrRef, &LiteralLoc)) 6338 return; 6339 6340 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or 6341 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former. 6342 StringRef StrRef = OrigStrRef; 6343 if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}') 6344 StrRef = StrRef.drop_front().drop_back(); 6345 6346 // Validate GUID length. 6347 if (StrRef.size() != 36) { 6348 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid); 6349 return; 6350 } 6351 6352 for (unsigned i = 0; i < 36; ++i) { 6353 if (i == 8 || i == 13 || i == 18 || i == 23) { 6354 if (StrRef[i] != '-') { 6355 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid); 6356 return; 6357 } 6358 } else if (!isHexDigit(StrRef[i])) { 6359 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid); 6360 return; 6361 } 6362 } 6363 6364 // Convert to our parsed format and canonicalize. 6365 MSGuidDecl::Parts Parsed; 6366 StrRef.substr(0, 8).getAsInteger(16, Parsed.Part1); 6367 StrRef.substr(9, 4).getAsInteger(16, Parsed.Part2); 6368 StrRef.substr(14, 4).getAsInteger(16, Parsed.Part3); 6369 for (unsigned i = 0; i != 8; ++i) 6370 StrRef.substr(19 + 2 * i + (i >= 2 ? 1 : 0), 2) 6371 .getAsInteger(16, Parsed.Part4And5[i]); 6372 MSGuidDecl *Guid = S.Context.getMSGuidDecl(Parsed); 6373 6374 // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's 6375 // the only thing in the [] list, the [] too), and add an insertion of 6376 // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas 6377 // separating attributes nor of the [ and the ] are in the AST. 6378 // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc" 6379 // on cfe-dev. 6380 if (AL.isMicrosoftAttribute()) // Check for [uuid(...)] spelling. 6381 S.Diag(AL.getLoc(), diag::warn_atl_uuid_deprecated); 6382 6383 UuidAttr *UA = S.mergeUuidAttr(D, AL, OrigStrRef, Guid); 6384 if (UA) 6385 D->addAttr(UA); 6386} 6387 6388static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6389 if (!S.LangOpts.CPlusPlus) { 6390 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang) 6391 << AL << AttributeLangSupport::C; 6392 return; 6393 } 6394 MSInheritanceAttr *IA = S.mergeMSInheritanceAttr( 6395 D, AL, /*BestCase=*/true, (MSInheritanceModel)AL.getSemanticSpelling()); 6396 if (IA) { 6397 D->addAttr(IA); 6398 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D)); 6399 } 6400} 6401 6402static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6403 const auto *VD = cast<VarDecl>(D); 6404 if (!S.Context.getTargetInfo().isTLSSupported()) { 6405 S.Diag(AL.getLoc(), diag::err_thread_unsupported); 6406 return; 6407 } 6408 if (VD->getTSCSpec() != TSCS_unspecified) { 6409 S.Diag(AL.getLoc(), diag::err_declspec_thread_on_thread_variable); 6410 return; 6411 } 6412 if (VD->hasLocalStorage()) { 6413 S.Diag(AL.getLoc(), diag::err_thread_non_global) << "__declspec(thread)"; 6414 return; 6415 } 6416 D->addAttr(::new (S.Context) ThreadAttr(S.Context, AL)); 6417} 6418 6419static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6420 SmallVector<StringRef, 4> Tags; 6421 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) { 6422 StringRef Tag; 6423 if (!S.checkStringLiteralArgumentAttr(AL, I, Tag)) 6424 return; 6425 Tags.push_back(Tag); 6426 } 6427 6428 if (const auto *NS = dyn_cast<NamespaceDecl>(D)) { 6429 if (!NS->isInline()) { 6430 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 0; 6431 return; 6432 } 6433 if (NS->isAnonymousNamespace()) { 6434 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1; 6435 return; 6436 } 6437 if (AL.getNumArgs() == 0) 6438 Tags.push_back(NS->getName()); 6439 } else if (!AL.checkAtLeastNumArgs(S, 1)) 6440 return; 6441 6442 // Store tags sorted and without duplicates. 6443 llvm::sort(Tags); 6444 Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end()); 6445 6446 D->addAttr(::new (S.Context) 6447 AbiTagAttr(S.Context, AL, Tags.data(), Tags.size())); 6448} 6449 6450static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6451 // Check the attribute arguments. 6452 if (AL.getNumArgs() > 1) { 6453 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1; 6454 return; 6455 } 6456 6457 StringRef Str; 6458 SourceLocation ArgLoc; 6459 6460 if (AL.getNumArgs() == 0) 6461 Str = ""; 6462 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6463 return; 6464 6465 ARMInterruptAttr::InterruptType Kind; 6466 if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) { 6467 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str 6468 << ArgLoc; 6469 return; 6470 } 6471 6472 D->addAttr(::new (S.Context) ARMInterruptAttr(S.Context, AL, Kind)); 6473} 6474 6475static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6476 // MSP430 'interrupt' attribute is applied to 6477 // a function with no parameters and void return type. 6478 if (!isFunctionOrMethod(D)) { 6479 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6480 << "'interrupt'" << ExpectedFunctionOrMethod; 6481 return; 6482 } 6483 6484 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) { 6485 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6486 << /*MSP430*/ 1 << 0; 6487 return; 6488 } 6489 6490 if (!getFunctionOrMethodResultType(D)->isVoidType()) { 6491 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6492 << /*MSP430*/ 1 << 1; 6493 return; 6494 } 6495 6496 // The attribute takes one integer argument. 6497 if (!AL.checkExactlyNumArgs(S, 1)) 6498 return; 6499 6500 if (!AL.isArgExpr(0)) { 6501 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 6502 << AL << AANT_ArgumentIntegerConstant; 6503 return; 6504 } 6505 6506 Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0)); 6507 Optional<llvm::APSInt> NumParams = llvm::APSInt(32); 6508 if (!(NumParams = NumParamsExpr->getIntegerConstantExpr(S.Context))) { 6509 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 6510 << AL << AANT_ArgumentIntegerConstant 6511 << NumParamsExpr->getSourceRange(); 6512 return; 6513 } 6514 // The argument should be in range 0..63. 6515 unsigned Num = NumParams->getLimitedValue(255); 6516 if (Num > 63) { 6517 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 6518 << AL << (int)NumParams->getSExtValue() 6519 << NumParamsExpr->getSourceRange(); 6520 return; 6521 } 6522 6523 D->addAttr(::new (S.Context) MSP430InterruptAttr(S.Context, AL, Num)); 6524 D->addAttr(UsedAttr::CreateImplicit(S.Context)); 6525} 6526 6527static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6528 // Only one optional argument permitted. 6529 if (AL.getNumArgs() > 1) { 6530 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1; 6531 return; 6532 } 6533 6534 StringRef Str; 6535 SourceLocation ArgLoc; 6536 6537 if (AL.getNumArgs() == 0) 6538 Str = ""; 6539 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6540 return; 6541 6542 // Semantic checks for a function with the 'interrupt' attribute for MIPS: 6543 // a) Must be a function. 6544 // b) Must have no parameters. 6545 // c) Must have the 'void' return type. 6546 // d) Cannot have the 'mips16' attribute, as that instruction set 6547 // lacks the 'eret' instruction. 6548 // e) The attribute itself must either have no argument or one of the 6549 // valid interrupt types, see [MipsInterruptDocs]. 6550 6551 if (!isFunctionOrMethod(D)) { 6552 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6553 << "'interrupt'" << ExpectedFunctionOrMethod; 6554 return; 6555 } 6556 6557 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) { 6558 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6559 << /*MIPS*/ 0 << 0; 6560 return; 6561 } 6562 6563 if (!getFunctionOrMethodResultType(D)->isVoidType()) { 6564 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6565 << /*MIPS*/ 0 << 1; 6566 return; 6567 } 6568 6569 // We still have to do this manually because the Interrupt attributes are 6570 // a bit special due to sharing their spellings across targets. 6571 if (checkAttrMutualExclusion<Mips16Attr>(S, D, AL)) 6572 return; 6573 6574 MipsInterruptAttr::InterruptType Kind; 6575 if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) { 6576 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) 6577 << AL << "'" + std::string(Str) + "'"; 6578 return; 6579 } 6580 6581 D->addAttr(::new (S.Context) MipsInterruptAttr(S.Context, AL, Kind)); 6582} 6583 6584static void handleM68kInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6585 if (!AL.checkExactlyNumArgs(S, 1)) 6586 return; 6587 6588 if (!AL.isArgExpr(0)) { 6589 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 6590 << AL << AANT_ArgumentIntegerConstant; 6591 return; 6592 } 6593 6594 // FIXME: Check for decl - it should be void ()(void). 6595 6596 Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0)); 6597 auto MaybeNumParams = NumParamsExpr->getIntegerConstantExpr(S.Context); 6598 if (!MaybeNumParams) { 6599 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 6600 << AL << AANT_ArgumentIntegerConstant 6601 << NumParamsExpr->getSourceRange(); 6602 return; 6603 } 6604 6605 unsigned Num = MaybeNumParams->getLimitedValue(255); 6606 if ((Num & 1) || Num > 30) { 6607 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 6608 << AL << (int)MaybeNumParams->getSExtValue() 6609 << NumParamsExpr->getSourceRange(); 6610 return; 6611 } 6612 6613 D->addAttr(::new (S.Context) M68kInterruptAttr(S.Context, AL, Num)); 6614 D->addAttr(UsedAttr::CreateImplicit(S.Context)); 6615} 6616 6617static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6618 // Semantic checks for a function with the 'interrupt' attribute. 6619 // a) Must be a function. 6620 // b) Must have the 'void' return type. 6621 // c) Must take 1 or 2 arguments. 6622 // d) The 1st argument must be a pointer. 6623 // e) The 2nd argument (if any) must be an unsigned integer. 6624 if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) || 6625 CXXMethodDecl::isStaticOverloadedOperator( 6626 cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) { 6627 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 6628 << AL << ExpectedFunctionWithProtoType; 6629 return; 6630 } 6631 // Interrupt handler must have void return type. 6632 if (!getFunctionOrMethodResultType(D)->isVoidType()) { 6633 S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(), 6634 diag::err_anyx86_interrupt_attribute) 6635 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 6636 ? 0 6637 : 1) 6638 << 0; 6639 return; 6640 } 6641 // Interrupt handler must have 1 or 2 parameters. 6642 unsigned NumParams = getFunctionOrMethodNumParams(D); 6643 if (NumParams < 1 || NumParams > 2) { 6644 S.Diag(D->getBeginLoc(), diag::err_anyx86_interrupt_attribute) 6645 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 6646 ? 0 6647 : 1) 6648 << 1; 6649 return; 6650 } 6651 // The first argument must be a pointer. 6652 if (!getFunctionOrMethodParamType(D, 0)->isPointerType()) { 6653 S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(), 6654 diag::err_anyx86_interrupt_attribute) 6655 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 6656 ? 0 6657 : 1) 6658 << 2; 6659 return; 6660 } 6661 // The second argument, if present, must be an unsigned integer. 6662 unsigned TypeSize = 6663 S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86_64 6664 ? 64 6665 : 32; 6666 if (NumParams == 2 && 6667 (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() || 6668 S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) { 6669 S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(), 6670 diag::err_anyx86_interrupt_attribute) 6671 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86 6672 ? 0 6673 : 1) 6674 << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false); 6675 return; 6676 } 6677 D->addAttr(::new (S.Context) AnyX86InterruptAttr(S.Context, AL)); 6678 D->addAttr(UsedAttr::CreateImplicit(S.Context)); 6679} 6680 6681static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6682 if (!isFunctionOrMethod(D)) { 6683 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6684 << "'interrupt'" << ExpectedFunction; 6685 return; 6686 } 6687 6688 if (!AL.checkExactlyNumArgs(S, 0)) 6689 return; 6690 6691 handleSimpleAttribute<AVRInterruptAttr>(S, D, AL); 6692} 6693 6694static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6695 if (!isFunctionOrMethod(D)) { 6696 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6697 << "'signal'" << ExpectedFunction; 6698 return; 6699 } 6700 6701 if (!AL.checkExactlyNumArgs(S, 0)) 6702 return; 6703 6704 handleSimpleAttribute<AVRSignalAttr>(S, D, AL); 6705} 6706 6707static void handleBPFPreserveAIRecord(Sema &S, RecordDecl *RD) { 6708 // Add preserve_access_index attribute to all fields and inner records. 6709 for (auto D : RD->decls()) { 6710 if (D->hasAttr<BPFPreserveAccessIndexAttr>()) 6711 continue; 6712 6713 D->addAttr(BPFPreserveAccessIndexAttr::CreateImplicit(S.Context)); 6714 if (auto *Rec = dyn_cast<RecordDecl>(D)) 6715 handleBPFPreserveAIRecord(S, Rec); 6716 } 6717} 6718 6719static void handleBPFPreserveAccessIndexAttr(Sema &S, Decl *D, 6720 const ParsedAttr &AL) { 6721 auto *Rec = cast<RecordDecl>(D); 6722 handleBPFPreserveAIRecord(S, Rec); 6723 Rec->addAttr(::new (S.Context) BPFPreserveAccessIndexAttr(S.Context, AL)); 6724} 6725 6726static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6727 if (!isFunctionOrMethod(D)) { 6728 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6729 << "'export_name'" << ExpectedFunction; 6730 return; 6731 } 6732 6733 auto *FD = cast<FunctionDecl>(D); 6734 if (FD->isThisDeclarationADefinition()) { 6735 S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0; 6736 return; 6737 } 6738 6739 StringRef Str; 6740 SourceLocation ArgLoc; 6741 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6742 return; 6743 6744 D->addAttr(::new (S.Context) WebAssemblyExportNameAttr(S.Context, AL, Str)); 6745 D->addAttr(UsedAttr::CreateImplicit(S.Context)); 6746} 6747 6748WebAssemblyImportModuleAttr * 6749Sema::mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL) { 6750 auto *FD = cast<FunctionDecl>(D); 6751 6752 if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportModuleAttr>()) { 6753 if (ExistingAttr->getImportModule() == AL.getImportModule()) 6754 return nullptr; 6755 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_import) << 0 6756 << ExistingAttr->getImportModule() << AL.getImportModule(); 6757 Diag(AL.getLoc(), diag::note_previous_attribute); 6758 return nullptr; 6759 } 6760 if (FD->hasBody()) { 6761 Diag(AL.getLoc(), diag::warn_import_on_definition) << 0; 6762 return nullptr; 6763 } 6764 return ::new (Context) WebAssemblyImportModuleAttr(Context, AL, 6765 AL.getImportModule()); 6766} 6767 6768WebAssemblyImportNameAttr * 6769Sema::mergeImportNameAttr(Decl *D, const WebAssemblyImportNameAttr &AL) { 6770 auto *FD = cast<FunctionDecl>(D); 6771 6772 if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportNameAttr>()) { 6773 if (ExistingAttr->getImportName() == AL.getImportName()) 6774 return nullptr; 6775 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_import) << 1 6776 << ExistingAttr->getImportName() << AL.getImportName(); 6777 Diag(AL.getLoc(), diag::note_previous_attribute); 6778 return nullptr; 6779 } 6780 if (FD->hasBody()) { 6781 Diag(AL.getLoc(), diag::warn_import_on_definition) << 1; 6782 return nullptr; 6783 } 6784 return ::new (Context) WebAssemblyImportNameAttr(Context, AL, 6785 AL.getImportName()); 6786} 6787 6788static void 6789handleWebAssemblyImportModuleAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6790 auto *FD = cast<FunctionDecl>(D); 6791 6792 StringRef Str; 6793 SourceLocation ArgLoc; 6794 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6795 return; 6796 if (FD->hasBody()) { 6797 S.Diag(AL.getLoc(), diag::warn_import_on_definition) << 0; 6798 return; 6799 } 6800 6801 FD->addAttr(::new (S.Context) 6802 WebAssemblyImportModuleAttr(S.Context, AL, Str)); 6803} 6804 6805static void 6806handleWebAssemblyImportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6807 auto *FD = cast<FunctionDecl>(D); 6808 6809 StringRef Str; 6810 SourceLocation ArgLoc; 6811 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6812 return; 6813 if (FD->hasBody()) { 6814 S.Diag(AL.getLoc(), diag::warn_import_on_definition) << 1; 6815 return; 6816 } 6817 6818 FD->addAttr(::new (S.Context) WebAssemblyImportNameAttr(S.Context, AL, Str)); 6819} 6820 6821static void handleRISCVInterruptAttr(Sema &S, Decl *D, 6822 const ParsedAttr &AL) { 6823 // Warn about repeated attributes. 6824 if (const auto *A = D->getAttr<RISCVInterruptAttr>()) { 6825 S.Diag(AL.getRange().getBegin(), 6826 diag::warn_riscv_repeated_interrupt_attribute); 6827 S.Diag(A->getLocation(), diag::note_riscv_repeated_interrupt_attribute); 6828 return; 6829 } 6830 6831 // Check the attribute argument. Argument is optional. 6832 if (!AL.checkAtMostNumArgs(S, 1)) 6833 return; 6834 6835 StringRef Str; 6836 SourceLocation ArgLoc; 6837 6838 // 'machine'is the default interrupt mode. 6839 if (AL.getNumArgs() == 0) 6840 Str = "machine"; 6841 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc)) 6842 return; 6843 6844 // Semantic checks for a function with the 'interrupt' attribute: 6845 // - Must be a function. 6846 // - Must have no parameters. 6847 // - Must have the 'void' return type. 6848 // - The attribute itself must either have no argument or one of the 6849 // valid interrupt types, see [RISCVInterruptDocs]. 6850 6851 if (D->getFunctionType() == nullptr) { 6852 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) 6853 << "'interrupt'" << ExpectedFunction; 6854 return; 6855 } 6856 6857 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) { 6858 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6859 << /*RISC-V*/ 2 << 0; 6860 return; 6861 } 6862 6863 if (!getFunctionOrMethodResultType(D)->isVoidType()) { 6864 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid) 6865 << /*RISC-V*/ 2 << 1; 6866 return; 6867 } 6868 6869 RISCVInterruptAttr::InterruptType Kind; 6870 if (!RISCVInterruptAttr::ConvertStrToInterruptType(Str, Kind)) { 6871 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str 6872 << ArgLoc; 6873 return; 6874 } 6875 6876 D->addAttr(::new (S.Context) RISCVInterruptAttr(S.Context, AL, Kind)); 6877} 6878 6879static void handleInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 6880 // Dispatch the interrupt attribute based on the current target. 6881 switch (S.Context.getTargetInfo().getTriple().getArch()) { 6882 case llvm::Triple::msp430: 6883 handleMSP430InterruptAttr(S, D, AL); 6884 break; 6885 case llvm::Triple::mipsel: 6886 case llvm::Triple::mips: 6887 handleMipsInterruptAttr(S, D, AL); 6888 break; 6889 case llvm::Triple::m68k: 6890 handleM68kInterruptAttr(S, D, AL); 6891 break; 6892 case llvm::Triple::x86: 6893 case llvm::Triple::x86_64: 6894 handleAnyX86InterruptAttr(S, D, AL); 6895 break; 6896 case llvm::Triple::avr: 6897 handleAVRInterruptAttr(S, D, AL); 6898 break; 6899 case llvm::Triple::riscv32: 6900 case llvm::Triple::riscv64: 6901 handleRISCVInterruptAttr(S, D, AL); 6902 break; 6903 default: 6904 handleARMInterruptAttr(S, D, AL); 6905 break; 6906 } 6907} 6908 6909static bool 6910checkAMDGPUFlatWorkGroupSizeArguments(Sema &S, Expr *MinExpr, Expr *MaxExpr, 6911 const AMDGPUFlatWorkGroupSizeAttr &Attr) { 6912 // Accept template arguments for now as they depend on something else. 6913 // We'll get to check them when they eventually get instantiated. 6914 if (MinExpr->isValueDependent() || MaxExpr->isValueDependent()) 6915 return false; 6916 6917 uint32_t Min = 0; 6918 if (!checkUInt32Argument(S, Attr, MinExpr, Min, 0)) 6919 return true; 6920 6921 uint32_t Max = 0; 6922 if (!checkUInt32Argument(S, Attr, MaxExpr, Max, 1)) 6923 return true; 6924 6925 if (Min == 0 && Max != 0) { 6926 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid) 6927 << &Attr << 0; 6928 return true; 6929 } 6930 if (Min > Max) { 6931 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid) 6932 << &Attr << 1; 6933 return true; 6934 } 6935 6936 return false; 6937} 6938 6939void Sema::addAMDGPUFlatWorkGroupSizeAttr(Decl *D, 6940 const AttributeCommonInfo &CI, 6941 Expr *MinExpr, Expr *MaxExpr) { 6942 AMDGPUFlatWorkGroupSizeAttr TmpAttr(Context, CI, MinExpr, MaxExpr); 6943 6944 if (checkAMDGPUFlatWorkGroupSizeArguments(*this, MinExpr, MaxExpr, TmpAttr)) 6945 return; 6946 6947 D->addAttr(::new (Context) 6948 AMDGPUFlatWorkGroupSizeAttr(Context, CI, MinExpr, MaxExpr)); 6949} 6950 6951static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D, 6952 const ParsedAttr &AL) { 6953 Expr *MinExpr = AL.getArgAsExpr(0); 6954 Expr *MaxExpr = AL.getArgAsExpr(1); 6955 6956 S.addAMDGPUFlatWorkGroupSizeAttr(D, AL, MinExpr, MaxExpr); 6957} 6958 6959static bool checkAMDGPUWavesPerEUArguments(Sema &S, Expr *MinExpr, 6960 Expr *MaxExpr, 6961 const AMDGPUWavesPerEUAttr &Attr) { 6962 if (S.DiagnoseUnexpandedParameterPack(MinExpr) || 6963 (MaxExpr && S.DiagnoseUnexpandedParameterPack(MaxExpr))) 6964 return true; 6965 6966 // Accept template arguments for now as they depend on something else. 6967 // We'll get to check them when they eventually get instantiated. 6968 if (MinExpr->isValueDependent() || (MaxExpr && MaxExpr->isValueDependent())) 6969 return false; 6970 6971 uint32_t Min = 0; 6972 if (!checkUInt32Argument(S, Attr, MinExpr, Min, 0)) 6973 return true; 6974 6975 uint32_t Max = 0; 6976 if (MaxExpr && !checkUInt32Argument(S, Attr, MaxExpr, Max, 1)) 6977 return true; 6978 6979 if (Min == 0 && Max != 0) { 6980 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid) 6981 << &Attr << 0; 6982 return true; 6983 } 6984 if (Max != 0 && Min > Max) { 6985 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid) 6986 << &Attr << 1; 6987 return true; 6988 } 6989 6990 return false; 6991} 6992 6993void Sema::addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI, 6994 Expr *MinExpr, Expr *MaxExpr) { 6995 AMDGPUWavesPerEUAttr TmpAttr(Context, CI, MinExpr, MaxExpr); 6996 6997 if (checkAMDGPUWavesPerEUArguments(*this, MinExpr, MaxExpr, TmpAttr)) 6998 return; 6999 7000 D->addAttr(::new (Context) 7001 AMDGPUWavesPerEUAttr(Context, CI, MinExpr, MaxExpr)); 7002} 7003 7004static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7005 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 2)) 7006 return; 7007 7008 Expr *MinExpr = AL.getArgAsExpr(0); 7009 Expr *MaxExpr = (AL.getNumArgs() > 1) ? AL.getArgAsExpr(1) : nullptr; 7010 7011 S.addAMDGPUWavesPerEUAttr(D, AL, MinExpr, MaxExpr); 7012} 7013 7014static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7015 uint32_t NumSGPR = 0; 7016 Expr *NumSGPRExpr = AL.getArgAsExpr(0); 7017 if (!checkUInt32Argument(S, AL, NumSGPRExpr, NumSGPR)) 7018 return; 7019 7020 D->addAttr(::new (S.Context) AMDGPUNumSGPRAttr(S.Context, AL, NumSGPR)); 7021} 7022 7023static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7024 uint32_t NumVGPR = 0; 7025 Expr *NumVGPRExpr = AL.getArgAsExpr(0); 7026 if (!checkUInt32Argument(S, AL, NumVGPRExpr, NumVGPR)) 7027 return; 7028 7029 D->addAttr(::new (S.Context) AMDGPUNumVGPRAttr(S.Context, AL, NumVGPR)); 7030} 7031 7032static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D, 7033 const ParsedAttr &AL) { 7034 // If we try to apply it to a function pointer, don't warn, but don't 7035 // do anything, either. It doesn't matter anyway, because there's nothing 7036 // special about calling a force_align_arg_pointer function. 7037 const auto *VD = dyn_cast<ValueDecl>(D); 7038 if (VD && VD->getType()->isFunctionPointerType()) 7039 return; 7040 // Also don't warn on function pointer typedefs. 7041 const auto *TD = dyn_cast<TypedefNameDecl>(D); 7042 if (TD && (TD->getUnderlyingType()->isFunctionPointerType() || 7043 TD->getUnderlyingType()->isFunctionType())) 7044 return; 7045 // Attribute can only be applied to function types. 7046 if (!isa<FunctionDecl>(D)) { 7047 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) 7048 << AL << ExpectedFunction; 7049 return; 7050 } 7051 7052 D->addAttr(::new (S.Context) X86ForceAlignArgPointerAttr(S.Context, AL)); 7053} 7054 7055static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL) { 7056 uint32_t Version; 7057 Expr *VersionExpr = static_cast<Expr *>(AL.getArgAsExpr(0)); 7058 if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Version)) 7059 return; 7060 7061 // TODO: Investigate what happens with the next major version of MSVC. 7062 if (Version != LangOptions::MSVC2015 / 100) { 7063 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds) 7064 << AL << Version << VersionExpr->getSourceRange(); 7065 return; 7066 } 7067 7068 // The attribute expects a "major" version number like 19, but new versions of 7069 // MSVC have moved to updating the "minor", or less significant numbers, so we 7070 // have to multiply by 100 now. 7071 Version *= 100; 7072 7073 D->addAttr(::new (S.Context) LayoutVersionAttr(S.Context, AL, Version)); 7074} 7075 7076DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, 7077 const AttributeCommonInfo &CI) { 7078 if (D->hasAttr<DLLExportAttr>()) { 7079 Diag(CI.getLoc(), diag::warn_attribute_ignored) << "'dllimport'"; 7080 return nullptr; 7081 } 7082 7083 if (D->hasAttr<DLLImportAttr>()) 7084 return nullptr; 7085 7086 return ::new (Context) DLLImportAttr(Context, CI); 7087} 7088 7089DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, 7090 const AttributeCommonInfo &CI) { 7091 if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) { 7092 Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import; 7093 D->dropAttr<DLLImportAttr>(); 7094 } 7095 7096 if (D->hasAttr<DLLExportAttr>()) 7097 return nullptr; 7098 7099 return ::new (Context) DLLExportAttr(Context, CI); 7100} 7101 7102static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) { 7103 if (isa<ClassTemplatePartialSpecializationDecl>(D) && 7104 (S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) { 7105 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored) << A; 7106 return; 7107 } 7108 7109 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 7110 if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport && 7111 !(S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) { 7112 // MinGW doesn't allow dllimport on inline functions. 7113 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline) 7114 << A; 7115 return; 7116 } 7117 } 7118 7119 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) { 7120 if ((S.Context.getTargetInfo().shouldDLLImportComdatSymbols()) && 7121 MD->getParent()->isLambda()) { 7122 S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A; 7123 return; 7124 } 7125 } 7126 7127 Attr *NewAttr = A.getKind() == ParsedAttr::AT_DLLExport 7128 ? (Attr *)S.mergeDLLExportAttr(D, A) 7129 : (Attr *)S.mergeDLLImportAttr(D, A); 7130 if (NewAttr) 7131 D->addAttr(NewAttr); 7132} 7133 7134MSInheritanceAttr * 7135Sema::mergeMSInheritanceAttr(Decl *D, const AttributeCommonInfo &CI, 7136 bool BestCase, 7137 MSInheritanceModel Model) { 7138 if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) { 7139 if (IA->getInheritanceModel() == Model) 7140 return nullptr; 7141 Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance) 7142 << 1 /*previous declaration*/; 7143 Diag(CI.getLoc(), diag::note_previous_ms_inheritance); 7144 D->dropAttr<MSInheritanceAttr>(); 7145 } 7146 7147 auto *RD = cast<CXXRecordDecl>(D); 7148 if (RD->hasDefinition()) { 7149 if (checkMSInheritanceAttrOnDefinition(RD, CI.getRange(), BestCase, 7150 Model)) { 7151 return nullptr; 7152 } 7153 } else { 7154 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) { 7155 Diag(CI.getLoc(), diag::warn_ignored_ms_inheritance) 7156 << 1 /*partial specialization*/; 7157 return nullptr; 7158 } 7159 if (RD->getDescribedClassTemplate()) { 7160 Diag(CI.getLoc(), diag::warn_ignored_ms_inheritance) 7161 << 0 /*primary template*/; 7162 return nullptr; 7163 } 7164 } 7165 7166 return ::new (Context) MSInheritanceAttr(Context, CI, BestCase); 7167} 7168 7169static void handleCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7170 // The capability attributes take a single string parameter for the name of 7171 // the capability they represent. The lockable attribute does not take any 7172 // parameters. However, semantically, both attributes represent the same 7173 // concept, and so they use the same semantic attribute. Eventually, the 7174 // lockable attribute will be removed. 7175 // 7176 // For backward compatibility, any capability which has no specified string 7177 // literal will be considered a "mutex." 7178 StringRef N("mutex"); 7179 SourceLocation LiteralLoc; 7180 if (AL.getKind() == ParsedAttr::AT_Capability && 7181 !S.checkStringLiteralArgumentAttr(AL, 0, N, &LiteralLoc)) 7182 return; 7183 7184 D->addAttr(::new (S.Context) CapabilityAttr(S.Context, AL, N)); 7185} 7186 7187static void handleAssertCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7188 SmallVector<Expr*, 1> Args; 7189 if (!checkLockFunAttrCommon(S, D, AL, Args)) 7190 return; 7191 7192 D->addAttr(::new (S.Context) 7193 AssertCapabilityAttr(S.Context, AL, Args.data(), Args.size())); 7194} 7195 7196static void handleAcquireCapabilityAttr(Sema &S, Decl *D, 7197 const ParsedAttr &AL) { 7198 SmallVector<Expr*, 1> Args; 7199 if (!checkLockFunAttrCommon(S, D, AL, Args)) 7200 return; 7201 7202 D->addAttr(::new (S.Context) AcquireCapabilityAttr(S.Context, AL, Args.data(), 7203 Args.size())); 7204} 7205 7206static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D, 7207 const ParsedAttr &AL) { 7208 SmallVector<Expr*, 2> Args; 7209 if (!checkTryLockFunAttrCommon(S, D, AL, Args)) 7210 return; 7211 7212 D->addAttr(::new (S.Context) TryAcquireCapabilityAttr( 7213 S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size())); 7214} 7215 7216static void handleReleaseCapabilityAttr(Sema &S, Decl *D, 7217 const ParsedAttr &AL) { 7218 // Check that all arguments are lockable objects. 7219 SmallVector<Expr *, 1> Args; 7220 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, true); 7221 7222 D->addAttr(::new (S.Context) ReleaseCapabilityAttr(S.Context, AL, Args.data(), 7223 Args.size())); 7224} 7225 7226static void handleRequiresCapabilityAttr(Sema &S, Decl *D, 7227 const ParsedAttr &AL) { 7228 if (!AL.checkAtLeastNumArgs(S, 1)) 7229 return; 7230 7231 // check that all arguments are lockable objects 7232 SmallVector<Expr*, 1> Args; 7233 checkAttrArgsAreCapabilityObjs(S, D, AL, Args); 7234 if (Args.empty()) 7235 return; 7236 7237 RequiresCapabilityAttr *RCA = ::new (S.Context) 7238 RequiresCapabilityAttr(S.Context, AL, Args.data(), Args.size()); 7239 7240 D->addAttr(RCA); 7241} 7242 7243static void handleDeprecatedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7244 if (const auto *NSD = dyn_cast<NamespaceDecl>(D)) { 7245 if (NSD->isAnonymousNamespace()) { 7246 S.Diag(AL.getLoc(), diag::warn_deprecated_anonymous_namespace); 7247 // Do not want to attach the attribute to the namespace because that will 7248 // cause confusing diagnostic reports for uses of declarations within the 7249 // namespace. 7250 return; 7251 } 7252 } 7253 7254 // Handle the cases where the attribute has a text message. 7255 StringRef Str, Replacement; 7256 if (AL.isArgExpr(0) && AL.getArgAsExpr(0) && 7257 !S.checkStringLiteralArgumentAttr(AL, 0, Str)) 7258 return; 7259 7260 // Only support a single optional message for Declspec and CXX11. 7261 if (AL.isDeclspecAttribute() || AL.isCXX11Attribute()) 7262 AL.checkAtMostNumArgs(S, 1); 7263 else if (AL.isArgExpr(1) && AL.getArgAsExpr(1) && 7264 !S.checkStringLiteralArgumentAttr(AL, 1, Replacement)) 7265 return; 7266 7267 if (!S.getLangOpts().CPlusPlus14 && AL.isCXX11Attribute() && !AL.isGNUScope()) 7268 S.Diag(AL.getLoc(), diag::ext_cxx14_attr) << AL; 7269 7270 D->addAttr(::new (S.Context) DeprecatedAttr(S.Context, AL, Str, Replacement)); 7271} 7272 7273static bool isGlobalVar(const Decl *D) { 7274 if (const auto *S = dyn_cast<VarDecl>(D)) 7275 return S->hasGlobalStorage(); 7276 return false; 7277} 7278 7279static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7280 if (!AL.checkAtLeastNumArgs(S, 1)) 7281 return; 7282 7283 std::vector<StringRef> Sanitizers; 7284 7285 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) { 7286 StringRef SanitizerName; 7287 SourceLocation LiteralLoc; 7288 7289 if (!S.checkStringLiteralArgumentAttr(AL, I, SanitizerName, &LiteralLoc)) 7290 return; 7291 7292 if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 7293 SanitizerMask()) 7294 S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName; 7295 else if (isGlobalVar(D) && SanitizerName != "address") 7296 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 7297 << AL << ExpectedFunctionOrMethod; 7298 Sanitizers.push_back(SanitizerName); 7299 } 7300 7301 D->addAttr(::new (S.Context) NoSanitizeAttr(S.Context, AL, Sanitizers.data(), 7302 Sanitizers.size())); 7303} 7304 7305static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D, 7306 const ParsedAttr &AL) { 7307 StringRef AttrName = AL.getAttrName()->getName(); 7308 normalizeName(AttrName); 7309 StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName) 7310 .Case("no_address_safety_analysis", "address") 7311 .Case("no_sanitize_address", "address") 7312 .Case("no_sanitize_thread", "thread") 7313 .Case("no_sanitize_memory", "memory"); 7314 if (isGlobalVar(D) && SanitizerName != "address") 7315 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 7316 << AL << ExpectedFunction; 7317 7318 // FIXME: Rather than create a NoSanitizeSpecificAttr, this creates a 7319 // NoSanitizeAttr object; but we need to calculate the correct spelling list 7320 // index rather than incorrectly assume the index for NoSanitizeSpecificAttr 7321 // has the same spellings as the index for NoSanitizeAttr. We don't have a 7322 // general way to "translate" between the two, so this hack attempts to work 7323 // around the issue with hard-coded indicies. This is critical for calling 7324 // getSpelling() or prettyPrint() on the resulting semantic attribute object 7325 // without failing assertions. 7326 unsigned TranslatedSpellingIndex = 0; 7327 if (AL.isC2xAttribute() || AL.isCXX11Attribute()) 7328 TranslatedSpellingIndex = 1; 7329 7330 AttributeCommonInfo Info = AL; 7331 Info.setAttributeSpellingListIndex(TranslatedSpellingIndex); 7332 D->addAttr(::new (S.Context) 7333 NoSanitizeAttr(S.Context, Info, &SanitizerName, 1)); 7334} 7335 7336static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7337 if (InternalLinkageAttr *Internal = S.mergeInternalLinkageAttr(D, AL)) 7338 D->addAttr(Internal); 7339} 7340 7341static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7342 if (S.LangOpts.OpenCLVersion != 200) 7343 S.Diag(AL.getLoc(), diag::err_attribute_requires_opencl_version) 7344 << AL << "2.0" << 0; 7345 else 7346 S.Diag(AL.getLoc(), diag::warn_opencl_attr_deprecated_ignored) << AL 7347 << "2.0"; 7348} 7349 7350static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7351 if (D->isInvalidDecl()) 7352 return; 7353 7354 // Check if there is only one access qualifier. 7355 if (D->hasAttr<OpenCLAccessAttr>()) { 7356 if (D->getAttr<OpenCLAccessAttr>()->getSemanticSpelling() == 7357 AL.getSemanticSpelling()) { 7358 S.Diag(AL.getLoc(), diag::warn_duplicate_declspec) 7359 << AL.getAttrName()->getName() << AL.getRange(); 7360 } else { 7361 S.Diag(AL.getLoc(), diag::err_opencl_multiple_access_qualifiers) 7362 << D->getSourceRange(); 7363 D->setInvalidDecl(true); 7364 return; 7365 } 7366 } 7367 7368 // OpenCL v2.0 s6.6 - read_write can be used for image types to specify that an 7369 // image object can be read and written. 7370 // OpenCL v2.0 s6.13.6 - A kernel cannot read from and write to the same pipe 7371 // object. Using the read_write (or __read_write) qualifier with the pipe 7372 // qualifier is a compilation error. 7373 if (const auto *PDecl = dyn_cast<ParmVarDecl>(D)) { 7374 const Type *DeclTy = PDecl->getType().getCanonicalType().getTypePtr(); 7375 if (AL.getAttrName()->getName().find("read_write") != StringRef::npos) { 7376 if ((!S.getLangOpts().OpenCLCPlusPlus && 7377 S.getLangOpts().OpenCLVersion < 200) || 7378 DeclTy->isPipeType()) { 7379 S.Diag(AL.getLoc(), diag::err_opencl_invalid_read_write) 7380 << AL << PDecl->getType() << DeclTy->isImageType(); 7381 D->setInvalidDecl(true); 7382 return; 7383 } 7384 } 7385 } 7386 7387 D->addAttr(::new (S.Context) OpenCLAccessAttr(S.Context, AL)); 7388} 7389 7390static void handleSYCLKernelAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7391 // The 'sycl_kernel' attribute applies only to function templates. 7392 const auto *FD = cast<FunctionDecl>(D); 7393 const FunctionTemplateDecl *FT = FD->getDescribedFunctionTemplate(); 7394 assert(FT && "Function template is expected"); 7395 7396 // Function template must have at least two template parameters. 7397 const TemplateParameterList *TL = FT->getTemplateParameters(); 7398 if (TL->size() < 2) { 7399 S.Diag(FT->getLocation(), diag::warn_sycl_kernel_num_of_template_params); 7400 return; 7401 } 7402 7403 // Template parameters must be typenames. 7404 for (unsigned I = 0; I < 2; ++I) { 7405 const NamedDecl *TParam = TL->getParam(I); 7406 if (isa<NonTypeTemplateParmDecl>(TParam)) { 7407 S.Diag(FT->getLocation(), 7408 diag::warn_sycl_kernel_invalid_template_param_type); 7409 return; 7410 } 7411 } 7412 7413 // Function must have at least one argument. 7414 if (getFunctionOrMethodNumParams(D) != 1) { 7415 S.Diag(FT->getLocation(), diag::warn_sycl_kernel_num_of_function_params); 7416 return; 7417 } 7418 7419 // Function must return void. 7420 QualType RetTy = getFunctionOrMethodResultType(D); 7421 if (!RetTy->isVoidType()) { 7422 S.Diag(FT->getLocation(), diag::warn_sycl_kernel_return_type); 7423 return; 7424 } 7425 7426 handleSimpleAttribute<SYCLKernelAttr>(S, D, AL); 7427} 7428 7429static void handleDestroyAttr(Sema &S, Decl *D, const ParsedAttr &A) { 7430 if (!cast<VarDecl>(D)->hasGlobalStorage()) { 7431 S.Diag(D->getLocation(), diag::err_destroy_attr_on_non_static_var) 7432 << (A.getKind() == ParsedAttr::AT_AlwaysDestroy); 7433 return; 7434 } 7435 7436 if (A.getKind() == ParsedAttr::AT_AlwaysDestroy) 7437 handleSimpleAttribute<AlwaysDestroyAttr>(S, D, A); 7438 else 7439 handleSimpleAttribute<NoDestroyAttr>(S, D, A); 7440} 7441 7442static void handleUninitializedAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7443 assert(cast<VarDecl>(D)->getStorageDuration() == SD_Automatic && 7444 "uninitialized is only valid on automatic duration variables"); 7445 D->addAttr(::new (S.Context) UninitializedAttr(S.Context, AL)); 7446} 7447 7448static bool tryMakeVariablePseudoStrong(Sema &S, VarDecl *VD, 7449 bool DiagnoseFailure) { 7450 QualType Ty = VD->getType(); 7451 if (!Ty->isObjCRetainableType()) { 7452 if (DiagnoseFailure) { 7453 S.Diag(VD->getBeginLoc(), diag::warn_ignored_objc_externally_retained) 7454 << 0; 7455 } 7456 return false; 7457 } 7458 7459 Qualifiers::ObjCLifetime LifetimeQual = Ty.getQualifiers().getObjCLifetime(); 7460 7461 // Sema::inferObjCARCLifetime must run after processing decl attributes 7462 // (because __block lowers to an attribute), so if the lifetime hasn't been 7463 // explicitly specified, infer it locally now. 7464 if (LifetimeQual == Qualifiers::OCL_None) 7465 LifetimeQual = Ty->getObjCARCImplicitLifetime(); 7466 7467 // The attributes only really makes sense for __strong variables; ignore any 7468 // attempts to annotate a parameter with any other lifetime qualifier. 7469 if (LifetimeQual != Qualifiers::OCL_Strong) { 7470 if (DiagnoseFailure) { 7471 S.Diag(VD->getBeginLoc(), diag::warn_ignored_objc_externally_retained) 7472 << 1; 7473 } 7474 return false; 7475 } 7476 7477 // Tampering with the type of a VarDecl here is a bit of a hack, but we need 7478 // to ensure that the variable is 'const' so that we can error on 7479 // modification, which can otherwise over-release. 7480 VD->setType(Ty.withConst()); 7481 VD->setARCPseudoStrong(true); 7482 return true; 7483} 7484 7485static void handleObjCExternallyRetainedAttr(Sema &S, Decl *D, 7486 const ParsedAttr &AL) { 7487 if (auto *VD = dyn_cast<VarDecl>(D)) { 7488 assert(!isa<ParmVarDecl>(VD) && "should be diagnosed automatically"); 7489 if (!VD->hasLocalStorage()) { 7490 S.Diag(D->getBeginLoc(), diag::warn_ignored_objc_externally_retained) 7491 << 0; 7492 return; 7493 } 7494 7495 if (!tryMakeVariablePseudoStrong(S, VD, /*DiagnoseFailure=*/true)) 7496 return; 7497 7498 handleSimpleAttribute<ObjCExternallyRetainedAttr>(S, D, AL); 7499 return; 7500 } 7501 7502 // If D is a function-like declaration (method, block, or function), then we 7503 // make every parameter psuedo-strong. 7504 unsigned NumParams = 7505 hasFunctionProto(D) ? getFunctionOrMethodNumParams(D) : 0; 7506 for (unsigned I = 0; I != NumParams; ++I) { 7507 auto *PVD = const_cast<ParmVarDecl *>(getFunctionOrMethodParam(D, I)); 7508 QualType Ty = PVD->getType(); 7509 7510 // If a user wrote a parameter with __strong explicitly, then assume they 7511 // want "real" strong semantics for that parameter. This works because if 7512 // the parameter was written with __strong, then the strong qualifier will 7513 // be non-local. 7514 if (Ty.getLocalUnqualifiedType().getQualifiers().getObjCLifetime() == 7515 Qualifiers::OCL_Strong) 7516 continue; 7517 7518 tryMakeVariablePseudoStrong(S, PVD, /*DiagnoseFailure=*/false); 7519 } 7520 handleSimpleAttribute<ObjCExternallyRetainedAttr>(S, D, AL); 7521} 7522 7523static void handleMIGServerRoutineAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7524 // Check that the return type is a `typedef int kern_return_t` or a typedef 7525 // around it, because otherwise MIG convention checks make no sense. 7526 // BlockDecl doesn't store a return type, so it's annoying to check, 7527 // so let's skip it for now. 7528 if (!isa<BlockDecl>(D)) { 7529 QualType T = getFunctionOrMethodResultType(D); 7530 bool IsKernReturnT = false; 7531 while (const auto *TT = T->getAs<TypedefType>()) { 7532 IsKernReturnT = (TT->getDecl()->getName() == "kern_return_t"); 7533 T = TT->desugar(); 7534 } 7535 if (!IsKernReturnT || T.getCanonicalType() != S.getASTContext().IntTy) { 7536 S.Diag(D->getBeginLoc(), 7537 diag::warn_mig_server_routine_does_not_return_kern_return_t); 7538 return; 7539 } 7540 } 7541 7542 handleSimpleAttribute<MIGServerRoutineAttr>(S, D, AL); 7543} 7544 7545static void handleMSAllocatorAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7546 // Warn if the return type is not a pointer or reference type. 7547 if (auto *FD = dyn_cast<FunctionDecl>(D)) { 7548 QualType RetTy = FD->getReturnType(); 7549 if (!RetTy->isPointerType() && !RetTy->isReferenceType()) { 7550 S.Diag(AL.getLoc(), diag::warn_declspec_allocator_nonpointer) 7551 << AL.getRange() << RetTy; 7552 return; 7553 } 7554 } 7555 7556 handleSimpleAttribute<MSAllocatorAttr>(S, D, AL); 7557} 7558 7559static void handleAcquireHandleAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7560 if (AL.isUsedAsTypeAttr()) 7561 return; 7562 // Warn if the parameter is definitely not an output parameter. 7563 if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) { 7564 if (PVD->getType()->isIntegerType()) { 7565 S.Diag(AL.getLoc(), diag::err_attribute_output_parameter) 7566 << AL.getRange(); 7567 return; 7568 } 7569 } 7570 StringRef Argument; 7571 if (!S.checkStringLiteralArgumentAttr(AL, 0, Argument)) 7572 return; 7573 D->addAttr(AcquireHandleAttr::Create(S.Context, Argument, AL)); 7574} 7575 7576template<typename Attr> 7577static void handleHandleAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7578 StringRef Argument; 7579 if (!S.checkStringLiteralArgumentAttr(AL, 0, Argument)) 7580 return; 7581 D->addAttr(Attr::Create(S.Context, Argument, AL)); 7582} 7583 7584static void handleCFGuardAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7585 // The guard attribute takes a single identifier argument. 7586 7587 if (!AL.isArgIdent(0)) { 7588 S.Diag(AL.getLoc(), diag::err_attribute_argument_type) 7589 << AL << AANT_ArgumentIdentifier; 7590 return; 7591 } 7592 7593 CFGuardAttr::GuardArg Arg; 7594 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident; 7595 if (!CFGuardAttr::ConvertStrToGuardArg(II->getName(), Arg)) { 7596 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II; 7597 return; 7598 } 7599 7600 D->addAttr(::new (S.Context) CFGuardAttr(S.Context, AL, Arg)); 7601} 7602 7603 7604template <typename AttrTy> 7605static const AttrTy *findEnforceTCBAttrByName(Decl *D, StringRef Name) { 7606 auto Attrs = D->specific_attrs<AttrTy>(); 7607 auto I = llvm::find_if(Attrs, 7608 [Name](const AttrTy *A) { 7609 return A->getTCBName() == Name; 7610 }); 7611 return I == Attrs.end() ? nullptr : *I; 7612} 7613 7614template <typename AttrTy, typename ConflictingAttrTy> 7615static void handleEnforceTCBAttr(Sema &S, Decl *D, const ParsedAttr &AL) { 7616 StringRef Argument; 7617 if (!S.checkStringLiteralArgumentAttr(AL, 0, Argument)) 7618 return; 7619 7620 // A function cannot be have both regular and leaf membership in the same TCB. 7621 if (const ConflictingAttrTy *ConflictingAttr = 7622 findEnforceTCBAttrByName<ConflictingAttrTy>(D, Argument)) { 7623 // We could attach a note to the other attribute but in this case 7624 // there's no need given how the two are very close to each other. 7625 S.Diag(AL.getLoc(), diag::err_tcb_conflicting_attributes) 7626 << AL.getAttrName()->getName() << ConflictingAttr->getAttrName()->getName() 7627 << Argument; 7628 7629 // Error recovery: drop the non-leaf attribute so that to suppress 7630 // all future warnings caused by erroneous attributes. The leaf attribute 7631 // needs to be kept because it can only suppresses warnings, not cause them. 7632 D->dropAttr<EnforceTCBAttr>(); 7633 return; 7634 } 7635 7636 D->addAttr(AttrTy::Create(S.Context, Argument, AL)); 7637} 7638 7639template <typename AttrTy, typename ConflictingAttrTy> 7640static AttrTy *mergeEnforceTCBAttrImpl(Sema &S, Decl *D, const AttrTy &AL) { 7641 // Check if the new redeclaration has different leaf-ness in the same TCB. 7642 StringRef TCBName = AL.getTCBName(); 7643 if (const ConflictingAttrTy *ConflictingAttr = 7644 findEnforceTCBAttrByName<ConflictingAttrTy>(D, TCBName)) { 7645 S.Diag(ConflictingAttr->getLoc(), diag::err_tcb_conflicting_attributes) 7646 << ConflictingAttr->getAttrName()->getName() 7647 << AL.getAttrName()->getName() << TCBName; 7648 7649 // Add a note so that the user could easily find the conflicting attribute. 7650 S.Diag(AL.getLoc(), diag::note_conflicting_attribute); 7651 7652 // More error recovery. 7653 D->dropAttr<EnforceTCBAttr>(); 7654 return nullptr; 7655 } 7656 7657 ASTContext &Context = S.getASTContext(); 7658 return ::new(Context) AttrTy(Context, AL, AL.getTCBName()); 7659} 7660 7661EnforceTCBAttr *Sema::mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL) { 7662 return mergeEnforceTCBAttrImpl<EnforceTCBAttr, EnforceTCBLeafAttr>( 7663 *this, D, AL); 7664} 7665 7666EnforceTCBLeafAttr *Sema::mergeEnforceTCBLeafAttr( 7667 Decl *D, const EnforceTCBLeafAttr &AL) { 7668 return mergeEnforceTCBAttrImpl<EnforceTCBLeafAttr, EnforceTCBAttr>( 7669 *this, D, AL); 7670} 7671 7672//===----------------------------------------------------------------------===// 7673// Top Level Sema Entry Points 7674//===----------------------------------------------------------------------===// 7675 7676/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if 7677/// the attribute applies to decls. If the attribute is a type attribute, just 7678/// silently ignore it if a GNU attribute. 7679static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, 7680 const ParsedAttr &AL, 7681 bool IncludeCXX11Attributes) { 7682 if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute) 7683 return; 7684 7685 // Ignore C++11 attributes on declarator chunks: they appertain to the type 7686 // instead. 7687 if (AL.isCXX11Attribute() && !IncludeCXX11Attributes) 7688 return; 7689 7690 // Unknown attributes are automatically warned on. Target-specific attributes 7691 // which do not apply to the current target architecture are treated as 7692 // though they were unknown attributes. 7693 if (AL.getKind() == ParsedAttr::UnknownAttribute || 7694 !AL.existsInTarget(S.Context.getTargetInfo())) { 7695 S.Diag(AL.getLoc(), 7696 AL.isDeclspecAttribute() 7697 ? (unsigned)diag::warn_unhandled_ms_attribute_ignored 7698 : (unsigned)diag::warn_unknown_attribute_ignored) 7699 << AL << AL.getRange(); 7700 return; 7701 } 7702 7703 if (S.checkCommonAttributeFeatures(D, AL)) 7704 return; 7705 7706 switch (AL.getKind()) { 7707 default: 7708 if (AL.getInfo().handleDeclAttribute(S, D, AL) != ParsedAttrInfo::NotHandled) 7709 break; 7710 if (!AL.isStmtAttr()) { 7711 // Type attributes are handled elsewhere; silently move on. 7712 assert(AL.isTypeAttr() && "Non-type attribute not handled"); 7713 break; 7714 } 7715 // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a 7716 // statement attribute is not written on a declaration, but this code is 7717 // needed for attributes in Attr.td that do not list any subjects. 7718 S.Diag(AL.getLoc(), diag::err_stmt_attribute_invalid_on_decl) 7719 << AL << D->getLocation(); 7720 break; 7721 case ParsedAttr::AT_Interrupt: 7722 handleInterruptAttr(S, D, AL); 7723 break; 7724 case ParsedAttr::AT_X86ForceAlignArgPointer: 7725 handleX86ForceAlignArgPointerAttr(S, D, AL); 7726 break; 7727 case ParsedAttr::AT_DLLExport: 7728 case ParsedAttr::AT_DLLImport: 7729 handleDLLAttr(S, D, AL); 7730 break; 7731 case ParsedAttr::AT_AMDGPUFlatWorkGroupSize: 7732 handleAMDGPUFlatWorkGroupSizeAttr(S, D, AL); 7733 break; 7734 case ParsedAttr::AT_AMDGPUWavesPerEU: 7735 handleAMDGPUWavesPerEUAttr(S, D, AL); 7736 break; 7737 case ParsedAttr::AT_AMDGPUNumSGPR: 7738 handleAMDGPUNumSGPRAttr(S, D, AL); 7739 break; 7740 case ParsedAttr::AT_AMDGPUNumVGPR: 7741 handleAMDGPUNumVGPRAttr(S, D, AL); 7742 break; 7743 case ParsedAttr::AT_AVRSignal: 7744 handleAVRSignalAttr(S, D, AL); 7745 break; 7746 case ParsedAttr::AT_BPFPreserveAccessIndex: 7747 handleBPFPreserveAccessIndexAttr(S, D, AL); 7748 break; 7749 case ParsedAttr::AT_WebAssemblyExportName: 7750 handleWebAssemblyExportNameAttr(S, D, AL); 7751 break; 7752 case ParsedAttr::AT_WebAssemblyImportModule: 7753 handleWebAssemblyImportModuleAttr(S, D, AL); 7754 break; 7755 case ParsedAttr::AT_WebAssemblyImportName: 7756 handleWebAssemblyImportNameAttr(S, D, AL); 7757 break; 7758 case ParsedAttr::AT_IBOutlet: 7759 handleIBOutlet(S, D, AL); 7760 break; 7761 case ParsedAttr::AT_IBOutletCollection: 7762 handleIBOutletCollection(S, D, AL); 7763 break; 7764 case ParsedAttr::AT_IFunc: 7765 handleIFuncAttr(S, D, AL); 7766 break; 7767 case ParsedAttr::AT_Alias: 7768 handleAliasAttr(S, D, AL); 7769 break; 7770 case ParsedAttr::AT_Aligned: 7771 handleAlignedAttr(S, D, AL); 7772 break; 7773 case ParsedAttr::AT_AlignValue: 7774 handleAlignValueAttr(S, D, AL); 7775 break; 7776 case ParsedAttr::AT_AllocSize: 7777 handleAllocSizeAttr(S, D, AL); 7778 break; 7779 case ParsedAttr::AT_AlwaysInline: 7780 handleAlwaysInlineAttr(S, D, AL); 7781 break; 7782 case ParsedAttr::AT_AnalyzerNoReturn: 7783 handleAnalyzerNoReturnAttr(S, D, AL); 7784 break; 7785 case ParsedAttr::AT_TLSModel: 7786 handleTLSModelAttr(S, D, AL); 7787 break; 7788 case ParsedAttr::AT_Annotate: 7789 handleAnnotateAttr(S, D, AL); 7790 break; 7791 case ParsedAttr::AT_Availability: 7792 handleAvailabilityAttr(S, D, AL); 7793 break; 7794 case ParsedAttr::AT_CarriesDependency: 7795 handleDependencyAttr(S, scope, D, AL); 7796 break; 7797 case ParsedAttr::AT_CPUDispatch: 7798 case ParsedAttr::AT_CPUSpecific: 7799 handleCPUSpecificAttr(S, D, AL); 7800 break; 7801 case ParsedAttr::AT_Common: 7802 handleCommonAttr(S, D, AL); 7803 break; 7804 case ParsedAttr::AT_CUDAConstant: 7805 handleConstantAttr(S, D, AL); 7806 break; 7807 case ParsedAttr::AT_PassObjectSize: 7808 handlePassObjectSizeAttr(S, D, AL); 7809 break; 7810 case ParsedAttr::AT_Constructor: 7811 handleConstructorAttr(S, D, AL); 7812 break; 7813 case ParsedAttr::AT_Deprecated: 7814 handleDeprecatedAttr(S, D, AL); 7815 break; 7816 case ParsedAttr::AT_Destructor: 7817 handleDestructorAttr(S, D, AL); 7818 break; 7819 case ParsedAttr::AT_EnableIf: 7820 handleEnableIfAttr(S, D, AL); 7821 break; 7822 case ParsedAttr::AT_DiagnoseIf: 7823 handleDiagnoseIfAttr(S, D, AL); 7824 break; 7825 case ParsedAttr::AT_NoBuiltin: 7826 handleNoBuiltinAttr(S, D, AL); 7827 break; 7828 case ParsedAttr::AT_ExtVectorType: 7829 handleExtVectorTypeAttr(S, D, AL); 7830 break; 7831 case ParsedAttr::AT_ExternalSourceSymbol: 7832 handleExternalSourceSymbolAttr(S, D, AL); 7833 break; 7834 case ParsedAttr::AT_MinSize: 7835 handleMinSizeAttr(S, D, AL); 7836 break; 7837 case ParsedAttr::AT_OptimizeNone: 7838 handleOptimizeNoneAttr(S, D, AL); 7839 break; 7840 case ParsedAttr::AT_EnumExtensibility: 7841 handleEnumExtensibilityAttr(S, D, AL); 7842 break; 7843 case ParsedAttr::AT_SYCLKernel: 7844 handleSYCLKernelAttr(S, D, AL); 7845 break; 7846 case ParsedAttr::AT_Format: 7847 handleFormatAttr(S, D, AL); 7848 break; 7849 case ParsedAttr::AT_FormatArg: 7850 handleFormatArgAttr(S, D, AL); 7851 break; 7852 case ParsedAttr::AT_Callback: 7853 handleCallbackAttr(S, D, AL); 7854 break; 7855 case ParsedAttr::AT_CalledOnce: 7856 handleCalledOnceAttr(S, D, AL); 7857 break; 7858 case ParsedAttr::AT_CUDAGlobal: 7859 handleGlobalAttr(S, D, AL); 7860 break; 7861 case ParsedAttr::AT_CUDADevice: 7862 handleDeviceAttr(S, D, AL); 7863 break; 7864 case ParsedAttr::AT_HIPManaged: 7865 handleManagedAttr(S, D, AL); 7866 break; 7867 case ParsedAttr::AT_GNUInline: 7868 handleGNUInlineAttr(S, D, AL); 7869 break; 7870 case ParsedAttr::AT_CUDALaunchBounds: 7871 handleLaunchBoundsAttr(S, D, AL); 7872 break; 7873 case ParsedAttr::AT_Restrict: 7874 handleRestrictAttr(S, D, AL); 7875 break; 7876 case ParsedAttr::AT_Mode: 7877 handleModeAttr(S, D, AL); 7878 break; 7879 case ParsedAttr::AT_NonNull: 7880 if (auto *PVD = dyn_cast<ParmVarDecl>(D)) 7881 handleNonNullAttrParameter(S, PVD, AL); 7882 else 7883 handleNonNullAttr(S, D, AL); 7884 break; 7885 case ParsedAttr::AT_ReturnsNonNull: 7886 handleReturnsNonNullAttr(S, D, AL); 7887 break; 7888 case ParsedAttr::AT_NoEscape: 7889 handleNoEscapeAttr(S, D, AL); 7890 break; 7891 case ParsedAttr::AT_AssumeAligned: 7892 handleAssumeAlignedAttr(S, D, AL); 7893 break; 7894 case ParsedAttr::AT_AllocAlign: 7895 handleAllocAlignAttr(S, D, AL); 7896 break; 7897 case ParsedAttr::AT_Ownership: 7898 handleOwnershipAttr(S, D, AL); 7899 break; 7900 case ParsedAttr::AT_Naked: 7901 handleNakedAttr(S, D, AL); 7902 break; 7903 case ParsedAttr::AT_NoReturn: 7904 handleNoReturnAttr(S, D, AL); 7905 break; 7906 case ParsedAttr::AT_AnyX86NoCfCheck: 7907 handleNoCfCheckAttr(S, D, AL); 7908 break; 7909 case ParsedAttr::AT_NoThrow: 7910 if (!AL.isUsedAsTypeAttr()) 7911 handleSimpleAttribute<NoThrowAttr>(S, D, AL); 7912 break; 7913 case ParsedAttr::AT_CUDAShared: 7914 handleSharedAttr(S, D, AL); 7915 break; 7916 case ParsedAttr::AT_VecReturn: 7917 handleVecReturnAttr(S, D, AL); 7918 break; 7919 case ParsedAttr::AT_ObjCOwnership: 7920 handleObjCOwnershipAttr(S, D, AL); 7921 break; 7922 case ParsedAttr::AT_ObjCPreciseLifetime: 7923 handleObjCPreciseLifetimeAttr(S, D, AL); 7924 break; 7925 case ParsedAttr::AT_ObjCReturnsInnerPointer: 7926 handleObjCReturnsInnerPointerAttr(S, D, AL); 7927 break; 7928 case ParsedAttr::AT_ObjCRequiresSuper: 7929 handleObjCRequiresSuperAttr(S, D, AL); 7930 break; 7931 case ParsedAttr::AT_ObjCBridge: 7932 handleObjCBridgeAttr(S, D, AL); 7933 break; 7934 case ParsedAttr::AT_ObjCBridgeMutable: 7935 handleObjCBridgeMutableAttr(S, D, AL); 7936 break; 7937 case ParsedAttr::AT_ObjCBridgeRelated: 7938 handleObjCBridgeRelatedAttr(S, D, AL); 7939 break; 7940 case ParsedAttr::AT_ObjCDesignatedInitializer: 7941 handleObjCDesignatedInitializer(S, D, AL); 7942 break; 7943 case ParsedAttr::AT_ObjCRuntimeName: 7944 handleObjCRuntimeName(S, D, AL); 7945 break; 7946 case ParsedAttr::AT_ObjCBoxable: 7947 handleObjCBoxable(S, D, AL); 7948 break; 7949 case ParsedAttr::AT_NSErrorDomain: 7950 handleNSErrorDomain(S, D, AL); 7951 break; 7952 case ParsedAttr::AT_CFConsumed: 7953 case ParsedAttr::AT_NSConsumed: 7954 case ParsedAttr::AT_OSConsumed: 7955 S.AddXConsumedAttr(D, AL, parsedAttrToRetainOwnershipKind(AL), 7956 /*IsTemplateInstantiation=*/false); 7957 break; 7958 case ParsedAttr::AT_OSReturnsRetainedOnZero: 7959 handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnZeroAttr>( 7960 S, D, AL, isValidOSObjectOutParameter(D), 7961 diag::warn_ns_attribute_wrong_parameter_type, 7962 /*Extra Args=*/AL, /*pointer-to-OSObject-pointer*/ 3, AL.getRange()); 7963 break; 7964 case ParsedAttr::AT_OSReturnsRetainedOnNonZero: 7965 handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnNonZeroAttr>( 7966 S, D, AL, isValidOSObjectOutParameter(D), 7967 diag::warn_ns_attribute_wrong_parameter_type, 7968 /*Extra Args=*/AL, /*pointer-to-OSObject-poointer*/ 3, AL.getRange()); 7969 break; 7970 case ParsedAttr::AT_NSReturnsAutoreleased: 7971 case ParsedAttr::AT_NSReturnsNotRetained: 7972 case ParsedAttr::AT_NSReturnsRetained: 7973 case ParsedAttr::AT_CFReturnsNotRetained: 7974 case ParsedAttr::AT_CFReturnsRetained: 7975 case ParsedAttr::AT_OSReturnsNotRetained: 7976 case ParsedAttr::AT_OSReturnsRetained: 7977 handleXReturnsXRetainedAttr(S, D, AL); 7978 break; 7979 case ParsedAttr::AT_WorkGroupSizeHint: 7980 handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, AL); 7981 break; 7982 case ParsedAttr::AT_ReqdWorkGroupSize: 7983 handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, AL); 7984 break; 7985 case ParsedAttr::AT_OpenCLIntelReqdSubGroupSize: 7986 handleSubGroupSize(S, D, AL); 7987 break; 7988 case ParsedAttr::AT_VecTypeHint: 7989 handleVecTypeHint(S, D, AL); 7990 break; 7991 case ParsedAttr::AT_InitPriority: 7992 handleInitPriorityAttr(S, D, AL); 7993 break; 7994 case ParsedAttr::AT_Packed: 7995 handlePackedAttr(S, D, AL); 7996 break; 7997 case ParsedAttr::AT_PreferredName: 7998 handlePreferredName(S, D, AL); 7999 break; 8000 case ParsedAttr::AT_Section: 8001 handleSectionAttr(S, D, AL); 8002 break; 8003 case ParsedAttr::AT_CodeSeg: 8004 handleCodeSegAttr(S, D, AL); 8005 break; 8006 case ParsedAttr::AT_Target: 8007 handleTargetAttr(S, D, AL); 8008 break; 8009 case ParsedAttr::AT_MinVectorWidth: 8010 handleMinVectorWidthAttr(S, D, AL); 8011 break; 8012 case ParsedAttr::AT_Unavailable: 8013 handleAttrWithMessage<UnavailableAttr>(S, D, AL); 8014 break; 8015 case ParsedAttr::AT_Assumption: 8016 handleAssumumptionAttr(S, D, AL); 8017 break; 8018 case ParsedAttr::AT_ObjCDirect: 8019 handleObjCDirectAttr(S, D, AL); 8020 break; 8021 case ParsedAttr::AT_ObjCDirectMembers: 8022 handleObjCDirectMembersAttr(S, D, AL); 8023 handleSimpleAttribute<ObjCDirectMembersAttr>(S, D, AL); 8024 break; 8025 case ParsedAttr::AT_ObjCExplicitProtocolImpl: 8026 handleObjCSuppresProtocolAttr(S, D, AL); 8027 break; 8028 case ParsedAttr::AT_Unused: 8029 handleUnusedAttr(S, D, AL); 8030 break; 8031 case ParsedAttr::AT_Visibility: 8032 handleVisibilityAttr(S, D, AL, false); 8033 break; 8034 case ParsedAttr::AT_TypeVisibility: 8035 handleVisibilityAttr(S, D, AL, true); 8036 break; 8037 case ParsedAttr::AT_WarnUnusedResult: 8038 handleWarnUnusedResult(S, D, AL); 8039 break; 8040 case ParsedAttr::AT_WeakRef: 8041 handleWeakRefAttr(S, D, AL); 8042 break; 8043 case ParsedAttr::AT_WeakImport: 8044 handleWeakImportAttr(S, D, AL); 8045 break; 8046 case ParsedAttr::AT_TransparentUnion: 8047 handleTransparentUnionAttr(S, D, AL); 8048 break; 8049 case ParsedAttr::AT_ObjCMethodFamily: 8050 handleObjCMethodFamilyAttr(S, D, AL); 8051 break; 8052 case ParsedAttr::AT_ObjCNSObject: 8053 handleObjCNSObject(S, D, AL); 8054 break; 8055 case ParsedAttr::AT_ObjCIndependentClass: 8056 handleObjCIndependentClass(S, D, AL); 8057 break; 8058 case ParsedAttr::AT_Blocks: 8059 handleBlocksAttr(S, D, AL); 8060 break; 8061 case ParsedAttr::AT_Sentinel: 8062 handleSentinelAttr(S, D, AL); 8063 break; 8064 case ParsedAttr::AT_Cleanup: 8065 handleCleanupAttr(S, D, AL); 8066 break; 8067 case ParsedAttr::AT_NoDebug: 8068 handleNoDebugAttr(S, D, AL); 8069 break; 8070 case ParsedAttr::AT_CmseNSEntry: 8071 handleCmseNSEntryAttr(S, D, AL); 8072 break; 8073 case ParsedAttr::AT_StdCall: 8074 case ParsedAttr::AT_CDecl: 8075 case ParsedAttr::AT_FastCall: 8076 case ParsedAttr::AT_ThisCall: 8077 case ParsedAttr::AT_Pascal: 8078 case ParsedAttr::AT_RegCall: 8079 case ParsedAttr::AT_SwiftCall: 8080 case ParsedAttr::AT_VectorCall: 8081 case ParsedAttr::AT_MSABI: 8082 case ParsedAttr::AT_SysVABI: 8083 case ParsedAttr::AT_Pcs: 8084 case ParsedAttr::AT_IntelOclBicc: 8085 case ParsedAttr::AT_PreserveMost: 8086 case ParsedAttr::AT_PreserveAll: 8087 case ParsedAttr::AT_AArch64VectorPcs: 8088 handleCallConvAttr(S, D, AL); 8089 break; 8090 case ParsedAttr::AT_Suppress: 8091 handleSuppressAttr(S, D, AL); 8092 break; 8093 case ParsedAttr::AT_Owner: 8094 case ParsedAttr::AT_Pointer: 8095 handleLifetimeCategoryAttr(S, D, AL); 8096 break; 8097 case ParsedAttr::AT_OpenCLAccess: 8098 handleOpenCLAccessAttr(S, D, AL); 8099 break; 8100 case ParsedAttr::AT_OpenCLNoSVM: 8101 handleOpenCLNoSVMAttr(S, D, AL); 8102 break; 8103 case ParsedAttr::AT_SwiftContext: 8104 S.AddParameterABIAttr(D, AL, ParameterABI::SwiftContext); 8105 break; 8106 case ParsedAttr::AT_SwiftErrorResult: 8107 S.AddParameterABIAttr(D, AL, ParameterABI::SwiftErrorResult); 8108 break; 8109 case ParsedAttr::AT_SwiftIndirectResult: 8110 S.AddParameterABIAttr(D, AL, ParameterABI::SwiftIndirectResult); 8111 break; 8112 case ParsedAttr::AT_InternalLinkage: 8113 handleInternalLinkageAttr(S, D, AL); 8114 break; 8115 8116 // Microsoft attributes: 8117 case ParsedAttr::AT_LayoutVersion: 8118 handleLayoutVersion(S, D, AL); 8119 break; 8120 case ParsedAttr::AT_Uuid: 8121 handleUuidAttr(S, D, AL); 8122 break; 8123 case ParsedAttr::AT_MSInheritance: 8124 handleMSInheritanceAttr(S, D, AL); 8125 break; 8126 case ParsedAttr::AT_Thread: 8127 handleDeclspecThreadAttr(S, D, AL); 8128 break; 8129 8130 case ParsedAttr::AT_AbiTag: 8131 handleAbiTagAttr(S, D, AL); 8132 break; 8133 case ParsedAttr::AT_CFGuard: 8134 handleCFGuardAttr(S, D, AL); 8135 break; 8136 8137 // Thread safety attributes: 8138 case ParsedAttr::AT_AssertExclusiveLock: 8139 handleAssertExclusiveLockAttr(S, D, AL); 8140 break; 8141 case ParsedAttr::AT_AssertSharedLock: 8142 handleAssertSharedLockAttr(S, D, AL); 8143 break; 8144 case ParsedAttr::AT_PtGuardedVar: 8145 handlePtGuardedVarAttr(S, D, AL); 8146 break; 8147 case ParsedAttr::AT_NoSanitize: 8148 handleNoSanitizeAttr(S, D, AL); 8149 break; 8150 case ParsedAttr::AT_NoSanitizeSpecific: 8151 handleNoSanitizeSpecificAttr(S, D, AL); 8152 break; 8153 case ParsedAttr::AT_GuardedBy: 8154 handleGuardedByAttr(S, D, AL); 8155 break; 8156 case ParsedAttr::AT_PtGuardedBy: 8157 handlePtGuardedByAttr(S, D, AL); 8158 break; 8159 case ParsedAttr::AT_ExclusiveTrylockFunction: 8160 handleExclusiveTrylockFunctionAttr(S, D, AL); 8161 break; 8162 case ParsedAttr::AT_LockReturned: 8163 handleLockReturnedAttr(S, D, AL); 8164 break; 8165 case ParsedAttr::AT_LocksExcluded: 8166 handleLocksExcludedAttr(S, D, AL); 8167 break; 8168 case ParsedAttr::AT_SharedTrylockFunction: 8169 handleSharedTrylockFunctionAttr(S, D, AL); 8170 break; 8171 case ParsedAttr::AT_AcquiredBefore: 8172 handleAcquiredBeforeAttr(S, D, AL); 8173 break; 8174 case ParsedAttr::AT_AcquiredAfter: 8175 handleAcquiredAfterAttr(S, D, AL); 8176 break; 8177 8178 // Capability analysis attributes. 8179 case ParsedAttr::AT_Capability: 8180 case ParsedAttr::AT_Lockable: 8181 handleCapabilityAttr(S, D, AL); 8182 break; 8183 case ParsedAttr::AT_RequiresCapability: 8184 handleRequiresCapabilityAttr(S, D, AL); 8185 break; 8186 8187 case ParsedAttr::AT_AssertCapability: 8188 handleAssertCapabilityAttr(S, D, AL); 8189 break; 8190 case ParsedAttr::AT_AcquireCapability: 8191 handleAcquireCapabilityAttr(S, D, AL); 8192 break; 8193 case ParsedAttr::AT_ReleaseCapability: 8194 handleReleaseCapabilityAttr(S, D, AL); 8195 break; 8196 case ParsedAttr::AT_TryAcquireCapability: 8197 handleTryAcquireCapabilityAttr(S, D, AL); 8198 break; 8199 8200 // Consumed analysis attributes. 8201 case ParsedAttr::AT_Consumable: 8202 handleConsumableAttr(S, D, AL); 8203 break; 8204 case ParsedAttr::AT_CallableWhen: 8205 handleCallableWhenAttr(S, D, AL); 8206 break; 8207 case ParsedAttr::AT_ParamTypestate: 8208 handleParamTypestateAttr(S, D, AL); 8209 break; 8210 case ParsedAttr::AT_ReturnTypestate: 8211 handleReturnTypestateAttr(S, D, AL); 8212 break; 8213 case ParsedAttr::AT_SetTypestate: 8214 handleSetTypestateAttr(S, D, AL); 8215 break; 8216 case ParsedAttr::AT_TestTypestate: 8217 handleTestTypestateAttr(S, D, AL); 8218 break; 8219 8220 // Type safety attributes. 8221 case ParsedAttr::AT_ArgumentWithTypeTag: 8222 handleArgumentWithTypeTagAttr(S, D, AL); 8223 break; 8224 case ParsedAttr::AT_TypeTagForDatatype: 8225 handleTypeTagForDatatypeAttr(S, D, AL); 8226 break; 8227 8228 // Swift attributes. 8229 case ParsedAttr::AT_SwiftAsyncName: 8230 handleSwiftAsyncName(S, D, AL); 8231 break; 8232 case ParsedAttr::AT_SwiftAttr: 8233 handleSwiftAttrAttr(S, D, AL); 8234 break; 8235 case ParsedAttr::AT_SwiftBridge: 8236 handleSwiftBridge(S, D, AL); 8237 break; 8238 case ParsedAttr::AT_SwiftError: 8239 handleSwiftError(S, D, AL); 8240 break; 8241 case ParsedAttr::AT_SwiftName: 8242 handleSwiftName(S, D, AL); 8243 break; 8244 case ParsedAttr::AT_SwiftNewType: 8245 handleSwiftNewType(S, D, AL); 8246 break; 8247 case ParsedAttr::AT_SwiftAsync: 8248 handleSwiftAsyncAttr(S, D, AL); 8249 break; 8250 case ParsedAttr::AT_SwiftAsyncError: 8251 handleSwiftAsyncError(S, D, AL); 8252 break; 8253 8254 // XRay attributes. 8255 case ParsedAttr::AT_XRayLogArgs: 8256 handleXRayLogArgsAttr(S, D, AL); 8257 break; 8258 8259 case ParsedAttr::AT_PatchableFunctionEntry: 8260 handlePatchableFunctionEntryAttr(S, D, AL); 8261 break; 8262 8263 case ParsedAttr::AT_AlwaysDestroy: 8264 case ParsedAttr::AT_NoDestroy: 8265 handleDestroyAttr(S, D, AL); 8266 break; 8267 8268 case ParsedAttr::AT_Uninitialized: 8269 handleUninitializedAttr(S, D, AL); 8270 break; 8271 8272 case ParsedAttr::AT_ObjCExternallyRetained: 8273 handleObjCExternallyRetainedAttr(S, D, AL); 8274 break; 8275 8276 case ParsedAttr::AT_MIGServerRoutine: 8277 handleMIGServerRoutineAttr(S, D, AL); 8278 break; 8279 8280 case ParsedAttr::AT_MSAllocator: 8281 handleMSAllocatorAttr(S, D, AL); 8282 break; 8283 8284 case ParsedAttr::AT_ArmBuiltinAlias: 8285 handleArmBuiltinAliasAttr(S, D, AL); 8286 break; 8287 8288 case ParsedAttr::AT_AcquireHandle: 8289 handleAcquireHandleAttr(S, D, AL); 8290 break; 8291 8292 case ParsedAttr::AT_ReleaseHandle: 8293 handleHandleAttr<ReleaseHandleAttr>(S, D, AL); 8294 break; 8295 8296 case ParsedAttr::AT_UseHandle: 8297 handleHandleAttr<UseHandleAttr>(S, D, AL); 8298 break; 8299 8300 case ParsedAttr::AT_EnforceTCB: 8301 handleEnforceTCBAttr<EnforceTCBAttr, EnforceTCBLeafAttr>(S, D, AL); 8302 break; 8303 8304 case ParsedAttr::AT_EnforceTCBLeaf: 8305 handleEnforceTCBAttr<EnforceTCBLeafAttr, EnforceTCBAttr>(S, D, AL); 8306 break; 8307 8308 case ParsedAttr::AT_BuiltinAlias: 8309 handleBuiltinAliasAttr(S, D, AL); 8310 break; 8311 } 8312} 8313 8314/// ProcessDeclAttributeList - Apply all the decl attributes in the specified 8315/// attribute list to the specified decl, ignoring any type attributes. 8316void Sema::ProcessDeclAttributeList(Scope *S, Decl *D, 8317 const ParsedAttributesView &AttrList, 8318 bool IncludeCXX11Attributes) { 8319 if (AttrList.empty()) 8320 return; 8321 8322 for (const ParsedAttr &AL : AttrList) 8323 ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes); 8324 8325 // FIXME: We should be able to handle these cases in TableGen. 8326 // GCC accepts 8327 // static int a9 __attribute__((weakref)); 8328 // but that looks really pointless. We reject it. 8329 if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) { 8330 Diag(AttrList.begin()->getLoc(), diag::err_attribute_weakref_without_alias) 8331 << cast<NamedDecl>(D); 8332 D->dropAttr<WeakRefAttr>(); 8333 return; 8334 } 8335 8336 // FIXME: We should be able to handle this in TableGen as well. It would be 8337 // good to have a way to specify "these attributes must appear as a group", 8338 // for these. Additionally, it would be good to have a way to specify "these 8339 // attribute must never appear as a group" for attributes like cold and hot. 8340 if (!D->hasAttr<OpenCLKernelAttr>()) { 8341 // These attributes cannot be applied to a non-kernel function. 8342 if (const auto *A = D->getAttr<ReqdWorkGroupSizeAttr>()) { 8343 // FIXME: This emits a different error message than 8344 // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction. 8345 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A; 8346 D->setInvalidDecl(); 8347 } else if (const auto *A = D->getAttr<WorkGroupSizeHintAttr>()) { 8348 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A; 8349 D->setInvalidDecl(); 8350 } else if (const auto *A = D->getAttr<VecTypeHintAttr>()) { 8351 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A; 8352 D->setInvalidDecl(); 8353 } else if (const auto *A = D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) { 8354 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A; 8355 D->setInvalidDecl(); 8356 } else if (!D->hasAttr<CUDAGlobalAttr>()) { 8357 if (const auto *A = D->getAttr<AMDGPUFlatWorkGroupSizeAttr>()) { 8358 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 8359 << A << ExpectedKernelFunction; 8360 D->setInvalidDecl(); 8361 } else if (const auto *A = D->getAttr<AMDGPUWavesPerEUAttr>()) { 8362 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 8363 << A << ExpectedKernelFunction; 8364 D->setInvalidDecl(); 8365 } else if (const auto *A = D->getAttr<AMDGPUNumSGPRAttr>()) { 8366 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 8367 << A << ExpectedKernelFunction; 8368 D->setInvalidDecl(); 8369 } else if (const auto *A = D->getAttr<AMDGPUNumVGPRAttr>()) { 8370 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) 8371 << A << ExpectedKernelFunction; 8372 D->setInvalidDecl(); 8373 } 8374 } 8375 } 8376 8377 // Do this check after processing D's attributes because the attribute 8378 // objc_method_family can change whether the given method is in the init 8379 // family, and it can be applied after objc_designated_initializer. This is a 8380 // bit of a hack, but we need it to be compatible with versions of clang that 8381 // processed the attribute list in the wrong order. 8382 if (D->hasAttr<ObjCDesignatedInitializerAttr>() && 8383 cast<ObjCMethodDecl>(D)->getMethodFamily() != OMF_init) { 8384 Diag(D->getLocation(), diag::err_designated_init_attr_non_init); 8385 D->dropAttr<ObjCDesignatedInitializerAttr>(); 8386 } 8387} 8388 8389// Helper for delayed processing TransparentUnion or BPFPreserveAccessIndexAttr 8390// attribute. 8391void Sema::ProcessDeclAttributeDelayed(Decl *D, 8392 const ParsedAttributesView &AttrList) { 8393 for (const ParsedAttr &AL : AttrList) 8394 if (AL.getKind() == ParsedAttr::AT_TransparentUnion) { 8395 handleTransparentUnionAttr(*this, D, AL); 8396 break; 8397 } 8398 8399 // For BPFPreserveAccessIndexAttr, we want to populate the attributes 8400 // to fields and inner records as well. 8401 if (D && D->hasAttr<BPFPreserveAccessIndexAttr>()) 8402 handleBPFPreserveAIRecord(*this, cast<RecordDecl>(D)); 8403} 8404 8405// Annotation attributes are the only attributes allowed after an access 8406// specifier. 8407bool Sema::ProcessAccessDeclAttributeList( 8408 AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList) { 8409 for (const ParsedAttr &AL : AttrList) { 8410 if (AL.getKind() == ParsedAttr::AT_Annotate) { 8411 ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute()); 8412 } else { 8413 Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec); 8414 return true; 8415 } 8416 } 8417 return false; 8418} 8419 8420/// checkUnusedDeclAttributes - Check a list of attributes to see if it 8421/// contains any decl attributes that we should warn about. 8422static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A) { 8423 for (const ParsedAttr &AL : A) { 8424 // Only warn if the attribute is an unignored, non-type attribute. 8425 if (AL.isUsedAsTypeAttr() || AL.isInvalid()) 8426 continue; 8427 if (AL.getKind() == ParsedAttr::IgnoredAttribute) 8428 continue; 8429 8430 if (AL.getKind() == ParsedAttr::UnknownAttribute) { 8431 S.Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) 8432 << AL << AL.getRange(); 8433 } else { 8434 S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL 8435 << AL.getRange(); 8436 } 8437 } 8438} 8439 8440/// checkUnusedDeclAttributes - Given a declarator which is not being 8441/// used to build a declaration, complain about any decl attributes 8442/// which might be lying around on it. 8443void Sema::checkUnusedDeclAttributes(Declarator &D) { 8444 ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes()); 8445 ::checkUnusedDeclAttributes(*this, D.getAttributes()); 8446 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) 8447 ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs()); 8448} 8449 8450/// DeclClonePragmaWeak - clone existing decl (maybe definition), 8451/// \#pragma weak needs a non-definition decl and source may not have one. 8452NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II, 8453 SourceLocation Loc) { 8454 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND)); 8455 NamedDecl *NewD = nullptr; 8456 if (auto *FD = dyn_cast<FunctionDecl>(ND)) { 8457 FunctionDecl *NewFD; 8458 // FIXME: Missing call to CheckFunctionDeclaration(). 8459 // FIXME: Mangling? 8460 // FIXME: Is the qualifier info correct? 8461 // FIXME: Is the DeclContext correct? 8462 NewFD = FunctionDecl::Create( 8463 FD->getASTContext(), FD->getDeclContext(), Loc, Loc, 8464 DeclarationName(II), FD->getType(), FD->getTypeSourceInfo(), SC_None, 8465 false /*isInlineSpecified*/, FD->hasPrototype(), 8466 ConstexprSpecKind::Unspecified, FD->getTrailingRequiresClause()); 8467 NewD = NewFD; 8468 8469 if (FD->getQualifier()) 8470 NewFD->setQualifierInfo(FD->getQualifierLoc()); 8471 8472 // Fake up parameter variables; they are declared as if this were 8473 // a typedef. 8474 QualType FDTy = FD->getType(); 8475 if (const auto *FT = FDTy->getAs<FunctionProtoType>()) { 8476 SmallVector<ParmVarDecl*, 16> Params; 8477 for (const auto &AI : FT->param_types()) { 8478 ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI); 8479 Param->setScopeInfo(0, Params.size()); 8480 Params.push_back(Param); 8481 } 8482 NewFD->setParams(Params); 8483 } 8484 } else if (auto *VD = dyn_cast<VarDecl>(ND)) { 8485 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(), 8486 VD->getInnerLocStart(), VD->getLocation(), II, 8487 VD->getType(), VD->getTypeSourceInfo(), 8488 VD->getStorageClass()); 8489 if (VD->getQualifier()) 8490 cast<VarDecl>(NewD)->setQualifierInfo(VD->getQualifierLoc()); 8491 } 8492 return NewD; 8493} 8494 8495/// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak 8496/// applied to it, possibly with an alias. 8497void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) { 8498 if (W.getUsed()) return; // only do this once 8499 W.setUsed(true); 8500 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...)) 8501 IdentifierInfo *NDId = ND->getIdentifier(); 8502 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation()); 8503 NewD->addAttr( 8504 AliasAttr::CreateImplicit(Context, NDId->getName(), W.getLocation())); 8505 NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation(), 8506 AttributeCommonInfo::AS_Pragma)); 8507 WeakTopLevelDecl.push_back(NewD); 8508 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin 8509 // to insert Decl at TU scope, sorry. 8510 DeclContext *SavedContext = CurContext; 8511 CurContext = Context.getTranslationUnitDecl(); 8512 NewD->setDeclContext(CurContext); 8513 NewD->setLexicalDeclContext(CurContext); 8514 PushOnScopeChains(NewD, S); 8515 CurContext = SavedContext; 8516 } else { // just add weak to existing 8517 ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation(), 8518 AttributeCommonInfo::AS_Pragma)); 8519 } 8520} 8521 8522void Sema::ProcessPragmaWeak(Scope *S, Decl *D) { 8523 // It's valid to "forward-declare" #pragma weak, in which case we 8524 // have to do this. 8525 LoadExternalWeakUndeclaredIdentifiers(); 8526 if (!WeakUndeclaredIdentifiers.empty()) { 8527 NamedDecl *ND = nullptr; 8528 if (auto *VD = dyn_cast<VarDecl>(D)) 8529 if (VD->isExternC()) 8530 ND = VD; 8531 if (auto *FD = dyn_cast<FunctionDecl>(D)) 8532 if (FD->isExternC()) 8533 ND = FD; 8534 if (ND) { 8535 if (IdentifierInfo *Id = ND->getIdentifier()) { 8536 auto I = WeakUndeclaredIdentifiers.find(Id); 8537 if (I != WeakUndeclaredIdentifiers.end()) { 8538 WeakInfo W = I->second; 8539 DeclApplyPragmaWeak(S, ND, W); 8540 WeakUndeclaredIdentifiers[Id] = W; 8541 } 8542 } 8543 } 8544 } 8545} 8546 8547/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in 8548/// it, apply them to D. This is a bit tricky because PD can have attributes 8549/// specified in many different places, and we need to find and apply them all. 8550void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) { 8551 // Apply decl attributes from the DeclSpec if present. 8552 if (!PD.getDeclSpec().getAttributes().empty()) 8553 ProcessDeclAttributeList(S, D, PD.getDeclSpec().getAttributes()); 8554 8555 // Walk the declarator structure, applying decl attributes that were in a type 8556 // position to the decl itself. This handles cases like: 8557 // int *__attr__(x)** D; 8558 // when X is a decl attribute. 8559 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i) 8560 ProcessDeclAttributeList(S, D, PD.getTypeObject(i).getAttrs(), 8561 /*IncludeCXX11Attributes=*/false); 8562 8563 // Finally, apply any attributes on the decl itself. 8564 ProcessDeclAttributeList(S, D, PD.getAttributes()); 8565 8566 // Apply additional attributes specified by '#pragma clang attribute'. 8567 AddPragmaAttributes(S, D); 8568} 8569 8570/// Is the given declaration allowed to use a forbidden type? 8571/// If so, it'll still be annotated with an attribute that makes it 8572/// illegal to actually use. 8573static bool isForbiddenTypeAllowed(Sema &S, Decl *D, 8574 const DelayedDiagnostic &diag, 8575 UnavailableAttr::ImplicitReason &reason) { 8576 // Private ivars are always okay. Unfortunately, people don't 8577 // always properly make their ivars private, even in system headers. 8578 // Plus we need to make fields okay, too. 8579 if (!isa<FieldDecl>(D) && !isa<ObjCPropertyDecl>(D) && 8580 !isa<FunctionDecl>(D)) 8581 return false; 8582 8583 // Silently accept unsupported uses of __weak in both user and system 8584 // declarations when it's been disabled, for ease of integration with 8585 // -fno-objc-arc files. We do have to take some care against attempts 8586 // to define such things; for now, we've only done that for ivars 8587 // and properties. 8588 if ((isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) { 8589 if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled || 8590 diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) { 8591 reason = UnavailableAttr::IR_ForbiddenWeak; 8592 return true; 8593 } 8594 } 8595 8596 // Allow all sorts of things in system headers. 8597 if (S.Context.getSourceManager().isInSystemHeader(D->getLocation())) { 8598 // Currently, all the failures dealt with this way are due to ARC 8599 // restrictions. 8600 reason = UnavailableAttr::IR_ARCForbiddenType; 8601 return true; 8602 } 8603 8604 return false; 8605} 8606 8607/// Handle a delayed forbidden-type diagnostic. 8608static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &DD, 8609 Decl *D) { 8610 auto Reason = UnavailableAttr::IR_None; 8611 if (D && isForbiddenTypeAllowed(S, D, DD, Reason)) { 8612 assert(Reason && "didn't set reason?"); 8613 D->addAttr(UnavailableAttr::CreateImplicit(S.Context, "", Reason, DD.Loc)); 8614 return; 8615 } 8616 if (S.getLangOpts().ObjCAutoRefCount) 8617 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 8618 // FIXME: we may want to suppress diagnostics for all 8619 // kind of forbidden type messages on unavailable functions. 8620 if (FD->hasAttr<UnavailableAttr>() && 8621 DD.getForbiddenTypeDiagnostic() == 8622 diag::err_arc_array_param_no_ownership) { 8623 DD.Triggered = true; 8624 return; 8625 } 8626 } 8627 8628 S.Diag(DD.Loc, DD.getForbiddenTypeDiagnostic()) 8629 << DD.getForbiddenTypeOperand() << DD.getForbiddenTypeArgument(); 8630 DD.Triggered = true; 8631} 8632 8633 8634void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) { 8635 assert(DelayedDiagnostics.getCurrentPool()); 8636 DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool(); 8637 DelayedDiagnostics.popWithoutEmitting(state); 8638 8639 // When delaying diagnostics to run in the context of a parsed 8640 // declaration, we only want to actually emit anything if parsing 8641 // succeeds. 8642 if (!decl) return; 8643 8644 // We emit all the active diagnostics in this pool or any of its 8645 // parents. In general, we'll get one pool for the decl spec 8646 // and a child pool for each declarator; in a decl group like: 8647 // deprecated_typedef foo, *bar, baz(); 8648 // only the declarator pops will be passed decls. This is correct; 8649 // we really do need to consider delayed diagnostics from the decl spec 8650 // for each of the different declarations. 8651 const DelayedDiagnosticPool *pool = &poppedPool; 8652 do { 8653 bool AnyAccessFailures = false; 8654 for (DelayedDiagnosticPool::pool_iterator 8655 i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) { 8656 // This const_cast is a bit lame. Really, Triggered should be mutable. 8657 DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i); 8658 if (diag.Triggered) 8659 continue; 8660 8661 switch (diag.Kind) { 8662 case DelayedDiagnostic::Availability: 8663 // Don't bother giving deprecation/unavailable diagnostics if 8664 // the decl is invalid. 8665 if (!decl->isInvalidDecl()) 8666 handleDelayedAvailabilityCheck(diag, decl); 8667 break; 8668 8669 case DelayedDiagnostic::Access: 8670 // Only produce one access control diagnostic for a structured binding 8671 // declaration: we don't need to tell the user that all the fields are 8672 // inaccessible one at a time. 8673 if (AnyAccessFailures && isa<DecompositionDecl>(decl)) 8674 continue; 8675 HandleDelayedAccessCheck(diag, decl); 8676 if (diag.Triggered) 8677 AnyAccessFailures = true; 8678 break; 8679 8680 case DelayedDiagnostic::ForbiddenType: 8681 handleDelayedForbiddenType(*this, diag, decl); 8682 break; 8683 } 8684 } 8685 } while ((pool = pool->getParent())); 8686} 8687 8688/// Given a set of delayed diagnostics, re-emit them as if they had 8689/// been delayed in the current context instead of in the given pool. 8690/// Essentially, this just moves them to the current pool. 8691void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) { 8692 DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool(); 8693 assert(curPool && "re-emitting in undelayed context not supported"); 8694 curPool->steal(pool); 8695} 8696