| /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| |* *| |
| |* Parsed attribute helpers *| |
| |* *| |
| |* Automatically generated file, do not edit! *| |
| |* *| |
| \*===----------------------------------------------------------------------===*/ |
| |
| static bool defaultAppertainsTo(Sema &, const ParsedAttr &,const Decl *) { |
| return true; |
| } |
| |
| static bool defaultDiagnoseLangOpts(Sema &, const ParsedAttr &) { |
| return true; |
| } |
| |
| static bool defaultTargetRequirements(const TargetInfo &) { |
| return true; |
| } |
| |
| static unsigned defaultSpellingIndexToSemanticSpelling(const ParsedAttr &Attr) { |
| return UINT_MAX; |
| } |
| |
| static bool checkAMDGPUFlatWorkGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "kernel functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAMDGPUFlatWorkGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAMDGPUNumSGPRAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "kernel functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAMDGPUNumSGPR(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAMDGPUNumVGPRAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "kernel functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAMDGPUNumVGPR(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAMDGPUWavesPerEUAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "kernel functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAMDGPUWavesPerEU(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool isTargetarmthumbarmebthumbebavrx86x86_64msp430mipsmipselriscv32riscv64(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::armeb || T.getArch() == llvm::Triple::thumbeb || T.getArch() == llvm::Triple::avr || T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::msp430 || T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::riscv32 || T.getArch() == llvm::Triple::riscv64); |
| } |
| |
| static bool checkAVRSignalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetavr(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::avr); |
| } |
| |
| static void matchRulesForAVRSignal(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool isStruct(const Decl *D) { |
| if (const auto *S = dyn_cast<RecordDecl>(D)) |
| return !S->isUnion(); |
| return false; |
| } |
| |
| static bool checkAbiTagAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isStruct(D) && !isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<NamespaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, variables, functions, and namespaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAbiTag(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus)); |
| } |
| |
| static bool checkAcquireCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned AcquireCapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_acquire_capability = 0, |
| CXX11_clang_acquire_capability = 1, |
| GNU_acquire_shared_capability = 2, |
| CXX11_clang_acquire_shared_capability = 3, |
| GNU_exclusive_lock_function = 4, |
| GNU_shared_lock_function = 5 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_acquire_capability; |
| case 1: return CXX11_clang_acquire_capability; |
| case 2: return GNU_acquire_shared_capability; |
| case 3: return CXX11_clang_acquire_shared_capability; |
| case 4: return GNU_exclusive_lock_function; |
| case 5: return GNU_shared_lock_function; |
| } |
| } |
| |
| static bool isSharedVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return S->hasGlobalStorage() && !S->getTLSKind(); |
| return false; |
| } |
| |
| static bool checkAcquiredAfterAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkAcquiredBeforeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isGlobalVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return S->hasGlobalStorage(); |
| return false; |
| } |
| |
| static bool checkAliasAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAlias(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAlignValueAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<TypedefNameDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables and typedefs"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAlignValue(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true)); |
| } |
| |
| static unsigned AlignedAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_aligned = 0, |
| CXX11_gnu_aligned = 1, |
| Declspec_align = 2, |
| Keyword_alignas = 3, |
| Keyword_Alignas = 4 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_aligned; |
| case 1: return CXX11_gnu_aligned; |
| case 2: return Declspec_align; |
| case 3: return Keyword_alignas; |
| case 4: return Keyword_Alignas; |
| } |
| } |
| |
| static bool isHasFunctionProto(const Decl *D) { |
| if (const auto *S = dyn_cast<Decl>(D)) |
| return (S->getFunctionType(true) != nullptr && |
| isa<FunctionProtoType>(S->getFunctionType())) || |
| isa<ObjCMethodDecl>(S) || |
| isa<BlockDecl>(S); |
| return false; |
| } |
| |
| static bool checkAllocAlignAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isHasFunctionProto(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-K&R-style functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkAllocSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAllocSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAlwaysDestroyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAlwaysDestroy(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAlwaysInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned AlwaysInlineAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_always_inline = 0, |
| CXX11_gnu_always_inline = 1, |
| Keyword_forceinline = 2 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_always_inline; |
| case 1: return CXX11_gnu_always_inline; |
| case 2: return Keyword_forceinline; |
| } |
| } |
| |
| static void matchRulesForAlwaysInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static void matchRulesForAnnotate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| } |
| |
| static bool isTargetx86x86_64(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64); |
| } |
| |
| static bool isFunctionLike(const Decl *D) { |
| if (const auto *S = dyn_cast<Decl>(D)) |
| return S->getFunctionType(false) != nullptr; |
| return false; |
| } |
| |
| static bool checkAnyX86NoCfCheckAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isFunctionLike(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and function pointers"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAnyX86NoCfCheck(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true)); |
| } |
| |
| static bool checkArcWeakrefUnavailableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForArcWeakrefUnavailable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkArgumentWithTypeTagAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isHasFunctionProto(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "non-K&R-style functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned ArgumentWithTypeTagAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_argument_with_type_tag = 0, |
| CXX11_clang_argument_with_type_tag = 1, |
| C2x_clang_argument_with_type_tag = 2, |
| GNU_pointer_with_type_tag = 3, |
| CXX11_clang_pointer_with_type_tag = 4, |
| C2x_clang_pointer_with_type_tag = 5 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_argument_with_type_tag; |
| case 1: return CXX11_clang_argument_with_type_tag; |
| case 2: return C2x_clang_argument_with_type_tag; |
| case 3: return GNU_pointer_with_type_tag; |
| case 4: return CXX11_clang_pointer_with_type_tag; |
| case 5: return C2x_clang_pointer_with_type_tag; |
| } |
| } |
| |
| static bool isInlineFunction(const Decl *D) { |
| if (const auto *S = dyn_cast<FunctionDecl>(D)) |
| return S->isInlineSpecified(); |
| return false; |
| } |
| |
| static bool checkArtificialAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isInlineFunction(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "inline functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkAssertCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned AssertCapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_assert_capability = 0, |
| CXX11_clang_assert_capability = 1, |
| GNU_assert_shared_capability = 2, |
| CXX11_clang_assert_shared_capability = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_assert_capability; |
| case 1: return CXX11_clang_assert_capability; |
| case 2: return GNU_assert_shared_capability; |
| case 3: return CXX11_clang_assert_shared_capability; |
| } |
| } |
| |
| static bool checkAssertExclusiveLockAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkAssertSharedLockAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkAssumeAlignedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods and functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAssumeAligned(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkAvailabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<NamedDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "named declarations"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForAvailability(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCFAuditedTransferAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCFAuditedTransfer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCFConsumedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCFConsumed(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCFUnknownTransferAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCFUnknownTransfer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCPUDispatchAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCPUDispatch(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCPUSpecificAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCPUSpecific(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDAConstantAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkCUDALangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.CUDA) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static void matchRulesForCUDAConstant(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDADeviceAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCUDADevice(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDAGlobalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCUDAGlobal(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDAHostAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCUDAHost(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDAInvalidTargetAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkCUDALaunchBoundsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isFunctionLike(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods, functions, and function pointers"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCUDALaunchBounds(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCUDASharedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCUDAShared(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCXX11NoReturnAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCXX11NoReturn(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCallableWhenAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCallableWhen(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus)); |
| } |
| |
| static bool checkCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, classes, and typedefs"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned CapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_capability = 0, |
| CXX11_clang_capability = 1, |
| GNU_shared_capability = 2, |
| CXX11_clang_shared_capability = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_capability; |
| case 1: return CXX11_clang_capability; |
| case 2: return GNU_shared_capability; |
| case 3: return CXX11_clang_shared_capability; |
| } |
| } |
| |
| static void matchRulesForCapability(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCarriesDependencyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "parameters, Objective-C methods, and functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCarriesDependency(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool isLocalVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return S->hasLocalStorage() && !isa<ParmVarDecl>(S); |
| return false; |
| } |
| |
| static bool checkCleanupAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isLocalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "local variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkCodeSegAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkColdAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCold(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkCommonAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForCommon(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkConstructorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForConstructor(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkConsumableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForConsumable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkConsumableAutoCastAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForConsumableAutoCast(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkConsumableSetOnReadAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForConsumableSetOnRead(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkConvergentAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForConvergent(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkDLLExportAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, variables, classes, and Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetx86x86_64armthumbaarch64Win32(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::aarch64) && (T.getOS() == llvm::Triple::Win32); |
| } |
| |
| static void matchRulesForDLLExport(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkDLLExportStaticLocalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkDLLImportAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, variables, classes, and Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForDLLImport(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkDLLImportStaticLocalAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkDestructorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForDestructor(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkDiagnoseIfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, Objective-C methods, and Objective-C properties"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkDisableTailCallsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForDisableTailCalls(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkEmptyBasesAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetx86x86_64armthumbaarch64Microsoft(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64 || T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::aarch64) && (Target.getCXXABI().getKind() == TargetCXXABI::Microsoft); |
| } |
| |
| static bool checkEnableIfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForEnableIf(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkEnumExtensibilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<EnumDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "enums"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForEnumExtensibility(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true)); |
| } |
| |
| static bool checkExcludeFromExplicitInstantiationAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables, functions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForExcludeFromExplicitInstantiation(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkExclusiveTrylockFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkExtVectorTypeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<TypedefNameDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "typedefs"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkExternalSourceSymbolAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<NamedDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "named declarations"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForExternalSourceSymbol(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkFlagEnumAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<EnumDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "enums"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForFlagEnum(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true)); |
| } |
| |
| static bool checkFlattenAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForFlatten(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkFormatAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D) && !isHasFunctionProto(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods, blocks, and non-K&R-style functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkFormatArgAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods and non-K&R-style functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkGNUInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForGNUInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkGuardedByAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkGuardedVarAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkHotAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForHot(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool isObjCInstanceMethod(const Decl *D) { |
| if (const auto *S = dyn_cast<ObjCMethodDecl>(D)) |
| return S->isInstanceMethod(); |
| return false; |
| } |
| |
| static bool checkIBActionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isObjCInstanceMethod(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C instance methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForIBAction(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method_is_instance, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkIFuncAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetELF(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getObjectFormat() == llvm::Triple::ELF); |
| } |
| |
| static void matchRulesForIFunc(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkInitPriorityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForInitPriority(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkInternalLinkageAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables, functions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForInternalLinkage(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkLTOVisibilityPublicAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForLTOVisibilityPublic(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkLayoutVersionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isImplicitObjectParameter(const Decl *D) { |
| if (const auto *S = dyn_cast<FunctionDecl>(D)) |
| return static_cast<void>(S), false; |
| return false; |
| } |
| |
| static bool checkLifetimeBoundAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D) && !isImplicitObjectParameter(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "parameters and implicit object parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkCPlusPlusLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.CPlusPlus) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static bool checkLockReturnedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkLockableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForLockable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkLocksExcludedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned LoopHintAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| Pragma_clang_loop = 0, |
| Pragma_unroll = 1, |
| Pragma_nounroll = 2, |
| Pragma_unroll_and_jam = 3, |
| Pragma_nounroll_and_jam = 4 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return Pragma_clang_loop; |
| case 1: return Pragma_unroll; |
| case 2: return Pragma_nounroll; |
| case 3: return Pragma_unroll_and_jam; |
| case 4: return Pragma_nounroll_and_jam; |
| } |
| } |
| |
| static bool checkMicrosoftExtLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.MicrosoftExt) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static unsigned MSInheritanceAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| Keyword_single_inheritance = 0, |
| Keyword_multiple_inheritance = 1, |
| Keyword_virtual_inheritance = 2, |
| Keyword_unspecified_inheritance = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return Keyword_single_inheritance; |
| case 1: return Keyword_multiple_inheritance; |
| case 2: return Keyword_virtual_inheritance; |
| case 3: return Keyword_unspecified_inheritance; |
| } |
| } |
| |
| static bool checkMSNoVTableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkMSStructAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForMSStruct(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkMicroMipsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetmipsmipsel(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel); |
| } |
| |
| static void matchRulesForMicroMips(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkMinSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForMinSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkMinVectorWidthAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForMinVectorWidth(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkMips16AppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForMips16(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkMipsLongCallAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isTargetmipsmipselmips64mips64el(const TargetInfo &Target) { |
| const llvm::Triple &T = Target.getTriple(); |
| return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::mips64 || T.getArch() == llvm::Triple::mips64el); |
| } |
| |
| static unsigned MipsLongCallAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_long_call = 0, |
| CXX11_gnu_long_call = 1, |
| GNU_far = 2, |
| CXX11_gnu_far = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_long_call; |
| case 1: return CXX11_gnu_long_call; |
| case 2: return GNU_far; |
| case 3: return CXX11_gnu_far; |
| } |
| } |
| |
| static void matchRulesForMipsLongCall(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkMipsShortCallAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned MipsShortCallAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_short_call = 0, |
| CXX11_gnu_short_call = 1, |
| GNU_near = 2, |
| CXX11_gnu_near = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_short_call; |
| case 1: return CXX11_gnu_short_call; |
| case 2: return GNU_near; |
| case 3: return CXX11_gnu_near; |
| } |
| } |
| |
| static void matchRulesForMipsShortCall(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkModeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<EnumDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<FieldDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "variables, enums, typedefs, and non-static data members"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkNSConsumedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNSConsumed(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNSConsumesSelfAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNSConsumesSelf(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkNakedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNaked(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoAliasAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkNoCommonAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoCommon(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool isNonParmVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return S->getKind() != Decl::ParmVar; |
| return false; |
| } |
| |
| static bool checkNoDebugAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isFunctionLike(D) && !isa<ObjCMethodDecl>(D) && !isNonParmVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, function pointers, Objective-C methods, and variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoDebug(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_not_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoDestroyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoDestroy(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoDuplicateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoDuplicate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoEscapeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoEscape(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoInlineAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoInline(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoInstrumentFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoInstrumentFunction(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoMicroMipsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoMicroMips(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoMips16AppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoMips16(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoSanitizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions, Objective-C methods, and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoSanitize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoSanitizeSpecificAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoSanitizeSpecific(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoSplitStackAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoSplitStack(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoStackProtectorAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoStackProtector(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoThreadSafetyAnalysisAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoThreadSafetyAnalysis(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNoThrowAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNoThrow(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkNonNullAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D) && !isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, methods, and parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkNotTailCalledAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForNotTailCalled(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkOSConsumedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOSConsumed(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool isNonStaticCXXMethod(const Decl *D) { |
| if (const auto *S = dyn_cast<CXXMethodDecl>(D)) |
| return !S->isStatic(); |
| return false; |
| } |
| |
| static bool checkOSConsumesThisAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isNonStaticCXXMethod(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static member functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkOSReturnsNotRetainedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, Objective-C methods, and Objective-C properties"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOSReturnsNotRetained(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkOSReturnsRetainedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions, Objective-C methods, and Objective-C properties"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOSReturnsRetained(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCBoxableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCBoxable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkObjCBridgeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, classes, and typedefs"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCBridge(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true)); |
| } |
| |
| static bool checkObjCBridgeMutableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCBridgeMutable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkObjCBridgeRelatedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCBridgeRelated(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool isObjCInterfaceDeclInitMethod(const Decl *D) { |
| if (const auto *S = dyn_cast<ObjCMethodDecl>(D)) |
| return S->getMethodFamily() == OMF_init && |
| (isa<ObjCInterfaceDecl>(S->getDeclContext()) || |
| (isa<ObjCCategoryDecl>(S->getDeclContext()) && |
| cast<ObjCCategoryDecl>(S->getDeclContext())->IsClassExtension())); |
| return false; |
| } |
| |
| static bool checkObjCDesignatedInitializerAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isObjCInterfaceDeclInitMethod(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "init methods of interface or class extension declarations"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkObjCExceptionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCException(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCExplicitProtocolImplAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCProtocolDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C protocols"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCExplicitProtocolImpl(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCMethodFamilyAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCMethodFamily(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCPreciseLifetimeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCPreciseLifetime(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkObjCRequiresPropertyDefsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCRequiresPropertyDefs(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCRequiresSuperAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCRequiresSuper(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCReturnsInnerPointerAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods and Objective-C properties"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCReturnsInnerPointer(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCRootClassAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCRootClass(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCRuntimeNameAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces and Objective-C protocols"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCRuntimeName(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCRuntimeVisibleAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCRuntimeVisible(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkObjCSubclassingRestrictedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCInterfaceDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C interfaces"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForObjCSubclassingRestricted(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkOpenCLAccessAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D) && !isa<TypedefNameDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "parameters and typedefs"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned OpenCLAccessAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| Keyword_read_only = 0, |
| Keyword_write_only = 2, |
| Keyword_read_write = 4 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return Keyword_read_only; |
| case 1: return Keyword_read_only; |
| case 2: return Keyword_write_only; |
| case 3: return Keyword_write_only; |
| case 4: return Keyword_read_write; |
| case 5: return Keyword_read_write; |
| } |
| } |
| |
| static bool checkOpenCLIntelReqdSubGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOpenCLIntelReqdSubGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkOpenCLKernelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkOpenCLNoSVMAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkOpenCLLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.OpenCL) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static void matchRulesForOpenCLNoSVM(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| } |
| |
| static bool checkOptimizeNoneAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOptimizeNone(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkOverloadableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForOverloadable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkOwnershipAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isHasFunctionProto(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-K&R-style functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned OwnershipAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_ownership_holds = 0, |
| CXX11_clang_ownership_holds = 1, |
| C2x_clang_ownership_holds = 2, |
| GNU_ownership_returns = 3, |
| CXX11_clang_ownership_returns = 4, |
| C2x_clang_ownership_returns = 5, |
| GNU_ownership_takes = 6, |
| CXX11_clang_ownership_takes = 7, |
| C2x_clang_ownership_takes = 8 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_ownership_holds; |
| case 1: return CXX11_clang_ownership_holds; |
| case 2: return C2x_clang_ownership_holds; |
| case 3: return GNU_ownership_returns; |
| case 4: return CXX11_clang_ownership_returns; |
| case 5: return C2x_clang_ownership_returns; |
| case 6: return GNU_ownership_takes; |
| case 7: return CXX11_clang_ownership_takes; |
| case 8: return C2x_clang_ownership_takes; |
| } |
| } |
| |
| static bool checkParamTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForParamTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkPassObjectSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForPassObjectSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkPragmaClangBSSSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkPragmaClangDataSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkPragmaClangRodataSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkPragmaClangTextSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkPtGuardedByAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkPtGuardedVarAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FieldDecl>(D) && !isSharedVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "non-static data members and global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool isNonStaticNonConstCXXMethod(const Decl *D) { |
| if (const auto *S = dyn_cast<CXXMethodDecl>(D)) |
| return !S->isStatic() && !S->isConst(); |
| return false; |
| } |
| |
| static bool checkReinitializesAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isNonStaticNonConstCXXMethod(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "non-static non-const member functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkReleaseCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned ReleaseCapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_release_capability = 0, |
| CXX11_clang_release_capability = 1, |
| GNU_release_shared_capability = 2, |
| CXX11_clang_release_shared_capability = 3, |
| GNU_release_generic_capability = 4, |
| CXX11_clang_release_generic_capability = 5, |
| GNU_unlock_function = 6, |
| CXX11_clang_unlock_function = 7 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_release_capability; |
| case 1: return CXX11_clang_release_capability; |
| case 2: return GNU_release_shared_capability; |
| case 3: return CXX11_clang_release_shared_capability; |
| case 4: return GNU_release_generic_capability; |
| case 5: return CXX11_clang_release_generic_capability; |
| case 6: return GNU_unlock_function; |
| case 7: return CXX11_clang_unlock_function; |
| } |
| } |
| |
| static bool checkRenderScriptKernelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkRenderScriptLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.RenderScript) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static void matchRulesForRenderScriptKernel(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkReqdWorkGroupSizeAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForReqdWorkGroupSize(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkRequireConstantInitAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isGlobalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "global variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForRequireConstantInit(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true)); |
| } |
| |
| static bool checkRequiresCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned RequiresCapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_requires_capability = 0, |
| CXX11_clang_requires_capability = 1, |
| GNU_exclusive_locks_required = 2, |
| CXX11_clang_exclusive_locks_required = 3, |
| GNU_requires_shared_capability = 4, |
| CXX11_clang_requires_shared_capability = 5, |
| GNU_shared_locks_required = 6, |
| CXX11_clang_shared_locks_required = 7 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_requires_capability; |
| case 1: return CXX11_clang_requires_capability; |
| case 2: return GNU_exclusive_locks_required; |
| case 3: return CXX11_clang_exclusive_locks_required; |
| case 4: return GNU_requires_shared_capability; |
| case 5: return CXX11_clang_requires_shared_capability; |
| case 6: return GNU_shared_locks_required; |
| case 7: return CXX11_clang_shared_locks_required; |
| } |
| } |
| |
| static bool checkRestrictAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned RestrictAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| Declspec_restrict = 0, |
| GNU_malloc = 1, |
| CXX11_gnu_malloc = 2 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return Declspec_restrict; |
| case 1: return GNU_malloc; |
| case 2: return CXX11_gnu_malloc; |
| } |
| } |
| |
| static void matchRulesForRestrict(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkReturnTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForReturnTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkReturnsNonNullAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods and functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForReturnsNonNull(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkReturnsTwiceAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForReturnsTwice(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkScopedLockableAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForScopedLockable(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkSectionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isGlobalVar(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions, global variables, Objective-C methods, and Objective-C properties"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned SectionAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_section = 0, |
| CXX11_gnu_section = 1, |
| Declspec_allocate = 2 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_section; |
| case 1: return CXX11_gnu_section; |
| case 2: return Declspec_allocate; |
| } |
| } |
| |
| static void matchRulesForSection(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkSetTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForSetTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus)); |
| } |
| |
| static bool checkSharedTrylockFunctionAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkSpeculativeLoadHardeningAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForSpeculativeLoadHardening(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkSwiftContextAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForSwiftContext(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkSwiftErrorResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForSwiftErrorResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool checkSwiftIndirectResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ParmVarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "parameters"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForSwiftIndirectResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true)); |
| } |
| |
| static bool isTLSVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return S->getTLSKind() != 0; |
| return false; |
| } |
| |
| static bool checkTLSModelAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isTLSVar(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "thread-local variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForTLSModel(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_thread_local, /*IsSupported=*/true)); |
| } |
| |
| static bool checkTargetAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForTarget(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkTestTypestateAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForTestTypestate(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus)); |
| } |
| |
| static bool checkThreadAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkNotCPlusPlusLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (!S.LangOpts.CPlusPlus) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static bool checkTrivialABIAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForTrivialABI(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkTryAcquireCapabilityAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned TryAcquireCapabilityAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_try_acquire_capability = 0, |
| CXX11_clang_try_acquire_capability = 1, |
| GNU_try_acquire_shared_capability = 2, |
| CXX11_clang_try_acquire_shared_capability = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_try_acquire_capability; |
| case 1: return CXX11_clang_try_acquire_capability; |
| case 2: return GNU_try_acquire_shared_capability; |
| case 3: return CXX11_clang_try_acquire_shared_capability; |
| } |
| } |
| |
| static bool checkUninitializedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isLocalVar(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "local variables"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkUnusedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<ObjCIvarDecl>(D) && !isa<TypeDecl>(D) && !isa<EnumDecl>(D) && !isa<EnumConstantDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D) && !isa<ObjCMethodDecl>(D) && !isFunctionLike(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables, non-static data members, types, enums, enumerators, labels, non-static data members, Objective-C methods, functions, and function pointers"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned UnusedAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| CXX11_maybe_unused = 0, |
| GNU_unused = 1, |
| CXX11_gnu_unused = 2, |
| C2x_maybe_unused = 3 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return CXX11_maybe_unused; |
| case 1: return GNU_unused; |
| case 2: return CXX11_gnu_unused; |
| case 3: return C2x_maybe_unused; |
| } |
| } |
| |
| static bool isNonLocalVar(const Decl *D) { |
| if (const auto *S = dyn_cast<VarDecl>(D)) |
| return !S->hasLocalStorage(); |
| return false; |
| } |
| |
| static bool checkUsedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables with non-local storage, functions, and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkUuidAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D) && !isa<EnumDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, classes, and enums"; |
| return false; |
| } |
| return true; |
| } |
| |
| static bool checkMicrosoftExtBorlandLangOpts(Sema &S, const ParsedAttr &Attr) { |
| if (S.LangOpts.MicrosoftExt || S.LangOpts.Borland) |
| return true; |
| |
| S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); |
| return false; |
| } |
| |
| static bool checkVecReturnAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForVecReturn(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkVecTypeHintAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForVecTypeHint(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkWarnUnusedAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<RecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "structs, unions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForWarnUnused(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkWarnUnusedResultAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<ObjCMethodDecl>(D) && !isa<EnumDecl>(D) && !isa<RecordDecl>(D) && !isFunctionLike(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "Objective-C methods, enums, structs, unions, classes, functions, and function pointers"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned WarnUnusedResultAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| CXX11_nodiscard = 0, |
| C2x_nodiscard = 1, |
| CXX11_clang_warn_unused_result = 2, |
| GNU_warn_unused_result = 3, |
| CXX11_gnu_warn_unused_result = 4 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return CXX11_nodiscard; |
| case 1: return C2x_nodiscard; |
| case 2: return CXX11_clang_warn_unused_result; |
| case 3: return GNU_warn_unused_result; |
| case 4: return CXX11_gnu_warn_unused_result; |
| } |
| } |
| |
| static void matchRulesForWarnUnusedResult(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true)); |
| } |
| |
| static bool checkWeakAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "variables, functions, and classes"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForWeak(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true)); |
| } |
| |
| static bool checkWeakRefAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<VarDecl>(D) && !isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "variables and functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForWeakRef(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkWorkGroupSizeHintAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) |
| << Attr << "functions"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForWorkGroupSizeHint(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| } |
| |
| static bool checkXRayInstrumentAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static unsigned XRayInstrumentAttrSpellingMap(const ParsedAttr &Attr) { |
| enum Spelling { |
| GNU_xray_always_instrument = 0, |
| CXX11_clang_xray_always_instrument = 1, |
| C2x_clang_xray_always_instrument = 2, |
| GNU_xray_never_instrument = 3, |
| CXX11_clang_xray_never_instrument = 4, |
| C2x_clang_xray_never_instrument = 5 |
| }; |
| |
| unsigned Idx = Attr.getAttributeSpellingListIndex(); |
| switch (Idx) { |
| default: llvm_unreachable("Unknown spelling list index"); |
| case 0: return GNU_xray_always_instrument; |
| case 1: return CXX11_clang_xray_always_instrument; |
| case 2: return C2x_clang_xray_always_instrument; |
| case 3: return GNU_xray_never_instrument; |
| case 4: return CXX11_clang_xray_never_instrument; |
| case 5: return C2x_clang_xray_never_instrument; |
| } |
| } |
| |
| static void matchRulesForXRayInstrument(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static bool checkXRayLogArgsAppertainsTo(Sema &S, const ParsedAttr &Attr, const Decl *D) { |
| if (!D || (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D))) { |
| S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) |
| << Attr << "functions and Objective-C methods"; |
| return false; |
| } |
| return true; |
| } |
| |
| static void matchRulesForXRayLogArgs(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) { |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true)); |
| MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC)); |
| } |
| |
| static const ParsedAttrInfo AttrInfoMap[ParsedAttr::UnknownAttribute + 1] = { |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AArch64VectorPcs |
| { 2, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUFlatWorkGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUFlatWorkGroupSize }, // AT_AMDGPUFlatWorkGroupSize |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUNumSGPRAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUNumSGPR }, // AT_AMDGPUNumSGPR |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkAMDGPUNumVGPRAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUNumVGPR }, // AT_AMDGPUNumVGPR |
| { 1, 1, 0, 0, 0, 0, 0, 1, checkAMDGPUWavesPerEUAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAMDGPUWavesPerEU }, // AT_AMDGPUWavesPerEU |
| { 0, 1, 1, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetarmthumbarmebthumbebavrx86x86_64msp430mipsmipselriscv32riscv64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Interrupt |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkAVRSignalAppertainsTo, defaultDiagnoseLangOpts, isTargetavr, defaultSpellingIndexToSemanticSpelling, matchRulesForAVRSignal }, // AT_AVRSignal |
| { 0, 15, 0, 0, 0, 0, 1, 1, checkAbiTagAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAbiTag }, // AT_AbiTag |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquireCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AcquireCapabilityAttrSpellingMap, nullptr }, // AT_AcquireCapability |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquiredAfterAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AcquiredAfter |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAcquiredBeforeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AcquiredBefore |
| { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AddressSpace |
| { 1, 0, 0, 0, 0, 0, 1, 1, checkAliasAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlias }, // AT_Alias |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkAlignValueAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlignValue }, // AT_AlignValue |
| { 0, 1, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AlignedAttrSpellingMap, nullptr }, // AT_Aligned |
| { 1, 0, 0, 0, 0, 0, 1, 0, checkAllocAlignAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AllocAlign |
| { 1, 1, 0, 0, 0, 0, 1, 1, checkAllocSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAllocSize }, // AT_AllocSize |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkAlwaysDestroyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAlwaysDestroy }, // AT_AlwaysDestroy |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkAlwaysInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AlwaysInlineAttrSpellingMap, matchRulesForAlwaysInline }, // AT_AlwaysInline |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AnalyzerNoReturn |
| { 1, 0, 0, 0, 0, 0, 0, 1, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAnnotate }, // AT_Annotate |
| { 0, 0, 0, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AnyX86NoCallerSavedRegisters |
| { 0, 0, 0, 1, 1, 0, 1, 1, checkAnyX86NoCfCheckAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, matchRulesForAnyX86NoCfCheck }, // AT_AnyX86NoCfCheck |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkArcWeakrefUnavailableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForArcWeakrefUnavailable }, // AT_ArcWeakrefUnavailable |
| { 3, 0, 0, 0, 0, 0, 0, 0, checkArgumentWithTypeTagAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, ArgumentWithTypeTagAttrSpellingMap, nullptr }, // AT_ArgumentWithTypeTag |
| { 0, 0, 0, 0, 0, 0, 1, 0, checkArtificialAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Artificial |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, AssertCapabilityAttrSpellingMap, nullptr }, // AT_AssertCapability |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertExclusiveLockAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AssertExclusiveLock |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkAssertSharedLockAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_AssertSharedLock |
| { 1, 1, 0, 0, 0, 0, 1, 1, checkAssumeAlignedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAssumeAligned }, // AT_AssumeAligned |
| { 8, 0, 1, 0, 0, 0, 0, 1, checkAvailabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForAvailability }, // AT_Availability |
| { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Blocks |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CDecl |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCFAuditedTransferAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFAuditedTransfer }, // AT_CFAuditedTransfer |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCFConsumedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFConsumed }, // AT_CFConsumed |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CFReturnsNotRetained |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CFReturnsRetained |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCFUnknownTransferAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCFUnknownTransfer }, // AT_CFUnknownTransfer |
| { 0, 15, 0, 0, 0, 0, 0, 1, checkCPUDispatchAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCPUDispatch }, // AT_CPUDispatch |
| { 0, 15, 0, 0, 0, 0, 0, 1, checkCPUSpecificAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCPUSpecific }, // AT_CPUSpecific |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAConstantAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAConstant }, // AT_CUDAConstant |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDADeviceAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDADevice }, // AT_CUDADevice |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAGlobalAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAGlobal }, // AT_CUDAGlobal |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDAHostAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAHost }, // AT_CUDAHost |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkCUDAInvalidTargetAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CUDAInvalidTarget |
| { 1, 1, 0, 0, 0, 0, 0, 1, checkCUDALaunchBoundsAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDALaunchBounds }, // AT_CUDALaunchBounds |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCUDASharedAppertainsTo, checkCUDALangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCUDAShared }, // AT_CUDAShared |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCXX11NoReturnAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCXX11NoReturn }, // AT_CXX11NoReturn |
| { 0, 15, 0, 0, 0, 0, 0, 1, checkCallableWhenAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCallableWhen }, // AT_CallableWhen |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, CapabilityAttrSpellingMap, matchRulesForCapability }, // AT_Capability |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkCarriesDependencyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCarriesDependency }, // AT_CarriesDependency |
| { 1, 0, 0, 0, 0, 0, 1, 0, checkCleanupAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Cleanup |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkCodeSegAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_CodeSeg |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkColdAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCold }, // AT_Cold |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkCommonAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForCommon }, // AT_Common |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Const |
| { 0, 1, 0, 0, 0, 0, 1, 1, checkConstructorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConstructor }, // AT_Constructor |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkConsumableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumable }, // AT_Consumable |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkConsumableAutoCastAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumableAutoCast }, // AT_ConsumableAutoCast |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkConsumableSetOnReadAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConsumableSetOnRead }, // AT_ConsumableSetOnRead |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkConvergentAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForConvergent }, // AT_Convergent |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkDLLExportAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, matchRulesForDLLExport }, // AT_DLLExport |
| { 0, 0, 0, 1, 0, 0, 0, 0, checkDLLExportStaticLocalAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_DLLExportStaticLocal |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkDLLImportAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, matchRulesForDLLImport }, // AT_DLLImport |
| { 0, 0, 0, 1, 0, 0, 0, 0, checkDLLImportStaticLocalAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Win32, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_DLLImportStaticLocal |
| { 0, 2, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Deprecated |
| { 0, 1, 0, 0, 0, 0, 1, 1, checkDestructorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForDestructor }, // AT_Destructor |
| { 3, 0, 0, 0, 0, 0, 0, 0, checkDiagnoseIfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_DiagnoseIf |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkDisableTailCallsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForDisableTailCalls }, // AT_DisableTailCalls |
| { 0, 0, 0, 1, 0, 0, 0, 0, checkEmptyBasesAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_EmptyBases |
| { 2, 0, 0, 0, 0, 0, 0, 1, checkEnableIfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForEnableIf }, // AT_EnableIf |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkEnumExtensibilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForEnumExtensibility }, // AT_EnumExtensibility |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkExcludeFromExplicitInstantiationAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForExcludeFromExplicitInstantiation }, // AT_ExcludeFromExplicitInstantiation |
| { 1, 15, 0, 0, 0, 0, 0, 0, checkExclusiveTrylockFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ExclusiveTrylockFunction |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkExtVectorTypeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ExtVectorType |
| { 0, 3, 1, 0, 0, 0, 0, 1, checkExternalSourceSymbolAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForExternalSourceSymbol }, // AT_ExternalSourceSymbol |
| { 0, 0, 0, 0, 0, 1, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FallThrough |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FastCall |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkFlagEnumAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForFlagEnum }, // AT_FlagEnum |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkFlattenAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForFlatten }, // AT_Flatten |
| { 3, 0, 0, 0, 0, 0, 1, 0, checkFormatAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Format |
| { 1, 0, 0, 0, 0, 0, 1, 0, checkFormatArgAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_FormatArg |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkGNUInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForGNUInline }, // AT_GNUInline |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkGuardedByAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_GuardedBy |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkGuardedVarAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_GuardedVar |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkHotAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForHot }, // AT_Hot |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkIBActionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForIBAction }, // AT_IBAction |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IBOutlet |
| { 0, 1, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IBOutletCollection |
| { 1, 0, 0, 1, 0, 0, 1, 1, checkIFuncAppertainsTo, defaultDiagnoseLangOpts, isTargetELF, defaultSpellingIndexToSemanticSpelling, matchRulesForIFunc }, // AT_IFunc |
| { 1, 0, 0, 0, 0, 0, 1, 1, checkInitPriorityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForInitPriority }, // AT_InitPriority |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_IntelOclBicc |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkInternalLinkageAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForInternalLinkage }, // AT_InternalLinkage |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkLTOVisibilityPublicAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForLTOVisibilityPublic }, // AT_LTOVisibilityPublic |
| { 1, 0, 0, 1, 0, 0, 0, 0, checkLayoutVersionAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LayoutVersion |
| { 0, 0, 0, 0, 1, 0, 0, 0, checkLifetimeBoundAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LifetimeBound |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkLockReturnedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LockReturned |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkLockableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForLockable }, // AT_Lockable |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkLocksExcludedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_LocksExcluded |
| { 3, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, LoopHintAttrSpellingMap, nullptr }, // AT_LoopHint |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MSABI |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, checkMicrosoftExtLangOpts, defaultTargetRequirements, MSInheritanceAttrSpellingMap, nullptr }, // AT_MSInheritance |
| { 0, 0, 0, 1, 0, 0, 0, 0, checkMSNoVTableAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64armthumbaarch64Microsoft, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MSNoVTable |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkMSStructAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMSStruct }, // AT_MSStruct |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_MayAlias |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkMicroMipsAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForMicroMips }, // AT_MicroMips |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkMinSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMinSize }, // AT_MinSize |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkMinVectorWidthAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForMinVectorWidth }, // AT_MinVectorWidth |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkMips16AppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForMips16 }, // AT_Mips16 |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkMipsLongCallAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipselmips64mips64el, MipsLongCallAttrSpellingMap, matchRulesForMipsLongCall }, // AT_MipsLongCall |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkMipsShortCallAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipselmips64mips64el, MipsShortCallAttrSpellingMap, matchRulesForMipsShortCall }, // AT_MipsShortCall |
| { 1, 0, 0, 0, 0, 0, 1, 0, checkModeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Mode |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNSConsumedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNSConsumed }, // AT_NSConsumed |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNSConsumesSelfAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNSConsumesSelf }, // AT_NSConsumesSelf |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsAutoreleased |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsNotRetained |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NSReturnsRetained |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNakedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNaked }, // AT_Naked |
| { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NeonPolyVectorType |
| { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NeonVectorType |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkNoAliasAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NoAlias |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoCommonAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoCommon }, // AT_NoCommon |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoDebugAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDebug }, // AT_NoDebug |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NoDeref |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNoDestroyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDestroy }, // AT_NoDestroy |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNoDuplicateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoDuplicate }, // AT_NoDuplicate |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNoEscapeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoEscape }, // AT_NoEscape |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoInlineAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoInline }, // AT_NoInline |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoInstrumentFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoInstrumentFunction }, // AT_NoInstrumentFunction |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkNoMicroMipsAppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForNoMicroMips }, // AT_NoMicroMips |
| { 0, 0, 0, 1, 0, 0, 1, 1, checkNoMips16AppertainsTo, defaultDiagnoseLangOpts, isTargetmipsmipsel, defaultSpellingIndexToSemanticSpelling, matchRulesForNoMips16 }, // AT_NoMips16 |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NoReturn |
| { 0, 15, 0, 0, 0, 0, 0, 1, checkNoSanitizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSanitize }, // AT_NoSanitize |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoSanitizeSpecificAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSanitizeSpecific }, // AT_NoSanitizeSpecific |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoSplitStackAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoSplitStack }, // AT_NoSplitStack |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNoStackProtectorAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoStackProtector }, // AT_NoStackProtector |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNoThreadSafetyAnalysisAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoThreadSafetyAnalysis }, // AT_NoThreadSafetyAnalysis |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkNoThrowAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNoThrow }, // AT_NoThrow |
| { 0, 15, 0, 0, 0, 0, 1, 0, checkNonNullAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_NonNull |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkNotTailCalledAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForNotTailCalled }, // AT_NotTailCalled |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOSConsumedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOSConsumed }, // AT_OSConsumed |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkOSConsumesThisAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OSConsumesThis |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOSReturnsNotRetainedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOSReturnsNotRetained }, // AT_OSReturnsNotRetained |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOSReturnsRetainedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOSReturnsRetained }, // AT_OSReturnsRetained |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCBoxableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBoxable }, // AT_ObjCBoxable |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCBridgeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridge }, // AT_ObjCBridge |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCBridgeMutableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridgeMutable }, // AT_ObjCBridgeMutable |
| { 3, 0, 1, 0, 0, 0, 0, 1, checkObjCBridgeRelatedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCBridgeRelated }, // AT_ObjCBridgeRelated |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkObjCDesignatedInitializerAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCDesignatedInitializer |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCExceptionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCException }, // AT_ObjCException |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCExplicitProtocolImplAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCExplicitProtocolImpl }, // AT_ObjCExplicitProtocolImpl |
| { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCGC |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCIndependentClass |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCInertUnsafeUnretained |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCKindOf |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCMethodFamilyAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCMethodFamily }, // AT_ObjCMethodFamily |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCNSObject |
| { 1, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ObjCOwnership |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCPreciseLifetimeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCPreciseLifetime }, // AT_ObjCPreciseLifetime |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRequiresPropertyDefsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRequiresPropertyDefs }, // AT_ObjCRequiresPropertyDefs |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRequiresSuperAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRequiresSuper }, // AT_ObjCRequiresSuper |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCReturnsInnerPointerAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCReturnsInnerPointer }, // AT_ObjCReturnsInnerPointer |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRootClassAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRootClass }, // AT_ObjCRootClass |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkObjCRuntimeNameAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRuntimeName }, // AT_ObjCRuntimeName |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCRuntimeVisibleAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCRuntimeVisible }, // AT_ObjCRuntimeVisible |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkObjCSubclassingRestrictedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForObjCSubclassingRestricted }, // AT_ObjCSubclassingRestricted |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkOpenCLAccessAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, OpenCLAccessAttrSpellingMap, nullptr }, // AT_OpenCLAccess |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLConstantAddressSpace |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLGenericAddressSpace |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLGlobalAddressSpace |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkOpenCLIntelReqdSubGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOpenCLIntelReqdSubGroupSize }, // AT_OpenCLIntelReqdSubGroupSize |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkOpenCLKernelAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLKernel |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLLocalAddressSpace |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOpenCLNoSVMAppertainsTo, checkOpenCLLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOpenCLNoSVM }, // AT_OpenCLNoSVM |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLPrivateAddressSpace |
| { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_OpenCLUnrollHint |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOptimizeNoneAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOptimizeNone }, // AT_OptimizeNone |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkOverloadableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForOverloadable }, // AT_Overloadable |
| { 1, 15, 0, 0, 0, 0, 0, 0, checkOwnershipAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, OwnershipAttrSpellingMap, nullptr }, // AT_Ownership |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Packed |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkParamTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForParamTypestate }, // AT_ParamTypestate |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pascal |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkPassObjectSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForPassObjectSize }, // AT_PassObjectSize |
| { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pcs |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangBSSSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangBSSSection |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangDataSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangDataSection |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangRodataSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangRodataSection |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkPragmaClangTextSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PragmaClangTextSection |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PreserveAll |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PreserveMost |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkPtGuardedByAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PtGuardedBy |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkPtGuardedVarAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_PtGuardedVar |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Ptr32 |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Ptr64 |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Pure |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_RegCall |
| { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Regparm |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkReinitializesAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Reinitializes |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkReleaseCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, ReleaseCapabilityAttrSpellingMap, nullptr }, // AT_ReleaseCapability |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkRenderScriptKernelAppertainsTo, checkRenderScriptLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForRenderScriptKernel }, // AT_RenderScriptKernel |
| { 3, 0, 0, 0, 0, 0, 0, 1, checkReqdWorkGroupSizeAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReqdWorkGroupSize }, // AT_ReqdWorkGroupSize |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkRequireConstantInitAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForRequireConstantInit }, // AT_RequireConstantInit |
| { 0, 15, 0, 0, 0, 0, 0, 0, checkRequiresCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, RequiresCapabilityAttrSpellingMap, nullptr }, // AT_RequiresCapability |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkRestrictAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, RestrictAttrSpellingMap, matchRulesForRestrict }, // AT_Restrict |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkReturnTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnTypestate }, // AT_ReturnTypestate |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkReturnsNonNullAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnsNonNull }, // AT_ReturnsNonNull |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkReturnsTwiceAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForReturnsTwice }, // AT_ReturnsTwice |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SPtr |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkScopedLockableAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForScopedLockable }, // AT_ScopedLockable |
| { 1, 0, 0, 0, 0, 0, 1, 1, checkSectionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, SectionAttrSpellingMap, matchRulesForSection }, // AT_Section |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SelectAny |
| { 0, 2, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Sentinel |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkSetTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSetTypestate }, // AT_SetTypestate |
| { 1, 15, 0, 0, 0, 0, 0, 0, checkSharedTrylockFunctionAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SharedTrylockFunction |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkSpeculativeLoadHardeningAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSpeculativeLoadHardening }, // AT_SpeculativeLoadHardening |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_StdCall |
| { 0, 15, 0, 0, 0, 1, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Suppress |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SwiftCall |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftContextAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftContext }, // AT_SwiftContext |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftErrorResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftErrorResult }, // AT_SwiftErrorResult |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkSwiftIndirectResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForSwiftIndirectResult }, // AT_SwiftIndirectResult |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_SysVABI |
| { 1, 0, 0, 0, 0, 0, 1, 1, checkTLSModelAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTLSModel }, // AT_TLSModel |
| { 1, 0, 0, 0, 0, 0, 1, 1, checkTargetAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTarget }, // AT_Target |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkTestTypestateAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTestTypestate }, // AT_TestTypestate |
| { 0, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_ThisCall |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkThreadAppertainsTo, checkMicrosoftExtLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Thread |
| { 0, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, checkNotCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TransparentUnion |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkTrivialABIAppertainsTo, checkCPlusPlusLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForTrivialABI }, // AT_TrivialABI |
| { 1, 15, 0, 0, 0, 0, 0, 0, checkTryAcquireCapabilityAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, TryAcquireCapabilityAttrSpellingMap, nullptr }, // AT_TryAcquireCapability |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNonNull |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNullUnspecified |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeNullable |
| { 4, 0, 1, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeTagForDatatype |
| { 1, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_TypeVisibility |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_UPtr |
| { 0, 1, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Unavailable |
| { 0, 0, 0, 0, 0, 0, 0, 0, checkUninitializedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Uninitialized |
| { 0, 0, 0, 0, 0, 0, 1, 0, checkUnusedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, UnusedAttrSpellingMap, nullptr }, // AT_Unused |
| { 0, 0, 0, 0, 0, 0, 1, 0, checkUsedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Used |
| { 1, 0, 0, 0, 0, 0, 0, 0, checkUuidAppertainsTo, checkMicrosoftExtBorlandLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Uuid |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkVecReturnAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForVecReturn }, // AT_VecReturn |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkVecTypeHintAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForVecTypeHint }, // AT_VecTypeHint |
| { 0, 0, 0, 0, 1, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_VectorCall |
| { 1, 0, 0, 0, 1, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_VectorSize |
| { 1, 0, 0, 0, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_Visibility |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkWarnUnusedAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWarnUnused }, // AT_WarnUnused |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkWarnUnusedResultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, WarnUnusedResultAttrSpellingMap, matchRulesForWarnUnusedResult }, // AT_WarnUnusedResult |
| { 0, 0, 0, 0, 0, 0, 1, 1, checkWeakAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWeak }, // AT_Weak |
| { 0, 0, 0, 0, 0, 0, 0, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_WeakImport |
| { 0, 1, 0, 0, 0, 0, 1, 1, checkWeakRefAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWeakRef }, // AT_WeakRef |
| { 3, 0, 0, 0, 0, 0, 0, 1, checkWorkGroupSizeHintAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForWorkGroupSizeHint }, // AT_WorkGroupSizeHint |
| { 0, 0, 0, 1, 0, 0, 1, 0, defaultAppertainsTo, defaultDiagnoseLangOpts, isTargetx86x86_64, defaultSpellingIndexToSemanticSpelling, nullptr }, // AT_X86ForceAlignArgPointer |
| { 0, 0, 0, 0, 0, 0, 0, 1, checkXRayInstrumentAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, XRayInstrumentAttrSpellingMap, matchRulesForXRayInstrument }, // AT_XRayInstrument |
| { 1, 0, 0, 0, 0, 0, 0, 1, checkXRayLogArgsAppertainsTo, defaultDiagnoseLangOpts, defaultTargetRequirements, defaultSpellingIndexToSemanticSpelling, matchRulesForXRayLogArgs } // AT_XRayLogArgs |
| }; |
| |
| static bool checkAttributeMatchRuleAppliesTo(const Decl *D, attr::SubjectMatchRule rule) { |
| switch (rule) { |
| case attr::SubjectMatchRule_block: |
| return isa<BlockDecl>(D); |
| case attr::SubjectMatchRule_enum: |
| return isa<EnumDecl>(D); |
| case attr::SubjectMatchRule_enum_constant: |
| return isa<EnumConstantDecl>(D); |
| case attr::SubjectMatchRule_field: |
| return isa<FieldDecl>(D); |
| case attr::SubjectMatchRule_function: |
| return isa<FunctionDecl>(D); |
| case attr::SubjectMatchRule_function_is_member: |
| return isa<CXXMethodDecl>(D); |
| case attr::SubjectMatchRule_namespace: |
| return isa<NamespaceDecl>(D); |
| case attr::SubjectMatchRule_objc_category: |
| return isa<ObjCCategoryDecl>(D); |
| case attr::SubjectMatchRule_objc_interface: |
| return isa<ObjCInterfaceDecl>(D); |
| case attr::SubjectMatchRule_objc_method: |
| return isa<ObjCMethodDecl>(D); |
| case attr::SubjectMatchRule_objc_method_is_instance: |
| return isObjCInstanceMethod(D); |
| case attr::SubjectMatchRule_objc_property: |
| return isa<ObjCPropertyDecl>(D); |
| case attr::SubjectMatchRule_objc_protocol: |
| return isa<ObjCProtocolDecl>(D); |
| case attr::SubjectMatchRule_record: |
| return isa<RecordDecl>(D) || isa<CXXRecordDecl>(D); |
| case attr::SubjectMatchRule_record_not_is_union: |
| return isStruct(D); |
| case attr::SubjectMatchRule_hasType_abstract: |
| assert(false && "Abstract matcher rule isn't allowed"); |
| return false; |
| case attr::SubjectMatchRule_hasType_functionType: |
| return isFunctionLike(D); |
| case attr::SubjectMatchRule_type_alias: |
| return isa<TypedefNameDecl>(D); |
| case attr::SubjectMatchRule_variable: |
| return isa<VarDecl>(D); |
| case attr::SubjectMatchRule_variable_is_thread_local: |
| return isTLSVar(D); |
| case attr::SubjectMatchRule_variable_is_global: |
| return isGlobalVar(D); |
| case attr::SubjectMatchRule_variable_is_parameter: |
| return isa<ParmVarDecl>(D); |
| case attr::SubjectMatchRule_variable_not_is_parameter: |
| return isNonParmVar(D); |
| } |
| llvm_unreachable("Invalid match rule"); |
| return false; |
| } |
| |