Файловый менеджер

BGA Файловый менеджер

Файловый менеджер - Редактировать - /usr/include/clang/Sema/AttrParsedAttrImpl.inc

Назад
/===- TableGen'erated file -------------------------------------- C++ --===\ \|* \| \| Parsed attribute helpers \| \| \| \| Automatically generated file, do not edit! \| \| \| \===----------------------------------------------------------------------===/ #if !defined(WANT_DECL_MERGE_LOGIC) && !defined(WANT_STMT_MERGE_LOGIC) static bool isStruct(const Decl D) { if (const auto S = dyn_cast<RecordDecl>(D)) return !S->isUnion(); return false; } static bool isSharedVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->hasGlobalStorage() && !S->getTLSKind(); return false; } static bool isGlobalVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->hasGlobalStorage(); return false; } 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 isFunctionLike(const Decl D) { if (const auto S = dyn_cast<Decl>(D)) return S->getFunctionType(false) != nullptr; return false; } static bool isInlineFunction(const Decl D) { if (const auto S = dyn_cast<FunctionDecl>(D)) return S->isInlineSpecified(); return false; } static bool isLocalVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->hasLocalStorage() && !isa<ParmVarDecl>(S); return false; } static bool isHLSLEntry(const Decl D) { if (const auto S = dyn_cast<FunctionDecl>(D)) return S->isExternallyVisible() && !isa<CXXMethodDecl>(S); return false; } static bool isHLSLBufferObj(const Decl D) { if (const auto S = dyn_cast<HLSLBufferDecl>(D)) return isa<HLSLBufferDecl>(S); return false; } static bool isExternalGlobalVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->hasGlobalStorage() && S->getStorageClass()!=StorageClass::SC_Static && !S->isLocalExternDecl(); return false; } static bool isObjCInstanceMethod(const Decl D) { if (const auto S = dyn_cast<ObjCMethodDecl>(D)) return S->isInstanceMethod(); return false; } static bool isImplicitObjectParameter(const Decl D) { if (const auto S = dyn_cast<FunctionDecl>(D)) return static_cast<void>(S), false; return false; } static bool isNonParmVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->getKind() != Decl::ParmVar; return false; } static bool isNonBitField(const Decl D) { if (const auto S = dyn_cast<FieldDecl>(D)) return !S->isBitField(); return false; } static bool isNonStaticCXXMethod(const Decl D) { if (const auto S = dyn_cast<CXXMethodDecl>(D)) return !S->isStatic(); return false; } static bool isClassTmpl(const Decl D) { if (const auto S = dyn_cast<CXXRecordDecl>(D)) return S->getDescribedClassTemplate(); return false; } static bool isNonStaticNonConstCXXMethod(const Decl D) { if (const auto S = dyn_cast<CXXMethodDecl>(D)) return !S->isStatic() && !S->isConst(); return false; } static bool isNonLocalVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return !S->hasLocalStorage(); return false; } static bool isFunctionTmpl(const Decl D) { if (const auto S = dyn_cast<FunctionDecl>(D)) return S->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate; return false; } static bool isTLSVar(const Decl D) { if (const auto S = dyn_cast<VarDecl>(D)) return S->getTLSKind() != 0; return false; } static bool isFunctionPointer(const Decl D) { if (const auto S = dyn_cast<Decl>(D)) return S->isFunctionPointerType(); return false; } static constexpr ParsedAttrInfo::Spelling AArch64SVEPcsSpellings[] = { {AttributeCommonInfo::AS_GNU, "aarch64_sve_pcs"}, {AttributeCommonInfo::AS_CXX11, "clang::aarch64_sve_pcs"}, {AttributeCommonInfo::AS_C2x, "clang::aarch64_sve_pcs"}, }; struct ParsedAttrInfoAArch64SVEPcs final : public ParsedAttrInfo { constexpr ParsedAttrInfoAArch64SVEPcs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AArch64SVEPcs, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AArch64SVEPcsSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAArch64SVEPcs Instance; }; const ParsedAttrInfoAArch64SVEPcs ParsedAttrInfoAArch64SVEPcs::Instance; static constexpr ParsedAttrInfo::Spelling AArch64VectorPcsSpellings[] = { {AttributeCommonInfo::AS_GNU, "aarch64_vector_pcs"}, {AttributeCommonInfo::AS_CXX11, "clang::aarch64_vector_pcs"}, {AttributeCommonInfo::AS_C2x, "clang::aarch64_vector_pcs"}, }; struct ParsedAttrInfoAArch64VectorPcs final : public ParsedAttrInfo { constexpr ParsedAttrInfoAArch64VectorPcs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AArch64VectorPcs, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AArch64VectorPcsSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAArch64VectorPcs Instance; }; const ParsedAttrInfoAArch64VectorPcs ParsedAttrInfoAArch64VectorPcs::Instance; static constexpr ParsedAttrInfo::Spelling AMDGPUFlatWorkGroupSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "amdgpu_flat_work_group_size"}, {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_flat_work_group_size"}, }; static constexpr const char AMDGPUFlatWorkGroupSizeArgNames[] = { "Min","Max",}; struct ParsedAttrInfoAMDGPUFlatWorkGroupSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoAMDGPUFlatWorkGroupSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AMDGPUFlatWorkGroupSize, /NumArgs=/2, /OptArgs=/0, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AMDGPUFlatWorkGroupSizeSpellings, /ArgNames=/AMDGPUFlatWorkGroupSizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "kernel functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoAMDGPUFlatWorkGroupSize Instance; }; const ParsedAttrInfoAMDGPUFlatWorkGroupSize ParsedAttrInfoAMDGPUFlatWorkGroupSize::Instance; static constexpr ParsedAttrInfo::Spelling AMDGPUKernelCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "amdgpu_kernel"}, {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_kernel"}, {AttributeCommonInfo::AS_C2x, "clang::amdgpu_kernel"}, }; struct ParsedAttrInfoAMDGPUKernelCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoAMDGPUKernelCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AMDGPUKernelCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AMDGPUKernelCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAMDGPUKernelCall Instance; }; const ParsedAttrInfoAMDGPUKernelCall ParsedAttrInfoAMDGPUKernelCall::Instance; static constexpr ParsedAttrInfo::Spelling AMDGPUNumSGPRSpellings[] = { {AttributeCommonInfo::AS_GNU, "amdgpu_num_sgpr"}, {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_num_sgpr"}, }; static constexpr const char AMDGPUNumSGPRArgNames[] = { "NumSGPR",}; struct ParsedAttrInfoAMDGPUNumSGPR final : public ParsedAttrInfo { constexpr ParsedAttrInfoAMDGPUNumSGPR() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AMDGPUNumSGPR, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AMDGPUNumSGPRSpellings, /ArgNames=/AMDGPUNumSGPRArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "kernel functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAMDGPUNumSGPR Instance; }; const ParsedAttrInfoAMDGPUNumSGPR ParsedAttrInfoAMDGPUNumSGPR::Instance; static constexpr ParsedAttrInfo::Spelling AMDGPUNumVGPRSpellings[] = { {AttributeCommonInfo::AS_GNU, "amdgpu_num_vgpr"}, {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_num_vgpr"}, }; static constexpr const char AMDGPUNumVGPRArgNames[] = { "NumVGPR",}; struct ParsedAttrInfoAMDGPUNumVGPR final : public ParsedAttrInfo { constexpr ParsedAttrInfoAMDGPUNumVGPR() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AMDGPUNumVGPR, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AMDGPUNumVGPRSpellings, /ArgNames=/AMDGPUNumVGPRArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "kernel functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAMDGPUNumVGPR Instance; }; const ParsedAttrInfoAMDGPUNumVGPR ParsedAttrInfoAMDGPUNumVGPR::Instance; static constexpr ParsedAttrInfo::Spelling AMDGPUWavesPerEUSpellings[] = { {AttributeCommonInfo::AS_GNU, "amdgpu_waves_per_eu"}, {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_waves_per_eu"}, }; static constexpr const char AMDGPUWavesPerEUArgNames[] = { "Min","Max",}; struct ParsedAttrInfoAMDGPUWavesPerEU final : public ParsedAttrInfo { constexpr ParsedAttrInfoAMDGPUWavesPerEU() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AMDGPUWavesPerEU, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AMDGPUWavesPerEUSpellings, /ArgNames=/AMDGPUWavesPerEUArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "kernel functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoAMDGPUWavesPerEU Instance; }; const ParsedAttrInfoAMDGPUWavesPerEU ParsedAttrInfoAMDGPUWavesPerEU::Instance; static constexpr ParsedAttrInfo::Spelling InterruptSpellings[] = { {AttributeCommonInfo::AS_GNU, "interrupt"}, {AttributeCommonInfo::AS_CXX11, "gnu::interrupt"}, {AttributeCommonInfo::AS_C2x, "gnu::interrupt"}, }; static constexpr const char InterruptArgNames[] = { "Interrupt",}; struct ParsedAttrInfoInterrupt final : public ParsedAttrInfo { constexpr ParsedAttrInfoInterrupt() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Interrupt, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/InterruptSpellings, /ArgNames=/InterruptArgNames) {} bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; 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::m68k \|\| 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); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoInterrupt Instance; }; const ParsedAttrInfoInterrupt ParsedAttrInfoInterrupt::Instance; static constexpr ParsedAttrInfo::Spelling AVRSignalSpellings[] = { {AttributeCommonInfo::AS_GNU, "signal"}, {AttributeCommonInfo::AS_CXX11, "gnu::signal"}, {AttributeCommonInfo::AS_C2x, "gnu::signal"}, }; struct ParsedAttrInfoAVRSignal final : public ParsedAttrInfo { constexpr ParsedAttrInfoAVRSignal() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AVRSignal, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AVRSignalSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::avr); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAVRSignal Instance; }; const ParsedAttrInfoAVRSignal ParsedAttrInfoAVRSignal::Instance; static constexpr ParsedAttrInfo::Spelling AbiTagSpellings[] = { {AttributeCommonInfo::AS_GNU, "abi_tag"}, {AttributeCommonInfo::AS_CXX11, "gnu::abi_tag"}, }; static constexpr const char AbiTagArgNames[] = { "Tags...",}; struct ParsedAttrInfoAbiTag final : public ParsedAttrInfo { constexpr ParsedAttrInfoAbiTag() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AbiTag, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AbiTagSpellings, /ArgNames=/AbiTagArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isStruct(D) && !isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<NamespaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, variables, functions, and namespaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAbiTag Instance; }; const ParsedAttrInfoAbiTag ParsedAttrInfoAbiTag::Instance; static constexpr ParsedAttrInfo::Spelling AcquireCapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "acquire_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::acquire_capability"}, {AttributeCommonInfo::AS_GNU, "acquire_shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::acquire_shared_capability"}, {AttributeCommonInfo::AS_GNU, "exclusive_lock_function"}, {AttributeCommonInfo::AS_GNU, "shared_lock_function"}, }; static constexpr const char AcquireCapabilityArgNames[] = { "Args...",}; struct ParsedAttrInfoAcquireCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoAcquireCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AcquireCapability, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AcquireCapabilitySpellings, /ArgNames=/AcquireCapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAcquireCapability Instance; }; const ParsedAttrInfoAcquireCapability ParsedAttrInfoAcquireCapability::Instance; static constexpr ParsedAttrInfo::Spelling AcquireHandleSpellings[] = { {AttributeCommonInfo::AS_GNU, "acquire_handle"}, {AttributeCommonInfo::AS_CXX11, "clang::acquire_handle"}, {AttributeCommonInfo::AS_C2x, "clang::acquire_handle"}, }; static constexpr const char AcquireHandleArgNames[] = { "HandleType",}; struct ParsedAttrInfoAcquireHandle final : public ParsedAttrInfo { constexpr ParsedAttrInfoAcquireHandle() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AcquireHandle, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AcquireHandleSpellings, /ArgNames=/AcquireHandleArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, typedefs, and parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAcquireHandle Instance; }; const ParsedAttrInfoAcquireHandle ParsedAttrInfoAcquireHandle::Instance; static constexpr ParsedAttrInfo::Spelling AcquiredAfterSpellings[] = { {AttributeCommonInfo::AS_GNU, "acquired_after"}, }; static constexpr const char AcquiredAfterArgNames[] = { "Args...",}; struct ParsedAttrInfoAcquiredAfter final : public ParsedAttrInfo { constexpr ParsedAttrInfoAcquiredAfter() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AcquiredAfter, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AcquiredAfterSpellings, /ArgNames=/AcquiredAfterArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAcquiredAfter Instance; }; const ParsedAttrInfoAcquiredAfter ParsedAttrInfoAcquiredAfter::Instance; static constexpr ParsedAttrInfo::Spelling AcquiredBeforeSpellings[] = { {AttributeCommonInfo::AS_GNU, "acquired_before"}, }; static constexpr const char AcquiredBeforeArgNames[] = { "Args...",}; struct ParsedAttrInfoAcquiredBefore final : public ParsedAttrInfo { constexpr ParsedAttrInfoAcquiredBefore() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AcquiredBefore, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AcquiredBeforeSpellings, /ArgNames=/AcquiredBeforeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAcquiredBefore Instance; }; const ParsedAttrInfoAcquiredBefore ParsedAttrInfoAcquiredBefore::Instance; static constexpr ParsedAttrInfo::Spelling AddressSpaceSpellings[] = { {AttributeCommonInfo::AS_GNU, "address_space"}, {AttributeCommonInfo::AS_CXX11, "clang::address_space"}, {AttributeCommonInfo::AS_C2x, "clang::address_space"}, }; static constexpr const char AddressSpaceArgNames[] = { "AddressSpace",}; struct ParsedAttrInfoAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AddressSpace, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AddressSpaceSpellings, /ArgNames=/AddressSpaceArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAddressSpace Instance; }; const ParsedAttrInfoAddressSpace ParsedAttrInfoAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling AliasSpellings[] = { {AttributeCommonInfo::AS_GNU, "alias"}, {AttributeCommonInfo::AS_CXX11, "gnu::alias"}, {AttributeCommonInfo::AS_C2x, "gnu::alias"}, }; static constexpr const char AliasArgNames[] = { "Aliasee",}; struct ParsedAttrInfoAlias final : public ParsedAttrInfo { constexpr ParsedAttrInfoAlias() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Alias, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AliasSpellings, /ArgNames=/AliasArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAlias Instance; }; const ParsedAttrInfoAlias ParsedAttrInfoAlias::Instance; static constexpr ParsedAttrInfo::Spelling AlignValueSpellings[] = { {AttributeCommonInfo::AS_GNU, "align_value"}, }; static constexpr const char AlignValueArgNames[] = { "Alignment",}; struct ParsedAttrInfoAlignValue final : public ParsedAttrInfo { constexpr ParsedAttrInfoAlignValue() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AlignValue, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AlignValueSpellings, /ArgNames=/AlignValueArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAlignValue Instance; }; const ParsedAttrInfoAlignValue ParsedAttrInfoAlignValue::Instance; static constexpr ParsedAttrInfo::Spelling AlignedSpellings[] = { {AttributeCommonInfo::AS_GNU, "aligned"}, {AttributeCommonInfo::AS_CXX11, "gnu::aligned"}, {AttributeCommonInfo::AS_C2x, "gnu::aligned"}, {AttributeCommonInfo::AS_Declspec, "align"}, {AttributeCommonInfo::AS_Keyword, "alignas"}, {AttributeCommonInfo::AS_Keyword, "_Alignas"}, }; static constexpr const char AlignedArgNames[] = { "Alignment",}; struct ParsedAttrInfoAligned final : public ParsedAttrInfo { constexpr ParsedAttrInfoAligned() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Aligned, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/AlignedSpellings, /ArgNames=/AlignedArgNames) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_aligned = 0, CXX11_gnu_aligned = 1, C2x_gnu_aligned = 2, Declspec_align = 3, Keyword_alignas = 4, Keyword_Alignas = 5, SpellingNotCalculated = 15 }; 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 C2x_gnu_aligned; case 3: return Declspec_align; case 4: return Keyword_alignas; case 5: return Keyword_Alignas; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAligned Instance; }; const ParsedAttrInfoAligned ParsedAttrInfoAligned::Instance; static constexpr ParsedAttrInfo::Spelling AllocAlignSpellings[] = { {AttributeCommonInfo::AS_GNU, "alloc_align"}, {AttributeCommonInfo::AS_CXX11, "gnu::alloc_align"}, {AttributeCommonInfo::AS_C2x, "gnu::alloc_align"}, }; static constexpr const char AllocAlignArgNames[] = { "ParamIndex",}; struct ParsedAttrInfoAllocAlign final : public ParsedAttrInfo { constexpr ParsedAttrInfoAllocAlign() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AllocAlign, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/AllocAlignSpellings, /ArgNames=/AllocAlignArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAllocAlign Instance; }; const ParsedAttrInfoAllocAlign ParsedAttrInfoAllocAlign::Instance; static constexpr ParsedAttrInfo::Spelling AllocSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "alloc_size"}, {AttributeCommonInfo::AS_CXX11, "gnu::alloc_size"}, {AttributeCommonInfo::AS_C2x, "gnu::alloc_size"}, }; static constexpr const char AllocSizeArgNames[] = { "ElemSizeParam","NumElemsParam",}; struct ParsedAttrInfoAllocSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoAllocSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AllocSize, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/AllocSizeSpellings, /ArgNames=/AllocSizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAllocSize Instance; }; const ParsedAttrInfoAllocSize ParsedAttrInfoAllocSize::Instance; static constexpr ParsedAttrInfo::Spelling AlwaysDestroySpellings[] = { {AttributeCommonInfo::AS_GNU, "always_destroy"}, {AttributeCommonInfo::AS_CXX11, "clang::always_destroy"}, }; struct ParsedAttrInfoAlwaysDestroy final : public ParsedAttrInfo { constexpr ParsedAttrInfoAlwaysDestroy() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AlwaysDestroy, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AlwaysDestroySpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<NoDestroyAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAlwaysDestroy Instance; }; const ParsedAttrInfoAlwaysDestroy ParsedAttrInfoAlwaysDestroy::Instance; static constexpr ParsedAttrInfo::Spelling AlwaysInlineSpellings[] = { {AttributeCommonInfo::AS_GNU, "always_inline"}, {AttributeCommonInfo::AS_CXX11, "gnu::always_inline"}, {AttributeCommonInfo::AS_C2x, "gnu::always_inline"}, {AttributeCommonInfo::AS_CXX11, "clang::always_inline"}, {AttributeCommonInfo::AS_C2x, "clang::always_inline"}, {AttributeCommonInfo::AS_Keyword, "__forceinline"}, }; struct ParsedAttrInfoAlwaysInline final : public ParsedAttrInfo { constexpr ParsedAttrInfoAlwaysInline() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AlwaysInline, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AlwaysInlineSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and statements"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<Stmt>(St)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and statements"; return false; } return true; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<NotTailCalledAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_always_inline = 0, CXX11_gnu_always_inline = 1, C2x_gnu_always_inline = 2, CXX11_clang_always_inline = 3, C2x_clang_always_inline = 4, Keyword_forceinline = 5, SpellingNotCalculated = 15 }; 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 C2x_gnu_always_inline; case 3: return CXX11_clang_always_inline; case 4: return C2x_clang_always_inline; case 5: return Keyword_forceinline; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAlwaysInline Instance; }; const ParsedAttrInfoAlwaysInline ParsedAttrInfoAlwaysInline::Instance; static constexpr ParsedAttrInfo::Spelling AnalyzerNoReturnSpellings[] = { {AttributeCommonInfo::AS_GNU, "analyzer_noreturn"}, }; struct ParsedAttrInfoAnalyzerNoReturn final : public ParsedAttrInfo { constexpr ParsedAttrInfoAnalyzerNoReturn() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AnalyzerNoReturn, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AnalyzerNoReturnSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAnalyzerNoReturn Instance; }; const ParsedAttrInfoAnalyzerNoReturn ParsedAttrInfoAnalyzerNoReturn::Instance; static constexpr ParsedAttrInfo::Spelling AnnotateSpellings[] = { {AttributeCommonInfo::AS_GNU, "annotate"}, {AttributeCommonInfo::AS_CXX11, "clang::annotate"}, {AttributeCommonInfo::AS_C2x, "clang::annotate"}, }; static constexpr const char AnnotateArgNames[] = { "Annotation","Args...",}; struct ParsedAttrInfoAnnotate final : public ParsedAttrInfo { constexpr ParsedAttrInfoAnnotate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Annotate, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/1, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AnnotateSpellings, /ArgNames=/AnnotateArgNames) {} bool isParamExpr(size_t N) const override { return (N == 1) \|\| false; } static const ParsedAttrInfoAnnotate Instance; }; const ParsedAttrInfoAnnotate ParsedAttrInfoAnnotate::Instance; static constexpr ParsedAttrInfo::Spelling AnnotateTypeSpellings[] = { {AttributeCommonInfo::AS_CXX11, "clang::annotate_type"}, {AttributeCommonInfo::AS_C2x, "clang::annotate_type"}, }; static constexpr const char AnnotateTypeArgNames[] = { "Annotation","Args...",}; struct ParsedAttrInfoAnnotateType final : public ParsedAttrInfo { constexpr ParsedAttrInfoAnnotateType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AnnotateType, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/1, /AcceptsExprPack=/1, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AnnotateTypeSpellings, /ArgNames=/AnnotateTypeArgNames) {} bool isParamExpr(size_t N) const override { return (N == 1) \|\| false; } static const ParsedAttrInfoAnnotateType Instance; }; const ParsedAttrInfoAnnotateType ParsedAttrInfoAnnotateType::Instance; static constexpr ParsedAttrInfo::Spelling AnyX86NoCallerSavedRegistersSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_caller_saved_registers"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_caller_saved_registers"}, {AttributeCommonInfo::AS_C2x, "gnu::no_caller_saved_registers"}, }; struct ParsedAttrInfoAnyX86NoCallerSavedRegisters final : public ParsedAttrInfo { constexpr ParsedAttrInfoAnyX86NoCallerSavedRegisters() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AnyX86NoCallerSavedRegisters, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/AnyX86NoCallerSavedRegistersSpellings, /ArgNames=/{}) {} bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::x86 \|\| T.getArch() == llvm::Triple::x86_64); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAnyX86NoCallerSavedRegisters Instance; }; const ParsedAttrInfoAnyX86NoCallerSavedRegisters ParsedAttrInfoAnyX86NoCallerSavedRegisters::Instance; static constexpr ParsedAttrInfo::Spelling AnyX86NoCfCheckSpellings[] = { {AttributeCommonInfo::AS_GNU, "nocf_check"}, {AttributeCommonInfo::AS_CXX11, "gnu::nocf_check"}, {AttributeCommonInfo::AS_C2x, "gnu::nocf_check"}, }; struct ParsedAttrInfoAnyX86NoCfCheck final : public ParsedAttrInfo { constexpr ParsedAttrInfoAnyX86NoCfCheck() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AnyX86NoCfCheck, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AnyX86NoCfCheckSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isFunctionLike(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::x86 \|\| T.getArch() == llvm::Triple::x86_64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAnyX86NoCfCheck Instance; }; const ParsedAttrInfoAnyX86NoCfCheck ParsedAttrInfoAnyX86NoCfCheck::Instance; static constexpr ParsedAttrInfo::Spelling ArcWeakrefUnavailableSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_arc_weak_reference_unavailable"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_arc_weak_reference_unavailable"}, {AttributeCommonInfo::AS_C2x, "clang::objc_arc_weak_reference_unavailable"}, }; struct ParsedAttrInfoArcWeakrefUnavailable final : public ParsedAttrInfo { constexpr ParsedAttrInfoArcWeakrefUnavailable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArcWeakrefUnavailable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ArcWeakrefUnavailableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArcWeakrefUnavailable Instance; }; const ParsedAttrInfoArcWeakrefUnavailable ParsedAttrInfoArcWeakrefUnavailable::Instance; static constexpr ParsedAttrInfo::Spelling ArgumentWithTypeTagSpellings[] = { {AttributeCommonInfo::AS_GNU, "argument_with_type_tag"}, {AttributeCommonInfo::AS_CXX11, "clang::argument_with_type_tag"}, {AttributeCommonInfo::AS_C2x, "clang::argument_with_type_tag"}, {AttributeCommonInfo::AS_GNU, "pointer_with_type_tag"}, {AttributeCommonInfo::AS_CXX11, "clang::pointer_with_type_tag"}, {AttributeCommonInfo::AS_C2x, "clang::pointer_with_type_tag"}, }; static constexpr const char ArgumentWithTypeTagArgNames[] = { "ArgumentKind","ArgumentIdx","TypeTagIdx",}; struct ParsedAttrInfoArgumentWithTypeTag final : public ParsedAttrInfo { constexpr ParsedAttrInfoArgumentWithTypeTag() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArgumentWithTypeTag, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ArgumentWithTypeTagSpellings, /ArgNames=/ArgumentWithTypeTagArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArgumentWithTypeTag Instance; }; const ParsedAttrInfoArgumentWithTypeTag ParsedAttrInfoArgumentWithTypeTag::Instance; static constexpr ParsedAttrInfo::Spelling ArmBuiltinAliasSpellings[] = { {AttributeCommonInfo::AS_GNU, "__clang_arm_builtin_alias"}, {AttributeCommonInfo::AS_CXX11, "clang::__clang_arm_builtin_alias"}, {AttributeCommonInfo::AS_C2x, "clang::__clang_arm_builtin_alias"}, }; static constexpr const char ArmBuiltinAliasArgNames[] = { "BuiltinName",}; struct ParsedAttrInfoArmBuiltinAlias final : public ParsedAttrInfo { constexpr ParsedAttrInfoArmBuiltinAlias() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArmBuiltinAlias, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ArmBuiltinAliasSpellings, /ArgNames=/ArmBuiltinAliasArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; 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::aarch64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArmBuiltinAlias Instance; }; const ParsedAttrInfoArmBuiltinAlias ParsedAttrInfoArmBuiltinAlias::Instance; static constexpr ParsedAttrInfo::Spelling ArmMveStrictPolymorphismSpellings[] = { {AttributeCommonInfo::AS_GNU, "__clang_arm_mve_strict_polymorphism"}, {AttributeCommonInfo::AS_CXX11, "clang::__clang_arm_mve_strict_polymorphism"}, {AttributeCommonInfo::AS_C2x, "clang::__clang_arm_mve_strict_polymorphism"}, }; struct ParsedAttrInfoArmMveStrictPolymorphism final : public ParsedAttrInfo { constexpr ParsedAttrInfoArmMveStrictPolymorphism() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArmMveStrictPolymorphism, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ArmMveStrictPolymorphismSpellings, /ArgNames=/{}) {} bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::arm \|\| T.getArch() == llvm::Triple::thumb \|\| T.getArch() == llvm::Triple::armeb \|\| T.getArch() == llvm::Triple::thumbeb); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArmMveStrictPolymorphism Instance; }; const ParsedAttrInfoArmMveStrictPolymorphism ParsedAttrInfoArmMveStrictPolymorphism::Instance; static constexpr ParsedAttrInfo::Spelling ArmStreamingSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__arm_streaming"}, }; struct ParsedAttrInfoArmStreaming final : public ParsedAttrInfo { constexpr ParsedAttrInfoArmStreaming() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArmStreaming, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ArmStreamingSpellings, /ArgNames=/{}) {} bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::aarch64); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArmStreaming Instance; }; const ParsedAttrInfoArmStreaming ParsedAttrInfoArmStreaming::Instance; static constexpr ParsedAttrInfo::Spelling ArmSveVectorBitsSpellings[] = { {AttributeCommonInfo::AS_GNU, "arm_sve_vector_bits"}, }; static constexpr const char ArmSveVectorBitsArgNames[] = { "NumBits",}; struct ParsedAttrInfoArmSveVectorBits final : public ParsedAttrInfo { constexpr ParsedAttrInfoArmSveVectorBits() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ArmSveVectorBits, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ArmSveVectorBitsSpellings, /ArgNames=/ArmSveVectorBitsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArmSveVectorBits Instance; }; const ParsedAttrInfoArmSveVectorBits ParsedAttrInfoArmSveVectorBits::Instance; static constexpr ParsedAttrInfo::Spelling ArtificialSpellings[] = { {AttributeCommonInfo::AS_GNU, "artificial"}, {AttributeCommonInfo::AS_CXX11, "gnu::artificial"}, {AttributeCommonInfo::AS_C2x, "gnu::artificial"}, }; struct ParsedAttrInfoArtificial final : public ParsedAttrInfo { constexpr ParsedAttrInfoArtificial() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Artificial, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/ArtificialSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isInlineFunction(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "inline functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ArtificialAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoArtificial Instance; }; const ParsedAttrInfoArtificial ParsedAttrInfoArtificial::Instance; static constexpr ParsedAttrInfo::Spelling AssertCapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "assert_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::assert_capability"}, {AttributeCommonInfo::AS_GNU, "assert_shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::assert_shared_capability"}, }; static constexpr const char AssertCapabilityArgNames[] = { "Args...",}; struct ParsedAttrInfoAssertCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoAssertCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AssertCapability, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AssertCapabilitySpellings, /ArgNames=/AssertCapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_assert_capability = 0, CXX11_clang_assert_capability = 1, GNU_assert_shared_capability = 2, CXX11_clang_assert_shared_capability = 3, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAssertCapability Instance; }; const ParsedAttrInfoAssertCapability ParsedAttrInfoAssertCapability::Instance; static constexpr ParsedAttrInfo::Spelling AssertExclusiveLockSpellings[] = { {AttributeCommonInfo::AS_GNU, "assert_exclusive_lock"}, }; static constexpr const char AssertExclusiveLockArgNames[] = { "Args...",}; struct ParsedAttrInfoAssertExclusiveLock final : public ParsedAttrInfo { constexpr ParsedAttrInfoAssertExclusiveLock() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AssertExclusiveLock, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AssertExclusiveLockSpellings, /ArgNames=/AssertExclusiveLockArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAssertExclusiveLock Instance; }; const ParsedAttrInfoAssertExclusiveLock ParsedAttrInfoAssertExclusiveLock::Instance; static constexpr ParsedAttrInfo::Spelling AssertSharedLockSpellings[] = { {AttributeCommonInfo::AS_GNU, "assert_shared_lock"}, }; static constexpr const char AssertSharedLockArgNames[] = { "Args...",}; struct ParsedAttrInfoAssertSharedLock final : public ParsedAttrInfo { constexpr ParsedAttrInfoAssertSharedLock() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AssertSharedLock, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/AssertSharedLockSpellings, /ArgNames=/AssertSharedLockArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoAssertSharedLock Instance; }; const ParsedAttrInfoAssertSharedLock ParsedAttrInfoAssertSharedLock::Instance; static constexpr ParsedAttrInfo::Spelling AssumeAlignedSpellings[] = { {AttributeCommonInfo::AS_GNU, "assume_aligned"}, {AttributeCommonInfo::AS_CXX11, "gnu::assume_aligned"}, {AttributeCommonInfo::AS_C2x, "gnu::assume_aligned"}, }; static constexpr const char AssumeAlignedArgNames[] = { "Alignment","Offset",}; struct ParsedAttrInfoAssumeAligned final : public ParsedAttrInfo { constexpr ParsedAttrInfoAssumeAligned() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AssumeAligned, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/AssumeAlignedSpellings, /ArgNames=/AssumeAlignedArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoAssumeAligned Instance; }; const ParsedAttrInfoAssumeAligned ParsedAttrInfoAssumeAligned::Instance; static constexpr ParsedAttrInfo::Spelling AssumptionSpellings[] = { {AttributeCommonInfo::AS_GNU, "assume"}, {AttributeCommonInfo::AS_CXX11, "clang::assume"}, {AttributeCommonInfo::AS_C2x, "clang::assume"}, }; static constexpr const char AssumptionArgNames[] = { "Assumption",}; struct ParsedAttrInfoAssumption final : public ParsedAttrInfo { constexpr ParsedAttrInfoAssumption() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Assumption, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AssumptionSpellings, /ArgNames=/AssumptionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAssumption Instance; }; const ParsedAttrInfoAssumption ParsedAttrInfoAssumption::Instance; static constexpr ParsedAttrInfo::Spelling AvailabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "availability"}, {AttributeCommonInfo::AS_CXX11, "clang::availability"}, {AttributeCommonInfo::AS_C2x, "clang::availability"}, }; static constexpr const char AvailabilityArgNames[] = { "platform","introduced","deprecated","obsoleted","unavailable","message","strict","replacement","priority",}; struct ParsedAttrInfoAvailability final : public ParsedAttrInfo { constexpr ParsedAttrInfoAvailability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Availability, /NumArgs=/9, /OptArgs=/0, /NumArgMembers=/9, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AvailabilitySpellings, /ArgNames=/AvailabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<NamedDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "named declarations"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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_implementation, /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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAvailability Instance; }; const ParsedAttrInfoAvailability ParsedAttrInfoAvailability::Instance; static constexpr ParsedAttrInfo::Spelling AvailableOnlyInDefaultEvalMethodSpellings[] = { {AttributeCommonInfo::AS_GNU, "available_only_in_default_eval_method"}, {AttributeCommonInfo::AS_CXX11, "clang::available_only_in_default_eval_method"}, {AttributeCommonInfo::AS_C2x, "clang::available_only_in_default_eval_method"}, }; struct ParsedAttrInfoAvailableOnlyInDefaultEvalMethod final : public ParsedAttrInfo { constexpr ParsedAttrInfoAvailableOnlyInDefaultEvalMethod() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_AvailableOnlyInDefaultEvalMethod, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/AvailableOnlyInDefaultEvalMethodSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoAvailableOnlyInDefaultEvalMethod Instance; }; const ParsedAttrInfoAvailableOnlyInDefaultEvalMethod ParsedAttrInfoAvailableOnlyInDefaultEvalMethod::Instance; static constexpr ParsedAttrInfo::Spelling BPFPreserveAccessIndexSpellings[] = { {AttributeCommonInfo::AS_GNU, "preserve_access_index"}, {AttributeCommonInfo::AS_CXX11, "clang::preserve_access_index"}, {AttributeCommonInfo::AS_C2x, "clang::preserve_access_index"}, }; struct ParsedAttrInfoBPFPreserveAccessIndex final : public ParsedAttrInfo { constexpr ParsedAttrInfoBPFPreserveAccessIndex() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_BPFPreserveAccessIndex, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/BPFPreserveAccessIndexSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::bpfel \|\| T.getArch() == llvm::Triple::bpfeb); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoBPFPreserveAccessIndex Instance; }; const ParsedAttrInfoBPFPreserveAccessIndex ParsedAttrInfoBPFPreserveAccessIndex::Instance; static constexpr ParsedAttrInfo::Spelling BTFDeclTagSpellings[] = { {AttributeCommonInfo::AS_GNU, "btf_decl_tag"}, {AttributeCommonInfo::AS_CXX11, "clang::btf_decl_tag"}, {AttributeCommonInfo::AS_C2x, "clang::btf_decl_tag"}, }; static constexpr const char BTFDeclTagArgNames[] = { "BTFDeclTag",}; struct ParsedAttrInfoBTFDeclTag final : public ParsedAttrInfo { constexpr ParsedAttrInfoBTFDeclTag() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_BTFDeclTag, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/BTFDeclTagSpellings, /ArgNames=/BTFDeclTagArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<RecordDecl>(D) && !isa<FieldDecl>(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, structs, unions, classes, non-static data members, and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoBTFDeclTag Instance; }; const ParsedAttrInfoBTFDeclTag ParsedAttrInfoBTFDeclTag::Instance; static constexpr ParsedAttrInfo::Spelling BTFTypeTagSpellings[] = { {AttributeCommonInfo::AS_GNU, "btf_type_tag"}, {AttributeCommonInfo::AS_CXX11, "clang::btf_type_tag"}, {AttributeCommonInfo::AS_C2x, "clang::btf_type_tag"}, }; static constexpr const char BTFTypeTagArgNames[] = { "BTFTypeTag",}; struct ParsedAttrInfoBTFTypeTag final : public ParsedAttrInfo { constexpr ParsedAttrInfoBTFTypeTag() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_BTFTypeTag, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/BTFTypeTagSpellings, /ArgNames=/BTFTypeTagArgNames) {} bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoBTFTypeTag Instance; }; const ParsedAttrInfoBTFTypeTag ParsedAttrInfoBTFTypeTag::Instance; static constexpr ParsedAttrInfo::Spelling BlocksSpellings[] = { {AttributeCommonInfo::AS_GNU, "blocks"}, {AttributeCommonInfo::AS_CXX11, "clang::blocks"}, {AttributeCommonInfo::AS_C2x, "clang::blocks"}, }; static constexpr const char BlocksArgNames[] = { "Type",}; struct ParsedAttrInfoBlocks final : public ParsedAttrInfo { constexpr ParsedAttrInfoBlocks() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Blocks, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/BlocksSpellings, /ArgNames=/BlocksArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoBlocks Instance; }; const ParsedAttrInfoBlocks ParsedAttrInfoBlocks::Instance; static constexpr ParsedAttrInfo::Spelling BuiltinAliasSpellings[] = { {AttributeCommonInfo::AS_CXX11, "clang::builtin_alias"}, {AttributeCommonInfo::AS_C2x, "clang::builtin_alias"}, {AttributeCommonInfo::AS_GNU, "clang_builtin_alias"}, }; static constexpr const char BuiltinAliasArgNames[] = { "BuiltinName",}; struct ParsedAttrInfoBuiltinAlias final : public ParsedAttrInfo { constexpr ParsedAttrInfoBuiltinAlias() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_BuiltinAlias, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/BuiltinAliasSpellings, /ArgNames=/BuiltinAliasArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { CXX11_clang_builtin_alias = 0, C2x_clang_builtin_alias = 1, GNU_clang_builtin_alias = 2, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return CXX11_clang_builtin_alias; case 1: return C2x_clang_builtin_alias; case 2: return GNU_clang_builtin_alias; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoBuiltinAlias Instance; }; const ParsedAttrInfoBuiltinAlias ParsedAttrInfoBuiltinAlias::Instance; static constexpr ParsedAttrInfo::Spelling CDeclSpellings[] = { {AttributeCommonInfo::AS_GNU, "cdecl"}, {AttributeCommonInfo::AS_CXX11, "gnu::cdecl"}, {AttributeCommonInfo::AS_C2x, "gnu::cdecl"}, {AttributeCommonInfo::AS_Keyword, "__cdecl"}, {AttributeCommonInfo::AS_Keyword, "_cdecl"}, }; struct ParsedAttrInfoCDecl final : public ParsedAttrInfo { constexpr ParsedAttrInfoCDecl() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CDecl, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/CDeclSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCDecl Instance; }; const ParsedAttrInfoCDecl ParsedAttrInfoCDecl::Instance; static constexpr ParsedAttrInfo::Spelling CFAuditedTransferSpellings[] = { {AttributeCommonInfo::AS_GNU, "cf_audited_transfer"}, {AttributeCommonInfo::AS_CXX11, "clang::cf_audited_transfer"}, {AttributeCommonInfo::AS_C2x, "clang::cf_audited_transfer"}, }; struct ParsedAttrInfoCFAuditedTransfer final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFAuditedTransfer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFAuditedTransfer, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CFAuditedTransferSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CFUnknownTransferAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CFAuditedTransferAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFAuditedTransfer Instance; }; const ParsedAttrInfoCFAuditedTransfer ParsedAttrInfoCFAuditedTransfer::Instance; static constexpr ParsedAttrInfo::Spelling CFConsumedSpellings[] = { {AttributeCommonInfo::AS_GNU, "cf_consumed"}, {AttributeCommonInfo::AS_CXX11, "clang::cf_consumed"}, {AttributeCommonInfo::AS_C2x, "clang::cf_consumed"}, }; struct ParsedAttrInfoCFConsumed final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFConsumed() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFConsumed, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CFConsumedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFConsumed Instance; }; const ParsedAttrInfoCFConsumed ParsedAttrInfoCFConsumed::Instance; static constexpr ParsedAttrInfo::Spelling CFGuardSpellings[] = { {AttributeCommonInfo::AS_Declspec, "guard"}, {AttributeCommonInfo::AS_GNU, "guard"}, {AttributeCommonInfo::AS_CXX11, "clang::guard"}, {AttributeCommonInfo::AS_C2x, "clang::guard"}, }; static constexpr const char CFGuardArgNames[] = { "Guard",}; struct ParsedAttrInfoCFGuard final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFGuard() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFGuard, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CFGuardSpellings, /ArgNames=/CFGuardArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getOS() == llvm::Triple::Win32); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFGuard Instance; }; const ParsedAttrInfoCFGuard ParsedAttrInfoCFGuard::Instance; static constexpr ParsedAttrInfo::Spelling CFICanonicalJumpTableSpellings[] = { {AttributeCommonInfo::AS_GNU, "cfi_canonical_jump_table"}, {AttributeCommonInfo::AS_CXX11, "clang::cfi_canonical_jump_table"}, {AttributeCommonInfo::AS_C2x, "clang::cfi_canonical_jump_table"}, }; struct ParsedAttrInfoCFICanonicalJumpTable final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFICanonicalJumpTable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFICanonicalJumpTable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CFICanonicalJumpTableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CFICanonicalJumpTableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFICanonicalJumpTable Instance; }; const ParsedAttrInfoCFICanonicalJumpTable ParsedAttrInfoCFICanonicalJumpTable::Instance; static constexpr ParsedAttrInfo::Spelling CFReturnsNotRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "cf_returns_not_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::cf_returns_not_retained"}, {AttributeCommonInfo::AS_C2x, "clang::cf_returns_not_retained"}, }; struct ParsedAttrInfoCFReturnsNotRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFReturnsNotRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFReturnsNotRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/CFReturnsNotRetainedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFReturnsNotRetained Instance; }; const ParsedAttrInfoCFReturnsNotRetained ParsedAttrInfoCFReturnsNotRetained::Instance; static constexpr ParsedAttrInfo::Spelling CFReturnsRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "cf_returns_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::cf_returns_retained"}, {AttributeCommonInfo::AS_C2x, "clang::cf_returns_retained"}, }; struct ParsedAttrInfoCFReturnsRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFReturnsRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFReturnsRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/CFReturnsRetainedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFReturnsRetained Instance; }; const ParsedAttrInfoCFReturnsRetained ParsedAttrInfoCFReturnsRetained::Instance; static constexpr ParsedAttrInfo::Spelling CFUnknownTransferSpellings[] = { {AttributeCommonInfo::AS_GNU, "cf_unknown_transfer"}, {AttributeCommonInfo::AS_CXX11, "clang::cf_unknown_transfer"}, {AttributeCommonInfo::AS_C2x, "clang::cf_unknown_transfer"}, }; struct ParsedAttrInfoCFUnknownTransfer final : public ParsedAttrInfo { constexpr ParsedAttrInfoCFUnknownTransfer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CFUnknownTransfer, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CFUnknownTransferSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CFAuditedTransferAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CFUnknownTransferAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCFUnknownTransfer Instance; }; const ParsedAttrInfoCFUnknownTransfer ParsedAttrInfoCFUnknownTransfer::Instance; static constexpr ParsedAttrInfo::Spelling CPUDispatchSpellings[] = { {AttributeCommonInfo::AS_GNU, "cpu_dispatch"}, {AttributeCommonInfo::AS_CXX11, "clang::cpu_dispatch"}, {AttributeCommonInfo::AS_C2x, "clang::cpu_dispatch"}, {AttributeCommonInfo::AS_Declspec, "cpu_dispatch"}, }; static constexpr const char CPUDispatchArgNames[] = { "Cpus...",}; struct ParsedAttrInfoCPUDispatch final : public ParsedAttrInfo { constexpr ParsedAttrInfoCPUDispatch() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CPUDispatch, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CPUDispatchSpellings, /ArgNames=/CPUDispatchArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<TargetClonesAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetVersionAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUSpecificAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCPUDispatch Instance; }; const ParsedAttrInfoCPUDispatch ParsedAttrInfoCPUDispatch::Instance; static constexpr ParsedAttrInfo::Spelling CPUSpecificSpellings[] = { {AttributeCommonInfo::AS_GNU, "cpu_specific"}, {AttributeCommonInfo::AS_CXX11, "clang::cpu_specific"}, {AttributeCommonInfo::AS_C2x, "clang::cpu_specific"}, {AttributeCommonInfo::AS_Declspec, "cpu_specific"}, }; static constexpr const char CPUSpecificArgNames[] = { "Cpus...",}; struct ParsedAttrInfoCPUSpecific final : public ParsedAttrInfo { constexpr ParsedAttrInfoCPUSpecific() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CPUSpecific, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CPUSpecificSpellings, /ArgNames=/CPUSpecificArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<TargetClonesAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetVersionAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUDispatchAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCPUSpecific Instance; }; const ParsedAttrInfoCPUSpecific ParsedAttrInfoCPUSpecific::Instance; static constexpr ParsedAttrInfo::Spelling CUDAConstantSpellings[] = { {AttributeCommonInfo::AS_GNU, "constant"}, {AttributeCommonInfo::AS_Declspec, "__constant__"}, }; struct ParsedAttrInfoCUDAConstant final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDAConstant() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDAConstant, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDAConstantSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDASharedAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<HIPManagedAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDAConstant Instance; }; const ParsedAttrInfoCUDAConstant ParsedAttrInfoCUDAConstant::Instance; static constexpr ParsedAttrInfo::Spelling CUDADeviceSpellings[] = { {AttributeCommonInfo::AS_GNU, "device"}, {AttributeCommonInfo::AS_Declspec, "__device__"}, }; struct ParsedAttrInfoCUDADevice final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDADevice() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDADevice, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDADeviceSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDAGlobalAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDADevice Instance; }; const ParsedAttrInfoCUDADevice ParsedAttrInfoCUDADevice::Instance; static constexpr ParsedAttrInfo::Spelling CUDADeviceBuiltinSurfaceTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "device_builtin_surface_type"}, {AttributeCommonInfo::AS_Declspec, "__device_builtin_surface_type__"}, }; struct ParsedAttrInfoCUDADeviceBuiltinSurfaceType final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDADeviceBuiltinSurfaceType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDADeviceBuiltinSurfaceType, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDADeviceBuiltinSurfaceTypeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDADeviceBuiltinTextureTypeAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CUDADeviceBuiltinSurfaceTypeAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDADeviceBuiltinSurfaceType Instance; }; const ParsedAttrInfoCUDADeviceBuiltinSurfaceType ParsedAttrInfoCUDADeviceBuiltinSurfaceType::Instance; static constexpr ParsedAttrInfo::Spelling CUDADeviceBuiltinTextureTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "device_builtin_texture_type"}, {AttributeCommonInfo::AS_Declspec, "__device_builtin_texture_type__"}, }; struct ParsedAttrInfoCUDADeviceBuiltinTextureType final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDADeviceBuiltinTextureType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDADeviceBuiltinTextureType, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDADeviceBuiltinTextureTypeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDADeviceBuiltinSurfaceTypeAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CUDADeviceBuiltinTextureTypeAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDADeviceBuiltinTextureType Instance; }; const ParsedAttrInfoCUDADeviceBuiltinTextureType ParsedAttrInfoCUDADeviceBuiltinTextureType::Instance; static constexpr ParsedAttrInfo::Spelling CUDAGlobalSpellings[] = { {AttributeCommonInfo::AS_GNU, "global"}, {AttributeCommonInfo::AS_Declspec, "__global__"}, }; struct ParsedAttrInfoCUDAGlobal final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDAGlobal() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDAGlobal, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDAGlobalSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDADeviceAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CUDAHostAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDAGlobal Instance; }; const ParsedAttrInfoCUDAGlobal ParsedAttrInfoCUDAGlobal::Instance; static constexpr ParsedAttrInfo::Spelling CUDAHostSpellings[] = { {AttributeCommonInfo::AS_GNU, "host"}, {AttributeCommonInfo::AS_Declspec, "__host__"}, }; struct ParsedAttrInfoCUDAHost final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDAHost() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDAHost, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDAHostSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDAGlobalAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) CUDAHostAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDAHost Instance; }; const ParsedAttrInfoCUDAHost ParsedAttrInfoCUDAHost::Instance; struct ParsedAttrInfoCUDAInvalidTarget final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDAInvalidTarget() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDAInvalidTarget, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDAInvalidTarget Instance; }; const ParsedAttrInfoCUDAInvalidTarget ParsedAttrInfoCUDAInvalidTarget::Instance; static constexpr ParsedAttrInfo::Spelling CUDALaunchBoundsSpellings[] = { {AttributeCommonInfo::AS_GNU, "launch_bounds"}, {AttributeCommonInfo::AS_Declspec, "__launch_bounds__"}, }; static constexpr const char CUDALaunchBoundsArgNames[] = { "MaxThreads","MinBlocks",}; struct ParsedAttrInfoCUDALaunchBounds final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDALaunchBounds() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDALaunchBounds, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDALaunchBoundsSpellings, /ArgNames=/CUDALaunchBoundsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isFunctionLike(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, functions, and function pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoCUDALaunchBounds Instance; }; const ParsedAttrInfoCUDALaunchBounds ParsedAttrInfoCUDALaunchBounds::Instance; static constexpr ParsedAttrInfo::Spelling CUDASharedSpellings[] = { {AttributeCommonInfo::AS_GNU, "shared"}, {AttributeCommonInfo::AS_Declspec, "__shared__"}, }; struct ParsedAttrInfoCUDAShared final : public ParsedAttrInfo { constexpr ParsedAttrInfoCUDAShared() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CUDAShared, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CUDASharedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDAConstantAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<HIPManagedAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CUDA; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCUDAShared Instance; }; const ParsedAttrInfoCUDAShared ParsedAttrInfoCUDAShared::Instance; static constexpr ParsedAttrInfo::Spelling CXX11NoReturnSpellings[] = { {AttributeCommonInfo::AS_CXX11, "noreturn"}, {AttributeCommonInfo::AS_C2x, "noreturn"}, {AttributeCommonInfo::AS_C2x, "_Noreturn"}, }; struct ParsedAttrInfoCXX11NoReturn final : public ParsedAttrInfo { constexpr ParsedAttrInfoCXX11NoReturn() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CXX11NoReturn, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CXX11NoReturnSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { CXX11_noreturn = 0, C2x_noreturn = 1, C2x_Noreturn = 2, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return CXX11_noreturn; case 1: return C2x_noreturn; case 2: return C2x_Noreturn; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCXX11NoReturn Instance; }; const ParsedAttrInfoCXX11NoReturn ParsedAttrInfoCXX11NoReturn::Instance; static constexpr ParsedAttrInfo::Spelling CallableWhenSpellings[] = { {AttributeCommonInfo::AS_GNU, "callable_when"}, {AttributeCommonInfo::AS_CXX11, "clang::callable_when"}, }; static constexpr const char CallableWhenArgNames[] = { "CallableStates...",}; struct ParsedAttrInfoCallableWhen final : public ParsedAttrInfo { constexpr ParsedAttrInfoCallableWhen() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CallableWhen, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CallableWhenSpellings, /ArgNames=/CallableWhenArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /IsSupported=/LangOpts.CPlusPlus)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCallableWhen Instance; }; const ParsedAttrInfoCallableWhen ParsedAttrInfoCallableWhen::Instance; static constexpr ParsedAttrInfo::Spelling CallbackSpellings[] = { {AttributeCommonInfo::AS_GNU, "callback"}, {AttributeCommonInfo::AS_CXX11, "clang::callback"}, {AttributeCommonInfo::AS_C2x, "clang::callback"}, }; static constexpr const char CallbackArgNames[] = { "Encoding...",}; struct ParsedAttrInfoCallback final : public ParsedAttrInfo { constexpr ParsedAttrInfoCallback() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Callback, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CallbackSpellings, /ArgNames=/CallbackArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCallback Instance; }; const ParsedAttrInfoCallback ParsedAttrInfoCallback::Instance; static constexpr ParsedAttrInfo::Spelling CalledOnceSpellings[] = { {AttributeCommonInfo::AS_GNU, "called_once"}, {AttributeCommonInfo::AS_CXX11, "clang::called_once"}, {AttributeCommonInfo::AS_C2x, "clang::called_once"}, }; struct ParsedAttrInfoCalledOnce final : public ParsedAttrInfo { constexpr ParsedAttrInfoCalledOnce() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CalledOnce, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CalledOnceSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjC; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCalledOnce Instance; }; const ParsedAttrInfoCalledOnce ParsedAttrInfoCalledOnce::Instance; static constexpr ParsedAttrInfo::Spelling CapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "capability"}, {AttributeCommonInfo::AS_CXX11, "clang::capability"}, {AttributeCommonInfo::AS_GNU, "shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::shared_capability"}, }; static constexpr const char CapabilityArgNames[] = { "Name",}; struct ParsedAttrInfoCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Capability, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CapabilitySpellings, /ArgNames=/CapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_capability = 0, CXX11_clang_capability = 1, GNU_shared_capability = 2, CXX11_clang_shared_capability = 3, SpellingNotCalculated = 15 }; 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; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCapability Instance; }; const ParsedAttrInfoCapability ParsedAttrInfoCapability::Instance; static constexpr ParsedAttrInfo::Spelling CarriesDependencySpellings[] = { {AttributeCommonInfo::AS_GNU, "carries_dependency"}, {AttributeCommonInfo::AS_CXX11, "carries_dependency"}, }; struct ParsedAttrInfoCarriesDependency final : public ParsedAttrInfo { constexpr ParsedAttrInfoCarriesDependency() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CarriesDependency, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CarriesDependencySpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters, Objective-C methods, and functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCarriesDependency Instance; }; const ParsedAttrInfoCarriesDependency ParsedAttrInfoCarriesDependency::Instance; static constexpr ParsedAttrInfo::Spelling CleanupSpellings[] = { {AttributeCommonInfo::AS_GNU, "cleanup"}, {AttributeCommonInfo::AS_CXX11, "gnu::cleanup"}, {AttributeCommonInfo::AS_C2x, "gnu::cleanup"}, }; static constexpr const char CleanupArgNames[] = { "FunctionDecl",}; struct ParsedAttrInfoCleanup final : public ParsedAttrInfo { constexpr ParsedAttrInfoCleanup() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Cleanup, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/CleanupSpellings, /ArgNames=/CleanupArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isLocalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "local variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_local, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCleanup Instance; }; const ParsedAttrInfoCleanup ParsedAttrInfoCleanup::Instance; static constexpr ParsedAttrInfo::Spelling CmseNSCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "cmse_nonsecure_call"}, }; struct ParsedAttrInfoCmseNSCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoCmseNSCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CmseNSCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/CmseNSCallSpellings, /ArgNames=/{}) {} bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.Cmse; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::arm \|\| T.getArch() == llvm::Triple::thumb \|\| T.getArch() == llvm::Triple::armeb \|\| T.getArch() == llvm::Triple::thumbeb); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCmseNSCall Instance; }; const ParsedAttrInfoCmseNSCall ParsedAttrInfoCmseNSCall::Instance; static constexpr ParsedAttrInfo::Spelling CmseNSEntrySpellings[] = { {AttributeCommonInfo::AS_GNU, "cmse_nonsecure_entry"}, }; struct ParsedAttrInfoCmseNSEntry final : public ParsedAttrInfo { constexpr ParsedAttrInfoCmseNSEntry() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CmseNSEntry, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/CmseNSEntrySpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.Cmse; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::arm \|\| T.getArch() == llvm::Triple::thumb \|\| T.getArch() == llvm::Triple::armeb \|\| T.getArch() == llvm::Triple::thumbeb); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCmseNSEntry Instance; }; const ParsedAttrInfoCmseNSEntry ParsedAttrInfoCmseNSEntry::Instance; static constexpr ParsedAttrInfo::Spelling CodeSegSpellings[] = { {AttributeCommonInfo::AS_Declspec, "code_seg"}, }; static constexpr const char CodeSegArgNames[] = { "Name",}; struct ParsedAttrInfoCodeSeg final : public ParsedAttrInfo { constexpr ParsedAttrInfoCodeSeg() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_CodeSeg, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/CodeSegSpellings, /ArgNames=/CodeSegArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCodeSeg Instance; }; const ParsedAttrInfoCodeSeg ParsedAttrInfoCodeSeg::Instance; static constexpr ParsedAttrInfo::Spelling ColdSpellings[] = { {AttributeCommonInfo::AS_GNU, "cold"}, {AttributeCommonInfo::AS_CXX11, "gnu::cold"}, {AttributeCommonInfo::AS_C2x, "gnu::cold"}, }; struct ParsedAttrInfoCold final : public ParsedAttrInfo { constexpr ParsedAttrInfoCold() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Cold, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ColdSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<HotAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ColdAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCold Instance; }; const ParsedAttrInfoCold ParsedAttrInfoCold::Instance; static constexpr ParsedAttrInfo::Spelling CommonSpellings[] = { {AttributeCommonInfo::AS_GNU, "common"}, {AttributeCommonInfo::AS_CXX11, "gnu::common"}, {AttributeCommonInfo::AS_C2x, "gnu::common"}, }; struct ParsedAttrInfoCommon final : public ParsedAttrInfo { constexpr ParsedAttrInfoCommon() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Common, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/CommonSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<InternalLinkageAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoCommon Instance; }; const ParsedAttrInfoCommon ParsedAttrInfoCommon::Instance; static constexpr ParsedAttrInfo::Spelling ConstSpellings[] = { {AttributeCommonInfo::AS_GNU, "const"}, {AttributeCommonInfo::AS_CXX11, "gnu::const"}, {AttributeCommonInfo::AS_C2x, "gnu::const"}, {AttributeCommonInfo::AS_GNU, "__const"}, {AttributeCommonInfo::AS_CXX11, "gnu::__const"}, {AttributeCommonInfo::AS_C2x, "gnu::__const"}, }; struct ParsedAttrInfoConst final : public ParsedAttrInfo { constexpr ParsedAttrInfoConst() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Const, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/ConstSpellings, /ArgNames=/{}) {} AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ConstAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConst Instance; }; const ParsedAttrInfoConst ParsedAttrInfoConst::Instance; static constexpr ParsedAttrInfo::Spelling ConstInitSpellings[] = { {AttributeCommonInfo::AS_Keyword, "constinit"}, {AttributeCommonInfo::AS_GNU, "require_constant_initialization"}, {AttributeCommonInfo::AS_CXX11, "clang::require_constant_initialization"}, }; struct ParsedAttrInfoConstInit final : public ParsedAttrInfo { constexpr ParsedAttrInfoConstInit() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ConstInit, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConstInitSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CPlusPlus; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_constinit = 0, GNU_require_constant_initialization = 1, CXX11_clang_require_constant_initialization = 2, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_constinit; case 1: return GNU_require_constant_initialization; case 2: return CXX11_clang_require_constant_initialization; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ConstInitAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConstInit Instance; }; const ParsedAttrInfoConstInit ParsedAttrInfoConstInit::Instance; static constexpr ParsedAttrInfo::Spelling ConstructorSpellings[] = { {AttributeCommonInfo::AS_GNU, "constructor"}, {AttributeCommonInfo::AS_CXX11, "gnu::constructor"}, {AttributeCommonInfo::AS_C2x, "gnu::constructor"}, }; static constexpr const char ConstructorArgNames[] = { "Priority",}; struct ParsedAttrInfoConstructor final : public ParsedAttrInfo { constexpr ParsedAttrInfoConstructor() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Constructor, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConstructorSpellings, /ArgNames=/ConstructorArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConstructor Instance; }; const ParsedAttrInfoConstructor ParsedAttrInfoConstructor::Instance; static constexpr ParsedAttrInfo::Spelling ConsumableSpellings[] = { {AttributeCommonInfo::AS_GNU, "consumable"}, {AttributeCommonInfo::AS_CXX11, "clang::consumable"}, }; static constexpr const char ConsumableArgNames[] = { "DefaultState",}; struct ParsedAttrInfoConsumable final : public ParsedAttrInfo { constexpr ParsedAttrInfoConsumable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Consumable, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConsumableSpellings, /ArgNames=/ConsumableArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConsumable Instance; }; const ParsedAttrInfoConsumable ParsedAttrInfoConsumable::Instance; static constexpr ParsedAttrInfo::Spelling ConsumableAutoCastSpellings[] = { {AttributeCommonInfo::AS_GNU, "consumable_auto_cast_state"}, {AttributeCommonInfo::AS_CXX11, "clang::consumable_auto_cast_state"}, }; struct ParsedAttrInfoConsumableAutoCast final : public ParsedAttrInfo { constexpr ParsedAttrInfoConsumableAutoCast() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ConsumableAutoCast, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConsumableAutoCastSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ConsumableAutoCastAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConsumableAutoCast Instance; }; const ParsedAttrInfoConsumableAutoCast ParsedAttrInfoConsumableAutoCast::Instance; static constexpr ParsedAttrInfo::Spelling ConsumableSetOnReadSpellings[] = { {AttributeCommonInfo::AS_GNU, "consumable_set_state_on_read"}, {AttributeCommonInfo::AS_CXX11, "clang::consumable_set_state_on_read"}, }; struct ParsedAttrInfoConsumableSetOnRead final : public ParsedAttrInfo { constexpr ParsedAttrInfoConsumableSetOnRead() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ConsumableSetOnRead, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConsumableSetOnReadSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ConsumableSetOnReadAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConsumableSetOnRead Instance; }; const ParsedAttrInfoConsumableSetOnRead ParsedAttrInfoConsumableSetOnRead::Instance; static constexpr ParsedAttrInfo::Spelling ConvergentSpellings[] = { {AttributeCommonInfo::AS_GNU, "convergent"}, {AttributeCommonInfo::AS_CXX11, "clang::convergent"}, {AttributeCommonInfo::AS_C2x, "clang::convergent"}, }; struct ParsedAttrInfoConvergent final : public ParsedAttrInfo { constexpr ParsedAttrInfoConvergent() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Convergent, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ConvergentSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ConvergentAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoConvergent Instance; }; const ParsedAttrInfoConvergent ParsedAttrInfoConvergent::Instance; static constexpr ParsedAttrInfo::Spelling DLLExportSpellings[] = { {AttributeCommonInfo::AS_Declspec, "dllexport"}, {AttributeCommonInfo::AS_GNU, "dllexport"}, {AttributeCommonInfo::AS_CXX11, "gnu::dllexport"}, {AttributeCommonInfo::AS_C2x, "gnu::dllexport"}, }; struct ParsedAttrInfoDLLExport final : public ParsedAttrInfo { constexpr ParsedAttrInfoDLLExport() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DLLExport, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/DLLExportSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, variables, classes, and Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( Target.getTriple().hasDLLImportExport() ); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDLLExport Instance; }; const ParsedAttrInfoDLLExport ParsedAttrInfoDLLExport::Instance; struct ParsedAttrInfoDLLExportStaticLocal final : public ParsedAttrInfo { constexpr ParsedAttrInfoDLLExportStaticLocal() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DLLExportStaticLocal, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( Target.getTriple().hasDLLImportExport() ); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDLLExportStaticLocal Instance; }; const ParsedAttrInfoDLLExportStaticLocal ParsedAttrInfoDLLExportStaticLocal::Instance; static constexpr ParsedAttrInfo::Spelling DLLImportSpellings[] = { {AttributeCommonInfo::AS_Declspec, "dllimport"}, {AttributeCommonInfo::AS_GNU, "dllimport"}, {AttributeCommonInfo::AS_CXX11, "gnu::dllimport"}, {AttributeCommonInfo::AS_C2x, "gnu::dllimport"}, }; struct ParsedAttrInfoDLLImport final : public ParsedAttrInfo { constexpr ParsedAttrInfoDLLImport() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DLLImport, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/DLLImportSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, variables, classes, and Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( Target.getTriple().hasDLLImportExport() ); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDLLImport Instance; }; const ParsedAttrInfoDLLImport ParsedAttrInfoDLLImport::Instance; struct ParsedAttrInfoDLLImportStaticLocal final : public ParsedAttrInfo { constexpr ParsedAttrInfoDLLImportStaticLocal() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DLLImportStaticLocal, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( Target.getTriple().hasDLLImportExport() ); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDLLImportStaticLocal Instance; }; const ParsedAttrInfoDLLImportStaticLocal ParsedAttrInfoDLLImportStaticLocal::Instance; static constexpr ParsedAttrInfo::Spelling DeprecatedSpellings[] = { {AttributeCommonInfo::AS_GNU, "deprecated"}, {AttributeCommonInfo::AS_CXX11, "gnu::deprecated"}, {AttributeCommonInfo::AS_C2x, "gnu::deprecated"}, {AttributeCommonInfo::AS_Declspec, "deprecated"}, {AttributeCommonInfo::AS_CXX11, "deprecated"}, {AttributeCommonInfo::AS_C2x, "deprecated"}, }; static constexpr const char DeprecatedArgNames[] = { "Message","Replacement",}; struct ParsedAttrInfoDeprecated final : public ParsedAttrInfo { constexpr ParsedAttrInfoDeprecated() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Deprecated, /NumArgs=/0, /OptArgs=/2, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/DeprecatedSpellings, /ArgNames=/DeprecatedArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDeprecated Instance; }; const ParsedAttrInfoDeprecated ParsedAttrInfoDeprecated::Instance; static constexpr ParsedAttrInfo::Spelling DestructorSpellings[] = { {AttributeCommonInfo::AS_GNU, "destructor"}, {AttributeCommonInfo::AS_CXX11, "gnu::destructor"}, {AttributeCommonInfo::AS_C2x, "gnu::destructor"}, }; static constexpr const char DestructorArgNames[] = { "Priority",}; struct ParsedAttrInfoDestructor final : public ParsedAttrInfo { constexpr ParsedAttrInfoDestructor() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Destructor, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/DestructorSpellings, /ArgNames=/DestructorArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDestructor Instance; }; const ParsedAttrInfoDestructor ParsedAttrInfoDestructor::Instance; static constexpr ParsedAttrInfo::Spelling DiagnoseAsBuiltinSpellings[] = { {AttributeCommonInfo::AS_GNU, "diagnose_as_builtin"}, {AttributeCommonInfo::AS_CXX11, "clang::diagnose_as_builtin"}, {AttributeCommonInfo::AS_C2x, "clang::diagnose_as_builtin"}, }; static constexpr const char DiagnoseAsBuiltinArgNames[] = { "Function","ArgIndices...",}; struct ParsedAttrInfoDiagnoseAsBuiltin final : public ParsedAttrInfo { constexpr ParsedAttrInfoDiagnoseAsBuiltin() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DiagnoseAsBuiltin, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/DiagnoseAsBuiltinSpellings, /ArgNames=/DiagnoseAsBuiltinArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDiagnoseAsBuiltin Instance; }; const ParsedAttrInfoDiagnoseAsBuiltin ParsedAttrInfoDiagnoseAsBuiltin::Instance; static constexpr ParsedAttrInfo::Spelling DiagnoseIfSpellings[] = { {AttributeCommonInfo::AS_GNU, "diagnose_if"}, }; static constexpr const char DiagnoseIfArgNames[] = { "Cond","Message","DiagnosticType",}; struct ParsedAttrInfoDiagnoseIf final : public ParsedAttrInfo { constexpr ParsedAttrInfoDiagnoseIf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DiagnoseIf, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/DiagnoseIfSpellings, /ArgNames=/DiagnoseIfArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and Objective-C properties"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoDiagnoseIf Instance; }; const ParsedAttrInfoDiagnoseIf ParsedAttrInfoDiagnoseIf::Instance; static constexpr ParsedAttrInfo::Spelling DisableSanitizerInstrumentationSpellings[] = { {AttributeCommonInfo::AS_GNU, "disable_sanitizer_instrumentation"}, {AttributeCommonInfo::AS_CXX11, "clang::disable_sanitizer_instrumentation"}, {AttributeCommonInfo::AS_C2x, "clang::disable_sanitizer_instrumentation"}, }; struct ParsedAttrInfoDisableSanitizerInstrumentation final : public ParsedAttrInfo { constexpr ParsedAttrInfoDisableSanitizerInstrumentation() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DisableSanitizerInstrumentation, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/DisableSanitizerInstrumentationSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) DisableSanitizerInstrumentationAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDisableSanitizerInstrumentation Instance; }; const ParsedAttrInfoDisableSanitizerInstrumentation ParsedAttrInfoDisableSanitizerInstrumentation::Instance; static constexpr ParsedAttrInfo::Spelling DisableTailCallsSpellings[] = { {AttributeCommonInfo::AS_GNU, "disable_tail_calls"}, {AttributeCommonInfo::AS_CXX11, "clang::disable_tail_calls"}, {AttributeCommonInfo::AS_C2x, "clang::disable_tail_calls"}, }; struct ParsedAttrInfoDisableTailCalls final : public ParsedAttrInfo { constexpr ParsedAttrInfoDisableTailCalls() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_DisableTailCalls, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/DisableTailCallsSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<NakedAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) DisableTailCallsAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoDisableTailCalls Instance; }; const ParsedAttrInfoDisableTailCalls ParsedAttrInfoDisableTailCalls::Instance; static constexpr ParsedAttrInfo::Spelling EmptyBasesSpellings[] = { {AttributeCommonInfo::AS_Declspec, "empty_bases"}, }; struct ParsedAttrInfoEmptyBases final : public ParsedAttrInfo { constexpr ParsedAttrInfoEmptyBases() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_EmptyBases, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/EmptyBasesSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; 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().isMicrosoft() ); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) EmptyBasesAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoEmptyBases Instance; }; const ParsedAttrInfoEmptyBases ParsedAttrInfoEmptyBases::Instance; static constexpr ParsedAttrInfo::Spelling EnableIfSpellings[] = { {AttributeCommonInfo::AS_GNU, "enable_if"}, }; static constexpr const char EnableIfArgNames[] = { "Cond","Message",}; struct ParsedAttrInfoEnableIf final : public ParsedAttrInfo { constexpr ParsedAttrInfoEnableIf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_EnableIf, /NumArgs=/2, /OptArgs=/0, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/EnableIfSpellings, /ArgNames=/EnableIfArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoEnableIf Instance; }; const ParsedAttrInfoEnableIf ParsedAttrInfoEnableIf::Instance; static constexpr ParsedAttrInfo::Spelling EnforceTCBSpellings[] = { {AttributeCommonInfo::AS_GNU, "enforce_tcb"}, {AttributeCommonInfo::AS_CXX11, "clang::enforce_tcb"}, {AttributeCommonInfo::AS_C2x, "clang::enforce_tcb"}, }; static constexpr const char EnforceTCBArgNames[] = { "TCBName",}; struct ParsedAttrInfoEnforceTCB final : public ParsedAttrInfo { constexpr ParsedAttrInfoEnforceTCB() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_EnforceTCB, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/EnforceTCBSpellings, /ArgNames=/EnforceTCBArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoEnforceTCB Instance; }; const ParsedAttrInfoEnforceTCB ParsedAttrInfoEnforceTCB::Instance; static constexpr ParsedAttrInfo::Spelling EnforceTCBLeafSpellings[] = { {AttributeCommonInfo::AS_GNU, "enforce_tcb_leaf"}, {AttributeCommonInfo::AS_CXX11, "clang::enforce_tcb_leaf"}, {AttributeCommonInfo::AS_C2x, "clang::enforce_tcb_leaf"}, }; static constexpr const char EnforceTCBLeafArgNames[] = { "TCBName",}; struct ParsedAttrInfoEnforceTCBLeaf final : public ParsedAttrInfo { constexpr ParsedAttrInfoEnforceTCBLeaf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_EnforceTCBLeaf, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/EnforceTCBLeafSpellings, /ArgNames=/EnforceTCBLeafArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoEnforceTCBLeaf Instance; }; const ParsedAttrInfoEnforceTCBLeaf ParsedAttrInfoEnforceTCBLeaf::Instance; static constexpr ParsedAttrInfo::Spelling EnumExtensibilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "enum_extensibility"}, {AttributeCommonInfo::AS_CXX11, "clang::enum_extensibility"}, {AttributeCommonInfo::AS_C2x, "clang::enum_extensibility"}, }; static constexpr const char EnumExtensibilityArgNames[] = { "Extensibility",}; struct ParsedAttrInfoEnumExtensibility final : public ParsedAttrInfo { constexpr ParsedAttrInfoEnumExtensibility() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_EnumExtensibility, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/EnumExtensibilitySpellings, /ArgNames=/EnumExtensibilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<EnumDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "enums"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoEnumExtensibility Instance; }; const ParsedAttrInfoEnumExtensibility ParsedAttrInfoEnumExtensibility::Instance; static constexpr ParsedAttrInfo::Spelling ErrorSpellings[] = { {AttributeCommonInfo::AS_GNU, "error"}, {AttributeCommonInfo::AS_CXX11, "gnu::error"}, {AttributeCommonInfo::AS_C2x, "gnu::error"}, {AttributeCommonInfo::AS_GNU, "warning"}, {AttributeCommonInfo::AS_CXX11, "gnu::warning"}, {AttributeCommonInfo::AS_C2x, "gnu::warning"}, }; static constexpr const char ErrorArgNames[] = { "UserDiagnostic",}; struct ParsedAttrInfoError final : public ParsedAttrInfo { constexpr ParsedAttrInfoError() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Error, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ErrorSpellings, /ArgNames=/ErrorArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_error = 0, CXX11_gnu_error = 1, C2x_gnu_error = 2, GNU_warning = 3, CXX11_gnu_warning = 4, C2x_gnu_warning = 5, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return GNU_error; case 1: return CXX11_gnu_error; case 2: return C2x_gnu_error; case 3: return GNU_warning; case 4: return CXX11_gnu_warning; case 5: return C2x_gnu_warning; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoError Instance; }; const ParsedAttrInfoError ParsedAttrInfoError::Instance; static constexpr ParsedAttrInfo::Spelling ExcludeFromExplicitInstantiationSpellings[] = { {AttributeCommonInfo::AS_GNU, "exclude_from_explicit_instantiation"}, {AttributeCommonInfo::AS_CXX11, "clang::exclude_from_explicit_instantiation"}, {AttributeCommonInfo::AS_C2x, "clang::exclude_from_explicit_instantiation"}, }; struct ParsedAttrInfoExcludeFromExplicitInstantiation final : public ParsedAttrInfo { constexpr ParsedAttrInfoExcludeFromExplicitInstantiation() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ExcludeFromExplicitInstantiation, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ExcludeFromExplicitInstantiationSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ExcludeFromExplicitInstantiationAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoExcludeFromExplicitInstantiation Instance; }; const ParsedAttrInfoExcludeFromExplicitInstantiation ParsedAttrInfoExcludeFromExplicitInstantiation::Instance; static constexpr ParsedAttrInfo::Spelling ExclusiveTrylockFunctionSpellings[] = { {AttributeCommonInfo::AS_GNU, "exclusive_trylock_function"}, }; static constexpr const char ExclusiveTrylockFunctionArgNames[] = { "SuccessValue","Args...",}; struct ParsedAttrInfoExclusiveTrylockFunction final : public ParsedAttrInfo { constexpr ParsedAttrInfoExclusiveTrylockFunction() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ExclusiveTrylockFunction, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ExclusiveTrylockFunctionSpellings, /ArgNames=/ExclusiveTrylockFunctionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoExclusiveTrylockFunction Instance; }; const ParsedAttrInfoExclusiveTrylockFunction ParsedAttrInfoExclusiveTrylockFunction::Instance; static constexpr ParsedAttrInfo::Spelling ExtVectorTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "ext_vector_type"}, }; static constexpr const char ExtVectorTypeArgNames[] = { "NumElements",}; struct ParsedAttrInfoExtVectorType final : public ParsedAttrInfo { constexpr ParsedAttrInfoExtVectorType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ExtVectorType, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ExtVectorTypeSpellings, /ArgNames=/ExtVectorTypeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoExtVectorType Instance; }; const ParsedAttrInfoExtVectorType ParsedAttrInfoExtVectorType::Instance; static constexpr ParsedAttrInfo::Spelling ExternalSourceSymbolSpellings[] = { {AttributeCommonInfo::AS_GNU, "external_source_symbol"}, {AttributeCommonInfo::AS_CXX11, "clang::external_source_symbol"}, {AttributeCommonInfo::AS_C2x, "clang::external_source_symbol"}, }; static constexpr const char ExternalSourceSymbolArgNames[] = { "language","definedIn","generatedDeclaration","USR",}; struct ParsedAttrInfoExternalSourceSymbol final : public ParsedAttrInfo { constexpr ParsedAttrInfoExternalSourceSymbol() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ExternalSourceSymbol, /NumArgs=/0, /OptArgs=/4, /NumArgMembers=/4, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ExternalSourceSymbolSpellings, /ArgNames=/ExternalSourceSymbolArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<NamedDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "named declarations"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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_implementation, /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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoExternalSourceSymbol Instance; }; const ParsedAttrInfoExternalSourceSymbol ParsedAttrInfoExternalSourceSymbol::Instance; static constexpr ParsedAttrInfo::Spelling FallThroughSpellings[] = { {AttributeCommonInfo::AS_CXX11, "fallthrough"}, {AttributeCommonInfo::AS_C2x, "fallthrough"}, {AttributeCommonInfo::AS_CXX11, "clang::fallthrough"}, {AttributeCommonInfo::AS_GNU, "fallthrough"}, {AttributeCommonInfo::AS_CXX11, "gnu::fallthrough"}, {AttributeCommonInfo::AS_C2x, "gnu::fallthrough"}, }; struct ParsedAttrInfoFallThrough final : public ParsedAttrInfo { constexpr ParsedAttrInfoFallThrough() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_FallThrough, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/FallThroughSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl D) const override { S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl) << AL << AL.isRegularKeywordAttribute() << D->getLocation(); return false; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<NullStmt>(St) && !isa<SwitchCase>(St)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "empty statements"; return false; } return true; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFallThrough Instance; }; const ParsedAttrInfoFallThrough ParsedAttrInfoFallThrough::Instance; static constexpr ParsedAttrInfo::Spelling FastCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "fastcall"}, {AttributeCommonInfo::AS_CXX11, "gnu::fastcall"}, {AttributeCommonInfo::AS_C2x, "gnu::fastcall"}, {AttributeCommonInfo::AS_Keyword, "__fastcall"}, {AttributeCommonInfo::AS_Keyword, "_fastcall"}, }; struct ParsedAttrInfoFastCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoFastCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_FastCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/FastCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFastCall Instance; }; const ParsedAttrInfoFastCall ParsedAttrInfoFastCall::Instance; static constexpr ParsedAttrInfo::Spelling FlagEnumSpellings[] = { {AttributeCommonInfo::AS_GNU, "flag_enum"}, {AttributeCommonInfo::AS_CXX11, "clang::flag_enum"}, {AttributeCommonInfo::AS_C2x, "clang::flag_enum"}, }; struct ParsedAttrInfoFlagEnum final : public ParsedAttrInfo { constexpr ParsedAttrInfoFlagEnum() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_FlagEnum, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/FlagEnumSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<EnumDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "enums"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) FlagEnumAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFlagEnum Instance; }; const ParsedAttrInfoFlagEnum ParsedAttrInfoFlagEnum::Instance; static constexpr ParsedAttrInfo::Spelling FlattenSpellings[] = { {AttributeCommonInfo::AS_GNU, "flatten"}, {AttributeCommonInfo::AS_CXX11, "gnu::flatten"}, {AttributeCommonInfo::AS_C2x, "gnu::flatten"}, }; struct ParsedAttrInfoFlatten final : public ParsedAttrInfo { constexpr ParsedAttrInfoFlatten() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Flatten, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/FlattenSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) FlattenAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFlatten Instance; }; const ParsedAttrInfoFlatten ParsedAttrInfoFlatten::Instance; static constexpr ParsedAttrInfo::Spelling FormatSpellings[] = { {AttributeCommonInfo::AS_GNU, "format"}, {AttributeCommonInfo::AS_CXX11, "gnu::format"}, {AttributeCommonInfo::AS_C2x, "gnu::format"}, }; static constexpr const char FormatArgNames[] = { "Type","FormatIdx","FirstArg",}; struct ParsedAttrInfoFormat final : public ParsedAttrInfo { constexpr ParsedAttrInfoFormat() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Format, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/FormatSpellings, /ArgNames=/FormatArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D) && !isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, blocks, and non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFormat Instance; }; const ParsedAttrInfoFormat ParsedAttrInfoFormat::Instance; static constexpr ParsedAttrInfo::Spelling FormatArgSpellings[] = { {AttributeCommonInfo::AS_GNU, "format_arg"}, {AttributeCommonInfo::AS_CXX11, "gnu::format_arg"}, {AttributeCommonInfo::AS_C2x, "gnu::format_arg"}, }; static constexpr const char FormatArgArgNames[] = { "FormatIdx",}; struct ParsedAttrInfoFormatArg final : public ParsedAttrInfo { constexpr ParsedAttrInfoFormatArg() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_FormatArg, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/FormatArgSpellings, /ArgNames=/FormatArgArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFormatArg Instance; }; const ParsedAttrInfoFormatArg ParsedAttrInfoFormatArg::Instance; static constexpr ParsedAttrInfo::Spelling FunctionReturnThunksSpellings[] = { {AttributeCommonInfo::AS_GNU, "function_return"}, {AttributeCommonInfo::AS_CXX11, "gnu::function_return"}, {AttributeCommonInfo::AS_C2x, "gnu::function_return"}, }; static constexpr const char FunctionReturnThunksArgNames[] = { "ThunkType",}; struct ParsedAttrInfoFunctionReturnThunks final : public ParsedAttrInfo { constexpr ParsedAttrInfoFunctionReturnThunks() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_FunctionReturnThunks, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/FunctionReturnThunksSpellings, /ArgNames=/FunctionReturnThunksArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::x86 \|\| T.getArch() == llvm::Triple::x86_64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoFunctionReturnThunks Instance; }; const ParsedAttrInfoFunctionReturnThunks ParsedAttrInfoFunctionReturnThunks::Instance; static constexpr ParsedAttrInfo::Spelling GNUInlineSpellings[] = { {AttributeCommonInfo::AS_GNU, "gnu_inline"}, {AttributeCommonInfo::AS_CXX11, "gnu::gnu_inline"}, {AttributeCommonInfo::AS_C2x, "gnu::gnu_inline"}, }; struct ParsedAttrInfoGNUInline final : public ParsedAttrInfo { constexpr ParsedAttrInfoGNUInline() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_GNUInline, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/GNUInlineSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoGNUInline Instance; }; const ParsedAttrInfoGNUInline ParsedAttrInfoGNUInline::Instance; static constexpr ParsedAttrInfo::Spelling GuardedBySpellings[] = { {AttributeCommonInfo::AS_GNU, "guarded_by"}, }; static constexpr const char GuardedByArgNames[] = { "Arg",}; struct ParsedAttrInfoGuardedBy final : public ParsedAttrInfo { constexpr ParsedAttrInfoGuardedBy() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_GuardedBy, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/GuardedBySpellings, /ArgNames=/GuardedByArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoGuardedBy Instance; }; const ParsedAttrInfoGuardedBy ParsedAttrInfoGuardedBy::Instance; static constexpr ParsedAttrInfo::Spelling GuardedVarSpellings[] = { {AttributeCommonInfo::AS_GNU, "guarded_var"}, {AttributeCommonInfo::AS_CXX11, "clang::guarded_var"}, }; struct ParsedAttrInfoGuardedVar final : public ParsedAttrInfo { constexpr ParsedAttrInfoGuardedVar() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_GuardedVar, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/GuardedVarSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) GuardedVarAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoGuardedVar Instance; }; const ParsedAttrInfoGuardedVar ParsedAttrInfoGuardedVar::Instance; static constexpr ParsedAttrInfo::Spelling HIPManagedSpellings[] = { {AttributeCommonInfo::AS_GNU, "managed"}, {AttributeCommonInfo::AS_Declspec, "__managed__"}, }; struct ParsedAttrInfoHIPManaged final : public ParsedAttrInfo { constexpr ParsedAttrInfoHIPManaged() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HIPManaged, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/HIPManagedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CUDAConstantAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CUDASharedAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HIP; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHIPManaged Instance; }; const ParsedAttrInfoHIPManaged ParsedAttrInfoHIPManaged::Instance; static constexpr ParsedAttrInfo::Spelling HLSLGroupSharedAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "groupshared"}, }; struct ParsedAttrInfoHLSLGroupSharedAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLGroupSharedAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLGroupSharedAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLGroupSharedAddressSpaceSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLGroupSharedAddressSpace Instance; }; const ParsedAttrInfoHLSLGroupSharedAddressSpace ParsedAttrInfoHLSLGroupSharedAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling HLSLNumThreadsSpellings[] = { {AttributeCommonInfo::AS_Microsoft, "numthreads"}, }; static constexpr const char HLSLNumThreadsArgNames[] = { "X","Y","Z",}; struct ParsedAttrInfoHLSLNumThreads final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLNumThreads() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLNumThreads, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLNumThreadsSpellings, /ArgNames=/HLSLNumThreadsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHLSLEntry(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLNumThreads Instance; }; const ParsedAttrInfoHLSLNumThreads ParsedAttrInfoHLSLNumThreads::Instance; static constexpr const char HLSLResourceArgNames[] = { "ResourceType","ResourceShape",}; struct ParsedAttrInfoHLSLResource final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLResource() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLResource, /NumArgs=/2, /OptArgs=/0, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/HLSLResourceArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isStruct(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLResource Instance; }; const ParsedAttrInfoHLSLResource ParsedAttrInfoHLSLResource::Instance; static constexpr ParsedAttrInfo::Spelling HLSLResourceBindingSpellings[] = { {AttributeCommonInfo::AS_HLSLSemantic, "register"}, }; static constexpr const char HLSLResourceBindingArgNames[] = { "Slot","Space",}; struct ParsedAttrInfoHLSLResourceBinding final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLResourceBinding() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLResourceBinding, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLResourceBindingSpellings, /ArgNames=/HLSLResourceBindingArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHLSLBufferObj(D) && !isExternalGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "cbuffer/tbuffer and external global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLResourceBinding Instance; }; const ParsedAttrInfoHLSLResourceBinding ParsedAttrInfoHLSLResourceBinding::Instance; static constexpr ParsedAttrInfo::Spelling HLSLSV_DispatchThreadIDSpellings[] = { {AttributeCommonInfo::AS_HLSLSemantic, "SV_DispatchThreadID"}, }; struct ParsedAttrInfoHLSLSV_DispatchThreadID final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLSV_DispatchThreadID() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLSV_DispatchThreadID, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLSV_DispatchThreadIDSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D) && !isa<FieldDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters and non-static data members"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLSV_DispatchThreadID Instance; }; const ParsedAttrInfoHLSLSV_DispatchThreadID ParsedAttrInfoHLSLSV_DispatchThreadID::Instance; static constexpr ParsedAttrInfo::Spelling HLSLSV_GroupIndexSpellings[] = { {AttributeCommonInfo::AS_HLSLSemantic, "SV_GroupIndex"}, }; struct ParsedAttrInfoHLSLSV_GroupIndex final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLSV_GroupIndex() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLSV_GroupIndex, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLSV_GroupIndexSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D) && !isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLSV_GroupIndex Instance; }; const ParsedAttrInfoHLSLSV_GroupIndex ParsedAttrInfoHLSLSV_GroupIndex::Instance; static constexpr ParsedAttrInfo::Spelling HLSLShaderSpellings[] = { {AttributeCommonInfo::AS_Microsoft, "shader"}, }; static constexpr const char HLSLShaderArgNames[] = { "Type",}; struct ParsedAttrInfoHLSLShader final : public ParsedAttrInfo { constexpr ParsedAttrInfoHLSLShader() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_HLSLShader, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/HLSLShaderSpellings, /ArgNames=/HLSLShaderArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHLSLEntry(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.HLSL; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHLSLShader Instance; }; const ParsedAttrInfoHLSLShader ParsedAttrInfoHLSLShader::Instance; static constexpr ParsedAttrInfo::Spelling HotSpellings[] = { {AttributeCommonInfo::AS_GNU, "hot"}, {AttributeCommonInfo::AS_CXX11, "gnu::hot"}, {AttributeCommonInfo::AS_C2x, "gnu::hot"}, }; struct ParsedAttrInfoHot final : public ParsedAttrInfo { constexpr ParsedAttrInfoHot() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Hot, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/HotSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<ColdAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) HotAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoHot Instance; }; const ParsedAttrInfoHot ParsedAttrInfoHot::Instance; static constexpr ParsedAttrInfo::Spelling IBActionSpellings[] = { {AttributeCommonInfo::AS_GNU, "ibaction"}, {AttributeCommonInfo::AS_CXX11, "clang::ibaction"}, {AttributeCommonInfo::AS_C2x, "clang::ibaction"}, }; struct ParsedAttrInfoIBAction final : public ParsedAttrInfo { constexpr ParsedAttrInfoIBAction() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_IBAction, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/IBActionSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isObjCInstanceMethod(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C instance methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method_is_instance, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) IBActionAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoIBAction Instance; }; const ParsedAttrInfoIBAction ParsedAttrInfoIBAction::Instance; static constexpr ParsedAttrInfo::Spelling IBOutletSpellings[] = { {AttributeCommonInfo::AS_GNU, "iboutlet"}, {AttributeCommonInfo::AS_CXX11, "clang::iboutlet"}, {AttributeCommonInfo::AS_C2x, "clang::iboutlet"}, }; struct ParsedAttrInfoIBOutlet final : public ParsedAttrInfo { constexpr ParsedAttrInfoIBOutlet() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_IBOutlet, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/IBOutletSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoIBOutlet Instance; }; const ParsedAttrInfoIBOutlet ParsedAttrInfoIBOutlet::Instance; static constexpr ParsedAttrInfo::Spelling IBOutletCollectionSpellings[] = { {AttributeCommonInfo::AS_GNU, "iboutletcollection"}, {AttributeCommonInfo::AS_CXX11, "clang::iboutletcollection"}, {AttributeCommonInfo::AS_C2x, "clang::iboutletcollection"}, }; static constexpr const char IBOutletCollectionArgNames[] = { "Interface",}; struct ParsedAttrInfoIBOutletCollection final : public ParsedAttrInfo { constexpr ParsedAttrInfoIBOutletCollection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_IBOutletCollection, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/IBOutletCollectionSpellings, /ArgNames=/IBOutletCollectionArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoIBOutletCollection Instance; }; const ParsedAttrInfoIBOutletCollection ParsedAttrInfoIBOutletCollection::Instance; static constexpr ParsedAttrInfo::Spelling IFuncSpellings[] = { {AttributeCommonInfo::AS_GNU, "ifunc"}, {AttributeCommonInfo::AS_CXX11, "gnu::ifunc"}, {AttributeCommonInfo::AS_C2x, "gnu::ifunc"}, }; static constexpr const char IFuncArgNames[] = { "Resolver",}; struct ParsedAttrInfoIFunc final : public ParsedAttrInfo { constexpr ParsedAttrInfoIFunc() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_IFunc, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/IFuncSpellings, /ArgNames=/IFuncArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getObjectFormat() == llvm::Triple::ELF); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoIFunc Instance; }; const ParsedAttrInfoIFunc ParsedAttrInfoIFunc::Instance; static constexpr ParsedAttrInfo::Spelling InitPrioritySpellings[] = { {AttributeCommonInfo::AS_GNU, "init_priority"}, {AttributeCommonInfo::AS_CXX11, "gnu::init_priority"}, }; static constexpr const char InitPriorityArgNames[] = { "Priority",}; struct ParsedAttrInfoInitPriority final : public ParsedAttrInfo { constexpr ParsedAttrInfoInitPriority() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_InitPriority, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/InitPrioritySpellings, /ArgNames=/InitPriorityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( !Target.getTriple().isOSzOS() ); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoInitPriority Instance; }; const ParsedAttrInfoInitPriority ParsedAttrInfoInitPriority::Instance; static constexpr ParsedAttrInfo::Spelling IntelOclBiccSpellings[] = { {AttributeCommonInfo::AS_GNU, "intel_ocl_bicc"}, {AttributeCommonInfo::AS_CXX11, "clang::intel_ocl_bicc"}, }; struct ParsedAttrInfoIntelOclBicc final : public ParsedAttrInfo { constexpr ParsedAttrInfoIntelOclBicc() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_IntelOclBicc, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/IntelOclBiccSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoIntelOclBicc Instance; }; const ParsedAttrInfoIntelOclBicc ParsedAttrInfoIntelOclBicc::Instance; static constexpr ParsedAttrInfo::Spelling InternalLinkageSpellings[] = { {AttributeCommonInfo::AS_GNU, "internal_linkage"}, {AttributeCommonInfo::AS_CXX11, "clang::internal_linkage"}, {AttributeCommonInfo::AS_C2x, "clang::internal_linkage"}, }; struct ParsedAttrInfoInternalLinkage final : public ParsedAttrInfo { constexpr ParsedAttrInfoInternalLinkage() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_InternalLinkage, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/InternalLinkageSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<CommonAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoInternalLinkage Instance; }; const ParsedAttrInfoInternalLinkage ParsedAttrInfoInternalLinkage::Instance; static constexpr ParsedAttrInfo::Spelling LTOVisibilityPublicSpellings[] = { {AttributeCommonInfo::AS_GNU, "lto_visibility_public"}, {AttributeCommonInfo::AS_CXX11, "clang::lto_visibility_public"}, {AttributeCommonInfo::AS_C2x, "clang::lto_visibility_public"}, }; struct ParsedAttrInfoLTOVisibilityPublic final : public ParsedAttrInfo { constexpr ParsedAttrInfoLTOVisibilityPublic() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LTOVisibilityPublic, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/LTOVisibilityPublicSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) LTOVisibilityPublicAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLTOVisibilityPublic Instance; }; const ParsedAttrInfoLTOVisibilityPublic ParsedAttrInfoLTOVisibilityPublic::Instance; static constexpr ParsedAttrInfo::Spelling LayoutVersionSpellings[] = { {AttributeCommonInfo::AS_Declspec, "layout_version"}, }; static constexpr const char LayoutVersionArgNames[] = { "Version",}; struct ParsedAttrInfoLayoutVersion final : public ParsedAttrInfo { constexpr ParsedAttrInfoLayoutVersion() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LayoutVersion, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LayoutVersionSpellings, /ArgNames=/LayoutVersionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; 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().isMicrosoft() ); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLayoutVersion Instance; }; const ParsedAttrInfoLayoutVersion ParsedAttrInfoLayoutVersion::Instance; static constexpr ParsedAttrInfo::Spelling LeafSpellings[] = { {AttributeCommonInfo::AS_GNU, "leaf"}, {AttributeCommonInfo::AS_CXX11, "gnu::leaf"}, {AttributeCommonInfo::AS_C2x, "gnu::leaf"}, }; struct ParsedAttrInfoLeaf final : public ParsedAttrInfo { constexpr ParsedAttrInfoLeaf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Leaf, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/LeafSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) LeafAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLeaf Instance; }; const ParsedAttrInfoLeaf ParsedAttrInfoLeaf::Instance; static constexpr ParsedAttrInfo::Spelling LifetimeBoundSpellings[] = { {AttributeCommonInfo::AS_GNU, "lifetimebound"}, {AttributeCommonInfo::AS_CXX11, "clang::lifetimebound"}, }; struct ParsedAttrInfoLifetimeBound final : public ParsedAttrInfo { constexpr ParsedAttrInfoLifetimeBound() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LifetimeBound, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LifetimeBoundSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D) && !isImplicitObjectParameter(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters and implicit object parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CPlusPlus; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) LifetimeBoundAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLifetimeBound Instance; }; const ParsedAttrInfoLifetimeBound ParsedAttrInfoLifetimeBound::Instance; static constexpr ParsedAttrInfo::Spelling LikelySpellings[] = { {AttributeCommonInfo::AS_CXX11, "likely"}, {AttributeCommonInfo::AS_C2x, "clang::likely"}, }; struct ParsedAttrInfoLikely final : public ParsedAttrInfo { constexpr ParsedAttrInfoLikely() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Likely, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LikelySpellings, /ArgNames=/{}) {} using ParsedAttrInfo::diagMutualExclusion; bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLikely Instance; }; const ParsedAttrInfoLikely ParsedAttrInfoLikely::Instance; static constexpr ParsedAttrInfo::Spelling LoaderUninitializedSpellings[] = { {AttributeCommonInfo::AS_GNU, "loader_uninitialized"}, {AttributeCommonInfo::AS_CXX11, "clang::loader_uninitialized"}, {AttributeCommonInfo::AS_C2x, "clang::loader_uninitialized"}, }; struct ParsedAttrInfoLoaderUninitialized final : public ParsedAttrInfo { constexpr ParsedAttrInfoLoaderUninitialized() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LoaderUninitialized, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/LoaderUninitializedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) LoaderUninitializedAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLoaderUninitialized Instance; }; const ParsedAttrInfoLoaderUninitialized ParsedAttrInfoLoaderUninitialized::Instance; static constexpr ParsedAttrInfo::Spelling LockReturnedSpellings[] = { {AttributeCommonInfo::AS_GNU, "lock_returned"}, }; static constexpr const char LockReturnedArgNames[] = { "Arg",}; struct ParsedAttrInfoLockReturned final : public ParsedAttrInfo { constexpr ParsedAttrInfoLockReturned() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LockReturned, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LockReturnedSpellings, /ArgNames=/LockReturnedArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoLockReturned Instance; }; const ParsedAttrInfoLockReturned ParsedAttrInfoLockReturned::Instance; static constexpr ParsedAttrInfo::Spelling LockableSpellings[] = { {AttributeCommonInfo::AS_GNU, "lockable"}, }; struct ParsedAttrInfoLockable final : public ParsedAttrInfo { constexpr ParsedAttrInfoLockable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Lockable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/LockableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoLockable Instance; }; const ParsedAttrInfoLockable ParsedAttrInfoLockable::Instance; static constexpr ParsedAttrInfo::Spelling LocksExcludedSpellings[] = { {AttributeCommonInfo::AS_GNU, "locks_excluded"}, }; static constexpr const char LocksExcludedArgNames[] = { "Args...",}; struct ParsedAttrInfoLocksExcluded final : public ParsedAttrInfo { constexpr ParsedAttrInfoLocksExcluded() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LocksExcluded, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LocksExcludedSpellings, /ArgNames=/LocksExcludedArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoLocksExcluded Instance; }; const ParsedAttrInfoLocksExcluded ParsedAttrInfoLocksExcluded::Instance; static constexpr ParsedAttrInfo::Spelling LoopHintSpellings[] = { {AttributeCommonInfo::AS_Pragma, "clang::loop"}, {AttributeCommonInfo::AS_Pragma, "unroll"}, {AttributeCommonInfo::AS_Pragma, "nounroll"}, {AttributeCommonInfo::AS_Pragma, "unroll_and_jam"}, {AttributeCommonInfo::AS_Pragma, "nounroll_and_jam"}, }; static constexpr const char LoopHintArgNames[] = { "Option","State","Value",}; struct ParsedAttrInfoLoopHint final : public ParsedAttrInfo { constexpr ParsedAttrInfoLoopHint() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_LoopHint, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/LoopHintSpellings, /ArgNames=/LoopHintArgNames) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Pragma_clang_loop = 0, Pragma_unroll = 1, Pragma_nounroll = 2, Pragma_unroll_and_jam = 3, Pragma_nounroll_and_jam = 4, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 2) \|\| false; } static const ParsedAttrInfoLoopHint Instance; }; const ParsedAttrInfoLoopHint ParsedAttrInfoLoopHint::Instance; static constexpr ParsedAttrInfo::Spelling MIGServerRoutineSpellings[] = { {AttributeCommonInfo::AS_GNU, "mig_server_routine"}, {AttributeCommonInfo::AS_CXX11, "clang::mig_server_routine"}, {AttributeCommonInfo::AS_C2x, "clang::mig_server_routine"}, }; struct ParsedAttrInfoMIGServerRoutine final : public ParsedAttrInfo { constexpr ParsedAttrInfoMIGServerRoutine() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MIGServerRoutine, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/MIGServerRoutineSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and blocks"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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_block, /IsSupported=/LangOpts.Blocks)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMIGServerRoutine Instance; }; const ParsedAttrInfoMIGServerRoutine ParsedAttrInfoMIGServerRoutine::Instance; static constexpr ParsedAttrInfo::Spelling MSABISpellings[] = { {AttributeCommonInfo::AS_GNU, "ms_abi"}, {AttributeCommonInfo::AS_CXX11, "gnu::ms_abi"}, {AttributeCommonInfo::AS_C2x, "gnu::ms_abi"}, }; struct ParsedAttrInfoMSABI final : public ParsedAttrInfo { constexpr ParsedAttrInfoMSABI() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MSABI, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/MSABISpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMSABI Instance; }; const ParsedAttrInfoMSABI ParsedAttrInfoMSABI::Instance; static constexpr ParsedAttrInfo::Spelling MSAllocatorSpellings[] = { {AttributeCommonInfo::AS_Declspec, "allocator"}, }; struct ParsedAttrInfoMSAllocator final : public ParsedAttrInfo { constexpr ParsedAttrInfoMSAllocator() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MSAllocator, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/MSAllocatorSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMSAllocator Instance; }; const ParsedAttrInfoMSAllocator ParsedAttrInfoMSAllocator::Instance; static constexpr ParsedAttrInfo::Spelling MSInheritanceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__single_inheritance"}, {AttributeCommonInfo::AS_Keyword, "__multiple_inheritance"}, {AttributeCommonInfo::AS_Keyword, "__virtual_inheritance"}, {AttributeCommonInfo::AS_Keyword, "__unspecified_inheritance"}, }; struct ParsedAttrInfoMSInheritance final : public ParsedAttrInfo { constexpr ParsedAttrInfoMSInheritance() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MSInheritance, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/MSInheritanceSpellings, /ArgNames=/{}) {} bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.MicrosoftExt; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_single_inheritance = 0, Keyword_multiple_inheritance = 1, Keyword_virtual_inheritance = 2, Keyword_unspecified_inheritance = 3, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMSInheritance Instance; }; const ParsedAttrInfoMSInheritance ParsedAttrInfoMSInheritance::Instance; static constexpr ParsedAttrInfo::Spelling MSNoVTableSpellings[] = { {AttributeCommonInfo::AS_Declspec, "novtable"}, }; struct ParsedAttrInfoMSNoVTable final : public ParsedAttrInfo { constexpr ParsedAttrInfoMSNoVTable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MSNoVTable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/MSNoVTableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; 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().isMicrosoft() ); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MSNoVTableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMSNoVTable Instance; }; const ParsedAttrInfoMSNoVTable ParsedAttrInfoMSNoVTable::Instance; static constexpr ParsedAttrInfo::Spelling MSStructSpellings[] = { {AttributeCommonInfo::AS_GNU, "ms_struct"}, {AttributeCommonInfo::AS_CXX11, "gnu::ms_struct"}, {AttributeCommonInfo::AS_C2x, "gnu::ms_struct"}, }; struct ParsedAttrInfoMSStruct final : public ParsedAttrInfo { constexpr ParsedAttrInfoMSStruct() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MSStruct, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/MSStructSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MSStructAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMSStruct Instance; }; const ParsedAttrInfoMSStruct ParsedAttrInfoMSStruct::Instance; static constexpr ParsedAttrInfo::Spelling MatrixTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "matrix_type"}, {AttributeCommonInfo::AS_CXX11, "clang::matrix_type"}, {AttributeCommonInfo::AS_C2x, "clang::matrix_type"}, }; static constexpr const char MatrixTypeArgNames[] = { "NumRows","NumColumns",}; struct ParsedAttrInfoMatrixType final : public ParsedAttrInfo { constexpr ParsedAttrInfoMatrixType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MatrixType, /NumArgs=/2, /OptArgs=/0, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/MatrixTypeSpellings, /ArgNames=/MatrixTypeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoMatrixType Instance; }; const ParsedAttrInfoMatrixType ParsedAttrInfoMatrixType::Instance; static constexpr ParsedAttrInfo::Spelling MayAliasSpellings[] = { {AttributeCommonInfo::AS_GNU, "may_alias"}, {AttributeCommonInfo::AS_CXX11, "gnu::may_alias"}, {AttributeCommonInfo::AS_C2x, "gnu::may_alias"}, }; struct ParsedAttrInfoMayAlias final : public ParsedAttrInfo { constexpr ParsedAttrInfoMayAlias() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MayAlias, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/MayAliasSpellings, /ArgNames=/{}) {} AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MayAliasAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMayAlias Instance; }; const ParsedAttrInfoMayAlias ParsedAttrInfoMayAlias::Instance; static constexpr ParsedAttrInfo::Spelling MaybeUndefSpellings[] = { {AttributeCommonInfo::AS_GNU, "maybe_undef"}, {AttributeCommonInfo::AS_CXX11, "clang::maybe_undef"}, {AttributeCommonInfo::AS_C2x, "clang::maybe_undef"}, }; struct ParsedAttrInfoMaybeUndef final : public ParsedAttrInfo { constexpr ParsedAttrInfoMaybeUndef() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MaybeUndef, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/MaybeUndefSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MaybeUndefAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMaybeUndef Instance; }; const ParsedAttrInfoMaybeUndef ParsedAttrInfoMaybeUndef::Instance; static constexpr ParsedAttrInfo::Spelling MicroMipsSpellings[] = { {AttributeCommonInfo::AS_GNU, "micromips"}, {AttributeCommonInfo::AS_CXX11, "gnu::micromips"}, {AttributeCommonInfo::AS_C2x, "gnu::micromips"}, }; struct ParsedAttrInfoMicroMips final : public ParsedAttrInfo { constexpr ParsedAttrInfoMicroMips() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MicroMips, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/MicroMipsSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<Mips16Attr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MicroMipsAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMicroMips Instance; }; const ParsedAttrInfoMicroMips ParsedAttrInfoMicroMips::Instance; static constexpr ParsedAttrInfo::Spelling MinSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "minsize"}, {AttributeCommonInfo::AS_CXX11, "clang::minsize"}, {AttributeCommonInfo::AS_C2x, "clang::minsize"}, }; struct ParsedAttrInfoMinSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoMinSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MinSize, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/MinSizeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMinSize Instance; }; const ParsedAttrInfoMinSize ParsedAttrInfoMinSize::Instance; static constexpr ParsedAttrInfo::Spelling MinVectorWidthSpellings[] = { {AttributeCommonInfo::AS_GNU, "min_vector_width"}, {AttributeCommonInfo::AS_CXX11, "clang::min_vector_width"}, {AttributeCommonInfo::AS_C2x, "clang::min_vector_width"}, }; static constexpr const char MinVectorWidthArgNames[] = { "VectorWidth",}; struct ParsedAttrInfoMinVectorWidth final : public ParsedAttrInfo { constexpr ParsedAttrInfoMinVectorWidth() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MinVectorWidth, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/MinVectorWidthSpellings, /ArgNames=/MinVectorWidthArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMinVectorWidth Instance; }; const ParsedAttrInfoMinVectorWidth ParsedAttrInfoMinVectorWidth::Instance; static constexpr ParsedAttrInfo::Spelling Mips16Spellings[] = { {AttributeCommonInfo::AS_GNU, "mips16"}, {AttributeCommonInfo::AS_CXX11, "gnu::mips16"}, {AttributeCommonInfo::AS_C2x, "gnu::mips16"}, }; struct ParsedAttrInfoMips16 final : public ParsedAttrInfo { constexpr ParsedAttrInfoMips16() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Mips16, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/Mips16Spellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<MipsInterruptAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<MicroMipsAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) Mips16Attr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMips16 Instance; }; const ParsedAttrInfoMips16 ParsedAttrInfoMips16::Instance; static constexpr ParsedAttrInfo::Spelling MipsLongCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "long_call"}, {AttributeCommonInfo::AS_CXX11, "gnu::long_call"}, {AttributeCommonInfo::AS_C2x, "gnu::long_call"}, {AttributeCommonInfo::AS_GNU, "far"}, {AttributeCommonInfo::AS_CXX11, "gnu::far"}, {AttributeCommonInfo::AS_C2x, "gnu::far"}, }; struct ParsedAttrInfoMipsLongCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoMipsLongCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MipsLongCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/MipsLongCallSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<MipsShortCallAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel \|\| T.getArch() == llvm::Triple::mips64 \|\| T.getArch() == llvm::Triple::mips64el); } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_long_call = 0, CXX11_gnu_long_call = 1, C2x_gnu_long_call = 2, GNU_far = 3, CXX11_gnu_far = 4, C2x_gnu_far = 5, SpellingNotCalculated = 15 }; 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 C2x_gnu_long_call; case 3: return GNU_far; case 4: return CXX11_gnu_far; case 5: return C2x_gnu_far; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MipsLongCallAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMipsLongCall Instance; }; const ParsedAttrInfoMipsLongCall ParsedAttrInfoMipsLongCall::Instance; static constexpr ParsedAttrInfo::Spelling MipsShortCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "short_call"}, {AttributeCommonInfo::AS_CXX11, "gnu::short_call"}, {AttributeCommonInfo::AS_C2x, "gnu::short_call"}, {AttributeCommonInfo::AS_GNU, "near"}, {AttributeCommonInfo::AS_CXX11, "gnu::near"}, {AttributeCommonInfo::AS_C2x, "gnu::near"}, }; struct ParsedAttrInfoMipsShortCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoMipsShortCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MipsShortCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/MipsShortCallSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<MipsLongCallAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel \|\| T.getArch() == llvm::Triple::mips64 \|\| T.getArch() == llvm::Triple::mips64el); } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_short_call = 0, CXX11_gnu_short_call = 1, C2x_gnu_short_call = 2, GNU_near = 3, CXX11_gnu_near = 4, C2x_gnu_near = 5, SpellingNotCalculated = 15 }; 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 C2x_gnu_short_call; case 3: return GNU_near; case 4: return CXX11_gnu_near; case 5: return C2x_gnu_near; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) MipsShortCallAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMipsShortCall Instance; }; const ParsedAttrInfoMipsShortCall ParsedAttrInfoMipsShortCall::Instance; static constexpr ParsedAttrInfo::Spelling ModeSpellings[] = { {AttributeCommonInfo::AS_GNU, "mode"}, {AttributeCommonInfo::AS_CXX11, "gnu::mode"}, {AttributeCommonInfo::AS_C2x, "gnu::mode"}, }; static constexpr const char ModeArgNames[] = { "Mode",}; struct ParsedAttrInfoMode final : public ParsedAttrInfo { constexpr ParsedAttrInfoMode() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Mode, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/ModeSpellings, /ArgNames=/ModeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<EnumDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<FieldDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, enums, typedefs, and non-static data members"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMode Instance; }; const ParsedAttrInfoMode ParsedAttrInfoMode::Instance; static constexpr ParsedAttrInfo::Spelling MustTailSpellings[] = { {AttributeCommonInfo::AS_GNU, "musttail"}, {AttributeCommonInfo::AS_CXX11, "clang::musttail"}, {AttributeCommonInfo::AS_C2x, "clang::musttail"}, }; struct ParsedAttrInfoMustTail final : public ParsedAttrInfo { constexpr ParsedAttrInfoMustTail() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_MustTail, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/MustTailSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl D) const override { S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl) << AL << AL.isRegularKeywordAttribute() << D->getLocation(); return false; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<ReturnStmt>(St)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "return statements"; return false; } return true; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoMustTail Instance; }; const ParsedAttrInfoMustTail ParsedAttrInfoMustTail::Instance; static constexpr ParsedAttrInfo::Spelling NSConsumedSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_consumed"}, {AttributeCommonInfo::AS_CXX11, "clang::ns_consumed"}, {AttributeCommonInfo::AS_C2x, "clang::ns_consumed"}, }; struct ParsedAttrInfoNSConsumed final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSConsumed() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSConsumed, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NSConsumedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSConsumed Instance; }; const ParsedAttrInfoNSConsumed ParsedAttrInfoNSConsumed::Instance; static constexpr ParsedAttrInfo::Spelling NSConsumesSelfSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_consumes_self"}, {AttributeCommonInfo::AS_CXX11, "clang::ns_consumes_self"}, {AttributeCommonInfo::AS_C2x, "clang::ns_consumes_self"}, }; struct ParsedAttrInfoNSConsumesSelf final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSConsumesSelf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSConsumesSelf, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NSConsumesSelfSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NSConsumesSelfAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSConsumesSelf Instance; }; const ParsedAttrInfoNSConsumesSelf ParsedAttrInfoNSConsumesSelf::Instance; static constexpr ParsedAttrInfo::Spelling NSErrorDomainSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_error_domain"}, }; static constexpr const char NSErrorDomainArgNames[] = { "ErrorDomain",}; struct ParsedAttrInfoNSErrorDomain final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSErrorDomain() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSErrorDomain, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NSErrorDomainSpellings, /ArgNames=/NSErrorDomainArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<EnumDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "enums"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSErrorDomain Instance; }; const ParsedAttrInfoNSErrorDomain ParsedAttrInfoNSErrorDomain::Instance; static constexpr ParsedAttrInfo::Spelling NSReturnsAutoreleasedSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_returns_autoreleased"}, {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_autoreleased"}, {AttributeCommonInfo::AS_C2x, "clang::ns_returns_autoreleased"}, }; struct ParsedAttrInfoNSReturnsAutoreleased final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSReturnsAutoreleased() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSReturnsAutoreleased, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NSReturnsAutoreleasedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSReturnsAutoreleased Instance; }; const ParsedAttrInfoNSReturnsAutoreleased ParsedAttrInfoNSReturnsAutoreleased::Instance; static constexpr ParsedAttrInfo::Spelling NSReturnsNotRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_returns_not_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_not_retained"}, {AttributeCommonInfo::AS_C2x, "clang::ns_returns_not_retained"}, }; struct ParsedAttrInfoNSReturnsNotRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSReturnsNotRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSReturnsNotRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NSReturnsNotRetainedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSReturnsNotRetained Instance; }; const ParsedAttrInfoNSReturnsNotRetained ParsedAttrInfoNSReturnsNotRetained::Instance; static constexpr ParsedAttrInfo::Spelling NSReturnsRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "ns_returns_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_retained"}, {AttributeCommonInfo::AS_C2x, "clang::ns_returns_retained"}, }; struct ParsedAttrInfoNSReturnsRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoNSReturnsRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NSReturnsRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NSReturnsRetainedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNSReturnsRetained Instance; }; const ParsedAttrInfoNSReturnsRetained ParsedAttrInfoNSReturnsRetained::Instance; static constexpr ParsedAttrInfo::Spelling NVPTXKernelSpellings[] = { {AttributeCommonInfo::AS_GNU, "nvptx_kernel"}, {AttributeCommonInfo::AS_CXX11, "clang::nvptx_kernel"}, {AttributeCommonInfo::AS_C2x, "clang::nvptx_kernel"}, }; struct ParsedAttrInfoNVPTXKernel final : public ParsedAttrInfo { constexpr ParsedAttrInfoNVPTXKernel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NVPTXKernel, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NVPTXKernelSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::nvptx \|\| T.getArch() == llvm::Triple::nvptx64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNVPTXKernel Instance; }; const ParsedAttrInfoNVPTXKernel ParsedAttrInfoNVPTXKernel::Instance; static constexpr ParsedAttrInfo::Spelling NakedSpellings[] = { {AttributeCommonInfo::AS_GNU, "naked"}, {AttributeCommonInfo::AS_CXX11, "gnu::naked"}, {AttributeCommonInfo::AS_C2x, "gnu::naked"}, {AttributeCommonInfo::AS_Declspec, "naked"}, }; struct ParsedAttrInfoNaked final : public ParsedAttrInfo { constexpr ParsedAttrInfoNaked() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Naked, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NakedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<DisableTailCallsAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNaked Instance; }; const ParsedAttrInfoNaked ParsedAttrInfoNaked::Instance; static constexpr ParsedAttrInfo::Spelling NeonPolyVectorTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "neon_polyvector_type"}, {AttributeCommonInfo::AS_CXX11, "clang::neon_polyvector_type"}, {AttributeCommonInfo::AS_C2x, "clang::neon_polyvector_type"}, }; static constexpr const char NeonPolyVectorTypeArgNames[] = { "NumElements",}; struct ParsedAttrInfoNeonPolyVectorType final : public ParsedAttrInfo { constexpr ParsedAttrInfoNeonPolyVectorType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NeonPolyVectorType, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NeonPolyVectorTypeSpellings, /ArgNames=/NeonPolyVectorTypeArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNeonPolyVectorType Instance; }; const ParsedAttrInfoNeonPolyVectorType ParsedAttrInfoNeonPolyVectorType::Instance; static constexpr ParsedAttrInfo::Spelling NeonVectorTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "neon_vector_type"}, {AttributeCommonInfo::AS_CXX11, "clang::neon_vector_type"}, {AttributeCommonInfo::AS_C2x, "clang::neon_vector_type"}, }; static constexpr const char NeonVectorTypeArgNames[] = { "NumElements",}; struct ParsedAttrInfoNeonVectorType final : public ParsedAttrInfo { constexpr ParsedAttrInfoNeonVectorType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NeonVectorType, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NeonVectorTypeSpellings, /ArgNames=/NeonVectorTypeArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNeonVectorType Instance; }; const ParsedAttrInfoNeonVectorType ParsedAttrInfoNeonVectorType::Instance; static constexpr ParsedAttrInfo::Spelling NoAliasSpellings[] = { {AttributeCommonInfo::AS_Declspec, "noalias"}, }; struct ParsedAttrInfoNoAlias final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoAlias() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoAlias, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NoAliasSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoAliasAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoAlias Instance; }; const ParsedAttrInfoNoAlias ParsedAttrInfoNoAlias::Instance; static constexpr ParsedAttrInfo::Spelling NoBuiltinSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_builtin"}, {AttributeCommonInfo::AS_CXX11, "clang::no_builtin"}, {AttributeCommonInfo::AS_C2x, "clang::no_builtin"}, }; static constexpr const char NoBuiltinArgNames[] = { "BuiltinNames...",}; struct ParsedAttrInfoNoBuiltin final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoBuiltin() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoBuiltin, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoBuiltinSpellings, /ArgNames=/NoBuiltinArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoBuiltin Instance; }; const ParsedAttrInfoNoBuiltin ParsedAttrInfoNoBuiltin::Instance; static constexpr ParsedAttrInfo::Spelling NoCommonSpellings[] = { {AttributeCommonInfo::AS_GNU, "nocommon"}, {AttributeCommonInfo::AS_CXX11, "gnu::nocommon"}, {AttributeCommonInfo::AS_C2x, "gnu::nocommon"}, }; struct ParsedAttrInfoNoCommon final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoCommon() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoCommon, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoCommonSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoCommonAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoCommon Instance; }; const ParsedAttrInfoNoCommon ParsedAttrInfoNoCommon::Instance; static constexpr ParsedAttrInfo::Spelling NoDebugSpellings[] = { {AttributeCommonInfo::AS_GNU, "nodebug"}, {AttributeCommonInfo::AS_CXX11, "gnu::nodebug"}, {AttributeCommonInfo::AS_C2x, "gnu::nodebug"}, }; struct ParsedAttrInfoNoDebug final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoDebug() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoDebug, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoDebugSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D) && !isFunctionLike(D) && !isa<ObjCMethodDecl>(D) && !isNonParmVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs, functions, function pointers, Objective-C methods, and variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoDebug Instance; }; const ParsedAttrInfoNoDebug ParsedAttrInfoNoDebug::Instance; static constexpr ParsedAttrInfo::Spelling NoDerefSpellings[] = { {AttributeCommonInfo::AS_GNU, "noderef"}, {AttributeCommonInfo::AS_CXX11, "clang::noderef"}, {AttributeCommonInfo::AS_C2x, "clang::noderef"}, }; struct ParsedAttrInfoNoDeref final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoDeref() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoDeref, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NoDerefSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoDeref Instance; }; const ParsedAttrInfoNoDeref ParsedAttrInfoNoDeref::Instance; static constexpr ParsedAttrInfo::Spelling NoDestroySpellings[] = { {AttributeCommonInfo::AS_GNU, "no_destroy"}, {AttributeCommonInfo::AS_CXX11, "clang::no_destroy"}, }; struct ParsedAttrInfoNoDestroy final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoDestroy() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoDestroy, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoDestroySpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<AlwaysDestroyAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoDestroy Instance; }; const ParsedAttrInfoNoDestroy ParsedAttrInfoNoDestroy::Instance; static constexpr ParsedAttrInfo::Spelling NoDuplicateSpellings[] = { {AttributeCommonInfo::AS_GNU, "noduplicate"}, {AttributeCommonInfo::AS_CXX11, "clang::noduplicate"}, {AttributeCommonInfo::AS_C2x, "clang::noduplicate"}, }; struct ParsedAttrInfoNoDuplicate final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoDuplicate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoDuplicate, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoDuplicateSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoDuplicateAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoDuplicate Instance; }; const ParsedAttrInfoNoDuplicate ParsedAttrInfoNoDuplicate::Instance; static constexpr ParsedAttrInfo::Spelling NoEscapeSpellings[] = { {AttributeCommonInfo::AS_GNU, "noescape"}, {AttributeCommonInfo::AS_CXX11, "clang::noescape"}, {AttributeCommonInfo::AS_C2x, "clang::noescape"}, }; struct ParsedAttrInfoNoEscape final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoEscape() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoEscape, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoEscapeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoEscape Instance; }; const ParsedAttrInfoNoEscape ParsedAttrInfoNoEscape::Instance; static constexpr ParsedAttrInfo::Spelling NoInlineSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__noinline__"}, {AttributeCommonInfo::AS_GNU, "noinline"}, {AttributeCommonInfo::AS_CXX11, "gnu::noinline"}, {AttributeCommonInfo::AS_C2x, "gnu::noinline"}, {AttributeCommonInfo::AS_CXX11, "clang::noinline"}, {AttributeCommonInfo::AS_C2x, "clang::noinline"}, {AttributeCommonInfo::AS_Declspec, "noinline"}, }; struct ParsedAttrInfoNoInline final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoInline() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoInline, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoInlineSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and statements"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<Stmt>(St)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and statements"; return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoInlineAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoInline Instance; }; const ParsedAttrInfoNoInline ParsedAttrInfoNoInline::Instance; static constexpr ParsedAttrInfo::Spelling NoInstrumentFunctionSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_instrument_function"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_instrument_function"}, {AttributeCommonInfo::AS_C2x, "gnu::no_instrument_function"}, }; struct ParsedAttrInfoNoInstrumentFunction final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoInstrumentFunction() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoInstrumentFunction, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoInstrumentFunctionSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoInstrumentFunction Instance; }; const ParsedAttrInfoNoInstrumentFunction ParsedAttrInfoNoInstrumentFunction::Instance; static constexpr ParsedAttrInfo::Spelling NoMergeSpellings[] = { {AttributeCommonInfo::AS_GNU, "nomerge"}, {AttributeCommonInfo::AS_CXX11, "clang::nomerge"}, {AttributeCommonInfo::AS_C2x, "clang::nomerge"}, }; struct ParsedAttrInfoNoMerge final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoMerge() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoMerge, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoMergeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, statements and variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<Stmt>(St)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, statements and variables"; return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoMerge Instance; }; const ParsedAttrInfoNoMerge ParsedAttrInfoNoMerge::Instance; static constexpr ParsedAttrInfo::Spelling NoMicroMipsSpellings[] = { {AttributeCommonInfo::AS_GNU, "nomicromips"}, {AttributeCommonInfo::AS_CXX11, "gnu::nomicromips"}, {AttributeCommonInfo::AS_C2x, "gnu::nomicromips"}, }; struct ParsedAttrInfoNoMicroMips final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoMicroMips() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoMicroMips, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoMicroMipsSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoMicroMipsAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoMicroMips Instance; }; const ParsedAttrInfoNoMicroMips ParsedAttrInfoNoMicroMips::Instance; static constexpr ParsedAttrInfo::Spelling NoMips16Spellings[] = { {AttributeCommonInfo::AS_GNU, "nomips16"}, {AttributeCommonInfo::AS_CXX11, "gnu::nomips16"}, {AttributeCommonInfo::AS_C2x, "gnu::nomips16"}, }; struct ParsedAttrInfoNoMips16 final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoMips16() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoMips16, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoMips16Spellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::mips \|\| T.getArch() == llvm::Triple::mipsel); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoMips16Attr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoMips16 Instance; }; const ParsedAttrInfoNoMips16 ParsedAttrInfoNoMips16::Instance; static constexpr ParsedAttrInfo::Spelling NoProfileFunctionSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_profile_instrument_function"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_profile_instrument_function"}, {AttributeCommonInfo::AS_C2x, "gnu::no_profile_instrument_function"}, }; struct ParsedAttrInfoNoProfileFunction final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoProfileFunction() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoProfileFunction, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoProfileFunctionSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoProfileFunctionAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoProfileFunction Instance; }; const ParsedAttrInfoNoProfileFunction ParsedAttrInfoNoProfileFunction::Instance; static constexpr ParsedAttrInfo::Spelling NoRandomizeLayoutSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_randomize_layout"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_randomize_layout"}, {AttributeCommonInfo::AS_C2x, "gnu::no_randomize_layout"}, }; struct ParsedAttrInfoNoRandomizeLayout final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoRandomizeLayout() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoRandomizeLayout, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoRandomizeLayoutSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<RandomizeLayoutAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoRandomizeLayout Instance; }; const ParsedAttrInfoNoRandomizeLayout ParsedAttrInfoNoRandomizeLayout::Instance; static constexpr ParsedAttrInfo::Spelling NoReturnSpellings[] = { {AttributeCommonInfo::AS_GNU, "noreturn"}, {AttributeCommonInfo::AS_CXX11, "gnu::noreturn"}, {AttributeCommonInfo::AS_C2x, "gnu::noreturn"}, {AttributeCommonInfo::AS_Declspec, "noreturn"}, }; struct ParsedAttrInfoNoReturn final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoReturn() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoReturn, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/NoReturnSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoReturn Instance; }; const ParsedAttrInfoNoReturn ParsedAttrInfoNoReturn::Instance; static constexpr ParsedAttrInfo::Spelling NoSanitizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_sanitize"}, {AttributeCommonInfo::AS_CXX11, "clang::no_sanitize"}, {AttributeCommonInfo::AS_C2x, "clang::no_sanitize"}, }; static constexpr const char NoSanitizeArgNames[] = { "Sanitizers...",}; struct ParsedAttrInfoNoSanitize final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoSanitize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoSanitize, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoSanitizeSpellings, /ArgNames=/NoSanitizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoSanitize Instance; }; const ParsedAttrInfoNoSanitize ParsedAttrInfoNoSanitize::Instance; static constexpr ParsedAttrInfo::Spelling NoSanitizeSpecificSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_address_safety_analysis"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_address_safety_analysis"}, {AttributeCommonInfo::AS_C2x, "gnu::no_address_safety_analysis"}, {AttributeCommonInfo::AS_GNU, "no_sanitize_address"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_sanitize_address"}, {AttributeCommonInfo::AS_C2x, "gnu::no_sanitize_address"}, {AttributeCommonInfo::AS_GNU, "no_sanitize_thread"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_sanitize_thread"}, {AttributeCommonInfo::AS_C2x, "gnu::no_sanitize_thread"}, {AttributeCommonInfo::AS_GNU, "no_sanitize_memory"}, {AttributeCommonInfo::AS_CXX11, "clang::no_sanitize_memory"}, {AttributeCommonInfo::AS_C2x, "clang::no_sanitize_memory"}, }; struct ParsedAttrInfoNoSanitizeSpecific final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoSanitizeSpecific() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoSanitizeSpecific, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoSanitizeSpecificSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoSanitizeSpecific Instance; }; const ParsedAttrInfoNoSanitizeSpecific ParsedAttrInfoNoSanitizeSpecific::Instance; static constexpr ParsedAttrInfo::Spelling NoSpeculativeLoadHardeningSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_speculative_load_hardening"}, {AttributeCommonInfo::AS_CXX11, "clang::no_speculative_load_hardening"}, {AttributeCommonInfo::AS_C2x, "clang::no_speculative_load_hardening"}, }; struct ParsedAttrInfoNoSpeculativeLoadHardening final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoSpeculativeLoadHardening() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoSpeculativeLoadHardening, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoSpeculativeLoadHardeningSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<SpeculativeLoadHardeningAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoSpeculativeLoadHardeningAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoSpeculativeLoadHardening Instance; }; const ParsedAttrInfoNoSpeculativeLoadHardening ParsedAttrInfoNoSpeculativeLoadHardening::Instance; static constexpr ParsedAttrInfo::Spelling NoSplitStackSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_split_stack"}, {AttributeCommonInfo::AS_CXX11, "gnu::no_split_stack"}, {AttributeCommonInfo::AS_C2x, "gnu::no_split_stack"}, }; struct ParsedAttrInfoNoSplitStack final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoSplitStack() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoSplitStack, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoSplitStackSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoSplitStackAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoSplitStack Instance; }; const ParsedAttrInfoNoSplitStack ParsedAttrInfoNoSplitStack::Instance; static constexpr ParsedAttrInfo::Spelling NoStackProtectorSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_stack_protector"}, {AttributeCommonInfo::AS_CXX11, "clang::no_stack_protector"}, {AttributeCommonInfo::AS_C2x, "clang::no_stack_protector"}, {AttributeCommonInfo::AS_Declspec, "safebuffers"}, }; struct ParsedAttrInfoNoStackProtector final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoStackProtector() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoStackProtector, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoStackProtectorSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_no_stack_protector = 0, CXX11_clang_no_stack_protector = 1, C2x_clang_no_stack_protector = 2, Declspec_safebuffers = 3, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return GNU_no_stack_protector; case 1: return CXX11_clang_no_stack_protector; case 2: return C2x_clang_no_stack_protector; case 3: return Declspec_safebuffers; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoStackProtectorAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoStackProtector Instance; }; const ParsedAttrInfoNoStackProtector ParsedAttrInfoNoStackProtector::Instance; static constexpr ParsedAttrInfo::Spelling NoThreadSafetyAnalysisSpellings[] = { {AttributeCommonInfo::AS_GNU, "no_thread_safety_analysis"}, {AttributeCommonInfo::AS_CXX11, "clang::no_thread_safety_analysis"}, {AttributeCommonInfo::AS_C2x, "clang::no_thread_safety_analysis"}, }; struct ParsedAttrInfoNoThreadSafetyAnalysis final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoThreadSafetyAnalysis() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoThreadSafetyAnalysis, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoThreadSafetyAnalysisSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoThreadSafetyAnalysisAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoThreadSafetyAnalysis Instance; }; const ParsedAttrInfoNoThreadSafetyAnalysis ParsedAttrInfoNoThreadSafetyAnalysis::Instance; static constexpr ParsedAttrInfo::Spelling NoThrowSpellings[] = { {AttributeCommonInfo::AS_GNU, "nothrow"}, {AttributeCommonInfo::AS_CXX11, "gnu::nothrow"}, {AttributeCommonInfo::AS_C2x, "gnu::nothrow"}, {AttributeCommonInfo::AS_Declspec, "nothrow"}, }; struct ParsedAttrInfoNoThrow final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoThrow() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoThrow, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoThrowSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isFunctionLike(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoThrow Instance; }; const ParsedAttrInfoNoThrow ParsedAttrInfoNoThrow::Instance; static constexpr ParsedAttrInfo::Spelling NoUniqueAddressSpellings[] = { {AttributeCommonInfo::AS_CXX11, "no_unique_address"}, }; struct ParsedAttrInfoNoUniqueAddress final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoUniqueAddress() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoUniqueAddress, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/NoUniqueAddressSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonBitField(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-bit-field non-static data members"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && ( Target.getCXXABI().isItaniumFamily() ); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoUniqueAddressAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoUniqueAddress Instance; }; const ParsedAttrInfoNoUniqueAddress ParsedAttrInfoNoUniqueAddress::Instance; static constexpr ParsedAttrInfo::Spelling NoUwtableSpellings[] = { {AttributeCommonInfo::AS_GNU, "nouwtable"}, {AttributeCommonInfo::AS_CXX11, "clang::nouwtable"}, {AttributeCommonInfo::AS_C2x, "clang::nouwtable"}, }; struct ParsedAttrInfoNoUwtable final : public ParsedAttrInfo { constexpr ParsedAttrInfoNoUwtable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NoUwtable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NoUwtableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isFunctionLike(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NoUwtableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNoUwtable Instance; }; const ParsedAttrInfoNoUwtable ParsedAttrInfoNoUwtable::Instance; static constexpr ParsedAttrInfo::Spelling NonNullSpellings[] = { {AttributeCommonInfo::AS_GNU, "nonnull"}, {AttributeCommonInfo::AS_CXX11, "gnu::nonnull"}, {AttributeCommonInfo::AS_C2x, "gnu::nonnull"}, }; static constexpr const char NonNullArgNames[] = { "Args...",}; struct ParsedAttrInfoNonNull final : public ParsedAttrInfo { constexpr ParsedAttrInfoNonNull() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NonNull, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/NonNullSpellings, /ArgNames=/NonNullArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D) && !isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, methods, and parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNonNull Instance; }; const ParsedAttrInfoNonNull ParsedAttrInfoNonNull::Instance; static constexpr ParsedAttrInfo::Spelling NotTailCalledSpellings[] = { {AttributeCommonInfo::AS_GNU, "not_tail_called"}, {AttributeCommonInfo::AS_CXX11, "clang::not_tail_called"}, {AttributeCommonInfo::AS_C2x, "clang::not_tail_called"}, }; struct ParsedAttrInfoNotTailCalled final : public ParsedAttrInfo { constexpr ParsedAttrInfoNotTailCalled() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_NotTailCalled, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/NotTailCalledSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<AlwaysInlineAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) NotTailCalledAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoNotTailCalled Instance; }; const ParsedAttrInfoNotTailCalled ParsedAttrInfoNotTailCalled::Instance; static constexpr ParsedAttrInfo::Spelling OSConsumedSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_consumed"}, {AttributeCommonInfo::AS_CXX11, "clang::os_consumed"}, {AttributeCommonInfo::AS_C2x, "clang::os_consumed"}, }; struct ParsedAttrInfoOSConsumed final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSConsumed() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSConsumed, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OSConsumedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSConsumed Instance; }; const ParsedAttrInfoOSConsumed ParsedAttrInfoOSConsumed::Instance; static constexpr ParsedAttrInfo::Spelling OSConsumesThisSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_consumes_this"}, {AttributeCommonInfo::AS_CXX11, "clang::os_consumes_this"}, {AttributeCommonInfo::AS_C2x, "clang::os_consumes_this"}, }; struct ParsedAttrInfoOSConsumesThis final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSConsumesThis() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSConsumesThis, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OSConsumesThisSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonStaticCXXMethod(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static member functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) OSConsumesThisAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSConsumesThis Instance; }; const ParsedAttrInfoOSConsumesThis ParsedAttrInfoOSConsumesThis::Instance; static constexpr ParsedAttrInfo::Spelling OSReturnsNotRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_returns_not_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::os_returns_not_retained"}, {AttributeCommonInfo::AS_C2x, "clang::os_returns_not_retained"}, }; struct ParsedAttrInfoOSReturnsNotRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSReturnsNotRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSReturnsNotRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OSReturnsNotRetainedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D) && !isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, Objective-C properties, and parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSReturnsNotRetained Instance; }; const ParsedAttrInfoOSReturnsNotRetained ParsedAttrInfoOSReturnsNotRetained::Instance; static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_returns_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained"}, {AttributeCommonInfo::AS_C2x, "clang::os_returns_retained"}, }; struct ParsedAttrInfoOSReturnsRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSReturnsRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSReturnsRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OSReturnsRetainedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D) && !isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, Objective-C properties, and parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSReturnsRetained Instance; }; const ParsedAttrInfoOSReturnsRetained ParsedAttrInfoOSReturnsRetained::Instance; static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedOnNonZeroSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_returns_retained_on_non_zero"}, {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained_on_non_zero"}, {AttributeCommonInfo::AS_C2x, "clang::os_returns_retained_on_non_zero"}, }; struct ParsedAttrInfoOSReturnsRetainedOnNonZero final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSReturnsRetainedOnNonZero() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSReturnsRetainedOnNonZero, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OSReturnsRetainedOnNonZeroSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSReturnsRetainedOnNonZero Instance; }; const ParsedAttrInfoOSReturnsRetainedOnNonZero ParsedAttrInfoOSReturnsRetainedOnNonZero::Instance; static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedOnZeroSpellings[] = { {AttributeCommonInfo::AS_GNU, "os_returns_retained_on_zero"}, {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained_on_zero"}, {AttributeCommonInfo::AS_C2x, "clang::os_returns_retained_on_zero"}, }; struct ParsedAttrInfoOSReturnsRetainedOnZero final : public ParsedAttrInfo { constexpr ParsedAttrInfoOSReturnsRetainedOnZero() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OSReturnsRetainedOnZero, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OSReturnsRetainedOnZeroSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOSReturnsRetainedOnZero Instance; }; const ParsedAttrInfoOSReturnsRetainedOnZero ParsedAttrInfoOSReturnsRetainedOnZero::Instance; static constexpr ParsedAttrInfo::Spelling ObjCBoxableSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_boxable"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_boxable"}, {AttributeCommonInfo::AS_C2x, "clang::objc_boxable"}, }; struct ParsedAttrInfoObjCBoxable final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCBoxable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCBoxable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCBoxableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCBoxable Instance; }; const ParsedAttrInfoObjCBoxable ParsedAttrInfoObjCBoxable::Instance; static constexpr ParsedAttrInfo::Spelling ObjCBridgeSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_bridge"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge"}, {AttributeCommonInfo::AS_C2x, "clang::objc_bridge"}, }; static constexpr const char ObjCBridgeArgNames[] = { "BridgedType",}; struct ParsedAttrInfoObjCBridge final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCBridge() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCBridge, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCBridgeSpellings, /ArgNames=/ObjCBridgeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCBridge Instance; }; const ParsedAttrInfoObjCBridge ParsedAttrInfoObjCBridge::Instance; static constexpr ParsedAttrInfo::Spelling ObjCBridgeMutableSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_bridge_mutable"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge_mutable"}, {AttributeCommonInfo::AS_C2x, "clang::objc_bridge_mutable"}, }; static constexpr const char ObjCBridgeMutableArgNames[] = { "BridgedType",}; struct ParsedAttrInfoObjCBridgeMutable final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCBridgeMutable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCBridgeMutable, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCBridgeMutableSpellings, /ArgNames=/ObjCBridgeMutableArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCBridgeMutable Instance; }; const ParsedAttrInfoObjCBridgeMutable ParsedAttrInfoObjCBridgeMutable::Instance; static constexpr ParsedAttrInfo::Spelling ObjCBridgeRelatedSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_bridge_related"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge_related"}, {AttributeCommonInfo::AS_C2x, "clang::objc_bridge_related"}, }; static constexpr const char ObjCBridgeRelatedArgNames[] = { "RelatedClass","ClassMethod","InstanceMethod",}; struct ParsedAttrInfoObjCBridgeRelated final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCBridgeRelated() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCBridgeRelated, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCBridgeRelatedSpellings, /ArgNames=/ObjCBridgeRelatedArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCBridgeRelated Instance; }; const ParsedAttrInfoObjCBridgeRelated ParsedAttrInfoObjCBridgeRelated::Instance; static constexpr ParsedAttrInfo::Spelling ObjCClassStubSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_class_stub"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_class_stub"}, {AttributeCommonInfo::AS_C2x, "clang::objc_class_stub"}, }; struct ParsedAttrInfoObjCClassStub final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCClassStub() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCClassStub, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCClassStubSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (LangOpts.ObjCRuntime.allowsClassStubs()); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCClassStubAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCClassStub Instance; }; const ParsedAttrInfoObjCClassStub ParsedAttrInfoObjCClassStub::Instance; static constexpr ParsedAttrInfo::Spelling ObjCDesignatedInitializerSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_designated_initializer"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_designated_initializer"}, {AttributeCommonInfo::AS_C2x, "clang::objc_designated_initializer"}, }; struct ParsedAttrInfoObjCDesignatedInitializer final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCDesignatedInitializer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCDesignatedInitializer, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCDesignatedInitializerSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCDesignatedInitializer Instance; }; const ParsedAttrInfoObjCDesignatedInitializer ParsedAttrInfoObjCDesignatedInitializer::Instance; static constexpr ParsedAttrInfo::Spelling ObjCDirectSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_direct"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_direct"}, {AttributeCommonInfo::AS_C2x, "clang::objc_direct"}, }; struct ParsedAttrInfoObjCDirect final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCDirect() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCDirect, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCDirectSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjC; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCDirect Instance; }; const ParsedAttrInfoObjCDirect ParsedAttrInfoObjCDirect::Instance; static constexpr ParsedAttrInfo::Spelling ObjCDirectMembersSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_direct_members"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_direct_members"}, {AttributeCommonInfo::AS_C2x, "clang::objc_direct_members"}, }; struct ParsedAttrInfoObjCDirectMembers final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCDirectMembers() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCDirectMembers, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCDirectMembersSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCImplDecl>(D) && !isa<ObjCInterfaceDecl>(D) && !isa<ObjCCategoryDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C implementation declarations, Objective-C interfaces, and Objective-C containers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjC; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /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_category, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCDirectMembers Instance; }; const ParsedAttrInfoObjCDirectMembers ParsedAttrInfoObjCDirectMembers::Instance; static constexpr ParsedAttrInfo::Spelling ObjCExceptionSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_exception"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_exception"}, {AttributeCommonInfo::AS_C2x, "clang::objc_exception"}, }; struct ParsedAttrInfoObjCException final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCException() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCException, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCExceptionSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCExceptionAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCException Instance; }; const ParsedAttrInfoObjCException ParsedAttrInfoObjCException::Instance; static constexpr ParsedAttrInfo::Spelling ObjCExplicitProtocolImplSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_protocol_requires_explicit_implementation"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_protocol_requires_explicit_implementation"}, {AttributeCommonInfo::AS_C2x, "clang::objc_protocol_requires_explicit_implementation"}, }; struct ParsedAttrInfoObjCExplicitProtocolImpl final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCExplicitProtocolImpl() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCExplicitProtocolImpl, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCExplicitProtocolImplSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCProtocolDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C protocols"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCExplicitProtocolImpl Instance; }; const ParsedAttrInfoObjCExplicitProtocolImpl ParsedAttrInfoObjCExplicitProtocolImpl::Instance; static constexpr ParsedAttrInfo::Spelling ObjCExternallyRetainedSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_externally_retained"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_externally_retained"}, {AttributeCommonInfo::AS_C2x, "clang::objc_externally_retained"}, }; struct ParsedAttrInfoObjCExternallyRetained final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCExternallyRetained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCExternallyRetained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCExternallyRetainedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonParmVar(D) && !isa<FunctionDecl>(D) && !isa<BlockDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, blocks, and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjCAutoRefCount; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_not_is_parameter, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_block, /IsSupported=/LangOpts.Blocks)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCExternallyRetained Instance; }; const ParsedAttrInfoObjCExternallyRetained ParsedAttrInfoObjCExternallyRetained::Instance; static constexpr ParsedAttrInfo::Spelling ObjCGCSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_gc"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_gc"}, {AttributeCommonInfo::AS_C2x, "clang::objc_gc"}, }; static constexpr const char ObjCGCArgNames[] = { "Kind",}; struct ParsedAttrInfoObjCGC final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCGC() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCGC, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCGCSpellings, /ArgNames=/ObjCGCArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCGC Instance; }; const ParsedAttrInfoObjCGC ParsedAttrInfoObjCGC::Instance; static constexpr ParsedAttrInfo::Spelling ObjCIndependentClassSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_independent_class"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_independent_class"}, {AttributeCommonInfo::AS_C2x, "clang::objc_independent_class"}, }; struct ParsedAttrInfoObjCIndependentClass final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCIndependentClass() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCIndependentClass, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCIndependentClassSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCIndependentClass Instance; }; const ParsedAttrInfoObjCIndependentClass ParsedAttrInfoObjCIndependentClass::Instance; static constexpr ParsedAttrInfo::Spelling ObjCInertUnsafeUnretainedSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__unsafe_unretained"}, }; struct ParsedAttrInfoObjCInertUnsafeUnretained final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCInertUnsafeUnretained() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCInertUnsafeUnretained, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCInertUnsafeUnretainedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCInertUnsafeUnretained Instance; }; const ParsedAttrInfoObjCInertUnsafeUnretained ParsedAttrInfoObjCInertUnsafeUnretained::Instance; static constexpr ParsedAttrInfo::Spelling ObjCKindOfSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__kindof"}, }; struct ParsedAttrInfoObjCKindOf final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCKindOf() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCKindOf, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCKindOfSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCKindOf Instance; }; const ParsedAttrInfoObjCKindOf ParsedAttrInfoObjCKindOf::Instance; static constexpr ParsedAttrInfo::Spelling ObjCMethodFamilySpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_method_family"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_method_family"}, {AttributeCommonInfo::AS_C2x, "clang::objc_method_family"}, }; static constexpr const char ObjCMethodFamilyArgNames[] = { "Family",}; struct ParsedAttrInfoObjCMethodFamily final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCMethodFamily() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCMethodFamily, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCMethodFamilySpellings, /ArgNames=/ObjCMethodFamilyArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCMethodFamily Instance; }; const ParsedAttrInfoObjCMethodFamily ParsedAttrInfoObjCMethodFamily::Instance; static constexpr ParsedAttrInfo::Spelling ObjCNSObjectSpellings[] = { {AttributeCommonInfo::AS_GNU, "NSObject"}, {AttributeCommonInfo::AS_CXX11, "clang::NSObject"}, {AttributeCommonInfo::AS_C2x, "clang::NSObject"}, }; struct ParsedAttrInfoObjCNSObject final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCNSObject() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCNSObject, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCNSObjectSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCNSObject Instance; }; const ParsedAttrInfoObjCNSObject ParsedAttrInfoObjCNSObject::Instance; static constexpr ParsedAttrInfo::Spelling ObjCNonLazyClassSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_nonlazy_class"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_nonlazy_class"}, {AttributeCommonInfo::AS_C2x, "clang::objc_nonlazy_class"}, }; struct ParsedAttrInfoObjCNonLazyClass final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCNonLazyClass() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCNonLazyClass, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCNonLazyClassSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCImplDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces and Objective-C implementation declarations"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjC; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCNonLazyClassAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCNonLazyClass Instance; }; const ParsedAttrInfoObjCNonLazyClass ParsedAttrInfoObjCNonLazyClass::Instance; static constexpr ParsedAttrInfo::Spelling ObjCNonRuntimeProtocolSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_non_runtime_protocol"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_non_runtime_protocol"}, {AttributeCommonInfo::AS_C2x, "clang::objc_non_runtime_protocol"}, }; struct ParsedAttrInfoObjCNonRuntimeProtocol final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCNonRuntimeProtocol() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCNonRuntimeProtocol, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCNonRuntimeProtocolSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCProtocolDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C protocols"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.ObjC; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCNonRuntimeProtocolAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCNonRuntimeProtocol Instance; }; const ParsedAttrInfoObjCNonRuntimeProtocol ParsedAttrInfoObjCNonRuntimeProtocol::Instance; static constexpr ParsedAttrInfo::Spelling ObjCOwnershipSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_ownership"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_ownership"}, {AttributeCommonInfo::AS_C2x, "clang::objc_ownership"}, }; static constexpr const char ObjCOwnershipArgNames[] = { "Kind",}; struct ParsedAttrInfoObjCOwnership final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCOwnership() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCOwnership, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ObjCOwnershipSpellings, /ArgNames=/ObjCOwnershipArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCOwnership Instance; }; const ParsedAttrInfoObjCOwnership ParsedAttrInfoObjCOwnership::Instance; static constexpr ParsedAttrInfo::Spelling ObjCPreciseLifetimeSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_precise_lifetime"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_precise_lifetime"}, {AttributeCommonInfo::AS_C2x, "clang::objc_precise_lifetime"}, }; struct ParsedAttrInfoObjCPreciseLifetime final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCPreciseLifetime() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCPreciseLifetime, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCPreciseLifetimeSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCPreciseLifetime Instance; }; const ParsedAttrInfoObjCPreciseLifetime ParsedAttrInfoObjCPreciseLifetime::Instance; static constexpr ParsedAttrInfo::Spelling ObjCRequiresPropertyDefsSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_requires_property_definitions"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_requires_property_definitions"}, {AttributeCommonInfo::AS_C2x, "clang::objc_requires_property_definitions"}, }; struct ParsedAttrInfoObjCRequiresPropertyDefs final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCRequiresPropertyDefs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCRequiresPropertyDefs, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCRequiresPropertyDefsSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCRequiresPropertyDefsAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCRequiresPropertyDefs Instance; }; const ParsedAttrInfoObjCRequiresPropertyDefs ParsedAttrInfoObjCRequiresPropertyDefs::Instance; static constexpr ParsedAttrInfo::Spelling ObjCRequiresSuperSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_requires_super"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_requires_super"}, {AttributeCommonInfo::AS_C2x, "clang::objc_requires_super"}, }; struct ParsedAttrInfoObjCRequiresSuper final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCRequiresSuper() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCRequiresSuper, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCRequiresSuperSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCRequiresSuper Instance; }; const ParsedAttrInfoObjCRequiresSuper ParsedAttrInfoObjCRequiresSuper::Instance; static constexpr ParsedAttrInfo::Spelling ObjCReturnsInnerPointerSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_returns_inner_pointer"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_returns_inner_pointer"}, {AttributeCommonInfo::AS_C2x, "clang::objc_returns_inner_pointer"}, }; struct ParsedAttrInfoObjCReturnsInnerPointer final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCReturnsInnerPointer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCReturnsInnerPointer, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCReturnsInnerPointerSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and Objective-C properties"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCReturnsInnerPointer Instance; }; const ParsedAttrInfoObjCReturnsInnerPointer ParsedAttrInfoObjCReturnsInnerPointer::Instance; static constexpr ParsedAttrInfo::Spelling ObjCRootClassSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_root_class"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_root_class"}, {AttributeCommonInfo::AS_C2x, "clang::objc_root_class"}, }; struct ParsedAttrInfoObjCRootClass final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCRootClass() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCRootClass, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCRootClassSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCRootClassAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCRootClass Instance; }; const ParsedAttrInfoObjCRootClass ParsedAttrInfoObjCRootClass::Instance; static constexpr ParsedAttrInfo::Spelling ObjCRuntimeNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_runtime_name"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_runtime_name"}, {AttributeCommonInfo::AS_C2x, "clang::objc_runtime_name"}, }; static constexpr const char ObjCRuntimeNameArgNames[] = { "MetadataName",}; struct ParsedAttrInfoObjCRuntimeName final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCRuntimeName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCRuntimeName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCRuntimeNameSpellings, /ArgNames=/ObjCRuntimeNameArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces and Objective-C protocols"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCRuntimeName Instance; }; const ParsedAttrInfoObjCRuntimeName ParsedAttrInfoObjCRuntimeName::Instance; static constexpr ParsedAttrInfo::Spelling ObjCRuntimeVisibleSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_runtime_visible"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_runtime_visible"}, {AttributeCommonInfo::AS_C2x, "clang::objc_runtime_visible"}, }; struct ParsedAttrInfoObjCRuntimeVisible final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCRuntimeVisible() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCRuntimeVisible, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCRuntimeVisibleSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCRuntimeVisibleAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCRuntimeVisible Instance; }; const ParsedAttrInfoObjCRuntimeVisible ParsedAttrInfoObjCRuntimeVisible::Instance; static constexpr ParsedAttrInfo::Spelling ObjCSubclassingRestrictedSpellings[] = { {AttributeCommonInfo::AS_GNU, "objc_subclassing_restricted"}, {AttributeCommonInfo::AS_CXX11, "clang::objc_subclassing_restricted"}, {AttributeCommonInfo::AS_C2x, "clang::objc_subclassing_restricted"}, }; struct ParsedAttrInfoObjCSubclassingRestricted final : public ParsedAttrInfo { constexpr ParsedAttrInfoObjCSubclassingRestricted() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ObjCSubclassingRestricted, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ObjCSubclassingRestrictedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ObjCSubclassingRestrictedAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoObjCSubclassingRestricted Instance; }; const ParsedAttrInfoObjCSubclassingRestricted ParsedAttrInfoObjCSubclassingRestricted::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLAccessSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__read_only"}, {AttributeCommonInfo::AS_Keyword, "read_only"}, {AttributeCommonInfo::AS_Keyword, "__write_only"}, {AttributeCommonInfo::AS_Keyword, "write_only"}, {AttributeCommonInfo::AS_Keyword, "__read_write"}, {AttributeCommonInfo::AS_Keyword, "read_write"}, }; struct ParsedAttrInfoOpenCLAccess final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLAccess() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLAccess, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLAccessSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_read_only = 0, Keyword_write_only = 2, Keyword_read_write = 4, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLAccess Instance; }; const ParsedAttrInfoOpenCLAccess ParsedAttrInfoOpenCLAccess::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLConstantAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__constant"}, {AttributeCommonInfo::AS_Keyword, "constant"}, {AttributeCommonInfo::AS_GNU, "opencl_constant"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_constant"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_constant"}, }; struct ParsedAttrInfoOpenCLConstantAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLConstantAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLConstantAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLConstantAddressSpaceSpellings, /ArgNames=/{}) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_constant = 0, GNU_opencl_constant = 2, CXX11_clang_opencl_constant = 3, C2x_clang_opencl_constant = 4, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_constant; case 1: return Keyword_constant; case 2: return GNU_opencl_constant; case 3: return CXX11_clang_opencl_constant; case 4: return C2x_clang_opencl_constant; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLConstantAddressSpace Instance; }; const ParsedAttrInfoOpenCLConstantAddressSpace ParsedAttrInfoOpenCLConstantAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLGenericAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__generic"}, {AttributeCommonInfo::AS_Keyword, "generic"}, {AttributeCommonInfo::AS_GNU, "opencl_generic"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_generic"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_generic"}, }; struct ParsedAttrInfoOpenCLGenericAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLGenericAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLGenericAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLGenericAddressSpaceSpellings, /ArgNames=/{}) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_generic = 0, GNU_opencl_generic = 2, CXX11_clang_opencl_generic = 3, C2x_clang_opencl_generic = 4, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_generic; case 1: return Keyword_generic; case 2: return GNU_opencl_generic; case 3: return CXX11_clang_opencl_generic; case 4: return C2x_clang_opencl_generic; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLGenericAddressSpace Instance; }; const ParsedAttrInfoOpenCLGenericAddressSpace ParsedAttrInfoOpenCLGenericAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLGlobalAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__global"}, {AttributeCommonInfo::AS_Keyword, "global"}, {AttributeCommonInfo::AS_GNU, "opencl_global"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_global"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_global"}, }; struct ParsedAttrInfoOpenCLGlobalAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLGlobalAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLGlobalAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLGlobalAddressSpaceSpellings, /ArgNames=/{}) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_global = 0, GNU_opencl_global = 2, CXX11_clang_opencl_global = 3, C2x_clang_opencl_global = 4, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_global; case 1: return Keyword_global; case 2: return GNU_opencl_global; case 3: return CXX11_clang_opencl_global; case 4: return C2x_clang_opencl_global; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLGlobalAddressSpace Instance; }; const ParsedAttrInfoOpenCLGlobalAddressSpace ParsedAttrInfoOpenCLGlobalAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLGlobalDeviceAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_GNU, "opencl_global_device"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_global_device"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_global_device"}, }; struct ParsedAttrInfoOpenCLGlobalDeviceAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLGlobalDeviceAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLGlobalDeviceAddressSpaceSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLGlobalDeviceAddressSpace Instance; }; const ParsedAttrInfoOpenCLGlobalDeviceAddressSpace ParsedAttrInfoOpenCLGlobalDeviceAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLGlobalHostAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_GNU, "opencl_global_host"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_global_host"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_global_host"}, }; struct ParsedAttrInfoOpenCLGlobalHostAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLGlobalHostAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLGlobalHostAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLGlobalHostAddressSpaceSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLGlobalHostAddressSpace Instance; }; const ParsedAttrInfoOpenCLGlobalHostAddressSpace ParsedAttrInfoOpenCLGlobalHostAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLIntelReqdSubGroupSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "intel_reqd_sub_group_size"}, }; static constexpr const char OpenCLIntelReqdSubGroupSizeArgNames[] = { "SubGroupSize",}; struct ParsedAttrInfoOpenCLIntelReqdSubGroupSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLIntelReqdSubGroupSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLIntelReqdSubGroupSize, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OpenCLIntelReqdSubGroupSizeSpellings, /ArgNames=/OpenCLIntelReqdSubGroupSizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLIntelReqdSubGroupSize Instance; }; const ParsedAttrInfoOpenCLIntelReqdSubGroupSize ParsedAttrInfoOpenCLIntelReqdSubGroupSize::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLKernelSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__kernel"}, {AttributeCommonInfo::AS_Keyword, "kernel"}, }; struct ParsedAttrInfoOpenCLKernel final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLKernel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLKernel, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLKernelSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) OpenCLKernelAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLKernel Instance; }; const ParsedAttrInfoOpenCLKernel ParsedAttrInfoOpenCLKernel::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLLocalAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__local"}, {AttributeCommonInfo::AS_Keyword, "local"}, {AttributeCommonInfo::AS_GNU, "opencl_local"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_local"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_local"}, }; struct ParsedAttrInfoOpenCLLocalAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLLocalAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLLocalAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLLocalAddressSpaceSpellings, /ArgNames=/{}) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_local = 0, GNU_opencl_local = 2, CXX11_clang_opencl_local = 3, C2x_clang_opencl_local = 4, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_local; case 1: return Keyword_local; case 2: return GNU_opencl_local; case 3: return CXX11_clang_opencl_local; case 4: return C2x_clang_opencl_local; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLLocalAddressSpace Instance; }; const ParsedAttrInfoOpenCLLocalAddressSpace ParsedAttrInfoOpenCLLocalAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLNoSVMSpellings[] = { {AttributeCommonInfo::AS_GNU, "nosvm"}, }; struct ParsedAttrInfoOpenCLNoSVM final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLNoSVM() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLNoSVM, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OpenCLNoSVMSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.OpenCL; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLNoSVM Instance; }; const ParsedAttrInfoOpenCLNoSVM ParsedAttrInfoOpenCLNoSVM::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLPrivateAddressSpaceSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__private"}, {AttributeCommonInfo::AS_Keyword, "private"}, {AttributeCommonInfo::AS_GNU, "opencl_private"}, {AttributeCommonInfo::AS_CXX11, "clang::opencl_private"}, {AttributeCommonInfo::AS_C2x, "clang::opencl_private"}, }; struct ParsedAttrInfoOpenCLPrivateAddressSpace final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLPrivateAddressSpace() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLPrivateAddressSpace, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLPrivateAddressSpaceSpellings, /ArgNames=/{}) {} unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Keyword_private = 0, GNU_opencl_private = 2, CXX11_clang_opencl_private = 3, C2x_clang_opencl_private = 4, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return Keyword_private; case 1: return Keyword_private; case 2: return GNU_opencl_private; case 3: return CXX11_clang_opencl_private; case 4: return C2x_clang_opencl_private; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLPrivateAddressSpace Instance; }; const ParsedAttrInfoOpenCLPrivateAddressSpace ParsedAttrInfoOpenCLPrivateAddressSpace::Instance; static constexpr ParsedAttrInfo::Spelling OpenCLUnrollHintSpellings[] = { {AttributeCommonInfo::AS_GNU, "opencl_unroll_hint"}, }; static constexpr const char OpenCLUnrollHintArgNames[] = { "UnrollHint",}; struct ParsedAttrInfoOpenCLUnrollHint final : public ParsedAttrInfo { constexpr ParsedAttrInfoOpenCLUnrollHint() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OpenCLUnrollHint, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OpenCLUnrollHintSpellings, /ArgNames=/OpenCLUnrollHintArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl D) const override { S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl) << AL << AL.isRegularKeywordAttribute() << D->getLocation(); return false; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt St) const override { if (!isa<ForStmt>(St) && !isa<CXXForRangeStmt>(St) && !isa<WhileStmt>(St) && !isa<DoStmt>(St)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "'for', 'while', and 'do' statements"; return false; } return true; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOpenCLUnrollHint Instance; }; const ParsedAttrInfoOpenCLUnrollHint ParsedAttrInfoOpenCLUnrollHint::Instance; static constexpr ParsedAttrInfo::Spelling OptimizeNoneSpellings[] = { {AttributeCommonInfo::AS_GNU, "optnone"}, {AttributeCommonInfo::AS_CXX11, "clang::optnone"}, {AttributeCommonInfo::AS_C2x, "clang::optnone"}, }; struct ParsedAttrInfoOptimizeNone final : public ParsedAttrInfo { constexpr ParsedAttrInfoOptimizeNone() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_OptimizeNone, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OptimizeNoneSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOptimizeNone Instance; }; const ParsedAttrInfoOptimizeNone ParsedAttrInfoOptimizeNone::Instance; static constexpr ParsedAttrInfo::Spelling OverloadableSpellings[] = { {AttributeCommonInfo::AS_GNU, "overloadable"}, {AttributeCommonInfo::AS_CXX11, "clang::overloadable"}, {AttributeCommonInfo::AS_C2x, "clang::overloadable"}, }; struct ParsedAttrInfoOverloadable final : public ParsedAttrInfo { constexpr ParsedAttrInfoOverloadable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Overloadable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OverloadableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) OverloadableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOverloadable Instance; }; const ParsedAttrInfoOverloadable ParsedAttrInfoOverloadable::Instance; static constexpr ParsedAttrInfo::Spelling OwnerSpellings[] = { {AttributeCommonInfo::AS_CXX11, "gsl::Owner"}, }; static constexpr const char OwnerArgNames[] = { "DerefType",}; struct ParsedAttrInfoOwner final : public ParsedAttrInfo { constexpr ParsedAttrInfoOwner() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Owner, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/OwnerSpellings, /ArgNames=/OwnerArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isStruct(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<PointerAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOwner Instance; }; const ParsedAttrInfoOwner ParsedAttrInfoOwner::Instance; static constexpr ParsedAttrInfo::Spelling OwnershipSpellings[] = { {AttributeCommonInfo::AS_GNU, "ownership_holds"}, {AttributeCommonInfo::AS_CXX11, "clang::ownership_holds"}, {AttributeCommonInfo::AS_C2x, "clang::ownership_holds"}, {AttributeCommonInfo::AS_GNU, "ownership_returns"}, {AttributeCommonInfo::AS_CXX11, "clang::ownership_returns"}, {AttributeCommonInfo::AS_C2x, "clang::ownership_returns"}, {AttributeCommonInfo::AS_GNU, "ownership_takes"}, {AttributeCommonInfo::AS_CXX11, "clang::ownership_takes"}, {AttributeCommonInfo::AS_C2x, "clang::ownership_takes"}, }; static constexpr const char OwnershipArgNames[] = { "Module","Args...",}; struct ParsedAttrInfoOwnership final : public ParsedAttrInfo { constexpr ParsedAttrInfoOwnership() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Ownership, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/OwnershipSpellings, /ArgNames=/OwnershipArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isHasFunctionProto(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoOwnership Instance; }; const ParsedAttrInfoOwnership ParsedAttrInfoOwnership::Instance; static constexpr ParsedAttrInfo::Spelling PackedSpellings[] = { {AttributeCommonInfo::AS_GNU, "packed"}, {AttributeCommonInfo::AS_CXX11, "gnu::packed"}, {AttributeCommonInfo::AS_C2x, "gnu::packed"}, }; struct ParsedAttrInfoPacked final : public ParsedAttrInfo { constexpr ParsedAttrInfoPacked() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Packed, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/PackedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPacked Instance; }; const ParsedAttrInfoPacked ParsedAttrInfoPacked::Instance; static constexpr ParsedAttrInfo::Spelling ParamTypestateSpellings[] = { {AttributeCommonInfo::AS_GNU, "param_typestate"}, {AttributeCommonInfo::AS_CXX11, "clang::param_typestate"}, }; static constexpr const char ParamTypestateArgNames[] = { "ParamState",}; struct ParsedAttrInfoParamTypestate final : public ParsedAttrInfo { constexpr ParsedAttrInfoParamTypestate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ParamTypestate, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ParamTypestateSpellings, /ArgNames=/ParamTypestateArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoParamTypestate Instance; }; const ParsedAttrInfoParamTypestate ParsedAttrInfoParamTypestate::Instance; static constexpr ParsedAttrInfo::Spelling PascalSpellings[] = { {AttributeCommonInfo::AS_GNU, "pascal"}, {AttributeCommonInfo::AS_CXX11, "clang::pascal"}, {AttributeCommonInfo::AS_C2x, "clang::pascal"}, {AttributeCommonInfo::AS_Keyword, "__pascal"}, {AttributeCommonInfo::AS_Keyword, "_pascal"}, }; struct ParsedAttrInfoPascal final : public ParsedAttrInfo { constexpr ParsedAttrInfoPascal() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Pascal, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PascalSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPascal Instance; }; const ParsedAttrInfoPascal ParsedAttrInfoPascal::Instance; static constexpr ParsedAttrInfo::Spelling PassObjectSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "pass_object_size"}, {AttributeCommonInfo::AS_CXX11, "clang::pass_object_size"}, {AttributeCommonInfo::AS_C2x, "clang::pass_object_size"}, {AttributeCommonInfo::AS_GNU, "pass_dynamic_object_size"}, {AttributeCommonInfo::AS_CXX11, "clang::pass_dynamic_object_size"}, {AttributeCommonInfo::AS_C2x, "clang::pass_dynamic_object_size"}, }; static constexpr const char PassObjectSizeArgNames[] = { "Type",}; struct ParsedAttrInfoPassObjectSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoPassObjectSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PassObjectSize, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/PassObjectSizeSpellings, /ArgNames=/PassObjectSizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_pass_object_size = 0, CXX11_clang_pass_object_size = 1, C2x_clang_pass_object_size = 2, GNU_pass_dynamic_object_size = 3, CXX11_clang_pass_dynamic_object_size = 4, C2x_clang_pass_dynamic_object_size = 5, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return GNU_pass_object_size; case 1: return CXX11_clang_pass_object_size; case 2: return C2x_clang_pass_object_size; case 3: return GNU_pass_dynamic_object_size; case 4: return CXX11_clang_pass_dynamic_object_size; case 5: return C2x_clang_pass_dynamic_object_size; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPassObjectSize Instance; }; const ParsedAttrInfoPassObjectSize ParsedAttrInfoPassObjectSize::Instance; static constexpr ParsedAttrInfo::Spelling PatchableFunctionEntrySpellings[] = { {AttributeCommonInfo::AS_GNU, "patchable_function_entry"}, {AttributeCommonInfo::AS_CXX11, "gnu::patchable_function_entry"}, {AttributeCommonInfo::AS_C2x, "gnu::patchable_function_entry"}, }; static constexpr const char PatchableFunctionEntryArgNames[] = { "Count","Offset",}; struct ParsedAttrInfoPatchableFunctionEntry final : public ParsedAttrInfo { constexpr ParsedAttrInfoPatchableFunctionEntry() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PatchableFunctionEntry, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/PatchableFunctionEntrySpellings, /ArgNames=/PatchableFunctionEntryArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::aarch64 \|\| T.getArch() == llvm::Triple::aarch64_be \|\| T.getArch() == llvm::Triple::loongarch32 \|\| T.getArch() == llvm::Triple::loongarch64 \|\| T.getArch() == llvm::Triple::riscv32 \|\| T.getArch() == llvm::Triple::riscv64 \|\| T.getArch() == llvm::Triple::x86 \|\| T.getArch() == llvm::Triple::x86_64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPatchableFunctionEntry Instance; }; const ParsedAttrInfoPatchableFunctionEntry ParsedAttrInfoPatchableFunctionEntry::Instance; static constexpr ParsedAttrInfo::Spelling PcsSpellings[] = { {AttributeCommonInfo::AS_GNU, "pcs"}, {AttributeCommonInfo::AS_CXX11, "gnu::pcs"}, {AttributeCommonInfo::AS_C2x, "gnu::pcs"}, }; static constexpr const char PcsArgNames[] = { "PCS",}; struct ParsedAttrInfoPcs final : public ParsedAttrInfo { constexpr ParsedAttrInfoPcs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Pcs, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/PcsSpellings, /ArgNames=/PcsArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPcs Instance; }; const ParsedAttrInfoPcs ParsedAttrInfoPcs::Instance; static constexpr ParsedAttrInfo::Spelling PointerSpellings[] = { {AttributeCommonInfo::AS_CXX11, "gsl::Pointer"}, }; static constexpr const char PointerArgNames[] = { "DerefType",}; struct ParsedAttrInfoPointer final : public ParsedAttrInfo { constexpr ParsedAttrInfoPointer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Pointer, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/PointerSpellings, /ArgNames=/PointerArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isStruct(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<OwnerAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPointer Instance; }; const ParsedAttrInfoPointer ParsedAttrInfoPointer::Instance; static constexpr const char PragmaClangBSSSectionArgNames[] = { "Name",}; struct ParsedAttrInfoPragmaClangBSSSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoPragmaClangBSSSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PragmaClangBSSSection, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/PragmaClangBSSSectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPragmaClangBSSSection Instance; }; const ParsedAttrInfoPragmaClangBSSSection ParsedAttrInfoPragmaClangBSSSection::Instance; static constexpr const char PragmaClangDataSectionArgNames[] = { "Name",}; struct ParsedAttrInfoPragmaClangDataSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoPragmaClangDataSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PragmaClangDataSection, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/PragmaClangDataSectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPragmaClangDataSection Instance; }; const ParsedAttrInfoPragmaClangDataSection ParsedAttrInfoPragmaClangDataSection::Instance; static constexpr const char PragmaClangRelroSectionArgNames[] = { "Name",}; struct ParsedAttrInfoPragmaClangRelroSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoPragmaClangRelroSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PragmaClangRelroSection, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/PragmaClangRelroSectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPragmaClangRelroSection Instance; }; const ParsedAttrInfoPragmaClangRelroSection ParsedAttrInfoPragmaClangRelroSection::Instance; static constexpr const char PragmaClangRodataSectionArgNames[] = { "Name",}; struct ParsedAttrInfoPragmaClangRodataSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoPragmaClangRodataSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PragmaClangRodataSection, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/PragmaClangRodataSectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isGlobalVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPragmaClangRodataSection Instance; }; const ParsedAttrInfoPragmaClangRodataSection ParsedAttrInfoPragmaClangRodataSection::Instance; static constexpr const char PragmaClangTextSectionArgNames[] = { "Name",}; struct ParsedAttrInfoPragmaClangTextSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoPragmaClangTextSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PragmaClangTextSection, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/PragmaClangTextSectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPragmaClangTextSection Instance; }; const ParsedAttrInfoPragmaClangTextSection ParsedAttrInfoPragmaClangTextSection::Instance; static constexpr ParsedAttrInfo::Spelling PreferredNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "preferred_name"}, {AttributeCommonInfo::AS_CXX11, "clang::preferred_name"}, }; static constexpr const char PreferredNameArgNames[] = { "TypedefType",}; struct ParsedAttrInfoPreferredName final : public ParsedAttrInfo { constexpr ParsedAttrInfoPreferredName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PreferredName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PreferredNameSpellings, /ArgNames=/PreferredNameArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isClassTmpl(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "class templates"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPreferredName Instance; }; const ParsedAttrInfoPreferredName ParsedAttrInfoPreferredName::Instance; static constexpr ParsedAttrInfo::Spelling PreserveAllSpellings[] = { {AttributeCommonInfo::AS_GNU, "preserve_all"}, {AttributeCommonInfo::AS_CXX11, "clang::preserve_all"}, {AttributeCommonInfo::AS_C2x, "clang::preserve_all"}, }; struct ParsedAttrInfoPreserveAll final : public ParsedAttrInfo { constexpr ParsedAttrInfoPreserveAll() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PreserveAll, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PreserveAllSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPreserveAll Instance; }; const ParsedAttrInfoPreserveAll ParsedAttrInfoPreserveAll::Instance; static constexpr ParsedAttrInfo::Spelling PreserveMostSpellings[] = { {AttributeCommonInfo::AS_GNU, "preserve_most"}, {AttributeCommonInfo::AS_CXX11, "clang::preserve_most"}, {AttributeCommonInfo::AS_C2x, "clang::preserve_most"}, }; struct ParsedAttrInfoPreserveMost final : public ParsedAttrInfo { constexpr ParsedAttrInfoPreserveMost() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PreserveMost, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PreserveMostSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPreserveMost Instance; }; const ParsedAttrInfoPreserveMost ParsedAttrInfoPreserveMost::Instance; static constexpr ParsedAttrInfo::Spelling PtGuardedBySpellings[] = { {AttributeCommonInfo::AS_GNU, "pt_guarded_by"}, }; static constexpr const char PtGuardedByArgNames[] = { "Arg",}; struct ParsedAttrInfoPtGuardedBy final : public ParsedAttrInfo { constexpr ParsedAttrInfoPtGuardedBy() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PtGuardedBy, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PtGuardedBySpellings, /ArgNames=/PtGuardedByArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoPtGuardedBy Instance; }; const ParsedAttrInfoPtGuardedBy ParsedAttrInfoPtGuardedBy::Instance; static constexpr ParsedAttrInfo::Spelling PtGuardedVarSpellings[] = { {AttributeCommonInfo::AS_GNU, "pt_guarded_var"}, {AttributeCommonInfo::AS_CXX11, "clang::pt_guarded_var"}, }; struct ParsedAttrInfoPtGuardedVar final : public ParsedAttrInfo { constexpr ParsedAttrInfoPtGuardedVar() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_PtGuardedVar, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/PtGuardedVarSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FieldDecl>(D) && !isSharedVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPtGuardedVar Instance; }; const ParsedAttrInfoPtGuardedVar ParsedAttrInfoPtGuardedVar::Instance; static constexpr ParsedAttrInfo::Spelling Ptr32Spellings[] = { {AttributeCommonInfo::AS_Keyword, "__ptr32"}, }; struct ParsedAttrInfoPtr32 final : public ParsedAttrInfo { constexpr ParsedAttrInfoPtr32() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Ptr32, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/Ptr32Spellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPtr32 Instance; }; const ParsedAttrInfoPtr32 ParsedAttrInfoPtr32::Instance; static constexpr ParsedAttrInfo::Spelling Ptr64Spellings[] = { {AttributeCommonInfo::AS_Keyword, "__ptr64"}, }; struct ParsedAttrInfoPtr64 final : public ParsedAttrInfo { constexpr ParsedAttrInfoPtr64() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Ptr64, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/Ptr64Spellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPtr64 Instance; }; const ParsedAttrInfoPtr64 ParsedAttrInfoPtr64::Instance; static constexpr ParsedAttrInfo::Spelling PureSpellings[] = { {AttributeCommonInfo::AS_GNU, "pure"}, {AttributeCommonInfo::AS_CXX11, "gnu::pure"}, {AttributeCommonInfo::AS_C2x, "gnu::pure"}, }; struct ParsedAttrInfoPure final : public ParsedAttrInfo { constexpr ParsedAttrInfoPure() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Pure, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/PureSpellings, /ArgNames=/{}) {} AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) PureAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoPure Instance; }; const ParsedAttrInfoPure ParsedAttrInfoPure::Instance; static constexpr ParsedAttrInfo::Spelling RISCVRVVVectorBitsSpellings[] = { {AttributeCommonInfo::AS_GNU, "riscv_rvv_vector_bits"}, }; static constexpr const char RISCVRVVVectorBitsArgNames[] = { "NumBits",}; struct ParsedAttrInfoRISCVRVVVectorBits final : public ParsedAttrInfo { constexpr ParsedAttrInfoRISCVRVVVectorBits() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_RISCVRVVVectorBits, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/RISCVRVVVectorBitsSpellings, /ArgNames=/RISCVRVVVectorBitsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRISCVRVVVectorBits Instance; }; const ParsedAttrInfoRISCVRVVVectorBits ParsedAttrInfoRISCVRVVVectorBits::Instance; static constexpr ParsedAttrInfo::Spelling RandomizeLayoutSpellings[] = { {AttributeCommonInfo::AS_GNU, "randomize_layout"}, {AttributeCommonInfo::AS_CXX11, "gnu::randomize_layout"}, {AttributeCommonInfo::AS_C2x, "gnu::randomize_layout"}, }; struct ParsedAttrInfoRandomizeLayout final : public ParsedAttrInfo { constexpr ParsedAttrInfoRandomizeLayout() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_RandomizeLayout, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/RandomizeLayoutSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<NoRandomizeLayoutAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRandomizeLayout Instance; }; const ParsedAttrInfoRandomizeLayout ParsedAttrInfoRandomizeLayout::Instance; static constexpr ParsedAttrInfo::Spelling ReadOnlyPlacementSpellings[] = { {AttributeCommonInfo::AS_GNU, "enforce_read_only_placement"}, {AttributeCommonInfo::AS_CXX11, "clang::enforce_read_only_placement"}, {AttributeCommonInfo::AS_C2x, "clang::enforce_read_only_placement"}, }; struct ParsedAttrInfoReadOnlyPlacement final : public ParsedAttrInfo { constexpr ParsedAttrInfoReadOnlyPlacement() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReadOnlyPlacement, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReadOnlyPlacementSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReadOnlyPlacement Instance; }; const ParsedAttrInfoReadOnlyPlacement ParsedAttrInfoReadOnlyPlacement::Instance; static constexpr ParsedAttrInfo::Spelling RegCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "regcall"}, {AttributeCommonInfo::AS_CXX11, "gnu::regcall"}, {AttributeCommonInfo::AS_C2x, "gnu::regcall"}, {AttributeCommonInfo::AS_Keyword, "__regcall"}, }; struct ParsedAttrInfoRegCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoRegCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_RegCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/RegCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRegCall Instance; }; const ParsedAttrInfoRegCall ParsedAttrInfoRegCall::Instance; static constexpr ParsedAttrInfo::Spelling RegparmSpellings[] = { {AttributeCommonInfo::AS_GNU, "regparm"}, {AttributeCommonInfo::AS_CXX11, "gnu::regparm"}, {AttributeCommonInfo::AS_C2x, "gnu::regparm"}, }; static constexpr const char RegparmArgNames[] = { "NumParams",}; struct ParsedAttrInfoRegparm final : public ParsedAttrInfo { constexpr ParsedAttrInfoRegparm() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Regparm, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/RegparmSpellings, /ArgNames=/RegparmArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRegparm Instance; }; const ParsedAttrInfoRegparm ParsedAttrInfoRegparm::Instance; static constexpr ParsedAttrInfo::Spelling ReinitializesSpellings[] = { {AttributeCommonInfo::AS_GNU, "reinitializes"}, {AttributeCommonInfo::AS_CXX11, "clang::reinitializes"}, }; struct ParsedAttrInfoReinitializes final : public ParsedAttrInfo { constexpr ParsedAttrInfoReinitializes() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Reinitializes, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ReinitializesSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonStaticNonConstCXXMethod(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "non-static non-const member functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ReinitializesAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReinitializes Instance; }; const ParsedAttrInfoReinitializes ParsedAttrInfoReinitializes::Instance; static constexpr ParsedAttrInfo::Spelling ReleaseCapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "release_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::release_capability"}, {AttributeCommonInfo::AS_GNU, "release_shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::release_shared_capability"}, {AttributeCommonInfo::AS_GNU, "release_generic_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::release_generic_capability"}, {AttributeCommonInfo::AS_GNU, "unlock_function"}, {AttributeCommonInfo::AS_CXX11, "clang::unlock_function"}, }; static constexpr const char ReleaseCapabilityArgNames[] = { "Args...",}; struct ParsedAttrInfoReleaseCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoReleaseCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReleaseCapability, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ReleaseCapabilitySpellings, /ArgNames=/ReleaseCapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoReleaseCapability Instance; }; const ParsedAttrInfoReleaseCapability ParsedAttrInfoReleaseCapability::Instance; static constexpr ParsedAttrInfo::Spelling ReleaseHandleSpellings[] = { {AttributeCommonInfo::AS_GNU, "release_handle"}, {AttributeCommonInfo::AS_CXX11, "clang::release_handle"}, {AttributeCommonInfo::AS_C2x, "clang::release_handle"}, }; static constexpr const char ReleaseHandleArgNames[] = { "HandleType",}; struct ParsedAttrInfoReleaseHandle final : public ParsedAttrInfo { constexpr ParsedAttrInfoReleaseHandle() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReleaseHandle, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReleaseHandleSpellings, /ArgNames=/ReleaseHandleArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReleaseHandle Instance; }; const ParsedAttrInfoReleaseHandle ParsedAttrInfoReleaseHandle::Instance; static constexpr ParsedAttrInfo::Spelling RenderScriptKernelSpellings[] = { {AttributeCommonInfo::AS_GNU, "kernel"}, }; struct ParsedAttrInfoRenderScriptKernel final : public ParsedAttrInfo { constexpr ParsedAttrInfoRenderScriptKernel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_RenderScriptKernel, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/RenderScriptKernelSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.RenderScript; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) RenderScriptKernelAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRenderScriptKernel Instance; }; const ParsedAttrInfoRenderScriptKernel ParsedAttrInfoRenderScriptKernel::Instance; static constexpr ParsedAttrInfo::Spelling ReqdWorkGroupSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "reqd_work_group_size"}, }; static constexpr const char ReqdWorkGroupSizeArgNames[] = { "XDim","YDim","ZDim",}; struct ParsedAttrInfoReqdWorkGroupSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoReqdWorkGroupSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReqdWorkGroupSize, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReqdWorkGroupSizeSpellings, /ArgNames=/ReqdWorkGroupSizeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReqdWorkGroupSize Instance; }; const ParsedAttrInfoReqdWorkGroupSize ParsedAttrInfoReqdWorkGroupSize::Instance; static constexpr ParsedAttrInfo::Spelling RequiresCapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "requires_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::requires_capability"}, {AttributeCommonInfo::AS_GNU, "exclusive_locks_required"}, {AttributeCommonInfo::AS_CXX11, "clang::exclusive_locks_required"}, {AttributeCommonInfo::AS_GNU, "requires_shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::requires_shared_capability"}, {AttributeCommonInfo::AS_GNU, "shared_locks_required"}, {AttributeCommonInfo::AS_CXX11, "clang::shared_locks_required"}, }; static constexpr const char RequiresCapabilityArgNames[] = { "Args...",}; struct ParsedAttrInfoRequiresCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoRequiresCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_RequiresCapability, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/RequiresCapabilitySpellings, /ArgNames=/RequiresCapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoRequiresCapability Instance; }; const ParsedAttrInfoRequiresCapability ParsedAttrInfoRequiresCapability::Instance; static constexpr ParsedAttrInfo::Spelling RestrictSpellings[] = { {AttributeCommonInfo::AS_Declspec, "restrict"}, {AttributeCommonInfo::AS_GNU, "malloc"}, {AttributeCommonInfo::AS_CXX11, "gnu::malloc"}, {AttributeCommonInfo::AS_C2x, "gnu::malloc"}, }; struct ParsedAttrInfoRestrict final : public ParsedAttrInfo { constexpr ParsedAttrInfoRestrict() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Restrict, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/RestrictSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { Declspec_restrict = 0, GNU_malloc = 1, CXX11_gnu_malloc = 2, C2x_gnu_malloc = 3, SpellingNotCalculated = 15 }; 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; case 3: return C2x_gnu_malloc; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRestrict Instance; }; const ParsedAttrInfoRestrict ParsedAttrInfoRestrict::Instance; static constexpr ParsedAttrInfo::Spelling RetainSpellings[] = { {AttributeCommonInfo::AS_GNU, "retain"}, {AttributeCommonInfo::AS_CXX11, "gnu::retain"}, {AttributeCommonInfo::AS_C2x, "gnu::retain"}, }; struct ParsedAttrInfoRetain final : public ParsedAttrInfo { constexpr ParsedAttrInfoRetain() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Retain, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/RetainSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables with non-local storage, functions, and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) RetainAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoRetain Instance; }; const ParsedAttrInfoRetain ParsedAttrInfoRetain::Instance; static constexpr ParsedAttrInfo::Spelling ReturnTypestateSpellings[] = { {AttributeCommonInfo::AS_GNU, "return_typestate"}, {AttributeCommonInfo::AS_CXX11, "clang::return_typestate"}, }; static constexpr const char ReturnTypestateArgNames[] = { "State",}; struct ParsedAttrInfoReturnTypestate final : public ParsedAttrInfo { constexpr ParsedAttrInfoReturnTypestate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReturnTypestate, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReturnTypestateSpellings, /ArgNames=/ReturnTypestateArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReturnTypestate Instance; }; const ParsedAttrInfoReturnTypestate ParsedAttrInfoReturnTypestate::Instance; static constexpr ParsedAttrInfo::Spelling ReturnsNonNullSpellings[] = { {AttributeCommonInfo::AS_GNU, "returns_nonnull"}, {AttributeCommonInfo::AS_CXX11, "gnu::returns_nonnull"}, {AttributeCommonInfo::AS_C2x, "gnu::returns_nonnull"}, }; struct ParsedAttrInfoReturnsNonNull final : public ParsedAttrInfo { constexpr ParsedAttrInfoReturnsNonNull() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReturnsNonNull, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReturnsNonNullSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReturnsNonNull Instance; }; const ParsedAttrInfoReturnsNonNull ParsedAttrInfoReturnsNonNull::Instance; static constexpr ParsedAttrInfo::Spelling ReturnsTwiceSpellings[] = { {AttributeCommonInfo::AS_GNU, "returns_twice"}, {AttributeCommonInfo::AS_CXX11, "gnu::returns_twice"}, {AttributeCommonInfo::AS_C2x, "gnu::returns_twice"}, }; struct ParsedAttrInfoReturnsTwice final : public ParsedAttrInfo { constexpr ParsedAttrInfoReturnsTwice() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ReturnsTwice, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ReturnsTwiceSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ReturnsTwiceAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoReturnsTwice Instance; }; const ParsedAttrInfoReturnsTwice ParsedAttrInfoReturnsTwice::Instance; static constexpr ParsedAttrInfo::Spelling SPtrSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__sptr"}, }; struct ParsedAttrInfoSPtr final : public ParsedAttrInfo { constexpr ParsedAttrInfoSPtr() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SPtr, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SPtrSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSPtr Instance; }; const ParsedAttrInfoSPtr ParsedAttrInfoSPtr::Instance; static constexpr ParsedAttrInfo::Spelling SYCLKernelSpellings[] = { {AttributeCommonInfo::AS_GNU, "sycl_kernel"}, {AttributeCommonInfo::AS_CXX11, "clang::sycl_kernel"}, {AttributeCommonInfo::AS_C2x, "clang::sycl_kernel"}, }; struct ParsedAttrInfoSYCLKernel final : public ParsedAttrInfo { constexpr ParsedAttrInfoSYCLKernel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SYCLKernel, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SYCLKernelSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isFunctionTmpl(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "function templates"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.SYCLIsDevice; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSYCLKernel Instance; }; const ParsedAttrInfoSYCLKernel ParsedAttrInfoSYCLKernel::Instance; static constexpr ParsedAttrInfo::Spelling SYCLSpecialClassSpellings[] = { {AttributeCommonInfo::AS_GNU, "sycl_special_class"}, {AttributeCommonInfo::AS_CXX11, "clang::sycl_special_class"}, {AttributeCommonInfo::AS_C2x, "clang::sycl_special_class"}, }; struct ParsedAttrInfoSYCLSpecialClass final : public ParsedAttrInfo { constexpr ParsedAttrInfoSYCLSpecialClass() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SYCLSpecialClass, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SYCLSpecialClassSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.SYCLIsDevice; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSYCLSpecialClass Instance; }; const ParsedAttrInfoSYCLSpecialClass ParsedAttrInfoSYCLSpecialClass::Instance; static constexpr ParsedAttrInfo::Spelling ScopedLockableSpellings[] = { {AttributeCommonInfo::AS_GNU, "scoped_lockable"}, {AttributeCommonInfo::AS_CXX11, "clang::scoped_lockable"}, }; struct ParsedAttrInfoScopedLockable final : public ParsedAttrInfo { constexpr ParsedAttrInfoScopedLockable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ScopedLockable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/ScopedLockableSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) ScopedLockableAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoScopedLockable Instance; }; const ParsedAttrInfoScopedLockable ParsedAttrInfoScopedLockable::Instance; static constexpr ParsedAttrInfo::Spelling SectionSpellings[] = { {AttributeCommonInfo::AS_GNU, "section"}, {AttributeCommonInfo::AS_CXX11, "gnu::section"}, {AttributeCommonInfo::AS_C2x, "gnu::section"}, {AttributeCommonInfo::AS_Declspec, "allocate"}, }; static constexpr const char SectionArgNames[] = { "Name",}; struct ParsedAttrInfoSection final : public ParsedAttrInfo { constexpr ParsedAttrInfoSection() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Section, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/SectionSpellings, /ArgNames=/SectionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isGlobalVar(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions, global variables, Objective-C methods, and Objective-C properties"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_section = 0, CXX11_gnu_section = 1, C2x_gnu_section = 2, Declspec_allocate = 3, SpellingNotCalculated = 15 }; 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 C2x_gnu_section; case 3: return Declspec_allocate; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSection Instance; }; const ParsedAttrInfoSection ParsedAttrInfoSection::Instance; static constexpr ParsedAttrInfo::Spelling SelectAnySpellings[] = { {AttributeCommonInfo::AS_Declspec, "selectany"}, {AttributeCommonInfo::AS_GNU, "selectany"}, {AttributeCommonInfo::AS_CXX11, "gnu::selectany"}, {AttributeCommonInfo::AS_C2x, "gnu::selectany"}, }; struct ParsedAttrInfoSelectAny final : public ParsedAttrInfo { constexpr ParsedAttrInfoSelectAny() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SelectAny, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/SelectAnySpellings, /ArgNames=/{}) {} AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) SelectAnyAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSelectAny Instance; }; const ParsedAttrInfoSelectAny ParsedAttrInfoSelectAny::Instance; static constexpr ParsedAttrInfo::Spelling SentinelSpellings[] = { {AttributeCommonInfo::AS_GNU, "sentinel"}, {AttributeCommonInfo::AS_CXX11, "gnu::sentinel"}, {AttributeCommonInfo::AS_C2x, "gnu::sentinel"}, }; static constexpr const char SentinelArgNames[] = { "Sentinel","NullPos",}; struct ParsedAttrInfoSentinel final : public ParsedAttrInfo { constexpr ParsedAttrInfoSentinel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Sentinel, /NumArgs=/0, /OptArgs=/2, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/SentinelSpellings, /ArgNames=/SentinelArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSentinel Instance; }; const ParsedAttrInfoSentinel ParsedAttrInfoSentinel::Instance; static constexpr ParsedAttrInfo::Spelling SetTypestateSpellings[] = { {AttributeCommonInfo::AS_GNU, "set_typestate"}, {AttributeCommonInfo::AS_CXX11, "clang::set_typestate"}, }; static constexpr const char SetTypestateArgNames[] = { "NewState",}; struct ParsedAttrInfoSetTypestate final : public ParsedAttrInfo { constexpr ParsedAttrInfoSetTypestate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SetTypestate, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SetTypestateSpellings, /ArgNames=/SetTypestateArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /IsSupported=/LangOpts.CPlusPlus)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSetTypestate Instance; }; const ParsedAttrInfoSetTypestate ParsedAttrInfoSetTypestate::Instance; static constexpr ParsedAttrInfo::Spelling SharedTrylockFunctionSpellings[] = { {AttributeCommonInfo::AS_GNU, "shared_trylock_function"}, }; static constexpr const char SharedTrylockFunctionArgNames[] = { "SuccessValue","Args...",}; struct ParsedAttrInfoSharedTrylockFunction final : public ParsedAttrInfo { constexpr ParsedAttrInfoSharedTrylockFunction() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SharedTrylockFunction, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SharedTrylockFunctionSpellings, /ArgNames=/SharedTrylockFunctionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoSharedTrylockFunction Instance; }; const ParsedAttrInfoSharedTrylockFunction ParsedAttrInfoSharedTrylockFunction::Instance; static constexpr ParsedAttrInfo::Spelling SpeculativeLoadHardeningSpellings[] = { {AttributeCommonInfo::AS_GNU, "speculative_load_hardening"}, {AttributeCommonInfo::AS_CXX11, "clang::speculative_load_hardening"}, {AttributeCommonInfo::AS_C2x, "clang::speculative_load_hardening"}, }; struct ParsedAttrInfoSpeculativeLoadHardening final : public ParsedAttrInfo { constexpr ParsedAttrInfoSpeculativeLoadHardening() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SpeculativeLoadHardening, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SpeculativeLoadHardeningSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<NoSpeculativeLoadHardeningAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) SpeculativeLoadHardeningAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSpeculativeLoadHardening Instance; }; const ParsedAttrInfoSpeculativeLoadHardening ParsedAttrInfoSpeculativeLoadHardening::Instance; static constexpr ParsedAttrInfo::Spelling StandaloneDebugSpellings[] = { {AttributeCommonInfo::AS_GNU, "standalone_debug"}, {AttributeCommonInfo::AS_CXX11, "clang::standalone_debug"}, }; struct ParsedAttrInfoStandaloneDebug final : public ParsedAttrInfo { constexpr ParsedAttrInfoStandaloneDebug() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_StandaloneDebug, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/StandaloneDebugSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CPlusPlus; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) StandaloneDebugAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoStandaloneDebug Instance; }; const ParsedAttrInfoStandaloneDebug ParsedAttrInfoStandaloneDebug::Instance; static constexpr ParsedAttrInfo::Spelling StdCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "stdcall"}, {AttributeCommonInfo::AS_CXX11, "gnu::stdcall"}, {AttributeCommonInfo::AS_C2x, "gnu::stdcall"}, {AttributeCommonInfo::AS_Keyword, "__stdcall"}, {AttributeCommonInfo::AS_Keyword, "_stdcall"}, }; struct ParsedAttrInfoStdCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoStdCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_StdCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/StdCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoStdCall Instance; }; const ParsedAttrInfoStdCall ParsedAttrInfoStdCall::Instance; struct ParsedAttrInfoStrictFP final : public ParsedAttrInfo { constexpr ParsedAttrInfoStrictFP() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_StrictFP, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/{}, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoStrictFP Instance; }; const ParsedAttrInfoStrictFP ParsedAttrInfoStrictFP::Instance; static constexpr ParsedAttrInfo::Spelling StrictGuardStackCheckSpellings[] = { {AttributeCommonInfo::AS_Declspec, "strict_gs_check"}, }; struct ParsedAttrInfoStrictGuardStackCheck final : public ParsedAttrInfo { constexpr ParsedAttrInfoStrictGuardStackCheck() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_StrictGuardStackCheck, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/StrictGuardStackCheckSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) StrictGuardStackCheckAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoStrictGuardStackCheck Instance; }; const ParsedAttrInfoStrictGuardStackCheck ParsedAttrInfoStrictGuardStackCheck::Instance; static constexpr ParsedAttrInfo::Spelling SuppressSpellings[] = { {AttributeCommonInfo::AS_CXX11, "gsl::suppress"}, }; static constexpr const char SuppressArgNames[] = { "DiagnosticIdentifiers...",}; struct ParsedAttrInfoSuppress final : public ParsedAttrInfo { constexpr ParsedAttrInfoSuppress() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Suppress, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SuppressSpellings, /ArgNames=/SuppressArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSuppress Instance; }; const ParsedAttrInfoSuppress ParsedAttrInfoSuppress::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAsyncSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_async"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_async"}, {AttributeCommonInfo::AS_C2x, "clang::swift_async"}, }; static constexpr const char SwiftAsyncArgNames[] = { "Kind","CompletionHandlerIndex",}; struct ParsedAttrInfoSwiftAsync final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAsync() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAsync, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftAsyncSpellings, /ArgNames=/SwiftAsyncArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAsync Instance; }; const ParsedAttrInfoSwiftAsync ParsedAttrInfoSwiftAsync::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAsyncCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "swiftasynccall"}, {AttributeCommonInfo::AS_CXX11, "clang::swiftasynccall"}, {AttributeCommonInfo::AS_C2x, "clang::swiftasynccall"}, }; struct ParsedAttrInfoSwiftAsyncCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAsyncCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAsyncCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SwiftAsyncCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAsyncCall Instance; }; const ParsedAttrInfoSwiftAsyncCall ParsedAttrInfoSwiftAsyncCall::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAsyncContextSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_async_context"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_async_context"}, {AttributeCommonInfo::AS_C2x, "clang::swift_async_context"}, }; struct ParsedAttrInfoSwiftAsyncContext final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAsyncContext() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAsyncContext, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftAsyncContextSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAsyncContext Instance; }; const ParsedAttrInfoSwiftAsyncContext ParsedAttrInfoSwiftAsyncContext::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAsyncErrorSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_async_error"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_async_error"}, {AttributeCommonInfo::AS_C2x, "clang::swift_async_error"}, }; static constexpr const char SwiftAsyncErrorArgNames[] = { "Convention","HandlerParamIdx",}; struct ParsedAttrInfoSwiftAsyncError final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAsyncError() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAsyncError, /NumArgs=/1, /OptArgs=/1, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftAsyncErrorSpellings, /ArgNames=/SwiftAsyncErrorArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAsyncError Instance; }; const ParsedAttrInfoSwiftAsyncError ParsedAttrInfoSwiftAsyncError::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAsyncNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_async_name"}, }; static constexpr const char SwiftAsyncNameArgNames[] = { "Name",}; struct ParsedAttrInfoSwiftAsyncName final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAsyncName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAsyncName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftAsyncNameSpellings, /ArgNames=/SwiftAsyncNameArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAsyncName Instance; }; const ParsedAttrInfoSwiftAsyncName ParsedAttrInfoSwiftAsyncName::Instance; static constexpr ParsedAttrInfo::Spelling SwiftAttrSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_attr"}, }; static constexpr const char SwiftAttrArgNames[] = { "Attribute",}; struct ParsedAttrInfoSwiftAttr final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftAttr() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftAttr, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftAttrSpellings, /ArgNames=/SwiftAttrArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftAttr Instance; }; const ParsedAttrInfoSwiftAttr ParsedAttrInfoSwiftAttr::Instance; static constexpr ParsedAttrInfo::Spelling SwiftBridgeSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_bridge"}, }; static constexpr const char SwiftBridgeArgNames[] = { "SwiftType",}; struct ParsedAttrInfoSwiftBridge final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftBridge() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftBridge, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SwiftBridgeSpellings, /ArgNames=/SwiftBridgeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TagDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "tag types, typedefs, Objective-C interfaces, and Objective-C protocols"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftBridge Instance; }; const ParsedAttrInfoSwiftBridge ParsedAttrInfoSwiftBridge::Instance; static constexpr ParsedAttrInfo::Spelling SwiftBridgedTypedefSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_bridged_typedef"}, }; struct ParsedAttrInfoSwiftBridgedTypedef final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftBridgedTypedef() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftBridgedTypedef, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftBridgedTypedefSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) SwiftBridgedTypedefAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftBridgedTypedef Instance; }; const ParsedAttrInfoSwiftBridgedTypedef ParsedAttrInfoSwiftBridgedTypedef::Instance; static constexpr ParsedAttrInfo::Spelling SwiftCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "swiftcall"}, {AttributeCommonInfo::AS_CXX11, "clang::swiftcall"}, {AttributeCommonInfo::AS_C2x, "clang::swiftcall"}, }; struct ParsedAttrInfoSwiftCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SwiftCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftCall Instance; }; const ParsedAttrInfoSwiftCall ParsedAttrInfoSwiftCall::Instance; static constexpr ParsedAttrInfo::Spelling SwiftContextSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_context"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_context"}, {AttributeCommonInfo::AS_C2x, "clang::swift_context"}, }; struct ParsedAttrInfoSwiftContext final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftContext() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftContext, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftContextSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftContext Instance; }; const ParsedAttrInfoSwiftContext ParsedAttrInfoSwiftContext::Instance; static constexpr ParsedAttrInfo::Spelling SwiftErrorSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_error"}, }; static constexpr const char SwiftErrorArgNames[] = { "Convention",}; struct ParsedAttrInfoSwiftError final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftError() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftError, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftErrorSpellings, /ArgNames=/SwiftErrorArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftError Instance; }; const ParsedAttrInfoSwiftError ParsedAttrInfoSwiftError::Instance; static constexpr ParsedAttrInfo::Spelling SwiftErrorResultSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_error_result"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_error_result"}, {AttributeCommonInfo::AS_C2x, "clang::swift_error_result"}, }; struct ParsedAttrInfoSwiftErrorResult final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftErrorResult() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftErrorResult, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftErrorResultSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftErrorResult Instance; }; const ParsedAttrInfoSwiftErrorResult ParsedAttrInfoSwiftErrorResult::Instance; static constexpr ParsedAttrInfo::Spelling SwiftIndirectResultSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_indirect_result"}, {AttributeCommonInfo::AS_CXX11, "clang::swift_indirect_result"}, {AttributeCommonInfo::AS_C2x, "clang::swift_indirect_result"}, }; struct ParsedAttrInfoSwiftIndirectResult final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftIndirectResult() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftIndirectResult, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftIndirectResultSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftIndirectResult Instance; }; const ParsedAttrInfoSwiftIndirectResult ParsedAttrInfoSwiftIndirectResult::Instance; static constexpr ParsedAttrInfo::Spelling SwiftNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_name"}, }; static constexpr const char SwiftNameArgNames[] = { "Name",}; struct ParsedAttrInfoSwiftName final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SwiftNameSpellings, /ArgNames=/SwiftNameArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftName Instance; }; const ParsedAttrInfoSwiftName ParsedAttrInfoSwiftName::Instance; static constexpr ParsedAttrInfo::Spelling SwiftNewTypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_newtype"}, {AttributeCommonInfo::AS_GNU, "swift_wrapper"}, }; static constexpr const char SwiftNewTypeArgNames[] = { "NewtypeKind",}; struct ParsedAttrInfoSwiftNewType final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftNewType() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftNewType, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftNewTypeSpellings, /ArgNames=/SwiftNewTypeArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { GNU_swift_newtype = 0, GNU_swift_wrapper = 1, SpellingNotCalculated = 15 }; unsigned Idx = Attr.getAttributeSpellingListIndex(); switch (Idx) { default: llvm_unreachable("Unknown spelling list index"); case 0: return GNU_swift_newtype; case 1: return GNU_swift_wrapper; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftNewType Instance; }; const ParsedAttrInfoSwiftNewType ParsedAttrInfoSwiftNewType::Instance; static constexpr ParsedAttrInfo::Spelling SwiftObjCMembersSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_objc_members"}, }; struct ParsedAttrInfoSwiftObjCMembers final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftObjCMembers() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftObjCMembers, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/SwiftObjCMembersSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCInterfaceDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) SwiftObjCMembersAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftObjCMembers Instance; }; const ParsedAttrInfoSwiftObjCMembers ParsedAttrInfoSwiftObjCMembers::Instance; static constexpr ParsedAttrInfo::Spelling SwiftPrivateSpellings[] = { {AttributeCommonInfo::AS_GNU, "swift_private"}, }; struct ParsedAttrInfoSwiftPrivate final : public ParsedAttrInfo { constexpr ParsedAttrInfoSwiftPrivate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SwiftPrivate, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/SwiftPrivateSpellings, /ArgNames=/{}) {} AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) SwiftPrivateAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSwiftPrivate Instance; }; const ParsedAttrInfoSwiftPrivate ParsedAttrInfoSwiftPrivate::Instance; static constexpr ParsedAttrInfo::Spelling SysVABISpellings[] = { {AttributeCommonInfo::AS_GNU, "sysv_abi"}, {AttributeCommonInfo::AS_CXX11, "gnu::sysv_abi"}, {AttributeCommonInfo::AS_C2x, "gnu::sysv_abi"}, }; struct ParsedAttrInfoSysVABI final : public ParsedAttrInfo { constexpr ParsedAttrInfoSysVABI() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_SysVABI, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/SysVABISpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoSysVABI Instance; }; const ParsedAttrInfoSysVABI ParsedAttrInfoSysVABI::Instance; static constexpr ParsedAttrInfo::Spelling TLSModelSpellings[] = { {AttributeCommonInfo::AS_GNU, "tls_model"}, {AttributeCommonInfo::AS_CXX11, "gnu::tls_model"}, {AttributeCommonInfo::AS_C2x, "gnu::tls_model"}, }; static constexpr const char TLSModelArgNames[] = { "Model",}; struct ParsedAttrInfoTLSModel final : public ParsedAttrInfo { constexpr ParsedAttrInfoTLSModel() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TLSModel, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/TLSModelSpellings, /ArgNames=/TLSModelArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isTLSVar(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "thread-local variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_thread_local, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTLSModel Instance; }; const ParsedAttrInfoTLSModel ParsedAttrInfoTLSModel::Instance; static constexpr ParsedAttrInfo::Spelling TargetSpellings[] = { {AttributeCommonInfo::AS_GNU, "target"}, {AttributeCommonInfo::AS_CXX11, "gnu::target"}, {AttributeCommonInfo::AS_C2x, "gnu::target"}, }; static constexpr const char TargetArgNames[] = { "featuresStr",}; struct ParsedAttrInfoTarget final : public ParsedAttrInfo { constexpr ParsedAttrInfoTarget() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Target, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/TargetSpellings, /ArgNames=/TargetArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<TargetClonesAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetVersionAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUDispatchAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUSpecificAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTarget Instance; }; const ParsedAttrInfoTarget ParsedAttrInfoTarget::Instance; static constexpr ParsedAttrInfo::Spelling TargetClonesSpellings[] = { {AttributeCommonInfo::AS_GNU, "target_clones"}, {AttributeCommonInfo::AS_CXX11, "gnu::target_clones"}, {AttributeCommonInfo::AS_C2x, "gnu::target_clones"}, }; static constexpr const char TargetClonesArgNames[] = { "featuresStrs...",}; struct ParsedAttrInfoTargetClones final : public ParsedAttrInfo { constexpr ParsedAttrInfoTargetClones() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TargetClones, /NumArgs=/0, /OptArgs=/15, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/TargetClonesSpellings, /ArgNames=/TargetClonesArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<TargetVersionAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUDispatchAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUSpecificAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTargetClones Instance; }; const ParsedAttrInfoTargetClones ParsedAttrInfoTargetClones::Instance; static constexpr ParsedAttrInfo::Spelling TargetVersionSpellings[] = { {AttributeCommonInfo::AS_GNU, "target_version"}, {AttributeCommonInfo::AS_CXX11, "gnu::target_version"}, {AttributeCommonInfo::AS_C2x, "gnu::target_version"}, }; static constexpr const char TargetVersionArgNames[] = { "NamesStr",}; struct ParsedAttrInfoTargetVersion final : public ParsedAttrInfo { constexpr ParsedAttrInfoTargetVersion() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TargetVersion, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/TargetVersionSpellings, /ArgNames=/TargetVersionArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } using ParsedAttrInfo::diagMutualExclusion; bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl D) const override { if (const auto A = D->getAttr<TargetClonesAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<TargetAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUDispatchAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto A = D->getAttr<CPUSpecificAttr>()) { S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() \|\| A->isRegularKeywordAttribute()); S.Diag(A->getLocation(), diag::note_conflicting_attribute); return false; } return true; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTargetVersion Instance; }; const ParsedAttrInfoTargetVersion ParsedAttrInfoTargetVersion::Instance; static constexpr ParsedAttrInfo::Spelling TestTypestateSpellings[] = { {AttributeCommonInfo::AS_GNU, "test_typestate"}, {AttributeCommonInfo::AS_CXX11, "clang::test_typestate"}, }; static constexpr const char TestTypestateArgNames[] = { "TestState",}; struct ParsedAttrInfoTestTypestate final : public ParsedAttrInfo { constexpr ParsedAttrInfoTestTypestate() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TestTypestate, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/TestTypestateSpellings, /ArgNames=/TestTypestateArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /IsSupported=/LangOpts.CPlusPlus)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTestTypestate Instance; }; const ParsedAttrInfoTestTypestate ParsedAttrInfoTestTypestate::Instance; static constexpr ParsedAttrInfo::Spelling ThisCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "thiscall"}, {AttributeCommonInfo::AS_CXX11, "gnu::thiscall"}, {AttributeCommonInfo::AS_C2x, "gnu::thiscall"}, {AttributeCommonInfo::AS_Keyword, "__thiscall"}, {AttributeCommonInfo::AS_Keyword, "_thiscall"}, }; struct ParsedAttrInfoThisCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoThisCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ThisCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/ThisCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoThisCall Instance; }; const ParsedAttrInfoThisCall ParsedAttrInfoThisCall::Instance; static constexpr ParsedAttrInfo::Spelling ThreadSpellings[] = { {AttributeCommonInfo::AS_Declspec, "thread"}, }; struct ParsedAttrInfoThread final : public ParsedAttrInfo { constexpr ParsedAttrInfoThread() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Thread, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/ThreadSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.MicrosoftExt; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoThread Instance; }; const ParsedAttrInfoThread ParsedAttrInfoThread::Instance; static constexpr ParsedAttrInfo::Spelling TransparentUnionSpellings[] = { {AttributeCommonInfo::AS_GNU, "transparent_union"}, {AttributeCommonInfo::AS_CXX11, "gnu::transparent_union"}, {AttributeCommonInfo::AS_C2x, "gnu::transparent_union"}, }; struct ParsedAttrInfoTransparentUnion final : public ParsedAttrInfo { constexpr ParsedAttrInfoTransparentUnion() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TransparentUnion, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/TransparentUnionSpellings, /ArgNames=/{}) {} bool acceptsLangOpts(const LangOptions &LangOpts) const override { return (!LangOpts.CPlusPlus); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTransparentUnion Instance; }; const ParsedAttrInfoTransparentUnion ParsedAttrInfoTransparentUnion::Instance; static constexpr ParsedAttrInfo::Spelling TrivialABISpellings[] = { {AttributeCommonInfo::AS_GNU, "trivial_abi"}, {AttributeCommonInfo::AS_CXX11, "clang::trivial_abi"}, }; struct ParsedAttrInfoTrivialABI final : public ParsedAttrInfo { constexpr ParsedAttrInfoTrivialABI() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TrivialABI, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/TrivialABISpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.CPlusPlus; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) TrivialABIAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTrivialABI Instance; }; const ParsedAttrInfoTrivialABI ParsedAttrInfoTrivialABI::Instance; static constexpr ParsedAttrInfo::Spelling TryAcquireCapabilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "try_acquire_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::try_acquire_capability"}, {AttributeCommonInfo::AS_GNU, "try_acquire_shared_capability"}, {AttributeCommonInfo::AS_CXX11, "clang::try_acquire_shared_capability"}, }; static constexpr const char TryAcquireCapabilityArgNames[] = { "SuccessValue","Args...",}; struct ParsedAttrInfoTryAcquireCapability final : public ParsedAttrInfo { constexpr ParsedAttrInfoTryAcquireCapability() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TryAcquireCapability, /NumArgs=/1, /OptArgs=/15, /NumArgMembers=/2, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TryAcquireCapabilitySpellings, /ArgNames=/TryAcquireCapabilityArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } bool isParamExpr(size_t N) const override { return (N == 0) \|\| (N == 1) \|\| false; } static const ParsedAttrInfoTryAcquireCapability Instance; }; const ParsedAttrInfoTryAcquireCapability ParsedAttrInfoTryAcquireCapability::Instance; static constexpr ParsedAttrInfo::Spelling TypeNonNullSpellings[] = { {AttributeCommonInfo::AS_Keyword, "_Nonnull"}, }; struct ParsedAttrInfoTypeNonNull final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeNonNull() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeNonNull, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeNonNullSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeNonNull Instance; }; const ParsedAttrInfoTypeNonNull ParsedAttrInfoTypeNonNull::Instance; static constexpr ParsedAttrInfo::Spelling TypeNullUnspecifiedSpellings[] = { {AttributeCommonInfo::AS_Keyword, "_Null_unspecified"}, }; struct ParsedAttrInfoTypeNullUnspecified final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeNullUnspecified() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeNullUnspecified, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeNullUnspecifiedSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeNullUnspecified Instance; }; const ParsedAttrInfoTypeNullUnspecified ParsedAttrInfoTypeNullUnspecified::Instance; static constexpr ParsedAttrInfo::Spelling TypeNullableSpellings[] = { {AttributeCommonInfo::AS_Keyword, "_Nullable"}, }; struct ParsedAttrInfoTypeNullable final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeNullable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeNullable, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeNullableSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeNullable Instance; }; const ParsedAttrInfoTypeNullable ParsedAttrInfoTypeNullable::Instance; static constexpr ParsedAttrInfo::Spelling TypeNullableResultSpellings[] = { {AttributeCommonInfo::AS_Keyword, "_Nullable_result"}, }; struct ParsedAttrInfoTypeNullableResult final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeNullableResult() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeNullableResult, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeNullableResultSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeNullableResult Instance; }; const ParsedAttrInfoTypeNullableResult ParsedAttrInfoTypeNullableResult::Instance; static constexpr ParsedAttrInfo::Spelling TypeTagForDatatypeSpellings[] = { {AttributeCommonInfo::AS_GNU, "type_tag_for_datatype"}, {AttributeCommonInfo::AS_CXX11, "clang::type_tag_for_datatype"}, {AttributeCommonInfo::AS_C2x, "clang::type_tag_for_datatype"}, }; static constexpr const char TypeTagForDatatypeArgNames[] = { "ArgumentKind","MatchingCType","LayoutCompatible","MustBeNull",}; struct ParsedAttrInfoTypeTagForDatatype final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeTagForDatatype() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeTagForDatatype, /NumArgs=/4, /OptArgs=/0, /NumArgMembers=/4, /HasCustomParsing=/1, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeTagForDatatypeSpellings, /ArgNames=/TypeTagForDatatypeArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeTagForDatatype Instance; }; const ParsedAttrInfoTypeTagForDatatype ParsedAttrInfoTypeTagForDatatype::Instance; static constexpr ParsedAttrInfo::Spelling TypeVisibilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "type_visibility"}, {AttributeCommonInfo::AS_CXX11, "clang::type_visibility"}, {AttributeCommonInfo::AS_C2x, "clang::type_visibility"}, }; static constexpr const char TypeVisibilityArgNames[] = { "Visibility",}; struct ParsedAttrInfoTypeVisibility final : public ParsedAttrInfo { constexpr ParsedAttrInfoTypeVisibility() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_TypeVisibility, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/TypeVisibilitySpellings, /ArgNames=/TypeVisibilityArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoTypeVisibility Instance; }; const ParsedAttrInfoTypeVisibility ParsedAttrInfoTypeVisibility::Instance; static constexpr ParsedAttrInfo::Spelling UPtrSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__uptr"}, }; struct ParsedAttrInfoUPtr final : public ParsedAttrInfo { constexpr ParsedAttrInfoUPtr() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_UPtr, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/UPtrSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUPtr Instance; }; const ParsedAttrInfoUPtr ParsedAttrInfoUPtr::Instance; static constexpr ParsedAttrInfo::Spelling UnavailableSpellings[] = { {AttributeCommonInfo::AS_GNU, "unavailable"}, {AttributeCommonInfo::AS_CXX11, "clang::unavailable"}, {AttributeCommonInfo::AS_C2x, "clang::unavailable"}, }; static constexpr const char UnavailableArgNames[] = { "Message",}; struct ParsedAttrInfoUnavailable final : public ParsedAttrInfo { constexpr ParsedAttrInfoUnavailable() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Unavailable, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/UnavailableSpellings, /ArgNames=/UnavailableArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUnavailable Instance; }; const ParsedAttrInfoUnavailable ParsedAttrInfoUnavailable::Instance; static constexpr ParsedAttrInfo::Spelling UninitializedSpellings[] = { {AttributeCommonInfo::AS_GNU, "uninitialized"}, {AttributeCommonInfo::AS_CXX11, "clang::uninitialized"}, }; struct ParsedAttrInfoUninitialized final : public ParsedAttrInfo { constexpr ParsedAttrInfoUninitialized() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Uninitialized, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/UninitializedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isLocalVar(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "local variables"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_local, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUninitialized Instance; }; const ParsedAttrInfoUninitialized ParsedAttrInfoUninitialized::Instance; static constexpr ParsedAttrInfo::Spelling UnlikelySpellings[] = { {AttributeCommonInfo::AS_CXX11, "unlikely"}, {AttributeCommonInfo::AS_C2x, "clang::unlikely"}, }; struct ParsedAttrInfoUnlikely final : public ParsedAttrInfo { constexpr ParsedAttrInfoUnlikely() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Unlikely, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/1, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/UnlikelySpellings, /ArgNames=/{}) {} using ParsedAttrInfo::diagMutualExclusion; bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUnlikely Instance; }; const ParsedAttrInfoUnlikely ParsedAttrInfoUnlikely::Instance; static constexpr ParsedAttrInfo::Spelling UnsafeBufferUsageSpellings[] = { {AttributeCommonInfo::AS_GNU, "unsafe_buffer_usage"}, {AttributeCommonInfo::AS_CXX11, "clang::unsafe_buffer_usage"}, {AttributeCommonInfo::AS_C2x, "clang::unsafe_buffer_usage"}, }; struct ParsedAttrInfoUnsafeBufferUsage final : public ParsedAttrInfo { constexpr ParsedAttrInfoUnsafeBufferUsage() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_UnsafeBufferUsage, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/UnsafeBufferUsageSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUnsafeBufferUsage Instance; }; const ParsedAttrInfoUnsafeBufferUsage ParsedAttrInfoUnsafeBufferUsage::Instance; static constexpr ParsedAttrInfo::Spelling UnusedSpellings[] = { {AttributeCommonInfo::AS_CXX11, "maybe_unused"}, {AttributeCommonInfo::AS_GNU, "unused"}, {AttributeCommonInfo::AS_CXX11, "gnu::unused"}, {AttributeCommonInfo::AS_C2x, "gnu::unused"}, {AttributeCommonInfo::AS_C2x, "maybe_unused"}, }; struct ParsedAttrInfoUnused final : public ParsedAttrInfo { constexpr ParsedAttrInfoUnused() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Unused, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/UnusedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!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 << Attr.isRegularKeywordAttribute() << "variables, non-static data members, types, enums, enumerators, labels, non-static data members, Objective-C methods, functions, and function pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { enum Spelling { CXX11_maybe_unused = 0, GNU_unused = 1, CXX11_gnu_unused = 2, C2x_gnu_unused = 3, C2x_maybe_unused = 4, SpellingNotCalculated = 15 }; 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_gnu_unused; case 4: return C2x_maybe_unused; } } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUnused Instance; }; const ParsedAttrInfoUnused ParsedAttrInfoUnused::Instance; static constexpr ParsedAttrInfo::Spelling UseHandleSpellings[] = { {AttributeCommonInfo::AS_GNU, "use_handle"}, {AttributeCommonInfo::AS_CXX11, "clang::use_handle"}, {AttributeCommonInfo::AS_C2x, "clang::use_handle"}, }; static constexpr const char UseHandleArgNames[] = { "HandleType",}; struct ParsedAttrInfoUseHandle final : public ParsedAttrInfo { constexpr ParsedAttrInfoUseHandle() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_UseHandle, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/UseHandleSpellings, /ArgNames=/UseHandleArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ParmVarDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "parameters"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUseHandle Instance; }; const ParsedAttrInfoUseHandle ParsedAttrInfoUseHandle::Instance; static constexpr ParsedAttrInfo::Spelling UsedSpellings[] = { {AttributeCommonInfo::AS_GNU, "used"}, {AttributeCommonInfo::AS_CXX11, "gnu::used"}, {AttributeCommonInfo::AS_C2x, "gnu::used"}, }; struct ParsedAttrInfoUsed final : public ParsedAttrInfo { constexpr ParsedAttrInfoUsed() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Used, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/UsedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables with non-local storage, functions, and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) UsedAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUsed Instance; }; const ParsedAttrInfoUsed ParsedAttrInfoUsed::Instance; static constexpr ParsedAttrInfo::Spelling UsingIfExistsSpellings[] = { {AttributeCommonInfo::AS_GNU, "using_if_exists"}, {AttributeCommonInfo::AS_CXX11, "clang::using_if_exists"}, }; struct ParsedAttrInfoUsingIfExists final : public ParsedAttrInfo { constexpr ParsedAttrInfoUsingIfExists() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_UsingIfExists, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/UsingIfExistsSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<UsingDecl>(D) && !isa<UnresolvedUsingTypenameDecl>(D) && !isa<UnresolvedUsingValueDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "named declarations, types, and value declarations"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUsingIfExists Instance; }; const ParsedAttrInfoUsingIfExists ParsedAttrInfoUsingIfExists::Instance; static constexpr ParsedAttrInfo::Spelling UuidSpellings[] = { {AttributeCommonInfo::AS_Declspec, "uuid"}, {AttributeCommonInfo::AS_Microsoft, "uuid"}, }; static constexpr const char UuidArgNames[] = { "Guid",}; struct ParsedAttrInfoUuid final : public ParsedAttrInfo { constexpr ParsedAttrInfoUuid() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Uuid, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/UuidSpellings, /ArgNames=/UuidArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D) && !isa<EnumDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and enums"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool acceptsLangOpts(const LangOptions &LangOpts) const override { return LangOpts.MicrosoftExt \|\| LangOpts.Borland; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoUuid Instance; }; const ParsedAttrInfoUuid ParsedAttrInfoUuid::Instance; static constexpr ParsedAttrInfo::Spelling VecReturnSpellings[] = { {AttributeCommonInfo::AS_GNU, "vecreturn"}, {AttributeCommonInfo::AS_CXX11, "clang::vecreturn"}, }; struct ParsedAttrInfoVecReturn final : public ParsedAttrInfo { constexpr ParsedAttrInfoVecReturn() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_VecReturn, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/VecReturnSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoVecReturn Instance; }; const ParsedAttrInfoVecReturn ParsedAttrInfoVecReturn::Instance; static constexpr ParsedAttrInfo::Spelling VecTypeHintSpellings[] = { {AttributeCommonInfo::AS_GNU, "vec_type_hint"}, }; static constexpr const char VecTypeHintArgNames[] = { "TypeHint",}; struct ParsedAttrInfoVecTypeHint final : public ParsedAttrInfo { constexpr ParsedAttrInfoVecTypeHint() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_VecTypeHint, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/VecTypeHintSpellings, /ArgNames=/VecTypeHintArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoVecTypeHint Instance; }; const ParsedAttrInfoVecTypeHint ParsedAttrInfoVecTypeHint::Instance; static constexpr ParsedAttrInfo::Spelling VectorCallSpellings[] = { {AttributeCommonInfo::AS_GNU, "vectorcall"}, {AttributeCommonInfo::AS_CXX11, "clang::vectorcall"}, {AttributeCommonInfo::AS_C2x, "clang::vectorcall"}, {AttributeCommonInfo::AS_Keyword, "__vectorcall"}, {AttributeCommonInfo::AS_Keyword, "_vectorcall"}, }; struct ParsedAttrInfoVectorCall final : public ParsedAttrInfo { constexpr ParsedAttrInfoVectorCall() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_VectorCall, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/VectorCallSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoVectorCall Instance; }; const ParsedAttrInfoVectorCall ParsedAttrInfoVectorCall::Instance; static constexpr ParsedAttrInfo::Spelling VectorSizeSpellings[] = { {AttributeCommonInfo::AS_GNU, "vector_size"}, {AttributeCommonInfo::AS_CXX11, "gnu::vector_size"}, {AttributeCommonInfo::AS_C2x, "gnu::vector_size"}, }; static constexpr const char VectorSizeArgNames[] = { "NumBytes",}; struct ParsedAttrInfoVectorSize final : public ParsedAttrInfo { constexpr ParsedAttrInfoVectorSize() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_VectorSize, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/VectorSizeSpellings, /ArgNames=/VectorSizeArgNames) {} bool isParamExpr(size_t N) const override { return (N == 0) \|\| false; } static const ParsedAttrInfoVectorSize Instance; }; const ParsedAttrInfoVectorSize ParsedAttrInfoVectorSize::Instance; static constexpr ParsedAttrInfo::Spelling VisibilitySpellings[] = { {AttributeCommonInfo::AS_GNU, "visibility"}, {AttributeCommonInfo::AS_CXX11, "gnu::visibility"}, {AttributeCommonInfo::AS_C2x, "gnu::visibility"}, }; static constexpr const char VisibilityArgNames[] = { "Visibility",}; struct ParsedAttrInfoVisibility final : public ParsedAttrInfo { constexpr ParsedAttrInfoVisibility() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Visibility, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/VisibilitySpellings, /ArgNames=/VisibilityArgNames) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoVisibility Instance; }; const ParsedAttrInfoVisibility ParsedAttrInfoVisibility::Instance; static constexpr ParsedAttrInfo::Spelling WarnUnusedSpellings[] = { {AttributeCommonInfo::AS_GNU, "warn_unused"}, {AttributeCommonInfo::AS_CXX11, "gnu::warn_unused"}, {AttributeCommonInfo::AS_C2x, "gnu::warn_unused"}, }; struct ParsedAttrInfoWarnUnused final : public ParsedAttrInfo { constexpr ParsedAttrInfoWarnUnused() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WarnUnused, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/WarnUnusedSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<RecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /IsSupported=/true)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) WarnUnusedAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWarnUnused Instance; }; const ParsedAttrInfoWarnUnused ParsedAttrInfoWarnUnused::Instance; static constexpr ParsedAttrInfo::Spelling WarnUnusedResultSpellings[] = { {AttributeCommonInfo::AS_CXX11, "nodiscard"}, {AttributeCommonInfo::AS_C2x, "nodiscard"}, {AttributeCommonInfo::AS_CXX11, "clang::warn_unused_result"}, {AttributeCommonInfo::AS_GNU, "warn_unused_result"}, {AttributeCommonInfo::AS_CXX11, "gnu::warn_unused_result"}, {AttributeCommonInfo::AS_C2x, "gnu::warn_unused_result"}, }; static constexpr const char WarnUnusedResultArgNames[] = { "Message",}; struct ParsedAttrInfoWarnUnusedResult final : public ParsedAttrInfo { constexpr ParsedAttrInfoWarnUnusedResult() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WarnUnusedResult, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/WarnUnusedResultSpellings, /ArgNames=/WarnUnusedResultArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<ObjCMethodDecl>(D) && !isa<EnumDecl>(D) && !isa<RecordDecl>(D) && !isFunctionLike(D) && !isa<TypedefNameDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, enums, structs, unions, classes, functions, function pointers, and typedefs"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, C2x_gnu_warn_unused_result = 5, SpellingNotCalculated = 15 }; 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; case 5: return C2x_gnu_warn_unused_result; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWarnUnusedResult Instance; }; const ParsedAttrInfoWarnUnusedResult ParsedAttrInfoWarnUnusedResult::Instance; static constexpr ParsedAttrInfo::Spelling WeakSpellings[] = { {AttributeCommonInfo::AS_GNU, "weak"}, {AttributeCommonInfo::AS_CXX11, "gnu::weak"}, {AttributeCommonInfo::AS_C2x, "gnu::weak"}, }; struct ParsedAttrInfoWeak final : public ParsedAttrInfo { constexpr ParsedAttrInfoWeak() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_Weak, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/WeakSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { 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)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) WeakAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWeak Instance; }; const ParsedAttrInfoWeak ParsedAttrInfoWeak::Instance; static constexpr ParsedAttrInfo::Spelling WeakImportSpellings[] = { {AttributeCommonInfo::AS_GNU, "weak_import"}, {AttributeCommonInfo::AS_CXX11, "clang::weak_import"}, {AttributeCommonInfo::AS_C2x, "clang::weak_import"}, }; struct ParsedAttrInfoWeakImport final : public ParsedAttrInfo { constexpr ParsedAttrInfoWeakImport() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WeakImport, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/WeakImportSpellings, /ArgNames=/{}) {} bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWeakImport Instance; }; const ParsedAttrInfoWeakImport ParsedAttrInfoWeakImport::Instance; static constexpr ParsedAttrInfo::Spelling WeakRefSpellings[] = { {AttributeCommonInfo::AS_GNU, "weakref"}, {AttributeCommonInfo::AS_CXX11, "gnu::weakref"}, {AttributeCommonInfo::AS_C2x, "gnu::weakref"}, }; static constexpr const char WeakRefArgNames[] = { "Aliasee",}; struct ParsedAttrInfoWeakRef final : public ParsedAttrInfo { constexpr ParsedAttrInfoWeakRef() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WeakRef, /NumArgs=/0, /OptArgs=/1, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/WeakRefSpellings, /ArgNames=/WeakRefArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "variables and functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWeakRef Instance; }; const ParsedAttrInfoWeakRef ParsedAttrInfoWeakRef::Instance; static constexpr ParsedAttrInfo::Spelling WebAssemblyExportNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "export_name"}, {AttributeCommonInfo::AS_CXX11, "clang::export_name"}, {AttributeCommonInfo::AS_C2x, "clang::export_name"}, }; static constexpr const char WebAssemblyExportNameArgNames[] = { "ExportName",}; struct ParsedAttrInfoWebAssemblyExportName final : public ParsedAttrInfo { constexpr ParsedAttrInfoWebAssemblyExportName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WebAssemblyExportName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/WebAssemblyExportNameSpellings, /ArgNames=/WebAssemblyExportNameArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::wasm32 \|\| T.getArch() == llvm::Triple::wasm64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWebAssemblyExportName Instance; }; const ParsedAttrInfoWebAssemblyExportName ParsedAttrInfoWebAssemblyExportName::Instance; static constexpr ParsedAttrInfo::Spelling WebAssemblyFuncrefSpellings[] = { {AttributeCommonInfo::AS_Keyword, "__funcref"}, }; struct ParsedAttrInfoWebAssemblyFuncref final : public ParsedAttrInfo { constexpr ParsedAttrInfoWebAssemblyFuncref() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WebAssemblyFuncref, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/1, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/0, /Spellings=/WebAssemblyFuncrefSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isFunctionPointer(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions pointers"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::wasm32 \|\| T.getArch() == llvm::Triple::wasm64); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWebAssemblyFuncref Instance; }; const ParsedAttrInfoWebAssemblyFuncref ParsedAttrInfoWebAssemblyFuncref::Instance; static constexpr ParsedAttrInfo::Spelling WebAssemblyImportModuleSpellings[] = { {AttributeCommonInfo::AS_GNU, "import_module"}, {AttributeCommonInfo::AS_CXX11, "clang::import_module"}, {AttributeCommonInfo::AS_C2x, "clang::import_module"}, }; static constexpr const char WebAssemblyImportModuleArgNames[] = { "ImportModule",}; struct ParsedAttrInfoWebAssemblyImportModule final : public ParsedAttrInfo { constexpr ParsedAttrInfoWebAssemblyImportModule() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WebAssemblyImportModule, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/WebAssemblyImportModuleSpellings, /ArgNames=/WebAssemblyImportModuleArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::wasm32 \|\| T.getArch() == llvm::Triple::wasm64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWebAssemblyImportModule Instance; }; const ParsedAttrInfoWebAssemblyImportModule ParsedAttrInfoWebAssemblyImportModule::Instance; static constexpr ParsedAttrInfo::Spelling WebAssemblyImportNameSpellings[] = { {AttributeCommonInfo::AS_GNU, "import_name"}, {AttributeCommonInfo::AS_CXX11, "clang::import_name"}, {AttributeCommonInfo::AS_C2x, "clang::import_name"}, }; static constexpr const char WebAssemblyImportNameArgNames[] = { "ImportName",}; struct ParsedAttrInfoWebAssemblyImportName final : public ParsedAttrInfo { constexpr ParsedAttrInfoWebAssemblyImportName() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WebAssemblyImportName, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/WebAssemblyImportNameSpellings, /ArgNames=/WebAssemblyImportNameArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::wasm32 \|\| T.getArch() == llvm::Triple::wasm64); } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWebAssemblyImportName Instance; }; const ParsedAttrInfoWebAssemblyImportName ParsedAttrInfoWebAssemblyImportName::Instance; static constexpr ParsedAttrInfo::Spelling WorkGroupSizeHintSpellings[] = { {AttributeCommonInfo::AS_GNU, "work_group_size_hint"}, }; static constexpr const char WorkGroupSizeHintArgNames[] = { "XDim","YDim","ZDim",}; struct ParsedAttrInfoWorkGroupSizeHint final : public ParsedAttrInfo { constexpr ParsedAttrInfoWorkGroupSizeHint() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_WorkGroupSizeHint, /NumArgs=/3, /OptArgs=/0, /NumArgMembers=/3, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/WorkGroupSizeHintSpellings, /ArgNames=/WorkGroupSizeHintArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoWorkGroupSizeHint Instance; }; const ParsedAttrInfoWorkGroupSizeHint ParsedAttrInfoWorkGroupSizeHint::Instance; static constexpr ParsedAttrInfo::Spelling X86ForceAlignArgPointerSpellings[] = { {AttributeCommonInfo::AS_GNU, "force_align_arg_pointer"}, {AttributeCommonInfo::AS_CXX11, "gnu::force_align_arg_pointer"}, {AttributeCommonInfo::AS_C2x, "gnu::force_align_arg_pointer"}, }; struct ParsedAttrInfoX86ForceAlignArgPointer final : public ParsedAttrInfo { constexpr ParsedAttrInfoX86ForceAlignArgPointer() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_X86ForceAlignArgPointer, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/1, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/0, /Spellings=/X86ForceAlignArgPointerSpellings, /ArgNames=/{}) {} bool existsInTarget(const TargetInfo &Target) const override { const llvm::Triple &T = Target.getTriple(); (void)T; return true && (T.getArch() == llvm::Triple::x86 \|\| T.getArch() == llvm::Triple::x86_64); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoX86ForceAlignArgPointer Instance; }; const ParsedAttrInfoX86ForceAlignArgPointer ParsedAttrInfoX86ForceAlignArgPointer::Instance; static constexpr ParsedAttrInfo::Spelling XRayInstrumentSpellings[] = { {AttributeCommonInfo::AS_GNU, "xray_always_instrument"}, {AttributeCommonInfo::AS_CXX11, "clang::xray_always_instrument"}, {AttributeCommonInfo::AS_C2x, "clang::xray_always_instrument"}, {AttributeCommonInfo::AS_GNU, "xray_never_instrument"}, {AttributeCommonInfo::AS_CXX11, "clang::xray_never_instrument"}, {AttributeCommonInfo::AS_C2x, "clang::xray_never_instrument"}, }; struct ParsedAttrInfoXRayInstrument final : public ParsedAttrInfo { constexpr ParsedAttrInfoXRayInstrument() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_XRayInstrument, /NumArgs=/0, /OptArgs=/0, /NumArgMembers=/0, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/XRayInstrumentSpellings, /ArgNames=/{}) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override { 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, SpellingNotCalculated = 15 }; 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; } } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } AttrHandling handleDeclAttribute(Sema &S, Decl D,const ParsedAttr &Attr) const override { D->addAttr(::new (S.Context) XRayInstrumentAttr(S.Context, Attr)); return AttributeApplied; } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoXRayInstrument Instance; }; const ParsedAttrInfoXRayInstrument ParsedAttrInfoXRayInstrument::Instance; static constexpr ParsedAttrInfo::Spelling XRayLogArgsSpellings[] = { {AttributeCommonInfo::AS_GNU, "xray_log_args"}, {AttributeCommonInfo::AS_CXX11, "clang::xray_log_args"}, {AttributeCommonInfo::AS_C2x, "clang::xray_log_args"}, }; static constexpr const char XRayLogArgsArgNames[] = { "ArgumentCount",}; struct ParsedAttrInfoXRayLogArgs final : public ParsedAttrInfo { constexpr ParsedAttrInfoXRayLogArgs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_XRayLogArgs, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/0, /IsSupportedByPragmaAttribute=/1, /Spellings=/XRayLogArgsSpellings, /ArgNames=/XRayLogArgsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) { S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /IsSupported=/LangOpts.ObjC)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoXRayLogArgs Instance; }; const ParsedAttrInfoXRayLogArgs ParsedAttrInfoXRayLogArgs::Instance; static constexpr ParsedAttrInfo::Spelling ZeroCallUsedRegsSpellings[] = { {AttributeCommonInfo::AS_GNU, "zero_call_used_regs"}, {AttributeCommonInfo::AS_CXX11, "gnu::zero_call_used_regs"}, {AttributeCommonInfo::AS_C2x, "gnu::zero_call_used_regs"}, }; static constexpr const char ZeroCallUsedRegsArgNames[] = { "ZeroCallUsedRegs",}; struct ParsedAttrInfoZeroCallUsedRegs final : public ParsedAttrInfo { constexpr ParsedAttrInfoZeroCallUsedRegs() : ParsedAttrInfo( /AttrKind=/ParsedAttr::AT_ZeroCallUsedRegs, /NumArgs=/1, /OptArgs=/0, /NumArgMembers=/1, /HasCustomParsing=/0, /AcceptsExprPack=/0, /IsTargetSpecific=/0, /IsType=/0, /IsStmt=/0, /IsKnownToGCC=/1, /IsSupportedByPragmaAttribute=/1, /Spellings=/ZeroCallUsedRegsSpellings, /ArgNames=/ZeroCallUsedRegsArgNames) {} bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl D) const override { if (!isa<FunctionDecl>(D)) { S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << "functions"; return false; } return true; } bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt St) const override { S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt) << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc(); return false; } void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override { MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /IsSupported=/true)); } bool isParamExpr(size_t N) const override { return false; } static const ParsedAttrInfoZeroCallUsedRegs Instance; }; const ParsedAttrInfoZeroCallUsedRegs ParsedAttrInfoZeroCallUsedRegs::Instance; static const ParsedAttrInfo AttrInfoMap[] = { &ParsedAttrInfoAArch64SVEPcs::Instance, &ParsedAttrInfoAArch64VectorPcs::Instance, &ParsedAttrInfoAMDGPUFlatWorkGroupSize::Instance, &ParsedAttrInfoAMDGPUKernelCall::Instance, &ParsedAttrInfoAMDGPUNumSGPR::Instance, &ParsedAttrInfoAMDGPUNumVGPR::Instance, &ParsedAttrInfoAMDGPUWavesPerEU::Instance, &ParsedAttrInfoInterrupt::Instance, &ParsedAttrInfoAVRSignal::Instance, &ParsedAttrInfoAbiTag::Instance, &ParsedAttrInfoAcquireCapability::Instance, &ParsedAttrInfoAcquireHandle::Instance, &ParsedAttrInfoAcquiredAfter::Instance, &ParsedAttrInfoAcquiredBefore::Instance, &ParsedAttrInfoAddressSpace::Instance, &ParsedAttrInfoAlias::Instance, &ParsedAttrInfoAlignValue::Instance, &ParsedAttrInfoAligned::Instance, &ParsedAttrInfoAllocAlign::Instance, &ParsedAttrInfoAllocSize::Instance, &ParsedAttrInfoAlwaysDestroy::Instance, &ParsedAttrInfoAlwaysInline::Instance, &ParsedAttrInfoAnalyzerNoReturn::Instance, &ParsedAttrInfoAnnotate::Instance, &ParsedAttrInfoAnnotateType::Instance, &ParsedAttrInfoAnyX86NoCallerSavedRegisters::Instance, &ParsedAttrInfoAnyX86NoCfCheck::Instance, &ParsedAttrInfoArcWeakrefUnavailable::Instance, &ParsedAttrInfoArgumentWithTypeTag::Instance, &ParsedAttrInfoArmBuiltinAlias::Instance, &ParsedAttrInfoArmMveStrictPolymorphism::Instance, &ParsedAttrInfoArmStreaming::Instance, &ParsedAttrInfoArmSveVectorBits::Instance, &ParsedAttrInfoArtificial::Instance, &ParsedAttrInfoAssertCapability::Instance, &ParsedAttrInfoAssertExclusiveLock::Instance, &ParsedAttrInfoAssertSharedLock::Instance, &ParsedAttrInfoAssumeAligned::Instance, &ParsedAttrInfoAssumption::Instance, &ParsedAttrInfoAvailability::Instance, &ParsedAttrInfoAvailableOnlyInDefaultEvalMethod::Instance, &ParsedAttrInfoBPFPreserveAccessIndex::Instance, &ParsedAttrInfoBTFDeclTag::Instance, &ParsedAttrInfoBTFTypeTag::Instance, &ParsedAttrInfoBlocks::Instance, &ParsedAttrInfoBuiltinAlias::Instance, &ParsedAttrInfoCDecl::Instance, &ParsedAttrInfoCFAuditedTransfer::Instance, &ParsedAttrInfoCFConsumed::Instance, &ParsedAttrInfoCFGuard::Instance, &ParsedAttrInfoCFICanonicalJumpTable::Instance, &ParsedAttrInfoCFReturnsNotRetained::Instance, &ParsedAttrInfoCFReturnsRetained::Instance, &ParsedAttrInfoCFUnknownTransfer::Instance, &ParsedAttrInfoCPUDispatch::Instance, &ParsedAttrInfoCPUSpecific::Instance, &ParsedAttrInfoCUDAConstant::Instance, &ParsedAttrInfoCUDADevice::Instance, &ParsedAttrInfoCUDADeviceBuiltinSurfaceType::Instance, &ParsedAttrInfoCUDADeviceBuiltinTextureType::Instance, &ParsedAttrInfoCUDAGlobal::Instance, &ParsedAttrInfoCUDAHost::Instance, &ParsedAttrInfoCUDAInvalidTarget::Instance, &ParsedAttrInfoCUDALaunchBounds::Instance, &ParsedAttrInfoCUDAShared::Instance, &ParsedAttrInfoCXX11NoReturn::Instance, &ParsedAttrInfoCallableWhen::Instance, &ParsedAttrInfoCallback::Instance, &ParsedAttrInfoCalledOnce::Instance, &ParsedAttrInfoCapability::Instance, &ParsedAttrInfoCarriesDependency::Instance, &ParsedAttrInfoCleanup::Instance, &ParsedAttrInfoCmseNSCall::Instance, &ParsedAttrInfoCmseNSEntry::Instance, &ParsedAttrInfoCodeSeg::Instance, &ParsedAttrInfoCold::Instance, &ParsedAttrInfoCommon::Instance, &ParsedAttrInfoConst::Instance, &ParsedAttrInfoConstInit::Instance, &ParsedAttrInfoConstructor::Instance, &ParsedAttrInfoConsumable::Instance, &ParsedAttrInfoConsumableAutoCast::Instance, &ParsedAttrInfoConsumableSetOnRead::Instance, &ParsedAttrInfoConvergent::Instance, &ParsedAttrInfoDLLExport::Instance, &ParsedAttrInfoDLLExportStaticLocal::Instance, &ParsedAttrInfoDLLImport::Instance, &ParsedAttrInfoDLLImportStaticLocal::Instance, &ParsedAttrInfoDeprecated::Instance, &ParsedAttrInfoDestructor::Instance, &ParsedAttrInfoDiagnoseAsBuiltin::Instance, &ParsedAttrInfoDiagnoseIf::Instance, &ParsedAttrInfoDisableSanitizerInstrumentation::Instance, &ParsedAttrInfoDisableTailCalls::Instance, &ParsedAttrInfoEmptyBases::Instance, &ParsedAttrInfoEnableIf::Instance, &ParsedAttrInfoEnforceTCB::Instance, &ParsedAttrInfoEnforceTCBLeaf::Instance, &ParsedAttrInfoEnumExtensibility::Instance, &ParsedAttrInfoError::Instance, &ParsedAttrInfoExcludeFromExplicitInstantiation::Instance, &ParsedAttrInfoExclusiveTrylockFunction::Instance, &ParsedAttrInfoExtVectorType::Instance, &ParsedAttrInfoExternalSourceSymbol::Instance, &ParsedAttrInfoFallThrough::Instance, &ParsedAttrInfoFastCall::Instance, &ParsedAttrInfoFlagEnum::Instance, &ParsedAttrInfoFlatten::Instance, &ParsedAttrInfoFormat::Instance, &ParsedAttrInfoFormatArg::Instance, &ParsedAttrInfoFunctionReturnThunks::Instance, &ParsedAttrInfoGNUInline::Instance, &ParsedAttrInfoGuardedBy::Instance, &ParsedAttrInfoGuardedVar::Instance, &ParsedAttrInfoHIPManaged::Instance, &ParsedAttrInfoHLSLGroupSharedAddressSpace::Instance, &ParsedAttrInfoHLSLNumThreads::Instance, &ParsedAttrInfoHLSLResource::Instance, &ParsedAttrInfoHLSLResourceBinding::Instance, &ParsedAttrInfoHLSLSV_DispatchThreadID::Instance, &ParsedAttrInfoHLSLSV_GroupIndex::Instance, &ParsedAttrInfoHLSLShader::Instance, &ParsedAttrInfoHot::Instance, &ParsedAttrInfoIBAction::Instance, &ParsedAttrInfoIBOutlet::Instance, &ParsedAttrInfoIBOutletCollection::Instance, &ParsedAttrInfoIFunc::Instance, &ParsedAttrInfoInitPriority::Instance, &ParsedAttrInfoIntelOclBicc::Instance, &ParsedAttrInfoInternalLinkage::Instance, &ParsedAttrInfoLTOVisibilityPublic::Instance, &ParsedAttrInfoLayoutVersion::Instance, &ParsedAttrInfoLeaf::Instance, &ParsedAttrInfoLifetimeBound::Instance, &ParsedAttrInfoLikely::Instance, &ParsedAttrInfoLoaderUninitialized::Instance, &ParsedAttrInfoLockReturned::Instance, &ParsedAttrInfoLockable::Instance, &ParsedAttrInfoLocksExcluded::Instance, &ParsedAttrInfoLoopHint::Instance, &ParsedAttrInfoMIGServerRoutine::Instance, &ParsedAttrInfoMSABI::Instance, &ParsedAttrInfoMSAllocator::Instance, &ParsedAttrInfoMSInheritance::Instance, &ParsedAttrInfoMSNoVTable::Instance, &ParsedAttrInfoMSStruct::Instance, &ParsedAttrInfoMatrixType::Instance, &ParsedAttrInfoMayAlias::Instance, &ParsedAttrInfoMaybeUndef::Instance, &ParsedAttrInfoMicroMips::Instance, &ParsedAttrInfoMinSize::Instance, &ParsedAttrInfoMinVectorWidth::Instance, &ParsedAttrInfoMips16::Instance, &ParsedAttrInfoMipsLongCall::Instance, &ParsedAttrInfoMipsShortCall::Instance, &ParsedAttrInfoMode::Instance, &ParsedAttrInfoMustTail::Instance, &ParsedAttrInfoNSConsumed::Instance, &ParsedAttrInfoNSConsumesSelf::Instance, &ParsedAttrInfoNSErrorDomain::Instance, &ParsedAttrInfoNSReturnsAutoreleased::Instance, &ParsedAttrInfoNSReturnsNotRetained::Instance, &ParsedAttrInfoNSReturnsRetained::Instance, &ParsedAttrInfoNVPTXKernel::Instance, &ParsedAttrInfoNaked::Instance, &ParsedAttrInfoNeonPolyVectorType::Instance, &ParsedAttrInfoNeonVectorType::Instance, &ParsedAttrInfoNoAlias::Instance, &ParsedAttrInfoNoBuiltin::Instance, &ParsedAttrInfoNoCommon::Instance, &ParsedAttrInfoNoDebug::Instance, &ParsedAttrInfoNoDeref::Instance, &ParsedAttrInfoNoDestroy::Instance, &ParsedAttrInfoNoDuplicate::Instance, &ParsedAttrInfoNoEscape::Instance, &ParsedAttrInfoNoInline::Instance, &ParsedAttrInfoNoInstrumentFunction::Instance, &ParsedAttrInfoNoMerge::Instance, &ParsedAttrInfoNoMicroMips::Instance, &ParsedAttrInfoNoMips16::Instance, &ParsedAttrInfoNoProfileFunction::Instance, &ParsedAttrInfoNoRandomizeLayout::Instance, &ParsedAttrInfoNoReturn::Instance, &ParsedAttrInfoNoSanitize::Instance, &ParsedAttrInfoNoSanitizeSpecific::Instance, &ParsedAttrInfoNoSpeculativeLoadHardening::Instance, &ParsedAttrInfoNoSplitStack::Instance, &ParsedAttrInfoNoStackProtector::Instance, &ParsedAttrInfoNoThreadSafetyAnalysis::Instance, &ParsedAttrInfoNoThrow::Instance, &ParsedAttrInfoNoUniqueAddress::Instance, &ParsedAttrInfoNoUwtable::Instance, &ParsedAttrInfoNonNull::Instance, &ParsedAttrInfoNotTailCalled::Instance, &ParsedAttrInfoOSConsumed::Instance, &ParsedAttrInfoOSConsumesThis::Instance, &ParsedAttrInfoOSReturnsNotRetained::Instance, &ParsedAttrInfoOSReturnsRetained::Instance, &ParsedAttrInfoOSReturnsRetainedOnNonZero::Instance, &ParsedAttrInfoOSReturnsRetainedOnZero::Instance, &ParsedAttrInfoObjCBoxable::Instance, &ParsedAttrInfoObjCBridge::Instance, &ParsedAttrInfoObjCBridgeMutable::Instance, &ParsedAttrInfoObjCBridgeRelated::Instance, &ParsedAttrInfoObjCClassStub::Instance, &ParsedAttrInfoObjCDesignatedInitializer::Instance, &ParsedAttrInfoObjCDirect::Instance, &ParsedAttrInfoObjCDirectMembers::Instance, &ParsedAttrInfoObjCException::Instance, &ParsedAttrInfoObjCExplicitProtocolImpl::Instance, &ParsedAttrInfoObjCExternallyRetained::Instance, &ParsedAttrInfoObjCGC::Instance, &ParsedAttrInfoObjCIndependentClass::Instance, &ParsedAttrInfoObjCInertUnsafeUnretained::Instance, &ParsedAttrInfoObjCKindOf::Instance, &ParsedAttrInfoObjCMethodFamily::Instance, &ParsedAttrInfoObjCNSObject::Instance, &ParsedAttrInfoObjCNonLazyClass::Instance, &ParsedAttrInfoObjCNonRuntimeProtocol::Instance, &ParsedAttrInfoObjCOwnership::Instance, &ParsedAttrInfoObjCPreciseLifetime::Instance, &ParsedAttrInfoObjCRequiresPropertyDefs::Instance, &ParsedAttrInfoObjCRequiresSuper::Instance, &ParsedAttrInfoObjCReturnsInnerPointer::Instance, &ParsedAttrInfoObjCRootClass::Instance, &ParsedAttrInfoObjCRuntimeName::Instance, &ParsedAttrInfoObjCRuntimeVisible::Instance, &ParsedAttrInfoObjCSubclassingRestricted::Instance, &ParsedAttrInfoOpenCLAccess::Instance, &ParsedAttrInfoOpenCLConstantAddressSpace::Instance, &ParsedAttrInfoOpenCLGenericAddressSpace::Instance, &ParsedAttrInfoOpenCLGlobalAddressSpace::Instance, &ParsedAttrInfoOpenCLGlobalDeviceAddressSpace::Instance, &ParsedAttrInfoOpenCLGlobalHostAddressSpace::Instance, &ParsedAttrInfoOpenCLIntelReqdSubGroupSize::Instance, &ParsedAttrInfoOpenCLKernel::Instance, &ParsedAttrInfoOpenCLLocalAddressSpace::Instance, &ParsedAttrInfoOpenCLNoSVM::Instance, &ParsedAttrInfoOpenCLPrivateAddressSpace::Instance, &ParsedAttrInfoOpenCLUnrollHint::Instance, &ParsedAttrInfoOptimizeNone::Instance, &ParsedAttrInfoOverloadable::Instance, &ParsedAttrInfoOwner::Instance, &ParsedAttrInfoOwnership::Instance, &ParsedAttrInfoPacked::Instance, &ParsedAttrInfoParamTypestate::Instance, &ParsedAttrInfoPascal::Instance, &ParsedAttrInfoPassObjectSize::Instance, &ParsedAttrInfoPatchableFunctionEntry::Instance, &ParsedAttrInfoPcs::Instance, &ParsedAttrInfoPointer::Instance, &ParsedAttrInfoPragmaClangBSSSection::Instance, &ParsedAttrInfoPragmaClangDataSection::Instance, &ParsedAttrInfoPragmaClangRelroSection::Instance, &ParsedAttrInfoPragmaClangRodataSection::Instance, &ParsedAttrInfoPragmaClangTextSection::Instance, &ParsedAttrInfoPreferredName::Instance, &ParsedAttrInfoPreserveAll::Instance, &ParsedAttrInfoPreserveMost::Instance, &ParsedAttrInfoPtGuardedBy::Instance, &ParsedAttrInfoPtGuardedVar::Instance, &ParsedAttrInfoPtr32::Instance, &ParsedAttrInfoPtr64::Instance, &ParsedAttrInfoPure::Instance, &ParsedAttrInfoRISCVRVVVectorBits::Instance, &ParsedAttrInfoRandomizeLayout::Instance, &ParsedAttrInfoReadOnlyPlacement::Instance, &ParsedAttrInfoRegCall::Instance, &ParsedAttrInfoRegparm::Instance, &ParsedAttrInfoReinitializes::Instance, &ParsedAttrInfoReleaseCapability::Instance, &ParsedAttrInfoReleaseHandle::Instance, &ParsedAttrInfoRenderScriptKernel::Instance, &ParsedAttrInfoReqdWorkGroupSize::Instance, &ParsedAttrInfoRequiresCapability::Instance, &ParsedAttrInfoRestrict::Instance, &ParsedAttrInfoRetain::Instance, &ParsedAttrInfoReturnTypestate::Instance, &ParsedAttrInfoReturnsNonNull::Instance, &ParsedAttrInfoReturnsTwice::Instance, &ParsedAttrInfoSPtr::Instance, &ParsedAttrInfoSYCLKernel::Instance, &ParsedAttrInfoSYCLSpecialClass::Instance, &ParsedAttrInfoScopedLockable::Instance, &ParsedAttrInfoSection::Instance, &ParsedAttrInfoSelectAny::Instance, &ParsedAttrInfoSentinel::Instance, &ParsedAttrInfoSetTypestate::Instance, &ParsedAttrInfoSharedTrylockFunction::Instance, &ParsedAttrInfoSpeculativeLoadHardening::Instance, &ParsedAttrInfoStandaloneDebug::Instance, &ParsedAttrInfoStdCall::Instance, &ParsedAttrInfoStrictFP::Instance, &ParsedAttrInfoStrictGuardStackCheck::Instance, &ParsedAttrInfoSuppress::Instance, &ParsedAttrInfoSwiftAsync::Instance, &ParsedAttrInfoSwiftAsyncCall::Instance, &ParsedAttrInfoSwiftAsyncContext::Instance, &ParsedAttrInfoSwiftAsyncError::Instance, &ParsedAttrInfoSwiftAsyncName::Instance, &ParsedAttrInfoSwiftAttr::Instance, &ParsedAttrInfoSwiftBridge::Instance, &ParsedAttrInfoSwiftBridgedTypedef::Instance, &ParsedAttrInfoSwiftCall::Instance, &ParsedAttrInfoSwiftContext::Instance, &ParsedAttrInfoSwiftError::Instance, &ParsedAttrInfoSwiftErrorResult::Instance, &ParsedAttrInfoSwiftIndirectResult::Instance, &ParsedAttrInfoSwiftName::Instance, &ParsedAttrInfoSwiftNewType::Instance, &ParsedAttrInfoSwiftObjCMembers::Instance, &ParsedAttrInfoSwiftPrivate::Instance, &ParsedAttrInfoSysVABI::Instance, &ParsedAttrInfoTLSModel::Instance, &ParsedAttrInfoTarget::Instance, &ParsedAttrInfoTargetClones::Instance, &ParsedAttrInfoTargetVersion::Instance, &ParsedAttrInfoTestTypestate::Instance, &ParsedAttrInfoThisCall::Instance, &ParsedAttrInfoThread::Instance, &ParsedAttrInfoTransparentUnion::Instance, &ParsedAttrInfoTrivialABI::Instance, &ParsedAttrInfoTryAcquireCapability::Instance, &ParsedAttrInfoTypeNonNull::Instance, &ParsedAttrInfoTypeNullUnspecified::Instance, &ParsedAttrInfoTypeNullable::Instance, &ParsedAttrInfoTypeNullableResult::Instance, &ParsedAttrInfoTypeTagForDatatype::Instance, &ParsedAttrInfoTypeVisibility::Instance, &ParsedAttrInfoUPtr::Instance, &ParsedAttrInfoUnavailable::Instance, &ParsedAttrInfoUninitialized::Instance, &ParsedAttrInfoUnlikely::Instance, &ParsedAttrInfoUnsafeBufferUsage::Instance, &ParsedAttrInfoUnused::Instance, &ParsedAttrInfoUseHandle::Instance, &ParsedAttrInfoUsed::Instance, &ParsedAttrInfoUsingIfExists::Instance, &ParsedAttrInfoUuid::Instance, &ParsedAttrInfoVecReturn::Instance, &ParsedAttrInfoVecTypeHint::Instance, &ParsedAttrInfoVectorCall::Instance, &ParsedAttrInfoVectorSize::Instance, &ParsedAttrInfoVisibility::Instance, &ParsedAttrInfoWarnUnused::Instance, &ParsedAttrInfoWarnUnusedResult::Instance, &ParsedAttrInfoWeak::Instance, &ParsedAttrInfoWeakImport::Instance, &ParsedAttrInfoWeakRef::Instance, &ParsedAttrInfoWebAssemblyExportName::Instance, &ParsedAttrInfoWebAssemblyFuncref::Instance, &ParsedAttrInfoWebAssemblyImportModule::Instance, &ParsedAttrInfoWebAssemblyImportName::Instance, &ParsedAttrInfoWorkGroupSizeHint::Instance, &ParsedAttrInfoX86ForceAlignArgPointer::Instance, &ParsedAttrInfoXRayInstrument::Instance, &ParsedAttrInfoXRayLogArgs::Instance, &ParsedAttrInfoZeroCallUsedRegs::Instance, }; static void handleAttrWithDelayedArgs(Sema &S, Decl D, const ParsedAttr &Attr) { SmallVector<Expr , 4> ArgExprs; ArgExprs.reserve(Attr.getNumArgs()); for (unsigned I = 0; I < Attr.getNumArgs(); ++I) { assert(!Attr.isArgIdent(I)); ArgExprs.push_back(Attr.getArgAsExpr(I)); } clang::Attr CreatedAttr = nullptr; switch (Attr.getKind()) { default: llvm_unreachable("Attribute cannot hold delayed arguments."); case ParsedAttr::AT_Annotate: { CreatedAttr = AnnotateAttr::CreateWithDelayedArgs(S.Context, ArgExprs.data(), ArgExprs.size(), Attr); break; } case ParsedAttr::AT_AnnotateType: { CreatedAttr = AnnotateTypeAttr::CreateWithDelayedArgs(S.Context, ArgExprs.data(), ArgExprs.size(), Attr); break; } } D->addAttr(CreatedAttr); } 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_implementation: return isa<ObjCImplDecl>(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_local: return isLocalVar(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; } #elif defined(WANT_DECL_MERGE_LOGIC) static bool DiagnoseMutualExclusions(Sema &S, const NamedDecl D, const Attr A) { if (const auto Second = dyn_cast<AlwaysDestroyAttr>(A)) { if (const auto First = D->getAttr<NoDestroyAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<AlwaysInlineAttr>(A)) { if (const auto First = D->getAttr<NotTailCalledAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CFAuditedTransferAttr>(A)) { if (const auto First = D->getAttr<CFUnknownTransferAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CFUnknownTransferAttr>(A)) { if (const auto First = D->getAttr<CFAuditedTransferAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CPUDispatchAttr>(A)) { if (const auto First = D->getAttr<TargetClonesAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetVersionAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUSpecificAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CPUSpecificAttr>(A)) { if (const auto First = D->getAttr<TargetClonesAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetVersionAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUDispatchAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDAConstantAttr>(A)) { if (const auto First = D->getAttr<CUDASharedAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<HIPManagedAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDADeviceAttr>(A)) { if (const auto First = D->getAttr<CUDAGlobalAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDADeviceBuiltinSurfaceTypeAttr>(A)) { if (const auto First = D->getAttr<CUDADeviceBuiltinTextureTypeAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDADeviceBuiltinTextureTypeAttr>(A)) { if (const auto First = D->getAttr<CUDADeviceBuiltinSurfaceTypeAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDAGlobalAttr>(A)) { if (const auto First = D->getAttr<CUDADeviceAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CUDAHostAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDAHostAttr>(A)) { if (const auto First = D->getAttr<CUDAGlobalAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CUDASharedAttr>(A)) { if (const auto First = D->getAttr<CUDAConstantAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<HIPManagedAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<ColdAttr>(A)) { if (const auto First = D->getAttr<HotAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<CommonAttr>(A)) { if (const auto First = D->getAttr<InternalLinkageAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<DisableTailCallsAttr>(A)) { if (const auto First = D->getAttr<NakedAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<HIPManagedAttr>(A)) { if (const auto First = D->getAttr<CUDAConstantAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CUDASharedAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<HotAttr>(A)) { if (const auto First = D->getAttr<ColdAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<InternalLinkageAttr>(A)) { if (const auto First = D->getAttr<CommonAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<MicroMipsAttr>(A)) { if (const auto First = D->getAttr<Mips16Attr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<Mips16Attr>(A)) { if (const auto First = D->getAttr<MipsInterruptAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<MicroMipsAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<MipsLongCallAttr>(A)) { if (const auto First = D->getAttr<MipsShortCallAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<MipsShortCallAttr>(A)) { if (const auto First = D->getAttr<MipsLongCallAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<NakedAttr>(A)) { if (const auto First = D->getAttr<DisableTailCallsAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<NoDestroyAttr>(A)) { if (const auto First = D->getAttr<AlwaysDestroyAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<NoRandomizeLayoutAttr>(A)) { if (const auto First = D->getAttr<RandomizeLayoutAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<NoSpeculativeLoadHardeningAttr>(A)) { if (const auto First = D->getAttr<SpeculativeLoadHardeningAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<NotTailCalledAttr>(A)) { if (const auto First = D->getAttr<AlwaysInlineAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<OwnerAttr>(A)) { if (const auto First = D->getAttr<PointerAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<PointerAttr>(A)) { if (const auto First = D->getAttr<OwnerAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<RandomizeLayoutAttr>(A)) { if (const auto First = D->getAttr<NoRandomizeLayoutAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<SpeculativeLoadHardeningAttr>(A)) { if (const auto First = D->getAttr<NoSpeculativeLoadHardeningAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<TargetAttr>(A)) { if (const auto First = D->getAttr<TargetClonesAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetVersionAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUDispatchAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUSpecificAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<TargetClonesAttr>(A)) { if (const auto First = D->getAttr<TargetVersionAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUDispatchAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUSpecificAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } if (const auto Second = dyn_cast<TargetVersionAttr>(A)) { if (const auto First = D->getAttr<TargetClonesAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<TargetAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUDispatchAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } if (const auto First = D->getAttr<CPUSpecificAttr>()) { S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } return true; } return true; } #elif defined(WANT_STMT_MERGE_LOGIC) static bool DiagnoseMutualExclusions(Sema &S, const SmallVectorImpl<const Attr > &C) { for (const Attr A : C) { if (const auto Second = dyn_cast<AlwaysInlineAttr>(A)) { auto Iter = llvm::find_if(C, [](const Attr Check) { return isa<NotTailCalledAttr>(Check); }); if (Iter != C.end()) { S.Diag((Iter)->getLocation(), diag::err_attributes_are_not_compatible) << Iter << Second << ((Iter)->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } } if (const auto Second = dyn_cast<LikelyAttr>(A)) { auto Iter = llvm::find_if(C, [](const Attr Check) { return isa<UnlikelyAttr>(Check); }); if (Iter != C.end()) { S.Diag((Iter)->getLocation(), diag::err_attributes_are_not_compatible) << Iter << Second << ((Iter)->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } } if (const auto Second = dyn_cast<UnlikelyAttr>(A)) { auto Iter = llvm::find_if(C, [](const Attr Check) { return isa<LikelyAttr>(Check); }); if (Iter != C.end()) { S.Diag((Iter)->getLocation(), diag::err_attributes_are_not_compatible) << Iter << Second << ((*Iter)->isRegularKeywordAttribute() \|\| Second->isRegularKeywordAttribute()); S.Diag(Second->getLocation(), diag::note_conflicting_attribute); return false; } } } return true; } #endif