Back to home page

EIC code displayed by LXR
 
 

    

Warning, /include/clang/Sema/AttrParsedAttrImpl.inc is written in an unsupported language. File is not indexed. 

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Parsed attribute helpers                                                   *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009 
0010 #if !defined(WANT_DECL_MERGE_LOGIC) && !defined(WANT_STMT_MERGE_LOGIC)
0011 static bool isStruct(const Decl *D) {
0012   if (const auto *S = dyn_cast<RecordDecl>(D))
0013     return !S->isUnion();
0014   return false;
0015 }
0016 
0017 static bool isSharedVar(const Decl *D) {
0018   if (const auto *S = dyn_cast<VarDecl>(D))
0019     return S->hasGlobalStorage() && !S->getTLSKind();
0020   return false;
0021 }
0022 
0023 static bool isGlobalVar(const Decl *D) {
0024   if (const auto *S = dyn_cast<VarDecl>(D))
0025     return S->hasGlobalStorage();
0026   return false;
0027 }
0028 
0029 static bool isHasFunctionProto(const Decl *D) {
0030   if (const auto *S = dyn_cast<Decl>(D))
0031     return (S->getFunctionType(true) != nullptr &&
0032                                        isa<FunctionProtoType>(S->getFunctionType())) ||
0033                                        isa<ObjCMethodDecl>(S) ||
0034                                        isa<BlockDecl>(S);
0035   return false;
0036 }
0037 
0038 static bool isFunctionLike(const Decl *D) {
0039   if (const auto *S = dyn_cast<Decl>(D))
0040     return S->getFunctionType(false) != nullptr;
0041   return false;
0042 }
0043 
0044 static bool isInlineFunction(const Decl *D) {
0045   if (const auto *S = dyn_cast<FunctionDecl>(D))
0046     return S->isInlineSpecified();
0047   return false;
0048 }
0049 
0050 static bool isLocalVar(const Decl *D) {
0051   if (const auto *S = dyn_cast<VarDecl>(D))
0052     return S->hasLocalStorage() && !isa<ParmVarDecl>(S);
0053   return false;
0054 }
0055 
0056 static bool isNonTLSGlobalVar(const Decl *D) {
0057   if (const auto *S = dyn_cast<VarDecl>(D))
0058     return S->hasGlobalStorage() &&
0059                                S->getTLSKind() == 0;
0060   return false;
0061 }
0062 
0063 static bool isHLSLEntry(const Decl *D) {
0064   if (const auto *S = dyn_cast<FunctionDecl>(D))
0065     return S->isExternallyVisible() && !isa<CXXMethodDecl>(S);
0066   return false;
0067 }
0068 
0069 static bool isHLSLBufferObj(const Decl *D) {
0070   if (const auto *S = dyn_cast<HLSLBufferDecl>(D))
0071     return isa<HLSLBufferDecl>(S);
0072   return false;
0073 }
0074 
0075 static bool isExternalGlobalVar(const Decl *D) {
0076   if (const auto *S = dyn_cast<VarDecl>(D))
0077     return S->hasGlobalStorage() &&
0078                                S->getStorageClass()!=StorageClass::SC_Static &&
0079                                !S->isLocalExternDecl();
0080   return false;
0081 }
0082 
0083 static bool isObjCInstanceMethod(const Decl *D) {
0084   if (const auto *S = dyn_cast<ObjCMethodDecl>(D))
0085     return S->isInstanceMethod();
0086   return false;
0087 }
0088 
0089 static bool isImplicitObjectParameter(const Decl *D) {
0090   if (const auto *S = dyn_cast<FunctionDecl>(D))
0091     return static_cast<void>(S), false;
0092   return false;
0093 }
0094 
0095 static bool isNonParmVar(const Decl *D) {
0096   if (const auto *S = dyn_cast<VarDecl>(D))
0097     return S->getKind() != Decl::ParmVar;
0098   return false;
0099 }
0100 
0101 static bool isClassTmpl(const Decl *D) {
0102   if (const auto *S = dyn_cast<CXXRecordDecl>(D))
0103     return S->getDescribedClassTemplate();
0104   return false;
0105 }
0106 
0107 static bool isFunctionTmpl(const Decl *D) {
0108   if (const auto *S = dyn_cast<FunctionDecl>(D))
0109     return S->getTemplatedKind() ==
0110                                  FunctionDecl::TK_FunctionTemplate;
0111   return false;
0112 }
0113 
0114 static bool isVarTmpl(const Decl *D) {
0115   if (const auto *S = dyn_cast<VarDecl>(D))
0116     return S->getDescribedVarTemplate();
0117   return false;
0118 }
0119 
0120 static bool isNonBitField(const Decl *D) {
0121   if (const auto *S = dyn_cast<FieldDecl>(D))
0122     return !S->isBitField();
0123   return false;
0124 }
0125 
0126 static bool isNonStaticCXXMethod(const Decl *D) {
0127   if (const auto *S = dyn_cast<CXXMethodDecl>(D))
0128     return !S->isStatic();
0129   return false;
0130 }
0131 
0132 static bool isBitField(const Decl *D) {
0133   if (const auto *S = dyn_cast<FieldDecl>(D))
0134     return S->isBitField();
0135   return false;
0136 }
0137 
0138 static bool isNonStaticNonConstCXXMethod(const Decl *D) {
0139   if (const auto *S = dyn_cast<CXXMethodDecl>(D))
0140     return !S->isStatic() && !S->isConst();
0141   return false;
0142 }
0143 
0144 static bool isNonLocalVar(const Decl *D) {
0145   if (const auto *S = dyn_cast<VarDecl>(D))
0146     return !S->hasLocalStorage();
0147   return false;
0148 }
0149 
0150 static bool isTLSVar(const Decl *D) {
0151   if (const auto *S = dyn_cast<VarDecl>(D))
0152     return S->getTLSKind() != 0;
0153   return false;
0154 }
0155 
0156 static bool isFunctionPointer(const Decl *D) {
0157   if (const auto *S = dyn_cast<Decl>(D))
0158     return S->isFunctionPointerType();
0159   return false;
0160 }
0161 
0162 static constexpr ParsedAttrInfo::Spelling AArch64SVEPcsSpellings[] = {
0163   {AttributeCommonInfo::AS_GNU, "aarch64_sve_pcs"},
0164   {AttributeCommonInfo::AS_CXX11, "clang::aarch64_sve_pcs"},
0165   {AttributeCommonInfo::AS_C23, "clang::aarch64_sve_pcs"},
0166 };
0167 struct ParsedAttrInfoAArch64SVEPcs final : public ParsedAttrInfo {
0168   constexpr ParsedAttrInfoAArch64SVEPcs() : ParsedAttrInfo(
0169     /*AttrKind=*/ParsedAttr::AT_AArch64SVEPcs,
0170     /*NumArgs=*/0,
0171     /*OptArgs=*/0,
0172     /*NumArgMembers=*/0,
0173     /*HasCustomParsing=*/0,
0174     /*AcceptsExprPack=*/0,
0175     /*IsTargetSpecific=*/0,
0176     /*IsType=*/1,
0177     /*IsStmt=*/0,
0178     /*IsKnownToGCC=*/0,
0179     /*IsSupportedByPragmaAttribute=*/0,
0180     /*Spellings=*/AArch64SVEPcsSpellings,
0181     /*ArgNames=*/{}) {}
0182 bool isParamExpr(size_t N) const override {
0183   return false;
0184 }
0185 
0186 static const ParsedAttrInfoAArch64SVEPcs Instance;
0187 };
0188 const ParsedAttrInfoAArch64SVEPcs ParsedAttrInfoAArch64SVEPcs::Instance;
0189 static constexpr ParsedAttrInfo::Spelling AArch64VectorPcsSpellings[] = {
0190   {AttributeCommonInfo::AS_GNU, "aarch64_vector_pcs"},
0191   {AttributeCommonInfo::AS_CXX11, "clang::aarch64_vector_pcs"},
0192   {AttributeCommonInfo::AS_C23, "clang::aarch64_vector_pcs"},
0193 };
0194 struct ParsedAttrInfoAArch64VectorPcs final : public ParsedAttrInfo {
0195   constexpr ParsedAttrInfoAArch64VectorPcs() : ParsedAttrInfo(
0196     /*AttrKind=*/ParsedAttr::AT_AArch64VectorPcs,
0197     /*NumArgs=*/0,
0198     /*OptArgs=*/0,
0199     /*NumArgMembers=*/0,
0200     /*HasCustomParsing=*/0,
0201     /*AcceptsExprPack=*/0,
0202     /*IsTargetSpecific=*/0,
0203     /*IsType=*/1,
0204     /*IsStmt=*/0,
0205     /*IsKnownToGCC=*/0,
0206     /*IsSupportedByPragmaAttribute=*/0,
0207     /*Spellings=*/AArch64VectorPcsSpellings,
0208     /*ArgNames=*/{}) {}
0209 bool isParamExpr(size_t N) const override {
0210   return false;
0211 }
0212 
0213 static const ParsedAttrInfoAArch64VectorPcs Instance;
0214 };
0215 const ParsedAttrInfoAArch64VectorPcs ParsedAttrInfoAArch64VectorPcs::Instance;
0216 static constexpr ParsedAttrInfo::Spelling AMDGPUFlatWorkGroupSizeSpellings[] = {
0217   {AttributeCommonInfo::AS_GNU, "amdgpu_flat_work_group_size"},
0218   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_flat_work_group_size"},
0219 };
0220 static constexpr const char *AMDGPUFlatWorkGroupSizeArgNames[] = {
0221 "Min","Max",};
0222 struct ParsedAttrInfoAMDGPUFlatWorkGroupSize final : public ParsedAttrInfo {
0223   constexpr ParsedAttrInfoAMDGPUFlatWorkGroupSize() : ParsedAttrInfo(
0224     /*AttrKind=*/ParsedAttr::AT_AMDGPUFlatWorkGroupSize,
0225     /*NumArgs=*/2,
0226     /*OptArgs=*/0,
0227     /*NumArgMembers=*/2,
0228     /*HasCustomParsing=*/0,
0229     /*AcceptsExprPack=*/0,
0230     /*IsTargetSpecific=*/0,
0231     /*IsType=*/0,
0232     /*IsStmt=*/0,
0233     /*IsKnownToGCC=*/0,
0234     /*IsSupportedByPragmaAttribute=*/1,
0235     /*Spellings=*/AMDGPUFlatWorkGroupSizeSpellings,
0236     /*ArgNames=*/AMDGPUFlatWorkGroupSizeArgNames) {}
0237 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0238   if (!isa<FunctionDecl>(D)) {
0239     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0240       << Attr << Attr.isRegularKeywordAttribute() << "kernel functions";
0241     return false;
0242   }
0243   return true;
0244 }
0245 
0246 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0247   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0248     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0249   return false;
0250 }
0251 
0252 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0253   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0254 }
0255 
0256 bool isParamExpr(size_t N) const override {
0257   return (N == 0) || (N == 1) || false;
0258 }
0259 
0260 static const ParsedAttrInfoAMDGPUFlatWorkGroupSize Instance;
0261 };
0262 const ParsedAttrInfoAMDGPUFlatWorkGroupSize ParsedAttrInfoAMDGPUFlatWorkGroupSize::Instance;
0263 static constexpr ParsedAttrInfo::Spelling AMDGPUKernelCallSpellings[] = {
0264   {AttributeCommonInfo::AS_GNU, "amdgpu_kernel"},
0265   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_kernel"},
0266   {AttributeCommonInfo::AS_C23, "clang::amdgpu_kernel"},
0267 };
0268 struct ParsedAttrInfoAMDGPUKernelCall final : public ParsedAttrInfo {
0269   constexpr ParsedAttrInfoAMDGPUKernelCall() : ParsedAttrInfo(
0270     /*AttrKind=*/ParsedAttr::AT_AMDGPUKernelCall,
0271     /*NumArgs=*/0,
0272     /*OptArgs=*/0,
0273     /*NumArgMembers=*/0,
0274     /*HasCustomParsing=*/0,
0275     /*AcceptsExprPack=*/0,
0276     /*IsTargetSpecific=*/0,
0277     /*IsType=*/1,
0278     /*IsStmt=*/0,
0279     /*IsKnownToGCC=*/0,
0280     /*IsSupportedByPragmaAttribute=*/0,
0281     /*Spellings=*/AMDGPUKernelCallSpellings,
0282     /*ArgNames=*/{}) {}
0283 bool isParamExpr(size_t N) const override {
0284   return false;
0285 }
0286 
0287 static const ParsedAttrInfoAMDGPUKernelCall Instance;
0288 };
0289 const ParsedAttrInfoAMDGPUKernelCall ParsedAttrInfoAMDGPUKernelCall::Instance;
0290 static constexpr ParsedAttrInfo::Spelling AMDGPUMaxNumWorkGroupsSpellings[] = {
0291   {AttributeCommonInfo::AS_GNU, "amdgpu_max_num_work_groups"},
0292   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_max_num_work_groups"},
0293 };
0294 static constexpr const char *AMDGPUMaxNumWorkGroupsArgNames[] = {
0295 "MaxNumWorkGroupsX","MaxNumWorkGroupsY","MaxNumWorkGroupsZ",};
0296 struct ParsedAttrInfoAMDGPUMaxNumWorkGroups final : public ParsedAttrInfo {
0297   constexpr ParsedAttrInfoAMDGPUMaxNumWorkGroups() : ParsedAttrInfo(
0298     /*AttrKind=*/ParsedAttr::AT_AMDGPUMaxNumWorkGroups,
0299     /*NumArgs=*/1,
0300     /*OptArgs=*/2,
0301     /*NumArgMembers=*/3,
0302     /*HasCustomParsing=*/0,
0303     /*AcceptsExprPack=*/0,
0304     /*IsTargetSpecific=*/0,
0305     /*IsType=*/0,
0306     /*IsStmt=*/0,
0307     /*IsKnownToGCC=*/0,
0308     /*IsSupportedByPragmaAttribute=*/1,
0309     /*Spellings=*/AMDGPUMaxNumWorkGroupsSpellings,
0310     /*ArgNames=*/AMDGPUMaxNumWorkGroupsArgNames) {}
0311 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0312   if (!isa<FunctionDecl>(D)) {
0313     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0314       << Attr << Attr.isRegularKeywordAttribute() << "kernel functions";
0315     return false;
0316   }
0317   return true;
0318 }
0319 
0320 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0321   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0322     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0323   return false;
0324 }
0325 
0326 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0327   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0328 }
0329 
0330 bool isParamExpr(size_t N) const override {
0331   return (N == 0) || (N == 1) || (N == 2) || false;
0332 }
0333 
0334 static const ParsedAttrInfoAMDGPUMaxNumWorkGroups Instance;
0335 };
0336 const ParsedAttrInfoAMDGPUMaxNumWorkGroups ParsedAttrInfoAMDGPUMaxNumWorkGroups::Instance;
0337 static constexpr ParsedAttrInfo::Spelling AMDGPUNumSGPRSpellings[] = {
0338   {AttributeCommonInfo::AS_GNU, "amdgpu_num_sgpr"},
0339   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_num_sgpr"},
0340 };
0341 static constexpr const char *AMDGPUNumSGPRArgNames[] = {
0342 "NumSGPR",};
0343 struct ParsedAttrInfoAMDGPUNumSGPR final : public ParsedAttrInfo {
0344   constexpr ParsedAttrInfoAMDGPUNumSGPR() : ParsedAttrInfo(
0345     /*AttrKind=*/ParsedAttr::AT_AMDGPUNumSGPR,
0346     /*NumArgs=*/1,
0347     /*OptArgs=*/0,
0348     /*NumArgMembers=*/1,
0349     /*HasCustomParsing=*/0,
0350     /*AcceptsExprPack=*/0,
0351     /*IsTargetSpecific=*/0,
0352     /*IsType=*/0,
0353     /*IsStmt=*/0,
0354     /*IsKnownToGCC=*/0,
0355     /*IsSupportedByPragmaAttribute=*/1,
0356     /*Spellings=*/AMDGPUNumSGPRSpellings,
0357     /*ArgNames=*/AMDGPUNumSGPRArgNames) {}
0358 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0359   if (!isa<FunctionDecl>(D)) {
0360     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0361       << Attr << Attr.isRegularKeywordAttribute() << "kernel functions";
0362     return false;
0363   }
0364   return true;
0365 }
0366 
0367 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0368   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0369     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0370   return false;
0371 }
0372 
0373 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0374   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0375 }
0376 
0377 bool isParamExpr(size_t N) const override {
0378   return false;
0379 }
0380 
0381 static const ParsedAttrInfoAMDGPUNumSGPR Instance;
0382 };
0383 const ParsedAttrInfoAMDGPUNumSGPR ParsedAttrInfoAMDGPUNumSGPR::Instance;
0384 static constexpr ParsedAttrInfo::Spelling AMDGPUNumVGPRSpellings[] = {
0385   {AttributeCommonInfo::AS_GNU, "amdgpu_num_vgpr"},
0386   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_num_vgpr"},
0387 };
0388 static constexpr const char *AMDGPUNumVGPRArgNames[] = {
0389 "NumVGPR",};
0390 struct ParsedAttrInfoAMDGPUNumVGPR final : public ParsedAttrInfo {
0391   constexpr ParsedAttrInfoAMDGPUNumVGPR() : ParsedAttrInfo(
0392     /*AttrKind=*/ParsedAttr::AT_AMDGPUNumVGPR,
0393     /*NumArgs=*/1,
0394     /*OptArgs=*/0,
0395     /*NumArgMembers=*/1,
0396     /*HasCustomParsing=*/0,
0397     /*AcceptsExprPack=*/0,
0398     /*IsTargetSpecific=*/0,
0399     /*IsType=*/0,
0400     /*IsStmt=*/0,
0401     /*IsKnownToGCC=*/0,
0402     /*IsSupportedByPragmaAttribute=*/1,
0403     /*Spellings=*/AMDGPUNumVGPRSpellings,
0404     /*ArgNames=*/AMDGPUNumVGPRArgNames) {}
0405 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0406   if (!isa<FunctionDecl>(D)) {
0407     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0408       << Attr << Attr.isRegularKeywordAttribute() << "kernel functions";
0409     return false;
0410   }
0411   return true;
0412 }
0413 
0414 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0415   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0416     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0417   return false;
0418 }
0419 
0420 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0421   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0422 }
0423 
0424 bool isParamExpr(size_t N) const override {
0425   return false;
0426 }
0427 
0428 static const ParsedAttrInfoAMDGPUNumVGPR Instance;
0429 };
0430 const ParsedAttrInfoAMDGPUNumVGPR ParsedAttrInfoAMDGPUNumVGPR::Instance;
0431 static constexpr ParsedAttrInfo::Spelling AMDGPUWavesPerEUSpellings[] = {
0432   {AttributeCommonInfo::AS_GNU, "amdgpu_waves_per_eu"},
0433   {AttributeCommonInfo::AS_CXX11, "clang::amdgpu_waves_per_eu"},
0434 };
0435 static constexpr const char *AMDGPUWavesPerEUArgNames[] = {
0436 "Min","Max",};
0437 struct ParsedAttrInfoAMDGPUWavesPerEU final : public ParsedAttrInfo {
0438   constexpr ParsedAttrInfoAMDGPUWavesPerEU() : ParsedAttrInfo(
0439     /*AttrKind=*/ParsedAttr::AT_AMDGPUWavesPerEU,
0440     /*NumArgs=*/1,
0441     /*OptArgs=*/1,
0442     /*NumArgMembers=*/2,
0443     /*HasCustomParsing=*/0,
0444     /*AcceptsExprPack=*/0,
0445     /*IsTargetSpecific=*/0,
0446     /*IsType=*/0,
0447     /*IsStmt=*/0,
0448     /*IsKnownToGCC=*/0,
0449     /*IsSupportedByPragmaAttribute=*/1,
0450     /*Spellings=*/AMDGPUWavesPerEUSpellings,
0451     /*ArgNames=*/AMDGPUWavesPerEUArgNames) {}
0452 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0453   if (!isa<FunctionDecl>(D)) {
0454     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0455       << Attr << Attr.isRegularKeywordAttribute() << "kernel functions";
0456     return false;
0457   }
0458   return true;
0459 }
0460 
0461 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0462   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0463     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0464   return false;
0465 }
0466 
0467 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0468   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0469 }
0470 
0471 bool isParamExpr(size_t N) const override {
0472   return (N == 0) || (N == 1) || false;
0473 }
0474 
0475 static const ParsedAttrInfoAMDGPUWavesPerEU Instance;
0476 };
0477 const ParsedAttrInfoAMDGPUWavesPerEU ParsedAttrInfoAMDGPUWavesPerEU::Instance;
0478 static constexpr ParsedAttrInfo::Spelling InterruptSpellings[] = {
0479   {AttributeCommonInfo::AS_GNU, "interrupt"},
0480   {AttributeCommonInfo::AS_CXX11, "gnu::interrupt"},
0481   {AttributeCommonInfo::AS_C23, "gnu::interrupt"},
0482 };
0483 static constexpr const char *InterruptArgNames[] = {
0484 "Interrupt",};
0485 struct ParsedAttrInfoInterrupt final : public ParsedAttrInfo {
0486   constexpr ParsedAttrInfoInterrupt() : ParsedAttrInfo(
0487     /*AttrKind=*/ParsedAttr::AT_Interrupt,
0488     /*NumArgs=*/0,
0489     /*OptArgs=*/1,
0490     /*NumArgMembers=*/1,
0491     /*HasCustomParsing=*/1,
0492     /*AcceptsExprPack=*/0,
0493     /*IsTargetSpecific=*/1,
0494     /*IsType=*/0,
0495     /*IsStmt=*/0,
0496     /*IsKnownToGCC=*/1,
0497     /*IsSupportedByPragmaAttribute=*/0,
0498     /*Spellings=*/InterruptSpellings,
0499     /*ArgNames=*/InterruptArgNames) {}
0500 bool existsInTarget(const TargetInfo &Target) const override {
0501   const llvm::Triple &T = Target.getTriple(); (void)T;
0502   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);
0503 }
0504 
0505 bool isParamExpr(size_t N) const override {
0506   return false;
0507 }
0508 
0509 static const ParsedAttrInfoInterrupt Instance;
0510 };
0511 const ParsedAttrInfoInterrupt ParsedAttrInfoInterrupt::Instance;
0512 static constexpr ParsedAttrInfo::Spelling AVRSignalSpellings[] = {
0513   {AttributeCommonInfo::AS_GNU, "signal"},
0514   {AttributeCommonInfo::AS_CXX11, "gnu::signal"},
0515   {AttributeCommonInfo::AS_C23, "gnu::signal"},
0516 };
0517 struct ParsedAttrInfoAVRSignal final : public ParsedAttrInfo {
0518   constexpr ParsedAttrInfoAVRSignal() : ParsedAttrInfo(
0519     /*AttrKind=*/ParsedAttr::AT_AVRSignal,
0520     /*NumArgs=*/0,
0521     /*OptArgs=*/0,
0522     /*NumArgMembers=*/0,
0523     /*HasCustomParsing=*/0,
0524     /*AcceptsExprPack=*/0,
0525     /*IsTargetSpecific=*/1,
0526     /*IsType=*/0,
0527     /*IsStmt=*/0,
0528     /*IsKnownToGCC=*/1,
0529     /*IsSupportedByPragmaAttribute=*/1,
0530     /*Spellings=*/AVRSignalSpellings,
0531     /*ArgNames=*/{}) {}
0532 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0533   if (!isa<FunctionDecl>(D)) {
0534     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0535       << Attr << Attr.isRegularKeywordAttribute() << "functions";
0536     return false;
0537   }
0538   return true;
0539 }
0540 
0541 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0542   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0543     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0544   return false;
0545 }
0546 
0547 bool existsInTarget(const TargetInfo &Target) const override {
0548   const llvm::Triple &T = Target.getTriple(); (void)T;
0549   return true && (T.getArch() == llvm::Triple::avr);
0550 }
0551 
0552 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0553   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0554 }
0555 
0556 bool isParamExpr(size_t N) const override {
0557   return false;
0558 }
0559 
0560 static const ParsedAttrInfoAVRSignal Instance;
0561 };
0562 const ParsedAttrInfoAVRSignal ParsedAttrInfoAVRSignal::Instance;
0563 static constexpr ParsedAttrInfo::Spelling AbiTagSpellings[] = {
0564   {AttributeCommonInfo::AS_GNU, "abi_tag"},
0565   {AttributeCommonInfo::AS_CXX11, "gnu::abi_tag"},
0566 };
0567 static constexpr const char *AbiTagArgNames[] = {
0568 "Tags...",};
0569 struct ParsedAttrInfoAbiTag final : public ParsedAttrInfo {
0570   constexpr ParsedAttrInfoAbiTag() : ParsedAttrInfo(
0571     /*AttrKind=*/ParsedAttr::AT_AbiTag,
0572     /*NumArgs=*/0,
0573     /*OptArgs=*/15,
0574     /*NumArgMembers=*/1,
0575     /*HasCustomParsing=*/0,
0576     /*AcceptsExprPack=*/0,
0577     /*IsTargetSpecific=*/0,
0578     /*IsType=*/0,
0579     /*IsStmt=*/0,
0580     /*IsKnownToGCC=*/1,
0581     /*IsSupportedByPragmaAttribute=*/1,
0582     /*Spellings=*/AbiTagSpellings,
0583     /*ArgNames=*/AbiTagArgNames) {}
0584 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0585   if (!isStruct(D) && !isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<NamespaceDecl>(D)) {
0586     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0587       << Attr << Attr.isRegularKeywordAttribute() << "structs, variables, functions, and namespaces";
0588     return false;
0589   }
0590   return true;
0591 }
0592 
0593 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0594   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0595     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0596   return false;
0597 }
0598 
0599 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0600   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /*IsSupported=*/true));
0601   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
0602   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0603   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
0604 }
0605 
0606 bool isParamExpr(size_t N) const override {
0607   return false;
0608 }
0609 
0610 static const ParsedAttrInfoAbiTag Instance;
0611 };
0612 const ParsedAttrInfoAbiTag ParsedAttrInfoAbiTag::Instance;
0613 static constexpr ParsedAttrInfo::Spelling AcquireCapabilitySpellings[] = {
0614   {AttributeCommonInfo::AS_GNU, "acquire_capability"},
0615   {AttributeCommonInfo::AS_CXX11, "clang::acquire_capability"},
0616   {AttributeCommonInfo::AS_GNU, "acquire_shared_capability"},
0617   {AttributeCommonInfo::AS_CXX11, "clang::acquire_shared_capability"},
0618   {AttributeCommonInfo::AS_GNU, "exclusive_lock_function"},
0619   {AttributeCommonInfo::AS_GNU, "shared_lock_function"},
0620 };
0621 static constexpr const char *AcquireCapabilityArgNames[] = {
0622 "Args...",};
0623 struct ParsedAttrInfoAcquireCapability final : public ParsedAttrInfo {
0624   constexpr ParsedAttrInfoAcquireCapability() : ParsedAttrInfo(
0625     /*AttrKind=*/ParsedAttr::AT_AcquireCapability,
0626     /*NumArgs=*/0,
0627     /*OptArgs=*/15,
0628     /*NumArgMembers=*/1,
0629     /*HasCustomParsing=*/0,
0630     /*AcceptsExprPack=*/0,
0631     /*IsTargetSpecific=*/0,
0632     /*IsType=*/0,
0633     /*IsStmt=*/0,
0634     /*IsKnownToGCC=*/0,
0635     /*IsSupportedByPragmaAttribute=*/0,
0636     /*Spellings=*/AcquireCapabilitySpellings,
0637     /*ArgNames=*/AcquireCapabilityArgNames) {}
0638 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0639   if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) {
0640     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0641       << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters";
0642     return false;
0643   }
0644   return true;
0645 }
0646 
0647 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0648   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0649     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0650   return false;
0651 }
0652 
0653 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
0654   enum Spelling {
0655     GNU_acquire_capability = 0,
0656     CXX11_clang_acquire_capability = 1,
0657     GNU_acquire_shared_capability = 2,
0658     CXX11_clang_acquire_shared_capability = 3,
0659     GNU_exclusive_lock_function = 4,
0660     GNU_shared_lock_function = 5,
0661   SpellingNotCalculated = 15
0662 
0663   };
0664 
0665   unsigned Idx = Attr.getAttributeSpellingListIndex();
0666   switch (Idx) {
0667     default: llvm_unreachable("Unknown spelling list index");
0668     case 0: return GNU_acquire_capability;
0669     case 1: return CXX11_clang_acquire_capability;
0670     case 2: return GNU_acquire_shared_capability;
0671     case 3: return CXX11_clang_acquire_shared_capability;
0672     case 4: return GNU_exclusive_lock_function;
0673     case 5: return GNU_shared_lock_function;
0674   }
0675 }
0676 
0677 bool isParamExpr(size_t N) const override {
0678   return (N == 0) || false;
0679 }
0680 
0681 static const ParsedAttrInfoAcquireCapability Instance;
0682 };
0683 const ParsedAttrInfoAcquireCapability ParsedAttrInfoAcquireCapability::Instance;
0684 static constexpr ParsedAttrInfo::Spelling AcquireHandleSpellings[] = {
0685   {AttributeCommonInfo::AS_GNU, "acquire_handle"},
0686   {AttributeCommonInfo::AS_CXX11, "clang::acquire_handle"},
0687   {AttributeCommonInfo::AS_C23, "clang::acquire_handle"},
0688 };
0689 static constexpr const char *AcquireHandleArgNames[] = {
0690 "HandleType",};
0691 struct ParsedAttrInfoAcquireHandle final : public ParsedAttrInfo {
0692   constexpr ParsedAttrInfoAcquireHandle() : ParsedAttrInfo(
0693     /*AttrKind=*/ParsedAttr::AT_AcquireHandle,
0694     /*NumArgs=*/1,
0695     /*OptArgs=*/0,
0696     /*NumArgMembers=*/1,
0697     /*HasCustomParsing=*/0,
0698     /*AcceptsExprPack=*/0,
0699     /*IsTargetSpecific=*/0,
0700     /*IsType=*/1,
0701     /*IsStmt=*/0,
0702     /*IsKnownToGCC=*/0,
0703     /*IsSupportedByPragmaAttribute=*/1,
0704     /*Spellings=*/AcquireHandleSpellings,
0705     /*ArgNames=*/AcquireHandleArgNames) {}
0706 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0707   if (!isa<FunctionDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<ParmVarDecl>(D)) {
0708     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0709       << Attr << Attr.isRegularKeywordAttribute() << "functions, typedefs, and parameters";
0710     return false;
0711   }
0712   return true;
0713 }
0714 
0715 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0716   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0717     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0718   return false;
0719 }
0720 
0721 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0722   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0723   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
0724   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
0725 }
0726 
0727 bool isParamExpr(size_t N) const override {
0728   return false;
0729 }
0730 
0731 static const ParsedAttrInfoAcquireHandle Instance;
0732 };
0733 const ParsedAttrInfoAcquireHandle ParsedAttrInfoAcquireHandle::Instance;
0734 static constexpr ParsedAttrInfo::Spelling AcquiredAfterSpellings[] = {
0735   {AttributeCommonInfo::AS_GNU, "acquired_after"},
0736 };
0737 static constexpr const char *AcquiredAfterArgNames[] = {
0738 "Args...",};
0739 struct ParsedAttrInfoAcquiredAfter final : public ParsedAttrInfo {
0740   constexpr ParsedAttrInfoAcquiredAfter() : ParsedAttrInfo(
0741     /*AttrKind=*/ParsedAttr::AT_AcquiredAfter,
0742     /*NumArgs=*/0,
0743     /*OptArgs=*/15,
0744     /*NumArgMembers=*/1,
0745     /*HasCustomParsing=*/0,
0746     /*AcceptsExprPack=*/0,
0747     /*IsTargetSpecific=*/0,
0748     /*IsType=*/0,
0749     /*IsStmt=*/0,
0750     /*IsKnownToGCC=*/0,
0751     /*IsSupportedByPragmaAttribute=*/0,
0752     /*Spellings=*/AcquiredAfterSpellings,
0753     /*ArgNames=*/AcquiredAfterArgNames) {}
0754 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0755   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
0756     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0757       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
0758     return false;
0759   }
0760   return true;
0761 }
0762 
0763 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0764   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0765     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0766   return false;
0767 }
0768 
0769 bool isParamExpr(size_t N) const override {
0770   return (N == 0) || false;
0771 }
0772 
0773 static const ParsedAttrInfoAcquiredAfter Instance;
0774 };
0775 const ParsedAttrInfoAcquiredAfter ParsedAttrInfoAcquiredAfter::Instance;
0776 static constexpr ParsedAttrInfo::Spelling AcquiredBeforeSpellings[] = {
0777   {AttributeCommonInfo::AS_GNU, "acquired_before"},
0778 };
0779 static constexpr const char *AcquiredBeforeArgNames[] = {
0780 "Args...",};
0781 struct ParsedAttrInfoAcquiredBefore final : public ParsedAttrInfo {
0782   constexpr ParsedAttrInfoAcquiredBefore() : ParsedAttrInfo(
0783     /*AttrKind=*/ParsedAttr::AT_AcquiredBefore,
0784     /*NumArgs=*/0,
0785     /*OptArgs=*/15,
0786     /*NumArgMembers=*/1,
0787     /*HasCustomParsing=*/0,
0788     /*AcceptsExprPack=*/0,
0789     /*IsTargetSpecific=*/0,
0790     /*IsType=*/0,
0791     /*IsStmt=*/0,
0792     /*IsKnownToGCC=*/0,
0793     /*IsSupportedByPragmaAttribute=*/0,
0794     /*Spellings=*/AcquiredBeforeSpellings,
0795     /*ArgNames=*/AcquiredBeforeArgNames) {}
0796 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0797   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
0798     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0799       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
0800     return false;
0801   }
0802   return true;
0803 }
0804 
0805 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0806   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0807     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0808   return false;
0809 }
0810 
0811 bool isParamExpr(size_t N) const override {
0812   return (N == 0) || false;
0813 }
0814 
0815 static const ParsedAttrInfoAcquiredBefore Instance;
0816 };
0817 const ParsedAttrInfoAcquiredBefore ParsedAttrInfoAcquiredBefore::Instance;
0818 static constexpr ParsedAttrInfo::Spelling AddressSpaceSpellings[] = {
0819   {AttributeCommonInfo::AS_GNU, "address_space"},
0820   {AttributeCommonInfo::AS_CXX11, "clang::address_space"},
0821   {AttributeCommonInfo::AS_C23, "clang::address_space"},
0822 };
0823 static constexpr const char *AddressSpaceArgNames[] = {
0824 "AddressSpace",};
0825 struct ParsedAttrInfoAddressSpace final : public ParsedAttrInfo {
0826   constexpr ParsedAttrInfoAddressSpace() : ParsedAttrInfo(
0827     /*AttrKind=*/ParsedAttr::AT_AddressSpace,
0828     /*NumArgs=*/1,
0829     /*OptArgs=*/0,
0830     /*NumArgMembers=*/1,
0831     /*HasCustomParsing=*/0,
0832     /*AcceptsExprPack=*/0,
0833     /*IsTargetSpecific=*/0,
0834     /*IsType=*/1,
0835     /*IsStmt=*/0,
0836     /*IsKnownToGCC=*/0,
0837     /*IsSupportedByPragmaAttribute=*/0,
0838     /*Spellings=*/AddressSpaceSpellings,
0839     /*ArgNames=*/AddressSpaceArgNames) {}
0840 bool isParamExpr(size_t N) const override {
0841   return false;
0842 }
0843 
0844 static const ParsedAttrInfoAddressSpace Instance;
0845 };
0846 const ParsedAttrInfoAddressSpace ParsedAttrInfoAddressSpace::Instance;
0847 static constexpr ParsedAttrInfo::Spelling AliasSpellings[] = {
0848   {AttributeCommonInfo::AS_GNU, "alias"},
0849   {AttributeCommonInfo::AS_CXX11, "gnu::alias"},
0850   {AttributeCommonInfo::AS_C23, "gnu::alias"},
0851 };
0852 static constexpr const char *AliasArgNames[] = {
0853 "Aliasee",};
0854 struct ParsedAttrInfoAlias final : public ParsedAttrInfo {
0855   constexpr ParsedAttrInfoAlias() : ParsedAttrInfo(
0856     /*AttrKind=*/ParsedAttr::AT_Alias,
0857     /*NumArgs=*/1,
0858     /*OptArgs=*/0,
0859     /*NumArgMembers=*/1,
0860     /*HasCustomParsing=*/0,
0861     /*AcceptsExprPack=*/0,
0862     /*IsTargetSpecific=*/0,
0863     /*IsType=*/0,
0864     /*IsStmt=*/0,
0865     /*IsKnownToGCC=*/1,
0866     /*IsSupportedByPragmaAttribute=*/1,
0867     /*Spellings=*/AliasSpellings,
0868     /*ArgNames=*/AliasArgNames) {}
0869 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0870   if (!isa<FunctionDecl>(D) && !isGlobalVar(D)) {
0871     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
0872       << Attr << Attr.isRegularKeywordAttribute() << "functions and global variables";
0873     return false;
0874   }
0875   return true;
0876 }
0877 
0878 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0879   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0880     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0881   return false;
0882 }
0883 
0884 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0885   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
0886   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
0887 }
0888 
0889 bool isParamExpr(size_t N) const override {
0890   return false;
0891 }
0892 
0893 static const ParsedAttrInfoAlias Instance;
0894 };
0895 const ParsedAttrInfoAlias ParsedAttrInfoAlias::Instance;
0896 static constexpr ParsedAttrInfo::Spelling AlignValueSpellings[] = {
0897   {AttributeCommonInfo::AS_GNU, "align_value"},
0898 };
0899 static constexpr const char *AlignValueArgNames[] = {
0900 "Alignment",};
0901 struct ParsedAttrInfoAlignValue final : public ParsedAttrInfo {
0902   constexpr ParsedAttrInfoAlignValue() : ParsedAttrInfo(
0903     /*AttrKind=*/ParsedAttr::AT_AlignValue,
0904     /*NumArgs=*/1,
0905     /*OptArgs=*/0,
0906     /*NumArgMembers=*/1,
0907     /*HasCustomParsing=*/0,
0908     /*AcceptsExprPack=*/0,
0909     /*IsTargetSpecific=*/0,
0910     /*IsType=*/0,
0911     /*IsStmt=*/0,
0912     /*IsKnownToGCC=*/0,
0913     /*IsSupportedByPragmaAttribute=*/1,
0914     /*Spellings=*/AlignValueSpellings,
0915     /*ArgNames=*/AlignValueArgNames) {}
0916 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
0917   if (!isa<VarDecl>(D) && !isa<TypedefNameDecl>(D)) {
0918     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
0919       << Attr << Attr.isRegularKeywordAttribute() << "variables and typedefs";
0920     return false;
0921   }
0922   return true;
0923 }
0924 
0925 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
0926   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
0927     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
0928   return false;
0929 }
0930 
0931 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
0932   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
0933   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
0934 }
0935 
0936 bool isParamExpr(size_t N) const override {
0937   return (N == 0) || false;
0938 }
0939 
0940 static const ParsedAttrInfoAlignValue Instance;
0941 };
0942 const ParsedAttrInfoAlignValue ParsedAttrInfoAlignValue::Instance;
0943 static constexpr ParsedAttrInfo::Spelling AlignedSpellings[] = {
0944   {AttributeCommonInfo::AS_GNU, "aligned"},
0945   {AttributeCommonInfo::AS_CXX11, "gnu::aligned"},
0946   {AttributeCommonInfo::AS_C23, "gnu::aligned"},
0947   {AttributeCommonInfo::AS_Declspec, "align"},
0948   {AttributeCommonInfo::AS_Keyword, "alignas"},
0949   {AttributeCommonInfo::AS_Keyword, "_Alignas"},
0950 };
0951 static constexpr const char *AlignedArgNames[] = {
0952 "Alignment",};
0953 struct ParsedAttrInfoAligned final : public ParsedAttrInfo {
0954   constexpr ParsedAttrInfoAligned() : ParsedAttrInfo(
0955     /*AttrKind=*/ParsedAttr::AT_Aligned,
0956     /*NumArgs=*/0,
0957     /*OptArgs=*/1,
0958     /*NumArgMembers=*/1,
0959     /*HasCustomParsing=*/0,
0960     /*AcceptsExprPack=*/0,
0961     /*IsTargetSpecific=*/0,
0962     /*IsType=*/0,
0963     /*IsStmt=*/0,
0964     /*IsKnownToGCC=*/1,
0965     /*IsSupportedByPragmaAttribute=*/0,
0966     /*Spellings=*/AlignedSpellings,
0967     /*ArgNames=*/AlignedArgNames) {}
0968 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
0969   enum Spelling {
0970     GNU_aligned = 0,
0971     CXX11_gnu_aligned = 1,
0972     C23_gnu_aligned = 2,
0973     Declspec_align = 3,
0974     Keyword_alignas = 4,
0975     Keyword_Alignas = 5,
0976   SpellingNotCalculated = 15
0977 
0978   };
0979 
0980   unsigned Idx = Attr.getAttributeSpellingListIndex();
0981   switch (Idx) {
0982     default: llvm_unreachable("Unknown spelling list index");
0983     case 0: return GNU_aligned;
0984     case 1: return CXX11_gnu_aligned;
0985     case 2: return C23_gnu_aligned;
0986     case 3: return Declspec_align;
0987     case 4: return Keyword_alignas;
0988     case 5: return Keyword_Alignas;
0989   }
0990 }
0991 
0992 bool isParamExpr(size_t N) const override {
0993   return false;
0994 }
0995 
0996 static const ParsedAttrInfoAligned Instance;
0997 };
0998 const ParsedAttrInfoAligned ParsedAttrInfoAligned::Instance;
0999 static constexpr ParsedAttrInfo::Spelling AllocAlignSpellings[] = {
1000   {AttributeCommonInfo::AS_GNU, "alloc_align"},
1001   {AttributeCommonInfo::AS_CXX11, "gnu::alloc_align"},
1002   {AttributeCommonInfo::AS_C23, "gnu::alloc_align"},
1003 };
1004 static constexpr const char *AllocAlignArgNames[] = {
1005 "ParamIndex",};
1006 struct ParsedAttrInfoAllocAlign final : public ParsedAttrInfo {
1007   constexpr ParsedAttrInfoAllocAlign() : ParsedAttrInfo(
1008     /*AttrKind=*/ParsedAttr::AT_AllocAlign,
1009     /*NumArgs=*/1,
1010     /*OptArgs=*/0,
1011     /*NumArgMembers=*/1,
1012     /*HasCustomParsing=*/0,
1013     /*AcceptsExprPack=*/0,
1014     /*IsTargetSpecific=*/0,
1015     /*IsType=*/0,
1016     /*IsStmt=*/0,
1017     /*IsKnownToGCC=*/1,
1018     /*IsSupportedByPragmaAttribute=*/0,
1019     /*Spellings=*/AllocAlignSpellings,
1020     /*ArgNames=*/AllocAlignArgNames) {}
1021 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1022   if (!isHasFunctionProto(D)) {
1023     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1024       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1025     return false;
1026   }
1027   return true;
1028 }
1029 
1030 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1031   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1032     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1033   return false;
1034 }
1035 
1036 bool isParamExpr(size_t N) const override {
1037   return false;
1038 }
1039 
1040 static const ParsedAttrInfoAllocAlign Instance;
1041 };
1042 const ParsedAttrInfoAllocAlign ParsedAttrInfoAllocAlign::Instance;
1043 static constexpr ParsedAttrInfo::Spelling AllocSizeSpellings[] = {
1044   {AttributeCommonInfo::AS_GNU, "alloc_size"},
1045   {AttributeCommonInfo::AS_CXX11, "gnu::alloc_size"},
1046   {AttributeCommonInfo::AS_C23, "gnu::alloc_size"},
1047 };
1048 static constexpr const char *AllocSizeArgNames[] = {
1049 "ElemSizeParam","NumElemsParam",};
1050 struct ParsedAttrInfoAllocSize final : public ParsedAttrInfo {
1051   constexpr ParsedAttrInfoAllocSize() : ParsedAttrInfo(
1052     /*AttrKind=*/ParsedAttr::AT_AllocSize,
1053     /*NumArgs=*/1,
1054     /*OptArgs=*/1,
1055     /*NumArgMembers=*/2,
1056     /*HasCustomParsing=*/0,
1057     /*AcceptsExprPack=*/0,
1058     /*IsTargetSpecific=*/0,
1059     /*IsType=*/0,
1060     /*IsStmt=*/0,
1061     /*IsKnownToGCC=*/1,
1062     /*IsSupportedByPragmaAttribute=*/0,
1063     /*Spellings=*/AllocSizeSpellings,
1064     /*ArgNames=*/AllocSizeArgNames) {}
1065 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1066   if (!isHasFunctionProto(D)) {
1067     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1068       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1069     return false;
1070   }
1071   return true;
1072 }
1073 
1074 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1075   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1076     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1077   return false;
1078 }
1079 
1080 bool isParamExpr(size_t N) const override {
1081   return false;
1082 }
1083 
1084 static const ParsedAttrInfoAllocSize Instance;
1085 };
1086 const ParsedAttrInfoAllocSize ParsedAttrInfoAllocSize::Instance;
1087 static constexpr ParsedAttrInfo::Spelling AllocatingSpellings[] = {
1088   {AttributeCommonInfo::AS_GNU, "allocating"},
1089   {AttributeCommonInfo::AS_CXX11, "clang::allocating"},
1090   {AttributeCommonInfo::AS_C23, "clang::allocating"},
1091 };
1092 struct ParsedAttrInfoAllocating final : public ParsedAttrInfo {
1093   constexpr ParsedAttrInfoAllocating() : ParsedAttrInfo(
1094     /*AttrKind=*/ParsedAttr::AT_Allocating,
1095     /*NumArgs=*/0,
1096     /*OptArgs=*/0,
1097     /*NumArgMembers=*/0,
1098     /*HasCustomParsing=*/0,
1099     /*AcceptsExprPack=*/0,
1100     /*IsTargetSpecific=*/0,
1101     /*IsType=*/1,
1102     /*IsStmt=*/0,
1103     /*IsKnownToGCC=*/0,
1104     /*IsSupportedByPragmaAttribute=*/0,
1105     /*Spellings=*/AllocatingSpellings,
1106     /*ArgNames=*/{}) {}
1107 bool isParamExpr(size_t N) const override {
1108   return false;
1109 }
1110 
1111 static const ParsedAttrInfoAllocating Instance;
1112 };
1113 const ParsedAttrInfoAllocating ParsedAttrInfoAllocating::Instance;
1114 static constexpr ParsedAttrInfo::Spelling AlwaysDestroySpellings[] = {
1115   {AttributeCommonInfo::AS_GNU, "always_destroy"},
1116   {AttributeCommonInfo::AS_CXX11, "clang::always_destroy"},
1117 };
1118 struct ParsedAttrInfoAlwaysDestroy final : public ParsedAttrInfo {
1119   constexpr ParsedAttrInfoAlwaysDestroy() : ParsedAttrInfo(
1120     /*AttrKind=*/ParsedAttr::AT_AlwaysDestroy,
1121     /*NumArgs=*/0,
1122     /*OptArgs=*/0,
1123     /*NumArgMembers=*/0,
1124     /*HasCustomParsing=*/0,
1125     /*AcceptsExprPack=*/0,
1126     /*IsTargetSpecific=*/0,
1127     /*IsType=*/0,
1128     /*IsStmt=*/0,
1129     /*IsKnownToGCC=*/0,
1130     /*IsSupportedByPragmaAttribute=*/1,
1131     /*Spellings=*/AlwaysDestroySpellings,
1132     /*ArgNames=*/{}) {}
1133 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1134   if (!isa<VarDecl>(D)) {
1135     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1136       << Attr << Attr.isRegularKeywordAttribute() << "variables";
1137     return false;
1138   }
1139   return true;
1140 }
1141 
1142 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1143   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1144     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1145   return false;
1146 }
1147 
1148   using ParsedAttrInfo::diagMutualExclusion;
1149 
1150   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
1151     if (const auto *A = D->getAttr<NoDestroyAttr>()) {
1152       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
1153       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
1154 return false;
1155     }
1156     return true;
1157   }
1158 
1159 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
1160   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
1161 }
1162 
1163 bool isParamExpr(size_t N) const override {
1164   return false;
1165 }
1166 
1167 static const ParsedAttrInfoAlwaysDestroy Instance;
1168 };
1169 const ParsedAttrInfoAlwaysDestroy ParsedAttrInfoAlwaysDestroy::Instance;
1170 static constexpr ParsedAttrInfo::Spelling AlwaysInlineSpellings[] = {
1171   {AttributeCommonInfo::AS_GNU, "always_inline"},
1172   {AttributeCommonInfo::AS_CXX11, "gnu::always_inline"},
1173   {AttributeCommonInfo::AS_C23, "gnu::always_inline"},
1174   {AttributeCommonInfo::AS_CXX11, "clang::always_inline"},
1175   {AttributeCommonInfo::AS_C23, "clang::always_inline"},
1176   {AttributeCommonInfo::AS_Keyword, "__forceinline"},
1177 };
1178 struct ParsedAttrInfoAlwaysInline final : public ParsedAttrInfo {
1179   constexpr ParsedAttrInfoAlwaysInline() : ParsedAttrInfo(
1180     /*AttrKind=*/ParsedAttr::AT_AlwaysInline,
1181     /*NumArgs=*/0,
1182     /*OptArgs=*/0,
1183     /*NumArgMembers=*/0,
1184     /*HasCustomParsing=*/0,
1185     /*AcceptsExprPack=*/0,
1186     /*IsTargetSpecific=*/0,
1187     /*IsType=*/0,
1188     /*IsStmt=*/1,
1189     /*IsKnownToGCC=*/1,
1190     /*IsSupportedByPragmaAttribute=*/1,
1191     /*Spellings=*/AlwaysInlineSpellings,
1192     /*ArgNames=*/{}) {}
1193 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1194   if (!isa<FunctionDecl>(D)) {
1195     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1196       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
1197     return false;
1198   }
1199   return true;
1200 }
1201 
1202 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
1203   if (!isa<Stmt>(St)) {
1204     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1205       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
1206     return false;
1207   }
1208   return true;
1209 }
1210 
1211   using ParsedAttrInfo::diagMutualExclusion;
1212 
1213   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
1214     if (const auto *A = D->getAttr<NotTailCalledAttr>()) {
1215       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
1216       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
1217 return false;
1218     }
1219     return true;
1220   }
1221 
1222 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
1223   enum Spelling {
1224     GNU_always_inline = 0,
1225     CXX11_gnu_always_inline = 1,
1226     C23_gnu_always_inline = 2,
1227     CXX11_clang_always_inline = 3,
1228     C23_clang_always_inline = 4,
1229     Keyword_forceinline = 5,
1230   SpellingNotCalculated = 15
1231 
1232   };
1233 
1234   unsigned Idx = Attr.getAttributeSpellingListIndex();
1235   switch (Idx) {
1236     default: llvm_unreachable("Unknown spelling list index");
1237     case 0: return GNU_always_inline;
1238     case 1: return CXX11_gnu_always_inline;
1239     case 2: return C23_gnu_always_inline;
1240     case 3: return CXX11_clang_always_inline;
1241     case 4: return C23_clang_always_inline;
1242     case 5: return Keyword_forceinline;
1243   }
1244 }
1245 
1246 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
1247   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1248 }
1249 
1250 bool isParamExpr(size_t N) const override {
1251   return false;
1252 }
1253 
1254 static const ParsedAttrInfoAlwaysInline Instance;
1255 };
1256 const ParsedAttrInfoAlwaysInline ParsedAttrInfoAlwaysInline::Instance;
1257 static constexpr ParsedAttrInfo::Spelling AnalyzerNoReturnSpellings[] = {
1258   {AttributeCommonInfo::AS_GNU, "analyzer_noreturn"},
1259 };
1260 struct ParsedAttrInfoAnalyzerNoReturn final : public ParsedAttrInfo {
1261   constexpr ParsedAttrInfoAnalyzerNoReturn() : ParsedAttrInfo(
1262     /*AttrKind=*/ParsedAttr::AT_AnalyzerNoReturn,
1263     /*NumArgs=*/0,
1264     /*OptArgs=*/0,
1265     /*NumArgMembers=*/0,
1266     /*HasCustomParsing=*/0,
1267     /*AcceptsExprPack=*/0,
1268     /*IsTargetSpecific=*/0,
1269     /*IsType=*/0,
1270     /*IsStmt=*/0,
1271     /*IsKnownToGCC=*/0,
1272     /*IsSupportedByPragmaAttribute=*/0,
1273     /*Spellings=*/AnalyzerNoReturnSpellings,
1274     /*ArgNames=*/{}) {}
1275 bool isParamExpr(size_t N) const override {
1276   return false;
1277 }
1278 
1279 static const ParsedAttrInfoAnalyzerNoReturn Instance;
1280 };
1281 const ParsedAttrInfoAnalyzerNoReturn ParsedAttrInfoAnalyzerNoReturn::Instance;
1282 static constexpr ParsedAttrInfo::Spelling AnnotateSpellings[] = {
1283   {AttributeCommonInfo::AS_GNU, "annotate"},
1284   {AttributeCommonInfo::AS_CXX11, "clang::annotate"},
1285   {AttributeCommonInfo::AS_C23, "clang::annotate"},
1286 };
1287 static constexpr const char *AnnotateArgNames[] = {
1288 "Annotation","Args...",};
1289 struct ParsedAttrInfoAnnotate final : public ParsedAttrInfo {
1290   constexpr ParsedAttrInfoAnnotate() : ParsedAttrInfo(
1291     /*AttrKind=*/ParsedAttr::AT_Annotate,
1292     /*NumArgs=*/1,
1293     /*OptArgs=*/15,
1294     /*NumArgMembers=*/2,
1295     /*HasCustomParsing=*/0,
1296     /*AcceptsExprPack=*/1,
1297     /*IsTargetSpecific=*/0,
1298     /*IsType=*/0,
1299     /*IsStmt=*/0,
1300     /*IsKnownToGCC=*/0,
1301     /*IsSupportedByPragmaAttribute=*/1,
1302     /*Spellings=*/AnnotateSpellings,
1303     /*ArgNames=*/AnnotateArgNames) {}
1304 bool isParamExpr(size_t N) const override {
1305   return (N == 1) || false;
1306 }
1307 
1308 static const ParsedAttrInfoAnnotate Instance;
1309 };
1310 const ParsedAttrInfoAnnotate ParsedAttrInfoAnnotate::Instance;
1311 static constexpr ParsedAttrInfo::Spelling AnnotateTypeSpellings[] = {
1312   {AttributeCommonInfo::AS_CXX11, "clang::annotate_type"},
1313   {AttributeCommonInfo::AS_C23, "clang::annotate_type"},
1314 };
1315 static constexpr const char *AnnotateTypeArgNames[] = {
1316 "Annotation","Args...",};
1317 struct ParsedAttrInfoAnnotateType final : public ParsedAttrInfo {
1318   constexpr ParsedAttrInfoAnnotateType() : ParsedAttrInfo(
1319     /*AttrKind=*/ParsedAttr::AT_AnnotateType,
1320     /*NumArgs=*/1,
1321     /*OptArgs=*/15,
1322     /*NumArgMembers=*/2,
1323     /*HasCustomParsing=*/1,
1324     /*AcceptsExprPack=*/1,
1325     /*IsTargetSpecific=*/0,
1326     /*IsType=*/1,
1327     /*IsStmt=*/0,
1328     /*IsKnownToGCC=*/0,
1329     /*IsSupportedByPragmaAttribute=*/0,
1330     /*Spellings=*/AnnotateTypeSpellings,
1331     /*ArgNames=*/AnnotateTypeArgNames) {}
1332 bool isParamExpr(size_t N) const override {
1333   return (N == 1) || false;
1334 }
1335 
1336 static const ParsedAttrInfoAnnotateType Instance;
1337 };
1338 const ParsedAttrInfoAnnotateType ParsedAttrInfoAnnotateType::Instance;
1339 static constexpr ParsedAttrInfo::Spelling AnyX86NoCallerSavedRegistersSpellings[] = {
1340   {AttributeCommonInfo::AS_GNU, "no_caller_saved_registers"},
1341   {AttributeCommonInfo::AS_CXX11, "gnu::no_caller_saved_registers"},
1342   {AttributeCommonInfo::AS_C23, "gnu::no_caller_saved_registers"},
1343 };
1344 struct ParsedAttrInfoAnyX86NoCallerSavedRegisters final : public ParsedAttrInfo {
1345   constexpr ParsedAttrInfoAnyX86NoCallerSavedRegisters() : ParsedAttrInfo(
1346     /*AttrKind=*/ParsedAttr::AT_AnyX86NoCallerSavedRegisters,
1347     /*NumArgs=*/0,
1348     /*OptArgs=*/0,
1349     /*NumArgMembers=*/0,
1350     /*HasCustomParsing=*/0,
1351     /*AcceptsExprPack=*/0,
1352     /*IsTargetSpecific=*/1,
1353     /*IsType=*/0,
1354     /*IsStmt=*/0,
1355     /*IsKnownToGCC=*/1,
1356     /*IsSupportedByPragmaAttribute=*/0,
1357     /*Spellings=*/AnyX86NoCallerSavedRegistersSpellings,
1358     /*ArgNames=*/{}) {}
1359 bool existsInTarget(const TargetInfo &Target) const override {
1360   const llvm::Triple &T = Target.getTriple(); (void)T;
1361   return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
1362 }
1363 
1364 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
1365   D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(S.Context, Attr));
1366   return AttributeApplied;
1367 }
1368 
1369 bool isParamExpr(size_t N) const override {
1370   return false;
1371 }
1372 
1373 static const ParsedAttrInfoAnyX86NoCallerSavedRegisters Instance;
1374 };
1375 const ParsedAttrInfoAnyX86NoCallerSavedRegisters ParsedAttrInfoAnyX86NoCallerSavedRegisters::Instance;
1376 static constexpr ParsedAttrInfo::Spelling AnyX86NoCfCheckSpellings[] = {
1377   {AttributeCommonInfo::AS_GNU, "nocf_check"},
1378   {AttributeCommonInfo::AS_CXX11, "gnu::nocf_check"},
1379   {AttributeCommonInfo::AS_C23, "gnu::nocf_check"},
1380 };
1381 struct ParsedAttrInfoAnyX86NoCfCheck final : public ParsedAttrInfo {
1382   constexpr ParsedAttrInfoAnyX86NoCfCheck() : ParsedAttrInfo(
1383     /*AttrKind=*/ParsedAttr::AT_AnyX86NoCfCheck,
1384     /*NumArgs=*/0,
1385     /*OptArgs=*/0,
1386     /*NumArgMembers=*/0,
1387     /*HasCustomParsing=*/0,
1388     /*AcceptsExprPack=*/0,
1389     /*IsTargetSpecific=*/1,
1390     /*IsType=*/1,
1391     /*IsStmt=*/0,
1392     /*IsKnownToGCC=*/1,
1393     /*IsSupportedByPragmaAttribute=*/1,
1394     /*Spellings=*/AnyX86NoCfCheckSpellings,
1395     /*ArgNames=*/{}) {}
1396 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1397   if (!isFunctionLike(D)) {
1398     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
1399       << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers";
1400     return false;
1401   }
1402   return true;
1403 }
1404 
1405 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1406   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1407     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1408   return false;
1409 }
1410 
1411 bool existsInTarget(const TargetInfo &Target) const override {
1412   const llvm::Triple &T = Target.getTriple(); (void)T;
1413   return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
1414 }
1415 
1416 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
1417   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
1418 }
1419 
1420 bool isParamExpr(size_t N) const override {
1421   return false;
1422 }
1423 
1424 static const ParsedAttrInfoAnyX86NoCfCheck Instance;
1425 };
1426 const ParsedAttrInfoAnyX86NoCfCheck ParsedAttrInfoAnyX86NoCfCheck::Instance;
1427 static constexpr ParsedAttrInfo::Spelling ArcWeakrefUnavailableSpellings[] = {
1428   {AttributeCommonInfo::AS_GNU, "objc_arc_weak_reference_unavailable"},
1429   {AttributeCommonInfo::AS_CXX11, "clang::objc_arc_weak_reference_unavailable"},
1430   {AttributeCommonInfo::AS_C23, "clang::objc_arc_weak_reference_unavailable"},
1431 };
1432 struct ParsedAttrInfoArcWeakrefUnavailable final : public ParsedAttrInfo {
1433   constexpr ParsedAttrInfoArcWeakrefUnavailable() : ParsedAttrInfo(
1434     /*AttrKind=*/ParsedAttr::AT_ArcWeakrefUnavailable,
1435     /*NumArgs=*/0,
1436     /*OptArgs=*/0,
1437     /*NumArgMembers=*/0,
1438     /*HasCustomParsing=*/0,
1439     /*AcceptsExprPack=*/0,
1440     /*IsTargetSpecific=*/0,
1441     /*IsType=*/0,
1442     /*IsStmt=*/0,
1443     /*IsKnownToGCC=*/0,
1444     /*IsSupportedByPragmaAttribute=*/1,
1445     /*Spellings=*/ArcWeakrefUnavailableSpellings,
1446     /*ArgNames=*/{}) {}
1447 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1448   if (!isa<ObjCInterfaceDecl>(D)) {
1449     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1450       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
1451     return false;
1452   }
1453   return true;
1454 }
1455 
1456 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1457   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1458     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1459   return false;
1460 }
1461 
1462 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
1463   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
1464 }
1465 
1466 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
1467   D->addAttr(::new (S.Context) ArcWeakrefUnavailableAttr(S.Context, Attr));
1468   return AttributeApplied;
1469 }
1470 
1471 bool isParamExpr(size_t N) const override {
1472   return false;
1473 }
1474 
1475 static const ParsedAttrInfoArcWeakrefUnavailable Instance;
1476 };
1477 const ParsedAttrInfoArcWeakrefUnavailable ParsedAttrInfoArcWeakrefUnavailable::Instance;
1478 static constexpr ParsedAttrInfo::Spelling ArgumentWithTypeTagSpellings[] = {
1479   {AttributeCommonInfo::AS_GNU, "argument_with_type_tag"},
1480   {AttributeCommonInfo::AS_CXX11, "clang::argument_with_type_tag"},
1481   {AttributeCommonInfo::AS_C23, "clang::argument_with_type_tag"},
1482   {AttributeCommonInfo::AS_GNU, "pointer_with_type_tag"},
1483   {AttributeCommonInfo::AS_CXX11, "clang::pointer_with_type_tag"},
1484   {AttributeCommonInfo::AS_C23, "clang::pointer_with_type_tag"},
1485 };
1486 static constexpr const char *ArgumentWithTypeTagArgNames[] = {
1487 "ArgumentKind","ArgumentIdx","TypeTagIdx",};
1488 struct ParsedAttrInfoArgumentWithTypeTag final : public ParsedAttrInfo {
1489   constexpr ParsedAttrInfoArgumentWithTypeTag() : ParsedAttrInfo(
1490     /*AttrKind=*/ParsedAttr::AT_ArgumentWithTypeTag,
1491     /*NumArgs=*/3,
1492     /*OptArgs=*/0,
1493     /*NumArgMembers=*/3,
1494     /*HasCustomParsing=*/0,
1495     /*AcceptsExprPack=*/0,
1496     /*IsTargetSpecific=*/0,
1497     /*IsType=*/0,
1498     /*IsStmt=*/0,
1499     /*IsKnownToGCC=*/0,
1500     /*IsSupportedByPragmaAttribute=*/0,
1501     /*Spellings=*/ArgumentWithTypeTagSpellings,
1502     /*ArgNames=*/ArgumentWithTypeTagArgNames) {}
1503 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1504   if (!isHasFunctionProto(D)) {
1505     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1506       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1507     return false;
1508   }
1509   return true;
1510 }
1511 
1512 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1513   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1514     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1515   return false;
1516 }
1517 
1518 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
1519   enum Spelling {
1520     GNU_argument_with_type_tag = 0,
1521     CXX11_clang_argument_with_type_tag = 1,
1522     C23_clang_argument_with_type_tag = 2,
1523     GNU_pointer_with_type_tag = 3,
1524     CXX11_clang_pointer_with_type_tag = 4,
1525     C23_clang_pointer_with_type_tag = 5,
1526   SpellingNotCalculated = 15
1527 
1528   };
1529 
1530   unsigned Idx = Attr.getAttributeSpellingListIndex();
1531   switch (Idx) {
1532     default: llvm_unreachable("Unknown spelling list index");
1533     case 0: return GNU_argument_with_type_tag;
1534     case 1: return CXX11_clang_argument_with_type_tag;
1535     case 2: return C23_clang_argument_with_type_tag;
1536     case 3: return GNU_pointer_with_type_tag;
1537     case 4: return CXX11_clang_pointer_with_type_tag;
1538     case 5: return C23_clang_pointer_with_type_tag;
1539   }
1540 }
1541 
1542 bool isParamExpr(size_t N) const override {
1543   return false;
1544 }
1545 
1546 static const ParsedAttrInfoArgumentWithTypeTag Instance;
1547 };
1548 const ParsedAttrInfoArgumentWithTypeTag ParsedAttrInfoArgumentWithTypeTag::Instance;
1549 static constexpr ParsedAttrInfo::Spelling ArmAgnosticSpellings[] = {
1550   {AttributeCommonInfo::AS_Keyword, "__arm_agnostic"},
1551 };
1552 static constexpr const char *ArmAgnosticArgNames[] = {
1553 "AgnosticArgs...",};
1554 struct ParsedAttrInfoArmAgnostic final : public ParsedAttrInfo {
1555   constexpr ParsedAttrInfoArmAgnostic() : ParsedAttrInfo(
1556     /*AttrKind=*/ParsedAttr::AT_ArmAgnostic,
1557     /*NumArgs=*/0,
1558     /*OptArgs=*/15,
1559     /*NumArgMembers=*/1,
1560     /*HasCustomParsing=*/0,
1561     /*AcceptsExprPack=*/0,
1562     /*IsTargetSpecific=*/1,
1563     /*IsType=*/1,
1564     /*IsStmt=*/0,
1565     /*IsKnownToGCC=*/0,
1566     /*IsSupportedByPragmaAttribute=*/0,
1567     /*Spellings=*/ArmAgnosticSpellings,
1568     /*ArgNames=*/ArmAgnosticArgNames) {}
1569 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1570   if (!isHasFunctionProto(D)) {
1571     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1572       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1573     return false;
1574   }
1575   return true;
1576 }
1577 
1578 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1579   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1580     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1581   return false;
1582 }
1583 
1584 bool existsInTarget(const TargetInfo &Target) const override {
1585   const llvm::Triple &T = Target.getTriple(); (void)T;
1586   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1587 }
1588 
1589 bool isParamExpr(size_t N) const override {
1590   return false;
1591 }
1592 
1593 static const ParsedAttrInfoArmAgnostic Instance;
1594 };
1595 const ParsedAttrInfoArmAgnostic ParsedAttrInfoArmAgnostic::Instance;
1596 static constexpr ParsedAttrInfo::Spelling ArmBuiltinAliasSpellings[] = {
1597   {AttributeCommonInfo::AS_GNU, "__clang_arm_builtin_alias"},
1598   {AttributeCommonInfo::AS_CXX11, "clang::__clang_arm_builtin_alias"},
1599   {AttributeCommonInfo::AS_C23, "clang::__clang_arm_builtin_alias"},
1600 };
1601 static constexpr const char *ArmBuiltinAliasArgNames[] = {
1602 "BuiltinName",};
1603 struct ParsedAttrInfoArmBuiltinAlias final : public ParsedAttrInfo {
1604   constexpr ParsedAttrInfoArmBuiltinAlias() : ParsedAttrInfo(
1605     /*AttrKind=*/ParsedAttr::AT_ArmBuiltinAlias,
1606     /*NumArgs=*/1,
1607     /*OptArgs=*/0,
1608     /*NumArgMembers=*/1,
1609     /*HasCustomParsing=*/0,
1610     /*AcceptsExprPack=*/0,
1611     /*IsTargetSpecific=*/1,
1612     /*IsType=*/0,
1613     /*IsStmt=*/0,
1614     /*IsKnownToGCC=*/0,
1615     /*IsSupportedByPragmaAttribute=*/1,
1616     /*Spellings=*/ArmBuiltinAliasSpellings,
1617     /*ArgNames=*/ArmBuiltinAliasArgNames) {}
1618 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1619   if (!isa<FunctionDecl>(D)) {
1620     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1621       << Attr << Attr.isRegularKeywordAttribute() << "functions";
1622     return false;
1623   }
1624   return true;
1625 }
1626 
1627 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1628   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1629     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1630   return false;
1631 }
1632 
1633 bool existsInTarget(const TargetInfo &Target) const override {
1634   const llvm::Triple &T = Target.getTriple(); (void)T;
1635   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 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1636 }
1637 
1638 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
1639   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
1640 }
1641 
1642 bool isParamExpr(size_t N) const override {
1643   return false;
1644 }
1645 
1646 static const ParsedAttrInfoArmBuiltinAlias Instance;
1647 };
1648 const ParsedAttrInfoArmBuiltinAlias ParsedAttrInfoArmBuiltinAlias::Instance;
1649 static constexpr ParsedAttrInfo::Spelling ArmInSpellings[] = {
1650   {AttributeCommonInfo::AS_Keyword, "__arm_in"},
1651 };
1652 static constexpr const char *ArmInArgNames[] = {
1653 "InArgs...",};
1654 struct ParsedAttrInfoArmIn final : public ParsedAttrInfo {
1655   constexpr ParsedAttrInfoArmIn() : ParsedAttrInfo(
1656     /*AttrKind=*/ParsedAttr::AT_ArmIn,
1657     /*NumArgs=*/0,
1658     /*OptArgs=*/15,
1659     /*NumArgMembers=*/1,
1660     /*HasCustomParsing=*/0,
1661     /*AcceptsExprPack=*/0,
1662     /*IsTargetSpecific=*/1,
1663     /*IsType=*/1,
1664     /*IsStmt=*/0,
1665     /*IsKnownToGCC=*/0,
1666     /*IsSupportedByPragmaAttribute=*/0,
1667     /*Spellings=*/ArmInSpellings,
1668     /*ArgNames=*/ArmInArgNames) {}
1669 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1670   if (!isHasFunctionProto(D)) {
1671     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1672       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1673     return false;
1674   }
1675   return true;
1676 }
1677 
1678 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1679   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1680     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1681   return false;
1682 }
1683 
1684 bool existsInTarget(const TargetInfo &Target) const override {
1685   const llvm::Triple &T = Target.getTriple(); (void)T;
1686   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1687 }
1688 
1689 bool isParamExpr(size_t N) const override {
1690   return false;
1691 }
1692 
1693 static const ParsedAttrInfoArmIn Instance;
1694 };
1695 const ParsedAttrInfoArmIn ParsedAttrInfoArmIn::Instance;
1696 static constexpr ParsedAttrInfo::Spelling ArmInOutSpellings[] = {
1697   {AttributeCommonInfo::AS_Keyword, "__arm_inout"},
1698 };
1699 static constexpr const char *ArmInOutArgNames[] = {
1700 "InOutArgs...",};
1701 struct ParsedAttrInfoArmInOut final : public ParsedAttrInfo {
1702   constexpr ParsedAttrInfoArmInOut() : ParsedAttrInfo(
1703     /*AttrKind=*/ParsedAttr::AT_ArmInOut,
1704     /*NumArgs=*/0,
1705     /*OptArgs=*/15,
1706     /*NumArgMembers=*/1,
1707     /*HasCustomParsing=*/0,
1708     /*AcceptsExprPack=*/0,
1709     /*IsTargetSpecific=*/1,
1710     /*IsType=*/1,
1711     /*IsStmt=*/0,
1712     /*IsKnownToGCC=*/0,
1713     /*IsSupportedByPragmaAttribute=*/0,
1714     /*Spellings=*/ArmInOutSpellings,
1715     /*ArgNames=*/ArmInOutArgNames) {}
1716 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1717   if (!isHasFunctionProto(D)) {
1718     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1719       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1720     return false;
1721   }
1722   return true;
1723 }
1724 
1725 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1726   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1727     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1728   return false;
1729 }
1730 
1731 bool existsInTarget(const TargetInfo &Target) const override {
1732   const llvm::Triple &T = Target.getTriple(); (void)T;
1733   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1734 }
1735 
1736 bool isParamExpr(size_t N) const override {
1737   return false;
1738 }
1739 
1740 static const ParsedAttrInfoArmInOut Instance;
1741 };
1742 const ParsedAttrInfoArmInOut ParsedAttrInfoArmInOut::Instance;
1743 static constexpr ParsedAttrInfo::Spelling ArmLocallyStreamingSpellings[] = {
1744   {AttributeCommonInfo::AS_Keyword, "__arm_locally_streaming"},
1745 };
1746 struct ParsedAttrInfoArmLocallyStreaming final : public ParsedAttrInfo {
1747   constexpr ParsedAttrInfoArmLocallyStreaming() : ParsedAttrInfo(
1748     /*AttrKind=*/ParsedAttr::AT_ArmLocallyStreaming,
1749     /*NumArgs=*/0,
1750     /*OptArgs=*/0,
1751     /*NumArgMembers=*/0,
1752     /*HasCustomParsing=*/0,
1753     /*AcceptsExprPack=*/0,
1754     /*IsTargetSpecific=*/1,
1755     /*IsType=*/0,
1756     /*IsStmt=*/0,
1757     /*IsKnownToGCC=*/0,
1758     /*IsSupportedByPragmaAttribute=*/0,
1759     /*Spellings=*/ArmLocallyStreamingSpellings,
1760     /*ArgNames=*/{}) {}
1761 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1762   if (!isa<FunctionDecl>(D)) {
1763     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1764       << Attr << Attr.isRegularKeywordAttribute() << "functions";
1765     return false;
1766   }
1767   return true;
1768 }
1769 
1770 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1771   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1772     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1773   return false;
1774 }
1775 
1776 bool existsInTarget(const TargetInfo &Target) const override {
1777   const llvm::Triple &T = Target.getTriple(); (void)T;
1778   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1779 }
1780 
1781 bool isParamExpr(size_t N) const override {
1782   return false;
1783 }
1784 
1785 static const ParsedAttrInfoArmLocallyStreaming Instance;
1786 };
1787 const ParsedAttrInfoArmLocallyStreaming ParsedAttrInfoArmLocallyStreaming::Instance;
1788 static constexpr ParsedAttrInfo::Spelling ArmMveStrictPolymorphismSpellings[] = {
1789   {AttributeCommonInfo::AS_GNU, "__clang_arm_mve_strict_polymorphism"},
1790   {AttributeCommonInfo::AS_CXX11, "clang::__clang_arm_mve_strict_polymorphism"},
1791   {AttributeCommonInfo::AS_C23, "clang::__clang_arm_mve_strict_polymorphism"},
1792 };
1793 struct ParsedAttrInfoArmMveStrictPolymorphism final : public ParsedAttrInfo {
1794   constexpr ParsedAttrInfoArmMveStrictPolymorphism() : ParsedAttrInfo(
1795     /*AttrKind=*/ParsedAttr::AT_ArmMveStrictPolymorphism,
1796     /*NumArgs=*/0,
1797     /*OptArgs=*/0,
1798     /*NumArgMembers=*/0,
1799     /*HasCustomParsing=*/0,
1800     /*AcceptsExprPack=*/0,
1801     /*IsTargetSpecific=*/1,
1802     /*IsType=*/1,
1803     /*IsStmt=*/0,
1804     /*IsKnownToGCC=*/0,
1805     /*IsSupportedByPragmaAttribute=*/0,
1806     /*Spellings=*/ArmMveStrictPolymorphismSpellings,
1807     /*ArgNames=*/{}) {}
1808 bool existsInTarget(const TargetInfo &Target) const override {
1809   const llvm::Triple &T = Target.getTriple(); (void)T;
1810   return true && (T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::armeb || T.getArch() == llvm::Triple::thumbeb);
1811 }
1812 
1813 bool isParamExpr(size_t N) const override {
1814   return false;
1815 }
1816 
1817 static const ParsedAttrInfoArmMveStrictPolymorphism Instance;
1818 };
1819 const ParsedAttrInfoArmMveStrictPolymorphism ParsedAttrInfoArmMveStrictPolymorphism::Instance;
1820 static constexpr ParsedAttrInfo::Spelling ArmNewSpellings[] = {
1821   {AttributeCommonInfo::AS_Keyword, "__arm_new"},
1822 };
1823 static constexpr const char *ArmNewArgNames[] = {
1824 "NewArgs...",};
1825 struct ParsedAttrInfoArmNew final : public ParsedAttrInfo {
1826   constexpr ParsedAttrInfoArmNew() : ParsedAttrInfo(
1827     /*AttrKind=*/ParsedAttr::AT_ArmNew,
1828     /*NumArgs=*/0,
1829     /*OptArgs=*/15,
1830     /*NumArgMembers=*/1,
1831     /*HasCustomParsing=*/0,
1832     /*AcceptsExprPack=*/0,
1833     /*IsTargetSpecific=*/1,
1834     /*IsType=*/0,
1835     /*IsStmt=*/0,
1836     /*IsKnownToGCC=*/0,
1837     /*IsSupportedByPragmaAttribute=*/0,
1838     /*Spellings=*/ArmNewSpellings,
1839     /*ArgNames=*/ArmNewArgNames) {}
1840 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1841   if (!isa<FunctionDecl>(D)) {
1842     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1843       << Attr << Attr.isRegularKeywordAttribute() << "functions";
1844     return false;
1845   }
1846   return true;
1847 }
1848 
1849 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1850   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1851     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1852   return false;
1853 }
1854 
1855 bool existsInTarget(const TargetInfo &Target) const override {
1856   const llvm::Triple &T = Target.getTriple(); (void)T;
1857   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1858 }
1859 
1860 bool isParamExpr(size_t N) const override {
1861   return false;
1862 }
1863 
1864 static const ParsedAttrInfoArmNew Instance;
1865 };
1866 const ParsedAttrInfoArmNew ParsedAttrInfoArmNew::Instance;
1867 static constexpr ParsedAttrInfo::Spelling ArmOutSpellings[] = {
1868   {AttributeCommonInfo::AS_Keyword, "__arm_out"},
1869 };
1870 static constexpr const char *ArmOutArgNames[] = {
1871 "OutArgs...",};
1872 struct ParsedAttrInfoArmOut final : public ParsedAttrInfo {
1873   constexpr ParsedAttrInfoArmOut() : ParsedAttrInfo(
1874     /*AttrKind=*/ParsedAttr::AT_ArmOut,
1875     /*NumArgs=*/0,
1876     /*OptArgs=*/15,
1877     /*NumArgMembers=*/1,
1878     /*HasCustomParsing=*/0,
1879     /*AcceptsExprPack=*/0,
1880     /*IsTargetSpecific=*/1,
1881     /*IsType=*/1,
1882     /*IsStmt=*/0,
1883     /*IsKnownToGCC=*/0,
1884     /*IsSupportedByPragmaAttribute=*/0,
1885     /*Spellings=*/ArmOutSpellings,
1886     /*ArgNames=*/ArmOutArgNames) {}
1887 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1888   if (!isHasFunctionProto(D)) {
1889     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1890       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1891     return false;
1892   }
1893   return true;
1894 }
1895 
1896 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1897   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1898     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1899   return false;
1900 }
1901 
1902 bool existsInTarget(const TargetInfo &Target) const override {
1903   const llvm::Triple &T = Target.getTriple(); (void)T;
1904   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1905 }
1906 
1907 bool isParamExpr(size_t N) const override {
1908   return false;
1909 }
1910 
1911 static const ParsedAttrInfoArmOut Instance;
1912 };
1913 const ParsedAttrInfoArmOut ParsedAttrInfoArmOut::Instance;
1914 static constexpr ParsedAttrInfo::Spelling ArmPreservesSpellings[] = {
1915   {AttributeCommonInfo::AS_Keyword, "__arm_preserves"},
1916 };
1917 static constexpr const char *ArmPreservesArgNames[] = {
1918 "PreserveArgs...",};
1919 struct ParsedAttrInfoArmPreserves final : public ParsedAttrInfo {
1920   constexpr ParsedAttrInfoArmPreserves() : ParsedAttrInfo(
1921     /*AttrKind=*/ParsedAttr::AT_ArmPreserves,
1922     /*NumArgs=*/0,
1923     /*OptArgs=*/15,
1924     /*NumArgMembers=*/1,
1925     /*HasCustomParsing=*/0,
1926     /*AcceptsExprPack=*/0,
1927     /*IsTargetSpecific=*/1,
1928     /*IsType=*/1,
1929     /*IsStmt=*/0,
1930     /*IsKnownToGCC=*/0,
1931     /*IsSupportedByPragmaAttribute=*/0,
1932     /*Spellings=*/ArmPreservesSpellings,
1933     /*ArgNames=*/ArmPreservesArgNames) {}
1934 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1935   if (!isHasFunctionProto(D)) {
1936     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1937       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1938     return false;
1939   }
1940   return true;
1941 }
1942 
1943 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1944   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1945     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1946   return false;
1947 }
1948 
1949 bool existsInTarget(const TargetInfo &Target) const override {
1950   const llvm::Triple &T = Target.getTriple(); (void)T;
1951   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1952 }
1953 
1954 bool isParamExpr(size_t N) const override {
1955   return false;
1956 }
1957 
1958 static const ParsedAttrInfoArmPreserves Instance;
1959 };
1960 const ParsedAttrInfoArmPreserves ParsedAttrInfoArmPreserves::Instance;
1961 static constexpr ParsedAttrInfo::Spelling ArmStreamingSpellings[] = {
1962   {AttributeCommonInfo::AS_Keyword, "__arm_streaming"},
1963 };
1964 struct ParsedAttrInfoArmStreaming final : public ParsedAttrInfo {
1965   constexpr ParsedAttrInfoArmStreaming() : ParsedAttrInfo(
1966     /*AttrKind=*/ParsedAttr::AT_ArmStreaming,
1967     /*NumArgs=*/0,
1968     /*OptArgs=*/0,
1969     /*NumArgMembers=*/0,
1970     /*HasCustomParsing=*/0,
1971     /*AcceptsExprPack=*/0,
1972     /*IsTargetSpecific=*/1,
1973     /*IsType=*/1,
1974     /*IsStmt=*/0,
1975     /*IsKnownToGCC=*/0,
1976     /*IsSupportedByPragmaAttribute=*/0,
1977     /*Spellings=*/ArmStreamingSpellings,
1978     /*ArgNames=*/{}) {}
1979 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
1980   if (!isHasFunctionProto(D)) {
1981     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
1982       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
1983     return false;
1984   }
1985   return true;
1986 }
1987 
1988 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
1989   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
1990     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
1991   return false;
1992 }
1993 
1994 bool existsInTarget(const TargetInfo &Target) const override {
1995   const llvm::Triple &T = Target.getTriple(); (void)T;
1996   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
1997 }
1998 
1999 bool isParamExpr(size_t N) const override {
2000   return false;
2001 }
2002 
2003 static const ParsedAttrInfoArmStreaming Instance;
2004 };
2005 const ParsedAttrInfoArmStreaming ParsedAttrInfoArmStreaming::Instance;
2006 static constexpr ParsedAttrInfo::Spelling ArmStreamingCompatibleSpellings[] = {
2007   {AttributeCommonInfo::AS_Keyword, "__arm_streaming_compatible"},
2008 };
2009 struct ParsedAttrInfoArmStreamingCompatible final : public ParsedAttrInfo {
2010   constexpr ParsedAttrInfoArmStreamingCompatible() : ParsedAttrInfo(
2011     /*AttrKind=*/ParsedAttr::AT_ArmStreamingCompatible,
2012     /*NumArgs=*/0,
2013     /*OptArgs=*/0,
2014     /*NumArgMembers=*/0,
2015     /*HasCustomParsing=*/0,
2016     /*AcceptsExprPack=*/0,
2017     /*IsTargetSpecific=*/1,
2018     /*IsType=*/1,
2019     /*IsStmt=*/0,
2020     /*IsKnownToGCC=*/0,
2021     /*IsSupportedByPragmaAttribute=*/0,
2022     /*Spellings=*/ArmStreamingCompatibleSpellings,
2023     /*ArgNames=*/{}) {}
2024 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2025   if (!isHasFunctionProto(D)) {
2026     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2027       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
2028     return false;
2029   }
2030   return true;
2031 }
2032 
2033 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2034   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2035     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2036   return false;
2037 }
2038 
2039 bool existsInTarget(const TargetInfo &Target) const override {
2040   const llvm::Triple &T = Target.getTriple(); (void)T;
2041   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32);
2042 }
2043 
2044 bool isParamExpr(size_t N) const override {
2045   return false;
2046 }
2047 
2048 static const ParsedAttrInfoArmStreamingCompatible Instance;
2049 };
2050 const ParsedAttrInfoArmStreamingCompatible ParsedAttrInfoArmStreamingCompatible::Instance;
2051 static constexpr ParsedAttrInfo::Spelling ArmSveVectorBitsSpellings[] = {
2052   {AttributeCommonInfo::AS_GNU, "arm_sve_vector_bits"},
2053 };
2054 static constexpr const char *ArmSveVectorBitsArgNames[] = {
2055 "NumBits",};
2056 struct ParsedAttrInfoArmSveVectorBits final : public ParsedAttrInfo {
2057   constexpr ParsedAttrInfoArmSveVectorBits() : ParsedAttrInfo(
2058     /*AttrKind=*/ParsedAttr::AT_ArmSveVectorBits,
2059     /*NumArgs=*/1,
2060     /*OptArgs=*/0,
2061     /*NumArgMembers=*/1,
2062     /*HasCustomParsing=*/0,
2063     /*AcceptsExprPack=*/0,
2064     /*IsTargetSpecific=*/0,
2065     /*IsType=*/1,
2066     /*IsStmt=*/0,
2067     /*IsKnownToGCC=*/0,
2068     /*IsSupportedByPragmaAttribute=*/0,
2069     /*Spellings=*/ArmSveVectorBitsSpellings,
2070     /*ArgNames=*/ArmSveVectorBitsArgNames) {}
2071 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2072   if (!isa<TypedefNameDecl>(D)) {
2073     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2074       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
2075     return false;
2076   }
2077   return true;
2078 }
2079 
2080 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2081   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2082     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2083   return false;
2084 }
2085 
2086 bool isParamExpr(size_t N) const override {
2087   return false;
2088 }
2089 
2090 static const ParsedAttrInfoArmSveVectorBits Instance;
2091 };
2092 const ParsedAttrInfoArmSveVectorBits ParsedAttrInfoArmSveVectorBits::Instance;
2093 static constexpr ParsedAttrInfo::Spelling ArtificialSpellings[] = {
2094   {AttributeCommonInfo::AS_GNU, "artificial"},
2095   {AttributeCommonInfo::AS_CXX11, "gnu::artificial"},
2096   {AttributeCommonInfo::AS_C23, "gnu::artificial"},
2097 };
2098 struct ParsedAttrInfoArtificial final : public ParsedAttrInfo {
2099   constexpr ParsedAttrInfoArtificial() : ParsedAttrInfo(
2100     /*AttrKind=*/ParsedAttr::AT_Artificial,
2101     /*NumArgs=*/0,
2102     /*OptArgs=*/0,
2103     /*NumArgMembers=*/0,
2104     /*HasCustomParsing=*/0,
2105     /*AcceptsExprPack=*/0,
2106     /*IsTargetSpecific=*/0,
2107     /*IsType=*/0,
2108     /*IsStmt=*/0,
2109     /*IsKnownToGCC=*/1,
2110     /*IsSupportedByPragmaAttribute=*/0,
2111     /*Spellings=*/ArtificialSpellings,
2112     /*ArgNames=*/{}) {}
2113 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2114   if (!isInlineFunction(D)) {
2115     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2116       << Attr << Attr.isRegularKeywordAttribute() << "inline functions";
2117     return false;
2118   }
2119   return true;
2120 }
2121 
2122 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2123   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2124     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2125   return false;
2126 }
2127 
2128 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
2129   D->addAttr(::new (S.Context) ArtificialAttr(S.Context, Attr));
2130   return AttributeApplied;
2131 }
2132 
2133 bool isParamExpr(size_t N) const override {
2134   return false;
2135 }
2136 
2137 static const ParsedAttrInfoArtificial Instance;
2138 };
2139 const ParsedAttrInfoArtificial ParsedAttrInfoArtificial::Instance;
2140 static constexpr ParsedAttrInfo::Spelling AssertCapabilitySpellings[] = {
2141   {AttributeCommonInfo::AS_GNU, "assert_capability"},
2142   {AttributeCommonInfo::AS_CXX11, "clang::assert_capability"},
2143   {AttributeCommonInfo::AS_GNU, "assert_shared_capability"},
2144   {AttributeCommonInfo::AS_CXX11, "clang::assert_shared_capability"},
2145 };
2146 static constexpr const char *AssertCapabilityArgNames[] = {
2147 "Args...",};
2148 struct ParsedAttrInfoAssertCapability final : public ParsedAttrInfo {
2149   constexpr ParsedAttrInfoAssertCapability() : ParsedAttrInfo(
2150     /*AttrKind=*/ParsedAttr::AT_AssertCapability,
2151     /*NumArgs=*/0,
2152     /*OptArgs=*/15,
2153     /*NumArgMembers=*/1,
2154     /*HasCustomParsing=*/0,
2155     /*AcceptsExprPack=*/0,
2156     /*IsTargetSpecific=*/0,
2157     /*IsType=*/0,
2158     /*IsStmt=*/0,
2159     /*IsKnownToGCC=*/0,
2160     /*IsSupportedByPragmaAttribute=*/0,
2161     /*Spellings=*/AssertCapabilitySpellings,
2162     /*ArgNames=*/AssertCapabilityArgNames) {}
2163 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2164   if (!isa<FunctionDecl>(D)) {
2165     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2166       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2167     return false;
2168   }
2169   return true;
2170 }
2171 
2172 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2173   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2174     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2175   return false;
2176 }
2177 
2178 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
2179   enum Spelling {
2180     GNU_assert_capability = 0,
2181     CXX11_clang_assert_capability = 1,
2182     GNU_assert_shared_capability = 2,
2183     CXX11_clang_assert_shared_capability = 3,
2184   SpellingNotCalculated = 15
2185 
2186   };
2187 
2188   unsigned Idx = Attr.getAttributeSpellingListIndex();
2189   switch (Idx) {
2190     default: llvm_unreachable("Unknown spelling list index");
2191     case 0: return GNU_assert_capability;
2192     case 1: return CXX11_clang_assert_capability;
2193     case 2: return GNU_assert_shared_capability;
2194     case 3: return CXX11_clang_assert_shared_capability;
2195   }
2196 }
2197 
2198 bool isParamExpr(size_t N) const override {
2199   return (N == 0) || false;
2200 }
2201 
2202 static const ParsedAttrInfoAssertCapability Instance;
2203 };
2204 const ParsedAttrInfoAssertCapability ParsedAttrInfoAssertCapability::Instance;
2205 static constexpr ParsedAttrInfo::Spelling AssertExclusiveLockSpellings[] = {
2206   {AttributeCommonInfo::AS_GNU, "assert_exclusive_lock"},
2207 };
2208 static constexpr const char *AssertExclusiveLockArgNames[] = {
2209 "Args...",};
2210 struct ParsedAttrInfoAssertExclusiveLock final : public ParsedAttrInfo {
2211   constexpr ParsedAttrInfoAssertExclusiveLock() : ParsedAttrInfo(
2212     /*AttrKind=*/ParsedAttr::AT_AssertExclusiveLock,
2213     /*NumArgs=*/0,
2214     /*OptArgs=*/15,
2215     /*NumArgMembers=*/1,
2216     /*HasCustomParsing=*/0,
2217     /*AcceptsExprPack=*/0,
2218     /*IsTargetSpecific=*/0,
2219     /*IsType=*/0,
2220     /*IsStmt=*/0,
2221     /*IsKnownToGCC=*/0,
2222     /*IsSupportedByPragmaAttribute=*/0,
2223     /*Spellings=*/AssertExclusiveLockSpellings,
2224     /*ArgNames=*/AssertExclusiveLockArgNames) {}
2225 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2226   if (!isa<FunctionDecl>(D)) {
2227     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2228       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2229     return false;
2230   }
2231   return true;
2232 }
2233 
2234 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2235   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2236     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2237   return false;
2238 }
2239 
2240 bool isParamExpr(size_t N) const override {
2241   return (N == 0) || false;
2242 }
2243 
2244 static const ParsedAttrInfoAssertExclusiveLock Instance;
2245 };
2246 const ParsedAttrInfoAssertExclusiveLock ParsedAttrInfoAssertExclusiveLock::Instance;
2247 static constexpr ParsedAttrInfo::Spelling AssertSharedLockSpellings[] = {
2248   {AttributeCommonInfo::AS_GNU, "assert_shared_lock"},
2249 };
2250 static constexpr const char *AssertSharedLockArgNames[] = {
2251 "Args...",};
2252 struct ParsedAttrInfoAssertSharedLock final : public ParsedAttrInfo {
2253   constexpr ParsedAttrInfoAssertSharedLock() : ParsedAttrInfo(
2254     /*AttrKind=*/ParsedAttr::AT_AssertSharedLock,
2255     /*NumArgs=*/0,
2256     /*OptArgs=*/15,
2257     /*NumArgMembers=*/1,
2258     /*HasCustomParsing=*/0,
2259     /*AcceptsExprPack=*/0,
2260     /*IsTargetSpecific=*/0,
2261     /*IsType=*/0,
2262     /*IsStmt=*/0,
2263     /*IsKnownToGCC=*/0,
2264     /*IsSupportedByPragmaAttribute=*/0,
2265     /*Spellings=*/AssertSharedLockSpellings,
2266     /*ArgNames=*/AssertSharedLockArgNames) {}
2267 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2268   if (!isa<FunctionDecl>(D)) {
2269     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2270       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2271     return false;
2272   }
2273   return true;
2274 }
2275 
2276 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2277   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2278     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2279   return false;
2280 }
2281 
2282 bool isParamExpr(size_t N) const override {
2283   return (N == 0) || false;
2284 }
2285 
2286 static const ParsedAttrInfoAssertSharedLock Instance;
2287 };
2288 const ParsedAttrInfoAssertSharedLock ParsedAttrInfoAssertSharedLock::Instance;
2289 static constexpr ParsedAttrInfo::Spelling AssumeAlignedSpellings[] = {
2290   {AttributeCommonInfo::AS_GNU, "assume_aligned"},
2291   {AttributeCommonInfo::AS_CXX11, "gnu::assume_aligned"},
2292   {AttributeCommonInfo::AS_C23, "gnu::assume_aligned"},
2293 };
2294 static constexpr const char *AssumeAlignedArgNames[] = {
2295 "Alignment","Offset",};
2296 struct ParsedAttrInfoAssumeAligned final : public ParsedAttrInfo {
2297   constexpr ParsedAttrInfoAssumeAligned() : ParsedAttrInfo(
2298     /*AttrKind=*/ParsedAttr::AT_AssumeAligned,
2299     /*NumArgs=*/1,
2300     /*OptArgs=*/1,
2301     /*NumArgMembers=*/2,
2302     /*HasCustomParsing=*/0,
2303     /*AcceptsExprPack=*/0,
2304     /*IsTargetSpecific=*/0,
2305     /*IsType=*/0,
2306     /*IsStmt=*/0,
2307     /*IsKnownToGCC=*/1,
2308     /*IsSupportedByPragmaAttribute=*/1,
2309     /*Spellings=*/AssumeAlignedSpellings,
2310     /*ArgNames=*/AssumeAlignedArgNames) {}
2311 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2312   if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) {
2313     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2314       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions";
2315     return false;
2316   }
2317   return true;
2318 }
2319 
2320 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2321   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2322     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2323   return false;
2324 }
2325 
2326 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2327   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
2328   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2329 }
2330 
2331 bool isParamExpr(size_t N) const override {
2332   return (N == 0) || (N == 1) || false;
2333 }
2334 
2335 static const ParsedAttrInfoAssumeAligned Instance;
2336 };
2337 const ParsedAttrInfoAssumeAligned ParsedAttrInfoAssumeAligned::Instance;
2338 static constexpr ParsedAttrInfo::Spelling AvailabilitySpellings[] = {
2339   {AttributeCommonInfo::AS_GNU, "availability"},
2340   {AttributeCommonInfo::AS_CXX11, "clang::availability"},
2341   {AttributeCommonInfo::AS_C23, "clang::availability"},
2342 };
2343 static constexpr const char *AvailabilityArgNames[] = {
2344 "platform","introduced","deprecated","obsoleted","unavailable","message","strict","replacement","priority","environment",};
2345 struct ParsedAttrInfoAvailability final : public ParsedAttrInfo {
2346   constexpr ParsedAttrInfoAvailability() : ParsedAttrInfo(
2347     /*AttrKind=*/ParsedAttr::AT_Availability,
2348     /*NumArgs=*/10,
2349     /*OptArgs=*/0,
2350     /*NumArgMembers=*/10,
2351     /*HasCustomParsing=*/1,
2352     /*AcceptsExprPack=*/0,
2353     /*IsTargetSpecific=*/0,
2354     /*IsType=*/0,
2355     /*IsStmt=*/0,
2356     /*IsKnownToGCC=*/0,
2357     /*IsSupportedByPragmaAttribute=*/1,
2358     /*Spellings=*/AvailabilitySpellings,
2359     /*ArgNames=*/AvailabilityArgNames) {}
2360 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2361   if (!isa<NamedDecl>(D)) {
2362     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2363       << Attr << Attr.isRegularKeywordAttribute() << "named declarations";
2364     return false;
2365   }
2366   return true;
2367 }
2368 
2369 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2370   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2371     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2372   return false;
2373 }
2374 
2375 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2376   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2377   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
2378   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true));
2379   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
2380   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2381   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
2382   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC));
2383   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /*IsSupported=*/LangOpts.ObjC));
2384   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
2385   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
2386   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
2387   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC));
2388   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2389   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
2390   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
2391 }
2392 
2393 bool isParamExpr(size_t N) const override {
2394   return false;
2395 }
2396 
2397 static const ParsedAttrInfoAvailability Instance;
2398 };
2399 const ParsedAttrInfoAvailability ParsedAttrInfoAvailability::Instance;
2400 static constexpr ParsedAttrInfo::Spelling AvailableOnlyInDefaultEvalMethodSpellings[] = {
2401   {AttributeCommonInfo::AS_GNU, "available_only_in_default_eval_method"},
2402   {AttributeCommonInfo::AS_CXX11, "clang::available_only_in_default_eval_method"},
2403   {AttributeCommonInfo::AS_C23, "clang::available_only_in_default_eval_method"},
2404 };
2405 struct ParsedAttrInfoAvailableOnlyInDefaultEvalMethod final : public ParsedAttrInfo {
2406   constexpr ParsedAttrInfoAvailableOnlyInDefaultEvalMethod() : ParsedAttrInfo(
2407     /*AttrKind=*/ParsedAttr::AT_AvailableOnlyInDefaultEvalMethod,
2408     /*NumArgs=*/0,
2409     /*OptArgs=*/0,
2410     /*NumArgMembers=*/0,
2411     /*HasCustomParsing=*/0,
2412     /*AcceptsExprPack=*/0,
2413     /*IsTargetSpecific=*/0,
2414     /*IsType=*/0,
2415     /*IsStmt=*/0,
2416     /*IsKnownToGCC=*/0,
2417     /*IsSupportedByPragmaAttribute=*/1,
2418     /*Spellings=*/AvailableOnlyInDefaultEvalMethodSpellings,
2419     /*ArgNames=*/{}) {}
2420 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2421   if (!isa<TypedefNameDecl>(D)) {
2422     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2423       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
2424     return false;
2425   }
2426   return true;
2427 }
2428 
2429 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2430   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2431     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2432   return false;
2433 }
2434 
2435 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2436   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
2437 }
2438 
2439 bool isParamExpr(size_t N) const override {
2440   return false;
2441 }
2442 
2443 static const ParsedAttrInfoAvailableOnlyInDefaultEvalMethod Instance;
2444 };
2445 const ParsedAttrInfoAvailableOnlyInDefaultEvalMethod ParsedAttrInfoAvailableOnlyInDefaultEvalMethod::Instance;
2446 static constexpr ParsedAttrInfo::Spelling BPFFastCallSpellings[] = {
2447   {AttributeCommonInfo::AS_GNU, "bpf_fastcall"},
2448   {AttributeCommonInfo::AS_CXX11, "clang::bpf_fastcall"},
2449   {AttributeCommonInfo::AS_C23, "clang::bpf_fastcall"},
2450 };
2451 struct ParsedAttrInfoBPFFastCall final : public ParsedAttrInfo {
2452   constexpr ParsedAttrInfoBPFFastCall() : ParsedAttrInfo(
2453     /*AttrKind=*/ParsedAttr::AT_BPFFastCall,
2454     /*NumArgs=*/0,
2455     /*OptArgs=*/0,
2456     /*NumArgMembers=*/0,
2457     /*HasCustomParsing=*/0,
2458     /*AcceptsExprPack=*/0,
2459     /*IsTargetSpecific=*/1,
2460     /*IsType=*/0,
2461     /*IsStmt=*/0,
2462     /*IsKnownToGCC=*/0,
2463     /*IsSupportedByPragmaAttribute=*/1,
2464     /*Spellings=*/BPFFastCallSpellings,
2465     /*ArgNames=*/{}) {}
2466 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2467   if (!isFunctionLike(D)) {
2468     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2469       << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers";
2470     return false;
2471   }
2472   return true;
2473 }
2474 
2475 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2476   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2477     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2478   return false;
2479 }
2480 
2481 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
2482   return (!LangOpts.CPlusPlus);
2483 }
2484 
2485 bool existsInTarget(const TargetInfo &Target) const override {
2486   const llvm::Triple &T = Target.getTriple(); (void)T;
2487   return true && (T.getArch() == llvm::Triple::bpfel || T.getArch() == llvm::Triple::bpfeb);
2488 }
2489 
2490 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2491   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
2492 }
2493 
2494 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
2495   D->addAttr(::new (S.Context) BPFFastCallAttr(S.Context, Attr));
2496   return AttributeApplied;
2497 }
2498 
2499 bool isParamExpr(size_t N) const override {
2500   return false;
2501 }
2502 
2503 static const ParsedAttrInfoBPFFastCall Instance;
2504 };
2505 const ParsedAttrInfoBPFFastCall ParsedAttrInfoBPFFastCall::Instance;
2506 static constexpr ParsedAttrInfo::Spelling BPFPreserveAccessIndexSpellings[] = {
2507   {AttributeCommonInfo::AS_GNU, "preserve_access_index"},
2508   {AttributeCommonInfo::AS_CXX11, "clang::preserve_access_index"},
2509   {AttributeCommonInfo::AS_C23, "clang::preserve_access_index"},
2510 };
2511 struct ParsedAttrInfoBPFPreserveAccessIndex final : public ParsedAttrInfo {
2512   constexpr ParsedAttrInfoBPFPreserveAccessIndex() : ParsedAttrInfo(
2513     /*AttrKind=*/ParsedAttr::AT_BPFPreserveAccessIndex,
2514     /*NumArgs=*/0,
2515     /*OptArgs=*/0,
2516     /*NumArgMembers=*/0,
2517     /*HasCustomParsing=*/0,
2518     /*AcceptsExprPack=*/0,
2519     /*IsTargetSpecific=*/1,
2520     /*IsType=*/0,
2521     /*IsStmt=*/0,
2522     /*IsKnownToGCC=*/0,
2523     /*IsSupportedByPragmaAttribute=*/1,
2524     /*Spellings=*/BPFPreserveAccessIndexSpellings,
2525     /*ArgNames=*/{}) {}
2526 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2527   if (!isa<RecordDecl>(D)) {
2528     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2529       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
2530     return false;
2531   }
2532   return true;
2533 }
2534 
2535 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2536   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2537     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2538   return false;
2539 }
2540 
2541 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
2542   return (!LangOpts.CPlusPlus);
2543 }
2544 
2545 bool existsInTarget(const TargetInfo &Target) const override {
2546   const llvm::Triple &T = Target.getTriple(); (void)T;
2547   return true && (T.getArch() == llvm::Triple::bpfel || T.getArch() == llvm::Triple::bpfeb);
2548 }
2549 
2550 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2551   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2552 }
2553 
2554 bool isParamExpr(size_t N) const override {
2555   return false;
2556 }
2557 
2558 static const ParsedAttrInfoBPFPreserveAccessIndex Instance;
2559 };
2560 const ParsedAttrInfoBPFPreserveAccessIndex ParsedAttrInfoBPFPreserveAccessIndex::Instance;
2561 static constexpr ParsedAttrInfo::Spelling BPFPreserveStaticOffsetSpellings[] = {
2562   {AttributeCommonInfo::AS_GNU, "preserve_static_offset"},
2563   {AttributeCommonInfo::AS_CXX11, "clang::preserve_static_offset"},
2564   {AttributeCommonInfo::AS_C23, "clang::preserve_static_offset"},
2565 };
2566 struct ParsedAttrInfoBPFPreserveStaticOffset final : public ParsedAttrInfo {
2567   constexpr ParsedAttrInfoBPFPreserveStaticOffset() : ParsedAttrInfo(
2568     /*AttrKind=*/ParsedAttr::AT_BPFPreserveStaticOffset,
2569     /*NumArgs=*/0,
2570     /*OptArgs=*/0,
2571     /*NumArgMembers=*/0,
2572     /*HasCustomParsing=*/0,
2573     /*AcceptsExprPack=*/0,
2574     /*IsTargetSpecific=*/1,
2575     /*IsType=*/0,
2576     /*IsStmt=*/0,
2577     /*IsKnownToGCC=*/0,
2578     /*IsSupportedByPragmaAttribute=*/1,
2579     /*Spellings=*/BPFPreserveStaticOffsetSpellings,
2580     /*ArgNames=*/{}) {}
2581 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2582   if (!isa<RecordDecl>(D)) {
2583     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2584       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
2585     return false;
2586   }
2587   return true;
2588 }
2589 
2590 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2591   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2592     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2593   return false;
2594 }
2595 
2596 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
2597   return (!LangOpts.CPlusPlus);
2598 }
2599 
2600 bool existsInTarget(const TargetInfo &Target) const override {
2601   const llvm::Triple &T = Target.getTriple(); (void)T;
2602   return true && (T.getArch() == llvm::Triple::bpfel || T.getArch() == llvm::Triple::bpfeb);
2603 }
2604 
2605 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2606   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2607 }
2608 
2609 bool isParamExpr(size_t N) const override {
2610   return false;
2611 }
2612 
2613 static const ParsedAttrInfoBPFPreserveStaticOffset Instance;
2614 };
2615 const ParsedAttrInfoBPFPreserveStaticOffset ParsedAttrInfoBPFPreserveStaticOffset::Instance;
2616 static constexpr ParsedAttrInfo::Spelling BTFDeclTagSpellings[] = {
2617   {AttributeCommonInfo::AS_GNU, "btf_decl_tag"},
2618   {AttributeCommonInfo::AS_CXX11, "clang::btf_decl_tag"},
2619   {AttributeCommonInfo::AS_C23, "clang::btf_decl_tag"},
2620 };
2621 static constexpr const char *BTFDeclTagArgNames[] = {
2622 "BTFDeclTag",};
2623 struct ParsedAttrInfoBTFDeclTag final : public ParsedAttrInfo {
2624   constexpr ParsedAttrInfoBTFDeclTag() : ParsedAttrInfo(
2625     /*AttrKind=*/ParsedAttr::AT_BTFDeclTag,
2626     /*NumArgs=*/1,
2627     /*OptArgs=*/0,
2628     /*NumArgMembers=*/1,
2629     /*HasCustomParsing=*/0,
2630     /*AcceptsExprPack=*/0,
2631     /*IsTargetSpecific=*/0,
2632     /*IsType=*/0,
2633     /*IsStmt=*/0,
2634     /*IsKnownToGCC=*/0,
2635     /*IsSupportedByPragmaAttribute=*/1,
2636     /*Spellings=*/BTFDeclTagSpellings,
2637     /*ArgNames=*/BTFDeclTagArgNames) {}
2638 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2639   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<RecordDecl>(D) && !isa<FieldDecl>(D) && !isa<TypedefNameDecl>(D)) {
2640     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2641       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, structs, unions, classes, non-static data members, and typedefs";
2642     return false;
2643   }
2644   return true;
2645 }
2646 
2647 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2648   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2649     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2650   return false;
2651 }
2652 
2653 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
2654   return (!LangOpts.CPlusPlus);
2655 }
2656 
2657 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2658   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
2659   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2660   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
2661   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
2662   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
2663 }
2664 
2665 bool isParamExpr(size_t N) const override {
2666   return false;
2667 }
2668 
2669 static const ParsedAttrInfoBTFDeclTag Instance;
2670 };
2671 const ParsedAttrInfoBTFDeclTag ParsedAttrInfoBTFDeclTag::Instance;
2672 static constexpr ParsedAttrInfo::Spelling BTFTypeTagSpellings[] = {
2673   {AttributeCommonInfo::AS_GNU, "btf_type_tag"},
2674   {AttributeCommonInfo::AS_CXX11, "clang::btf_type_tag"},
2675   {AttributeCommonInfo::AS_C23, "clang::btf_type_tag"},
2676 };
2677 static constexpr const char *BTFTypeTagArgNames[] = {
2678 "BTFTypeTag",};
2679 struct ParsedAttrInfoBTFTypeTag final : public ParsedAttrInfo {
2680   constexpr ParsedAttrInfoBTFTypeTag() : ParsedAttrInfo(
2681     /*AttrKind=*/ParsedAttr::AT_BTFTypeTag,
2682     /*NumArgs=*/1,
2683     /*OptArgs=*/0,
2684     /*NumArgMembers=*/1,
2685     /*HasCustomParsing=*/0,
2686     /*AcceptsExprPack=*/0,
2687     /*IsTargetSpecific=*/0,
2688     /*IsType=*/1,
2689     /*IsStmt=*/0,
2690     /*IsKnownToGCC=*/0,
2691     /*IsSupportedByPragmaAttribute=*/0,
2692     /*Spellings=*/BTFTypeTagSpellings,
2693     /*ArgNames=*/BTFTypeTagArgNames) {}
2694 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
2695   return (!LangOpts.CPlusPlus);
2696 }
2697 
2698 bool isParamExpr(size_t N) const override {
2699   return false;
2700 }
2701 
2702 static const ParsedAttrInfoBTFTypeTag Instance;
2703 };
2704 const ParsedAttrInfoBTFTypeTag ParsedAttrInfoBTFTypeTag::Instance;
2705 static constexpr ParsedAttrInfo::Spelling BlockingSpellings[] = {
2706   {AttributeCommonInfo::AS_GNU, "blocking"},
2707   {AttributeCommonInfo::AS_CXX11, "clang::blocking"},
2708   {AttributeCommonInfo::AS_C23, "clang::blocking"},
2709 };
2710 struct ParsedAttrInfoBlocking final : public ParsedAttrInfo {
2711   constexpr ParsedAttrInfoBlocking() : ParsedAttrInfo(
2712     /*AttrKind=*/ParsedAttr::AT_Blocking,
2713     /*NumArgs=*/0,
2714     /*OptArgs=*/0,
2715     /*NumArgMembers=*/0,
2716     /*HasCustomParsing=*/0,
2717     /*AcceptsExprPack=*/0,
2718     /*IsTargetSpecific=*/0,
2719     /*IsType=*/1,
2720     /*IsStmt=*/0,
2721     /*IsKnownToGCC=*/0,
2722     /*IsSupportedByPragmaAttribute=*/0,
2723     /*Spellings=*/BlockingSpellings,
2724     /*ArgNames=*/{}) {}
2725 bool isParamExpr(size_t N) const override {
2726   return false;
2727 }
2728 
2729 static const ParsedAttrInfoBlocking Instance;
2730 };
2731 const ParsedAttrInfoBlocking ParsedAttrInfoBlocking::Instance;
2732 static constexpr ParsedAttrInfo::Spelling BlocksSpellings[] = {
2733   {AttributeCommonInfo::AS_GNU, "blocks"},
2734   {AttributeCommonInfo::AS_CXX11, "clang::blocks"},
2735   {AttributeCommonInfo::AS_C23, "clang::blocks"},
2736 };
2737 static constexpr const char *BlocksArgNames[] = {
2738 "Type",};
2739 struct ParsedAttrInfoBlocks final : public ParsedAttrInfo {
2740   constexpr ParsedAttrInfoBlocks() : ParsedAttrInfo(
2741     /*AttrKind=*/ParsedAttr::AT_Blocks,
2742     /*NumArgs=*/1,
2743     /*OptArgs=*/0,
2744     /*NumArgMembers=*/1,
2745     /*HasCustomParsing=*/0,
2746     /*AcceptsExprPack=*/0,
2747     /*IsTargetSpecific=*/0,
2748     /*IsType=*/0,
2749     /*IsStmt=*/0,
2750     /*IsKnownToGCC=*/0,
2751     /*IsSupportedByPragmaAttribute=*/0,
2752     /*Spellings=*/BlocksSpellings,
2753     /*ArgNames=*/BlocksArgNames) {}
2754 bool isParamExpr(size_t N) const override {
2755   return false;
2756 }
2757 
2758 static const ParsedAttrInfoBlocks Instance;
2759 };
2760 const ParsedAttrInfoBlocks ParsedAttrInfoBlocks::Instance;
2761 static constexpr ParsedAttrInfo::Spelling BuiltinAliasSpellings[] = {
2762   {AttributeCommonInfo::AS_CXX11, "clang::builtin_alias"},
2763   {AttributeCommonInfo::AS_C23, "clang::builtin_alias"},
2764   {AttributeCommonInfo::AS_GNU, "clang_builtin_alias"},
2765 };
2766 static constexpr const char *BuiltinAliasArgNames[] = {
2767 "BuiltinName",};
2768 struct ParsedAttrInfoBuiltinAlias final : public ParsedAttrInfo {
2769   constexpr ParsedAttrInfoBuiltinAlias() : ParsedAttrInfo(
2770     /*AttrKind=*/ParsedAttr::AT_BuiltinAlias,
2771     /*NumArgs=*/1,
2772     /*OptArgs=*/0,
2773     /*NumArgMembers=*/1,
2774     /*HasCustomParsing=*/0,
2775     /*AcceptsExprPack=*/0,
2776     /*IsTargetSpecific=*/0,
2777     /*IsType=*/0,
2778     /*IsStmt=*/0,
2779     /*IsKnownToGCC=*/0,
2780     /*IsSupportedByPragmaAttribute=*/1,
2781     /*Spellings=*/BuiltinAliasSpellings,
2782     /*ArgNames=*/BuiltinAliasArgNames) {}
2783 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2784   if (!isa<FunctionDecl>(D)) {
2785     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2786       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2787     return false;
2788   }
2789   return true;
2790 }
2791 
2792 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2793   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2794     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2795   return false;
2796 }
2797 
2798 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
2799   enum Spelling {
2800     CXX11_clang_builtin_alias = 0,
2801     C23_clang_builtin_alias = 1,
2802     GNU_clang_builtin_alias = 2,
2803   SpellingNotCalculated = 15
2804 
2805   };
2806 
2807   unsigned Idx = Attr.getAttributeSpellingListIndex();
2808   switch (Idx) {
2809     default: llvm_unreachable("Unknown spelling list index");
2810     case 0: return CXX11_clang_builtin_alias;
2811     case 1: return C23_clang_builtin_alias;
2812     case 2: return GNU_clang_builtin_alias;
2813   }
2814 }
2815 
2816 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2817   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2818 }
2819 
2820 bool isParamExpr(size_t N) const override {
2821   return false;
2822 }
2823 
2824 static const ParsedAttrInfoBuiltinAlias Instance;
2825 };
2826 const ParsedAttrInfoBuiltinAlias ParsedAttrInfoBuiltinAlias::Instance;
2827 static constexpr ParsedAttrInfo::Spelling CDeclSpellings[] = {
2828   {AttributeCommonInfo::AS_GNU, "cdecl"},
2829   {AttributeCommonInfo::AS_CXX11, "gnu::cdecl"},
2830   {AttributeCommonInfo::AS_C23, "gnu::cdecl"},
2831   {AttributeCommonInfo::AS_Keyword, "__cdecl"},
2832   {AttributeCommonInfo::AS_Keyword, "_cdecl"},
2833 };
2834 struct ParsedAttrInfoCDecl final : public ParsedAttrInfo {
2835   constexpr ParsedAttrInfoCDecl() : ParsedAttrInfo(
2836     /*AttrKind=*/ParsedAttr::AT_CDecl,
2837     /*NumArgs=*/0,
2838     /*OptArgs=*/0,
2839     /*NumArgMembers=*/0,
2840     /*HasCustomParsing=*/0,
2841     /*AcceptsExprPack=*/0,
2842     /*IsTargetSpecific=*/0,
2843     /*IsType=*/1,
2844     /*IsStmt=*/0,
2845     /*IsKnownToGCC=*/1,
2846     /*IsSupportedByPragmaAttribute=*/0,
2847     /*Spellings=*/CDeclSpellings,
2848     /*ArgNames=*/{}) {}
2849 bool isParamExpr(size_t N) const override {
2850   return false;
2851 }
2852 
2853 static const ParsedAttrInfoCDecl Instance;
2854 };
2855 const ParsedAttrInfoCDecl ParsedAttrInfoCDecl::Instance;
2856 static constexpr ParsedAttrInfo::Spelling CFAuditedTransferSpellings[] = {
2857   {AttributeCommonInfo::AS_GNU, "cf_audited_transfer"},
2858   {AttributeCommonInfo::AS_CXX11, "clang::cf_audited_transfer"},
2859   {AttributeCommonInfo::AS_C23, "clang::cf_audited_transfer"},
2860 };
2861 struct ParsedAttrInfoCFAuditedTransfer final : public ParsedAttrInfo {
2862   constexpr ParsedAttrInfoCFAuditedTransfer() : ParsedAttrInfo(
2863     /*AttrKind=*/ParsedAttr::AT_CFAuditedTransfer,
2864     /*NumArgs=*/0,
2865     /*OptArgs=*/0,
2866     /*NumArgMembers=*/0,
2867     /*HasCustomParsing=*/0,
2868     /*AcceptsExprPack=*/0,
2869     /*IsTargetSpecific=*/0,
2870     /*IsType=*/0,
2871     /*IsStmt=*/0,
2872     /*IsKnownToGCC=*/0,
2873     /*IsSupportedByPragmaAttribute=*/1,
2874     /*Spellings=*/CFAuditedTransferSpellings,
2875     /*ArgNames=*/{}) {}
2876 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2877   if (!isa<FunctionDecl>(D)) {
2878     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
2879       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2880     return false;
2881   }
2882   return true;
2883 }
2884 
2885 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2886   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2887     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2888   return false;
2889 }
2890 
2891   using ParsedAttrInfo::diagMutualExclusion;
2892 
2893   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
2894     if (const auto *A = D->getAttr<CFUnknownTransferAttr>()) {
2895       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
2896       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
2897 return false;
2898     }
2899     return true;
2900   }
2901 
2902 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2903   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
2904 }
2905 
2906 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
2907   D->addAttr(::new (S.Context) CFAuditedTransferAttr(S.Context, Attr));
2908   return AttributeApplied;
2909 }
2910 
2911 bool isParamExpr(size_t N) const override {
2912   return false;
2913 }
2914 
2915 static const ParsedAttrInfoCFAuditedTransfer Instance;
2916 };
2917 const ParsedAttrInfoCFAuditedTransfer ParsedAttrInfoCFAuditedTransfer::Instance;
2918 static constexpr ParsedAttrInfo::Spelling CFConsumedSpellings[] = {
2919   {AttributeCommonInfo::AS_GNU, "cf_consumed"},
2920   {AttributeCommonInfo::AS_CXX11, "clang::cf_consumed"},
2921   {AttributeCommonInfo::AS_C23, "clang::cf_consumed"},
2922 };
2923 struct ParsedAttrInfoCFConsumed final : public ParsedAttrInfo {
2924   constexpr ParsedAttrInfoCFConsumed() : ParsedAttrInfo(
2925     /*AttrKind=*/ParsedAttr::AT_CFConsumed,
2926     /*NumArgs=*/0,
2927     /*OptArgs=*/0,
2928     /*NumArgMembers=*/0,
2929     /*HasCustomParsing=*/0,
2930     /*AcceptsExprPack=*/0,
2931     /*IsTargetSpecific=*/0,
2932     /*IsType=*/0,
2933     /*IsStmt=*/0,
2934     /*IsKnownToGCC=*/0,
2935     /*IsSupportedByPragmaAttribute=*/1,
2936     /*Spellings=*/CFConsumedSpellings,
2937     /*ArgNames=*/{}) {}
2938 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2939   if (!isa<ParmVarDecl>(D)) {
2940     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2941       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
2942     return false;
2943   }
2944   return true;
2945 }
2946 
2947 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2948   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2949     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2950   return false;
2951 }
2952 
2953 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
2954   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
2955 }
2956 
2957 bool isParamExpr(size_t N) const override {
2958   return false;
2959 }
2960 
2961 static const ParsedAttrInfoCFConsumed Instance;
2962 };
2963 const ParsedAttrInfoCFConsumed ParsedAttrInfoCFConsumed::Instance;
2964 static constexpr ParsedAttrInfo::Spelling CFGuardSpellings[] = {
2965   {AttributeCommonInfo::AS_Declspec, "guard"},
2966   {AttributeCommonInfo::AS_GNU, "guard"},
2967   {AttributeCommonInfo::AS_CXX11, "clang::guard"},
2968   {AttributeCommonInfo::AS_C23, "clang::guard"},
2969 };
2970 static constexpr const char *CFGuardArgNames[] = {
2971 "Guard",};
2972 struct ParsedAttrInfoCFGuard final : public ParsedAttrInfo {
2973   constexpr ParsedAttrInfoCFGuard() : ParsedAttrInfo(
2974     /*AttrKind=*/ParsedAttr::AT_CFGuard,
2975     /*NumArgs=*/1,
2976     /*OptArgs=*/0,
2977     /*NumArgMembers=*/1,
2978     /*HasCustomParsing=*/0,
2979     /*AcceptsExprPack=*/0,
2980     /*IsTargetSpecific=*/1,
2981     /*IsType=*/0,
2982     /*IsStmt=*/0,
2983     /*IsKnownToGCC=*/0,
2984     /*IsSupportedByPragmaAttribute=*/1,
2985     /*Spellings=*/CFGuardSpellings,
2986     /*ArgNames=*/CFGuardArgNames) {}
2987 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
2988   if (!isa<FunctionDecl>(D)) {
2989     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
2990       << Attr << Attr.isRegularKeywordAttribute() << "functions";
2991     return false;
2992   }
2993   return true;
2994 }
2995 
2996 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
2997   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
2998     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
2999   return false;
3000 }
3001 
3002 bool existsInTarget(const TargetInfo &Target) const override {
3003   const llvm::Triple &T = Target.getTriple(); (void)T;
3004   return true && (T.getOS() == llvm::Triple::Win32);
3005 }
3006 
3007 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3008   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3009 }
3010 
3011 bool isParamExpr(size_t N) const override {
3012   return false;
3013 }
3014 
3015 static const ParsedAttrInfoCFGuard Instance;
3016 };
3017 const ParsedAttrInfoCFGuard ParsedAttrInfoCFGuard::Instance;
3018 static constexpr ParsedAttrInfo::Spelling CFICanonicalJumpTableSpellings[] = {
3019   {AttributeCommonInfo::AS_GNU, "cfi_canonical_jump_table"},
3020   {AttributeCommonInfo::AS_CXX11, "clang::cfi_canonical_jump_table"},
3021   {AttributeCommonInfo::AS_C23, "clang::cfi_canonical_jump_table"},
3022 };
3023 struct ParsedAttrInfoCFICanonicalJumpTable final : public ParsedAttrInfo {
3024   constexpr ParsedAttrInfoCFICanonicalJumpTable() : ParsedAttrInfo(
3025     /*AttrKind=*/ParsedAttr::AT_CFICanonicalJumpTable,
3026     /*NumArgs=*/0,
3027     /*OptArgs=*/0,
3028     /*NumArgMembers=*/0,
3029     /*HasCustomParsing=*/0,
3030     /*AcceptsExprPack=*/0,
3031     /*IsTargetSpecific=*/0,
3032     /*IsType=*/0,
3033     /*IsStmt=*/0,
3034     /*IsKnownToGCC=*/0,
3035     /*IsSupportedByPragmaAttribute=*/1,
3036     /*Spellings=*/CFICanonicalJumpTableSpellings,
3037     /*ArgNames=*/{}) {}
3038 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3039   if (!isa<FunctionDecl>(D)) {
3040     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
3041       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3042     return false;
3043   }
3044   return true;
3045 }
3046 
3047 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3048   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3049     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3050   return false;
3051 }
3052 
3053 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3054   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3055 }
3056 
3057 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
3058   D->addAttr(::new (S.Context) CFICanonicalJumpTableAttr(S.Context, Attr));
3059   return AttributeApplied;
3060 }
3061 
3062 bool isParamExpr(size_t N) const override {
3063   return false;
3064 }
3065 
3066 static const ParsedAttrInfoCFICanonicalJumpTable Instance;
3067 };
3068 const ParsedAttrInfoCFICanonicalJumpTable ParsedAttrInfoCFICanonicalJumpTable::Instance;
3069 static constexpr ParsedAttrInfo::Spelling CFReturnsNotRetainedSpellings[] = {
3070   {AttributeCommonInfo::AS_GNU, "cf_returns_not_retained"},
3071   {AttributeCommonInfo::AS_CXX11, "clang::cf_returns_not_retained"},
3072   {AttributeCommonInfo::AS_C23, "clang::cf_returns_not_retained"},
3073 };
3074 struct ParsedAttrInfoCFReturnsNotRetained final : public ParsedAttrInfo {
3075   constexpr ParsedAttrInfoCFReturnsNotRetained() : ParsedAttrInfo(
3076     /*AttrKind=*/ParsedAttr::AT_CFReturnsNotRetained,
3077     /*NumArgs=*/0,
3078     /*OptArgs=*/0,
3079     /*NumArgMembers=*/0,
3080     /*HasCustomParsing=*/0,
3081     /*AcceptsExprPack=*/0,
3082     /*IsTargetSpecific=*/0,
3083     /*IsType=*/0,
3084     /*IsStmt=*/0,
3085     /*IsKnownToGCC=*/0,
3086     /*IsSupportedByPragmaAttribute=*/0,
3087     /*Spellings=*/CFReturnsNotRetainedSpellings,
3088     /*ArgNames=*/{}) {}
3089 bool isParamExpr(size_t N) const override {
3090   return false;
3091 }
3092 
3093 static const ParsedAttrInfoCFReturnsNotRetained Instance;
3094 };
3095 const ParsedAttrInfoCFReturnsNotRetained ParsedAttrInfoCFReturnsNotRetained::Instance;
3096 static constexpr ParsedAttrInfo::Spelling CFReturnsRetainedSpellings[] = {
3097   {AttributeCommonInfo::AS_GNU, "cf_returns_retained"},
3098   {AttributeCommonInfo::AS_CXX11, "clang::cf_returns_retained"},
3099   {AttributeCommonInfo::AS_C23, "clang::cf_returns_retained"},
3100 };
3101 struct ParsedAttrInfoCFReturnsRetained final : public ParsedAttrInfo {
3102   constexpr ParsedAttrInfoCFReturnsRetained() : ParsedAttrInfo(
3103     /*AttrKind=*/ParsedAttr::AT_CFReturnsRetained,
3104     /*NumArgs=*/0,
3105     /*OptArgs=*/0,
3106     /*NumArgMembers=*/0,
3107     /*HasCustomParsing=*/0,
3108     /*AcceptsExprPack=*/0,
3109     /*IsTargetSpecific=*/0,
3110     /*IsType=*/0,
3111     /*IsStmt=*/0,
3112     /*IsKnownToGCC=*/0,
3113     /*IsSupportedByPragmaAttribute=*/0,
3114     /*Spellings=*/CFReturnsRetainedSpellings,
3115     /*ArgNames=*/{}) {}
3116 bool isParamExpr(size_t N) const override {
3117   return false;
3118 }
3119 
3120 static const ParsedAttrInfoCFReturnsRetained Instance;
3121 };
3122 const ParsedAttrInfoCFReturnsRetained ParsedAttrInfoCFReturnsRetained::Instance;
3123 static constexpr ParsedAttrInfo::Spelling CFUnknownTransferSpellings[] = {
3124   {AttributeCommonInfo::AS_GNU, "cf_unknown_transfer"},
3125   {AttributeCommonInfo::AS_CXX11, "clang::cf_unknown_transfer"},
3126   {AttributeCommonInfo::AS_C23, "clang::cf_unknown_transfer"},
3127 };
3128 struct ParsedAttrInfoCFUnknownTransfer final : public ParsedAttrInfo {
3129   constexpr ParsedAttrInfoCFUnknownTransfer() : ParsedAttrInfo(
3130     /*AttrKind=*/ParsedAttr::AT_CFUnknownTransfer,
3131     /*NumArgs=*/0,
3132     /*OptArgs=*/0,
3133     /*NumArgMembers=*/0,
3134     /*HasCustomParsing=*/0,
3135     /*AcceptsExprPack=*/0,
3136     /*IsTargetSpecific=*/0,
3137     /*IsType=*/0,
3138     /*IsStmt=*/0,
3139     /*IsKnownToGCC=*/0,
3140     /*IsSupportedByPragmaAttribute=*/1,
3141     /*Spellings=*/CFUnknownTransferSpellings,
3142     /*ArgNames=*/{}) {}
3143 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3144   if (!isa<FunctionDecl>(D)) {
3145     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
3146       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3147     return false;
3148   }
3149   return true;
3150 }
3151 
3152 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3153   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3154     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3155   return false;
3156 }
3157 
3158   using ParsedAttrInfo::diagMutualExclusion;
3159 
3160   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3161     if (const auto *A = D->getAttr<CFAuditedTransferAttr>()) {
3162       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3163       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3164 return false;
3165     }
3166     return true;
3167   }
3168 
3169 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3170   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3171 }
3172 
3173 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
3174   D->addAttr(::new (S.Context) CFUnknownTransferAttr(S.Context, Attr));
3175   return AttributeApplied;
3176 }
3177 
3178 bool isParamExpr(size_t N) const override {
3179   return false;
3180 }
3181 
3182 static const ParsedAttrInfoCFUnknownTransfer Instance;
3183 };
3184 const ParsedAttrInfoCFUnknownTransfer ParsedAttrInfoCFUnknownTransfer::Instance;
3185 static constexpr ParsedAttrInfo::Spelling CPUDispatchSpellings[] = {
3186   {AttributeCommonInfo::AS_GNU, "cpu_dispatch"},
3187   {AttributeCommonInfo::AS_CXX11, "clang::cpu_dispatch"},
3188   {AttributeCommonInfo::AS_C23, "clang::cpu_dispatch"},
3189   {AttributeCommonInfo::AS_Declspec, "cpu_dispatch"},
3190 };
3191 static constexpr const char *CPUDispatchArgNames[] = {
3192 "Cpus...",};
3193 struct ParsedAttrInfoCPUDispatch final : public ParsedAttrInfo {
3194   constexpr ParsedAttrInfoCPUDispatch() : ParsedAttrInfo(
3195     /*AttrKind=*/ParsedAttr::AT_CPUDispatch,
3196     /*NumArgs=*/0,
3197     /*OptArgs=*/15,
3198     /*NumArgMembers=*/1,
3199     /*HasCustomParsing=*/0,
3200     /*AcceptsExprPack=*/0,
3201     /*IsTargetSpecific=*/0,
3202     /*IsType=*/0,
3203     /*IsStmt=*/0,
3204     /*IsKnownToGCC=*/0,
3205     /*IsSupportedByPragmaAttribute=*/1,
3206     /*Spellings=*/CPUDispatchSpellings,
3207     /*ArgNames=*/CPUDispatchArgNames) {}
3208 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3209   if (!isa<FunctionDecl>(D)) {
3210     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3211       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3212     return false;
3213   }
3214   return true;
3215 }
3216 
3217 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3218   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3219     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3220   return false;
3221 }
3222 
3223   using ParsedAttrInfo::diagMutualExclusion;
3224 
3225   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3226     if (const auto *A = D->getAttr<TargetClonesAttr>()) {
3227       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3228       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3229 return false;
3230     }
3231     if (const auto *A = D->getAttr<TargetVersionAttr>()) {
3232       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3233       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3234 return false;
3235     }
3236     if (const auto *A = D->getAttr<TargetAttr>()) {
3237       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3238       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3239 return false;
3240     }
3241     if (const auto *A = D->getAttr<CPUSpecificAttr>()) {
3242       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3243       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3244 return false;
3245     }
3246     return true;
3247   }
3248 
3249 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3250   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3251 }
3252 
3253 bool isParamExpr(size_t N) const override {
3254   return false;
3255 }
3256 
3257 static const ParsedAttrInfoCPUDispatch Instance;
3258 };
3259 const ParsedAttrInfoCPUDispatch ParsedAttrInfoCPUDispatch::Instance;
3260 static constexpr ParsedAttrInfo::Spelling CPUSpecificSpellings[] = {
3261   {AttributeCommonInfo::AS_GNU, "cpu_specific"},
3262   {AttributeCommonInfo::AS_CXX11, "clang::cpu_specific"},
3263   {AttributeCommonInfo::AS_C23, "clang::cpu_specific"},
3264   {AttributeCommonInfo::AS_Declspec, "cpu_specific"},
3265 };
3266 static constexpr const char *CPUSpecificArgNames[] = {
3267 "Cpus...",};
3268 struct ParsedAttrInfoCPUSpecific final : public ParsedAttrInfo {
3269   constexpr ParsedAttrInfoCPUSpecific() : ParsedAttrInfo(
3270     /*AttrKind=*/ParsedAttr::AT_CPUSpecific,
3271     /*NumArgs=*/0,
3272     /*OptArgs=*/15,
3273     /*NumArgMembers=*/1,
3274     /*HasCustomParsing=*/0,
3275     /*AcceptsExprPack=*/0,
3276     /*IsTargetSpecific=*/0,
3277     /*IsType=*/0,
3278     /*IsStmt=*/0,
3279     /*IsKnownToGCC=*/0,
3280     /*IsSupportedByPragmaAttribute=*/1,
3281     /*Spellings=*/CPUSpecificSpellings,
3282     /*ArgNames=*/CPUSpecificArgNames) {}
3283 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3284   if (!isa<FunctionDecl>(D)) {
3285     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3286       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3287     return false;
3288   }
3289   return true;
3290 }
3291 
3292 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3293   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3294     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3295   return false;
3296 }
3297 
3298   using ParsedAttrInfo::diagMutualExclusion;
3299 
3300   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3301     if (const auto *A = D->getAttr<TargetClonesAttr>()) {
3302       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3303       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3304 return false;
3305     }
3306     if (const auto *A = D->getAttr<TargetVersionAttr>()) {
3307       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3308       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3309 return false;
3310     }
3311     if (const auto *A = D->getAttr<TargetAttr>()) {
3312       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3313       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3314 return false;
3315     }
3316     if (const auto *A = D->getAttr<CPUDispatchAttr>()) {
3317       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3318       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3319 return false;
3320     }
3321     return true;
3322   }
3323 
3324 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3325   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3326 }
3327 
3328 bool isParamExpr(size_t N) const override {
3329   return false;
3330 }
3331 
3332 static const ParsedAttrInfoCPUSpecific Instance;
3333 };
3334 const ParsedAttrInfoCPUSpecific ParsedAttrInfoCPUSpecific::Instance;
3335 static constexpr ParsedAttrInfo::Spelling CUDAConstantSpellings[] = {
3336   {AttributeCommonInfo::AS_GNU, "constant"},
3337   {AttributeCommonInfo::AS_Declspec, "__constant__"},
3338 };
3339 struct ParsedAttrInfoCUDAConstant final : public ParsedAttrInfo {
3340   constexpr ParsedAttrInfoCUDAConstant() : ParsedAttrInfo(
3341     /*AttrKind=*/ParsedAttr::AT_CUDAConstant,
3342     /*NumArgs=*/0,
3343     /*OptArgs=*/0,
3344     /*NumArgMembers=*/0,
3345     /*HasCustomParsing=*/0,
3346     /*AcceptsExprPack=*/0,
3347     /*IsTargetSpecific=*/0,
3348     /*IsType=*/0,
3349     /*IsStmt=*/0,
3350     /*IsKnownToGCC=*/0,
3351     /*IsSupportedByPragmaAttribute=*/1,
3352     /*Spellings=*/CUDAConstantSpellings,
3353     /*ArgNames=*/{}) {}
3354 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3355   if (!isa<VarDecl>(D)) {
3356     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3357       << Attr << Attr.isRegularKeywordAttribute() << "variables";
3358     return false;
3359   }
3360   return true;
3361 }
3362 
3363 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3364   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3365     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3366   return false;
3367 }
3368 
3369   using ParsedAttrInfo::diagMutualExclusion;
3370 
3371   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3372     if (const auto *A = D->getAttr<CUDASharedAttr>()) {
3373       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3374       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3375 return false;
3376     }
3377     if (const auto *A = D->getAttr<HIPManagedAttr>()) {
3378       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3379       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3380 return false;
3381     }
3382     return true;
3383   }
3384 
3385 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3386   return LangOpts.CUDA;
3387 }
3388 
3389 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3390   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
3391 }
3392 
3393 bool isParamExpr(size_t N) const override {
3394   return false;
3395 }
3396 
3397 static const ParsedAttrInfoCUDAConstant Instance;
3398 };
3399 const ParsedAttrInfoCUDAConstant ParsedAttrInfoCUDAConstant::Instance;
3400 static constexpr ParsedAttrInfo::Spelling CUDADeviceSpellings[] = {
3401   {AttributeCommonInfo::AS_GNU, "device"},
3402   {AttributeCommonInfo::AS_Declspec, "__device__"},
3403 };
3404 struct ParsedAttrInfoCUDADevice final : public ParsedAttrInfo {
3405   constexpr ParsedAttrInfoCUDADevice() : ParsedAttrInfo(
3406     /*AttrKind=*/ParsedAttr::AT_CUDADevice,
3407     /*NumArgs=*/0,
3408     /*OptArgs=*/0,
3409     /*NumArgMembers=*/0,
3410     /*HasCustomParsing=*/0,
3411     /*AcceptsExprPack=*/0,
3412     /*IsTargetSpecific=*/0,
3413     /*IsType=*/0,
3414     /*IsStmt=*/0,
3415     /*IsKnownToGCC=*/0,
3416     /*IsSupportedByPragmaAttribute=*/1,
3417     /*Spellings=*/CUDADeviceSpellings,
3418     /*ArgNames=*/{}) {}
3419 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3420   if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
3421     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3422       << Attr << Attr.isRegularKeywordAttribute() << "functions and variables";
3423     return false;
3424   }
3425   return true;
3426 }
3427 
3428 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3429   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3430     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3431   return false;
3432 }
3433 
3434   using ParsedAttrInfo::diagMutualExclusion;
3435 
3436   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3437     if (const auto *A = D->getAttr<CUDAGlobalAttr>()) {
3438       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3439       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3440 return false;
3441     }
3442     return true;
3443   }
3444 
3445 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3446   return LangOpts.CUDA;
3447 }
3448 
3449 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3450   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3451   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
3452 }
3453 
3454 bool isParamExpr(size_t N) const override {
3455   return false;
3456 }
3457 
3458 static const ParsedAttrInfoCUDADevice Instance;
3459 };
3460 const ParsedAttrInfoCUDADevice ParsedAttrInfoCUDADevice::Instance;
3461 static constexpr ParsedAttrInfo::Spelling CUDADeviceBuiltinSurfaceTypeSpellings[] = {
3462   {AttributeCommonInfo::AS_GNU, "device_builtin_surface_type"},
3463   {AttributeCommonInfo::AS_Declspec, "__device_builtin_surface_type__"},
3464 };
3465 struct ParsedAttrInfoCUDADeviceBuiltinSurfaceType final : public ParsedAttrInfo {
3466   constexpr ParsedAttrInfoCUDADeviceBuiltinSurfaceType() : ParsedAttrInfo(
3467     /*AttrKind=*/ParsedAttr::AT_CUDADeviceBuiltinSurfaceType,
3468     /*NumArgs=*/0,
3469     /*OptArgs=*/0,
3470     /*NumArgMembers=*/0,
3471     /*HasCustomParsing=*/0,
3472     /*AcceptsExprPack=*/0,
3473     /*IsTargetSpecific=*/0,
3474     /*IsType=*/0,
3475     /*IsStmt=*/0,
3476     /*IsKnownToGCC=*/0,
3477     /*IsSupportedByPragmaAttribute=*/1,
3478     /*Spellings=*/CUDADeviceBuiltinSurfaceTypeSpellings,
3479     /*ArgNames=*/{}) {}
3480 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3481   if (!isa<CXXRecordDecl>(D)) {
3482     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3483       << Attr << Attr.isRegularKeywordAttribute() << "classes";
3484     return false;
3485   }
3486   return true;
3487 }
3488 
3489 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3490   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3491     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3492   return false;
3493 }
3494 
3495   using ParsedAttrInfo::diagMutualExclusion;
3496 
3497   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3498     if (const auto *A = D->getAttr<CUDADeviceBuiltinTextureTypeAttr>()) {
3499       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3500       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3501 return false;
3502     }
3503     return true;
3504   }
3505 
3506 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3507   return LangOpts.CUDA;
3508 }
3509 
3510 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3511   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
3512 }
3513 
3514 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
3515   D->addAttr(::new (S.Context) CUDADeviceBuiltinSurfaceTypeAttr(S.Context, Attr));
3516   return AttributeApplied;
3517 }
3518 
3519 bool isParamExpr(size_t N) const override {
3520   return false;
3521 }
3522 
3523 static const ParsedAttrInfoCUDADeviceBuiltinSurfaceType Instance;
3524 };
3525 const ParsedAttrInfoCUDADeviceBuiltinSurfaceType ParsedAttrInfoCUDADeviceBuiltinSurfaceType::Instance;
3526 static constexpr ParsedAttrInfo::Spelling CUDADeviceBuiltinTextureTypeSpellings[] = {
3527   {AttributeCommonInfo::AS_GNU, "device_builtin_texture_type"},
3528   {AttributeCommonInfo::AS_Declspec, "__device_builtin_texture_type__"},
3529 };
3530 struct ParsedAttrInfoCUDADeviceBuiltinTextureType final : public ParsedAttrInfo {
3531   constexpr ParsedAttrInfoCUDADeviceBuiltinTextureType() : ParsedAttrInfo(
3532     /*AttrKind=*/ParsedAttr::AT_CUDADeviceBuiltinTextureType,
3533     /*NumArgs=*/0,
3534     /*OptArgs=*/0,
3535     /*NumArgMembers=*/0,
3536     /*HasCustomParsing=*/0,
3537     /*AcceptsExprPack=*/0,
3538     /*IsTargetSpecific=*/0,
3539     /*IsType=*/0,
3540     /*IsStmt=*/0,
3541     /*IsKnownToGCC=*/0,
3542     /*IsSupportedByPragmaAttribute=*/1,
3543     /*Spellings=*/CUDADeviceBuiltinTextureTypeSpellings,
3544     /*ArgNames=*/{}) {}
3545 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3546   if (!isa<CXXRecordDecl>(D)) {
3547     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3548       << Attr << Attr.isRegularKeywordAttribute() << "classes";
3549     return false;
3550   }
3551   return true;
3552 }
3553 
3554 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3555   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3556     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3557   return false;
3558 }
3559 
3560   using ParsedAttrInfo::diagMutualExclusion;
3561 
3562   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3563     if (const auto *A = D->getAttr<CUDADeviceBuiltinSurfaceTypeAttr>()) {
3564       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3565       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3566 return false;
3567     }
3568     return true;
3569   }
3570 
3571 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3572   return LangOpts.CUDA;
3573 }
3574 
3575 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3576   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
3577 }
3578 
3579 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
3580   D->addAttr(::new (S.Context) CUDADeviceBuiltinTextureTypeAttr(S.Context, Attr));
3581   return AttributeApplied;
3582 }
3583 
3584 bool isParamExpr(size_t N) const override {
3585   return false;
3586 }
3587 
3588 static const ParsedAttrInfoCUDADeviceBuiltinTextureType Instance;
3589 };
3590 const ParsedAttrInfoCUDADeviceBuiltinTextureType ParsedAttrInfoCUDADeviceBuiltinTextureType::Instance;
3591 static constexpr ParsedAttrInfo::Spelling CUDAGlobalSpellings[] = {
3592   {AttributeCommonInfo::AS_GNU, "global"},
3593   {AttributeCommonInfo::AS_Declspec, "__global__"},
3594 };
3595 struct ParsedAttrInfoCUDAGlobal final : public ParsedAttrInfo {
3596   constexpr ParsedAttrInfoCUDAGlobal() : ParsedAttrInfo(
3597     /*AttrKind=*/ParsedAttr::AT_CUDAGlobal,
3598     /*NumArgs=*/0,
3599     /*OptArgs=*/0,
3600     /*NumArgMembers=*/0,
3601     /*HasCustomParsing=*/0,
3602     /*AcceptsExprPack=*/0,
3603     /*IsTargetSpecific=*/0,
3604     /*IsType=*/0,
3605     /*IsStmt=*/0,
3606     /*IsKnownToGCC=*/0,
3607     /*IsSupportedByPragmaAttribute=*/1,
3608     /*Spellings=*/CUDAGlobalSpellings,
3609     /*ArgNames=*/{}) {}
3610 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3611   if (!isa<FunctionDecl>(D)) {
3612     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3613       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3614     return false;
3615   }
3616   return true;
3617 }
3618 
3619 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3620   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3621     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3622   return false;
3623 }
3624 
3625   using ParsedAttrInfo::diagMutualExclusion;
3626 
3627   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3628     if (const auto *A = D->getAttr<CUDADeviceAttr>()) {
3629       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3630       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3631 return false;
3632     }
3633     if (const auto *A = D->getAttr<CUDAHostAttr>()) {
3634       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3635       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3636 return false;
3637     }
3638     return true;
3639   }
3640 
3641 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3642   return LangOpts.CUDA;
3643 }
3644 
3645 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3646   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3647 }
3648 
3649 bool isParamExpr(size_t N) const override {
3650   return false;
3651 }
3652 
3653 static const ParsedAttrInfoCUDAGlobal Instance;
3654 };
3655 const ParsedAttrInfoCUDAGlobal ParsedAttrInfoCUDAGlobal::Instance;
3656 static constexpr ParsedAttrInfo::Spelling CUDAGridConstantSpellings[] = {
3657   {AttributeCommonInfo::AS_GNU, "grid_constant"},
3658   {AttributeCommonInfo::AS_Declspec, "__grid_constant__"},
3659 };
3660 struct ParsedAttrInfoCUDAGridConstant final : public ParsedAttrInfo {
3661   constexpr ParsedAttrInfoCUDAGridConstant() : ParsedAttrInfo(
3662     /*AttrKind=*/ParsedAttr::AT_CUDAGridConstant,
3663     /*NumArgs=*/0,
3664     /*OptArgs=*/0,
3665     /*NumArgMembers=*/0,
3666     /*HasCustomParsing=*/0,
3667     /*AcceptsExprPack=*/0,
3668     /*IsTargetSpecific=*/0,
3669     /*IsType=*/0,
3670     /*IsStmt=*/0,
3671     /*IsKnownToGCC=*/0,
3672     /*IsSupportedByPragmaAttribute=*/1,
3673     /*Spellings=*/CUDAGridConstantSpellings,
3674     /*ArgNames=*/{}) {}
3675 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3676   if (!isa<ParmVarDecl>(D)) {
3677     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3678       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
3679     return false;
3680   }
3681   return true;
3682 }
3683 
3684 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3685   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3686     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3687   return false;
3688 }
3689 
3690 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3691   return LangOpts.CUDA;
3692 }
3693 
3694 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3695   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
3696 }
3697 
3698 bool isParamExpr(size_t N) const override {
3699   return false;
3700 }
3701 
3702 static const ParsedAttrInfoCUDAGridConstant Instance;
3703 };
3704 const ParsedAttrInfoCUDAGridConstant ParsedAttrInfoCUDAGridConstant::Instance;
3705 static constexpr ParsedAttrInfo::Spelling CUDAHostSpellings[] = {
3706   {AttributeCommonInfo::AS_GNU, "host"},
3707   {AttributeCommonInfo::AS_Declspec, "__host__"},
3708 };
3709 struct ParsedAttrInfoCUDAHost final : public ParsedAttrInfo {
3710   constexpr ParsedAttrInfoCUDAHost() : ParsedAttrInfo(
3711     /*AttrKind=*/ParsedAttr::AT_CUDAHost,
3712     /*NumArgs=*/0,
3713     /*OptArgs=*/0,
3714     /*NumArgMembers=*/0,
3715     /*HasCustomParsing=*/0,
3716     /*AcceptsExprPack=*/0,
3717     /*IsTargetSpecific=*/0,
3718     /*IsType=*/0,
3719     /*IsStmt=*/0,
3720     /*IsKnownToGCC=*/0,
3721     /*IsSupportedByPragmaAttribute=*/1,
3722     /*Spellings=*/CUDAHostSpellings,
3723     /*ArgNames=*/{}) {}
3724 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3725   if (!isa<FunctionDecl>(D)) {
3726     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3727       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3728     return false;
3729   }
3730   return true;
3731 }
3732 
3733 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3734   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3735     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3736   return false;
3737 }
3738 
3739   using ParsedAttrInfo::diagMutualExclusion;
3740 
3741   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3742     if (const auto *A = D->getAttr<CUDAGlobalAttr>()) {
3743       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3744       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3745 return false;
3746     }
3747     return true;
3748   }
3749 
3750 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3751   return LangOpts.CUDA;
3752 }
3753 
3754 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3755   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3756 }
3757 
3758 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
3759   D->addAttr(::new (S.Context) CUDAHostAttr(S.Context, Attr));
3760   return AttributeApplied;
3761 }
3762 
3763 bool isParamExpr(size_t N) const override {
3764   return false;
3765 }
3766 
3767 static const ParsedAttrInfoCUDAHost Instance;
3768 };
3769 const ParsedAttrInfoCUDAHost ParsedAttrInfoCUDAHost::Instance;
3770 struct ParsedAttrInfoCUDAInvalidTarget final : public ParsedAttrInfo {
3771   constexpr ParsedAttrInfoCUDAInvalidTarget() : ParsedAttrInfo(
3772     /*AttrKind=*/ParsedAttr::AT_CUDAInvalidTarget,
3773     /*NumArgs=*/0,
3774     /*OptArgs=*/0,
3775     /*NumArgMembers=*/0,
3776     /*HasCustomParsing=*/0,
3777     /*AcceptsExprPack=*/0,
3778     /*IsTargetSpecific=*/0,
3779     /*IsType=*/0,
3780     /*IsStmt=*/0,
3781     /*IsKnownToGCC=*/0,
3782     /*IsSupportedByPragmaAttribute=*/0,
3783     /*Spellings=*/{},
3784     /*ArgNames=*/{}) {}
3785 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3786   if (!isa<FunctionDecl>(D)) {
3787     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3788       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3789     return false;
3790   }
3791   return true;
3792 }
3793 
3794 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3795   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3796     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3797   return false;
3798 }
3799 
3800 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3801   return LangOpts.CUDA;
3802 }
3803 
3804 bool isParamExpr(size_t N) const override {
3805   return false;
3806 }
3807 
3808 static const ParsedAttrInfoCUDAInvalidTarget Instance;
3809 };
3810 const ParsedAttrInfoCUDAInvalidTarget ParsedAttrInfoCUDAInvalidTarget::Instance;
3811 static constexpr ParsedAttrInfo::Spelling CUDALaunchBoundsSpellings[] = {
3812   {AttributeCommonInfo::AS_GNU, "launch_bounds"},
3813   {AttributeCommonInfo::AS_Declspec, "__launch_bounds__"},
3814 };
3815 static constexpr const char *CUDALaunchBoundsArgNames[] = {
3816 "MaxThreads","MinBlocks","MaxBlocks",};
3817 struct ParsedAttrInfoCUDALaunchBounds final : public ParsedAttrInfo {
3818   constexpr ParsedAttrInfoCUDALaunchBounds() : ParsedAttrInfo(
3819     /*AttrKind=*/ParsedAttr::AT_CUDALaunchBounds,
3820     /*NumArgs=*/1,
3821     /*OptArgs=*/2,
3822     /*NumArgMembers=*/3,
3823     /*HasCustomParsing=*/0,
3824     /*AcceptsExprPack=*/0,
3825     /*IsTargetSpecific=*/0,
3826     /*IsType=*/0,
3827     /*IsStmt=*/0,
3828     /*IsKnownToGCC=*/0,
3829     /*IsSupportedByPragmaAttribute=*/1,
3830     /*Spellings=*/CUDALaunchBoundsSpellings,
3831     /*ArgNames=*/CUDALaunchBoundsArgNames) {}
3832 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3833   if (!isa<ObjCMethodDecl>(D) && !isFunctionLike(D)) {
3834     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3835       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, functions, and function pointers";
3836     return false;
3837   }
3838   return true;
3839 }
3840 
3841 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3842   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3843     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3844   return false;
3845 }
3846 
3847 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3848   return LangOpts.CUDA;
3849 }
3850 
3851 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3852   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
3853   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
3854 }
3855 
3856 bool isParamExpr(size_t N) const override {
3857   return (N == 0) || (N == 1) || (N == 2) || false;
3858 }
3859 
3860 static const ParsedAttrInfoCUDALaunchBounds Instance;
3861 };
3862 const ParsedAttrInfoCUDALaunchBounds ParsedAttrInfoCUDALaunchBounds::Instance;
3863 static constexpr ParsedAttrInfo::Spelling CUDASharedSpellings[] = {
3864   {AttributeCommonInfo::AS_GNU, "shared"},
3865   {AttributeCommonInfo::AS_Declspec, "__shared__"},
3866 };
3867 struct ParsedAttrInfoCUDAShared final : public ParsedAttrInfo {
3868   constexpr ParsedAttrInfoCUDAShared() : ParsedAttrInfo(
3869     /*AttrKind=*/ParsedAttr::AT_CUDAShared,
3870     /*NumArgs=*/0,
3871     /*OptArgs=*/0,
3872     /*NumArgMembers=*/0,
3873     /*HasCustomParsing=*/0,
3874     /*AcceptsExprPack=*/0,
3875     /*IsTargetSpecific=*/0,
3876     /*IsType=*/0,
3877     /*IsStmt=*/0,
3878     /*IsKnownToGCC=*/0,
3879     /*IsSupportedByPragmaAttribute=*/1,
3880     /*Spellings=*/CUDASharedSpellings,
3881     /*ArgNames=*/{}) {}
3882 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3883   if (!isa<VarDecl>(D)) {
3884     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3885       << Attr << Attr.isRegularKeywordAttribute() << "variables";
3886     return false;
3887   }
3888   return true;
3889 }
3890 
3891 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3892   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3893     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3894   return false;
3895 }
3896 
3897   using ParsedAttrInfo::diagMutualExclusion;
3898 
3899   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
3900     if (const auto *A = D->getAttr<CUDAConstantAttr>()) {
3901       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3902       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3903 return false;
3904     }
3905     if (const auto *A = D->getAttr<HIPManagedAttr>()) {
3906       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
3907       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
3908 return false;
3909     }
3910     return true;
3911   }
3912 
3913 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
3914   return LangOpts.CUDA;
3915 }
3916 
3917 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3918   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
3919 }
3920 
3921 bool isParamExpr(size_t N) const override {
3922   return false;
3923 }
3924 
3925 static const ParsedAttrInfoCUDAShared Instance;
3926 };
3927 const ParsedAttrInfoCUDAShared ParsedAttrInfoCUDAShared::Instance;
3928 static constexpr ParsedAttrInfo::Spelling CXX11NoReturnSpellings[] = {
3929   {AttributeCommonInfo::AS_CXX11, "noreturn"},
3930   {AttributeCommonInfo::AS_C23, "noreturn"},
3931   {AttributeCommonInfo::AS_C23, "_Noreturn"},
3932 };
3933 struct ParsedAttrInfoCXX11NoReturn final : public ParsedAttrInfo {
3934   constexpr ParsedAttrInfoCXX11NoReturn() : ParsedAttrInfo(
3935     /*AttrKind=*/ParsedAttr::AT_CXX11NoReturn,
3936     /*NumArgs=*/0,
3937     /*OptArgs=*/0,
3938     /*NumArgMembers=*/0,
3939     /*HasCustomParsing=*/0,
3940     /*AcceptsExprPack=*/0,
3941     /*IsTargetSpecific=*/0,
3942     /*IsType=*/0,
3943     /*IsStmt=*/0,
3944     /*IsKnownToGCC=*/0,
3945     /*IsSupportedByPragmaAttribute=*/1,
3946     /*Spellings=*/CXX11NoReturnSpellings,
3947     /*ArgNames=*/{}) {}
3948 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
3949   if (!isa<FunctionDecl>(D)) {
3950     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
3951       << Attr << Attr.isRegularKeywordAttribute() << "functions";
3952     return false;
3953   }
3954   return true;
3955 }
3956 
3957 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
3958   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
3959     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
3960   return false;
3961 }
3962 
3963 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
3964   enum Spelling {
3965     CXX11_noreturn = 0,
3966     C23_noreturn = 1,
3967     C23_Noreturn = 2,
3968   SpellingNotCalculated = 15
3969 
3970   };
3971 
3972   unsigned Idx = Attr.getAttributeSpellingListIndex();
3973   switch (Idx) {
3974     default: llvm_unreachable("Unknown spelling list index");
3975     case 0: return CXX11_noreturn;
3976     case 1: return C23_noreturn;
3977     case 2: return C23_Noreturn;
3978   }
3979 }
3980 
3981 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
3982   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
3983 }
3984 
3985 bool isParamExpr(size_t N) const override {
3986   return false;
3987 }
3988 
3989 static const ParsedAttrInfoCXX11NoReturn Instance;
3990 };
3991 const ParsedAttrInfoCXX11NoReturn ParsedAttrInfoCXX11NoReturn::Instance;
3992 static constexpr ParsedAttrInfo::Spelling CXXAssumeSpellings[] = {
3993   {AttributeCommonInfo::AS_CXX11, "assume"},
3994   {AttributeCommonInfo::AS_GNU, "assume"},
3995   {AttributeCommonInfo::AS_CXX11, "clang::assume"},
3996   {AttributeCommonInfo::AS_C23, "clang::assume"},
3997 };
3998 static constexpr const char *CXXAssumeArgNames[] = {
3999 "Assumption",};
4000 struct ParsedAttrInfoCXXAssume final : public ParsedAttrInfo {
4001   constexpr ParsedAttrInfoCXXAssume() : ParsedAttrInfo(
4002     /*AttrKind=*/ParsedAttr::AT_CXXAssume,
4003     /*NumArgs=*/1,
4004     /*OptArgs=*/0,
4005     /*NumArgMembers=*/1,
4006     /*HasCustomParsing=*/1,
4007     /*AcceptsExprPack=*/0,
4008     /*IsTargetSpecific=*/0,
4009     /*IsType=*/0,
4010     /*IsStmt=*/1,
4011     /*IsKnownToGCC=*/0,
4012     /*IsSupportedByPragmaAttribute=*/0,
4013     /*Spellings=*/CXXAssumeSpellings,
4014     /*ArgNames=*/CXXAssumeArgNames) {}
4015 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
4016   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
4017     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
4018   return false;
4019 }
4020 
4021 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
4022   if (!isa<NullStmt>(St)) {
4023     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4024       << Attr << Attr.isRegularKeywordAttribute() << "empty statements";
4025     return false;
4026   }
4027   return true;
4028 }
4029 
4030 bool isParamExpr(size_t N) const override {
4031   return (N == 0) || false;
4032 }
4033 
4034 static const ParsedAttrInfoCXXAssume Instance;
4035 };
4036 const ParsedAttrInfoCXXAssume ParsedAttrInfoCXXAssume::Instance;
4037 static constexpr ParsedAttrInfo::Spelling CallableWhenSpellings[] = {
4038   {AttributeCommonInfo::AS_GNU, "callable_when"},
4039   {AttributeCommonInfo::AS_CXX11, "clang::callable_when"},
4040 };
4041 static constexpr const char *CallableWhenArgNames[] = {
4042 "CallableStates...",};
4043 struct ParsedAttrInfoCallableWhen final : public ParsedAttrInfo {
4044   constexpr ParsedAttrInfoCallableWhen() : ParsedAttrInfo(
4045     /*AttrKind=*/ParsedAttr::AT_CallableWhen,
4046     /*NumArgs=*/0,
4047     /*OptArgs=*/15,
4048     /*NumArgMembers=*/1,
4049     /*HasCustomParsing=*/0,
4050     /*AcceptsExprPack=*/0,
4051     /*IsTargetSpecific=*/0,
4052     /*IsType=*/0,
4053     /*IsStmt=*/0,
4054     /*IsKnownToGCC=*/0,
4055     /*IsSupportedByPragmaAttribute=*/1,
4056     /*Spellings=*/CallableWhenSpellings,
4057     /*ArgNames=*/CallableWhenArgNames) {}
4058 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4059   if (!isa<CXXMethodDecl>(D)) {
4060     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4061       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4062     return false;
4063   }
4064   return true;
4065 }
4066 
4067 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4068   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4069     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4070   return false;
4071 }
4072 
4073 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4074   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
4075 }
4076 
4077 bool isParamExpr(size_t N) const override {
4078   return false;
4079 }
4080 
4081 static const ParsedAttrInfoCallableWhen Instance;
4082 };
4083 const ParsedAttrInfoCallableWhen ParsedAttrInfoCallableWhen::Instance;
4084 static constexpr ParsedAttrInfo::Spelling CallbackSpellings[] = {
4085   {AttributeCommonInfo::AS_GNU, "callback"},
4086   {AttributeCommonInfo::AS_CXX11, "clang::callback"},
4087   {AttributeCommonInfo::AS_C23, "clang::callback"},
4088 };
4089 static constexpr const char *CallbackArgNames[] = {
4090 "Encoding...",};
4091 struct ParsedAttrInfoCallback final : public ParsedAttrInfo {
4092   constexpr ParsedAttrInfoCallback() : ParsedAttrInfo(
4093     /*AttrKind=*/ParsedAttr::AT_Callback,
4094     /*NumArgs=*/0,
4095     /*OptArgs=*/15,
4096     /*NumArgMembers=*/1,
4097     /*HasCustomParsing=*/0,
4098     /*AcceptsExprPack=*/0,
4099     /*IsTargetSpecific=*/0,
4100     /*IsType=*/0,
4101     /*IsStmt=*/0,
4102     /*IsKnownToGCC=*/0,
4103     /*IsSupportedByPragmaAttribute=*/1,
4104     /*Spellings=*/CallbackSpellings,
4105     /*ArgNames=*/CallbackArgNames) {}
4106 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4107   if (!isa<FunctionDecl>(D)) {
4108     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4109       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4110     return false;
4111   }
4112   return true;
4113 }
4114 
4115 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4116   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4117     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4118   return false;
4119 }
4120 
4121 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4122   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4123 }
4124 
4125 bool isParamExpr(size_t N) const override {
4126   return false;
4127 }
4128 
4129 static const ParsedAttrInfoCallback Instance;
4130 };
4131 const ParsedAttrInfoCallback ParsedAttrInfoCallback::Instance;
4132 static constexpr ParsedAttrInfo::Spelling CalledOnceSpellings[] = {
4133   {AttributeCommonInfo::AS_GNU, "called_once"},
4134   {AttributeCommonInfo::AS_CXX11, "clang::called_once"},
4135   {AttributeCommonInfo::AS_C23, "clang::called_once"},
4136 };
4137 struct ParsedAttrInfoCalledOnce final : public ParsedAttrInfo {
4138   constexpr ParsedAttrInfoCalledOnce() : ParsedAttrInfo(
4139     /*AttrKind=*/ParsedAttr::AT_CalledOnce,
4140     /*NumArgs=*/0,
4141     /*OptArgs=*/0,
4142     /*NumArgMembers=*/0,
4143     /*HasCustomParsing=*/0,
4144     /*AcceptsExprPack=*/0,
4145     /*IsTargetSpecific=*/0,
4146     /*IsType=*/0,
4147     /*IsStmt=*/0,
4148     /*IsKnownToGCC=*/0,
4149     /*IsSupportedByPragmaAttribute=*/1,
4150     /*Spellings=*/CalledOnceSpellings,
4151     /*ArgNames=*/{}) {}
4152 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4153   if (!isa<ParmVarDecl>(D)) {
4154     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4155       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
4156     return false;
4157   }
4158   return true;
4159 }
4160 
4161 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4162   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4163     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4164   return false;
4165 }
4166 
4167 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
4168   return LangOpts.ObjC;
4169 }
4170 
4171 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4172   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
4173 }
4174 
4175 bool isParamExpr(size_t N) const override {
4176   return false;
4177 }
4178 
4179 static const ParsedAttrInfoCalledOnce Instance;
4180 };
4181 const ParsedAttrInfoCalledOnce ParsedAttrInfoCalledOnce::Instance;
4182 static constexpr ParsedAttrInfo::Spelling CapabilitySpellings[] = {
4183   {AttributeCommonInfo::AS_GNU, "capability"},
4184   {AttributeCommonInfo::AS_CXX11, "clang::capability"},
4185   {AttributeCommonInfo::AS_GNU, "shared_capability"},
4186   {AttributeCommonInfo::AS_CXX11, "clang::shared_capability"},
4187 };
4188 static constexpr const char *CapabilityArgNames[] = {
4189 "Name",};
4190 struct ParsedAttrInfoCapability final : public ParsedAttrInfo {
4191   constexpr ParsedAttrInfoCapability() : ParsedAttrInfo(
4192     /*AttrKind=*/ParsedAttr::AT_Capability,
4193     /*NumArgs=*/1,
4194     /*OptArgs=*/0,
4195     /*NumArgMembers=*/1,
4196     /*HasCustomParsing=*/0,
4197     /*AcceptsExprPack=*/0,
4198     /*IsTargetSpecific=*/0,
4199     /*IsType=*/0,
4200     /*IsStmt=*/0,
4201     /*IsKnownToGCC=*/0,
4202     /*IsSupportedByPragmaAttribute=*/1,
4203     /*Spellings=*/CapabilitySpellings,
4204     /*ArgNames=*/CapabilityArgNames) {}
4205 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4206   if (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D)) {
4207     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4208       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and typedefs";
4209     return false;
4210   }
4211   return true;
4212 }
4213 
4214 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4215   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4216     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4217   return false;
4218 }
4219 
4220 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
4221   enum Spelling {
4222     GNU_capability = 0,
4223     CXX11_clang_capability = 1,
4224     GNU_shared_capability = 2,
4225     CXX11_clang_shared_capability = 3,
4226   SpellingNotCalculated = 15
4227 
4228   };
4229 
4230   unsigned Idx = Attr.getAttributeSpellingListIndex();
4231   switch (Idx) {
4232     default: llvm_unreachable("Unknown spelling list index");
4233     case 0: return GNU_capability;
4234     case 1: return CXX11_clang_capability;
4235     case 2: return GNU_shared_capability;
4236     case 3: return CXX11_clang_shared_capability;
4237   }
4238 }
4239 
4240 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4241   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
4242   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
4243 }
4244 
4245 bool isParamExpr(size_t N) const override {
4246   return false;
4247 }
4248 
4249 static const ParsedAttrInfoCapability Instance;
4250 };
4251 const ParsedAttrInfoCapability ParsedAttrInfoCapability::Instance;
4252 static constexpr ParsedAttrInfo::Spelling CarriesDependencySpellings[] = {
4253   {AttributeCommonInfo::AS_GNU, "carries_dependency"},
4254   {AttributeCommonInfo::AS_CXX11, "carries_dependency"},
4255 };
4256 struct ParsedAttrInfoCarriesDependency final : public ParsedAttrInfo {
4257   constexpr ParsedAttrInfoCarriesDependency() : ParsedAttrInfo(
4258     /*AttrKind=*/ParsedAttr::AT_CarriesDependency,
4259     /*NumArgs=*/0,
4260     /*OptArgs=*/0,
4261     /*NumArgMembers=*/0,
4262     /*HasCustomParsing=*/0,
4263     /*AcceptsExprPack=*/0,
4264     /*IsTargetSpecific=*/0,
4265     /*IsType=*/0,
4266     /*IsStmt=*/0,
4267     /*IsKnownToGCC=*/0,
4268     /*IsSupportedByPragmaAttribute=*/1,
4269     /*Spellings=*/CarriesDependencySpellings,
4270     /*ArgNames=*/{}) {}
4271 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4272   if (!isa<ParmVarDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) {
4273     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4274       << Attr << Attr.isRegularKeywordAttribute() << "parameters, Objective-C methods, and functions";
4275     return false;
4276   }
4277   return true;
4278 }
4279 
4280 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4281   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4282     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4283   return false;
4284 }
4285 
4286 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4287   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
4288   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
4289   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4290 }
4291 
4292 bool isParamExpr(size_t N) const override {
4293   return false;
4294 }
4295 
4296 static const ParsedAttrInfoCarriesDependency Instance;
4297 };
4298 const ParsedAttrInfoCarriesDependency ParsedAttrInfoCarriesDependency::Instance;
4299 static constexpr ParsedAttrInfo::Spelling CleanupSpellings[] = {
4300   {AttributeCommonInfo::AS_GNU, "cleanup"},
4301   {AttributeCommonInfo::AS_CXX11, "gnu::cleanup"},
4302   {AttributeCommonInfo::AS_C23, "gnu::cleanup"},
4303 };
4304 static constexpr const char *CleanupArgNames[] = {
4305 "FunctionDecl",};
4306 struct ParsedAttrInfoCleanup final : public ParsedAttrInfo {
4307   constexpr ParsedAttrInfoCleanup() : ParsedAttrInfo(
4308     /*AttrKind=*/ParsedAttr::AT_Cleanup,
4309     /*NumArgs=*/1,
4310     /*OptArgs=*/0,
4311     /*NumArgMembers=*/1,
4312     /*HasCustomParsing=*/0,
4313     /*AcceptsExprPack=*/0,
4314     /*IsTargetSpecific=*/0,
4315     /*IsType=*/0,
4316     /*IsStmt=*/0,
4317     /*IsKnownToGCC=*/1,
4318     /*IsSupportedByPragmaAttribute=*/1,
4319     /*Spellings=*/CleanupSpellings,
4320     /*ArgNames=*/CleanupArgNames) {}
4321 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4322   if (!isLocalVar(D)) {
4323     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4324       << Attr << Attr.isRegularKeywordAttribute() << "local variables";
4325     return false;
4326   }
4327   return true;
4328 }
4329 
4330 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4331   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4332     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4333   return false;
4334 }
4335 
4336 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4337   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_local, /*IsSupported=*/true));
4338 }
4339 
4340 bool isParamExpr(size_t N) const override {
4341   return false;
4342 }
4343 
4344 static const ParsedAttrInfoCleanup Instance;
4345 };
4346 const ParsedAttrInfoCleanup ParsedAttrInfoCleanup::Instance;
4347 static constexpr ParsedAttrInfo::Spelling ClspvLibclcBuiltinSpellings[] = {
4348   {AttributeCommonInfo::AS_GNU, "clspv_libclc_builtin"},
4349   {AttributeCommonInfo::AS_CXX11, "clang::clspv_libclc_builtin"},
4350   {AttributeCommonInfo::AS_C23, "clang::clspv_libclc_builtin"},
4351 };
4352 struct ParsedAttrInfoClspvLibclcBuiltin final : public ParsedAttrInfo {
4353   constexpr ParsedAttrInfoClspvLibclcBuiltin() : ParsedAttrInfo(
4354     /*AttrKind=*/ParsedAttr::AT_ClspvLibclcBuiltin,
4355     /*NumArgs=*/0,
4356     /*OptArgs=*/0,
4357     /*NumArgMembers=*/0,
4358     /*HasCustomParsing=*/0,
4359     /*AcceptsExprPack=*/0,
4360     /*IsTargetSpecific=*/0,
4361     /*IsType=*/0,
4362     /*IsStmt=*/0,
4363     /*IsKnownToGCC=*/0,
4364     /*IsSupportedByPragmaAttribute=*/1,
4365     /*Spellings=*/ClspvLibclcBuiltinSpellings,
4366     /*ArgNames=*/{}) {}
4367 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4368   if (!isa<FunctionDecl>(D)) {
4369     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4370       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4371     return false;
4372   }
4373   return true;
4374 }
4375 
4376 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4377   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4378     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4379   return false;
4380 }
4381 
4382 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4383   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4384 }
4385 
4386 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
4387   D->addAttr(::new (S.Context) ClspvLibclcBuiltinAttr(S.Context, Attr));
4388   return AttributeApplied;
4389 }
4390 
4391 bool isParamExpr(size_t N) const override {
4392   return false;
4393 }
4394 
4395 static const ParsedAttrInfoClspvLibclcBuiltin Instance;
4396 };
4397 const ParsedAttrInfoClspvLibclcBuiltin ParsedAttrInfoClspvLibclcBuiltin::Instance;
4398 static constexpr ParsedAttrInfo::Spelling CmseNSCallSpellings[] = {
4399   {AttributeCommonInfo::AS_GNU, "cmse_nonsecure_call"},
4400 };
4401 struct ParsedAttrInfoCmseNSCall final : public ParsedAttrInfo {
4402   constexpr ParsedAttrInfoCmseNSCall() : ParsedAttrInfo(
4403     /*AttrKind=*/ParsedAttr::AT_CmseNSCall,
4404     /*NumArgs=*/0,
4405     /*OptArgs=*/0,
4406     /*NumArgMembers=*/0,
4407     /*HasCustomParsing=*/0,
4408     /*AcceptsExprPack=*/0,
4409     /*IsTargetSpecific=*/1,
4410     /*IsType=*/1,
4411     /*IsStmt=*/0,
4412     /*IsKnownToGCC=*/0,
4413     /*IsSupportedByPragmaAttribute=*/0,
4414     /*Spellings=*/CmseNSCallSpellings,
4415     /*ArgNames=*/{}) {}
4416 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
4417   return LangOpts.Cmse;
4418 }
4419 
4420 bool existsInTarget(const TargetInfo &Target) const override {
4421   const llvm::Triple &T = Target.getTriple(); (void)T;
4422   return true && (T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::armeb || T.getArch() == llvm::Triple::thumbeb);
4423 }
4424 
4425 bool isParamExpr(size_t N) const override {
4426   return false;
4427 }
4428 
4429 static const ParsedAttrInfoCmseNSCall Instance;
4430 };
4431 const ParsedAttrInfoCmseNSCall ParsedAttrInfoCmseNSCall::Instance;
4432 static constexpr ParsedAttrInfo::Spelling CmseNSEntrySpellings[] = {
4433   {AttributeCommonInfo::AS_GNU, "cmse_nonsecure_entry"},
4434 };
4435 struct ParsedAttrInfoCmseNSEntry final : public ParsedAttrInfo {
4436   constexpr ParsedAttrInfoCmseNSEntry() : ParsedAttrInfo(
4437     /*AttrKind=*/ParsedAttr::AT_CmseNSEntry,
4438     /*NumArgs=*/0,
4439     /*OptArgs=*/0,
4440     /*NumArgMembers=*/0,
4441     /*HasCustomParsing=*/0,
4442     /*AcceptsExprPack=*/0,
4443     /*IsTargetSpecific=*/1,
4444     /*IsType=*/0,
4445     /*IsStmt=*/0,
4446     /*IsKnownToGCC=*/0,
4447     /*IsSupportedByPragmaAttribute=*/1,
4448     /*Spellings=*/CmseNSEntrySpellings,
4449     /*ArgNames=*/{}) {}
4450 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4451   if (!isa<FunctionDecl>(D)) {
4452     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4453       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4454     return false;
4455   }
4456   return true;
4457 }
4458 
4459 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4460   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4461     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4462   return false;
4463 }
4464 
4465 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
4466   return LangOpts.Cmse;
4467 }
4468 
4469 bool existsInTarget(const TargetInfo &Target) const override {
4470   const llvm::Triple &T = Target.getTriple(); (void)T;
4471   return true && (T.getArch() == llvm::Triple::arm || T.getArch() == llvm::Triple::thumb || T.getArch() == llvm::Triple::armeb || T.getArch() == llvm::Triple::thumbeb);
4472 }
4473 
4474 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4475   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4476 }
4477 
4478 bool isParamExpr(size_t N) const override {
4479   return false;
4480 }
4481 
4482 static const ParsedAttrInfoCmseNSEntry Instance;
4483 };
4484 const ParsedAttrInfoCmseNSEntry ParsedAttrInfoCmseNSEntry::Instance;
4485 static constexpr ParsedAttrInfo::Spelling CodeAlignSpellings[] = {
4486   {AttributeCommonInfo::AS_GNU, "code_align"},
4487   {AttributeCommonInfo::AS_CXX11, "clang::code_align"},
4488   {AttributeCommonInfo::AS_C23, "clang::code_align"},
4489 };
4490 static constexpr const char *CodeAlignArgNames[] = {
4491 "Alignment",};
4492 struct ParsedAttrInfoCodeAlign final : public ParsedAttrInfo {
4493   constexpr ParsedAttrInfoCodeAlign() : ParsedAttrInfo(
4494     /*AttrKind=*/ParsedAttr::AT_CodeAlign,
4495     /*NumArgs=*/1,
4496     /*OptArgs=*/0,
4497     /*NumArgMembers=*/1,
4498     /*HasCustomParsing=*/0,
4499     /*AcceptsExprPack=*/0,
4500     /*IsTargetSpecific=*/0,
4501     /*IsType=*/0,
4502     /*IsStmt=*/1,
4503     /*IsKnownToGCC=*/0,
4504     /*IsSupportedByPragmaAttribute=*/0,
4505     /*Spellings=*/CodeAlignSpellings,
4506     /*ArgNames=*/CodeAlignArgNames) {}
4507 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
4508   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
4509     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
4510   return false;
4511 }
4512 
4513 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
4514   if (!isa<ForStmt>(St) && !isa<CXXForRangeStmt>(St) && !isa<WhileStmt>(St) && !isa<DoStmt>(St)) {
4515     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4516       << Attr << Attr.isRegularKeywordAttribute() << "'for', 'while', and 'do' statements";
4517     return false;
4518   }
4519   return true;
4520 }
4521 
4522 bool isParamExpr(size_t N) const override {
4523   return (N == 0) || false;
4524 }
4525 
4526 static const ParsedAttrInfoCodeAlign Instance;
4527 };
4528 const ParsedAttrInfoCodeAlign ParsedAttrInfoCodeAlign::Instance;
4529 static constexpr ParsedAttrInfo::Spelling CodeModelSpellings[] = {
4530   {AttributeCommonInfo::AS_GNU, "model"},
4531   {AttributeCommonInfo::AS_CXX11, "gnu::model"},
4532   {AttributeCommonInfo::AS_C23, "gnu::model"},
4533 };
4534 static constexpr const char *CodeModelArgNames[] = {
4535 "Model",};
4536 struct ParsedAttrInfoCodeModel final : public ParsedAttrInfo {
4537   constexpr ParsedAttrInfoCodeModel() : ParsedAttrInfo(
4538     /*AttrKind=*/ParsedAttr::AT_CodeModel,
4539     /*NumArgs=*/1,
4540     /*OptArgs=*/0,
4541     /*NumArgMembers=*/1,
4542     /*HasCustomParsing=*/0,
4543     /*AcceptsExprPack=*/0,
4544     /*IsTargetSpecific=*/1,
4545     /*IsType=*/0,
4546     /*IsStmt=*/0,
4547     /*IsKnownToGCC=*/1,
4548     /*IsSupportedByPragmaAttribute=*/0,
4549     /*Spellings=*/CodeModelSpellings,
4550     /*ArgNames=*/CodeModelArgNames) {}
4551 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4552   if (!isNonTLSGlobalVar(D)) {
4553     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4554       << Attr << Attr.isRegularKeywordAttribute() << "non-TLS global variables";
4555     return false;
4556   }
4557   return true;
4558 }
4559 
4560 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4561   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4562     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4563   return false;
4564 }
4565 
4566 bool existsInTarget(const TargetInfo &Target) const override {
4567   const llvm::Triple &T = Target.getTriple(); (void)T;
4568   return true && (T.getArch() == llvm::Triple::loongarch32 || T.getArch() == llvm::Triple::loongarch64);
4569 }
4570 
4571 bool isParamExpr(size_t N) const override {
4572   return false;
4573 }
4574 
4575 static const ParsedAttrInfoCodeModel Instance;
4576 };
4577 const ParsedAttrInfoCodeModel ParsedAttrInfoCodeModel::Instance;
4578 static constexpr ParsedAttrInfo::Spelling CodeSegSpellings[] = {
4579   {AttributeCommonInfo::AS_Declspec, "code_seg"},
4580 };
4581 static constexpr const char *CodeSegArgNames[] = {
4582 "Name",};
4583 struct ParsedAttrInfoCodeSeg final : public ParsedAttrInfo {
4584   constexpr ParsedAttrInfoCodeSeg() : ParsedAttrInfo(
4585     /*AttrKind=*/ParsedAttr::AT_CodeSeg,
4586     /*NumArgs=*/1,
4587     /*OptArgs=*/0,
4588     /*NumArgMembers=*/1,
4589     /*HasCustomParsing=*/0,
4590     /*AcceptsExprPack=*/0,
4591     /*IsTargetSpecific=*/0,
4592     /*IsType=*/0,
4593     /*IsStmt=*/0,
4594     /*IsKnownToGCC=*/0,
4595     /*IsSupportedByPragmaAttribute=*/0,
4596     /*Spellings=*/CodeSegSpellings,
4597     /*ArgNames=*/CodeSegArgNames) {}
4598 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4599   if (!isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) {
4600     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4601       << Attr << Attr.isRegularKeywordAttribute() << "functions and classes";
4602     return false;
4603   }
4604   return true;
4605 }
4606 
4607 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4608   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4609     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4610   return false;
4611 }
4612 
4613 bool isParamExpr(size_t N) const override {
4614   return false;
4615 }
4616 
4617 static const ParsedAttrInfoCodeSeg Instance;
4618 };
4619 const ParsedAttrInfoCodeSeg ParsedAttrInfoCodeSeg::Instance;
4620 static constexpr ParsedAttrInfo::Spelling ColdSpellings[] = {
4621   {AttributeCommonInfo::AS_GNU, "cold"},
4622   {AttributeCommonInfo::AS_CXX11, "gnu::cold"},
4623   {AttributeCommonInfo::AS_C23, "gnu::cold"},
4624 };
4625 struct ParsedAttrInfoCold final : public ParsedAttrInfo {
4626   constexpr ParsedAttrInfoCold() : ParsedAttrInfo(
4627     /*AttrKind=*/ParsedAttr::AT_Cold,
4628     /*NumArgs=*/0,
4629     /*OptArgs=*/0,
4630     /*NumArgMembers=*/0,
4631     /*HasCustomParsing=*/0,
4632     /*AcceptsExprPack=*/0,
4633     /*IsTargetSpecific=*/0,
4634     /*IsType=*/0,
4635     /*IsStmt=*/0,
4636     /*IsKnownToGCC=*/1,
4637     /*IsSupportedByPragmaAttribute=*/1,
4638     /*Spellings=*/ColdSpellings,
4639     /*ArgNames=*/{}) {}
4640 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4641   if (!isa<FunctionDecl>(D)) {
4642     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4643       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4644     return false;
4645   }
4646   return true;
4647 }
4648 
4649 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4650   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4651     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4652   return false;
4653 }
4654 
4655   using ParsedAttrInfo::diagMutualExclusion;
4656 
4657   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
4658     if (const auto *A = D->getAttr<HotAttr>()) {
4659       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
4660       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
4661 return false;
4662     }
4663     return true;
4664   }
4665 
4666 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4667   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4668 }
4669 
4670 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
4671   D->addAttr(::new (S.Context) ColdAttr(S.Context, Attr));
4672   return AttributeApplied;
4673 }
4674 
4675 bool isParamExpr(size_t N) const override {
4676   return false;
4677 }
4678 
4679 static const ParsedAttrInfoCold Instance;
4680 };
4681 const ParsedAttrInfoCold ParsedAttrInfoCold::Instance;
4682 static constexpr ParsedAttrInfo::Spelling CommonSpellings[] = {
4683   {AttributeCommonInfo::AS_GNU, "common"},
4684   {AttributeCommonInfo::AS_CXX11, "gnu::common"},
4685   {AttributeCommonInfo::AS_C23, "gnu::common"},
4686 };
4687 struct ParsedAttrInfoCommon final : public ParsedAttrInfo {
4688   constexpr ParsedAttrInfoCommon() : ParsedAttrInfo(
4689     /*AttrKind=*/ParsedAttr::AT_Common,
4690     /*NumArgs=*/0,
4691     /*OptArgs=*/0,
4692     /*NumArgMembers=*/0,
4693     /*HasCustomParsing=*/0,
4694     /*AcceptsExprPack=*/0,
4695     /*IsTargetSpecific=*/0,
4696     /*IsType=*/0,
4697     /*IsStmt=*/0,
4698     /*IsKnownToGCC=*/1,
4699     /*IsSupportedByPragmaAttribute=*/1,
4700     /*Spellings=*/CommonSpellings,
4701     /*ArgNames=*/{}) {}
4702 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4703   if (!isa<VarDecl>(D)) {
4704     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4705       << Attr << Attr.isRegularKeywordAttribute() << "variables";
4706     return false;
4707   }
4708   return true;
4709 }
4710 
4711 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4712   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4713     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4714   return false;
4715 }
4716 
4717   using ParsedAttrInfo::diagMutualExclusion;
4718 
4719   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
4720     if (const auto *A = D->getAttr<InternalLinkageAttr>()) {
4721       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
4722       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
4723 return false;
4724     }
4725     return true;
4726   }
4727 
4728 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4729   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
4730 }
4731 
4732 bool isParamExpr(size_t N) const override {
4733   return false;
4734 }
4735 
4736 static const ParsedAttrInfoCommon Instance;
4737 };
4738 const ParsedAttrInfoCommon ParsedAttrInfoCommon::Instance;
4739 static constexpr ParsedAttrInfo::Spelling ConstSpellings[] = {
4740   {AttributeCommonInfo::AS_GNU, "const"},
4741   {AttributeCommonInfo::AS_CXX11, "gnu::const"},
4742   {AttributeCommonInfo::AS_C23, "gnu::const"},
4743   {AttributeCommonInfo::AS_GNU, "__const"},
4744   {AttributeCommonInfo::AS_CXX11, "gnu::__const"},
4745   {AttributeCommonInfo::AS_C23, "gnu::__const"},
4746 };
4747 struct ParsedAttrInfoConst final : public ParsedAttrInfo {
4748   constexpr ParsedAttrInfoConst() : ParsedAttrInfo(
4749     /*AttrKind=*/ParsedAttr::AT_Const,
4750     /*NumArgs=*/0,
4751     /*OptArgs=*/0,
4752     /*NumArgMembers=*/0,
4753     /*HasCustomParsing=*/0,
4754     /*AcceptsExprPack=*/0,
4755     /*IsTargetSpecific=*/0,
4756     /*IsType=*/0,
4757     /*IsStmt=*/0,
4758     /*IsKnownToGCC=*/1,
4759     /*IsSupportedByPragmaAttribute=*/0,
4760     /*Spellings=*/ConstSpellings,
4761     /*ArgNames=*/{}) {}
4762 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
4763   D->addAttr(::new (S.Context) ConstAttr(S.Context, Attr));
4764   return AttributeApplied;
4765 }
4766 
4767 bool isParamExpr(size_t N) const override {
4768   return false;
4769 }
4770 
4771 static const ParsedAttrInfoConst Instance;
4772 };
4773 const ParsedAttrInfoConst ParsedAttrInfoConst::Instance;
4774 static constexpr ParsedAttrInfo::Spelling ConstInitSpellings[] = {
4775   {AttributeCommonInfo::AS_Keyword, "constinit"},
4776   {AttributeCommonInfo::AS_GNU, "require_constant_initialization"},
4777   {AttributeCommonInfo::AS_CXX11, "clang::require_constant_initialization"},
4778 };
4779 struct ParsedAttrInfoConstInit final : public ParsedAttrInfo {
4780   constexpr ParsedAttrInfoConstInit() : ParsedAttrInfo(
4781     /*AttrKind=*/ParsedAttr::AT_ConstInit,
4782     /*NumArgs=*/0,
4783     /*OptArgs=*/0,
4784     /*NumArgMembers=*/0,
4785     /*HasCustomParsing=*/0,
4786     /*AcceptsExprPack=*/0,
4787     /*IsTargetSpecific=*/0,
4788     /*IsType=*/0,
4789     /*IsStmt=*/0,
4790     /*IsKnownToGCC=*/0,
4791     /*IsSupportedByPragmaAttribute=*/1,
4792     /*Spellings=*/ConstInitSpellings,
4793     /*ArgNames=*/{}) {}
4794 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4795   if (!isGlobalVar(D)) {
4796     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
4797       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
4798     return false;
4799   }
4800   return true;
4801 }
4802 
4803 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4804   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4805     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4806   return false;
4807 }
4808 
4809 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
4810   return LangOpts.CPlusPlus;
4811 }
4812 
4813 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
4814   enum Spelling {
4815     Keyword_constinit = 0,
4816     GNU_require_constant_initialization = 1,
4817     CXX11_clang_require_constant_initialization = 2,
4818   SpellingNotCalculated = 15
4819 
4820   };
4821 
4822   unsigned Idx = Attr.getAttributeSpellingListIndex();
4823   switch (Idx) {
4824     default: llvm_unreachable("Unknown spelling list index");
4825     case 0: return Keyword_constinit;
4826     case 1: return GNU_require_constant_initialization;
4827     case 2: return CXX11_clang_require_constant_initialization;
4828   }
4829 }
4830 
4831 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4832   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
4833 }
4834 
4835 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
4836   D->addAttr(::new (S.Context) ConstInitAttr(S.Context, Attr));
4837   return AttributeApplied;
4838 }
4839 
4840 bool isParamExpr(size_t N) const override {
4841   return false;
4842 }
4843 
4844 static const ParsedAttrInfoConstInit Instance;
4845 };
4846 const ParsedAttrInfoConstInit ParsedAttrInfoConstInit::Instance;
4847 static constexpr ParsedAttrInfo::Spelling ConstructorSpellings[] = {
4848   {AttributeCommonInfo::AS_GNU, "constructor"},
4849   {AttributeCommonInfo::AS_CXX11, "gnu::constructor"},
4850   {AttributeCommonInfo::AS_C23, "gnu::constructor"},
4851 };
4852 static constexpr const char *ConstructorArgNames[] = {
4853 "Priority",};
4854 struct ParsedAttrInfoConstructor final : public ParsedAttrInfo {
4855   constexpr ParsedAttrInfoConstructor() : ParsedAttrInfo(
4856     /*AttrKind=*/ParsedAttr::AT_Constructor,
4857     /*NumArgs=*/0,
4858     /*OptArgs=*/1,
4859     /*NumArgMembers=*/1,
4860     /*HasCustomParsing=*/0,
4861     /*AcceptsExprPack=*/0,
4862     /*IsTargetSpecific=*/0,
4863     /*IsType=*/0,
4864     /*IsStmt=*/0,
4865     /*IsKnownToGCC=*/1,
4866     /*IsSupportedByPragmaAttribute=*/1,
4867     /*Spellings=*/ConstructorSpellings,
4868     /*ArgNames=*/ConstructorArgNames) {}
4869 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4870   if (!isa<FunctionDecl>(D)) {
4871     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4872       << Attr << Attr.isRegularKeywordAttribute() << "functions";
4873     return false;
4874   }
4875   return true;
4876 }
4877 
4878 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4879   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4880     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4881   return false;
4882 }
4883 
4884 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4885   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
4886 }
4887 
4888 bool isParamExpr(size_t N) const override {
4889   return false;
4890 }
4891 
4892 static const ParsedAttrInfoConstructor Instance;
4893 };
4894 const ParsedAttrInfoConstructor ParsedAttrInfoConstructor::Instance;
4895 static constexpr ParsedAttrInfo::Spelling ConsumableSpellings[] = {
4896   {AttributeCommonInfo::AS_GNU, "consumable"},
4897   {AttributeCommonInfo::AS_CXX11, "clang::consumable"},
4898 };
4899 static constexpr const char *ConsumableArgNames[] = {
4900 "DefaultState",};
4901 struct ParsedAttrInfoConsumable final : public ParsedAttrInfo {
4902   constexpr ParsedAttrInfoConsumable() : ParsedAttrInfo(
4903     /*AttrKind=*/ParsedAttr::AT_Consumable,
4904     /*NumArgs=*/1,
4905     /*OptArgs=*/0,
4906     /*NumArgMembers=*/1,
4907     /*HasCustomParsing=*/0,
4908     /*AcceptsExprPack=*/0,
4909     /*IsTargetSpecific=*/0,
4910     /*IsType=*/0,
4911     /*IsStmt=*/0,
4912     /*IsKnownToGCC=*/0,
4913     /*IsSupportedByPragmaAttribute=*/1,
4914     /*Spellings=*/ConsumableSpellings,
4915     /*ArgNames=*/ConsumableArgNames) {}
4916 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4917   if (!isa<CXXRecordDecl>(D)) {
4918     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4919       << Attr << Attr.isRegularKeywordAttribute() << "classes";
4920     return false;
4921   }
4922   return true;
4923 }
4924 
4925 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4926   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4927     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4928   return false;
4929 }
4930 
4931 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4932   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
4933 }
4934 
4935 bool isParamExpr(size_t N) const override {
4936   return false;
4937 }
4938 
4939 static const ParsedAttrInfoConsumable Instance;
4940 };
4941 const ParsedAttrInfoConsumable ParsedAttrInfoConsumable::Instance;
4942 static constexpr ParsedAttrInfo::Spelling ConsumableAutoCastSpellings[] = {
4943   {AttributeCommonInfo::AS_GNU, "consumable_auto_cast_state"},
4944   {AttributeCommonInfo::AS_CXX11, "clang::consumable_auto_cast_state"},
4945 };
4946 struct ParsedAttrInfoConsumableAutoCast final : public ParsedAttrInfo {
4947   constexpr ParsedAttrInfoConsumableAutoCast() : ParsedAttrInfo(
4948     /*AttrKind=*/ParsedAttr::AT_ConsumableAutoCast,
4949     /*NumArgs=*/0,
4950     /*OptArgs=*/0,
4951     /*NumArgMembers=*/0,
4952     /*HasCustomParsing=*/0,
4953     /*AcceptsExprPack=*/0,
4954     /*IsTargetSpecific=*/0,
4955     /*IsType=*/0,
4956     /*IsStmt=*/0,
4957     /*IsKnownToGCC=*/0,
4958     /*IsSupportedByPragmaAttribute=*/1,
4959     /*Spellings=*/ConsumableAutoCastSpellings,
4960     /*ArgNames=*/{}) {}
4961 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
4962   if (!isa<CXXRecordDecl>(D)) {
4963     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
4964       << Attr << Attr.isRegularKeywordAttribute() << "classes";
4965     return false;
4966   }
4967   return true;
4968 }
4969 
4970 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
4971   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
4972     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
4973   return false;
4974 }
4975 
4976 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
4977   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
4978 }
4979 
4980 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
4981   D->addAttr(::new (S.Context) ConsumableAutoCastAttr(S.Context, Attr));
4982   return AttributeApplied;
4983 }
4984 
4985 bool isParamExpr(size_t N) const override {
4986   return false;
4987 }
4988 
4989 static const ParsedAttrInfoConsumableAutoCast Instance;
4990 };
4991 const ParsedAttrInfoConsumableAutoCast ParsedAttrInfoConsumableAutoCast::Instance;
4992 static constexpr ParsedAttrInfo::Spelling ConsumableSetOnReadSpellings[] = {
4993   {AttributeCommonInfo::AS_GNU, "consumable_set_state_on_read"},
4994   {AttributeCommonInfo::AS_CXX11, "clang::consumable_set_state_on_read"},
4995 };
4996 struct ParsedAttrInfoConsumableSetOnRead final : public ParsedAttrInfo {
4997   constexpr ParsedAttrInfoConsumableSetOnRead() : ParsedAttrInfo(
4998     /*AttrKind=*/ParsedAttr::AT_ConsumableSetOnRead,
4999     /*NumArgs=*/0,
5000     /*OptArgs=*/0,
5001     /*NumArgMembers=*/0,
5002     /*HasCustomParsing=*/0,
5003     /*AcceptsExprPack=*/0,
5004     /*IsTargetSpecific=*/0,
5005     /*IsType=*/0,
5006     /*IsStmt=*/0,
5007     /*IsKnownToGCC=*/0,
5008     /*IsSupportedByPragmaAttribute=*/1,
5009     /*Spellings=*/ConsumableSetOnReadSpellings,
5010     /*ArgNames=*/{}) {}
5011 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5012   if (!isa<CXXRecordDecl>(D)) {
5013     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5014       << Attr << Attr.isRegularKeywordAttribute() << "classes";
5015     return false;
5016   }
5017   return true;
5018 }
5019 
5020 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5021   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5022     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5023   return false;
5024 }
5025 
5026 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5027   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5028 }
5029 
5030 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5031   D->addAttr(::new (S.Context) ConsumableSetOnReadAttr(S.Context, Attr));
5032   return AttributeApplied;
5033 }
5034 
5035 bool isParamExpr(size_t N) const override {
5036   return false;
5037 }
5038 
5039 static const ParsedAttrInfoConsumableSetOnRead Instance;
5040 };
5041 const ParsedAttrInfoConsumableSetOnRead ParsedAttrInfoConsumableSetOnRead::Instance;
5042 static constexpr ParsedAttrInfo::Spelling ConvergentSpellings[] = {
5043   {AttributeCommonInfo::AS_GNU, "convergent"},
5044   {AttributeCommonInfo::AS_CXX11, "clang::convergent"},
5045   {AttributeCommonInfo::AS_C23, "clang::convergent"},
5046 };
5047 struct ParsedAttrInfoConvergent final : public ParsedAttrInfo {
5048   constexpr ParsedAttrInfoConvergent() : ParsedAttrInfo(
5049     /*AttrKind=*/ParsedAttr::AT_Convergent,
5050     /*NumArgs=*/0,
5051     /*OptArgs=*/0,
5052     /*NumArgMembers=*/0,
5053     /*HasCustomParsing=*/0,
5054     /*AcceptsExprPack=*/0,
5055     /*IsTargetSpecific=*/0,
5056     /*IsType=*/0,
5057     /*IsStmt=*/0,
5058     /*IsKnownToGCC=*/0,
5059     /*IsSupportedByPragmaAttribute=*/1,
5060     /*Spellings=*/ConvergentSpellings,
5061     /*ArgNames=*/{}) {}
5062 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5063   if (!isa<FunctionDecl>(D)) {
5064     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5065       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5066     return false;
5067   }
5068   return true;
5069 }
5070 
5071 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5072   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5073     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5074   return false;
5075 }
5076 
5077   using ParsedAttrInfo::diagMutualExclusion;
5078 
5079   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
5080     if (const auto *A = D->getAttr<NoConvergentAttr>()) {
5081       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
5082       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
5083 return false;
5084     }
5085     return true;
5086   }
5087 
5088 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5089   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5090 }
5091 
5092 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5093   D->addAttr(::new (S.Context) ConvergentAttr(S.Context, Attr));
5094   return AttributeApplied;
5095 }
5096 
5097 bool isParamExpr(size_t N) const override {
5098   return false;
5099 }
5100 
5101 static const ParsedAttrInfoConvergent Instance;
5102 };
5103 const ParsedAttrInfoConvergent ParsedAttrInfoConvergent::Instance;
5104 static constexpr ParsedAttrInfo::Spelling CoroAwaitElidableSpellings[] = {
5105   {AttributeCommonInfo::AS_GNU, "coro_await_elidable"},
5106   {AttributeCommonInfo::AS_CXX11, "clang::coro_await_elidable"},
5107   {AttributeCommonInfo::AS_C23, "clang::coro_await_elidable"},
5108 };
5109 struct ParsedAttrInfoCoroAwaitElidable final : public ParsedAttrInfo {
5110   constexpr ParsedAttrInfoCoroAwaitElidable() : ParsedAttrInfo(
5111     /*AttrKind=*/ParsedAttr::AT_CoroAwaitElidable,
5112     /*NumArgs=*/0,
5113     /*OptArgs=*/0,
5114     /*NumArgMembers=*/0,
5115     /*HasCustomParsing=*/0,
5116     /*AcceptsExprPack=*/0,
5117     /*IsTargetSpecific=*/0,
5118     /*IsType=*/0,
5119     /*IsStmt=*/0,
5120     /*IsKnownToGCC=*/0,
5121     /*IsSupportedByPragmaAttribute=*/1,
5122     /*Spellings=*/CoroAwaitElidableSpellings,
5123     /*ArgNames=*/{}) {}
5124 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5125   if (!isa<CXXRecordDecl>(D)) {
5126     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5127       << Attr << Attr.isRegularKeywordAttribute() << "classes";
5128     return false;
5129   }
5130   return true;
5131 }
5132 
5133 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5134   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5135     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5136   return false;
5137 }
5138 
5139 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5140   return LangOpts.CPlusPlus;
5141 }
5142 
5143 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5144   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5145 }
5146 
5147 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5148   D->addAttr(::new (S.Context) CoroAwaitElidableAttr(S.Context, Attr));
5149   return AttributeApplied;
5150 }
5151 
5152 bool isParamExpr(size_t N) const override {
5153   return false;
5154 }
5155 
5156 static const ParsedAttrInfoCoroAwaitElidable Instance;
5157 };
5158 const ParsedAttrInfoCoroAwaitElidable ParsedAttrInfoCoroAwaitElidable::Instance;
5159 static constexpr ParsedAttrInfo::Spelling CoroAwaitElidableArgumentSpellings[] = {
5160   {AttributeCommonInfo::AS_GNU, "coro_await_elidable_argument"},
5161   {AttributeCommonInfo::AS_CXX11, "clang::coro_await_elidable_argument"},
5162   {AttributeCommonInfo::AS_C23, "clang::coro_await_elidable_argument"},
5163 };
5164 struct ParsedAttrInfoCoroAwaitElidableArgument final : public ParsedAttrInfo {
5165   constexpr ParsedAttrInfoCoroAwaitElidableArgument() : ParsedAttrInfo(
5166     /*AttrKind=*/ParsedAttr::AT_CoroAwaitElidableArgument,
5167     /*NumArgs=*/0,
5168     /*OptArgs=*/0,
5169     /*NumArgMembers=*/0,
5170     /*HasCustomParsing=*/0,
5171     /*AcceptsExprPack=*/0,
5172     /*IsTargetSpecific=*/0,
5173     /*IsType=*/0,
5174     /*IsStmt=*/0,
5175     /*IsKnownToGCC=*/0,
5176     /*IsSupportedByPragmaAttribute=*/1,
5177     /*Spellings=*/CoroAwaitElidableArgumentSpellings,
5178     /*ArgNames=*/{}) {}
5179 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5180   if (!isa<ParmVarDecl>(D)) {
5181     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5182       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
5183     return false;
5184   }
5185   return true;
5186 }
5187 
5188 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5189   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5190     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5191   return false;
5192 }
5193 
5194 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5195   return LangOpts.CPlusPlus;
5196 }
5197 
5198 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5199   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
5200 }
5201 
5202 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5203   D->addAttr(::new (S.Context) CoroAwaitElidableArgumentAttr(S.Context, Attr));
5204   return AttributeApplied;
5205 }
5206 
5207 bool isParamExpr(size_t N) const override {
5208   return false;
5209 }
5210 
5211 static const ParsedAttrInfoCoroAwaitElidableArgument Instance;
5212 };
5213 const ParsedAttrInfoCoroAwaitElidableArgument ParsedAttrInfoCoroAwaitElidableArgument::Instance;
5214 static constexpr ParsedAttrInfo::Spelling CoroDisableLifetimeBoundSpellings[] = {
5215   {AttributeCommonInfo::AS_GNU, "coro_disable_lifetimebound"},
5216   {AttributeCommonInfo::AS_CXX11, "clang::coro_disable_lifetimebound"},
5217   {AttributeCommonInfo::AS_C23, "clang::coro_disable_lifetimebound"},
5218 };
5219 struct ParsedAttrInfoCoroDisableLifetimeBound final : public ParsedAttrInfo {
5220   constexpr ParsedAttrInfoCoroDisableLifetimeBound() : ParsedAttrInfo(
5221     /*AttrKind=*/ParsedAttr::AT_CoroDisableLifetimeBound,
5222     /*NumArgs=*/0,
5223     /*OptArgs=*/0,
5224     /*NumArgMembers=*/0,
5225     /*HasCustomParsing=*/0,
5226     /*AcceptsExprPack=*/0,
5227     /*IsTargetSpecific=*/0,
5228     /*IsType=*/0,
5229     /*IsStmt=*/0,
5230     /*IsKnownToGCC=*/0,
5231     /*IsSupportedByPragmaAttribute=*/1,
5232     /*Spellings=*/CoroDisableLifetimeBoundSpellings,
5233     /*ArgNames=*/{}) {}
5234 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5235   if (!isa<FunctionDecl>(D)) {
5236     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5237       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5238     return false;
5239   }
5240   return true;
5241 }
5242 
5243 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5244   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5245     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5246   return false;
5247 }
5248 
5249 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5250   return LangOpts.CPlusPlus;
5251 }
5252 
5253 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5254   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5255 }
5256 
5257 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5258   D->addAttr(::new (S.Context) CoroDisableLifetimeBoundAttr(S.Context, Attr));
5259   return AttributeApplied;
5260 }
5261 
5262 bool isParamExpr(size_t N) const override {
5263   return false;
5264 }
5265 
5266 static const ParsedAttrInfoCoroDisableLifetimeBound Instance;
5267 };
5268 const ParsedAttrInfoCoroDisableLifetimeBound ParsedAttrInfoCoroDisableLifetimeBound::Instance;
5269 static constexpr ParsedAttrInfo::Spelling CoroLifetimeBoundSpellings[] = {
5270   {AttributeCommonInfo::AS_GNU, "coro_lifetimebound"},
5271   {AttributeCommonInfo::AS_CXX11, "clang::coro_lifetimebound"},
5272   {AttributeCommonInfo::AS_C23, "clang::coro_lifetimebound"},
5273 };
5274 struct ParsedAttrInfoCoroLifetimeBound final : public ParsedAttrInfo {
5275   constexpr ParsedAttrInfoCoroLifetimeBound() : ParsedAttrInfo(
5276     /*AttrKind=*/ParsedAttr::AT_CoroLifetimeBound,
5277     /*NumArgs=*/0,
5278     /*OptArgs=*/0,
5279     /*NumArgMembers=*/0,
5280     /*HasCustomParsing=*/0,
5281     /*AcceptsExprPack=*/0,
5282     /*IsTargetSpecific=*/0,
5283     /*IsType=*/0,
5284     /*IsStmt=*/0,
5285     /*IsKnownToGCC=*/0,
5286     /*IsSupportedByPragmaAttribute=*/1,
5287     /*Spellings=*/CoroLifetimeBoundSpellings,
5288     /*ArgNames=*/{}) {}
5289 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5290   if (!isa<CXXRecordDecl>(D)) {
5291     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5292       << Attr << Attr.isRegularKeywordAttribute() << "classes";
5293     return false;
5294   }
5295   return true;
5296 }
5297 
5298 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5299   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5300     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5301   return false;
5302 }
5303 
5304 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5305   return LangOpts.CPlusPlus;
5306 }
5307 
5308 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5309   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5310 }
5311 
5312 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5313   D->addAttr(::new (S.Context) CoroLifetimeBoundAttr(S.Context, Attr));
5314   return AttributeApplied;
5315 }
5316 
5317 bool isParamExpr(size_t N) const override {
5318   return false;
5319 }
5320 
5321 static const ParsedAttrInfoCoroLifetimeBound Instance;
5322 };
5323 const ParsedAttrInfoCoroLifetimeBound ParsedAttrInfoCoroLifetimeBound::Instance;
5324 static constexpr ParsedAttrInfo::Spelling CoroOnlyDestroyWhenCompleteSpellings[] = {
5325   {AttributeCommonInfo::AS_GNU, "coro_only_destroy_when_complete"},
5326   {AttributeCommonInfo::AS_CXX11, "clang::coro_only_destroy_when_complete"},
5327   {AttributeCommonInfo::AS_C23, "clang::coro_only_destroy_when_complete"},
5328 };
5329 struct ParsedAttrInfoCoroOnlyDestroyWhenComplete final : public ParsedAttrInfo {
5330   constexpr ParsedAttrInfoCoroOnlyDestroyWhenComplete() : ParsedAttrInfo(
5331     /*AttrKind=*/ParsedAttr::AT_CoroOnlyDestroyWhenComplete,
5332     /*NumArgs=*/0,
5333     /*OptArgs=*/0,
5334     /*NumArgMembers=*/0,
5335     /*HasCustomParsing=*/0,
5336     /*AcceptsExprPack=*/0,
5337     /*IsTargetSpecific=*/0,
5338     /*IsType=*/0,
5339     /*IsStmt=*/0,
5340     /*IsKnownToGCC=*/0,
5341     /*IsSupportedByPragmaAttribute=*/1,
5342     /*Spellings=*/CoroOnlyDestroyWhenCompleteSpellings,
5343     /*ArgNames=*/{}) {}
5344 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5345   if (!isa<CXXRecordDecl>(D)) {
5346     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5347       << Attr << Attr.isRegularKeywordAttribute() << "classes";
5348     return false;
5349   }
5350   return true;
5351 }
5352 
5353 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5354   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5355     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5356   return false;
5357 }
5358 
5359 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5360   return LangOpts.CPlusPlus;
5361 }
5362 
5363 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5364   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5365 }
5366 
5367 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5368   D->addAttr(::new (S.Context) CoroOnlyDestroyWhenCompleteAttr(S.Context, Attr));
5369   return AttributeApplied;
5370 }
5371 
5372 bool isParamExpr(size_t N) const override {
5373   return false;
5374 }
5375 
5376 static const ParsedAttrInfoCoroOnlyDestroyWhenComplete Instance;
5377 };
5378 const ParsedAttrInfoCoroOnlyDestroyWhenComplete ParsedAttrInfoCoroOnlyDestroyWhenComplete::Instance;
5379 static constexpr ParsedAttrInfo::Spelling CoroReturnTypeSpellings[] = {
5380   {AttributeCommonInfo::AS_GNU, "coro_return_type"},
5381   {AttributeCommonInfo::AS_CXX11, "clang::coro_return_type"},
5382   {AttributeCommonInfo::AS_C23, "clang::coro_return_type"},
5383 };
5384 struct ParsedAttrInfoCoroReturnType final : public ParsedAttrInfo {
5385   constexpr ParsedAttrInfoCoroReturnType() : ParsedAttrInfo(
5386     /*AttrKind=*/ParsedAttr::AT_CoroReturnType,
5387     /*NumArgs=*/0,
5388     /*OptArgs=*/0,
5389     /*NumArgMembers=*/0,
5390     /*HasCustomParsing=*/0,
5391     /*AcceptsExprPack=*/0,
5392     /*IsTargetSpecific=*/0,
5393     /*IsType=*/0,
5394     /*IsStmt=*/0,
5395     /*IsKnownToGCC=*/0,
5396     /*IsSupportedByPragmaAttribute=*/1,
5397     /*Spellings=*/CoroReturnTypeSpellings,
5398     /*ArgNames=*/{}) {}
5399 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5400   if (!isa<CXXRecordDecl>(D)) {
5401     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5402       << Attr << Attr.isRegularKeywordAttribute() << "classes";
5403     return false;
5404   }
5405   return true;
5406 }
5407 
5408 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5409   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5410     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5411   return false;
5412 }
5413 
5414 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5415   return LangOpts.CPlusPlus;
5416 }
5417 
5418 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5419   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5420 }
5421 
5422 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5423   D->addAttr(::new (S.Context) CoroReturnTypeAttr(S.Context, Attr));
5424   return AttributeApplied;
5425 }
5426 
5427 bool isParamExpr(size_t N) const override {
5428   return false;
5429 }
5430 
5431 static const ParsedAttrInfoCoroReturnType Instance;
5432 };
5433 const ParsedAttrInfoCoroReturnType ParsedAttrInfoCoroReturnType::Instance;
5434 static constexpr ParsedAttrInfo::Spelling CoroWrapperSpellings[] = {
5435   {AttributeCommonInfo::AS_GNU, "coro_wrapper"},
5436   {AttributeCommonInfo::AS_CXX11, "clang::coro_wrapper"},
5437   {AttributeCommonInfo::AS_C23, "clang::coro_wrapper"},
5438 };
5439 struct ParsedAttrInfoCoroWrapper final : public ParsedAttrInfo {
5440   constexpr ParsedAttrInfoCoroWrapper() : ParsedAttrInfo(
5441     /*AttrKind=*/ParsedAttr::AT_CoroWrapper,
5442     /*NumArgs=*/0,
5443     /*OptArgs=*/0,
5444     /*NumArgMembers=*/0,
5445     /*HasCustomParsing=*/0,
5446     /*AcceptsExprPack=*/0,
5447     /*IsTargetSpecific=*/0,
5448     /*IsType=*/0,
5449     /*IsStmt=*/0,
5450     /*IsKnownToGCC=*/0,
5451     /*IsSupportedByPragmaAttribute=*/1,
5452     /*Spellings=*/CoroWrapperSpellings,
5453     /*ArgNames=*/{}) {}
5454 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5455   if (!isa<FunctionDecl>(D)) {
5456     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5457       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5458     return false;
5459   }
5460   return true;
5461 }
5462 
5463 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5464   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5465     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5466   return false;
5467 }
5468 
5469 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5470   return LangOpts.CPlusPlus;
5471 }
5472 
5473 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5474   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5475 }
5476 
5477 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5478   D->addAttr(::new (S.Context) CoroWrapperAttr(S.Context, Attr));
5479   return AttributeApplied;
5480 }
5481 
5482 bool isParamExpr(size_t N) const override {
5483   return false;
5484 }
5485 
5486 static const ParsedAttrInfoCoroWrapper Instance;
5487 };
5488 const ParsedAttrInfoCoroWrapper ParsedAttrInfoCoroWrapper::Instance;
5489 static constexpr ParsedAttrInfo::Spelling CountedBySpellings[] = {
5490   {AttributeCommonInfo::AS_GNU, "counted_by"},
5491   {AttributeCommonInfo::AS_CXX11, "clang::counted_by"},
5492   {AttributeCommonInfo::AS_C23, "clang::counted_by"},
5493 };
5494 static constexpr const char *CountedByArgNames[] = {
5495 "Count","NestedLevel",};
5496 struct ParsedAttrInfoCountedBy final : public ParsedAttrInfo {
5497   constexpr ParsedAttrInfoCountedBy() : ParsedAttrInfo(
5498     /*AttrKind=*/ParsedAttr::AT_CountedBy,
5499     /*NumArgs=*/1,
5500     /*OptArgs=*/1,
5501     /*NumArgMembers=*/2,
5502     /*HasCustomParsing=*/0,
5503     /*AcceptsExprPack=*/0,
5504     /*IsTargetSpecific=*/0,
5505     /*IsType=*/1,
5506     /*IsStmt=*/0,
5507     /*IsKnownToGCC=*/0,
5508     /*IsSupportedByPragmaAttribute=*/0,
5509     /*Spellings=*/CountedBySpellings,
5510     /*ArgNames=*/CountedByArgNames) {}
5511 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5512   if (!isa<FieldDecl>(D)) {
5513     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
5514       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members";
5515     return false;
5516   }
5517   return true;
5518 }
5519 
5520 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5521   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5522     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5523   return false;
5524 }
5525 
5526 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5527   return (!LangOpts.CPlusPlus);
5528 }
5529 
5530 bool isParamExpr(size_t N) const override {
5531   return (N == 0) || false;
5532 }
5533 
5534 static const ParsedAttrInfoCountedBy Instance;
5535 };
5536 const ParsedAttrInfoCountedBy ParsedAttrInfoCountedBy::Instance;
5537 static constexpr ParsedAttrInfo::Spelling CountedByOrNullSpellings[] = {
5538   {AttributeCommonInfo::AS_GNU, "counted_by_or_null"},
5539   {AttributeCommonInfo::AS_CXX11, "clang::counted_by_or_null"},
5540   {AttributeCommonInfo::AS_C23, "clang::counted_by_or_null"},
5541 };
5542 static constexpr const char *CountedByOrNullArgNames[] = {
5543 "Count","NestedLevel",};
5544 struct ParsedAttrInfoCountedByOrNull final : public ParsedAttrInfo {
5545   constexpr ParsedAttrInfoCountedByOrNull() : ParsedAttrInfo(
5546     /*AttrKind=*/ParsedAttr::AT_CountedByOrNull,
5547     /*NumArgs=*/1,
5548     /*OptArgs=*/1,
5549     /*NumArgMembers=*/2,
5550     /*HasCustomParsing=*/0,
5551     /*AcceptsExprPack=*/0,
5552     /*IsTargetSpecific=*/0,
5553     /*IsType=*/1,
5554     /*IsStmt=*/0,
5555     /*IsKnownToGCC=*/0,
5556     /*IsSupportedByPragmaAttribute=*/0,
5557     /*Spellings=*/CountedByOrNullSpellings,
5558     /*ArgNames=*/CountedByOrNullArgNames) {}
5559 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5560   if (!isa<FieldDecl>(D)) {
5561     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
5562       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members";
5563     return false;
5564   }
5565   return true;
5566 }
5567 
5568 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5569   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5570     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5571   return false;
5572 }
5573 
5574 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
5575   return (!LangOpts.CPlusPlus);
5576 }
5577 
5578 bool isParamExpr(size_t N) const override {
5579   return (N == 0) || false;
5580 }
5581 
5582 static const ParsedAttrInfoCountedByOrNull Instance;
5583 };
5584 const ParsedAttrInfoCountedByOrNull ParsedAttrInfoCountedByOrNull::Instance;
5585 static constexpr ParsedAttrInfo::Spelling DLLExportSpellings[] = {
5586   {AttributeCommonInfo::AS_Declspec, "dllexport"},
5587   {AttributeCommonInfo::AS_GNU, "dllexport"},
5588   {AttributeCommonInfo::AS_CXX11, "gnu::dllexport"},
5589   {AttributeCommonInfo::AS_C23, "gnu::dllexport"},
5590 };
5591 struct ParsedAttrInfoDLLExport final : public ParsedAttrInfo {
5592   constexpr ParsedAttrInfoDLLExport() : ParsedAttrInfo(
5593     /*AttrKind=*/ParsedAttr::AT_DLLExport,
5594     /*NumArgs=*/0,
5595     /*OptArgs=*/0,
5596     /*NumArgMembers=*/0,
5597     /*HasCustomParsing=*/0,
5598     /*AcceptsExprPack=*/0,
5599     /*IsTargetSpecific=*/1,
5600     /*IsType=*/0,
5601     /*IsStmt=*/0,
5602     /*IsKnownToGCC=*/1,
5603     /*IsSupportedByPragmaAttribute=*/1,
5604     /*Spellings=*/DLLExportSpellings,
5605     /*ArgNames=*/{}) {}
5606 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5607   if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D)) {
5608     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5609       << Attr << Attr.isRegularKeywordAttribute() << "functions, variables, classes, and Objective-C interfaces";
5610     return false;
5611   }
5612   return true;
5613 }
5614 
5615 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5616   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5617     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5618   return false;
5619 }
5620 
5621 bool existsInTarget(const TargetInfo &Target) const override {
5622   const llvm::Triple &T = Target.getTriple(); (void)T;
5623   return true && ( Target.getTriple().hasDLLImportExport() );
5624 }
5625 
5626 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5627   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5628   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
5629   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5630   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
5631 }
5632 
5633 bool isParamExpr(size_t N) const override {
5634   return false;
5635 }
5636 
5637 static const ParsedAttrInfoDLLExport Instance;
5638 };
5639 const ParsedAttrInfoDLLExport ParsedAttrInfoDLLExport::Instance;
5640 struct ParsedAttrInfoDLLExportStaticLocal final : public ParsedAttrInfo {
5641   constexpr ParsedAttrInfoDLLExportStaticLocal() : ParsedAttrInfo(
5642     /*AttrKind=*/ParsedAttr::AT_DLLExportStaticLocal,
5643     /*NumArgs=*/0,
5644     /*OptArgs=*/0,
5645     /*NumArgMembers=*/0,
5646     /*HasCustomParsing=*/0,
5647     /*AcceptsExprPack=*/0,
5648     /*IsTargetSpecific=*/1,
5649     /*IsType=*/0,
5650     /*IsStmt=*/0,
5651     /*IsKnownToGCC=*/0,
5652     /*IsSupportedByPragmaAttribute=*/0,
5653     /*Spellings=*/{},
5654     /*ArgNames=*/{}) {}
5655 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5656   if (!isa<FunctionDecl>(D)) {
5657     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5658       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5659     return false;
5660   }
5661   return true;
5662 }
5663 
5664 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5665   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5666     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5667   return false;
5668 }
5669 
5670 bool existsInTarget(const TargetInfo &Target) const override {
5671   const llvm::Triple &T = Target.getTriple(); (void)T;
5672   return true && ( Target.getTriple().hasDLLImportExport() );
5673 }
5674 
5675 bool isParamExpr(size_t N) const override {
5676   return false;
5677 }
5678 
5679 static const ParsedAttrInfoDLLExportStaticLocal Instance;
5680 };
5681 const ParsedAttrInfoDLLExportStaticLocal ParsedAttrInfoDLLExportStaticLocal::Instance;
5682 static constexpr ParsedAttrInfo::Spelling DLLImportSpellings[] = {
5683   {AttributeCommonInfo::AS_Declspec, "dllimport"},
5684   {AttributeCommonInfo::AS_GNU, "dllimport"},
5685   {AttributeCommonInfo::AS_CXX11, "gnu::dllimport"},
5686   {AttributeCommonInfo::AS_C23, "gnu::dllimport"},
5687 };
5688 struct ParsedAttrInfoDLLImport final : public ParsedAttrInfo {
5689   constexpr ParsedAttrInfoDLLImport() : ParsedAttrInfo(
5690     /*AttrKind=*/ParsedAttr::AT_DLLImport,
5691     /*NumArgs=*/0,
5692     /*OptArgs=*/0,
5693     /*NumArgMembers=*/0,
5694     /*HasCustomParsing=*/0,
5695     /*AcceptsExprPack=*/0,
5696     /*IsTargetSpecific=*/1,
5697     /*IsType=*/0,
5698     /*IsStmt=*/0,
5699     /*IsKnownToGCC=*/1,
5700     /*IsSupportedByPragmaAttribute=*/1,
5701     /*Spellings=*/DLLImportSpellings,
5702     /*ArgNames=*/{}) {}
5703 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5704   if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D) && !isa<CXXRecordDecl>(D) && !isa<ObjCInterfaceDecl>(D)) {
5705     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5706       << Attr << Attr.isRegularKeywordAttribute() << "functions, variables, classes, and Objective-C interfaces";
5707     return false;
5708   }
5709   return true;
5710 }
5711 
5712 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5713   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5714     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5715   return false;
5716 }
5717 
5718 bool existsInTarget(const TargetInfo &Target) const override {
5719   const llvm::Triple &T = Target.getTriple(); (void)T;
5720   return true && ( Target.getTriple().hasDLLImportExport() );
5721 }
5722 
5723 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5724   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5725   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
5726   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
5727   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
5728 }
5729 
5730 bool isParamExpr(size_t N) const override {
5731   return false;
5732 }
5733 
5734 static const ParsedAttrInfoDLLImport Instance;
5735 };
5736 const ParsedAttrInfoDLLImport ParsedAttrInfoDLLImport::Instance;
5737 struct ParsedAttrInfoDLLImportStaticLocal final : public ParsedAttrInfo {
5738   constexpr ParsedAttrInfoDLLImportStaticLocal() : ParsedAttrInfo(
5739     /*AttrKind=*/ParsedAttr::AT_DLLImportStaticLocal,
5740     /*NumArgs=*/0,
5741     /*OptArgs=*/0,
5742     /*NumArgMembers=*/0,
5743     /*HasCustomParsing=*/0,
5744     /*AcceptsExprPack=*/0,
5745     /*IsTargetSpecific=*/1,
5746     /*IsType=*/0,
5747     /*IsStmt=*/0,
5748     /*IsKnownToGCC=*/0,
5749     /*IsSupportedByPragmaAttribute=*/0,
5750     /*Spellings=*/{},
5751     /*ArgNames=*/{}) {}
5752 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5753   if (!isa<FunctionDecl>(D)) {
5754     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5755       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5756     return false;
5757   }
5758   return true;
5759 }
5760 
5761 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5762   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5763     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5764   return false;
5765 }
5766 
5767 bool existsInTarget(const TargetInfo &Target) const override {
5768   const llvm::Triple &T = Target.getTriple(); (void)T;
5769   return true && ( Target.getTriple().hasDLLImportExport() );
5770 }
5771 
5772 bool isParamExpr(size_t N) const override {
5773   return false;
5774 }
5775 
5776 static const ParsedAttrInfoDLLImportStaticLocal Instance;
5777 };
5778 const ParsedAttrInfoDLLImportStaticLocal ParsedAttrInfoDLLImportStaticLocal::Instance;
5779 static constexpr ParsedAttrInfo::Spelling DeprecatedSpellings[] = {
5780   {AttributeCommonInfo::AS_GNU, "deprecated"},
5781   {AttributeCommonInfo::AS_CXX11, "gnu::deprecated"},
5782   {AttributeCommonInfo::AS_C23, "gnu::deprecated"},
5783   {AttributeCommonInfo::AS_Declspec, "deprecated"},
5784   {AttributeCommonInfo::AS_CXX11, "deprecated"},
5785   {AttributeCommonInfo::AS_C23, "deprecated"},
5786 };
5787 static constexpr const char *DeprecatedArgNames[] = {
5788 "Message","Replacement",};
5789 struct ParsedAttrInfoDeprecated final : public ParsedAttrInfo {
5790   constexpr ParsedAttrInfoDeprecated() : ParsedAttrInfo(
5791     /*AttrKind=*/ParsedAttr::AT_Deprecated,
5792     /*NumArgs=*/0,
5793     /*OptArgs=*/2,
5794     /*NumArgMembers=*/2,
5795     /*HasCustomParsing=*/0,
5796     /*AcceptsExprPack=*/0,
5797     /*IsTargetSpecific=*/0,
5798     /*IsType=*/0,
5799     /*IsStmt=*/0,
5800     /*IsKnownToGCC=*/1,
5801     /*IsSupportedByPragmaAttribute=*/0,
5802     /*Spellings=*/DeprecatedSpellings,
5803     /*ArgNames=*/DeprecatedArgNames) {}
5804 bool isParamExpr(size_t N) const override {
5805   return false;
5806 }
5807 
5808 static const ParsedAttrInfoDeprecated Instance;
5809 };
5810 const ParsedAttrInfoDeprecated ParsedAttrInfoDeprecated::Instance;
5811 static constexpr ParsedAttrInfo::Spelling DestructorSpellings[] = {
5812   {AttributeCommonInfo::AS_GNU, "destructor"},
5813   {AttributeCommonInfo::AS_CXX11, "gnu::destructor"},
5814   {AttributeCommonInfo::AS_C23, "gnu::destructor"},
5815 };
5816 static constexpr const char *DestructorArgNames[] = {
5817 "Priority",};
5818 struct ParsedAttrInfoDestructor final : public ParsedAttrInfo {
5819   constexpr ParsedAttrInfoDestructor() : ParsedAttrInfo(
5820     /*AttrKind=*/ParsedAttr::AT_Destructor,
5821     /*NumArgs=*/0,
5822     /*OptArgs=*/1,
5823     /*NumArgMembers=*/1,
5824     /*HasCustomParsing=*/0,
5825     /*AcceptsExprPack=*/0,
5826     /*IsTargetSpecific=*/0,
5827     /*IsType=*/0,
5828     /*IsStmt=*/0,
5829     /*IsKnownToGCC=*/1,
5830     /*IsSupportedByPragmaAttribute=*/1,
5831     /*Spellings=*/DestructorSpellings,
5832     /*ArgNames=*/DestructorArgNames) {}
5833 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5834   if (!isa<FunctionDecl>(D)) {
5835     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5836       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5837     return false;
5838   }
5839   return true;
5840 }
5841 
5842 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5843   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5844     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5845   return false;
5846 }
5847 
5848 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5849   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5850 }
5851 
5852 bool isParamExpr(size_t N) const override {
5853   return false;
5854 }
5855 
5856 static const ParsedAttrInfoDestructor Instance;
5857 };
5858 const ParsedAttrInfoDestructor ParsedAttrInfoDestructor::Instance;
5859 static constexpr ParsedAttrInfo::Spelling DiagnoseAsBuiltinSpellings[] = {
5860   {AttributeCommonInfo::AS_GNU, "diagnose_as_builtin"},
5861   {AttributeCommonInfo::AS_CXX11, "clang::diagnose_as_builtin"},
5862   {AttributeCommonInfo::AS_C23, "clang::diagnose_as_builtin"},
5863 };
5864 static constexpr const char *DiagnoseAsBuiltinArgNames[] = {
5865 "Function","ArgIndices...",};
5866 struct ParsedAttrInfoDiagnoseAsBuiltin final : public ParsedAttrInfo {
5867   constexpr ParsedAttrInfoDiagnoseAsBuiltin() : ParsedAttrInfo(
5868     /*AttrKind=*/ParsedAttr::AT_DiagnoseAsBuiltin,
5869     /*NumArgs=*/1,
5870     /*OptArgs=*/15,
5871     /*NumArgMembers=*/2,
5872     /*HasCustomParsing=*/0,
5873     /*AcceptsExprPack=*/0,
5874     /*IsTargetSpecific=*/0,
5875     /*IsType=*/0,
5876     /*IsStmt=*/0,
5877     /*IsKnownToGCC=*/0,
5878     /*IsSupportedByPragmaAttribute=*/1,
5879     /*Spellings=*/DiagnoseAsBuiltinSpellings,
5880     /*ArgNames=*/DiagnoseAsBuiltinArgNames) {}
5881 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5882   if (!isa<FunctionDecl>(D)) {
5883     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5884       << Attr << Attr.isRegularKeywordAttribute() << "functions";
5885     return false;
5886   }
5887   return true;
5888 }
5889 
5890 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5891   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5892     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5893   return false;
5894 }
5895 
5896 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5897   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5898 }
5899 
5900 bool isParamExpr(size_t N) const override {
5901   return false;
5902 }
5903 
5904 static const ParsedAttrInfoDiagnoseAsBuiltin Instance;
5905 };
5906 const ParsedAttrInfoDiagnoseAsBuiltin ParsedAttrInfoDiagnoseAsBuiltin::Instance;
5907 static constexpr ParsedAttrInfo::Spelling DiagnoseIfSpellings[] = {
5908   {AttributeCommonInfo::AS_GNU, "diagnose_if"},
5909 };
5910 static constexpr const char *DiagnoseIfArgNames[] = {
5911 "Cond","Message","DefaultSeverity","WarningGroup",};
5912 struct ParsedAttrInfoDiagnoseIf final : public ParsedAttrInfo {
5913   constexpr ParsedAttrInfoDiagnoseIf() : ParsedAttrInfo(
5914     /*AttrKind=*/ParsedAttr::AT_DiagnoseIf,
5915     /*NumArgs=*/3,
5916     /*OptArgs=*/1,
5917     /*NumArgMembers=*/4,
5918     /*HasCustomParsing=*/0,
5919     /*AcceptsExprPack=*/0,
5920     /*IsTargetSpecific=*/0,
5921     /*IsType=*/0,
5922     /*IsStmt=*/0,
5923     /*IsKnownToGCC=*/0,
5924     /*IsSupportedByPragmaAttribute=*/0,
5925     /*Spellings=*/DiagnoseIfSpellings,
5926     /*ArgNames=*/DiagnoseIfArgNames) {}
5927 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5928   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) {
5929     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5930       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and Objective-C properties";
5931     return false;
5932   }
5933   return true;
5934 }
5935 
5936 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5937   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5938     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5939   return false;
5940 }
5941 
5942 bool isParamExpr(size_t N) const override {
5943   return (N == 0) || false;
5944 }
5945 
5946 static const ParsedAttrInfoDiagnoseIf Instance;
5947 };
5948 const ParsedAttrInfoDiagnoseIf ParsedAttrInfoDiagnoseIf::Instance;
5949 static constexpr ParsedAttrInfo::Spelling DisableSanitizerInstrumentationSpellings[] = {
5950   {AttributeCommonInfo::AS_GNU, "disable_sanitizer_instrumentation"},
5951   {AttributeCommonInfo::AS_CXX11, "clang::disable_sanitizer_instrumentation"},
5952   {AttributeCommonInfo::AS_C23, "clang::disable_sanitizer_instrumentation"},
5953 };
5954 struct ParsedAttrInfoDisableSanitizerInstrumentation final : public ParsedAttrInfo {
5955   constexpr ParsedAttrInfoDisableSanitizerInstrumentation() : ParsedAttrInfo(
5956     /*AttrKind=*/ParsedAttr::AT_DisableSanitizerInstrumentation,
5957     /*NumArgs=*/0,
5958     /*OptArgs=*/0,
5959     /*NumArgMembers=*/0,
5960     /*HasCustomParsing=*/0,
5961     /*AcceptsExprPack=*/0,
5962     /*IsTargetSpecific=*/0,
5963     /*IsType=*/0,
5964     /*IsStmt=*/0,
5965     /*IsKnownToGCC=*/0,
5966     /*IsSupportedByPragmaAttribute=*/1,
5967     /*Spellings=*/DisableSanitizerInstrumentationSpellings,
5968     /*ArgNames=*/{}) {}
5969 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
5970   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D)) {
5971     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
5972       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and global variables";
5973     return false;
5974   }
5975   return true;
5976 }
5977 
5978 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
5979   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
5980     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
5981   return false;
5982 }
5983 
5984 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
5985   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
5986   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
5987   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
5988 }
5989 
5990 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
5991   D->addAttr(::new (S.Context) DisableSanitizerInstrumentationAttr(S.Context, Attr));
5992   return AttributeApplied;
5993 }
5994 
5995 bool isParamExpr(size_t N) const override {
5996   return false;
5997 }
5998 
5999 static const ParsedAttrInfoDisableSanitizerInstrumentation Instance;
6000 };
6001 const ParsedAttrInfoDisableSanitizerInstrumentation ParsedAttrInfoDisableSanitizerInstrumentation::Instance;
6002 static constexpr ParsedAttrInfo::Spelling DisableTailCallsSpellings[] = {
6003   {AttributeCommonInfo::AS_GNU, "disable_tail_calls"},
6004   {AttributeCommonInfo::AS_CXX11, "clang::disable_tail_calls"},
6005   {AttributeCommonInfo::AS_C23, "clang::disable_tail_calls"},
6006 };
6007 struct ParsedAttrInfoDisableTailCalls final : public ParsedAttrInfo {
6008   constexpr ParsedAttrInfoDisableTailCalls() : ParsedAttrInfo(
6009     /*AttrKind=*/ParsedAttr::AT_DisableTailCalls,
6010     /*NumArgs=*/0,
6011     /*OptArgs=*/0,
6012     /*NumArgMembers=*/0,
6013     /*HasCustomParsing=*/0,
6014     /*AcceptsExprPack=*/0,
6015     /*IsTargetSpecific=*/0,
6016     /*IsType=*/0,
6017     /*IsStmt=*/0,
6018     /*IsKnownToGCC=*/0,
6019     /*IsSupportedByPragmaAttribute=*/1,
6020     /*Spellings=*/DisableTailCallsSpellings,
6021     /*ArgNames=*/{}) {}
6022 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6023   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
6024     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6025       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
6026     return false;
6027   }
6028   return true;
6029 }
6030 
6031 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6032   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6033     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6034   return false;
6035 }
6036 
6037   using ParsedAttrInfo::diagMutualExclusion;
6038 
6039   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
6040     if (const auto *A = D->getAttr<NakedAttr>()) {
6041       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
6042       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
6043 return false;
6044     }
6045     return true;
6046   }
6047 
6048 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6049   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6050   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
6051 }
6052 
6053 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6054   D->addAttr(::new (S.Context) DisableTailCallsAttr(S.Context, Attr));
6055   return AttributeApplied;
6056 }
6057 
6058 bool isParamExpr(size_t N) const override {
6059   return false;
6060 }
6061 
6062 static const ParsedAttrInfoDisableTailCalls Instance;
6063 };
6064 const ParsedAttrInfoDisableTailCalls ParsedAttrInfoDisableTailCalls::Instance;
6065 static constexpr ParsedAttrInfo::Spelling EmptyBasesSpellings[] = {
6066   {AttributeCommonInfo::AS_Declspec, "empty_bases"},
6067 };
6068 struct ParsedAttrInfoEmptyBases final : public ParsedAttrInfo {
6069   constexpr ParsedAttrInfoEmptyBases() : ParsedAttrInfo(
6070     /*AttrKind=*/ParsedAttr::AT_EmptyBases,
6071     /*NumArgs=*/0,
6072     /*OptArgs=*/0,
6073     /*NumArgMembers=*/0,
6074     /*HasCustomParsing=*/0,
6075     /*AcceptsExprPack=*/0,
6076     /*IsTargetSpecific=*/1,
6077     /*IsType=*/0,
6078     /*IsStmt=*/0,
6079     /*IsKnownToGCC=*/0,
6080     /*IsSupportedByPragmaAttribute=*/0,
6081     /*Spellings=*/EmptyBasesSpellings,
6082     /*ArgNames=*/{}) {}
6083 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6084   if (!isa<CXXRecordDecl>(D)) {
6085     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6086       << Attr << Attr.isRegularKeywordAttribute() << "classes";
6087     return false;
6088   }
6089   return true;
6090 }
6091 
6092 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6093   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6094     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6095   return false;
6096 }
6097 
6098 bool existsInTarget(const TargetInfo &Target) const override {
6099   const llvm::Triple &T = Target.getTriple(); (void)T;
6100   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() );
6101 }
6102 
6103 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6104   D->addAttr(::new (S.Context) EmptyBasesAttr(S.Context, Attr));
6105   return AttributeApplied;
6106 }
6107 
6108 bool isParamExpr(size_t N) const override {
6109   return false;
6110 }
6111 
6112 static const ParsedAttrInfoEmptyBases Instance;
6113 };
6114 const ParsedAttrInfoEmptyBases ParsedAttrInfoEmptyBases::Instance;
6115 static constexpr ParsedAttrInfo::Spelling EnableIfSpellings[] = {
6116   {AttributeCommonInfo::AS_GNU, "enable_if"},
6117 };
6118 static constexpr const char *EnableIfArgNames[] = {
6119 "Cond","Message",};
6120 struct ParsedAttrInfoEnableIf final : public ParsedAttrInfo {
6121   constexpr ParsedAttrInfoEnableIf() : ParsedAttrInfo(
6122     /*AttrKind=*/ParsedAttr::AT_EnableIf,
6123     /*NumArgs=*/2,
6124     /*OptArgs=*/0,
6125     /*NumArgMembers=*/2,
6126     /*HasCustomParsing=*/0,
6127     /*AcceptsExprPack=*/0,
6128     /*IsTargetSpecific=*/0,
6129     /*IsType=*/0,
6130     /*IsStmt=*/0,
6131     /*IsKnownToGCC=*/0,
6132     /*IsSupportedByPragmaAttribute=*/1,
6133     /*Spellings=*/EnableIfSpellings,
6134     /*ArgNames=*/EnableIfArgNames) {}
6135 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6136   if (!isa<FunctionDecl>(D)) {
6137     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6138       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6139     return false;
6140   }
6141   return true;
6142 }
6143 
6144 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6145   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6146     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6147   return false;
6148 }
6149 
6150 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6151   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6152 }
6153 
6154 bool isParamExpr(size_t N) const override {
6155   return (N == 0) || false;
6156 }
6157 
6158 static const ParsedAttrInfoEnableIf Instance;
6159 };
6160 const ParsedAttrInfoEnableIf ParsedAttrInfoEnableIf::Instance;
6161 static constexpr ParsedAttrInfo::Spelling EnforceTCBSpellings[] = {
6162   {AttributeCommonInfo::AS_GNU, "enforce_tcb"},
6163   {AttributeCommonInfo::AS_CXX11, "clang::enforce_tcb"},
6164   {AttributeCommonInfo::AS_C23, "clang::enforce_tcb"},
6165 };
6166 static constexpr const char *EnforceTCBArgNames[] = {
6167 "TCBName",};
6168 struct ParsedAttrInfoEnforceTCB final : public ParsedAttrInfo {
6169   constexpr ParsedAttrInfoEnforceTCB() : ParsedAttrInfo(
6170     /*AttrKind=*/ParsedAttr::AT_EnforceTCB,
6171     /*NumArgs=*/1,
6172     /*OptArgs=*/0,
6173     /*NumArgMembers=*/1,
6174     /*HasCustomParsing=*/0,
6175     /*AcceptsExprPack=*/0,
6176     /*IsTargetSpecific=*/0,
6177     /*IsType=*/0,
6178     /*IsStmt=*/0,
6179     /*IsKnownToGCC=*/0,
6180     /*IsSupportedByPragmaAttribute=*/1,
6181     /*Spellings=*/EnforceTCBSpellings,
6182     /*ArgNames=*/EnforceTCBArgNames) {}
6183 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6184   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
6185     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6186       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
6187     return false;
6188   }
6189   return true;
6190 }
6191 
6192 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6193   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6194     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6195   return false;
6196 }
6197 
6198 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6199   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6200   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
6201 }
6202 
6203 bool isParamExpr(size_t N) const override {
6204   return false;
6205 }
6206 
6207 static const ParsedAttrInfoEnforceTCB Instance;
6208 };
6209 const ParsedAttrInfoEnforceTCB ParsedAttrInfoEnforceTCB::Instance;
6210 static constexpr ParsedAttrInfo::Spelling EnforceTCBLeafSpellings[] = {
6211   {AttributeCommonInfo::AS_GNU, "enforce_tcb_leaf"},
6212   {AttributeCommonInfo::AS_CXX11, "clang::enforce_tcb_leaf"},
6213   {AttributeCommonInfo::AS_C23, "clang::enforce_tcb_leaf"},
6214 };
6215 static constexpr const char *EnforceTCBLeafArgNames[] = {
6216 "TCBName",};
6217 struct ParsedAttrInfoEnforceTCBLeaf final : public ParsedAttrInfo {
6218   constexpr ParsedAttrInfoEnforceTCBLeaf() : ParsedAttrInfo(
6219     /*AttrKind=*/ParsedAttr::AT_EnforceTCBLeaf,
6220     /*NumArgs=*/1,
6221     /*OptArgs=*/0,
6222     /*NumArgMembers=*/1,
6223     /*HasCustomParsing=*/0,
6224     /*AcceptsExprPack=*/0,
6225     /*IsTargetSpecific=*/0,
6226     /*IsType=*/0,
6227     /*IsStmt=*/0,
6228     /*IsKnownToGCC=*/0,
6229     /*IsSupportedByPragmaAttribute=*/1,
6230     /*Spellings=*/EnforceTCBLeafSpellings,
6231     /*ArgNames=*/EnforceTCBLeafArgNames) {}
6232 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6233   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
6234     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6235       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
6236     return false;
6237   }
6238   return true;
6239 }
6240 
6241 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6242   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6243     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6244   return false;
6245 }
6246 
6247 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6248   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6249   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
6250 }
6251 
6252 bool isParamExpr(size_t N) const override {
6253   return false;
6254 }
6255 
6256 static const ParsedAttrInfoEnforceTCBLeaf Instance;
6257 };
6258 const ParsedAttrInfoEnforceTCBLeaf ParsedAttrInfoEnforceTCBLeaf::Instance;
6259 static constexpr ParsedAttrInfo::Spelling EnumExtensibilitySpellings[] = {
6260   {AttributeCommonInfo::AS_GNU, "enum_extensibility"},
6261   {AttributeCommonInfo::AS_CXX11, "clang::enum_extensibility"},
6262   {AttributeCommonInfo::AS_C23, "clang::enum_extensibility"},
6263 };
6264 static constexpr const char *EnumExtensibilityArgNames[] = {
6265 "Extensibility",};
6266 struct ParsedAttrInfoEnumExtensibility final : public ParsedAttrInfo {
6267   constexpr ParsedAttrInfoEnumExtensibility() : ParsedAttrInfo(
6268     /*AttrKind=*/ParsedAttr::AT_EnumExtensibility,
6269     /*NumArgs=*/1,
6270     /*OptArgs=*/0,
6271     /*NumArgMembers=*/1,
6272     /*HasCustomParsing=*/0,
6273     /*AcceptsExprPack=*/0,
6274     /*IsTargetSpecific=*/0,
6275     /*IsType=*/0,
6276     /*IsStmt=*/0,
6277     /*IsKnownToGCC=*/0,
6278     /*IsSupportedByPragmaAttribute=*/1,
6279     /*Spellings=*/EnumExtensibilitySpellings,
6280     /*ArgNames=*/EnumExtensibilityArgNames) {}
6281 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6282   if (!isa<EnumDecl>(D)) {
6283     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6284       << Attr << Attr.isRegularKeywordAttribute() << "enums";
6285     return false;
6286   }
6287   return true;
6288 }
6289 
6290 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6291   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6292     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6293   return false;
6294 }
6295 
6296 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6297   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
6298 }
6299 
6300 bool isParamExpr(size_t N) const override {
6301   return false;
6302 }
6303 
6304 static const ParsedAttrInfoEnumExtensibility Instance;
6305 };
6306 const ParsedAttrInfoEnumExtensibility ParsedAttrInfoEnumExtensibility::Instance;
6307 static constexpr ParsedAttrInfo::Spelling ErrorSpellings[] = {
6308   {AttributeCommonInfo::AS_GNU, "error"},
6309   {AttributeCommonInfo::AS_CXX11, "gnu::error"},
6310   {AttributeCommonInfo::AS_C23, "gnu::error"},
6311   {AttributeCommonInfo::AS_GNU, "warning"},
6312   {AttributeCommonInfo::AS_CXX11, "gnu::warning"},
6313   {AttributeCommonInfo::AS_C23, "gnu::warning"},
6314 };
6315 static constexpr const char *ErrorArgNames[] = {
6316 "UserDiagnostic",};
6317 struct ParsedAttrInfoError final : public ParsedAttrInfo {
6318   constexpr ParsedAttrInfoError() : ParsedAttrInfo(
6319     /*AttrKind=*/ParsedAttr::AT_Error,
6320     /*NumArgs=*/1,
6321     /*OptArgs=*/0,
6322     /*NumArgMembers=*/1,
6323     /*HasCustomParsing=*/0,
6324     /*AcceptsExprPack=*/0,
6325     /*IsTargetSpecific=*/0,
6326     /*IsType=*/0,
6327     /*IsStmt=*/0,
6328     /*IsKnownToGCC=*/1,
6329     /*IsSupportedByPragmaAttribute=*/1,
6330     /*Spellings=*/ErrorSpellings,
6331     /*ArgNames=*/ErrorArgNames) {}
6332 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6333   if (!isa<FunctionDecl>(D)) {
6334     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
6335       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6336     return false;
6337   }
6338   return true;
6339 }
6340 
6341 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6342   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6343     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6344   return false;
6345 }
6346 
6347 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
6348   enum Spelling {
6349     GNU_error = 0,
6350     CXX11_gnu_error = 1,
6351     C23_gnu_error = 2,
6352     GNU_warning = 3,
6353     CXX11_gnu_warning = 4,
6354     C23_gnu_warning = 5,
6355   SpellingNotCalculated = 15
6356 
6357   };
6358 
6359   unsigned Idx = Attr.getAttributeSpellingListIndex();
6360   switch (Idx) {
6361     default: llvm_unreachable("Unknown spelling list index");
6362     case 0: return GNU_error;
6363     case 1: return CXX11_gnu_error;
6364     case 2: return C23_gnu_error;
6365     case 3: return GNU_warning;
6366     case 4: return CXX11_gnu_warning;
6367     case 5: return C23_gnu_warning;
6368   }
6369 }
6370 
6371 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6372   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6373 }
6374 
6375 bool isParamExpr(size_t N) const override {
6376   return false;
6377 }
6378 
6379 static const ParsedAttrInfoError Instance;
6380 };
6381 const ParsedAttrInfoError ParsedAttrInfoError::Instance;
6382 static constexpr ParsedAttrInfo::Spelling ExcludeFromExplicitInstantiationSpellings[] = {
6383   {AttributeCommonInfo::AS_GNU, "exclude_from_explicit_instantiation"},
6384   {AttributeCommonInfo::AS_CXX11, "clang::exclude_from_explicit_instantiation"},
6385   {AttributeCommonInfo::AS_C23, "clang::exclude_from_explicit_instantiation"},
6386 };
6387 struct ParsedAttrInfoExcludeFromExplicitInstantiation final : public ParsedAttrInfo {
6388   constexpr ParsedAttrInfoExcludeFromExplicitInstantiation() : ParsedAttrInfo(
6389     /*AttrKind=*/ParsedAttr::AT_ExcludeFromExplicitInstantiation,
6390     /*NumArgs=*/0,
6391     /*OptArgs=*/0,
6392     /*NumArgMembers=*/0,
6393     /*HasCustomParsing=*/0,
6394     /*AcceptsExprPack=*/0,
6395     /*IsTargetSpecific=*/0,
6396     /*IsType=*/0,
6397     /*IsStmt=*/0,
6398     /*IsKnownToGCC=*/0,
6399     /*IsSupportedByPragmaAttribute=*/1,
6400     /*Spellings=*/ExcludeFromExplicitInstantiationSpellings,
6401     /*ArgNames=*/{}) {}
6402 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6403   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) {
6404     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6405       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes";
6406     return false;
6407   }
6408   return true;
6409 }
6410 
6411 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6412   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6413     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6414   return false;
6415 }
6416 
6417 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6418   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
6419   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6420   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
6421 }
6422 
6423 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6424   D->addAttr(::new (S.Context) ExcludeFromExplicitInstantiationAttr(S.Context, Attr));
6425   return AttributeApplied;
6426 }
6427 
6428 bool isParamExpr(size_t N) const override {
6429   return false;
6430 }
6431 
6432 static const ParsedAttrInfoExcludeFromExplicitInstantiation Instance;
6433 };
6434 const ParsedAttrInfoExcludeFromExplicitInstantiation ParsedAttrInfoExcludeFromExplicitInstantiation::Instance;
6435 static constexpr ParsedAttrInfo::Spelling ExclusiveTrylockFunctionSpellings[] = {
6436   {AttributeCommonInfo::AS_GNU, "exclusive_trylock_function"},
6437 };
6438 static constexpr const char *ExclusiveTrylockFunctionArgNames[] = {
6439 "SuccessValue","Args...",};
6440 struct ParsedAttrInfoExclusiveTrylockFunction final : public ParsedAttrInfo {
6441   constexpr ParsedAttrInfoExclusiveTrylockFunction() : ParsedAttrInfo(
6442     /*AttrKind=*/ParsedAttr::AT_ExclusiveTrylockFunction,
6443     /*NumArgs=*/1,
6444     /*OptArgs=*/15,
6445     /*NumArgMembers=*/2,
6446     /*HasCustomParsing=*/0,
6447     /*AcceptsExprPack=*/0,
6448     /*IsTargetSpecific=*/0,
6449     /*IsType=*/0,
6450     /*IsStmt=*/0,
6451     /*IsKnownToGCC=*/0,
6452     /*IsSupportedByPragmaAttribute=*/0,
6453     /*Spellings=*/ExclusiveTrylockFunctionSpellings,
6454     /*ArgNames=*/ExclusiveTrylockFunctionArgNames) {}
6455 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6456   if (!isa<FunctionDecl>(D)) {
6457     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6458       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6459     return false;
6460   }
6461   return true;
6462 }
6463 
6464 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6465   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6466     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6467   return false;
6468 }
6469 
6470 bool isParamExpr(size_t N) const override {
6471   return (N == 0) || (N == 1) || false;
6472 }
6473 
6474 static const ParsedAttrInfoExclusiveTrylockFunction Instance;
6475 };
6476 const ParsedAttrInfoExclusiveTrylockFunction ParsedAttrInfoExclusiveTrylockFunction::Instance;
6477 static constexpr ParsedAttrInfo::Spelling ExplicitInitSpellings[] = {
6478   {AttributeCommonInfo::AS_GNU, "require_explicit_initialization"},
6479   {AttributeCommonInfo::AS_CXX11, "clang::require_explicit_initialization"},
6480   {AttributeCommonInfo::AS_C23, "clang::require_explicit_initialization"},
6481 };
6482 struct ParsedAttrInfoExplicitInit final : public ParsedAttrInfo {
6483   constexpr ParsedAttrInfoExplicitInit() : ParsedAttrInfo(
6484     /*AttrKind=*/ParsedAttr::AT_ExplicitInit,
6485     /*NumArgs=*/0,
6486     /*OptArgs=*/0,
6487     /*NumArgMembers=*/0,
6488     /*HasCustomParsing=*/0,
6489     /*AcceptsExprPack=*/0,
6490     /*IsTargetSpecific=*/0,
6491     /*IsType=*/0,
6492     /*IsStmt=*/0,
6493     /*IsKnownToGCC=*/0,
6494     /*IsSupportedByPragmaAttribute=*/1,
6495     /*Spellings=*/ExplicitInitSpellings,
6496     /*ArgNames=*/{}) {}
6497 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6498   if (!isa<FieldDecl>(D)) {
6499     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
6500       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members";
6501     return false;
6502   }
6503   return true;
6504 }
6505 
6506 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6507   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6508     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6509   return false;
6510 }
6511 
6512 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6513   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
6514 }
6515 
6516 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6517   D->addAttr(::new (S.Context) ExplicitInitAttr(S.Context, Attr));
6518   return AttributeApplied;
6519 }
6520 
6521 bool isParamExpr(size_t N) const override {
6522   return false;
6523 }
6524 
6525 static const ParsedAttrInfoExplicitInit Instance;
6526 };
6527 const ParsedAttrInfoExplicitInit ParsedAttrInfoExplicitInit::Instance;
6528 static constexpr ParsedAttrInfo::Spelling ExtVectorTypeSpellings[] = {
6529   {AttributeCommonInfo::AS_GNU, "ext_vector_type"},
6530 };
6531 static constexpr const char *ExtVectorTypeArgNames[] = {
6532 "NumElements",};
6533 struct ParsedAttrInfoExtVectorType final : public ParsedAttrInfo {
6534   constexpr ParsedAttrInfoExtVectorType() : ParsedAttrInfo(
6535     /*AttrKind=*/ParsedAttr::AT_ExtVectorType,
6536     /*NumArgs=*/1,
6537     /*OptArgs=*/0,
6538     /*NumArgMembers=*/1,
6539     /*HasCustomParsing=*/0,
6540     /*AcceptsExprPack=*/0,
6541     /*IsTargetSpecific=*/0,
6542     /*IsType=*/0,
6543     /*IsStmt=*/0,
6544     /*IsKnownToGCC=*/0,
6545     /*IsSupportedByPragmaAttribute=*/0,
6546     /*Spellings=*/ExtVectorTypeSpellings,
6547     /*ArgNames=*/ExtVectorTypeArgNames) {}
6548 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6549   if (!isa<TypedefNameDecl>(D)) {
6550     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
6551       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
6552     return false;
6553   }
6554   return true;
6555 }
6556 
6557 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6558   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6559     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6560   return false;
6561 }
6562 
6563 bool isParamExpr(size_t N) const override {
6564   return (N == 0) || false;
6565 }
6566 
6567 static const ParsedAttrInfoExtVectorType Instance;
6568 };
6569 const ParsedAttrInfoExtVectorType ParsedAttrInfoExtVectorType::Instance;
6570 static constexpr ParsedAttrInfo::Spelling ExternalSourceSymbolSpellings[] = {
6571   {AttributeCommonInfo::AS_GNU, "external_source_symbol"},
6572   {AttributeCommonInfo::AS_CXX11, "clang::external_source_symbol"},
6573   {AttributeCommonInfo::AS_C23, "clang::external_source_symbol"},
6574 };
6575 static constexpr const char *ExternalSourceSymbolArgNames[] = {
6576 "language","definedIn","generatedDeclaration","USR",};
6577 struct ParsedAttrInfoExternalSourceSymbol final : public ParsedAttrInfo {
6578   constexpr ParsedAttrInfoExternalSourceSymbol() : ParsedAttrInfo(
6579     /*AttrKind=*/ParsedAttr::AT_ExternalSourceSymbol,
6580     /*NumArgs=*/0,
6581     /*OptArgs=*/4,
6582     /*NumArgMembers=*/4,
6583     /*HasCustomParsing=*/1,
6584     /*AcceptsExprPack=*/0,
6585     /*IsTargetSpecific=*/0,
6586     /*IsType=*/0,
6587     /*IsStmt=*/0,
6588     /*IsKnownToGCC=*/0,
6589     /*IsSupportedByPragmaAttribute=*/1,
6590     /*Spellings=*/ExternalSourceSymbolSpellings,
6591     /*ArgNames=*/ExternalSourceSymbolArgNames) {}
6592 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6593   if (!isa<NamedDecl>(D)) {
6594     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6595       << Attr << Attr.isRegularKeywordAttribute() << "named declarations";
6596     return false;
6597   }
6598   return true;
6599 }
6600 
6601 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6602   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6603     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6604   return false;
6605 }
6606 
6607 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6608   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
6609   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
6610   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum_constant, /*IsSupported=*/true));
6611   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
6612   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6613   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_namespace, /*IsSupported=*/LangOpts.CPlusPlus));
6614   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC));
6615   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /*IsSupported=*/LangOpts.ObjC));
6616   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
6617   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
6618   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
6619   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC));
6620   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
6621   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
6622   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
6623 }
6624 
6625 bool isParamExpr(size_t N) const override {
6626   return false;
6627 }
6628 
6629 static const ParsedAttrInfoExternalSourceSymbol Instance;
6630 };
6631 const ParsedAttrInfoExternalSourceSymbol ParsedAttrInfoExternalSourceSymbol::Instance;
6632 static constexpr ParsedAttrInfo::Spelling FallThroughSpellings[] = {
6633   {AttributeCommonInfo::AS_CXX11, "fallthrough"},
6634   {AttributeCommonInfo::AS_C23, "fallthrough"},
6635   {AttributeCommonInfo::AS_CXX11, "clang::fallthrough"},
6636   {AttributeCommonInfo::AS_GNU, "fallthrough"},
6637   {AttributeCommonInfo::AS_CXX11, "gnu::fallthrough"},
6638   {AttributeCommonInfo::AS_C23, "gnu::fallthrough"},
6639 };
6640 struct ParsedAttrInfoFallThrough final : public ParsedAttrInfo {
6641   constexpr ParsedAttrInfoFallThrough() : ParsedAttrInfo(
6642     /*AttrKind=*/ParsedAttr::AT_FallThrough,
6643     /*NumArgs=*/0,
6644     /*OptArgs=*/0,
6645     /*NumArgMembers=*/0,
6646     /*HasCustomParsing=*/0,
6647     /*AcceptsExprPack=*/0,
6648     /*IsTargetSpecific=*/0,
6649     /*IsType=*/0,
6650     /*IsStmt=*/1,
6651     /*IsKnownToGCC=*/1,
6652     /*IsSupportedByPragmaAttribute=*/0,
6653     /*Spellings=*/FallThroughSpellings,
6654     /*ArgNames=*/{}) {}
6655 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
6656   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
6657     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
6658   return false;
6659 }
6660 
6661 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
6662   if (!isa<NullStmt>(St) && !isa<SwitchCase>(St)) {
6663     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
6664       << Attr << Attr.isRegularKeywordAttribute() << "empty statements";
6665     return false;
6666   }
6667   return true;
6668 }
6669 
6670 bool isParamExpr(size_t N) const override {
6671   return false;
6672 }
6673 
6674 static const ParsedAttrInfoFallThrough Instance;
6675 };
6676 const ParsedAttrInfoFallThrough ParsedAttrInfoFallThrough::Instance;
6677 static constexpr ParsedAttrInfo::Spelling FastCallSpellings[] = {
6678   {AttributeCommonInfo::AS_GNU, "fastcall"},
6679   {AttributeCommonInfo::AS_CXX11, "gnu::fastcall"},
6680   {AttributeCommonInfo::AS_C23, "gnu::fastcall"},
6681   {AttributeCommonInfo::AS_Keyword, "__fastcall"},
6682   {AttributeCommonInfo::AS_Keyword, "_fastcall"},
6683 };
6684 struct ParsedAttrInfoFastCall final : public ParsedAttrInfo {
6685   constexpr ParsedAttrInfoFastCall() : ParsedAttrInfo(
6686     /*AttrKind=*/ParsedAttr::AT_FastCall,
6687     /*NumArgs=*/0,
6688     /*OptArgs=*/0,
6689     /*NumArgMembers=*/0,
6690     /*HasCustomParsing=*/0,
6691     /*AcceptsExprPack=*/0,
6692     /*IsTargetSpecific=*/0,
6693     /*IsType=*/1,
6694     /*IsStmt=*/0,
6695     /*IsKnownToGCC=*/1,
6696     /*IsSupportedByPragmaAttribute=*/0,
6697     /*Spellings=*/FastCallSpellings,
6698     /*ArgNames=*/{}) {}
6699 bool isParamExpr(size_t N) const override {
6700   return false;
6701 }
6702 
6703 static const ParsedAttrInfoFastCall Instance;
6704 };
6705 const ParsedAttrInfoFastCall ParsedAttrInfoFastCall::Instance;
6706 static constexpr ParsedAttrInfo::Spelling FlagEnumSpellings[] = {
6707   {AttributeCommonInfo::AS_GNU, "flag_enum"},
6708   {AttributeCommonInfo::AS_CXX11, "clang::flag_enum"},
6709   {AttributeCommonInfo::AS_C23, "clang::flag_enum"},
6710 };
6711 struct ParsedAttrInfoFlagEnum final : public ParsedAttrInfo {
6712   constexpr ParsedAttrInfoFlagEnum() : ParsedAttrInfo(
6713     /*AttrKind=*/ParsedAttr::AT_FlagEnum,
6714     /*NumArgs=*/0,
6715     /*OptArgs=*/0,
6716     /*NumArgMembers=*/0,
6717     /*HasCustomParsing=*/0,
6718     /*AcceptsExprPack=*/0,
6719     /*IsTargetSpecific=*/0,
6720     /*IsType=*/0,
6721     /*IsStmt=*/0,
6722     /*IsKnownToGCC=*/0,
6723     /*IsSupportedByPragmaAttribute=*/1,
6724     /*Spellings=*/FlagEnumSpellings,
6725     /*ArgNames=*/{}) {}
6726 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6727   if (!isa<EnumDecl>(D)) {
6728     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6729       << Attr << Attr.isRegularKeywordAttribute() << "enums";
6730     return false;
6731   }
6732   return true;
6733 }
6734 
6735 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6736   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6737     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6738   return false;
6739 }
6740 
6741 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6742   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
6743 }
6744 
6745 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6746   D->addAttr(::new (S.Context) FlagEnumAttr(S.Context, Attr));
6747   return AttributeApplied;
6748 }
6749 
6750 bool isParamExpr(size_t N) const override {
6751   return false;
6752 }
6753 
6754 static const ParsedAttrInfoFlagEnum Instance;
6755 };
6756 const ParsedAttrInfoFlagEnum ParsedAttrInfoFlagEnum::Instance;
6757 static constexpr ParsedAttrInfo::Spelling FlattenSpellings[] = {
6758   {AttributeCommonInfo::AS_GNU, "flatten"},
6759   {AttributeCommonInfo::AS_CXX11, "gnu::flatten"},
6760   {AttributeCommonInfo::AS_C23, "gnu::flatten"},
6761 };
6762 struct ParsedAttrInfoFlatten final : public ParsedAttrInfo {
6763   constexpr ParsedAttrInfoFlatten() : ParsedAttrInfo(
6764     /*AttrKind=*/ParsedAttr::AT_Flatten,
6765     /*NumArgs=*/0,
6766     /*OptArgs=*/0,
6767     /*NumArgMembers=*/0,
6768     /*HasCustomParsing=*/0,
6769     /*AcceptsExprPack=*/0,
6770     /*IsTargetSpecific=*/0,
6771     /*IsType=*/0,
6772     /*IsStmt=*/0,
6773     /*IsKnownToGCC=*/1,
6774     /*IsSupportedByPragmaAttribute=*/1,
6775     /*Spellings=*/FlattenSpellings,
6776     /*ArgNames=*/{}) {}
6777 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6778   if (!isa<FunctionDecl>(D)) {
6779     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
6780       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6781     return false;
6782   }
6783   return true;
6784 }
6785 
6786 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6787   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6788     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6789   return false;
6790 }
6791 
6792 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6793   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6794 }
6795 
6796 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
6797   D->addAttr(::new (S.Context) FlattenAttr(S.Context, Attr));
6798   return AttributeApplied;
6799 }
6800 
6801 bool isParamExpr(size_t N) const override {
6802   return false;
6803 }
6804 
6805 static const ParsedAttrInfoFlatten Instance;
6806 };
6807 const ParsedAttrInfoFlatten ParsedAttrInfoFlatten::Instance;
6808 static constexpr ParsedAttrInfo::Spelling FormatSpellings[] = {
6809   {AttributeCommonInfo::AS_GNU, "format"},
6810   {AttributeCommonInfo::AS_CXX11, "gnu::format"},
6811   {AttributeCommonInfo::AS_C23, "gnu::format"},
6812 };
6813 static constexpr const char *FormatArgNames[] = {
6814 "Type","FormatIdx","FirstArg",};
6815 struct ParsedAttrInfoFormat final : public ParsedAttrInfo {
6816   constexpr ParsedAttrInfoFormat() : ParsedAttrInfo(
6817     /*AttrKind=*/ParsedAttr::AT_Format,
6818     /*NumArgs=*/3,
6819     /*OptArgs=*/0,
6820     /*NumArgMembers=*/3,
6821     /*HasCustomParsing=*/0,
6822     /*AcceptsExprPack=*/0,
6823     /*IsTargetSpecific=*/0,
6824     /*IsType=*/0,
6825     /*IsStmt=*/0,
6826     /*IsKnownToGCC=*/1,
6827     /*IsSupportedByPragmaAttribute=*/0,
6828     /*Spellings=*/FormatSpellings,
6829     /*ArgNames=*/FormatArgNames) {}
6830 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6831   if (!isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D) && !isHasFunctionProto(D)) {
6832     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6833       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, blocks, and non-K&R-style functions";
6834     return false;
6835   }
6836   return true;
6837 }
6838 
6839 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6840   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6841     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6842   return false;
6843 }
6844 
6845 bool isParamExpr(size_t N) const override {
6846   return false;
6847 }
6848 
6849 static const ParsedAttrInfoFormat Instance;
6850 };
6851 const ParsedAttrInfoFormat ParsedAttrInfoFormat::Instance;
6852 static constexpr ParsedAttrInfo::Spelling FormatArgSpellings[] = {
6853   {AttributeCommonInfo::AS_GNU, "format_arg"},
6854   {AttributeCommonInfo::AS_CXX11, "gnu::format_arg"},
6855   {AttributeCommonInfo::AS_C23, "gnu::format_arg"},
6856 };
6857 static constexpr const char *FormatArgArgNames[] = {
6858 "FormatIdx",};
6859 struct ParsedAttrInfoFormatArg final : public ParsedAttrInfo {
6860   constexpr ParsedAttrInfoFormatArg() : ParsedAttrInfo(
6861     /*AttrKind=*/ParsedAttr::AT_FormatArg,
6862     /*NumArgs=*/1,
6863     /*OptArgs=*/0,
6864     /*NumArgMembers=*/1,
6865     /*HasCustomParsing=*/0,
6866     /*AcceptsExprPack=*/0,
6867     /*IsTargetSpecific=*/0,
6868     /*IsType=*/0,
6869     /*IsStmt=*/0,
6870     /*IsKnownToGCC=*/1,
6871     /*IsSupportedByPragmaAttribute=*/0,
6872     /*Spellings=*/FormatArgSpellings,
6873     /*ArgNames=*/FormatArgArgNames) {}
6874 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6875   if (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D)) {
6876     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6877       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and non-K&R-style functions";
6878     return false;
6879   }
6880   return true;
6881 }
6882 
6883 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6884   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6885     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6886   return false;
6887 }
6888 
6889 bool isParamExpr(size_t N) const override {
6890   return false;
6891 }
6892 
6893 static const ParsedAttrInfoFormatArg Instance;
6894 };
6895 const ParsedAttrInfoFormatArg ParsedAttrInfoFormatArg::Instance;
6896 static constexpr ParsedAttrInfo::Spelling FunctionReturnThunksSpellings[] = {
6897   {AttributeCommonInfo::AS_GNU, "function_return"},
6898   {AttributeCommonInfo::AS_CXX11, "gnu::function_return"},
6899   {AttributeCommonInfo::AS_C23, "gnu::function_return"},
6900 };
6901 static constexpr const char *FunctionReturnThunksArgNames[] = {
6902 "ThunkType",};
6903 struct ParsedAttrInfoFunctionReturnThunks final : public ParsedAttrInfo {
6904   constexpr ParsedAttrInfoFunctionReturnThunks() : ParsedAttrInfo(
6905     /*AttrKind=*/ParsedAttr::AT_FunctionReturnThunks,
6906     /*NumArgs=*/1,
6907     /*OptArgs=*/0,
6908     /*NumArgMembers=*/1,
6909     /*HasCustomParsing=*/0,
6910     /*AcceptsExprPack=*/0,
6911     /*IsTargetSpecific=*/1,
6912     /*IsType=*/0,
6913     /*IsStmt=*/0,
6914     /*IsKnownToGCC=*/1,
6915     /*IsSupportedByPragmaAttribute=*/1,
6916     /*Spellings=*/FunctionReturnThunksSpellings,
6917     /*ArgNames=*/FunctionReturnThunksArgNames) {}
6918 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6919   if (!isa<FunctionDecl>(D)) {
6920     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6921       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6922     return false;
6923   }
6924   return true;
6925 }
6926 
6927 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6928   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6929     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6930   return false;
6931 }
6932 
6933 bool existsInTarget(const TargetInfo &Target) const override {
6934   const llvm::Triple &T = Target.getTriple(); (void)T;
6935   return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
6936 }
6937 
6938 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6939   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6940 }
6941 
6942 bool isParamExpr(size_t N) const override {
6943   return false;
6944 }
6945 
6946 static const ParsedAttrInfoFunctionReturnThunks Instance;
6947 };
6948 const ParsedAttrInfoFunctionReturnThunks ParsedAttrInfoFunctionReturnThunks::Instance;
6949 static constexpr ParsedAttrInfo::Spelling GNUInlineSpellings[] = {
6950   {AttributeCommonInfo::AS_GNU, "gnu_inline"},
6951   {AttributeCommonInfo::AS_CXX11, "gnu::gnu_inline"},
6952   {AttributeCommonInfo::AS_C23, "gnu::gnu_inline"},
6953 };
6954 struct ParsedAttrInfoGNUInline final : public ParsedAttrInfo {
6955   constexpr ParsedAttrInfoGNUInline() : ParsedAttrInfo(
6956     /*AttrKind=*/ParsedAttr::AT_GNUInline,
6957     /*NumArgs=*/0,
6958     /*OptArgs=*/0,
6959     /*NumArgMembers=*/0,
6960     /*HasCustomParsing=*/0,
6961     /*AcceptsExprPack=*/0,
6962     /*IsTargetSpecific=*/0,
6963     /*IsType=*/0,
6964     /*IsStmt=*/0,
6965     /*IsKnownToGCC=*/1,
6966     /*IsSupportedByPragmaAttribute=*/1,
6967     /*Spellings=*/GNUInlineSpellings,
6968     /*ArgNames=*/{}) {}
6969 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
6970   if (!isa<FunctionDecl>(D)) {
6971     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
6972       << Attr << Attr.isRegularKeywordAttribute() << "functions";
6973     return false;
6974   }
6975   return true;
6976 }
6977 
6978 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
6979   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
6980     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
6981   return false;
6982 }
6983 
6984 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
6985   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
6986 }
6987 
6988 bool isParamExpr(size_t N) const override {
6989   return false;
6990 }
6991 
6992 static const ParsedAttrInfoGNUInline Instance;
6993 };
6994 const ParsedAttrInfoGNUInline ParsedAttrInfoGNUInline::Instance;
6995 static constexpr ParsedAttrInfo::Spelling GuardedBySpellings[] = {
6996   {AttributeCommonInfo::AS_GNU, "guarded_by"},
6997 };
6998 static constexpr const char *GuardedByArgNames[] = {
6999 "Arg",};
7000 struct ParsedAttrInfoGuardedBy final : public ParsedAttrInfo {
7001   constexpr ParsedAttrInfoGuardedBy() : ParsedAttrInfo(
7002     /*AttrKind=*/ParsedAttr::AT_GuardedBy,
7003     /*NumArgs=*/1,
7004     /*OptArgs=*/0,
7005     /*NumArgMembers=*/1,
7006     /*HasCustomParsing=*/0,
7007     /*AcceptsExprPack=*/0,
7008     /*IsTargetSpecific=*/0,
7009     /*IsType=*/0,
7010     /*IsStmt=*/0,
7011     /*IsKnownToGCC=*/0,
7012     /*IsSupportedByPragmaAttribute=*/0,
7013     /*Spellings=*/GuardedBySpellings,
7014     /*ArgNames=*/GuardedByArgNames) {}
7015 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7016   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
7017     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7018       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
7019     return false;
7020   }
7021   return true;
7022 }
7023 
7024 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7025   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7026     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7027   return false;
7028 }
7029 
7030 bool isParamExpr(size_t N) const override {
7031   return (N == 0) || false;
7032 }
7033 
7034 static const ParsedAttrInfoGuardedBy Instance;
7035 };
7036 const ParsedAttrInfoGuardedBy ParsedAttrInfoGuardedBy::Instance;
7037 static constexpr ParsedAttrInfo::Spelling GuardedVarSpellings[] = {
7038   {AttributeCommonInfo::AS_GNU, "guarded_var"},
7039   {AttributeCommonInfo::AS_CXX11, "clang::guarded_var"},
7040 };
7041 struct ParsedAttrInfoGuardedVar final : public ParsedAttrInfo {
7042   constexpr ParsedAttrInfoGuardedVar() : ParsedAttrInfo(
7043     /*AttrKind=*/ParsedAttr::AT_GuardedVar,
7044     /*NumArgs=*/0,
7045     /*OptArgs=*/0,
7046     /*NumArgMembers=*/0,
7047     /*HasCustomParsing=*/0,
7048     /*AcceptsExprPack=*/0,
7049     /*IsTargetSpecific=*/0,
7050     /*IsType=*/0,
7051     /*IsStmt=*/0,
7052     /*IsKnownToGCC=*/0,
7053     /*IsSupportedByPragmaAttribute=*/0,
7054     /*Spellings=*/GuardedVarSpellings,
7055     /*ArgNames=*/{}) {}
7056 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7057   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
7058     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7059       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
7060     return false;
7061   }
7062   return true;
7063 }
7064 
7065 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7066   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7067     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7068   return false;
7069 }
7070 
7071 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
7072   D->addAttr(::new (S.Context) GuardedVarAttr(S.Context, Attr));
7073   return AttributeApplied;
7074 }
7075 
7076 bool isParamExpr(size_t N) const override {
7077   return false;
7078 }
7079 
7080 static const ParsedAttrInfoGuardedVar Instance;
7081 };
7082 const ParsedAttrInfoGuardedVar ParsedAttrInfoGuardedVar::Instance;
7083 static constexpr ParsedAttrInfo::Spelling HIPManagedSpellings[] = {
7084   {AttributeCommonInfo::AS_GNU, "managed"},
7085   {AttributeCommonInfo::AS_Declspec, "__managed__"},
7086 };
7087 struct ParsedAttrInfoHIPManaged final : public ParsedAttrInfo {
7088   constexpr ParsedAttrInfoHIPManaged() : ParsedAttrInfo(
7089     /*AttrKind=*/ParsedAttr::AT_HIPManaged,
7090     /*NumArgs=*/0,
7091     /*OptArgs=*/0,
7092     /*NumArgMembers=*/0,
7093     /*HasCustomParsing=*/0,
7094     /*AcceptsExprPack=*/0,
7095     /*IsTargetSpecific=*/0,
7096     /*IsType=*/0,
7097     /*IsStmt=*/0,
7098     /*IsKnownToGCC=*/0,
7099     /*IsSupportedByPragmaAttribute=*/1,
7100     /*Spellings=*/HIPManagedSpellings,
7101     /*ArgNames=*/{}) {}
7102 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7103   if (!isa<VarDecl>(D)) {
7104     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7105       << Attr << Attr.isRegularKeywordAttribute() << "variables";
7106     return false;
7107   }
7108   return true;
7109 }
7110 
7111 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7112   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7113     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7114   return false;
7115 }
7116 
7117   using ParsedAttrInfo::diagMutualExclusion;
7118 
7119   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
7120     if (const auto *A = D->getAttr<CUDAConstantAttr>()) {
7121       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
7122       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
7123 return false;
7124     }
7125     if (const auto *A = D->getAttr<CUDASharedAttr>()) {
7126       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
7127       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
7128 return false;
7129     }
7130     return true;
7131   }
7132 
7133 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7134   return LangOpts.HIP;
7135 }
7136 
7137 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
7138   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
7139 }
7140 
7141 bool isParamExpr(size_t N) const override {
7142   return false;
7143 }
7144 
7145 static const ParsedAttrInfoHIPManaged Instance;
7146 };
7147 const ParsedAttrInfoHIPManaged ParsedAttrInfoHIPManaged::Instance;
7148 static constexpr ParsedAttrInfo::Spelling HLSLContainedTypeSpellings[] = {
7149   {AttributeCommonInfo::AS_CXX11, "hlsl::contained_type"},
7150 };
7151 static constexpr const char *HLSLContainedTypeArgNames[] = {
7152 "Type",};
7153 struct ParsedAttrInfoHLSLContainedType final : public ParsedAttrInfo {
7154   constexpr ParsedAttrInfoHLSLContainedType() : ParsedAttrInfo(
7155     /*AttrKind=*/ParsedAttr::AT_HLSLContainedType,
7156     /*NumArgs=*/1,
7157     /*OptArgs=*/0,
7158     /*NumArgMembers=*/1,
7159     /*HasCustomParsing=*/0,
7160     /*AcceptsExprPack=*/0,
7161     /*IsTargetSpecific=*/0,
7162     /*IsType=*/1,
7163     /*IsStmt=*/0,
7164     /*IsKnownToGCC=*/0,
7165     /*IsSupportedByPragmaAttribute=*/0,
7166     /*Spellings=*/HLSLContainedTypeSpellings,
7167     /*ArgNames=*/HLSLContainedTypeArgNames) {}
7168 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7169   return LangOpts.HLSL;
7170 }
7171 
7172 bool isParamExpr(size_t N) const override {
7173   return false;
7174 }
7175 
7176 static const ParsedAttrInfoHLSLContainedType Instance;
7177 };
7178 const ParsedAttrInfoHLSLContainedType ParsedAttrInfoHLSLContainedType::Instance;
7179 static constexpr ParsedAttrInfo::Spelling HLSLControlFlowHintSpellings[] = {
7180   {AttributeCommonInfo::AS_Microsoft, "branch"},
7181   {AttributeCommonInfo::AS_Microsoft, "flatten"},
7182 };
7183 struct ParsedAttrInfoHLSLControlFlowHint final : public ParsedAttrInfo {
7184   constexpr ParsedAttrInfoHLSLControlFlowHint() : ParsedAttrInfo(
7185     /*AttrKind=*/ParsedAttr::AT_HLSLControlFlowHint,
7186     /*NumArgs=*/0,
7187     /*OptArgs=*/0,
7188     /*NumArgMembers=*/0,
7189     /*HasCustomParsing=*/0,
7190     /*AcceptsExprPack=*/0,
7191     /*IsTargetSpecific=*/0,
7192     /*IsType=*/0,
7193     /*IsStmt=*/1,
7194     /*IsKnownToGCC=*/0,
7195     /*IsSupportedByPragmaAttribute=*/0,
7196     /*Spellings=*/HLSLControlFlowHintSpellings,
7197     /*ArgNames=*/{}) {}
7198 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
7199   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
7200     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
7201   return false;
7202 }
7203 
7204 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
7205   if (!isa<IfStmt>(St)) {
7206     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
7207       << Attr << Attr.isRegularKeywordAttribute() << "'if' statements";
7208     return false;
7209   }
7210   return true;
7211 }
7212 
7213 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7214   return LangOpts.HLSL;
7215 }
7216 
7217 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
7218   enum Spelling {
7219     Microsoft_branch = 0,
7220     Microsoft_flatten = 1,
7221   SpellingNotCalculated = 15
7222 
7223   };
7224 
7225   unsigned Idx = Attr.getAttributeSpellingListIndex();
7226   switch (Idx) {
7227     default: llvm_unreachable("Unknown spelling list index");
7228     case 0: return Microsoft_branch;
7229     case 1: return Microsoft_flatten;
7230   }
7231 }
7232 
7233 bool isParamExpr(size_t N) const override {
7234   return false;
7235 }
7236 
7237 static const ParsedAttrInfoHLSLControlFlowHint Instance;
7238 };
7239 const ParsedAttrInfoHLSLControlFlowHint ParsedAttrInfoHLSLControlFlowHint::Instance;
7240 static constexpr ParsedAttrInfo::Spelling HLSLGroupSharedAddressSpaceSpellings[] = {
7241   {AttributeCommonInfo::AS_Keyword, "groupshared"},
7242 };
7243 struct ParsedAttrInfoHLSLGroupSharedAddressSpace final : public ParsedAttrInfo {
7244   constexpr ParsedAttrInfoHLSLGroupSharedAddressSpace() : ParsedAttrInfo(
7245     /*AttrKind=*/ParsedAttr::AT_HLSLGroupSharedAddressSpace,
7246     /*NumArgs=*/0,
7247     /*OptArgs=*/0,
7248     /*NumArgMembers=*/0,
7249     /*HasCustomParsing=*/0,
7250     /*AcceptsExprPack=*/0,
7251     /*IsTargetSpecific=*/0,
7252     /*IsType=*/1,
7253     /*IsStmt=*/0,
7254     /*IsKnownToGCC=*/0,
7255     /*IsSupportedByPragmaAttribute=*/0,
7256     /*Spellings=*/HLSLGroupSharedAddressSpaceSpellings,
7257     /*ArgNames=*/{}) {}
7258 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7259   if (!isa<VarDecl>(D)) {
7260     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7261       << Attr << Attr.isRegularKeywordAttribute() << "variables";
7262     return false;
7263   }
7264   return true;
7265 }
7266 
7267 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7268   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7269     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7270   return false;
7271 }
7272 
7273 bool isParamExpr(size_t N) const override {
7274   return false;
7275 }
7276 
7277 static const ParsedAttrInfoHLSLGroupSharedAddressSpace Instance;
7278 };
7279 const ParsedAttrInfoHLSLGroupSharedAddressSpace ParsedAttrInfoHLSLGroupSharedAddressSpace::Instance;
7280 static constexpr ParsedAttrInfo::Spelling HLSLLoopHintSpellings[] = {
7281   {AttributeCommonInfo::AS_Microsoft, "unroll"},
7282   {AttributeCommonInfo::AS_Microsoft, "loop"},
7283 };
7284 static constexpr const char *HLSLLoopHintArgNames[] = {
7285 "directive",};
7286 struct ParsedAttrInfoHLSLLoopHint final : public ParsedAttrInfo {
7287   constexpr ParsedAttrInfoHLSLLoopHint() : ParsedAttrInfo(
7288     /*AttrKind=*/ParsedAttr::AT_HLSLLoopHint,
7289     /*NumArgs=*/0,
7290     /*OptArgs=*/1,
7291     /*NumArgMembers=*/1,
7292     /*HasCustomParsing=*/0,
7293     /*AcceptsExprPack=*/0,
7294     /*IsTargetSpecific=*/0,
7295     /*IsType=*/0,
7296     /*IsStmt=*/1,
7297     /*IsKnownToGCC=*/0,
7298     /*IsSupportedByPragmaAttribute=*/0,
7299     /*Spellings=*/HLSLLoopHintSpellings,
7300     /*ArgNames=*/HLSLLoopHintArgNames) {}
7301 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
7302   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
7303     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
7304   return false;
7305 }
7306 
7307 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
7308   if (!isa<ForStmt>(St) && !isa<WhileStmt>(St) && !isa<DoStmt>(St)) {
7309     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
7310       << Attr << Attr.isRegularKeywordAttribute() << "'for', 'while', and 'do' statements";
7311     return false;
7312   }
7313   return true;
7314 }
7315 
7316 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7317   return LangOpts.HLSL;
7318 }
7319 
7320 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
7321   enum Spelling {
7322     Microsoft_unroll = 0,
7323     Microsoft_loop = 1,
7324   SpellingNotCalculated = 15
7325 
7326   };
7327 
7328   unsigned Idx = Attr.getAttributeSpellingListIndex();
7329   switch (Idx) {
7330     default: llvm_unreachable("Unknown spelling list index");
7331     case 0: return Microsoft_unroll;
7332     case 1: return Microsoft_loop;
7333   }
7334 }
7335 
7336 bool isParamExpr(size_t N) const override {
7337   return false;
7338 }
7339 
7340 static const ParsedAttrInfoHLSLLoopHint Instance;
7341 };
7342 const ParsedAttrInfoHLSLLoopHint ParsedAttrInfoHLSLLoopHint::Instance;
7343 static constexpr ParsedAttrInfo::Spelling HLSLNumThreadsSpellings[] = {
7344   {AttributeCommonInfo::AS_Microsoft, "numthreads"},
7345 };
7346 static constexpr const char *HLSLNumThreadsArgNames[] = {
7347 "X","Y","Z",};
7348 struct ParsedAttrInfoHLSLNumThreads final : public ParsedAttrInfo {
7349   constexpr ParsedAttrInfoHLSLNumThreads() : ParsedAttrInfo(
7350     /*AttrKind=*/ParsedAttr::AT_HLSLNumThreads,
7351     /*NumArgs=*/3,
7352     /*OptArgs=*/0,
7353     /*NumArgMembers=*/3,
7354     /*HasCustomParsing=*/0,
7355     /*AcceptsExprPack=*/0,
7356     /*IsTargetSpecific=*/0,
7357     /*IsType=*/0,
7358     /*IsStmt=*/0,
7359     /*IsKnownToGCC=*/0,
7360     /*IsSupportedByPragmaAttribute=*/0,
7361     /*Spellings=*/HLSLNumThreadsSpellings,
7362     /*ArgNames=*/HLSLNumThreadsArgNames) {}
7363 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7364   if (!isHLSLEntry(D)) {
7365     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7366       << Attr << Attr.isRegularKeywordAttribute() << "global functions";
7367     return false;
7368   }
7369   return true;
7370 }
7371 
7372 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7373   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7374     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7375   return false;
7376 }
7377 
7378 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7379   return LangOpts.HLSL;
7380 }
7381 
7382 bool isParamExpr(size_t N) const override {
7383   return false;
7384 }
7385 
7386 static const ParsedAttrInfoHLSLNumThreads Instance;
7387 };
7388 const ParsedAttrInfoHLSLNumThreads ParsedAttrInfoHLSLNumThreads::Instance;
7389 static constexpr ParsedAttrInfo::Spelling HLSLPackOffsetSpellings[] = {
7390   {AttributeCommonInfo::AS_HLSLAnnotation, "packoffset"},
7391 };
7392 static constexpr const char *HLSLPackOffsetArgNames[] = {
7393 "Subcomponent","Component",};
7394 struct ParsedAttrInfoHLSLPackOffset final : public ParsedAttrInfo {
7395   constexpr ParsedAttrInfoHLSLPackOffset() : ParsedAttrInfo(
7396     /*AttrKind=*/ParsedAttr::AT_HLSLPackOffset,
7397     /*NumArgs=*/2,
7398     /*OptArgs=*/0,
7399     /*NumArgMembers=*/2,
7400     /*HasCustomParsing=*/0,
7401     /*AcceptsExprPack=*/0,
7402     /*IsTargetSpecific=*/0,
7403     /*IsType=*/0,
7404     /*IsStmt=*/0,
7405     /*IsKnownToGCC=*/0,
7406     /*IsSupportedByPragmaAttribute=*/0,
7407     /*Spellings=*/HLSLPackOffsetSpellings,
7408     /*ArgNames=*/HLSLPackOffsetArgNames) {}
7409 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7410   return LangOpts.HLSL;
7411 }
7412 
7413 bool isParamExpr(size_t N) const override {
7414   return false;
7415 }
7416 
7417 static const ParsedAttrInfoHLSLPackOffset Instance;
7418 };
7419 const ParsedAttrInfoHLSLPackOffset ParsedAttrInfoHLSLPackOffset::Instance;
7420 static constexpr ParsedAttrInfo::Spelling HLSLParamModifierSpellings[] = {
7421   {AttributeCommonInfo::AS_Keyword, "in"},
7422   {AttributeCommonInfo::AS_Keyword, "inout"},
7423   {AttributeCommonInfo::AS_Keyword, "out"},
7424 };
7425 struct ParsedAttrInfoHLSLParamModifier final : public ParsedAttrInfo {
7426   constexpr ParsedAttrInfoHLSLParamModifier() : ParsedAttrInfo(
7427     /*AttrKind=*/ParsedAttr::AT_HLSLParamModifier,
7428     /*NumArgs=*/0,
7429     /*OptArgs=*/0,
7430     /*NumArgMembers=*/0,
7431     /*HasCustomParsing=*/0,
7432     /*AcceptsExprPack=*/0,
7433     /*IsTargetSpecific=*/0,
7434     /*IsType=*/0,
7435     /*IsStmt=*/0,
7436     /*IsKnownToGCC=*/0,
7437     /*IsSupportedByPragmaAttribute=*/0,
7438     /*Spellings=*/HLSLParamModifierSpellings,
7439     /*ArgNames=*/{}) {}
7440 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7441   if (!isa<ParmVarDecl>(D)) {
7442     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7443       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
7444     return false;
7445   }
7446   return true;
7447 }
7448 
7449 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7450   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7451     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7452   return false;
7453 }
7454 
7455 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
7456   enum Spelling {
7457     Keyword_in = 0,
7458     Keyword_inout = 1,
7459     Keyword_out = 2,
7460   SpellingNotCalculated = 15
7461 
7462   };
7463 
7464   unsigned Idx = Attr.getAttributeSpellingListIndex();
7465   switch (Idx) {
7466     default: llvm_unreachable("Unknown spelling list index");
7467     case 0: return Keyword_in;
7468     case 1: return Keyword_inout;
7469     case 2: return Keyword_out;
7470   }
7471 }
7472 
7473 bool isParamExpr(size_t N) const override {
7474   return false;
7475 }
7476 
7477 static const ParsedAttrInfoHLSLParamModifier Instance;
7478 };
7479 const ParsedAttrInfoHLSLParamModifier ParsedAttrInfoHLSLParamModifier::Instance;
7480 static constexpr ParsedAttrInfo::Spelling HLSLROVSpellings[] = {
7481   {AttributeCommonInfo::AS_CXX11, "hlsl::is_rov"},
7482 };
7483 struct ParsedAttrInfoHLSLROV final : public ParsedAttrInfo {
7484   constexpr ParsedAttrInfoHLSLROV() : ParsedAttrInfo(
7485     /*AttrKind=*/ParsedAttr::AT_HLSLROV,
7486     /*NumArgs=*/0,
7487     /*OptArgs=*/0,
7488     /*NumArgMembers=*/0,
7489     /*HasCustomParsing=*/0,
7490     /*AcceptsExprPack=*/0,
7491     /*IsTargetSpecific=*/0,
7492     /*IsType=*/1,
7493     /*IsStmt=*/0,
7494     /*IsKnownToGCC=*/0,
7495     /*IsSupportedByPragmaAttribute=*/0,
7496     /*Spellings=*/HLSLROVSpellings,
7497     /*ArgNames=*/{}) {}
7498 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7499   return LangOpts.HLSL;
7500 }
7501 
7502 bool isParamExpr(size_t N) const override {
7503   return false;
7504 }
7505 
7506 static const ParsedAttrInfoHLSLROV Instance;
7507 };
7508 const ParsedAttrInfoHLSLROV ParsedAttrInfoHLSLROV::Instance;
7509 static constexpr ParsedAttrInfo::Spelling HLSLRawBufferSpellings[] = {
7510   {AttributeCommonInfo::AS_CXX11, "hlsl::raw_buffer"},
7511 };
7512 struct ParsedAttrInfoHLSLRawBuffer final : public ParsedAttrInfo {
7513   constexpr ParsedAttrInfoHLSLRawBuffer() : ParsedAttrInfo(
7514     /*AttrKind=*/ParsedAttr::AT_HLSLRawBuffer,
7515     /*NumArgs=*/0,
7516     /*OptArgs=*/0,
7517     /*NumArgMembers=*/0,
7518     /*HasCustomParsing=*/0,
7519     /*AcceptsExprPack=*/0,
7520     /*IsTargetSpecific=*/0,
7521     /*IsType=*/1,
7522     /*IsStmt=*/0,
7523     /*IsKnownToGCC=*/0,
7524     /*IsSupportedByPragmaAttribute=*/0,
7525     /*Spellings=*/HLSLRawBufferSpellings,
7526     /*ArgNames=*/{}) {}
7527 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7528   return LangOpts.HLSL;
7529 }
7530 
7531 bool isParamExpr(size_t N) const override {
7532   return false;
7533 }
7534 
7535 static const ParsedAttrInfoHLSLRawBuffer Instance;
7536 };
7537 const ParsedAttrInfoHLSLRawBuffer ParsedAttrInfoHLSLRawBuffer::Instance;
7538 static constexpr const char *HLSLResourceArgNames[] = {
7539 "ResourceKind",};
7540 struct ParsedAttrInfoHLSLResource final : public ParsedAttrInfo {
7541   constexpr ParsedAttrInfoHLSLResource() : ParsedAttrInfo(
7542     /*AttrKind=*/ParsedAttr::AT_HLSLResource,
7543     /*NumArgs=*/1,
7544     /*OptArgs=*/0,
7545     /*NumArgMembers=*/1,
7546     /*HasCustomParsing=*/0,
7547     /*AcceptsExprPack=*/0,
7548     /*IsTargetSpecific=*/0,
7549     /*IsType=*/0,
7550     /*IsStmt=*/0,
7551     /*IsKnownToGCC=*/0,
7552     /*IsSupportedByPragmaAttribute=*/0,
7553     /*Spellings=*/{},
7554     /*ArgNames=*/HLSLResourceArgNames) {}
7555 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7556   if (!isStruct(D)) {
7557     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7558       << Attr << Attr.isRegularKeywordAttribute() << "structs";
7559     return false;
7560   }
7561   return true;
7562 }
7563 
7564 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7565   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7566     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7567   return false;
7568 }
7569 
7570 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7571   return LangOpts.HLSL;
7572 }
7573 
7574 bool isParamExpr(size_t N) const override {
7575   return false;
7576 }
7577 
7578 static const ParsedAttrInfoHLSLResource Instance;
7579 };
7580 const ParsedAttrInfoHLSLResource ParsedAttrInfoHLSLResource::Instance;
7581 static constexpr ParsedAttrInfo::Spelling HLSLResourceBindingSpellings[] = {
7582   {AttributeCommonInfo::AS_HLSLAnnotation, "register"},
7583 };
7584 static constexpr const char *HLSLResourceBindingArgNames[] = {
7585 "Slot","Space",};
7586 struct ParsedAttrInfoHLSLResourceBinding final : public ParsedAttrInfo {
7587   constexpr ParsedAttrInfoHLSLResourceBinding() : ParsedAttrInfo(
7588     /*AttrKind=*/ParsedAttr::AT_HLSLResourceBinding,
7589     /*NumArgs=*/1,
7590     /*OptArgs=*/1,
7591     /*NumArgMembers=*/2,
7592     /*HasCustomParsing=*/0,
7593     /*AcceptsExprPack=*/0,
7594     /*IsTargetSpecific=*/0,
7595     /*IsType=*/0,
7596     /*IsStmt=*/0,
7597     /*IsKnownToGCC=*/0,
7598     /*IsSupportedByPragmaAttribute=*/0,
7599     /*Spellings=*/HLSLResourceBindingSpellings,
7600     /*ArgNames=*/HLSLResourceBindingArgNames) {}
7601 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7602   if (!isHLSLBufferObj(D) && !isExternalGlobalVar(D)) {
7603     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
7604       << Attr << Attr.isRegularKeywordAttribute() << "cbuffer/tbuffer and external global variables";
7605     return false;
7606   }
7607   return true;
7608 }
7609 
7610 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7611   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7612     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7613   return false;
7614 }
7615 
7616 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7617   return LangOpts.HLSL;
7618 }
7619 
7620 bool isParamExpr(size_t N) const override {
7621   return false;
7622 }
7623 
7624 static const ParsedAttrInfoHLSLResourceBinding Instance;
7625 };
7626 const ParsedAttrInfoHLSLResourceBinding ParsedAttrInfoHLSLResourceBinding::Instance;
7627 static constexpr ParsedAttrInfo::Spelling HLSLResourceClassSpellings[] = {
7628   {AttributeCommonInfo::AS_CXX11, "hlsl::resource_class"},
7629 };
7630 static constexpr const char *HLSLResourceClassArgNames[] = {
7631 "ResourceClass",};
7632 struct ParsedAttrInfoHLSLResourceClass final : public ParsedAttrInfo {
7633   constexpr ParsedAttrInfoHLSLResourceClass() : ParsedAttrInfo(
7634     /*AttrKind=*/ParsedAttr::AT_HLSLResourceClass,
7635     /*NumArgs=*/1,
7636     /*OptArgs=*/0,
7637     /*NumArgMembers=*/1,
7638     /*HasCustomParsing=*/0,
7639     /*AcceptsExprPack=*/0,
7640     /*IsTargetSpecific=*/0,
7641     /*IsType=*/1,
7642     /*IsStmt=*/0,
7643     /*IsKnownToGCC=*/0,
7644     /*IsSupportedByPragmaAttribute=*/0,
7645     /*Spellings=*/HLSLResourceClassSpellings,
7646     /*ArgNames=*/HLSLResourceClassArgNames) {}
7647 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7648   return LangOpts.HLSL;
7649 }
7650 
7651 bool isParamExpr(size_t N) const override {
7652   return false;
7653 }
7654 
7655 static const ParsedAttrInfoHLSLResourceClass Instance;
7656 };
7657 const ParsedAttrInfoHLSLResourceClass ParsedAttrInfoHLSLResourceClass::Instance;
7658 static constexpr ParsedAttrInfo::Spelling HLSLSV_DispatchThreadIDSpellings[] = {
7659   {AttributeCommonInfo::AS_HLSLAnnotation, "SV_DispatchThreadID"},
7660 };
7661 struct ParsedAttrInfoHLSLSV_DispatchThreadID final : public ParsedAttrInfo {
7662   constexpr ParsedAttrInfoHLSLSV_DispatchThreadID() : ParsedAttrInfo(
7663     /*AttrKind=*/ParsedAttr::AT_HLSLSV_DispatchThreadID,
7664     /*NumArgs=*/0,
7665     /*OptArgs=*/0,
7666     /*NumArgMembers=*/0,
7667     /*HasCustomParsing=*/0,
7668     /*AcceptsExprPack=*/0,
7669     /*IsTargetSpecific=*/0,
7670     /*IsType=*/0,
7671     /*IsStmt=*/0,
7672     /*IsKnownToGCC=*/0,
7673     /*IsSupportedByPragmaAttribute=*/0,
7674     /*Spellings=*/HLSLSV_DispatchThreadIDSpellings,
7675     /*ArgNames=*/{}) {}
7676 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7677   if (!isa<ParmVarDecl>(D) && !isa<FieldDecl>(D)) {
7678     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7679       << Attr << Attr.isRegularKeywordAttribute() << "parameters and non-static data members";
7680     return false;
7681   }
7682   return true;
7683 }
7684 
7685 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7686   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7687     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7688   return false;
7689 }
7690 
7691 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7692   return LangOpts.HLSL;
7693 }
7694 
7695 bool isParamExpr(size_t N) const override {
7696   return false;
7697 }
7698 
7699 static const ParsedAttrInfoHLSLSV_DispatchThreadID Instance;
7700 };
7701 const ParsedAttrInfoHLSLSV_DispatchThreadID ParsedAttrInfoHLSLSV_DispatchThreadID::Instance;
7702 static constexpr ParsedAttrInfo::Spelling HLSLSV_GroupIDSpellings[] = {
7703   {AttributeCommonInfo::AS_HLSLAnnotation, "SV_GroupID"},
7704 };
7705 struct ParsedAttrInfoHLSLSV_GroupID final : public ParsedAttrInfo {
7706   constexpr ParsedAttrInfoHLSLSV_GroupID() : ParsedAttrInfo(
7707     /*AttrKind=*/ParsedAttr::AT_HLSLSV_GroupID,
7708     /*NumArgs=*/0,
7709     /*OptArgs=*/0,
7710     /*NumArgMembers=*/0,
7711     /*HasCustomParsing=*/0,
7712     /*AcceptsExprPack=*/0,
7713     /*IsTargetSpecific=*/0,
7714     /*IsType=*/0,
7715     /*IsStmt=*/0,
7716     /*IsKnownToGCC=*/0,
7717     /*IsSupportedByPragmaAttribute=*/0,
7718     /*Spellings=*/HLSLSV_GroupIDSpellings,
7719     /*ArgNames=*/{}) {}
7720 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7721   if (!isa<ParmVarDecl>(D) && !isa<FieldDecl>(D)) {
7722     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7723       << Attr << Attr.isRegularKeywordAttribute() << "parameters and non-static data members";
7724     return false;
7725   }
7726   return true;
7727 }
7728 
7729 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7730   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7731     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7732   return false;
7733 }
7734 
7735 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7736   return LangOpts.HLSL;
7737 }
7738 
7739 bool isParamExpr(size_t N) const override {
7740   return false;
7741 }
7742 
7743 static const ParsedAttrInfoHLSLSV_GroupID Instance;
7744 };
7745 const ParsedAttrInfoHLSLSV_GroupID ParsedAttrInfoHLSLSV_GroupID::Instance;
7746 static constexpr ParsedAttrInfo::Spelling HLSLSV_GroupIndexSpellings[] = {
7747   {AttributeCommonInfo::AS_HLSLAnnotation, "SV_GroupIndex"},
7748 };
7749 struct ParsedAttrInfoHLSLSV_GroupIndex final : public ParsedAttrInfo {
7750   constexpr ParsedAttrInfoHLSLSV_GroupIndex() : ParsedAttrInfo(
7751     /*AttrKind=*/ParsedAttr::AT_HLSLSV_GroupIndex,
7752     /*NumArgs=*/0,
7753     /*OptArgs=*/0,
7754     /*NumArgMembers=*/0,
7755     /*HasCustomParsing=*/0,
7756     /*AcceptsExprPack=*/0,
7757     /*IsTargetSpecific=*/0,
7758     /*IsType=*/0,
7759     /*IsStmt=*/0,
7760     /*IsKnownToGCC=*/0,
7761     /*IsSupportedByPragmaAttribute=*/0,
7762     /*Spellings=*/HLSLSV_GroupIndexSpellings,
7763     /*ArgNames=*/{}) {}
7764 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7765   if (!isa<ParmVarDecl>(D) && !isGlobalVar(D)) {
7766     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7767       << Attr << Attr.isRegularKeywordAttribute() << "parameters and global variables";
7768     return false;
7769   }
7770   return true;
7771 }
7772 
7773 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7774   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7775     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7776   return false;
7777 }
7778 
7779 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7780   return LangOpts.HLSL;
7781 }
7782 
7783 bool isParamExpr(size_t N) const override {
7784   return false;
7785 }
7786 
7787 static const ParsedAttrInfoHLSLSV_GroupIndex Instance;
7788 };
7789 const ParsedAttrInfoHLSLSV_GroupIndex ParsedAttrInfoHLSLSV_GroupIndex::Instance;
7790 static constexpr ParsedAttrInfo::Spelling HLSLSV_GroupThreadIDSpellings[] = {
7791   {AttributeCommonInfo::AS_HLSLAnnotation, "SV_GroupThreadID"},
7792 };
7793 struct ParsedAttrInfoHLSLSV_GroupThreadID final : public ParsedAttrInfo {
7794   constexpr ParsedAttrInfoHLSLSV_GroupThreadID() : ParsedAttrInfo(
7795     /*AttrKind=*/ParsedAttr::AT_HLSLSV_GroupThreadID,
7796     /*NumArgs=*/0,
7797     /*OptArgs=*/0,
7798     /*NumArgMembers=*/0,
7799     /*HasCustomParsing=*/0,
7800     /*AcceptsExprPack=*/0,
7801     /*IsTargetSpecific=*/0,
7802     /*IsType=*/0,
7803     /*IsStmt=*/0,
7804     /*IsKnownToGCC=*/0,
7805     /*IsSupportedByPragmaAttribute=*/0,
7806     /*Spellings=*/HLSLSV_GroupThreadIDSpellings,
7807     /*ArgNames=*/{}) {}
7808 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7809   if (!isa<ParmVarDecl>(D) && !isa<FieldDecl>(D)) {
7810     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7811       << Attr << Attr.isRegularKeywordAttribute() << "parameters and non-static data members";
7812     return false;
7813   }
7814   return true;
7815 }
7816 
7817 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7818   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7819     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7820   return false;
7821 }
7822 
7823 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7824   return LangOpts.HLSL;
7825 }
7826 
7827 bool isParamExpr(size_t N) const override {
7828   return false;
7829 }
7830 
7831 static const ParsedAttrInfoHLSLSV_GroupThreadID Instance;
7832 };
7833 const ParsedAttrInfoHLSLSV_GroupThreadID ParsedAttrInfoHLSLSV_GroupThreadID::Instance;
7834 static constexpr ParsedAttrInfo::Spelling HLSLShaderSpellings[] = {
7835   {AttributeCommonInfo::AS_Microsoft, "shader"},
7836 };
7837 static constexpr const char *HLSLShaderArgNames[] = {
7838 "Type",};
7839 struct ParsedAttrInfoHLSLShader final : public ParsedAttrInfo {
7840   constexpr ParsedAttrInfoHLSLShader() : ParsedAttrInfo(
7841     /*AttrKind=*/ParsedAttr::AT_HLSLShader,
7842     /*NumArgs=*/1,
7843     /*OptArgs=*/0,
7844     /*NumArgMembers=*/1,
7845     /*HasCustomParsing=*/0,
7846     /*AcceptsExprPack=*/0,
7847     /*IsTargetSpecific=*/0,
7848     /*IsType=*/0,
7849     /*IsStmt=*/0,
7850     /*IsKnownToGCC=*/0,
7851     /*IsSupportedByPragmaAttribute=*/0,
7852     /*Spellings=*/HLSLShaderSpellings,
7853     /*ArgNames=*/HLSLShaderArgNames) {}
7854 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7855   if (!isHLSLEntry(D)) {
7856     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7857       << Attr << Attr.isRegularKeywordAttribute() << "global functions";
7858     return false;
7859   }
7860   return true;
7861 }
7862 
7863 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7864   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7865     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7866   return false;
7867 }
7868 
7869 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7870   return LangOpts.HLSL;
7871 }
7872 
7873 bool isParamExpr(size_t N) const override {
7874   return false;
7875 }
7876 
7877 static const ParsedAttrInfoHLSLShader Instance;
7878 };
7879 const ParsedAttrInfoHLSLShader ParsedAttrInfoHLSLShader::Instance;
7880 static constexpr ParsedAttrInfo::Spelling HLSLWaveSizeSpellings[] = {
7881   {AttributeCommonInfo::AS_Microsoft, "WaveSize"},
7882 };
7883 static constexpr const char *HLSLWaveSizeArgNames[] = {
7884 "Min","Max","Preferred",};
7885 struct ParsedAttrInfoHLSLWaveSize final : public ParsedAttrInfo {
7886   constexpr ParsedAttrInfoHLSLWaveSize() : ParsedAttrInfo(
7887     /*AttrKind=*/ParsedAttr::AT_HLSLWaveSize,
7888     /*NumArgs=*/1,
7889     /*OptArgs=*/2,
7890     /*NumArgMembers=*/3,
7891     /*HasCustomParsing=*/0,
7892     /*AcceptsExprPack=*/0,
7893     /*IsTargetSpecific=*/0,
7894     /*IsType=*/0,
7895     /*IsStmt=*/0,
7896     /*IsKnownToGCC=*/0,
7897     /*IsSupportedByPragmaAttribute=*/0,
7898     /*Spellings=*/HLSLWaveSizeSpellings,
7899     /*ArgNames=*/HLSLWaveSizeArgNames) {}
7900 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7901   if (!isHLSLEntry(D)) {
7902     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7903       << Attr << Attr.isRegularKeywordAttribute() << "global functions";
7904     return false;
7905   }
7906   return true;
7907 }
7908 
7909 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7910   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7911     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7912   return false;
7913 }
7914 
7915 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
7916   return LangOpts.HLSL;
7917 }
7918 
7919 bool isParamExpr(size_t N) const override {
7920   return false;
7921 }
7922 
7923 static const ParsedAttrInfoHLSLWaveSize Instance;
7924 };
7925 const ParsedAttrInfoHLSLWaveSize ParsedAttrInfoHLSLWaveSize::Instance;
7926 static constexpr ParsedAttrInfo::Spelling HotSpellings[] = {
7927   {AttributeCommonInfo::AS_GNU, "hot"},
7928   {AttributeCommonInfo::AS_CXX11, "gnu::hot"},
7929   {AttributeCommonInfo::AS_C23, "gnu::hot"},
7930 };
7931 struct ParsedAttrInfoHot final : public ParsedAttrInfo {
7932   constexpr ParsedAttrInfoHot() : ParsedAttrInfo(
7933     /*AttrKind=*/ParsedAttr::AT_Hot,
7934     /*NumArgs=*/0,
7935     /*OptArgs=*/0,
7936     /*NumArgMembers=*/0,
7937     /*HasCustomParsing=*/0,
7938     /*AcceptsExprPack=*/0,
7939     /*IsTargetSpecific=*/0,
7940     /*IsType=*/0,
7941     /*IsStmt=*/0,
7942     /*IsKnownToGCC=*/1,
7943     /*IsSupportedByPragmaAttribute=*/1,
7944     /*Spellings=*/HotSpellings,
7945     /*ArgNames=*/{}) {}
7946 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
7947   if (!isa<FunctionDecl>(D)) {
7948     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
7949       << Attr << Attr.isRegularKeywordAttribute() << "functions";
7950     return false;
7951   }
7952   return true;
7953 }
7954 
7955 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
7956   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
7957     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
7958   return false;
7959 }
7960 
7961   using ParsedAttrInfo::diagMutualExclusion;
7962 
7963   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
7964     if (const auto *A = D->getAttr<ColdAttr>()) {
7965       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
7966       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
7967 return false;
7968     }
7969     return true;
7970   }
7971 
7972 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
7973   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
7974 }
7975 
7976 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
7977   D->addAttr(::new (S.Context) HotAttr(S.Context, Attr));
7978   return AttributeApplied;
7979 }
7980 
7981 bool isParamExpr(size_t N) const override {
7982   return false;
7983 }
7984 
7985 static const ParsedAttrInfoHot Instance;
7986 };
7987 const ParsedAttrInfoHot ParsedAttrInfoHot::Instance;
7988 static constexpr ParsedAttrInfo::Spelling HybridPatchableSpellings[] = {
7989   {AttributeCommonInfo::AS_Declspec, "hybrid_patchable"},
7990   {AttributeCommonInfo::AS_GNU, "hybrid_patchable"},
7991   {AttributeCommonInfo::AS_CXX11, "clang::hybrid_patchable"},
7992   {AttributeCommonInfo::AS_C23, "clang::hybrid_patchable"},
7993 };
7994 struct ParsedAttrInfoHybridPatchable final : public ParsedAttrInfo {
7995   constexpr ParsedAttrInfoHybridPatchable() : ParsedAttrInfo(
7996     /*AttrKind=*/ParsedAttr::AT_HybridPatchable,
7997     /*NumArgs=*/0,
7998     /*OptArgs=*/0,
7999     /*NumArgMembers=*/0,
8000     /*HasCustomParsing=*/0,
8001     /*AcceptsExprPack=*/0,
8002     /*IsTargetSpecific=*/1,
8003     /*IsType=*/0,
8004     /*IsStmt=*/0,
8005     /*IsKnownToGCC=*/0,
8006     /*IsSupportedByPragmaAttribute=*/1,
8007     /*Spellings=*/HybridPatchableSpellings,
8008     /*ArgNames=*/{}) {}
8009 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8010   if (!isa<FunctionDecl>(D)) {
8011     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8012       << Attr << Attr.isRegularKeywordAttribute() << "functions";
8013     return false;
8014   }
8015   return true;
8016 }
8017 
8018 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8019   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8020     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8021   return false;
8022 }
8023 
8024 bool existsInTarget(const TargetInfo &Target) const override {
8025   const llvm::Triple &T = Target.getTriple(); (void)T;
8026   return true && ( Target.getTriple().isWindowsArm64EC() );
8027 }
8028 
8029 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8030   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
8031 }
8032 
8033 bool isParamExpr(size_t N) const override {
8034   return false;
8035 }
8036 
8037 static const ParsedAttrInfoHybridPatchable Instance;
8038 };
8039 const ParsedAttrInfoHybridPatchable ParsedAttrInfoHybridPatchable::Instance;
8040 static constexpr ParsedAttrInfo::Spelling IBActionSpellings[] = {
8041   {AttributeCommonInfo::AS_GNU, "ibaction"},
8042   {AttributeCommonInfo::AS_CXX11, "clang::ibaction"},
8043   {AttributeCommonInfo::AS_C23, "clang::ibaction"},
8044 };
8045 struct ParsedAttrInfoIBAction final : public ParsedAttrInfo {
8046   constexpr ParsedAttrInfoIBAction() : ParsedAttrInfo(
8047     /*AttrKind=*/ParsedAttr::AT_IBAction,
8048     /*NumArgs=*/0,
8049     /*OptArgs=*/0,
8050     /*NumArgMembers=*/0,
8051     /*HasCustomParsing=*/0,
8052     /*AcceptsExprPack=*/0,
8053     /*IsTargetSpecific=*/0,
8054     /*IsType=*/0,
8055     /*IsStmt=*/0,
8056     /*IsKnownToGCC=*/0,
8057     /*IsSupportedByPragmaAttribute=*/1,
8058     /*Spellings=*/IBActionSpellings,
8059     /*ArgNames=*/{}) {}
8060 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8061   if (!isObjCInstanceMethod(D)) {
8062     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8063       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C instance methods";
8064     return false;
8065   }
8066   return true;
8067 }
8068 
8069 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8070   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8071     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8072   return false;
8073 }
8074 
8075 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8076   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method_is_instance, /*IsSupported=*/LangOpts.ObjC));
8077 }
8078 
8079 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
8080   D->addAttr(::new (S.Context) IBActionAttr(S.Context, Attr));
8081   return AttributeApplied;
8082 }
8083 
8084 bool isParamExpr(size_t N) const override {
8085   return false;
8086 }
8087 
8088 static const ParsedAttrInfoIBAction Instance;
8089 };
8090 const ParsedAttrInfoIBAction ParsedAttrInfoIBAction::Instance;
8091 static constexpr ParsedAttrInfo::Spelling IBOutletSpellings[] = {
8092   {AttributeCommonInfo::AS_GNU, "iboutlet"},
8093   {AttributeCommonInfo::AS_CXX11, "clang::iboutlet"},
8094   {AttributeCommonInfo::AS_C23, "clang::iboutlet"},
8095 };
8096 struct ParsedAttrInfoIBOutlet final : public ParsedAttrInfo {
8097   constexpr ParsedAttrInfoIBOutlet() : ParsedAttrInfo(
8098     /*AttrKind=*/ParsedAttr::AT_IBOutlet,
8099     /*NumArgs=*/0,
8100     /*OptArgs=*/0,
8101     /*NumArgMembers=*/0,
8102     /*HasCustomParsing=*/0,
8103     /*AcceptsExprPack=*/0,
8104     /*IsTargetSpecific=*/0,
8105     /*IsType=*/0,
8106     /*IsStmt=*/0,
8107     /*IsKnownToGCC=*/0,
8108     /*IsSupportedByPragmaAttribute=*/0,
8109     /*Spellings=*/IBOutletSpellings,
8110     /*ArgNames=*/{}) {}
8111 bool isParamExpr(size_t N) const override {
8112   return false;
8113 }
8114 
8115 static const ParsedAttrInfoIBOutlet Instance;
8116 };
8117 const ParsedAttrInfoIBOutlet ParsedAttrInfoIBOutlet::Instance;
8118 static constexpr ParsedAttrInfo::Spelling IBOutletCollectionSpellings[] = {
8119   {AttributeCommonInfo::AS_GNU, "iboutletcollection"},
8120   {AttributeCommonInfo::AS_CXX11, "clang::iboutletcollection"},
8121   {AttributeCommonInfo::AS_C23, "clang::iboutletcollection"},
8122 };
8123 static constexpr const char *IBOutletCollectionArgNames[] = {
8124 "Interface",};
8125 struct ParsedAttrInfoIBOutletCollection final : public ParsedAttrInfo {
8126   constexpr ParsedAttrInfoIBOutletCollection() : ParsedAttrInfo(
8127     /*AttrKind=*/ParsedAttr::AT_IBOutletCollection,
8128     /*NumArgs=*/0,
8129     /*OptArgs=*/1,
8130     /*NumArgMembers=*/1,
8131     /*HasCustomParsing=*/0,
8132     /*AcceptsExprPack=*/0,
8133     /*IsTargetSpecific=*/0,
8134     /*IsType=*/0,
8135     /*IsStmt=*/0,
8136     /*IsKnownToGCC=*/0,
8137     /*IsSupportedByPragmaAttribute=*/0,
8138     /*Spellings=*/IBOutletCollectionSpellings,
8139     /*ArgNames=*/IBOutletCollectionArgNames) {}
8140 bool isParamExpr(size_t N) const override {
8141   return false;
8142 }
8143 
8144 static const ParsedAttrInfoIBOutletCollection Instance;
8145 };
8146 const ParsedAttrInfoIBOutletCollection ParsedAttrInfoIBOutletCollection::Instance;
8147 static constexpr ParsedAttrInfo::Spelling IFuncSpellings[] = {
8148   {AttributeCommonInfo::AS_GNU, "ifunc"},
8149   {AttributeCommonInfo::AS_CXX11, "gnu::ifunc"},
8150   {AttributeCommonInfo::AS_C23, "gnu::ifunc"},
8151 };
8152 static constexpr const char *IFuncArgNames[] = {
8153 "Resolver",};
8154 struct ParsedAttrInfoIFunc final : public ParsedAttrInfo {
8155   constexpr ParsedAttrInfoIFunc() : ParsedAttrInfo(
8156     /*AttrKind=*/ParsedAttr::AT_IFunc,
8157     /*NumArgs=*/1,
8158     /*OptArgs=*/0,
8159     /*NumArgMembers=*/1,
8160     /*HasCustomParsing=*/0,
8161     /*AcceptsExprPack=*/0,
8162     /*IsTargetSpecific=*/1,
8163     /*IsType=*/0,
8164     /*IsStmt=*/0,
8165     /*IsKnownToGCC=*/1,
8166     /*IsSupportedByPragmaAttribute=*/1,
8167     /*Spellings=*/IFuncSpellings,
8168     /*ArgNames=*/IFuncArgNames) {}
8169 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8170   if (!isa<FunctionDecl>(D)) {
8171     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8172       << Attr << Attr.isRegularKeywordAttribute() << "functions";
8173     return false;
8174   }
8175   return true;
8176 }
8177 
8178 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8179   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8180     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8181   return false;
8182 }
8183 
8184 bool existsInTarget(const TargetInfo &Target) const override {
8185   const llvm::Triple &T = Target.getTriple(); (void)T;
8186   return true && ( Target.supportsIFunc() );
8187 }
8188 
8189 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8190   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
8191 }
8192 
8193 bool isParamExpr(size_t N) const override {
8194   return false;
8195 }
8196 
8197 static const ParsedAttrInfoIFunc Instance;
8198 };
8199 const ParsedAttrInfoIFunc ParsedAttrInfoIFunc::Instance;
8200 static constexpr ParsedAttrInfo::Spelling InitPrioritySpellings[] = {
8201   {AttributeCommonInfo::AS_GNU, "init_priority"},
8202   {AttributeCommonInfo::AS_CXX11, "gnu::init_priority"},
8203 };
8204 static constexpr const char *InitPriorityArgNames[] = {
8205 "Priority",};
8206 struct ParsedAttrInfoInitPriority final : public ParsedAttrInfo {
8207   constexpr ParsedAttrInfoInitPriority() : ParsedAttrInfo(
8208     /*AttrKind=*/ParsedAttr::AT_InitPriority,
8209     /*NumArgs=*/1,
8210     /*OptArgs=*/0,
8211     /*NumArgMembers=*/1,
8212     /*HasCustomParsing=*/0,
8213     /*AcceptsExprPack=*/0,
8214     /*IsTargetSpecific=*/1,
8215     /*IsType=*/0,
8216     /*IsStmt=*/0,
8217     /*IsKnownToGCC=*/1,
8218     /*IsSupportedByPragmaAttribute=*/1,
8219     /*Spellings=*/InitPrioritySpellings,
8220     /*ArgNames=*/InitPriorityArgNames) {}
8221 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8222   if (!isa<VarDecl>(D)) {
8223     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
8224       << Attr << Attr.isRegularKeywordAttribute() << "variables";
8225     return false;
8226   }
8227   return true;
8228 }
8229 
8230 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8231   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8232     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8233   return false;
8234 }
8235 
8236 bool existsInTarget(const TargetInfo &Target) const override {
8237   const llvm::Triple &T = Target.getTriple(); (void)T;
8238   return true && ( !Target.getTriple().isOSzOS() );
8239 }
8240 
8241 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8242   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
8243 }
8244 
8245 bool isParamExpr(size_t N) const override {
8246   return false;
8247 }
8248 
8249 static const ParsedAttrInfoInitPriority Instance;
8250 };
8251 const ParsedAttrInfoInitPriority ParsedAttrInfoInitPriority::Instance;
8252 static constexpr ParsedAttrInfo::Spelling IntelOclBiccSpellings[] = {
8253   {AttributeCommonInfo::AS_GNU, "intel_ocl_bicc"},
8254   {AttributeCommonInfo::AS_CXX11, "clang::intel_ocl_bicc"},
8255 };
8256 struct ParsedAttrInfoIntelOclBicc final : public ParsedAttrInfo {
8257   constexpr ParsedAttrInfoIntelOclBicc() : ParsedAttrInfo(
8258     /*AttrKind=*/ParsedAttr::AT_IntelOclBicc,
8259     /*NumArgs=*/0,
8260     /*OptArgs=*/0,
8261     /*NumArgMembers=*/0,
8262     /*HasCustomParsing=*/0,
8263     /*AcceptsExprPack=*/0,
8264     /*IsTargetSpecific=*/0,
8265     /*IsType=*/1,
8266     /*IsStmt=*/0,
8267     /*IsKnownToGCC=*/0,
8268     /*IsSupportedByPragmaAttribute=*/0,
8269     /*Spellings=*/IntelOclBiccSpellings,
8270     /*ArgNames=*/{}) {}
8271 bool isParamExpr(size_t N) const override {
8272   return false;
8273 }
8274 
8275 static const ParsedAttrInfoIntelOclBicc Instance;
8276 };
8277 const ParsedAttrInfoIntelOclBicc ParsedAttrInfoIntelOclBicc::Instance;
8278 static constexpr ParsedAttrInfo::Spelling InternalLinkageSpellings[] = {
8279   {AttributeCommonInfo::AS_GNU, "internal_linkage"},
8280   {AttributeCommonInfo::AS_CXX11, "clang::internal_linkage"},
8281   {AttributeCommonInfo::AS_C23, "clang::internal_linkage"},
8282 };
8283 struct ParsedAttrInfoInternalLinkage final : public ParsedAttrInfo {
8284   constexpr ParsedAttrInfoInternalLinkage() : ParsedAttrInfo(
8285     /*AttrKind=*/ParsedAttr::AT_InternalLinkage,
8286     /*NumArgs=*/0,
8287     /*OptArgs=*/0,
8288     /*NumArgMembers=*/0,
8289     /*HasCustomParsing=*/0,
8290     /*AcceptsExprPack=*/0,
8291     /*IsTargetSpecific=*/0,
8292     /*IsType=*/0,
8293     /*IsStmt=*/0,
8294     /*IsKnownToGCC=*/0,
8295     /*IsSupportedByPragmaAttribute=*/1,
8296     /*Spellings=*/InternalLinkageSpellings,
8297     /*ArgNames=*/{}) {}
8298 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8299   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) {
8300     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8301       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes";
8302     return false;
8303   }
8304   return true;
8305 }
8306 
8307 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8308   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8309     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8310   return false;
8311 }
8312 
8313   using ParsedAttrInfo::diagMutualExclusion;
8314 
8315   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
8316     if (const auto *A = D->getAttr<CommonAttr>()) {
8317       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
8318       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
8319 return false;
8320     }
8321     return true;
8322   }
8323 
8324 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8325   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
8326   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
8327   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
8328 }
8329 
8330 bool isParamExpr(size_t N) const override {
8331   return false;
8332 }
8333 
8334 static const ParsedAttrInfoInternalLinkage Instance;
8335 };
8336 const ParsedAttrInfoInternalLinkage ParsedAttrInfoInternalLinkage::Instance;
8337 static constexpr ParsedAttrInfo::Spelling LTOVisibilityPublicSpellings[] = {
8338   {AttributeCommonInfo::AS_GNU, "lto_visibility_public"},
8339   {AttributeCommonInfo::AS_CXX11, "clang::lto_visibility_public"},
8340   {AttributeCommonInfo::AS_C23, "clang::lto_visibility_public"},
8341 };
8342 struct ParsedAttrInfoLTOVisibilityPublic final : public ParsedAttrInfo {
8343   constexpr ParsedAttrInfoLTOVisibilityPublic() : ParsedAttrInfo(
8344     /*AttrKind=*/ParsedAttr::AT_LTOVisibilityPublic,
8345     /*NumArgs=*/0,
8346     /*OptArgs=*/0,
8347     /*NumArgMembers=*/0,
8348     /*HasCustomParsing=*/0,
8349     /*AcceptsExprPack=*/0,
8350     /*IsTargetSpecific=*/0,
8351     /*IsType=*/0,
8352     /*IsStmt=*/0,
8353     /*IsKnownToGCC=*/0,
8354     /*IsSupportedByPragmaAttribute=*/1,
8355     /*Spellings=*/LTOVisibilityPublicSpellings,
8356     /*ArgNames=*/{}) {}
8357 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8358   if (!isa<RecordDecl>(D)) {
8359     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8360       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
8361     return false;
8362   }
8363   return true;
8364 }
8365 
8366 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8367   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8368     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8369   return false;
8370 }
8371 
8372 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8373   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
8374 }
8375 
8376 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
8377   D->addAttr(::new (S.Context) LTOVisibilityPublicAttr(S.Context, Attr));
8378   return AttributeApplied;
8379 }
8380 
8381 bool isParamExpr(size_t N) const override {
8382   return false;
8383 }
8384 
8385 static const ParsedAttrInfoLTOVisibilityPublic Instance;
8386 };
8387 const ParsedAttrInfoLTOVisibilityPublic ParsedAttrInfoLTOVisibilityPublic::Instance;
8388 static constexpr ParsedAttrInfo::Spelling LayoutVersionSpellings[] = {
8389   {AttributeCommonInfo::AS_Declspec, "layout_version"},
8390 };
8391 static constexpr const char *LayoutVersionArgNames[] = {
8392 "Version",};
8393 struct ParsedAttrInfoLayoutVersion final : public ParsedAttrInfo {
8394   constexpr ParsedAttrInfoLayoutVersion() : ParsedAttrInfo(
8395     /*AttrKind=*/ParsedAttr::AT_LayoutVersion,
8396     /*NumArgs=*/1,
8397     /*OptArgs=*/0,
8398     /*NumArgMembers=*/1,
8399     /*HasCustomParsing=*/0,
8400     /*AcceptsExprPack=*/0,
8401     /*IsTargetSpecific=*/1,
8402     /*IsType=*/0,
8403     /*IsStmt=*/0,
8404     /*IsKnownToGCC=*/0,
8405     /*IsSupportedByPragmaAttribute=*/0,
8406     /*Spellings=*/LayoutVersionSpellings,
8407     /*ArgNames=*/LayoutVersionArgNames) {}
8408 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8409   if (!isa<CXXRecordDecl>(D)) {
8410     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8411       << Attr << Attr.isRegularKeywordAttribute() << "classes";
8412     return false;
8413   }
8414   return true;
8415 }
8416 
8417 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8418   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8419     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8420   return false;
8421 }
8422 
8423 bool existsInTarget(const TargetInfo &Target) const override {
8424   const llvm::Triple &T = Target.getTriple(); (void)T;
8425   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() );
8426 }
8427 
8428 bool isParamExpr(size_t N) const override {
8429   return false;
8430 }
8431 
8432 static const ParsedAttrInfoLayoutVersion Instance;
8433 };
8434 const ParsedAttrInfoLayoutVersion ParsedAttrInfoLayoutVersion::Instance;
8435 static constexpr ParsedAttrInfo::Spelling LeafSpellings[] = {
8436   {AttributeCommonInfo::AS_GNU, "leaf"},
8437   {AttributeCommonInfo::AS_CXX11, "gnu::leaf"},
8438   {AttributeCommonInfo::AS_C23, "gnu::leaf"},
8439 };
8440 struct ParsedAttrInfoLeaf final : public ParsedAttrInfo {
8441   constexpr ParsedAttrInfoLeaf() : ParsedAttrInfo(
8442     /*AttrKind=*/ParsedAttr::AT_Leaf,
8443     /*NumArgs=*/0,
8444     /*OptArgs=*/0,
8445     /*NumArgMembers=*/0,
8446     /*HasCustomParsing=*/0,
8447     /*AcceptsExprPack=*/0,
8448     /*IsTargetSpecific=*/0,
8449     /*IsType=*/0,
8450     /*IsStmt=*/0,
8451     /*IsKnownToGCC=*/1,
8452     /*IsSupportedByPragmaAttribute=*/1,
8453     /*Spellings=*/LeafSpellings,
8454     /*ArgNames=*/{}) {}
8455 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8456   if (!isa<FunctionDecl>(D)) {
8457     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8458       << Attr << Attr.isRegularKeywordAttribute() << "functions";
8459     return false;
8460   }
8461   return true;
8462 }
8463 
8464 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8465   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8466     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8467   return false;
8468 }
8469 
8470 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8471   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
8472 }
8473 
8474 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
8475   D->addAttr(::new (S.Context) LeafAttr(S.Context, Attr));
8476   return AttributeApplied;
8477 }
8478 
8479 bool isParamExpr(size_t N) const override {
8480   return false;
8481 }
8482 
8483 static const ParsedAttrInfoLeaf Instance;
8484 };
8485 const ParsedAttrInfoLeaf ParsedAttrInfoLeaf::Instance;
8486 static constexpr ParsedAttrInfo::Spelling LifetimeBoundSpellings[] = {
8487   {AttributeCommonInfo::AS_GNU, "lifetimebound"},
8488   {AttributeCommonInfo::AS_CXX11, "clang::lifetimebound"},
8489 };
8490 struct ParsedAttrInfoLifetimeBound final : public ParsedAttrInfo {
8491   constexpr ParsedAttrInfoLifetimeBound() : ParsedAttrInfo(
8492     /*AttrKind=*/ParsedAttr::AT_LifetimeBound,
8493     /*NumArgs=*/0,
8494     /*OptArgs=*/0,
8495     /*NumArgMembers=*/0,
8496     /*HasCustomParsing=*/0,
8497     /*AcceptsExprPack=*/0,
8498     /*IsTargetSpecific=*/0,
8499     /*IsType=*/1,
8500     /*IsStmt=*/0,
8501     /*IsKnownToGCC=*/0,
8502     /*IsSupportedByPragmaAttribute=*/0,
8503     /*Spellings=*/LifetimeBoundSpellings,
8504     /*ArgNames=*/{}) {}
8505 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8506   if (!isa<ParmVarDecl>(D) && !isImplicitObjectParameter(D)) {
8507     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
8508       << Attr << Attr.isRegularKeywordAttribute() << "parameters and implicit object parameters";
8509     return false;
8510   }
8511   return true;
8512 }
8513 
8514 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8515   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8516     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8517   return false;
8518 }
8519 
8520 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
8521   D->addAttr(::new (S.Context) LifetimeBoundAttr(S.Context, Attr));
8522   return AttributeApplied;
8523 }
8524 
8525 bool isParamExpr(size_t N) const override {
8526   return false;
8527 }
8528 
8529 static const ParsedAttrInfoLifetimeBound Instance;
8530 };
8531 const ParsedAttrInfoLifetimeBound ParsedAttrInfoLifetimeBound::Instance;
8532 static constexpr ParsedAttrInfo::Spelling LifetimeCaptureBySpellings[] = {
8533   {AttributeCommonInfo::AS_GNU, "lifetime_capture_by"},
8534   {AttributeCommonInfo::AS_CXX11, "clang::lifetime_capture_by"},
8535 };
8536 static constexpr const char *LifetimeCaptureByArgNames[] = {
8537 "Params...",};
8538 struct ParsedAttrInfoLifetimeCaptureBy final : public ParsedAttrInfo {
8539   constexpr ParsedAttrInfoLifetimeCaptureBy() : ParsedAttrInfo(
8540     /*AttrKind=*/ParsedAttr::AT_LifetimeCaptureBy,
8541     /*NumArgs=*/0,
8542     /*OptArgs=*/15,
8543     /*NumArgMembers=*/1,
8544     /*HasCustomParsing=*/0,
8545     /*AcceptsExprPack=*/0,
8546     /*IsTargetSpecific=*/0,
8547     /*IsType=*/1,
8548     /*IsStmt=*/0,
8549     /*IsKnownToGCC=*/0,
8550     /*IsSupportedByPragmaAttribute=*/0,
8551     /*Spellings=*/LifetimeCaptureBySpellings,
8552     /*ArgNames=*/LifetimeCaptureByArgNames) {}
8553 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8554   if (!isa<ParmVarDecl>(D) && !isImplicitObjectParameter(D)) {
8555     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
8556       << Attr << Attr.isRegularKeywordAttribute() << "parameters and implicit object parameters";
8557     return false;
8558   }
8559   return true;
8560 }
8561 
8562 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8563   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8564     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8565   return false;
8566 }
8567 
8568 bool isParamExpr(size_t N) const override {
8569   return false;
8570 }
8571 
8572 static const ParsedAttrInfoLifetimeCaptureBy Instance;
8573 };
8574 const ParsedAttrInfoLifetimeCaptureBy ParsedAttrInfoLifetimeCaptureBy::Instance;
8575 static constexpr ParsedAttrInfo::Spelling LikelySpellings[] = {
8576   {AttributeCommonInfo::AS_CXX11, "likely"},
8577   {AttributeCommonInfo::AS_C23, "clang::likely"},
8578 };
8579 struct ParsedAttrInfoLikely final : public ParsedAttrInfo {
8580   constexpr ParsedAttrInfoLikely() : ParsedAttrInfo(
8581     /*AttrKind=*/ParsedAttr::AT_Likely,
8582     /*NumArgs=*/0,
8583     /*OptArgs=*/0,
8584     /*NumArgMembers=*/0,
8585     /*HasCustomParsing=*/0,
8586     /*AcceptsExprPack=*/0,
8587     /*IsTargetSpecific=*/0,
8588     /*IsType=*/0,
8589     /*IsStmt=*/1,
8590     /*IsKnownToGCC=*/0,
8591     /*IsSupportedByPragmaAttribute=*/0,
8592     /*Spellings=*/LikelySpellings,
8593     /*ArgNames=*/{}) {}
8594   using ParsedAttrInfo::diagMutualExclusion;
8595 
8596 bool isParamExpr(size_t N) const override {
8597   return false;
8598 }
8599 
8600 static const ParsedAttrInfoLikely Instance;
8601 };
8602 const ParsedAttrInfoLikely ParsedAttrInfoLikely::Instance;
8603 static constexpr ParsedAttrInfo::Spelling LoaderUninitializedSpellings[] = {
8604   {AttributeCommonInfo::AS_GNU, "loader_uninitialized"},
8605   {AttributeCommonInfo::AS_CXX11, "clang::loader_uninitialized"},
8606   {AttributeCommonInfo::AS_C23, "clang::loader_uninitialized"},
8607 };
8608 struct ParsedAttrInfoLoaderUninitialized final : public ParsedAttrInfo {
8609   constexpr ParsedAttrInfoLoaderUninitialized() : ParsedAttrInfo(
8610     /*AttrKind=*/ParsedAttr::AT_LoaderUninitialized,
8611     /*NumArgs=*/0,
8612     /*OptArgs=*/0,
8613     /*NumArgMembers=*/0,
8614     /*HasCustomParsing=*/0,
8615     /*AcceptsExprPack=*/0,
8616     /*IsTargetSpecific=*/0,
8617     /*IsType=*/0,
8618     /*IsStmt=*/0,
8619     /*IsKnownToGCC=*/0,
8620     /*IsSupportedByPragmaAttribute=*/1,
8621     /*Spellings=*/LoaderUninitializedSpellings,
8622     /*ArgNames=*/{}) {}
8623 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8624   if (!isGlobalVar(D)) {
8625     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8626       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
8627     return false;
8628   }
8629   return true;
8630 }
8631 
8632 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8633   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8634     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8635   return false;
8636 }
8637 
8638 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8639   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
8640 }
8641 
8642 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
8643   D->addAttr(::new (S.Context) LoaderUninitializedAttr(S.Context, Attr));
8644   return AttributeApplied;
8645 }
8646 
8647 bool isParamExpr(size_t N) const override {
8648   return false;
8649 }
8650 
8651 static const ParsedAttrInfoLoaderUninitialized Instance;
8652 };
8653 const ParsedAttrInfoLoaderUninitialized ParsedAttrInfoLoaderUninitialized::Instance;
8654 static constexpr ParsedAttrInfo::Spelling LockReturnedSpellings[] = {
8655   {AttributeCommonInfo::AS_GNU, "lock_returned"},
8656 };
8657 static constexpr const char *LockReturnedArgNames[] = {
8658 "Arg",};
8659 struct ParsedAttrInfoLockReturned final : public ParsedAttrInfo {
8660   constexpr ParsedAttrInfoLockReturned() : ParsedAttrInfo(
8661     /*AttrKind=*/ParsedAttr::AT_LockReturned,
8662     /*NumArgs=*/1,
8663     /*OptArgs=*/0,
8664     /*NumArgMembers=*/1,
8665     /*HasCustomParsing=*/0,
8666     /*AcceptsExprPack=*/0,
8667     /*IsTargetSpecific=*/0,
8668     /*IsType=*/0,
8669     /*IsStmt=*/0,
8670     /*IsKnownToGCC=*/0,
8671     /*IsSupportedByPragmaAttribute=*/0,
8672     /*Spellings=*/LockReturnedSpellings,
8673     /*ArgNames=*/LockReturnedArgNames) {}
8674 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8675   if (!isa<FunctionDecl>(D)) {
8676     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8677       << Attr << Attr.isRegularKeywordAttribute() << "functions";
8678     return false;
8679   }
8680   return true;
8681 }
8682 
8683 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8684   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8685     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8686   return false;
8687 }
8688 
8689 bool isParamExpr(size_t N) const override {
8690   return (N == 0) || false;
8691 }
8692 
8693 static const ParsedAttrInfoLockReturned Instance;
8694 };
8695 const ParsedAttrInfoLockReturned ParsedAttrInfoLockReturned::Instance;
8696 static constexpr ParsedAttrInfo::Spelling LockableSpellings[] = {
8697   {AttributeCommonInfo::AS_GNU, "lockable"},
8698 };
8699 struct ParsedAttrInfoLockable final : public ParsedAttrInfo {
8700   constexpr ParsedAttrInfoLockable() : ParsedAttrInfo(
8701     /*AttrKind=*/ParsedAttr::AT_Lockable,
8702     /*NumArgs=*/0,
8703     /*OptArgs=*/0,
8704     /*NumArgMembers=*/0,
8705     /*HasCustomParsing=*/0,
8706     /*AcceptsExprPack=*/0,
8707     /*IsTargetSpecific=*/0,
8708     /*IsType=*/0,
8709     /*IsStmt=*/0,
8710     /*IsKnownToGCC=*/0,
8711     /*IsSupportedByPragmaAttribute=*/1,
8712     /*Spellings=*/LockableSpellings,
8713     /*ArgNames=*/{}) {}
8714 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8715   if (!isa<RecordDecl>(D)) {
8716     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8717       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
8718     return false;
8719   }
8720   return true;
8721 }
8722 
8723 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8724   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8725     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8726   return false;
8727 }
8728 
8729 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8730   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
8731 }
8732 
8733 bool isParamExpr(size_t N) const override {
8734   return false;
8735 }
8736 
8737 static const ParsedAttrInfoLockable Instance;
8738 };
8739 const ParsedAttrInfoLockable ParsedAttrInfoLockable::Instance;
8740 static constexpr ParsedAttrInfo::Spelling LocksExcludedSpellings[] = {
8741   {AttributeCommonInfo::AS_GNU, "locks_excluded"},
8742 };
8743 static constexpr const char *LocksExcludedArgNames[] = {
8744 "Args...",};
8745 struct ParsedAttrInfoLocksExcluded final : public ParsedAttrInfo {
8746   constexpr ParsedAttrInfoLocksExcluded() : ParsedAttrInfo(
8747     /*AttrKind=*/ParsedAttr::AT_LocksExcluded,
8748     /*NumArgs=*/0,
8749     /*OptArgs=*/15,
8750     /*NumArgMembers=*/1,
8751     /*HasCustomParsing=*/0,
8752     /*AcceptsExprPack=*/0,
8753     /*IsTargetSpecific=*/0,
8754     /*IsType=*/0,
8755     /*IsStmt=*/0,
8756     /*IsKnownToGCC=*/0,
8757     /*IsSupportedByPragmaAttribute=*/0,
8758     /*Spellings=*/LocksExcludedSpellings,
8759     /*ArgNames=*/LocksExcludedArgNames) {}
8760 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8761   if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) {
8762     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8763       << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters";
8764     return false;
8765   }
8766   return true;
8767 }
8768 
8769 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8770   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8771     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8772   return false;
8773 }
8774 
8775 bool isParamExpr(size_t N) const override {
8776   return (N == 0) || false;
8777 }
8778 
8779 static const ParsedAttrInfoLocksExcluded Instance;
8780 };
8781 const ParsedAttrInfoLocksExcluded ParsedAttrInfoLocksExcluded::Instance;
8782 static constexpr ParsedAttrInfo::Spelling LoopHintSpellings[] = {
8783   {AttributeCommonInfo::AS_Pragma, "clang::loop"},
8784   {AttributeCommonInfo::AS_Pragma, "unroll"},
8785   {AttributeCommonInfo::AS_Pragma, "nounroll"},
8786   {AttributeCommonInfo::AS_Pragma, "unroll_and_jam"},
8787   {AttributeCommonInfo::AS_Pragma, "nounroll_and_jam"},
8788 };
8789 static constexpr const char *LoopHintArgNames[] = {
8790 "Option","State","Value",};
8791 struct ParsedAttrInfoLoopHint final : public ParsedAttrInfo {
8792   constexpr ParsedAttrInfoLoopHint() : ParsedAttrInfo(
8793     /*AttrKind=*/ParsedAttr::AT_LoopHint,
8794     /*NumArgs=*/3,
8795     /*OptArgs=*/0,
8796     /*NumArgMembers=*/3,
8797     /*HasCustomParsing=*/1,
8798     /*AcceptsExprPack=*/0,
8799     /*IsTargetSpecific=*/0,
8800     /*IsType=*/0,
8801     /*IsStmt=*/0,
8802     /*IsKnownToGCC=*/0,
8803     /*IsSupportedByPragmaAttribute=*/0,
8804     /*Spellings=*/LoopHintSpellings,
8805     /*ArgNames=*/LoopHintArgNames) {}
8806 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
8807   enum Spelling {
8808     Pragma_clang_loop = 0,
8809     Pragma_unroll = 1,
8810     Pragma_nounroll = 2,
8811     Pragma_unroll_and_jam = 3,
8812     Pragma_nounroll_and_jam = 4,
8813   SpellingNotCalculated = 15
8814 
8815   };
8816 
8817   unsigned Idx = Attr.getAttributeSpellingListIndex();
8818   switch (Idx) {
8819     default: llvm_unreachable("Unknown spelling list index");
8820     case 0: return Pragma_clang_loop;
8821     case 1: return Pragma_unroll;
8822     case 2: return Pragma_nounroll;
8823     case 3: return Pragma_unroll_and_jam;
8824     case 4: return Pragma_nounroll_and_jam;
8825   }
8826 }
8827 
8828 bool isParamExpr(size_t N) const override {
8829   return (N == 2) || false;
8830 }
8831 
8832 static const ParsedAttrInfoLoopHint Instance;
8833 };
8834 const ParsedAttrInfoLoopHint ParsedAttrInfoLoopHint::Instance;
8835 static constexpr ParsedAttrInfo::Spelling M68kRTDSpellings[] = {
8836   {AttributeCommonInfo::AS_GNU, "m68k_rtd"},
8837   {AttributeCommonInfo::AS_CXX11, "clang::m68k_rtd"},
8838   {AttributeCommonInfo::AS_C23, "clang::m68k_rtd"},
8839 };
8840 struct ParsedAttrInfoM68kRTD final : public ParsedAttrInfo {
8841   constexpr ParsedAttrInfoM68kRTD() : ParsedAttrInfo(
8842     /*AttrKind=*/ParsedAttr::AT_M68kRTD,
8843     /*NumArgs=*/0,
8844     /*OptArgs=*/0,
8845     /*NumArgMembers=*/0,
8846     /*HasCustomParsing=*/0,
8847     /*AcceptsExprPack=*/0,
8848     /*IsTargetSpecific=*/0,
8849     /*IsType=*/1,
8850     /*IsStmt=*/0,
8851     /*IsKnownToGCC=*/0,
8852     /*IsSupportedByPragmaAttribute=*/0,
8853     /*Spellings=*/M68kRTDSpellings,
8854     /*ArgNames=*/{}) {}
8855 bool isParamExpr(size_t N) const override {
8856   return false;
8857 }
8858 
8859 static const ParsedAttrInfoM68kRTD Instance;
8860 };
8861 const ParsedAttrInfoM68kRTD ParsedAttrInfoM68kRTD::Instance;
8862 static constexpr ParsedAttrInfo::Spelling MIGServerRoutineSpellings[] = {
8863   {AttributeCommonInfo::AS_GNU, "mig_server_routine"},
8864   {AttributeCommonInfo::AS_CXX11, "clang::mig_server_routine"},
8865   {AttributeCommonInfo::AS_C23, "clang::mig_server_routine"},
8866 };
8867 struct ParsedAttrInfoMIGServerRoutine final : public ParsedAttrInfo {
8868   constexpr ParsedAttrInfoMIGServerRoutine() : ParsedAttrInfo(
8869     /*AttrKind=*/ParsedAttr::AT_MIGServerRoutine,
8870     /*NumArgs=*/0,
8871     /*OptArgs=*/0,
8872     /*NumArgMembers=*/0,
8873     /*HasCustomParsing=*/0,
8874     /*AcceptsExprPack=*/0,
8875     /*IsTargetSpecific=*/0,
8876     /*IsType=*/0,
8877     /*IsStmt=*/0,
8878     /*IsKnownToGCC=*/0,
8879     /*IsSupportedByPragmaAttribute=*/1,
8880     /*Spellings=*/MIGServerRoutineSpellings,
8881     /*ArgNames=*/{}) {}
8882 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8883   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<BlockDecl>(D)) {
8884     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8885       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and blocks";
8886     return false;
8887   }
8888   return true;
8889 }
8890 
8891 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8892   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8893     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8894   return false;
8895 }
8896 
8897 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
8898   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
8899   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
8900   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_block, /*IsSupported=*/LangOpts.Blocks));
8901 }
8902 
8903 bool isParamExpr(size_t N) const override {
8904   return false;
8905 }
8906 
8907 static const ParsedAttrInfoMIGServerRoutine Instance;
8908 };
8909 const ParsedAttrInfoMIGServerRoutine ParsedAttrInfoMIGServerRoutine::Instance;
8910 static constexpr ParsedAttrInfo::Spelling MSABISpellings[] = {
8911   {AttributeCommonInfo::AS_GNU, "ms_abi"},
8912   {AttributeCommonInfo::AS_CXX11, "gnu::ms_abi"},
8913   {AttributeCommonInfo::AS_C23, "gnu::ms_abi"},
8914 };
8915 struct ParsedAttrInfoMSABI final : public ParsedAttrInfo {
8916   constexpr ParsedAttrInfoMSABI() : ParsedAttrInfo(
8917     /*AttrKind=*/ParsedAttr::AT_MSABI,
8918     /*NumArgs=*/0,
8919     /*OptArgs=*/0,
8920     /*NumArgMembers=*/0,
8921     /*HasCustomParsing=*/0,
8922     /*AcceptsExprPack=*/0,
8923     /*IsTargetSpecific=*/0,
8924     /*IsType=*/1,
8925     /*IsStmt=*/0,
8926     /*IsKnownToGCC=*/1,
8927     /*IsSupportedByPragmaAttribute=*/0,
8928     /*Spellings=*/MSABISpellings,
8929     /*ArgNames=*/{}) {}
8930 bool isParamExpr(size_t N) const override {
8931   return false;
8932 }
8933 
8934 static const ParsedAttrInfoMSABI Instance;
8935 };
8936 const ParsedAttrInfoMSABI ParsedAttrInfoMSABI::Instance;
8937 static constexpr ParsedAttrInfo::Spelling MSAllocatorSpellings[] = {
8938   {AttributeCommonInfo::AS_Declspec, "allocator"},
8939 };
8940 struct ParsedAttrInfoMSAllocator final : public ParsedAttrInfo {
8941   constexpr ParsedAttrInfoMSAllocator() : ParsedAttrInfo(
8942     /*AttrKind=*/ParsedAttr::AT_MSAllocator,
8943     /*NumArgs=*/0,
8944     /*OptArgs=*/0,
8945     /*NumArgMembers=*/0,
8946     /*HasCustomParsing=*/0,
8947     /*AcceptsExprPack=*/0,
8948     /*IsTargetSpecific=*/0,
8949     /*IsType=*/0,
8950     /*IsStmt=*/0,
8951     /*IsKnownToGCC=*/0,
8952     /*IsSupportedByPragmaAttribute=*/0,
8953     /*Spellings=*/MSAllocatorSpellings,
8954     /*ArgNames=*/{}) {}
8955 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8956   if (!isa<FunctionDecl>(D)) {
8957     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
8958       << Attr << Attr.isRegularKeywordAttribute() << "functions";
8959     return false;
8960   }
8961   return true;
8962 }
8963 
8964 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
8965   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
8966     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
8967   return false;
8968 }
8969 
8970 bool isParamExpr(size_t N) const override {
8971   return false;
8972 }
8973 
8974 static const ParsedAttrInfoMSAllocator Instance;
8975 };
8976 const ParsedAttrInfoMSAllocator ParsedAttrInfoMSAllocator::Instance;
8977 static constexpr ParsedAttrInfo::Spelling MSConstexprSpellings[] = {
8978   {AttributeCommonInfo::AS_CXX11, "msvc::constexpr"},
8979 };
8980 struct ParsedAttrInfoMSConstexpr final : public ParsedAttrInfo {
8981   constexpr ParsedAttrInfoMSConstexpr() : ParsedAttrInfo(
8982     /*AttrKind=*/ParsedAttr::AT_MSConstexpr,
8983     /*NumArgs=*/0,
8984     /*OptArgs=*/0,
8985     /*NumArgMembers=*/0,
8986     /*HasCustomParsing=*/0,
8987     /*AcceptsExprPack=*/0,
8988     /*IsTargetSpecific=*/0,
8989     /*IsType=*/0,
8990     /*IsStmt=*/0,
8991     /*IsKnownToGCC=*/0,
8992     /*IsSupportedByPragmaAttribute=*/1,
8993     /*Spellings=*/MSConstexprSpellings,
8994     /*ArgNames=*/{}) {}
8995 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
8996   if (!isa<FunctionDecl>(D)) {
8997     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
8998       << Attr << Attr.isRegularKeywordAttribute() << "functions and return statements";
8999     return false;
9000   }
9001   return true;
9002 }
9003 
9004 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
9005   if (!isa<ReturnStmt>(St)) {
9006     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9007       << Attr << Attr.isRegularKeywordAttribute() << "functions and return statements";
9008     return false;
9009   }
9010   return true;
9011 }
9012 
9013 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
9014   return LangOpts.MicrosoftExt;
9015 }
9016 
9017 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9018   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9019 }
9020 
9021 bool isParamExpr(size_t N) const override {
9022   return false;
9023 }
9024 
9025 static const ParsedAttrInfoMSConstexpr Instance;
9026 };
9027 const ParsedAttrInfoMSConstexpr ParsedAttrInfoMSConstexpr::Instance;
9028 static constexpr ParsedAttrInfo::Spelling MSInheritanceSpellings[] = {
9029   {AttributeCommonInfo::AS_Keyword, "__single_inheritance"},
9030   {AttributeCommonInfo::AS_Keyword, "__multiple_inheritance"},
9031   {AttributeCommonInfo::AS_Keyword, "__virtual_inheritance"},
9032   {AttributeCommonInfo::AS_Keyword, "__unspecified_inheritance"},
9033 };
9034 struct ParsedAttrInfoMSInheritance final : public ParsedAttrInfo {
9035   constexpr ParsedAttrInfoMSInheritance() : ParsedAttrInfo(
9036     /*AttrKind=*/ParsedAttr::AT_MSInheritance,
9037     /*NumArgs=*/0,
9038     /*OptArgs=*/0,
9039     /*NumArgMembers=*/0,
9040     /*HasCustomParsing=*/0,
9041     /*AcceptsExprPack=*/0,
9042     /*IsTargetSpecific=*/0,
9043     /*IsType=*/0,
9044     /*IsStmt=*/0,
9045     /*IsKnownToGCC=*/0,
9046     /*IsSupportedByPragmaAttribute=*/0,
9047     /*Spellings=*/MSInheritanceSpellings,
9048     /*ArgNames=*/{}) {}
9049 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
9050   return LangOpts.MicrosoftExt;
9051 }
9052 
9053 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
9054   enum Spelling {
9055     Keyword_single_inheritance = 0,
9056     Keyword_multiple_inheritance = 1,
9057     Keyword_virtual_inheritance = 2,
9058     Keyword_unspecified_inheritance = 3,
9059   SpellingNotCalculated = 15
9060 
9061   };
9062 
9063   unsigned Idx = Attr.getAttributeSpellingListIndex();
9064   switch (Idx) {
9065     default: llvm_unreachable("Unknown spelling list index");
9066     case 0: return Keyword_single_inheritance;
9067     case 1: return Keyword_multiple_inheritance;
9068     case 2: return Keyword_virtual_inheritance;
9069     case 3: return Keyword_unspecified_inheritance;
9070   }
9071 }
9072 
9073 bool isParamExpr(size_t N) const override {
9074   return false;
9075 }
9076 
9077 static const ParsedAttrInfoMSInheritance Instance;
9078 };
9079 const ParsedAttrInfoMSInheritance ParsedAttrInfoMSInheritance::Instance;
9080 static constexpr ParsedAttrInfo::Spelling MSNoVTableSpellings[] = {
9081   {AttributeCommonInfo::AS_Declspec, "novtable"},
9082 };
9083 struct ParsedAttrInfoMSNoVTable final : public ParsedAttrInfo {
9084   constexpr ParsedAttrInfoMSNoVTable() : ParsedAttrInfo(
9085     /*AttrKind=*/ParsedAttr::AT_MSNoVTable,
9086     /*NumArgs=*/0,
9087     /*OptArgs=*/0,
9088     /*NumArgMembers=*/0,
9089     /*HasCustomParsing=*/0,
9090     /*AcceptsExprPack=*/0,
9091     /*IsTargetSpecific=*/1,
9092     /*IsType=*/0,
9093     /*IsStmt=*/0,
9094     /*IsKnownToGCC=*/0,
9095     /*IsSupportedByPragmaAttribute=*/0,
9096     /*Spellings=*/MSNoVTableSpellings,
9097     /*ArgNames=*/{}) {}
9098 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9099   if (!isa<CXXRecordDecl>(D)) {
9100     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9101       << Attr << Attr.isRegularKeywordAttribute() << "classes";
9102     return false;
9103   }
9104   return true;
9105 }
9106 
9107 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9108   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9109     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9110   return false;
9111 }
9112 
9113 bool existsInTarget(const TargetInfo &Target) const override {
9114   const llvm::Triple &T = Target.getTriple(); (void)T;
9115   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() );
9116 }
9117 
9118 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9119   D->addAttr(::new (S.Context) MSNoVTableAttr(S.Context, Attr));
9120   return AttributeApplied;
9121 }
9122 
9123 bool isParamExpr(size_t N) const override {
9124   return false;
9125 }
9126 
9127 static const ParsedAttrInfoMSNoVTable Instance;
9128 };
9129 const ParsedAttrInfoMSNoVTable ParsedAttrInfoMSNoVTable::Instance;
9130 static constexpr ParsedAttrInfo::Spelling MSStructSpellings[] = {
9131   {AttributeCommonInfo::AS_GNU, "ms_struct"},
9132   {AttributeCommonInfo::AS_CXX11, "gnu::ms_struct"},
9133   {AttributeCommonInfo::AS_C23, "gnu::ms_struct"},
9134 };
9135 struct ParsedAttrInfoMSStruct final : public ParsedAttrInfo {
9136   constexpr ParsedAttrInfoMSStruct() : ParsedAttrInfo(
9137     /*AttrKind=*/ParsedAttr::AT_MSStruct,
9138     /*NumArgs=*/0,
9139     /*OptArgs=*/0,
9140     /*NumArgMembers=*/0,
9141     /*HasCustomParsing=*/0,
9142     /*AcceptsExprPack=*/0,
9143     /*IsTargetSpecific=*/0,
9144     /*IsType=*/0,
9145     /*IsStmt=*/0,
9146     /*IsKnownToGCC=*/1,
9147     /*IsSupportedByPragmaAttribute=*/1,
9148     /*Spellings=*/MSStructSpellings,
9149     /*ArgNames=*/{}) {}
9150 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9151   if (!isa<RecordDecl>(D)) {
9152     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9153       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
9154     return false;
9155   }
9156   return true;
9157 }
9158 
9159 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9160   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9161     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9162   return false;
9163 }
9164 
9165 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9166   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
9167 }
9168 
9169 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9170   D->addAttr(::new (S.Context) MSStructAttr(S.Context, Attr));
9171   return AttributeApplied;
9172 }
9173 
9174 bool isParamExpr(size_t N) const override {
9175   return false;
9176 }
9177 
9178 static const ParsedAttrInfoMSStruct Instance;
9179 };
9180 const ParsedAttrInfoMSStruct ParsedAttrInfoMSStruct::Instance;
9181 static constexpr ParsedAttrInfo::Spelling MatrixTypeSpellings[] = {
9182   {AttributeCommonInfo::AS_GNU, "matrix_type"},
9183   {AttributeCommonInfo::AS_CXX11, "clang::matrix_type"},
9184   {AttributeCommonInfo::AS_C23, "clang::matrix_type"},
9185 };
9186 static constexpr const char *MatrixTypeArgNames[] = {
9187 "NumRows","NumColumns",};
9188 struct ParsedAttrInfoMatrixType final : public ParsedAttrInfo {
9189   constexpr ParsedAttrInfoMatrixType() : ParsedAttrInfo(
9190     /*AttrKind=*/ParsedAttr::AT_MatrixType,
9191     /*NumArgs=*/2,
9192     /*OptArgs=*/0,
9193     /*NumArgMembers=*/2,
9194     /*HasCustomParsing=*/0,
9195     /*AcceptsExprPack=*/0,
9196     /*IsTargetSpecific=*/0,
9197     /*IsType=*/1,
9198     /*IsStmt=*/0,
9199     /*IsKnownToGCC=*/0,
9200     /*IsSupportedByPragmaAttribute=*/0,
9201     /*Spellings=*/MatrixTypeSpellings,
9202     /*ArgNames=*/MatrixTypeArgNames) {}
9203 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9204   if (!isa<TypedefNameDecl>(D)) {
9205     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9206       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
9207     return false;
9208   }
9209   return true;
9210 }
9211 
9212 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9213   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9214     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9215   return false;
9216 }
9217 
9218 bool isParamExpr(size_t N) const override {
9219   return (N == 0) || (N == 1) || false;
9220 }
9221 
9222 static const ParsedAttrInfoMatrixType Instance;
9223 };
9224 const ParsedAttrInfoMatrixType ParsedAttrInfoMatrixType::Instance;
9225 static constexpr ParsedAttrInfo::Spelling MayAliasSpellings[] = {
9226   {AttributeCommonInfo::AS_GNU, "may_alias"},
9227   {AttributeCommonInfo::AS_CXX11, "gnu::may_alias"},
9228   {AttributeCommonInfo::AS_C23, "gnu::may_alias"},
9229 };
9230 struct ParsedAttrInfoMayAlias final : public ParsedAttrInfo {
9231   constexpr ParsedAttrInfoMayAlias() : ParsedAttrInfo(
9232     /*AttrKind=*/ParsedAttr::AT_MayAlias,
9233     /*NumArgs=*/0,
9234     /*OptArgs=*/0,
9235     /*NumArgMembers=*/0,
9236     /*HasCustomParsing=*/0,
9237     /*AcceptsExprPack=*/0,
9238     /*IsTargetSpecific=*/0,
9239     /*IsType=*/0,
9240     /*IsStmt=*/0,
9241     /*IsKnownToGCC=*/1,
9242     /*IsSupportedByPragmaAttribute=*/0,
9243     /*Spellings=*/MayAliasSpellings,
9244     /*ArgNames=*/{}) {}
9245 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9246   D->addAttr(::new (S.Context) MayAliasAttr(S.Context, Attr));
9247   return AttributeApplied;
9248 }
9249 
9250 bool isParamExpr(size_t N) const override {
9251   return false;
9252 }
9253 
9254 static const ParsedAttrInfoMayAlias Instance;
9255 };
9256 const ParsedAttrInfoMayAlias ParsedAttrInfoMayAlias::Instance;
9257 static constexpr ParsedAttrInfo::Spelling MaybeUndefSpellings[] = {
9258   {AttributeCommonInfo::AS_GNU, "maybe_undef"},
9259   {AttributeCommonInfo::AS_CXX11, "clang::maybe_undef"},
9260   {AttributeCommonInfo::AS_C23, "clang::maybe_undef"},
9261 };
9262 struct ParsedAttrInfoMaybeUndef final : public ParsedAttrInfo {
9263   constexpr ParsedAttrInfoMaybeUndef() : ParsedAttrInfo(
9264     /*AttrKind=*/ParsedAttr::AT_MaybeUndef,
9265     /*NumArgs=*/0,
9266     /*OptArgs=*/0,
9267     /*NumArgMembers=*/0,
9268     /*HasCustomParsing=*/0,
9269     /*AcceptsExprPack=*/0,
9270     /*IsTargetSpecific=*/0,
9271     /*IsType=*/0,
9272     /*IsStmt=*/0,
9273     /*IsKnownToGCC=*/0,
9274     /*IsSupportedByPragmaAttribute=*/1,
9275     /*Spellings=*/MaybeUndefSpellings,
9276     /*ArgNames=*/{}) {}
9277 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9278   if (!isa<ParmVarDecl>(D)) {
9279     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9280       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
9281     return false;
9282   }
9283   return true;
9284 }
9285 
9286 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9287   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9288     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9289   return false;
9290 }
9291 
9292 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9293   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
9294 }
9295 
9296 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9297   D->addAttr(::new (S.Context) MaybeUndefAttr(S.Context, Attr));
9298   return AttributeApplied;
9299 }
9300 
9301 bool isParamExpr(size_t N) const override {
9302   return false;
9303 }
9304 
9305 static const ParsedAttrInfoMaybeUndef Instance;
9306 };
9307 const ParsedAttrInfoMaybeUndef ParsedAttrInfoMaybeUndef::Instance;
9308 static constexpr ParsedAttrInfo::Spelling MicroMipsSpellings[] = {
9309   {AttributeCommonInfo::AS_GNU, "micromips"},
9310   {AttributeCommonInfo::AS_CXX11, "gnu::micromips"},
9311   {AttributeCommonInfo::AS_C23, "gnu::micromips"},
9312 };
9313 struct ParsedAttrInfoMicroMips final : public ParsedAttrInfo {
9314   constexpr ParsedAttrInfoMicroMips() : ParsedAttrInfo(
9315     /*AttrKind=*/ParsedAttr::AT_MicroMips,
9316     /*NumArgs=*/0,
9317     /*OptArgs=*/0,
9318     /*NumArgMembers=*/0,
9319     /*HasCustomParsing=*/0,
9320     /*AcceptsExprPack=*/0,
9321     /*IsTargetSpecific=*/1,
9322     /*IsType=*/0,
9323     /*IsStmt=*/0,
9324     /*IsKnownToGCC=*/1,
9325     /*IsSupportedByPragmaAttribute=*/1,
9326     /*Spellings=*/MicroMipsSpellings,
9327     /*ArgNames=*/{}) {}
9328 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9329   if (!isa<FunctionDecl>(D)) {
9330     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9331       << Attr << Attr.isRegularKeywordAttribute() << "functions";
9332     return false;
9333   }
9334   return true;
9335 }
9336 
9337 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9338   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9339     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9340   return false;
9341 }
9342 
9343   using ParsedAttrInfo::diagMutualExclusion;
9344 
9345   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
9346     if (const auto *A = D->getAttr<Mips16Attr>()) {
9347       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
9348       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
9349 return false;
9350     }
9351     return true;
9352   }
9353 
9354 bool existsInTarget(const TargetInfo &Target) const override {
9355   const llvm::Triple &T = Target.getTriple(); (void)T;
9356   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel);
9357 }
9358 
9359 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9360   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9361 }
9362 
9363 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9364   D->addAttr(::new (S.Context) MicroMipsAttr(S.Context, Attr));
9365   return AttributeApplied;
9366 }
9367 
9368 bool isParamExpr(size_t N) const override {
9369   return false;
9370 }
9371 
9372 static const ParsedAttrInfoMicroMips Instance;
9373 };
9374 const ParsedAttrInfoMicroMips ParsedAttrInfoMicroMips::Instance;
9375 static constexpr ParsedAttrInfo::Spelling MinSizeSpellings[] = {
9376   {AttributeCommonInfo::AS_GNU, "minsize"},
9377   {AttributeCommonInfo::AS_CXX11, "clang::minsize"},
9378   {AttributeCommonInfo::AS_C23, "clang::minsize"},
9379 };
9380 struct ParsedAttrInfoMinSize final : public ParsedAttrInfo {
9381   constexpr ParsedAttrInfoMinSize() : ParsedAttrInfo(
9382     /*AttrKind=*/ParsedAttr::AT_MinSize,
9383     /*NumArgs=*/0,
9384     /*OptArgs=*/0,
9385     /*NumArgMembers=*/0,
9386     /*HasCustomParsing=*/0,
9387     /*AcceptsExprPack=*/0,
9388     /*IsTargetSpecific=*/0,
9389     /*IsType=*/0,
9390     /*IsStmt=*/0,
9391     /*IsKnownToGCC=*/0,
9392     /*IsSupportedByPragmaAttribute=*/1,
9393     /*Spellings=*/MinSizeSpellings,
9394     /*ArgNames=*/{}) {}
9395 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9396   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
9397     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9398       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
9399     return false;
9400   }
9401   return true;
9402 }
9403 
9404 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9405   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9406     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9407   return false;
9408 }
9409 
9410 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9411   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9412   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
9413 }
9414 
9415 bool isParamExpr(size_t N) const override {
9416   return false;
9417 }
9418 
9419 static const ParsedAttrInfoMinSize Instance;
9420 };
9421 const ParsedAttrInfoMinSize ParsedAttrInfoMinSize::Instance;
9422 static constexpr ParsedAttrInfo::Spelling MinVectorWidthSpellings[] = {
9423   {AttributeCommonInfo::AS_GNU, "min_vector_width"},
9424   {AttributeCommonInfo::AS_CXX11, "clang::min_vector_width"},
9425   {AttributeCommonInfo::AS_C23, "clang::min_vector_width"},
9426 };
9427 static constexpr const char *MinVectorWidthArgNames[] = {
9428 "VectorWidth",};
9429 struct ParsedAttrInfoMinVectorWidth final : public ParsedAttrInfo {
9430   constexpr ParsedAttrInfoMinVectorWidth() : ParsedAttrInfo(
9431     /*AttrKind=*/ParsedAttr::AT_MinVectorWidth,
9432     /*NumArgs=*/1,
9433     /*OptArgs=*/0,
9434     /*NumArgMembers=*/1,
9435     /*HasCustomParsing=*/0,
9436     /*AcceptsExprPack=*/0,
9437     /*IsTargetSpecific=*/0,
9438     /*IsType=*/0,
9439     /*IsStmt=*/0,
9440     /*IsKnownToGCC=*/0,
9441     /*IsSupportedByPragmaAttribute=*/1,
9442     /*Spellings=*/MinVectorWidthSpellings,
9443     /*ArgNames=*/MinVectorWidthArgNames) {}
9444 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9445   if (!isa<FunctionDecl>(D)) {
9446     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9447       << Attr << Attr.isRegularKeywordAttribute() << "functions";
9448     return false;
9449   }
9450   return true;
9451 }
9452 
9453 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9454   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9455     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9456   return false;
9457 }
9458 
9459 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9460   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9461 }
9462 
9463 bool isParamExpr(size_t N) const override {
9464   return false;
9465 }
9466 
9467 static const ParsedAttrInfoMinVectorWidth Instance;
9468 };
9469 const ParsedAttrInfoMinVectorWidth ParsedAttrInfoMinVectorWidth::Instance;
9470 static constexpr ParsedAttrInfo::Spelling Mips16Spellings[] = {
9471   {AttributeCommonInfo::AS_GNU, "mips16"},
9472   {AttributeCommonInfo::AS_CXX11, "gnu::mips16"},
9473   {AttributeCommonInfo::AS_C23, "gnu::mips16"},
9474 };
9475 struct ParsedAttrInfoMips16 final : public ParsedAttrInfo {
9476   constexpr ParsedAttrInfoMips16() : ParsedAttrInfo(
9477     /*AttrKind=*/ParsedAttr::AT_Mips16,
9478     /*NumArgs=*/0,
9479     /*OptArgs=*/0,
9480     /*NumArgMembers=*/0,
9481     /*HasCustomParsing=*/0,
9482     /*AcceptsExprPack=*/0,
9483     /*IsTargetSpecific=*/1,
9484     /*IsType=*/0,
9485     /*IsStmt=*/0,
9486     /*IsKnownToGCC=*/1,
9487     /*IsSupportedByPragmaAttribute=*/1,
9488     /*Spellings=*/Mips16Spellings,
9489     /*ArgNames=*/{}) {}
9490 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9491   if (!isa<FunctionDecl>(D)) {
9492     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9493       << Attr << Attr.isRegularKeywordAttribute() << "functions";
9494     return false;
9495   }
9496   return true;
9497 }
9498 
9499 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9500   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9501     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9502   return false;
9503 }
9504 
9505   using ParsedAttrInfo::diagMutualExclusion;
9506 
9507   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
9508     if (const auto *A = D->getAttr<MipsInterruptAttr>()) {
9509       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
9510       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
9511 return false;
9512     }
9513     if (const auto *A = D->getAttr<MicroMipsAttr>()) {
9514       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
9515       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
9516 return false;
9517     }
9518     return true;
9519   }
9520 
9521 bool existsInTarget(const TargetInfo &Target) const override {
9522   const llvm::Triple &T = Target.getTriple(); (void)T;
9523   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel);
9524 }
9525 
9526 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9527   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9528 }
9529 
9530 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9531   D->addAttr(::new (S.Context) Mips16Attr(S.Context, Attr));
9532   return AttributeApplied;
9533 }
9534 
9535 bool isParamExpr(size_t N) const override {
9536   return false;
9537 }
9538 
9539 static const ParsedAttrInfoMips16 Instance;
9540 };
9541 const ParsedAttrInfoMips16 ParsedAttrInfoMips16::Instance;
9542 static constexpr ParsedAttrInfo::Spelling MipsLongCallSpellings[] = {
9543   {AttributeCommonInfo::AS_GNU, "long_call"},
9544   {AttributeCommonInfo::AS_CXX11, "gnu::long_call"},
9545   {AttributeCommonInfo::AS_C23, "gnu::long_call"},
9546   {AttributeCommonInfo::AS_GNU, "far"},
9547   {AttributeCommonInfo::AS_CXX11, "gnu::far"},
9548   {AttributeCommonInfo::AS_C23, "gnu::far"},
9549 };
9550 struct ParsedAttrInfoMipsLongCall final : public ParsedAttrInfo {
9551   constexpr ParsedAttrInfoMipsLongCall() : ParsedAttrInfo(
9552     /*AttrKind=*/ParsedAttr::AT_MipsLongCall,
9553     /*NumArgs=*/0,
9554     /*OptArgs=*/0,
9555     /*NumArgMembers=*/0,
9556     /*HasCustomParsing=*/0,
9557     /*AcceptsExprPack=*/0,
9558     /*IsTargetSpecific=*/1,
9559     /*IsType=*/0,
9560     /*IsStmt=*/0,
9561     /*IsKnownToGCC=*/1,
9562     /*IsSupportedByPragmaAttribute=*/1,
9563     /*Spellings=*/MipsLongCallSpellings,
9564     /*ArgNames=*/{}) {}
9565 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9566   if (!isa<FunctionDecl>(D)) {
9567     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9568       << Attr << Attr.isRegularKeywordAttribute() << "functions";
9569     return false;
9570   }
9571   return true;
9572 }
9573 
9574 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9575   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9576     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9577   return false;
9578 }
9579 
9580   using ParsedAttrInfo::diagMutualExclusion;
9581 
9582   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
9583     if (const auto *A = D->getAttr<MipsShortCallAttr>()) {
9584       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
9585       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
9586 return false;
9587     }
9588     return true;
9589   }
9590 
9591 bool existsInTarget(const TargetInfo &Target) const override {
9592   const llvm::Triple &T = Target.getTriple(); (void)T;
9593   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::mips64 || T.getArch() == llvm::Triple::mips64el);
9594 }
9595 
9596 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
9597   enum Spelling {
9598     GNU_long_call = 0,
9599     CXX11_gnu_long_call = 1,
9600     C23_gnu_long_call = 2,
9601     GNU_far = 3,
9602     CXX11_gnu_far = 4,
9603     C23_gnu_far = 5,
9604   SpellingNotCalculated = 15
9605 
9606   };
9607 
9608   unsigned Idx = Attr.getAttributeSpellingListIndex();
9609   switch (Idx) {
9610     default: llvm_unreachable("Unknown spelling list index");
9611     case 0: return GNU_long_call;
9612     case 1: return CXX11_gnu_long_call;
9613     case 2: return C23_gnu_long_call;
9614     case 3: return GNU_far;
9615     case 4: return CXX11_gnu_far;
9616     case 5: return C23_gnu_far;
9617   }
9618 }
9619 
9620 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9621   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9622 }
9623 
9624 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9625   D->addAttr(::new (S.Context) MipsLongCallAttr(S.Context, Attr));
9626   return AttributeApplied;
9627 }
9628 
9629 bool isParamExpr(size_t N) const override {
9630   return false;
9631 }
9632 
9633 static const ParsedAttrInfoMipsLongCall Instance;
9634 };
9635 const ParsedAttrInfoMipsLongCall ParsedAttrInfoMipsLongCall::Instance;
9636 static constexpr ParsedAttrInfo::Spelling MipsShortCallSpellings[] = {
9637   {AttributeCommonInfo::AS_GNU, "short_call"},
9638   {AttributeCommonInfo::AS_CXX11, "gnu::short_call"},
9639   {AttributeCommonInfo::AS_C23, "gnu::short_call"},
9640   {AttributeCommonInfo::AS_GNU, "near"},
9641   {AttributeCommonInfo::AS_CXX11, "gnu::near"},
9642   {AttributeCommonInfo::AS_C23, "gnu::near"},
9643 };
9644 struct ParsedAttrInfoMipsShortCall final : public ParsedAttrInfo {
9645   constexpr ParsedAttrInfoMipsShortCall() : ParsedAttrInfo(
9646     /*AttrKind=*/ParsedAttr::AT_MipsShortCall,
9647     /*NumArgs=*/0,
9648     /*OptArgs=*/0,
9649     /*NumArgMembers=*/0,
9650     /*HasCustomParsing=*/0,
9651     /*AcceptsExprPack=*/0,
9652     /*IsTargetSpecific=*/1,
9653     /*IsType=*/0,
9654     /*IsStmt=*/0,
9655     /*IsKnownToGCC=*/1,
9656     /*IsSupportedByPragmaAttribute=*/1,
9657     /*Spellings=*/MipsShortCallSpellings,
9658     /*ArgNames=*/{}) {}
9659 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9660   if (!isa<FunctionDecl>(D)) {
9661     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9662       << Attr << Attr.isRegularKeywordAttribute() << "functions";
9663     return false;
9664   }
9665   return true;
9666 }
9667 
9668 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9669   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9670     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9671   return false;
9672 }
9673 
9674   using ParsedAttrInfo::diagMutualExclusion;
9675 
9676   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
9677     if (const auto *A = D->getAttr<MipsLongCallAttr>()) {
9678       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
9679       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
9680 return false;
9681     }
9682     return true;
9683   }
9684 
9685 bool existsInTarget(const TargetInfo &Target) const override {
9686   const llvm::Triple &T = Target.getTriple(); (void)T;
9687   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel || T.getArch() == llvm::Triple::mips64 || T.getArch() == llvm::Triple::mips64el);
9688 }
9689 
9690 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
9691   enum Spelling {
9692     GNU_short_call = 0,
9693     CXX11_gnu_short_call = 1,
9694     C23_gnu_short_call = 2,
9695     GNU_near = 3,
9696     CXX11_gnu_near = 4,
9697     C23_gnu_near = 5,
9698   SpellingNotCalculated = 15
9699 
9700   };
9701 
9702   unsigned Idx = Attr.getAttributeSpellingListIndex();
9703   switch (Idx) {
9704     default: llvm_unreachable("Unknown spelling list index");
9705     case 0: return GNU_short_call;
9706     case 1: return CXX11_gnu_short_call;
9707     case 2: return C23_gnu_short_call;
9708     case 3: return GNU_near;
9709     case 4: return CXX11_gnu_near;
9710     case 5: return C23_gnu_near;
9711   }
9712 }
9713 
9714 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9715   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
9716 }
9717 
9718 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9719   D->addAttr(::new (S.Context) MipsShortCallAttr(S.Context, Attr));
9720   return AttributeApplied;
9721 }
9722 
9723 bool isParamExpr(size_t N) const override {
9724   return false;
9725 }
9726 
9727 static const ParsedAttrInfoMipsShortCall Instance;
9728 };
9729 const ParsedAttrInfoMipsShortCall ParsedAttrInfoMipsShortCall::Instance;
9730 static constexpr ParsedAttrInfo::Spelling ModeSpellings[] = {
9731   {AttributeCommonInfo::AS_GNU, "mode"},
9732   {AttributeCommonInfo::AS_CXX11, "gnu::mode"},
9733   {AttributeCommonInfo::AS_C23, "gnu::mode"},
9734 };
9735 static constexpr const char *ModeArgNames[] = {
9736 "Mode",};
9737 struct ParsedAttrInfoMode final : public ParsedAttrInfo {
9738   constexpr ParsedAttrInfoMode() : ParsedAttrInfo(
9739     /*AttrKind=*/ParsedAttr::AT_Mode,
9740     /*NumArgs=*/1,
9741     /*OptArgs=*/0,
9742     /*NumArgMembers=*/1,
9743     /*HasCustomParsing=*/0,
9744     /*AcceptsExprPack=*/0,
9745     /*IsTargetSpecific=*/0,
9746     /*IsType=*/0,
9747     /*IsStmt=*/0,
9748     /*IsKnownToGCC=*/1,
9749     /*IsSupportedByPragmaAttribute=*/0,
9750     /*Spellings=*/ModeSpellings,
9751     /*ArgNames=*/ModeArgNames) {}
9752 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9753   if (!isa<VarDecl>(D) && !isa<EnumDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<FieldDecl>(D)) {
9754     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9755       << Attr << Attr.isRegularKeywordAttribute() << "variables, enums, typedefs, and non-static data members";
9756     return false;
9757   }
9758   return true;
9759 }
9760 
9761 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9762   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9763     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9764   return false;
9765 }
9766 
9767 bool isParamExpr(size_t N) const override {
9768   return false;
9769 }
9770 
9771 static const ParsedAttrInfoMode Instance;
9772 };
9773 const ParsedAttrInfoMode ParsedAttrInfoMode::Instance;
9774 static constexpr ParsedAttrInfo::Spelling MustTailSpellings[] = {
9775   {AttributeCommonInfo::AS_GNU, "musttail"},
9776   {AttributeCommonInfo::AS_CXX11, "clang::musttail"},
9777   {AttributeCommonInfo::AS_C23, "clang::musttail"},
9778 };
9779 struct ParsedAttrInfoMustTail final : public ParsedAttrInfo {
9780   constexpr ParsedAttrInfoMustTail() : ParsedAttrInfo(
9781     /*AttrKind=*/ParsedAttr::AT_MustTail,
9782     /*NumArgs=*/0,
9783     /*OptArgs=*/0,
9784     /*NumArgMembers=*/0,
9785     /*HasCustomParsing=*/0,
9786     /*AcceptsExprPack=*/0,
9787     /*IsTargetSpecific=*/0,
9788     /*IsType=*/0,
9789     /*IsStmt=*/1,
9790     /*IsKnownToGCC=*/0,
9791     /*IsSupportedByPragmaAttribute=*/0,
9792     /*Spellings=*/MustTailSpellings,
9793     /*ArgNames=*/{}) {}
9794 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
9795   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
9796     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
9797   return false;
9798 }
9799 
9800 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
9801   if (!isa<ReturnStmt>(St)) {
9802     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9803       << Attr << Attr.isRegularKeywordAttribute() << "return statements";
9804     return false;
9805   }
9806   return true;
9807 }
9808 
9809 bool isParamExpr(size_t N) const override {
9810   return false;
9811 }
9812 
9813 static const ParsedAttrInfoMustTail Instance;
9814 };
9815 const ParsedAttrInfoMustTail ParsedAttrInfoMustTail::Instance;
9816 static constexpr ParsedAttrInfo::Spelling NSConsumedSpellings[] = {
9817   {AttributeCommonInfo::AS_GNU, "ns_consumed"},
9818   {AttributeCommonInfo::AS_CXX11, "clang::ns_consumed"},
9819   {AttributeCommonInfo::AS_C23, "clang::ns_consumed"},
9820 };
9821 struct ParsedAttrInfoNSConsumed final : public ParsedAttrInfo {
9822   constexpr ParsedAttrInfoNSConsumed() : ParsedAttrInfo(
9823     /*AttrKind=*/ParsedAttr::AT_NSConsumed,
9824     /*NumArgs=*/0,
9825     /*OptArgs=*/0,
9826     /*NumArgMembers=*/0,
9827     /*HasCustomParsing=*/0,
9828     /*AcceptsExprPack=*/0,
9829     /*IsTargetSpecific=*/0,
9830     /*IsType=*/0,
9831     /*IsStmt=*/0,
9832     /*IsKnownToGCC=*/0,
9833     /*IsSupportedByPragmaAttribute=*/1,
9834     /*Spellings=*/NSConsumedSpellings,
9835     /*ArgNames=*/{}) {}
9836 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9837   if (!isa<ParmVarDecl>(D)) {
9838     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9839       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
9840     return false;
9841   }
9842   return true;
9843 }
9844 
9845 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9846   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9847     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9848   return false;
9849 }
9850 
9851 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9852   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
9853 }
9854 
9855 bool isParamExpr(size_t N) const override {
9856   return false;
9857 }
9858 
9859 static const ParsedAttrInfoNSConsumed Instance;
9860 };
9861 const ParsedAttrInfoNSConsumed ParsedAttrInfoNSConsumed::Instance;
9862 static constexpr ParsedAttrInfo::Spelling NSConsumesSelfSpellings[] = {
9863   {AttributeCommonInfo::AS_GNU, "ns_consumes_self"},
9864   {AttributeCommonInfo::AS_CXX11, "clang::ns_consumes_self"},
9865   {AttributeCommonInfo::AS_C23, "clang::ns_consumes_self"},
9866 };
9867 struct ParsedAttrInfoNSConsumesSelf final : public ParsedAttrInfo {
9868   constexpr ParsedAttrInfoNSConsumesSelf() : ParsedAttrInfo(
9869     /*AttrKind=*/ParsedAttr::AT_NSConsumesSelf,
9870     /*NumArgs=*/0,
9871     /*OptArgs=*/0,
9872     /*NumArgMembers=*/0,
9873     /*HasCustomParsing=*/0,
9874     /*AcceptsExprPack=*/0,
9875     /*IsTargetSpecific=*/0,
9876     /*IsType=*/0,
9877     /*IsStmt=*/0,
9878     /*IsKnownToGCC=*/0,
9879     /*IsSupportedByPragmaAttribute=*/1,
9880     /*Spellings=*/NSConsumesSelfSpellings,
9881     /*ArgNames=*/{}) {}
9882 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9883   if (!isa<ObjCMethodDecl>(D)) {
9884     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
9885       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods";
9886     return false;
9887   }
9888   return true;
9889 }
9890 
9891 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9892   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9893     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9894   return false;
9895 }
9896 
9897 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9898   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
9899 }
9900 
9901 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
9902   D->addAttr(::new (S.Context) NSConsumesSelfAttr(S.Context, Attr));
9903   return AttributeApplied;
9904 }
9905 
9906 bool isParamExpr(size_t N) const override {
9907   return false;
9908 }
9909 
9910 static const ParsedAttrInfoNSConsumesSelf Instance;
9911 };
9912 const ParsedAttrInfoNSConsumesSelf ParsedAttrInfoNSConsumesSelf::Instance;
9913 static constexpr ParsedAttrInfo::Spelling NSErrorDomainSpellings[] = {
9914   {AttributeCommonInfo::AS_GNU, "ns_error_domain"},
9915 };
9916 static constexpr const char *NSErrorDomainArgNames[] = {
9917 "ErrorDomain",};
9918 struct ParsedAttrInfoNSErrorDomain final : public ParsedAttrInfo {
9919   constexpr ParsedAttrInfoNSErrorDomain() : ParsedAttrInfo(
9920     /*AttrKind=*/ParsedAttr::AT_NSErrorDomain,
9921     /*NumArgs=*/1,
9922     /*OptArgs=*/0,
9923     /*NumArgMembers=*/1,
9924     /*HasCustomParsing=*/0,
9925     /*AcceptsExprPack=*/0,
9926     /*IsTargetSpecific=*/0,
9927     /*IsType=*/0,
9928     /*IsStmt=*/0,
9929     /*IsKnownToGCC=*/0,
9930     /*IsSupportedByPragmaAttribute=*/1,
9931     /*Spellings=*/NSErrorDomainSpellings,
9932     /*ArgNames=*/NSErrorDomainArgNames) {}
9933 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
9934   if (!isa<EnumDecl>(D)) {
9935     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
9936       << Attr << Attr.isRegularKeywordAttribute() << "enums";
9937     return false;
9938   }
9939   return true;
9940 }
9941 
9942 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
9943   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
9944     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
9945   return false;
9946 }
9947 
9948 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
9949   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
9950 }
9951 
9952 bool isParamExpr(size_t N) const override {
9953   return false;
9954 }
9955 
9956 static const ParsedAttrInfoNSErrorDomain Instance;
9957 };
9958 const ParsedAttrInfoNSErrorDomain ParsedAttrInfoNSErrorDomain::Instance;
9959 static constexpr ParsedAttrInfo::Spelling NSReturnsAutoreleasedSpellings[] = {
9960   {AttributeCommonInfo::AS_GNU, "ns_returns_autoreleased"},
9961   {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_autoreleased"},
9962   {AttributeCommonInfo::AS_C23, "clang::ns_returns_autoreleased"},
9963 };
9964 struct ParsedAttrInfoNSReturnsAutoreleased final : public ParsedAttrInfo {
9965   constexpr ParsedAttrInfoNSReturnsAutoreleased() : ParsedAttrInfo(
9966     /*AttrKind=*/ParsedAttr::AT_NSReturnsAutoreleased,
9967     /*NumArgs=*/0,
9968     /*OptArgs=*/0,
9969     /*NumArgMembers=*/0,
9970     /*HasCustomParsing=*/0,
9971     /*AcceptsExprPack=*/0,
9972     /*IsTargetSpecific=*/0,
9973     /*IsType=*/0,
9974     /*IsStmt=*/0,
9975     /*IsKnownToGCC=*/0,
9976     /*IsSupportedByPragmaAttribute=*/0,
9977     /*Spellings=*/NSReturnsAutoreleasedSpellings,
9978     /*ArgNames=*/{}) {}
9979 bool isParamExpr(size_t N) const override {
9980   return false;
9981 }
9982 
9983 static const ParsedAttrInfoNSReturnsAutoreleased Instance;
9984 };
9985 const ParsedAttrInfoNSReturnsAutoreleased ParsedAttrInfoNSReturnsAutoreleased::Instance;
9986 static constexpr ParsedAttrInfo::Spelling NSReturnsNotRetainedSpellings[] = {
9987   {AttributeCommonInfo::AS_GNU, "ns_returns_not_retained"},
9988   {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_not_retained"},
9989   {AttributeCommonInfo::AS_C23, "clang::ns_returns_not_retained"},
9990 };
9991 struct ParsedAttrInfoNSReturnsNotRetained final : public ParsedAttrInfo {
9992   constexpr ParsedAttrInfoNSReturnsNotRetained() : ParsedAttrInfo(
9993     /*AttrKind=*/ParsedAttr::AT_NSReturnsNotRetained,
9994     /*NumArgs=*/0,
9995     /*OptArgs=*/0,
9996     /*NumArgMembers=*/0,
9997     /*HasCustomParsing=*/0,
9998     /*AcceptsExprPack=*/0,
9999     /*IsTargetSpecific=*/0,
10000     /*IsType=*/0,
10001     /*IsStmt=*/0,
10002     /*IsKnownToGCC=*/0,
10003     /*IsSupportedByPragmaAttribute=*/0,
10004     /*Spellings=*/NSReturnsNotRetainedSpellings,
10005     /*ArgNames=*/{}) {}
10006 bool isParamExpr(size_t N) const override {
10007   return false;
10008 }
10009 
10010 static const ParsedAttrInfoNSReturnsNotRetained Instance;
10011 };
10012 const ParsedAttrInfoNSReturnsNotRetained ParsedAttrInfoNSReturnsNotRetained::Instance;
10013 static constexpr ParsedAttrInfo::Spelling NSReturnsRetainedSpellings[] = {
10014   {AttributeCommonInfo::AS_GNU, "ns_returns_retained"},
10015   {AttributeCommonInfo::AS_CXX11, "clang::ns_returns_retained"},
10016   {AttributeCommonInfo::AS_C23, "clang::ns_returns_retained"},
10017 };
10018 struct ParsedAttrInfoNSReturnsRetained final : public ParsedAttrInfo {
10019   constexpr ParsedAttrInfoNSReturnsRetained() : ParsedAttrInfo(
10020     /*AttrKind=*/ParsedAttr::AT_NSReturnsRetained,
10021     /*NumArgs=*/0,
10022     /*OptArgs=*/0,
10023     /*NumArgMembers=*/0,
10024     /*HasCustomParsing=*/0,
10025     /*AcceptsExprPack=*/0,
10026     /*IsTargetSpecific=*/0,
10027     /*IsType=*/1,
10028     /*IsStmt=*/0,
10029     /*IsKnownToGCC=*/0,
10030     /*IsSupportedByPragmaAttribute=*/0,
10031     /*Spellings=*/NSReturnsRetainedSpellings,
10032     /*ArgNames=*/{}) {}
10033 bool isParamExpr(size_t N) const override {
10034   return false;
10035 }
10036 
10037 static const ParsedAttrInfoNSReturnsRetained Instance;
10038 };
10039 const ParsedAttrInfoNSReturnsRetained ParsedAttrInfoNSReturnsRetained::Instance;
10040 static constexpr ParsedAttrInfo::Spelling NVPTXKernelSpellings[] = {
10041   {AttributeCommonInfo::AS_GNU, "nvptx_kernel"},
10042   {AttributeCommonInfo::AS_CXX11, "clang::nvptx_kernel"},
10043   {AttributeCommonInfo::AS_C23, "clang::nvptx_kernel"},
10044 };
10045 struct ParsedAttrInfoNVPTXKernel final : public ParsedAttrInfo {
10046   constexpr ParsedAttrInfoNVPTXKernel() : ParsedAttrInfo(
10047     /*AttrKind=*/ParsedAttr::AT_NVPTXKernel,
10048     /*NumArgs=*/0,
10049     /*OptArgs=*/0,
10050     /*NumArgMembers=*/0,
10051     /*HasCustomParsing=*/0,
10052     /*AcceptsExprPack=*/0,
10053     /*IsTargetSpecific=*/1,
10054     /*IsType=*/0,
10055     /*IsStmt=*/0,
10056     /*IsKnownToGCC=*/0,
10057     /*IsSupportedByPragmaAttribute=*/1,
10058     /*Spellings=*/NVPTXKernelSpellings,
10059     /*ArgNames=*/{}) {}
10060 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10061   if (!isa<FunctionDecl>(D)) {
10062     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10063       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10064     return false;
10065   }
10066   return true;
10067 }
10068 
10069 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10070   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10071     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10072   return false;
10073 }
10074 
10075 bool existsInTarget(const TargetInfo &Target) const override {
10076   const llvm::Triple &T = Target.getTriple(); (void)T;
10077   return true && (T.getArch() == llvm::Triple::nvptx || T.getArch() == llvm::Triple::nvptx64);
10078 }
10079 
10080 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10081   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10082 }
10083 
10084 bool isParamExpr(size_t N) const override {
10085   return false;
10086 }
10087 
10088 static const ParsedAttrInfoNVPTXKernel Instance;
10089 };
10090 const ParsedAttrInfoNVPTXKernel ParsedAttrInfoNVPTXKernel::Instance;
10091 static constexpr ParsedAttrInfo::Spelling NakedSpellings[] = {
10092   {AttributeCommonInfo::AS_GNU, "naked"},
10093   {AttributeCommonInfo::AS_CXX11, "gnu::naked"},
10094   {AttributeCommonInfo::AS_C23, "gnu::naked"},
10095   {AttributeCommonInfo::AS_Declspec, "naked"},
10096 };
10097 struct ParsedAttrInfoNaked final : public ParsedAttrInfo {
10098   constexpr ParsedAttrInfoNaked() : ParsedAttrInfo(
10099     /*AttrKind=*/ParsedAttr::AT_Naked,
10100     /*NumArgs=*/0,
10101     /*OptArgs=*/0,
10102     /*NumArgMembers=*/0,
10103     /*HasCustomParsing=*/0,
10104     /*AcceptsExprPack=*/0,
10105     /*IsTargetSpecific=*/0,
10106     /*IsType=*/0,
10107     /*IsStmt=*/0,
10108     /*IsKnownToGCC=*/1,
10109     /*IsSupportedByPragmaAttribute=*/1,
10110     /*Spellings=*/NakedSpellings,
10111     /*ArgNames=*/{}) {}
10112 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10113   if (!isa<FunctionDecl>(D)) {
10114     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10115       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10116     return false;
10117   }
10118   return true;
10119 }
10120 
10121 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10122   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10123     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10124   return false;
10125 }
10126 
10127   using ParsedAttrInfo::diagMutualExclusion;
10128 
10129   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
10130     if (const auto *A = D->getAttr<DisableTailCallsAttr>()) {
10131       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
10132       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
10133 return false;
10134     }
10135     return true;
10136   }
10137 
10138 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10139   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10140 }
10141 
10142 bool isParamExpr(size_t N) const override {
10143   return false;
10144 }
10145 
10146 static const ParsedAttrInfoNaked Instance;
10147 };
10148 const ParsedAttrInfoNaked ParsedAttrInfoNaked::Instance;
10149 static constexpr ParsedAttrInfo::Spelling NeonPolyVectorTypeSpellings[] = {
10150   {AttributeCommonInfo::AS_GNU, "neon_polyvector_type"},
10151   {AttributeCommonInfo::AS_CXX11, "clang::neon_polyvector_type"},
10152   {AttributeCommonInfo::AS_C23, "clang::neon_polyvector_type"},
10153 };
10154 static constexpr const char *NeonPolyVectorTypeArgNames[] = {
10155 "NumElements",};
10156 struct ParsedAttrInfoNeonPolyVectorType final : public ParsedAttrInfo {
10157   constexpr ParsedAttrInfoNeonPolyVectorType() : ParsedAttrInfo(
10158     /*AttrKind=*/ParsedAttr::AT_NeonPolyVectorType,
10159     /*NumArgs=*/1,
10160     /*OptArgs=*/0,
10161     /*NumArgMembers=*/1,
10162     /*HasCustomParsing=*/0,
10163     /*AcceptsExprPack=*/0,
10164     /*IsTargetSpecific=*/0,
10165     /*IsType=*/1,
10166     /*IsStmt=*/0,
10167     /*IsKnownToGCC=*/0,
10168     /*IsSupportedByPragmaAttribute=*/0,
10169     /*Spellings=*/NeonPolyVectorTypeSpellings,
10170     /*ArgNames=*/NeonPolyVectorTypeArgNames) {}
10171 bool isParamExpr(size_t N) const override {
10172   return false;
10173 }
10174 
10175 static const ParsedAttrInfoNeonPolyVectorType Instance;
10176 };
10177 const ParsedAttrInfoNeonPolyVectorType ParsedAttrInfoNeonPolyVectorType::Instance;
10178 static constexpr ParsedAttrInfo::Spelling NeonVectorTypeSpellings[] = {
10179   {AttributeCommonInfo::AS_GNU, "neon_vector_type"},
10180   {AttributeCommonInfo::AS_CXX11, "clang::neon_vector_type"},
10181   {AttributeCommonInfo::AS_C23, "clang::neon_vector_type"},
10182 };
10183 static constexpr const char *NeonVectorTypeArgNames[] = {
10184 "NumElements",};
10185 struct ParsedAttrInfoNeonVectorType final : public ParsedAttrInfo {
10186   constexpr ParsedAttrInfoNeonVectorType() : ParsedAttrInfo(
10187     /*AttrKind=*/ParsedAttr::AT_NeonVectorType,
10188     /*NumArgs=*/1,
10189     /*OptArgs=*/0,
10190     /*NumArgMembers=*/1,
10191     /*HasCustomParsing=*/0,
10192     /*AcceptsExprPack=*/0,
10193     /*IsTargetSpecific=*/0,
10194     /*IsType=*/1,
10195     /*IsStmt=*/0,
10196     /*IsKnownToGCC=*/0,
10197     /*IsSupportedByPragmaAttribute=*/0,
10198     /*Spellings=*/NeonVectorTypeSpellings,
10199     /*ArgNames=*/NeonVectorTypeArgNames) {}
10200 bool isParamExpr(size_t N) const override {
10201   return false;
10202 }
10203 
10204 static const ParsedAttrInfoNeonVectorType Instance;
10205 };
10206 const ParsedAttrInfoNeonVectorType ParsedAttrInfoNeonVectorType::Instance;
10207 static constexpr ParsedAttrInfo::Spelling NoAliasSpellings[] = {
10208   {AttributeCommonInfo::AS_Declspec, "noalias"},
10209 };
10210 struct ParsedAttrInfoNoAlias final : public ParsedAttrInfo {
10211   constexpr ParsedAttrInfoNoAlias() : ParsedAttrInfo(
10212     /*AttrKind=*/ParsedAttr::AT_NoAlias,
10213     /*NumArgs=*/0,
10214     /*OptArgs=*/0,
10215     /*NumArgMembers=*/0,
10216     /*HasCustomParsing=*/0,
10217     /*AcceptsExprPack=*/0,
10218     /*IsTargetSpecific=*/0,
10219     /*IsType=*/0,
10220     /*IsStmt=*/0,
10221     /*IsKnownToGCC=*/0,
10222     /*IsSupportedByPragmaAttribute=*/0,
10223     /*Spellings=*/NoAliasSpellings,
10224     /*ArgNames=*/{}) {}
10225 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10226   if (!isa<FunctionDecl>(D)) {
10227     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10228       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10229     return false;
10230   }
10231   return true;
10232 }
10233 
10234 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10235   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10236     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10237   return false;
10238 }
10239 
10240 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10241   D->addAttr(::new (S.Context) NoAliasAttr(S.Context, Attr));
10242   return AttributeApplied;
10243 }
10244 
10245 bool isParamExpr(size_t N) const override {
10246   return false;
10247 }
10248 
10249 static const ParsedAttrInfoNoAlias Instance;
10250 };
10251 const ParsedAttrInfoNoAlias ParsedAttrInfoNoAlias::Instance;
10252 static constexpr ParsedAttrInfo::Spelling NoBuiltinSpellings[] = {
10253   {AttributeCommonInfo::AS_GNU, "no_builtin"},
10254   {AttributeCommonInfo::AS_CXX11, "clang::no_builtin"},
10255   {AttributeCommonInfo::AS_C23, "clang::no_builtin"},
10256 };
10257 static constexpr const char *NoBuiltinArgNames[] = {
10258 "BuiltinNames...",};
10259 struct ParsedAttrInfoNoBuiltin final : public ParsedAttrInfo {
10260   constexpr ParsedAttrInfoNoBuiltin() : ParsedAttrInfo(
10261     /*AttrKind=*/ParsedAttr::AT_NoBuiltin,
10262     /*NumArgs=*/0,
10263     /*OptArgs=*/15,
10264     /*NumArgMembers=*/1,
10265     /*HasCustomParsing=*/0,
10266     /*AcceptsExprPack=*/0,
10267     /*IsTargetSpecific=*/0,
10268     /*IsType=*/0,
10269     /*IsStmt=*/0,
10270     /*IsKnownToGCC=*/0,
10271     /*IsSupportedByPragmaAttribute=*/1,
10272     /*Spellings=*/NoBuiltinSpellings,
10273     /*ArgNames=*/NoBuiltinArgNames) {}
10274 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10275   if (!isa<FunctionDecl>(D)) {
10276     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10277       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10278     return false;
10279   }
10280   return true;
10281 }
10282 
10283 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10284   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10285     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10286   return false;
10287 }
10288 
10289 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10290   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10291 }
10292 
10293 bool isParamExpr(size_t N) const override {
10294   return false;
10295 }
10296 
10297 static const ParsedAttrInfoNoBuiltin Instance;
10298 };
10299 const ParsedAttrInfoNoBuiltin ParsedAttrInfoNoBuiltin::Instance;
10300 static constexpr ParsedAttrInfo::Spelling NoCommonSpellings[] = {
10301   {AttributeCommonInfo::AS_GNU, "nocommon"},
10302   {AttributeCommonInfo::AS_CXX11, "gnu::nocommon"},
10303   {AttributeCommonInfo::AS_C23, "gnu::nocommon"},
10304 };
10305 struct ParsedAttrInfoNoCommon final : public ParsedAttrInfo {
10306   constexpr ParsedAttrInfoNoCommon() : ParsedAttrInfo(
10307     /*AttrKind=*/ParsedAttr::AT_NoCommon,
10308     /*NumArgs=*/0,
10309     /*OptArgs=*/0,
10310     /*NumArgMembers=*/0,
10311     /*HasCustomParsing=*/0,
10312     /*AcceptsExprPack=*/0,
10313     /*IsTargetSpecific=*/0,
10314     /*IsType=*/0,
10315     /*IsStmt=*/0,
10316     /*IsKnownToGCC=*/1,
10317     /*IsSupportedByPragmaAttribute=*/1,
10318     /*Spellings=*/NoCommonSpellings,
10319     /*ArgNames=*/{}) {}
10320 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10321   if (!isa<VarDecl>(D)) {
10322     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10323       << Attr << Attr.isRegularKeywordAttribute() << "variables";
10324     return false;
10325   }
10326   return true;
10327 }
10328 
10329 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10330   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10331     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10332   return false;
10333 }
10334 
10335 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10336   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
10337 }
10338 
10339 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10340   D->addAttr(::new (S.Context) NoCommonAttr(S.Context, Attr));
10341   return AttributeApplied;
10342 }
10343 
10344 bool isParamExpr(size_t N) const override {
10345   return false;
10346 }
10347 
10348 static const ParsedAttrInfoNoCommon Instance;
10349 };
10350 const ParsedAttrInfoNoCommon ParsedAttrInfoNoCommon::Instance;
10351 static constexpr ParsedAttrInfo::Spelling NoConvergentSpellings[] = {
10352   {AttributeCommonInfo::AS_GNU, "noconvergent"},
10353   {AttributeCommonInfo::AS_CXX11, "clang::noconvergent"},
10354   {AttributeCommonInfo::AS_C23, "clang::noconvergent"},
10355   {AttributeCommonInfo::AS_Declspec, "noconvergent"},
10356 };
10357 struct ParsedAttrInfoNoConvergent final : public ParsedAttrInfo {
10358   constexpr ParsedAttrInfoNoConvergent() : ParsedAttrInfo(
10359     /*AttrKind=*/ParsedAttr::AT_NoConvergent,
10360     /*NumArgs=*/0,
10361     /*OptArgs=*/0,
10362     /*NumArgMembers=*/0,
10363     /*HasCustomParsing=*/0,
10364     /*AcceptsExprPack=*/0,
10365     /*IsTargetSpecific=*/0,
10366     /*IsType=*/0,
10367     /*IsStmt=*/0,
10368     /*IsKnownToGCC=*/0,
10369     /*IsSupportedByPragmaAttribute=*/1,
10370     /*Spellings=*/NoConvergentSpellings,
10371     /*ArgNames=*/{}) {}
10372 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10373   if (!isa<FunctionDecl>(D)) {
10374     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10375       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
10376     return false;
10377   }
10378   return true;
10379 }
10380 
10381 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
10382   if (!isa<Stmt>(St)) {
10383     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10384       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
10385     return false;
10386   }
10387   return true;
10388 }
10389 
10390   using ParsedAttrInfo::diagMutualExclusion;
10391 
10392   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
10393     if (const auto *A = D->getAttr<ConvergentAttr>()) {
10394       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
10395       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
10396 return false;
10397     }
10398     return true;
10399   }
10400 
10401 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
10402   return LangOpts.CUDA;
10403 }
10404 
10405 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10406   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10407 }
10408 
10409 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10410   D->addAttr(::new (S.Context) NoConvergentAttr(S.Context, Attr));
10411   return AttributeApplied;
10412 }
10413 
10414 bool isParamExpr(size_t N) const override {
10415   return false;
10416 }
10417 
10418 static const ParsedAttrInfoNoConvergent Instance;
10419 };
10420 const ParsedAttrInfoNoConvergent ParsedAttrInfoNoConvergent::Instance;
10421 static constexpr ParsedAttrInfo::Spelling NoDebugSpellings[] = {
10422   {AttributeCommonInfo::AS_GNU, "nodebug"},
10423   {AttributeCommonInfo::AS_CXX11, "gnu::nodebug"},
10424   {AttributeCommonInfo::AS_C23, "gnu::nodebug"},
10425 };
10426 struct ParsedAttrInfoNoDebug final : public ParsedAttrInfo {
10427   constexpr ParsedAttrInfoNoDebug() : ParsedAttrInfo(
10428     /*AttrKind=*/ParsedAttr::AT_NoDebug,
10429     /*NumArgs=*/0,
10430     /*OptArgs=*/0,
10431     /*NumArgMembers=*/0,
10432     /*HasCustomParsing=*/0,
10433     /*AcceptsExprPack=*/0,
10434     /*IsTargetSpecific=*/0,
10435     /*IsType=*/0,
10436     /*IsStmt=*/0,
10437     /*IsKnownToGCC=*/1,
10438     /*IsSupportedByPragmaAttribute=*/1,
10439     /*Spellings=*/NoDebugSpellings,
10440     /*ArgNames=*/{}) {}
10441 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10442   if (!isa<TypedefNameDecl>(D) && !isFunctionLike(D) && !isa<ObjCMethodDecl>(D) && !isNonParmVar(D)) {
10443     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10444       << Attr << Attr.isRegularKeywordAttribute() << "typedefs, functions, function pointers, Objective-C methods, and variables";
10445     return false;
10446   }
10447   return true;
10448 }
10449 
10450 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10451   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10452     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10453   return false;
10454 }
10455 
10456 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10457   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
10458   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
10459   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
10460   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_not_is_parameter, /*IsSupported=*/true));
10461 }
10462 
10463 bool isParamExpr(size_t N) const override {
10464   return false;
10465 }
10466 
10467 static const ParsedAttrInfoNoDebug Instance;
10468 };
10469 const ParsedAttrInfoNoDebug ParsedAttrInfoNoDebug::Instance;
10470 static constexpr ParsedAttrInfo::Spelling NoDerefSpellings[] = {
10471   {AttributeCommonInfo::AS_GNU, "noderef"},
10472   {AttributeCommonInfo::AS_CXX11, "clang::noderef"},
10473   {AttributeCommonInfo::AS_C23, "clang::noderef"},
10474 };
10475 struct ParsedAttrInfoNoDeref final : public ParsedAttrInfo {
10476   constexpr ParsedAttrInfoNoDeref() : ParsedAttrInfo(
10477     /*AttrKind=*/ParsedAttr::AT_NoDeref,
10478     /*NumArgs=*/0,
10479     /*OptArgs=*/0,
10480     /*NumArgMembers=*/0,
10481     /*HasCustomParsing=*/0,
10482     /*AcceptsExprPack=*/0,
10483     /*IsTargetSpecific=*/0,
10484     /*IsType=*/1,
10485     /*IsStmt=*/0,
10486     /*IsKnownToGCC=*/0,
10487     /*IsSupportedByPragmaAttribute=*/0,
10488     /*Spellings=*/NoDerefSpellings,
10489     /*ArgNames=*/{}) {}
10490 bool isParamExpr(size_t N) const override {
10491   return false;
10492 }
10493 
10494 static const ParsedAttrInfoNoDeref Instance;
10495 };
10496 const ParsedAttrInfoNoDeref ParsedAttrInfoNoDeref::Instance;
10497 static constexpr ParsedAttrInfo::Spelling NoDestroySpellings[] = {
10498   {AttributeCommonInfo::AS_GNU, "no_destroy"},
10499   {AttributeCommonInfo::AS_CXX11, "clang::no_destroy"},
10500 };
10501 struct ParsedAttrInfoNoDestroy final : public ParsedAttrInfo {
10502   constexpr ParsedAttrInfoNoDestroy() : ParsedAttrInfo(
10503     /*AttrKind=*/ParsedAttr::AT_NoDestroy,
10504     /*NumArgs=*/0,
10505     /*OptArgs=*/0,
10506     /*NumArgMembers=*/0,
10507     /*HasCustomParsing=*/0,
10508     /*AcceptsExprPack=*/0,
10509     /*IsTargetSpecific=*/0,
10510     /*IsType=*/0,
10511     /*IsStmt=*/0,
10512     /*IsKnownToGCC=*/0,
10513     /*IsSupportedByPragmaAttribute=*/1,
10514     /*Spellings=*/NoDestroySpellings,
10515     /*ArgNames=*/{}) {}
10516 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10517   if (!isa<VarDecl>(D)) {
10518     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10519       << Attr << Attr.isRegularKeywordAttribute() << "variables";
10520     return false;
10521   }
10522   return true;
10523 }
10524 
10525 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10526   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10527     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10528   return false;
10529 }
10530 
10531   using ParsedAttrInfo::diagMutualExclusion;
10532 
10533   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
10534     if (const auto *A = D->getAttr<AlwaysDestroyAttr>()) {
10535       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
10536       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
10537 return false;
10538     }
10539     return true;
10540   }
10541 
10542 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10543   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
10544 }
10545 
10546 bool isParamExpr(size_t N) const override {
10547   return false;
10548 }
10549 
10550 static const ParsedAttrInfoNoDestroy Instance;
10551 };
10552 const ParsedAttrInfoNoDestroy ParsedAttrInfoNoDestroy::Instance;
10553 static constexpr ParsedAttrInfo::Spelling NoDuplicateSpellings[] = {
10554   {AttributeCommonInfo::AS_GNU, "noduplicate"},
10555   {AttributeCommonInfo::AS_CXX11, "clang::noduplicate"},
10556   {AttributeCommonInfo::AS_C23, "clang::noduplicate"},
10557 };
10558 struct ParsedAttrInfoNoDuplicate final : public ParsedAttrInfo {
10559   constexpr ParsedAttrInfoNoDuplicate() : ParsedAttrInfo(
10560     /*AttrKind=*/ParsedAttr::AT_NoDuplicate,
10561     /*NumArgs=*/0,
10562     /*OptArgs=*/0,
10563     /*NumArgMembers=*/0,
10564     /*HasCustomParsing=*/0,
10565     /*AcceptsExprPack=*/0,
10566     /*IsTargetSpecific=*/0,
10567     /*IsType=*/0,
10568     /*IsStmt=*/0,
10569     /*IsKnownToGCC=*/0,
10570     /*IsSupportedByPragmaAttribute=*/1,
10571     /*Spellings=*/NoDuplicateSpellings,
10572     /*ArgNames=*/{}) {}
10573 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10574   if (!isa<FunctionDecl>(D)) {
10575     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10576       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10577     return false;
10578   }
10579   return true;
10580 }
10581 
10582 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10583   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10584     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10585   return false;
10586 }
10587 
10588 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10589   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10590 }
10591 
10592 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10593   D->addAttr(::new (S.Context) NoDuplicateAttr(S.Context, Attr));
10594   return AttributeApplied;
10595 }
10596 
10597 bool isParamExpr(size_t N) const override {
10598   return false;
10599 }
10600 
10601 static const ParsedAttrInfoNoDuplicate Instance;
10602 };
10603 const ParsedAttrInfoNoDuplicate ParsedAttrInfoNoDuplicate::Instance;
10604 static constexpr ParsedAttrInfo::Spelling NoEscapeSpellings[] = {
10605   {AttributeCommonInfo::AS_GNU, "noescape"},
10606   {AttributeCommonInfo::AS_CXX11, "clang::noescape"},
10607   {AttributeCommonInfo::AS_C23, "clang::noescape"},
10608 };
10609 struct ParsedAttrInfoNoEscape final : public ParsedAttrInfo {
10610   constexpr ParsedAttrInfoNoEscape() : ParsedAttrInfo(
10611     /*AttrKind=*/ParsedAttr::AT_NoEscape,
10612     /*NumArgs=*/0,
10613     /*OptArgs=*/0,
10614     /*NumArgMembers=*/0,
10615     /*HasCustomParsing=*/0,
10616     /*AcceptsExprPack=*/0,
10617     /*IsTargetSpecific=*/0,
10618     /*IsType=*/0,
10619     /*IsStmt=*/0,
10620     /*IsKnownToGCC=*/0,
10621     /*IsSupportedByPragmaAttribute=*/1,
10622     /*Spellings=*/NoEscapeSpellings,
10623     /*ArgNames=*/{}) {}
10624 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10625   if (!isa<ParmVarDecl>(D)) {
10626     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10627       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
10628     return false;
10629   }
10630   return true;
10631 }
10632 
10633 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10634   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10635     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10636   return false;
10637 }
10638 
10639 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10640   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
10641 }
10642 
10643 bool isParamExpr(size_t N) const override {
10644   return false;
10645 }
10646 
10647 static const ParsedAttrInfoNoEscape Instance;
10648 };
10649 const ParsedAttrInfoNoEscape ParsedAttrInfoNoEscape::Instance;
10650 static constexpr ParsedAttrInfo::Spelling NoInlineSpellings[] = {
10651   {AttributeCommonInfo::AS_Keyword, "__noinline__"},
10652   {AttributeCommonInfo::AS_GNU, "noinline"},
10653   {AttributeCommonInfo::AS_CXX11, "gnu::noinline"},
10654   {AttributeCommonInfo::AS_C23, "gnu::noinline"},
10655   {AttributeCommonInfo::AS_CXX11, "clang::noinline"},
10656   {AttributeCommonInfo::AS_C23, "clang::noinline"},
10657   {AttributeCommonInfo::AS_CXX11, "msvc::noinline"},
10658   {AttributeCommonInfo::AS_C23, "msvc::noinline"},
10659   {AttributeCommonInfo::AS_Declspec, "noinline"},
10660 };
10661 struct ParsedAttrInfoNoInline final : public ParsedAttrInfo {
10662   constexpr ParsedAttrInfoNoInline() : ParsedAttrInfo(
10663     /*AttrKind=*/ParsedAttr::AT_NoInline,
10664     /*NumArgs=*/0,
10665     /*OptArgs=*/0,
10666     /*NumArgMembers=*/0,
10667     /*HasCustomParsing=*/0,
10668     /*AcceptsExprPack=*/0,
10669     /*IsTargetSpecific=*/0,
10670     /*IsType=*/0,
10671     /*IsStmt=*/1,
10672     /*IsKnownToGCC=*/1,
10673     /*IsSupportedByPragmaAttribute=*/1,
10674     /*Spellings=*/NoInlineSpellings,
10675     /*ArgNames=*/{}) {}
10676 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10677   if (!isa<FunctionDecl>(D)) {
10678     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10679       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
10680     return false;
10681   }
10682   return true;
10683 }
10684 
10685 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
10686   if (!isa<Stmt>(St)) {
10687     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10688       << Attr << Attr.isRegularKeywordAttribute() << "functions and statements";
10689     return false;
10690   }
10691   return true;
10692 }
10693 
10694 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10695   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10696 }
10697 
10698 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10699   D->addAttr(::new (S.Context) NoInlineAttr(S.Context, Attr));
10700   return AttributeApplied;
10701 }
10702 
10703 bool isParamExpr(size_t N) const override {
10704   return false;
10705 }
10706 
10707 static const ParsedAttrInfoNoInline Instance;
10708 };
10709 const ParsedAttrInfoNoInline ParsedAttrInfoNoInline::Instance;
10710 static constexpr ParsedAttrInfo::Spelling NoInstrumentFunctionSpellings[] = {
10711   {AttributeCommonInfo::AS_GNU, "no_instrument_function"},
10712   {AttributeCommonInfo::AS_CXX11, "gnu::no_instrument_function"},
10713   {AttributeCommonInfo::AS_C23, "gnu::no_instrument_function"},
10714 };
10715 struct ParsedAttrInfoNoInstrumentFunction final : public ParsedAttrInfo {
10716   constexpr ParsedAttrInfoNoInstrumentFunction() : ParsedAttrInfo(
10717     /*AttrKind=*/ParsedAttr::AT_NoInstrumentFunction,
10718     /*NumArgs=*/0,
10719     /*OptArgs=*/0,
10720     /*NumArgMembers=*/0,
10721     /*HasCustomParsing=*/0,
10722     /*AcceptsExprPack=*/0,
10723     /*IsTargetSpecific=*/0,
10724     /*IsType=*/0,
10725     /*IsStmt=*/0,
10726     /*IsKnownToGCC=*/1,
10727     /*IsSupportedByPragmaAttribute=*/1,
10728     /*Spellings=*/NoInstrumentFunctionSpellings,
10729     /*ArgNames=*/{}) {}
10730 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10731   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
10732     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10733       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
10734     return false;
10735   }
10736   return true;
10737 }
10738 
10739 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10740   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10741     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10742   return false;
10743 }
10744 
10745 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10746   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10747   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
10748 }
10749 
10750 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10751   D->addAttr(::new (S.Context) NoInstrumentFunctionAttr(S.Context, Attr));
10752   return AttributeApplied;
10753 }
10754 
10755 bool isParamExpr(size_t N) const override {
10756   return false;
10757 }
10758 
10759 static const ParsedAttrInfoNoInstrumentFunction Instance;
10760 };
10761 const ParsedAttrInfoNoInstrumentFunction ParsedAttrInfoNoInstrumentFunction::Instance;
10762 static constexpr ParsedAttrInfo::Spelling NoMergeSpellings[] = {
10763   {AttributeCommonInfo::AS_GNU, "nomerge"},
10764   {AttributeCommonInfo::AS_CXX11, "clang::nomerge"},
10765   {AttributeCommonInfo::AS_C23, "clang::nomerge"},
10766 };
10767 struct ParsedAttrInfoNoMerge final : public ParsedAttrInfo {
10768   constexpr ParsedAttrInfoNoMerge() : ParsedAttrInfo(
10769     /*AttrKind=*/ParsedAttr::AT_NoMerge,
10770     /*NumArgs=*/0,
10771     /*OptArgs=*/0,
10772     /*NumArgMembers=*/0,
10773     /*HasCustomParsing=*/0,
10774     /*AcceptsExprPack=*/0,
10775     /*IsTargetSpecific=*/0,
10776     /*IsType=*/0,
10777     /*IsStmt=*/1,
10778     /*IsKnownToGCC=*/0,
10779     /*IsSupportedByPragmaAttribute=*/1,
10780     /*Spellings=*/NoMergeSpellings,
10781     /*ArgNames=*/{}) {}
10782 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10783   if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D)) {
10784     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
10785       << Attr << Attr.isRegularKeywordAttribute() << "functions, statements and variables";
10786     return false;
10787   }
10788   return true;
10789 }
10790 
10791 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
10792   if (!isa<Stmt>(St)) {
10793     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
10794       << Attr << Attr.isRegularKeywordAttribute() << "functions, statements and variables";
10795     return false;
10796   }
10797   return true;
10798 }
10799 
10800 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10801   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10802   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
10803 }
10804 
10805 bool isParamExpr(size_t N) const override {
10806   return false;
10807 }
10808 
10809 static const ParsedAttrInfoNoMerge Instance;
10810 };
10811 const ParsedAttrInfoNoMerge ParsedAttrInfoNoMerge::Instance;
10812 static constexpr ParsedAttrInfo::Spelling NoMicroMipsSpellings[] = {
10813   {AttributeCommonInfo::AS_GNU, "nomicromips"},
10814   {AttributeCommonInfo::AS_CXX11, "gnu::nomicromips"},
10815   {AttributeCommonInfo::AS_C23, "gnu::nomicromips"},
10816 };
10817 struct ParsedAttrInfoNoMicroMips final : public ParsedAttrInfo {
10818   constexpr ParsedAttrInfoNoMicroMips() : ParsedAttrInfo(
10819     /*AttrKind=*/ParsedAttr::AT_NoMicroMips,
10820     /*NumArgs=*/0,
10821     /*OptArgs=*/0,
10822     /*NumArgMembers=*/0,
10823     /*HasCustomParsing=*/0,
10824     /*AcceptsExprPack=*/0,
10825     /*IsTargetSpecific=*/1,
10826     /*IsType=*/0,
10827     /*IsStmt=*/0,
10828     /*IsKnownToGCC=*/1,
10829     /*IsSupportedByPragmaAttribute=*/1,
10830     /*Spellings=*/NoMicroMipsSpellings,
10831     /*ArgNames=*/{}) {}
10832 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10833   if (!isa<FunctionDecl>(D)) {
10834     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
10835       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10836     return false;
10837   }
10838   return true;
10839 }
10840 
10841 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10842   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10843     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10844   return false;
10845 }
10846 
10847 bool existsInTarget(const TargetInfo &Target) const override {
10848   const llvm::Triple &T = Target.getTriple(); (void)T;
10849   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel);
10850 }
10851 
10852 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10853   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10854 }
10855 
10856 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10857   D->addAttr(::new (S.Context) NoMicroMipsAttr(S.Context, Attr));
10858   return AttributeApplied;
10859 }
10860 
10861 bool isParamExpr(size_t N) const override {
10862   return false;
10863 }
10864 
10865 static const ParsedAttrInfoNoMicroMips Instance;
10866 };
10867 const ParsedAttrInfoNoMicroMips ParsedAttrInfoNoMicroMips::Instance;
10868 static constexpr ParsedAttrInfo::Spelling NoMips16Spellings[] = {
10869   {AttributeCommonInfo::AS_GNU, "nomips16"},
10870   {AttributeCommonInfo::AS_CXX11, "gnu::nomips16"},
10871   {AttributeCommonInfo::AS_C23, "gnu::nomips16"},
10872 };
10873 struct ParsedAttrInfoNoMips16 final : public ParsedAttrInfo {
10874   constexpr ParsedAttrInfoNoMips16() : ParsedAttrInfo(
10875     /*AttrKind=*/ParsedAttr::AT_NoMips16,
10876     /*NumArgs=*/0,
10877     /*OptArgs=*/0,
10878     /*NumArgMembers=*/0,
10879     /*HasCustomParsing=*/0,
10880     /*AcceptsExprPack=*/0,
10881     /*IsTargetSpecific=*/1,
10882     /*IsType=*/0,
10883     /*IsStmt=*/0,
10884     /*IsKnownToGCC=*/1,
10885     /*IsSupportedByPragmaAttribute=*/1,
10886     /*Spellings=*/NoMips16Spellings,
10887     /*ArgNames=*/{}) {}
10888 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10889   if (!isa<FunctionDecl>(D)) {
10890     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
10891       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10892     return false;
10893   }
10894   return true;
10895 }
10896 
10897 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10898   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10899     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10900   return false;
10901 }
10902 
10903 bool existsInTarget(const TargetInfo &Target) const override {
10904   const llvm::Triple &T = Target.getTriple(); (void)T;
10905   return true && (T.getArch() == llvm::Triple::mips || T.getArch() == llvm::Triple::mipsel);
10906 }
10907 
10908 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10909   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10910 }
10911 
10912 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10913   D->addAttr(::new (S.Context) NoMips16Attr(S.Context, Attr));
10914   return AttributeApplied;
10915 }
10916 
10917 bool isParamExpr(size_t N) const override {
10918   return false;
10919 }
10920 
10921 static const ParsedAttrInfoNoMips16 Instance;
10922 };
10923 const ParsedAttrInfoNoMips16 ParsedAttrInfoNoMips16::Instance;
10924 static constexpr ParsedAttrInfo::Spelling NoProfileFunctionSpellings[] = {
10925   {AttributeCommonInfo::AS_GNU, "no_profile_instrument_function"},
10926   {AttributeCommonInfo::AS_CXX11, "gnu::no_profile_instrument_function"},
10927   {AttributeCommonInfo::AS_C23, "gnu::no_profile_instrument_function"},
10928 };
10929 struct ParsedAttrInfoNoProfileFunction final : public ParsedAttrInfo {
10930   constexpr ParsedAttrInfoNoProfileFunction() : ParsedAttrInfo(
10931     /*AttrKind=*/ParsedAttr::AT_NoProfileFunction,
10932     /*NumArgs=*/0,
10933     /*OptArgs=*/0,
10934     /*NumArgMembers=*/0,
10935     /*HasCustomParsing=*/0,
10936     /*AcceptsExprPack=*/0,
10937     /*IsTargetSpecific=*/0,
10938     /*IsType=*/0,
10939     /*IsStmt=*/0,
10940     /*IsKnownToGCC=*/1,
10941     /*IsSupportedByPragmaAttribute=*/1,
10942     /*Spellings=*/NoProfileFunctionSpellings,
10943     /*ArgNames=*/{}) {}
10944 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10945   if (!isa<FunctionDecl>(D)) {
10946     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10947       << Attr << Attr.isRegularKeywordAttribute() << "functions";
10948     return false;
10949   }
10950   return true;
10951 }
10952 
10953 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
10954   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
10955     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
10956   return false;
10957 }
10958 
10959 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
10960   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
10961 }
10962 
10963 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
10964   D->addAttr(::new (S.Context) NoProfileFunctionAttr(S.Context, Attr));
10965   return AttributeApplied;
10966 }
10967 
10968 bool isParamExpr(size_t N) const override {
10969   return false;
10970 }
10971 
10972 static const ParsedAttrInfoNoProfileFunction Instance;
10973 };
10974 const ParsedAttrInfoNoProfileFunction ParsedAttrInfoNoProfileFunction::Instance;
10975 static constexpr ParsedAttrInfo::Spelling NoRandomizeLayoutSpellings[] = {
10976   {AttributeCommonInfo::AS_GNU, "no_randomize_layout"},
10977   {AttributeCommonInfo::AS_CXX11, "gnu::no_randomize_layout"},
10978   {AttributeCommonInfo::AS_C23, "gnu::no_randomize_layout"},
10979 };
10980 struct ParsedAttrInfoNoRandomizeLayout final : public ParsedAttrInfo {
10981   constexpr ParsedAttrInfoNoRandomizeLayout() : ParsedAttrInfo(
10982     /*AttrKind=*/ParsedAttr::AT_NoRandomizeLayout,
10983     /*NumArgs=*/0,
10984     /*OptArgs=*/0,
10985     /*NumArgMembers=*/0,
10986     /*HasCustomParsing=*/0,
10987     /*AcceptsExprPack=*/0,
10988     /*IsTargetSpecific=*/0,
10989     /*IsType=*/0,
10990     /*IsStmt=*/0,
10991     /*IsKnownToGCC=*/1,
10992     /*IsSupportedByPragmaAttribute=*/1,
10993     /*Spellings=*/NoRandomizeLayoutSpellings,
10994     /*ArgNames=*/{}) {}
10995 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
10996   if (!isa<RecordDecl>(D)) {
10997     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
10998       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
10999     return false;
11000   }
11001   return true;
11002 }
11003 
11004 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11005   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11006     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11007   return false;
11008 }
11009 
11010   using ParsedAttrInfo::diagMutualExclusion;
11011 
11012   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
11013     if (const auto *A = D->getAttr<RandomizeLayoutAttr>()) {
11014       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
11015       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
11016 return false;
11017     }
11018     return true;
11019   }
11020 
11021 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
11022   return (!LangOpts.CPlusPlus);
11023 }
11024 
11025 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11026   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
11027 }
11028 
11029 bool isParamExpr(size_t N) const override {
11030   return false;
11031 }
11032 
11033 static const ParsedAttrInfoNoRandomizeLayout Instance;
11034 };
11035 const ParsedAttrInfoNoRandomizeLayout ParsedAttrInfoNoRandomizeLayout::Instance;
11036 static constexpr ParsedAttrInfo::Spelling NoReturnSpellings[] = {
11037   {AttributeCommonInfo::AS_GNU, "noreturn"},
11038   {AttributeCommonInfo::AS_CXX11, "gnu::noreturn"},
11039   {AttributeCommonInfo::AS_C23, "gnu::noreturn"},
11040   {AttributeCommonInfo::AS_Declspec, "noreturn"},
11041 };
11042 struct ParsedAttrInfoNoReturn final : public ParsedAttrInfo {
11043   constexpr ParsedAttrInfoNoReturn() : ParsedAttrInfo(
11044     /*AttrKind=*/ParsedAttr::AT_NoReturn,
11045     /*NumArgs=*/0,
11046     /*OptArgs=*/0,
11047     /*NumArgMembers=*/0,
11048     /*HasCustomParsing=*/0,
11049     /*AcceptsExprPack=*/0,
11050     /*IsTargetSpecific=*/0,
11051     /*IsType=*/0,
11052     /*IsStmt=*/0,
11053     /*IsKnownToGCC=*/1,
11054     /*IsSupportedByPragmaAttribute=*/0,
11055     /*Spellings=*/NoReturnSpellings,
11056     /*ArgNames=*/{}) {}
11057 bool isParamExpr(size_t N) const override {
11058   return false;
11059 }
11060 
11061 static const ParsedAttrInfoNoReturn Instance;
11062 };
11063 const ParsedAttrInfoNoReturn ParsedAttrInfoNoReturn::Instance;
11064 static constexpr ParsedAttrInfo::Spelling NoSanitizeSpellings[] = {
11065   {AttributeCommonInfo::AS_GNU, "no_sanitize"},
11066   {AttributeCommonInfo::AS_CXX11, "clang::no_sanitize"},
11067   {AttributeCommonInfo::AS_C23, "clang::no_sanitize"},
11068 };
11069 static constexpr const char *NoSanitizeArgNames[] = {
11070 "Sanitizers...",};
11071 struct ParsedAttrInfoNoSanitize final : public ParsedAttrInfo {
11072   constexpr ParsedAttrInfoNoSanitize() : ParsedAttrInfo(
11073     /*AttrKind=*/ParsedAttr::AT_NoSanitize,
11074     /*NumArgs=*/0,
11075     /*OptArgs=*/15,
11076     /*NumArgMembers=*/1,
11077     /*HasCustomParsing=*/0,
11078     /*AcceptsExprPack=*/0,
11079     /*IsTargetSpecific=*/0,
11080     /*IsType=*/0,
11081     /*IsStmt=*/0,
11082     /*IsKnownToGCC=*/0,
11083     /*IsSupportedByPragmaAttribute=*/1,
11084     /*Spellings=*/NoSanitizeSpellings,
11085     /*ArgNames=*/NoSanitizeArgNames) {}
11086 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11087   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isGlobalVar(D)) {
11088     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
11089       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, and global variables";
11090     return false;
11091   }
11092   return true;
11093 }
11094 
11095 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11096   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11097     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11098   return false;
11099 }
11100 
11101 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11102   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11103   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
11104   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
11105 }
11106 
11107 bool isParamExpr(size_t N) const override {
11108   return false;
11109 }
11110 
11111 static const ParsedAttrInfoNoSanitize Instance;
11112 };
11113 const ParsedAttrInfoNoSanitize ParsedAttrInfoNoSanitize::Instance;
11114 static constexpr ParsedAttrInfo::Spelling NoSanitizeSpecificSpellings[] = {
11115   {AttributeCommonInfo::AS_GNU, "no_address_safety_analysis"},
11116   {AttributeCommonInfo::AS_CXX11, "gnu::no_address_safety_analysis"},
11117   {AttributeCommonInfo::AS_C23, "gnu::no_address_safety_analysis"},
11118   {AttributeCommonInfo::AS_GNU, "no_sanitize_address"},
11119   {AttributeCommonInfo::AS_CXX11, "gnu::no_sanitize_address"},
11120   {AttributeCommonInfo::AS_C23, "gnu::no_sanitize_address"},
11121   {AttributeCommonInfo::AS_GNU, "no_sanitize_thread"},
11122   {AttributeCommonInfo::AS_CXX11, "gnu::no_sanitize_thread"},
11123   {AttributeCommonInfo::AS_C23, "gnu::no_sanitize_thread"},
11124   {AttributeCommonInfo::AS_GNU, "no_sanitize_memory"},
11125   {AttributeCommonInfo::AS_CXX11, "clang::no_sanitize_memory"},
11126   {AttributeCommonInfo::AS_C23, "clang::no_sanitize_memory"},
11127 };
11128 struct ParsedAttrInfoNoSanitizeSpecific final : public ParsedAttrInfo {
11129   constexpr ParsedAttrInfoNoSanitizeSpecific() : ParsedAttrInfo(
11130     /*AttrKind=*/ParsedAttr::AT_NoSanitizeSpecific,
11131     /*NumArgs=*/0,
11132     /*OptArgs=*/0,
11133     /*NumArgMembers=*/0,
11134     /*HasCustomParsing=*/0,
11135     /*AcceptsExprPack=*/0,
11136     /*IsTargetSpecific=*/0,
11137     /*IsType=*/0,
11138     /*IsStmt=*/0,
11139     /*IsKnownToGCC=*/1,
11140     /*IsSupportedByPragmaAttribute=*/1,
11141     /*Spellings=*/NoSanitizeSpecificSpellings,
11142     /*ArgNames=*/{}) {}
11143 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11144   if (!isa<FunctionDecl>(D) && !isGlobalVar(D)) {
11145     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
11146       << Attr << Attr.isRegularKeywordAttribute() << "functions and global variables";
11147     return false;
11148   }
11149   return true;
11150 }
11151 
11152 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11153   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11154     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11155   return false;
11156 }
11157 
11158 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11159   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11160   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
11161 }
11162 
11163 bool isParamExpr(size_t N) const override {
11164   return false;
11165 }
11166 
11167 static const ParsedAttrInfoNoSanitizeSpecific Instance;
11168 };
11169 const ParsedAttrInfoNoSanitizeSpecific ParsedAttrInfoNoSanitizeSpecific::Instance;
11170 static constexpr ParsedAttrInfo::Spelling NoSpecializationsSpellings[] = {
11171   {AttributeCommonInfo::AS_GNU, "no_specializations"},
11172   {AttributeCommonInfo::AS_CXX11, "clang::no_specializations"},
11173 };
11174 static constexpr const char *NoSpecializationsArgNames[] = {
11175 "Message",};
11176 struct ParsedAttrInfoNoSpecializations final : public ParsedAttrInfo {
11177   constexpr ParsedAttrInfoNoSpecializations() : ParsedAttrInfo(
11178     /*AttrKind=*/ParsedAttr::AT_NoSpecializations,
11179     /*NumArgs=*/0,
11180     /*OptArgs=*/1,
11181     /*NumArgMembers=*/1,
11182     /*HasCustomParsing=*/0,
11183     /*AcceptsExprPack=*/0,
11184     /*IsTargetSpecific=*/0,
11185     /*IsType=*/0,
11186     /*IsStmt=*/0,
11187     /*IsKnownToGCC=*/0,
11188     /*IsSupportedByPragmaAttribute=*/0,
11189     /*Spellings=*/NoSpecializationsSpellings,
11190     /*ArgNames=*/NoSpecializationsArgNames) {}
11191 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11192   if (!isClassTmpl(D) && !isFunctionTmpl(D) && !isVarTmpl(D)) {
11193     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11194       << Attr << Attr.isRegularKeywordAttribute() << "class templates, function templates, and variable templates";
11195     return false;
11196   }
11197   return true;
11198 }
11199 
11200 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11201   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11202     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11203   return false;
11204 }
11205 
11206 bool isParamExpr(size_t N) const override {
11207   return false;
11208 }
11209 
11210 static const ParsedAttrInfoNoSpecializations Instance;
11211 };
11212 const ParsedAttrInfoNoSpecializations ParsedAttrInfoNoSpecializations::Instance;
11213 static constexpr ParsedAttrInfo::Spelling NoSpeculativeLoadHardeningSpellings[] = {
11214   {AttributeCommonInfo::AS_GNU, "no_speculative_load_hardening"},
11215   {AttributeCommonInfo::AS_CXX11, "clang::no_speculative_load_hardening"},
11216   {AttributeCommonInfo::AS_C23, "clang::no_speculative_load_hardening"},
11217 };
11218 struct ParsedAttrInfoNoSpeculativeLoadHardening final : public ParsedAttrInfo {
11219   constexpr ParsedAttrInfoNoSpeculativeLoadHardening() : ParsedAttrInfo(
11220     /*AttrKind=*/ParsedAttr::AT_NoSpeculativeLoadHardening,
11221     /*NumArgs=*/0,
11222     /*OptArgs=*/0,
11223     /*NumArgMembers=*/0,
11224     /*HasCustomParsing=*/0,
11225     /*AcceptsExprPack=*/0,
11226     /*IsTargetSpecific=*/0,
11227     /*IsType=*/0,
11228     /*IsStmt=*/0,
11229     /*IsKnownToGCC=*/0,
11230     /*IsSupportedByPragmaAttribute=*/1,
11231     /*Spellings=*/NoSpeculativeLoadHardeningSpellings,
11232     /*ArgNames=*/{}) {}
11233 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11234   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
11235     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
11236       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
11237     return false;
11238   }
11239   return true;
11240 }
11241 
11242 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11243   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11244     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11245   return false;
11246 }
11247 
11248   using ParsedAttrInfo::diagMutualExclusion;
11249 
11250   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
11251     if (const auto *A = D->getAttr<SpeculativeLoadHardeningAttr>()) {
11252       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
11253       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
11254 return false;
11255     }
11256     return true;
11257   }
11258 
11259 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11260   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11261   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
11262 }
11263 
11264 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11265   D->addAttr(::new (S.Context) NoSpeculativeLoadHardeningAttr(S.Context, Attr));
11266   return AttributeApplied;
11267 }
11268 
11269 bool isParamExpr(size_t N) const override {
11270   return false;
11271 }
11272 
11273 static const ParsedAttrInfoNoSpeculativeLoadHardening Instance;
11274 };
11275 const ParsedAttrInfoNoSpeculativeLoadHardening ParsedAttrInfoNoSpeculativeLoadHardening::Instance;
11276 static constexpr ParsedAttrInfo::Spelling NoSplitStackSpellings[] = {
11277   {AttributeCommonInfo::AS_GNU, "no_split_stack"},
11278   {AttributeCommonInfo::AS_CXX11, "gnu::no_split_stack"},
11279   {AttributeCommonInfo::AS_C23, "gnu::no_split_stack"},
11280 };
11281 struct ParsedAttrInfoNoSplitStack final : public ParsedAttrInfo {
11282   constexpr ParsedAttrInfoNoSplitStack() : ParsedAttrInfo(
11283     /*AttrKind=*/ParsedAttr::AT_NoSplitStack,
11284     /*NumArgs=*/0,
11285     /*OptArgs=*/0,
11286     /*NumArgMembers=*/0,
11287     /*HasCustomParsing=*/0,
11288     /*AcceptsExprPack=*/0,
11289     /*IsTargetSpecific=*/0,
11290     /*IsType=*/0,
11291     /*IsStmt=*/0,
11292     /*IsKnownToGCC=*/1,
11293     /*IsSupportedByPragmaAttribute=*/1,
11294     /*Spellings=*/NoSplitStackSpellings,
11295     /*ArgNames=*/{}) {}
11296 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11297   if (!isa<FunctionDecl>(D)) {
11298     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
11299       << Attr << Attr.isRegularKeywordAttribute() << "functions";
11300     return false;
11301   }
11302   return true;
11303 }
11304 
11305 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11306   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11307     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11308   return false;
11309 }
11310 
11311 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11312   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11313 }
11314 
11315 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11316   D->addAttr(::new (S.Context) NoSplitStackAttr(S.Context, Attr));
11317   return AttributeApplied;
11318 }
11319 
11320 bool isParamExpr(size_t N) const override {
11321   return false;
11322 }
11323 
11324 static const ParsedAttrInfoNoSplitStack Instance;
11325 };
11326 const ParsedAttrInfoNoSplitStack ParsedAttrInfoNoSplitStack::Instance;
11327 static constexpr ParsedAttrInfo::Spelling NoStackProtectorSpellings[] = {
11328   {AttributeCommonInfo::AS_GNU, "no_stack_protector"},
11329   {AttributeCommonInfo::AS_CXX11, "clang::no_stack_protector"},
11330   {AttributeCommonInfo::AS_C23, "clang::no_stack_protector"},
11331   {AttributeCommonInfo::AS_CXX11, "gnu::no_stack_protector"},
11332   {AttributeCommonInfo::AS_C23, "gnu::no_stack_protector"},
11333   {AttributeCommonInfo::AS_Declspec, "safebuffers"},
11334 };
11335 struct ParsedAttrInfoNoStackProtector final : public ParsedAttrInfo {
11336   constexpr ParsedAttrInfoNoStackProtector() : ParsedAttrInfo(
11337     /*AttrKind=*/ParsedAttr::AT_NoStackProtector,
11338     /*NumArgs=*/0,
11339     /*OptArgs=*/0,
11340     /*NumArgMembers=*/0,
11341     /*HasCustomParsing=*/0,
11342     /*AcceptsExprPack=*/0,
11343     /*IsTargetSpecific=*/0,
11344     /*IsType=*/0,
11345     /*IsStmt=*/0,
11346     /*IsKnownToGCC=*/0,
11347     /*IsSupportedByPragmaAttribute=*/1,
11348     /*Spellings=*/NoStackProtectorSpellings,
11349     /*ArgNames=*/{}) {}
11350 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11351   if (!isa<FunctionDecl>(D)) {
11352     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11353       << Attr << Attr.isRegularKeywordAttribute() << "functions";
11354     return false;
11355   }
11356   return true;
11357 }
11358 
11359 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11360   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11361     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11362   return false;
11363 }
11364 
11365 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
11366   enum Spelling {
11367     GNU_no_stack_protector = 0,
11368     CXX11_clang_no_stack_protector = 1,
11369     C23_clang_no_stack_protector = 2,
11370     CXX11_gnu_no_stack_protector = 3,
11371     C23_gnu_no_stack_protector = 4,
11372     Declspec_safebuffers = 5,
11373   SpellingNotCalculated = 15
11374 
11375   };
11376 
11377   unsigned Idx = Attr.getAttributeSpellingListIndex();
11378   switch (Idx) {
11379     default: llvm_unreachable("Unknown spelling list index");
11380     case 0: return GNU_no_stack_protector;
11381     case 1: return CXX11_clang_no_stack_protector;
11382     case 2: return C23_clang_no_stack_protector;
11383     case 3: return CXX11_gnu_no_stack_protector;
11384     case 4: return C23_gnu_no_stack_protector;
11385     case 5: return Declspec_safebuffers;
11386   }
11387 }
11388 
11389 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11390   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11391 }
11392 
11393 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11394   D->addAttr(::new (S.Context) NoStackProtectorAttr(S.Context, Attr));
11395   return AttributeApplied;
11396 }
11397 
11398 bool isParamExpr(size_t N) const override {
11399   return false;
11400 }
11401 
11402 static const ParsedAttrInfoNoStackProtector Instance;
11403 };
11404 const ParsedAttrInfoNoStackProtector ParsedAttrInfoNoStackProtector::Instance;
11405 static constexpr ParsedAttrInfo::Spelling NoThreadSafetyAnalysisSpellings[] = {
11406   {AttributeCommonInfo::AS_GNU, "no_thread_safety_analysis"},
11407   {AttributeCommonInfo::AS_CXX11, "clang::no_thread_safety_analysis"},
11408   {AttributeCommonInfo::AS_C23, "clang::no_thread_safety_analysis"},
11409 };
11410 struct ParsedAttrInfoNoThreadSafetyAnalysis final : public ParsedAttrInfo {
11411   constexpr ParsedAttrInfoNoThreadSafetyAnalysis() : ParsedAttrInfo(
11412     /*AttrKind=*/ParsedAttr::AT_NoThreadSafetyAnalysis,
11413     /*NumArgs=*/0,
11414     /*OptArgs=*/0,
11415     /*NumArgMembers=*/0,
11416     /*HasCustomParsing=*/0,
11417     /*AcceptsExprPack=*/0,
11418     /*IsTargetSpecific=*/0,
11419     /*IsType=*/0,
11420     /*IsStmt=*/0,
11421     /*IsKnownToGCC=*/0,
11422     /*IsSupportedByPragmaAttribute=*/1,
11423     /*Spellings=*/NoThreadSafetyAnalysisSpellings,
11424     /*ArgNames=*/{}) {}
11425 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11426   if (!isa<FunctionDecl>(D)) {
11427     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11428       << Attr << Attr.isRegularKeywordAttribute() << "functions";
11429     return false;
11430   }
11431   return true;
11432 }
11433 
11434 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11435   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11436     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11437   return false;
11438 }
11439 
11440 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11441   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11442 }
11443 
11444 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11445   D->addAttr(::new (S.Context) NoThreadSafetyAnalysisAttr(S.Context, Attr));
11446   return AttributeApplied;
11447 }
11448 
11449 bool isParamExpr(size_t N) const override {
11450   return false;
11451 }
11452 
11453 static const ParsedAttrInfoNoThreadSafetyAnalysis Instance;
11454 };
11455 const ParsedAttrInfoNoThreadSafetyAnalysis ParsedAttrInfoNoThreadSafetyAnalysis::Instance;
11456 static constexpr ParsedAttrInfo::Spelling NoThrowSpellings[] = {
11457   {AttributeCommonInfo::AS_GNU, "nothrow"},
11458   {AttributeCommonInfo::AS_CXX11, "gnu::nothrow"},
11459   {AttributeCommonInfo::AS_C23, "gnu::nothrow"},
11460   {AttributeCommonInfo::AS_Declspec, "nothrow"},
11461 };
11462 struct ParsedAttrInfoNoThrow final : public ParsedAttrInfo {
11463   constexpr ParsedAttrInfoNoThrow() : ParsedAttrInfo(
11464     /*AttrKind=*/ParsedAttr::AT_NoThrow,
11465     /*NumArgs=*/0,
11466     /*OptArgs=*/0,
11467     /*NumArgMembers=*/0,
11468     /*HasCustomParsing=*/0,
11469     /*AcceptsExprPack=*/0,
11470     /*IsTargetSpecific=*/0,
11471     /*IsType=*/0,
11472     /*IsStmt=*/0,
11473     /*IsKnownToGCC=*/1,
11474     /*IsSupportedByPragmaAttribute=*/1,
11475     /*Spellings=*/NoThrowSpellings,
11476     /*ArgNames=*/{}) {}
11477 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11478   if (!isFunctionLike(D)) {
11479     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11480       << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers";
11481     return false;
11482   }
11483   return true;
11484 }
11485 
11486 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11487   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11488     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11489   return false;
11490 }
11491 
11492 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11493   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
11494 }
11495 
11496 bool isParamExpr(size_t N) const override {
11497   return false;
11498 }
11499 
11500 static const ParsedAttrInfoNoThrow Instance;
11501 };
11502 const ParsedAttrInfoNoThrow ParsedAttrInfoNoThrow::Instance;
11503 static constexpr ParsedAttrInfo::Spelling NoTrivialAutoVarInitSpellings[] = {
11504   {AttributeCommonInfo::AS_Declspec, "no_init_all"},
11505 };
11506 struct ParsedAttrInfoNoTrivialAutoVarInit final : public ParsedAttrInfo {
11507   constexpr ParsedAttrInfoNoTrivialAutoVarInit() : ParsedAttrInfo(
11508     /*AttrKind=*/ParsedAttr::AT_NoTrivialAutoVarInit,
11509     /*NumArgs=*/0,
11510     /*OptArgs=*/0,
11511     /*NumArgMembers=*/0,
11512     /*HasCustomParsing=*/0,
11513     /*AcceptsExprPack=*/0,
11514     /*IsTargetSpecific=*/0,
11515     /*IsType=*/0,
11516     /*IsStmt=*/0,
11517     /*IsKnownToGCC=*/0,
11518     /*IsSupportedByPragmaAttribute=*/0,
11519     /*Spellings=*/NoTrivialAutoVarInitSpellings,
11520     /*ArgNames=*/{}) {}
11521 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11522   if (!isa<FunctionDecl>(D) && !isa<TagDecl>(D)) {
11523     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11524       << Attr << Attr.isRegularKeywordAttribute() << "functions and tag types";
11525     return false;
11526   }
11527   return true;
11528 }
11529 
11530 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11531   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11532     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11533   return false;
11534 }
11535 
11536 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11537   D->addAttr(::new (S.Context) NoTrivialAutoVarInitAttr(S.Context, Attr));
11538   return AttributeApplied;
11539 }
11540 
11541 bool isParamExpr(size_t N) const override {
11542   return false;
11543 }
11544 
11545 static const ParsedAttrInfoNoTrivialAutoVarInit Instance;
11546 };
11547 const ParsedAttrInfoNoTrivialAutoVarInit ParsedAttrInfoNoTrivialAutoVarInit::Instance;
11548 static constexpr ParsedAttrInfo::Spelling NoUniqueAddressSpellings[] = {
11549   {AttributeCommonInfo::AS_CXX11, "no_unique_address"},
11550   {AttributeCommonInfo::AS_CXX11, "msvc::no_unique_address"},
11551 };
11552 struct ParsedAttrInfoNoUniqueAddress final : public ParsedAttrInfo {
11553   constexpr ParsedAttrInfoNoUniqueAddress() : ParsedAttrInfo(
11554     /*AttrKind=*/ParsedAttr::AT_NoUniqueAddress,
11555     /*NumArgs=*/0,
11556     /*OptArgs=*/0,
11557     /*NumArgMembers=*/0,
11558     /*HasCustomParsing=*/0,
11559     /*AcceptsExprPack=*/0,
11560     /*IsTargetSpecific=*/0,
11561     /*IsType=*/0,
11562     /*IsStmt=*/0,
11563     /*IsKnownToGCC=*/0,
11564     /*IsSupportedByPragmaAttribute=*/0,
11565     /*Spellings=*/NoUniqueAddressSpellings,
11566     /*ArgNames=*/{}) {}
11567 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11568   if (!isNonBitField(D)) {
11569     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
11570       << Attr << Attr.isRegularKeywordAttribute() << "non-bit-field non-static data members";
11571     return false;
11572   }
11573   return true;
11574 }
11575 
11576 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11577   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11578     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11579   return false;
11580 }
11581 
11582 bool spellingExistsInTarget(const TargetInfo &Target,
11583                             const unsigned SpellingListIndex) const override {
11584   const llvm::Triple &T = Target.getTriple(); (void)T;
11585   return ((SpellingListIndex == 0) && true && ( Target.getCXXABI().isItaniumFamily() )) || ((SpellingListIndex == 1) && 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() ));
11586 }
11587 
11588 bool isParamExpr(size_t N) const override {
11589   return false;
11590 }
11591 
11592 static const ParsedAttrInfoNoUniqueAddress Instance;
11593 };
11594 const ParsedAttrInfoNoUniqueAddress ParsedAttrInfoNoUniqueAddress::Instance;
11595 static constexpr ParsedAttrInfo::Spelling NoUwtableSpellings[] = {
11596   {AttributeCommonInfo::AS_GNU, "nouwtable"},
11597   {AttributeCommonInfo::AS_CXX11, "clang::nouwtable"},
11598   {AttributeCommonInfo::AS_C23, "clang::nouwtable"},
11599 };
11600 struct ParsedAttrInfoNoUwtable final : public ParsedAttrInfo {
11601   constexpr ParsedAttrInfoNoUwtable() : ParsedAttrInfo(
11602     /*AttrKind=*/ParsedAttr::AT_NoUwtable,
11603     /*NumArgs=*/0,
11604     /*OptArgs=*/0,
11605     /*NumArgMembers=*/0,
11606     /*HasCustomParsing=*/0,
11607     /*AcceptsExprPack=*/0,
11608     /*IsTargetSpecific=*/0,
11609     /*IsType=*/0,
11610     /*IsStmt=*/0,
11611     /*IsKnownToGCC=*/0,
11612     /*IsSupportedByPragmaAttribute=*/1,
11613     /*Spellings=*/NoUwtableSpellings,
11614     /*ArgNames=*/{}) {}
11615 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11616   if (!isFunctionLike(D)) {
11617     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11618       << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers";
11619     return false;
11620   }
11621   return true;
11622 }
11623 
11624 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11625   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11626     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11627   return false;
11628 }
11629 
11630 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11631   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
11632 }
11633 
11634 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11635   D->addAttr(::new (S.Context) NoUwtableAttr(S.Context, Attr));
11636   return AttributeApplied;
11637 }
11638 
11639 bool isParamExpr(size_t N) const override {
11640   return false;
11641 }
11642 
11643 static const ParsedAttrInfoNoUwtable Instance;
11644 };
11645 const ParsedAttrInfoNoUwtable ParsedAttrInfoNoUwtable::Instance;
11646 static constexpr ParsedAttrInfo::Spelling NonAllocatingSpellings[] = {
11647   {AttributeCommonInfo::AS_GNU, "nonallocating"},
11648   {AttributeCommonInfo::AS_CXX11, "clang::nonallocating"},
11649   {AttributeCommonInfo::AS_C23, "clang::nonallocating"},
11650 };
11651 static constexpr const char *NonAllocatingArgNames[] = {
11652 "Cond",};
11653 struct ParsedAttrInfoNonAllocating final : public ParsedAttrInfo {
11654   constexpr ParsedAttrInfoNonAllocating() : ParsedAttrInfo(
11655     /*AttrKind=*/ParsedAttr::AT_NonAllocating,
11656     /*NumArgs=*/0,
11657     /*OptArgs=*/1,
11658     /*NumArgMembers=*/1,
11659     /*HasCustomParsing=*/0,
11660     /*AcceptsExprPack=*/0,
11661     /*IsTargetSpecific=*/0,
11662     /*IsType=*/1,
11663     /*IsStmt=*/0,
11664     /*IsKnownToGCC=*/0,
11665     /*IsSupportedByPragmaAttribute=*/0,
11666     /*Spellings=*/NonAllocatingSpellings,
11667     /*ArgNames=*/NonAllocatingArgNames) {}
11668 bool isParamExpr(size_t N) const override {
11669   return (N == 0) || false;
11670 }
11671 
11672 static const ParsedAttrInfoNonAllocating Instance;
11673 };
11674 const ParsedAttrInfoNonAllocating ParsedAttrInfoNonAllocating::Instance;
11675 static constexpr ParsedAttrInfo::Spelling NonBlockingSpellings[] = {
11676   {AttributeCommonInfo::AS_GNU, "nonblocking"},
11677   {AttributeCommonInfo::AS_CXX11, "clang::nonblocking"},
11678   {AttributeCommonInfo::AS_C23, "clang::nonblocking"},
11679 };
11680 static constexpr const char *NonBlockingArgNames[] = {
11681 "Cond",};
11682 struct ParsedAttrInfoNonBlocking final : public ParsedAttrInfo {
11683   constexpr ParsedAttrInfoNonBlocking() : ParsedAttrInfo(
11684     /*AttrKind=*/ParsedAttr::AT_NonBlocking,
11685     /*NumArgs=*/0,
11686     /*OptArgs=*/1,
11687     /*NumArgMembers=*/1,
11688     /*HasCustomParsing=*/0,
11689     /*AcceptsExprPack=*/0,
11690     /*IsTargetSpecific=*/0,
11691     /*IsType=*/1,
11692     /*IsStmt=*/0,
11693     /*IsKnownToGCC=*/0,
11694     /*IsSupportedByPragmaAttribute=*/0,
11695     /*Spellings=*/NonBlockingSpellings,
11696     /*ArgNames=*/NonBlockingArgNames) {}
11697 bool isParamExpr(size_t N) const override {
11698   return (N == 0) || false;
11699 }
11700 
11701 static const ParsedAttrInfoNonBlocking Instance;
11702 };
11703 const ParsedAttrInfoNonBlocking ParsedAttrInfoNonBlocking::Instance;
11704 static constexpr ParsedAttrInfo::Spelling NonNullSpellings[] = {
11705   {AttributeCommonInfo::AS_GNU, "nonnull"},
11706   {AttributeCommonInfo::AS_CXX11, "gnu::nonnull"},
11707   {AttributeCommonInfo::AS_C23, "gnu::nonnull"},
11708 };
11709 static constexpr const char *NonNullArgNames[] = {
11710 "Args...",};
11711 struct ParsedAttrInfoNonNull final : public ParsedAttrInfo {
11712   constexpr ParsedAttrInfoNonNull() : ParsedAttrInfo(
11713     /*AttrKind=*/ParsedAttr::AT_NonNull,
11714     /*NumArgs=*/0,
11715     /*OptArgs=*/15,
11716     /*NumArgMembers=*/1,
11717     /*HasCustomParsing=*/0,
11718     /*AcceptsExprPack=*/0,
11719     /*IsTargetSpecific=*/0,
11720     /*IsType=*/0,
11721     /*IsStmt=*/0,
11722     /*IsKnownToGCC=*/1,
11723     /*IsSupportedByPragmaAttribute=*/0,
11724     /*Spellings=*/NonNullSpellings,
11725     /*ArgNames=*/NonNullArgNames) {}
11726 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11727   if (!isa<ObjCMethodDecl>(D) && !isHasFunctionProto(D) && !isa<ParmVarDecl>(D)) {
11728     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11729       << Attr << Attr.isRegularKeywordAttribute() << "functions, methods, and parameters";
11730     return false;
11731   }
11732   return true;
11733 }
11734 
11735 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11736   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11737     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11738   return false;
11739 }
11740 
11741 bool isParamExpr(size_t N) const override {
11742   return false;
11743 }
11744 
11745 static const ParsedAttrInfoNonNull Instance;
11746 };
11747 const ParsedAttrInfoNonNull ParsedAttrInfoNonNull::Instance;
11748 static constexpr ParsedAttrInfo::Spelling NotTailCalledSpellings[] = {
11749   {AttributeCommonInfo::AS_GNU, "not_tail_called"},
11750   {AttributeCommonInfo::AS_CXX11, "clang::not_tail_called"},
11751   {AttributeCommonInfo::AS_C23, "clang::not_tail_called"},
11752 };
11753 struct ParsedAttrInfoNotTailCalled final : public ParsedAttrInfo {
11754   constexpr ParsedAttrInfoNotTailCalled() : ParsedAttrInfo(
11755     /*AttrKind=*/ParsedAttr::AT_NotTailCalled,
11756     /*NumArgs=*/0,
11757     /*OptArgs=*/0,
11758     /*NumArgMembers=*/0,
11759     /*HasCustomParsing=*/0,
11760     /*AcceptsExprPack=*/0,
11761     /*IsTargetSpecific=*/0,
11762     /*IsType=*/0,
11763     /*IsStmt=*/0,
11764     /*IsKnownToGCC=*/0,
11765     /*IsSupportedByPragmaAttribute=*/1,
11766     /*Spellings=*/NotTailCalledSpellings,
11767     /*ArgNames=*/{}) {}
11768 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11769   if (!isa<FunctionDecl>(D)) {
11770     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11771       << Attr << Attr.isRegularKeywordAttribute() << "functions";
11772     return false;
11773   }
11774   return true;
11775 }
11776 
11777 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11778   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11779     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11780   return false;
11781 }
11782 
11783   using ParsedAttrInfo::diagMutualExclusion;
11784 
11785   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
11786     if (const auto *A = D->getAttr<AlwaysInlineAttr>()) {
11787       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
11788       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
11789 return false;
11790     }
11791     return true;
11792   }
11793 
11794 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11795   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11796 }
11797 
11798 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11799   D->addAttr(::new (S.Context) NotTailCalledAttr(S.Context, Attr));
11800   return AttributeApplied;
11801 }
11802 
11803 bool isParamExpr(size_t N) const override {
11804   return false;
11805 }
11806 
11807 static const ParsedAttrInfoNotTailCalled Instance;
11808 };
11809 const ParsedAttrInfoNotTailCalled ParsedAttrInfoNotTailCalled::Instance;
11810 static constexpr ParsedAttrInfo::Spelling OMPAssumeSpellings[] = {
11811   {AttributeCommonInfo::AS_CXX11, "omp::assume"},
11812 };
11813 static constexpr const char *OMPAssumeArgNames[] = {
11814 "Assumption",};
11815 struct ParsedAttrInfoOMPAssume final : public ParsedAttrInfo {
11816   constexpr ParsedAttrInfoOMPAssume() : ParsedAttrInfo(
11817     /*AttrKind=*/ParsedAttr::AT_OMPAssume,
11818     /*NumArgs=*/1,
11819     /*OptArgs=*/0,
11820     /*NumArgMembers=*/1,
11821     /*HasCustomParsing=*/0,
11822     /*AcceptsExprPack=*/0,
11823     /*IsTargetSpecific=*/0,
11824     /*IsType=*/0,
11825     /*IsStmt=*/0,
11826     /*IsKnownToGCC=*/0,
11827     /*IsSupportedByPragmaAttribute=*/1,
11828     /*Spellings=*/OMPAssumeSpellings,
11829     /*ArgNames=*/OMPAssumeArgNames) {}
11830 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11831   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
11832     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11833       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
11834     return false;
11835   }
11836   return true;
11837 }
11838 
11839 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11840   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11841     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11842   return false;
11843 }
11844 
11845 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11846   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11847   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
11848 }
11849 
11850 bool isParamExpr(size_t N) const override {
11851   return false;
11852 }
11853 
11854 static const ParsedAttrInfoOMPAssume Instance;
11855 };
11856 const ParsedAttrInfoOMPAssume ParsedAttrInfoOMPAssume::Instance;
11857 static constexpr ParsedAttrInfo::Spelling OSConsumedSpellings[] = {
11858   {AttributeCommonInfo::AS_GNU, "os_consumed"},
11859   {AttributeCommonInfo::AS_CXX11, "clang::os_consumed"},
11860   {AttributeCommonInfo::AS_C23, "clang::os_consumed"},
11861 };
11862 struct ParsedAttrInfoOSConsumed final : public ParsedAttrInfo {
11863   constexpr ParsedAttrInfoOSConsumed() : ParsedAttrInfo(
11864     /*AttrKind=*/ParsedAttr::AT_OSConsumed,
11865     /*NumArgs=*/0,
11866     /*OptArgs=*/0,
11867     /*NumArgMembers=*/0,
11868     /*HasCustomParsing=*/0,
11869     /*AcceptsExprPack=*/0,
11870     /*IsTargetSpecific=*/0,
11871     /*IsType=*/0,
11872     /*IsStmt=*/0,
11873     /*IsKnownToGCC=*/0,
11874     /*IsSupportedByPragmaAttribute=*/1,
11875     /*Spellings=*/OSConsumedSpellings,
11876     /*ArgNames=*/{}) {}
11877 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11878   if (!isa<ParmVarDecl>(D)) {
11879     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11880       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
11881     return false;
11882   }
11883   return true;
11884 }
11885 
11886 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11887   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11888     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11889   return false;
11890 }
11891 
11892 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11893   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
11894 }
11895 
11896 bool isParamExpr(size_t N) const override {
11897   return false;
11898 }
11899 
11900 static const ParsedAttrInfoOSConsumed Instance;
11901 };
11902 const ParsedAttrInfoOSConsumed ParsedAttrInfoOSConsumed::Instance;
11903 static constexpr ParsedAttrInfo::Spelling OSConsumesThisSpellings[] = {
11904   {AttributeCommonInfo::AS_GNU, "os_consumes_this"},
11905   {AttributeCommonInfo::AS_CXX11, "clang::os_consumes_this"},
11906   {AttributeCommonInfo::AS_C23, "clang::os_consumes_this"},
11907 };
11908 struct ParsedAttrInfoOSConsumesThis final : public ParsedAttrInfo {
11909   constexpr ParsedAttrInfoOSConsumesThis() : ParsedAttrInfo(
11910     /*AttrKind=*/ParsedAttr::AT_OSConsumesThis,
11911     /*NumArgs=*/0,
11912     /*OptArgs=*/0,
11913     /*NumArgMembers=*/0,
11914     /*HasCustomParsing=*/0,
11915     /*AcceptsExprPack=*/0,
11916     /*IsTargetSpecific=*/0,
11917     /*IsType=*/0,
11918     /*IsStmt=*/0,
11919     /*IsKnownToGCC=*/0,
11920     /*IsSupportedByPragmaAttribute=*/0,
11921     /*Spellings=*/OSConsumesThisSpellings,
11922     /*ArgNames=*/{}) {}
11923 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11924   if (!isNonStaticCXXMethod(D)) {
11925     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11926       << Attr << Attr.isRegularKeywordAttribute() << "non-static member functions";
11927     return false;
11928   }
11929   return true;
11930 }
11931 
11932 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11933   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11934     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11935   return false;
11936 }
11937 
11938 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
11939   D->addAttr(::new (S.Context) OSConsumesThisAttr(S.Context, Attr));
11940   return AttributeApplied;
11941 }
11942 
11943 bool isParamExpr(size_t N) const override {
11944   return false;
11945 }
11946 
11947 static const ParsedAttrInfoOSConsumesThis Instance;
11948 };
11949 const ParsedAttrInfoOSConsumesThis ParsedAttrInfoOSConsumesThis::Instance;
11950 static constexpr ParsedAttrInfo::Spelling OSReturnsNotRetainedSpellings[] = {
11951   {AttributeCommonInfo::AS_GNU, "os_returns_not_retained"},
11952   {AttributeCommonInfo::AS_CXX11, "clang::os_returns_not_retained"},
11953   {AttributeCommonInfo::AS_C23, "clang::os_returns_not_retained"},
11954 };
11955 struct ParsedAttrInfoOSReturnsNotRetained final : public ParsedAttrInfo {
11956   constexpr ParsedAttrInfoOSReturnsNotRetained() : ParsedAttrInfo(
11957     /*AttrKind=*/ParsedAttr::AT_OSReturnsNotRetained,
11958     /*NumArgs=*/0,
11959     /*OptArgs=*/0,
11960     /*NumArgMembers=*/0,
11961     /*HasCustomParsing=*/0,
11962     /*AcceptsExprPack=*/0,
11963     /*IsTargetSpecific=*/0,
11964     /*IsType=*/0,
11965     /*IsStmt=*/0,
11966     /*IsKnownToGCC=*/0,
11967     /*IsSupportedByPragmaAttribute=*/1,
11968     /*Spellings=*/OSReturnsNotRetainedSpellings,
11969     /*ArgNames=*/{}) {}
11970 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
11971   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D) && !isa<ParmVarDecl>(D)) {
11972     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
11973       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, Objective-C properties, and parameters";
11974     return false;
11975   }
11976   return true;
11977 }
11978 
11979 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
11980   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
11981     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
11982   return false;
11983 }
11984 
11985 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
11986   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
11987   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
11988   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
11989   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
11990 }
11991 
11992 bool isParamExpr(size_t N) const override {
11993   return false;
11994 }
11995 
11996 static const ParsedAttrInfoOSReturnsNotRetained Instance;
11997 };
11998 const ParsedAttrInfoOSReturnsNotRetained ParsedAttrInfoOSReturnsNotRetained::Instance;
11999 static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedSpellings[] = {
12000   {AttributeCommonInfo::AS_GNU, "os_returns_retained"},
12001   {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained"},
12002   {AttributeCommonInfo::AS_C23, "clang::os_returns_retained"},
12003 };
12004 struct ParsedAttrInfoOSReturnsRetained final : public ParsedAttrInfo {
12005   constexpr ParsedAttrInfoOSReturnsRetained() : ParsedAttrInfo(
12006     /*AttrKind=*/ParsedAttr::AT_OSReturnsRetained,
12007     /*NumArgs=*/0,
12008     /*OptArgs=*/0,
12009     /*NumArgMembers=*/0,
12010     /*HasCustomParsing=*/0,
12011     /*AcceptsExprPack=*/0,
12012     /*IsTargetSpecific=*/0,
12013     /*IsType=*/0,
12014     /*IsStmt=*/0,
12015     /*IsKnownToGCC=*/0,
12016     /*IsSupportedByPragmaAttribute=*/1,
12017     /*Spellings=*/OSReturnsRetainedSpellings,
12018     /*ArgNames=*/{}) {}
12019 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12020   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D) && !isa<ParmVarDecl>(D)) {
12021     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
12022       << Attr << Attr.isRegularKeywordAttribute() << "functions, Objective-C methods, Objective-C properties, and parameters";
12023     return false;
12024   }
12025   return true;
12026 }
12027 
12028 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12029   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12030     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12031   return false;
12032 }
12033 
12034 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12035   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
12036   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
12037   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
12038   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
12039 }
12040 
12041 bool isParamExpr(size_t N) const override {
12042   return false;
12043 }
12044 
12045 static const ParsedAttrInfoOSReturnsRetained Instance;
12046 };
12047 const ParsedAttrInfoOSReturnsRetained ParsedAttrInfoOSReturnsRetained::Instance;
12048 static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedOnNonZeroSpellings[] = {
12049   {AttributeCommonInfo::AS_GNU, "os_returns_retained_on_non_zero"},
12050   {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained_on_non_zero"},
12051   {AttributeCommonInfo::AS_C23, "clang::os_returns_retained_on_non_zero"},
12052 };
12053 struct ParsedAttrInfoOSReturnsRetainedOnNonZero final : public ParsedAttrInfo {
12054   constexpr ParsedAttrInfoOSReturnsRetainedOnNonZero() : ParsedAttrInfo(
12055     /*AttrKind=*/ParsedAttr::AT_OSReturnsRetainedOnNonZero,
12056     /*NumArgs=*/0,
12057     /*OptArgs=*/0,
12058     /*NumArgMembers=*/0,
12059     /*HasCustomParsing=*/0,
12060     /*AcceptsExprPack=*/0,
12061     /*IsTargetSpecific=*/0,
12062     /*IsType=*/0,
12063     /*IsStmt=*/0,
12064     /*IsKnownToGCC=*/0,
12065     /*IsSupportedByPragmaAttribute=*/1,
12066     /*Spellings=*/OSReturnsRetainedOnNonZeroSpellings,
12067     /*ArgNames=*/{}) {}
12068 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12069   if (!isa<ParmVarDecl>(D)) {
12070     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
12071       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
12072     return false;
12073   }
12074   return true;
12075 }
12076 
12077 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12078   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12079     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12080   return false;
12081 }
12082 
12083 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12084   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
12085 }
12086 
12087 bool isParamExpr(size_t N) const override {
12088   return false;
12089 }
12090 
12091 static const ParsedAttrInfoOSReturnsRetainedOnNonZero Instance;
12092 };
12093 const ParsedAttrInfoOSReturnsRetainedOnNonZero ParsedAttrInfoOSReturnsRetainedOnNonZero::Instance;
12094 static constexpr ParsedAttrInfo::Spelling OSReturnsRetainedOnZeroSpellings[] = {
12095   {AttributeCommonInfo::AS_GNU, "os_returns_retained_on_zero"},
12096   {AttributeCommonInfo::AS_CXX11, "clang::os_returns_retained_on_zero"},
12097   {AttributeCommonInfo::AS_C23, "clang::os_returns_retained_on_zero"},
12098 };
12099 struct ParsedAttrInfoOSReturnsRetainedOnZero final : public ParsedAttrInfo {
12100   constexpr ParsedAttrInfoOSReturnsRetainedOnZero() : ParsedAttrInfo(
12101     /*AttrKind=*/ParsedAttr::AT_OSReturnsRetainedOnZero,
12102     /*NumArgs=*/0,
12103     /*OptArgs=*/0,
12104     /*NumArgMembers=*/0,
12105     /*HasCustomParsing=*/0,
12106     /*AcceptsExprPack=*/0,
12107     /*IsTargetSpecific=*/0,
12108     /*IsType=*/0,
12109     /*IsStmt=*/0,
12110     /*IsKnownToGCC=*/0,
12111     /*IsSupportedByPragmaAttribute=*/1,
12112     /*Spellings=*/OSReturnsRetainedOnZeroSpellings,
12113     /*ArgNames=*/{}) {}
12114 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12115   if (!isa<ParmVarDecl>(D)) {
12116     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
12117       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
12118     return false;
12119   }
12120   return true;
12121 }
12122 
12123 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12124   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12125     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12126   return false;
12127 }
12128 
12129 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12130   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
12131 }
12132 
12133 bool isParamExpr(size_t N) const override {
12134   return false;
12135 }
12136 
12137 static const ParsedAttrInfoOSReturnsRetainedOnZero Instance;
12138 };
12139 const ParsedAttrInfoOSReturnsRetainedOnZero ParsedAttrInfoOSReturnsRetainedOnZero::Instance;
12140 static constexpr ParsedAttrInfo::Spelling ObjCBoxableSpellings[] = {
12141   {AttributeCommonInfo::AS_GNU, "objc_boxable"},
12142   {AttributeCommonInfo::AS_CXX11, "clang::objc_boxable"},
12143   {AttributeCommonInfo::AS_C23, "clang::objc_boxable"},
12144 };
12145 struct ParsedAttrInfoObjCBoxable final : public ParsedAttrInfo {
12146   constexpr ParsedAttrInfoObjCBoxable() : ParsedAttrInfo(
12147     /*AttrKind=*/ParsedAttr::AT_ObjCBoxable,
12148     /*NumArgs=*/0,
12149     /*OptArgs=*/0,
12150     /*NumArgMembers=*/0,
12151     /*HasCustomParsing=*/0,
12152     /*AcceptsExprPack=*/0,
12153     /*IsTargetSpecific=*/0,
12154     /*IsType=*/0,
12155     /*IsStmt=*/0,
12156     /*IsKnownToGCC=*/0,
12157     /*IsSupportedByPragmaAttribute=*/1,
12158     /*Spellings=*/ObjCBoxableSpellings,
12159     /*ArgNames=*/{}) {}
12160 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12161   if (!isa<RecordDecl>(D)) {
12162     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12163       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
12164     return false;
12165   }
12166   return true;
12167 }
12168 
12169 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12170   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12171     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12172   return false;
12173 }
12174 
12175 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12176   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
12177 }
12178 
12179 bool isParamExpr(size_t N) const override {
12180   return false;
12181 }
12182 
12183 static const ParsedAttrInfoObjCBoxable Instance;
12184 };
12185 const ParsedAttrInfoObjCBoxable ParsedAttrInfoObjCBoxable::Instance;
12186 static constexpr ParsedAttrInfo::Spelling ObjCBridgeSpellings[] = {
12187   {AttributeCommonInfo::AS_GNU, "objc_bridge"},
12188   {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge"},
12189   {AttributeCommonInfo::AS_C23, "clang::objc_bridge"},
12190 };
12191 static constexpr const char *ObjCBridgeArgNames[] = {
12192 "BridgedType",};
12193 struct ParsedAttrInfoObjCBridge final : public ParsedAttrInfo {
12194   constexpr ParsedAttrInfoObjCBridge() : ParsedAttrInfo(
12195     /*AttrKind=*/ParsedAttr::AT_ObjCBridge,
12196     /*NumArgs=*/1,
12197     /*OptArgs=*/0,
12198     /*NumArgMembers=*/1,
12199     /*HasCustomParsing=*/0,
12200     /*AcceptsExprPack=*/0,
12201     /*IsTargetSpecific=*/0,
12202     /*IsType=*/0,
12203     /*IsStmt=*/0,
12204     /*IsKnownToGCC=*/0,
12205     /*IsSupportedByPragmaAttribute=*/1,
12206     /*Spellings=*/ObjCBridgeSpellings,
12207     /*ArgNames=*/ObjCBridgeArgNames) {}
12208 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12209   if (!isa<RecordDecl>(D) && !isa<TypedefNameDecl>(D)) {
12210     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12211       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and typedefs";
12212     return false;
12213   }
12214   return true;
12215 }
12216 
12217 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12218   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12219     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12220   return false;
12221 }
12222 
12223 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12224   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
12225   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
12226 }
12227 
12228 bool isParamExpr(size_t N) const override {
12229   return false;
12230 }
12231 
12232 static const ParsedAttrInfoObjCBridge Instance;
12233 };
12234 const ParsedAttrInfoObjCBridge ParsedAttrInfoObjCBridge::Instance;
12235 static constexpr ParsedAttrInfo::Spelling ObjCBridgeMutableSpellings[] = {
12236   {AttributeCommonInfo::AS_GNU, "objc_bridge_mutable"},
12237   {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge_mutable"},
12238   {AttributeCommonInfo::AS_C23, "clang::objc_bridge_mutable"},
12239 };
12240 static constexpr const char *ObjCBridgeMutableArgNames[] = {
12241 "BridgedType",};
12242 struct ParsedAttrInfoObjCBridgeMutable final : public ParsedAttrInfo {
12243   constexpr ParsedAttrInfoObjCBridgeMutable() : ParsedAttrInfo(
12244     /*AttrKind=*/ParsedAttr::AT_ObjCBridgeMutable,
12245     /*NumArgs=*/1,
12246     /*OptArgs=*/0,
12247     /*NumArgMembers=*/1,
12248     /*HasCustomParsing=*/0,
12249     /*AcceptsExprPack=*/0,
12250     /*IsTargetSpecific=*/0,
12251     /*IsType=*/0,
12252     /*IsStmt=*/0,
12253     /*IsKnownToGCC=*/0,
12254     /*IsSupportedByPragmaAttribute=*/1,
12255     /*Spellings=*/ObjCBridgeMutableSpellings,
12256     /*ArgNames=*/ObjCBridgeMutableArgNames) {}
12257 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12258   if (!isa<RecordDecl>(D)) {
12259     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12260       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
12261     return false;
12262   }
12263   return true;
12264 }
12265 
12266 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12267   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12268     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12269   return false;
12270 }
12271 
12272 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12273   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
12274 }
12275 
12276 bool isParamExpr(size_t N) const override {
12277   return false;
12278 }
12279 
12280 static const ParsedAttrInfoObjCBridgeMutable Instance;
12281 };
12282 const ParsedAttrInfoObjCBridgeMutable ParsedAttrInfoObjCBridgeMutable::Instance;
12283 static constexpr ParsedAttrInfo::Spelling ObjCBridgeRelatedSpellings[] = {
12284   {AttributeCommonInfo::AS_GNU, "objc_bridge_related"},
12285   {AttributeCommonInfo::AS_CXX11, "clang::objc_bridge_related"},
12286   {AttributeCommonInfo::AS_C23, "clang::objc_bridge_related"},
12287 };
12288 static constexpr const char *ObjCBridgeRelatedArgNames[] = {
12289 "RelatedClass","ClassMethod","InstanceMethod",};
12290 struct ParsedAttrInfoObjCBridgeRelated final : public ParsedAttrInfo {
12291   constexpr ParsedAttrInfoObjCBridgeRelated() : ParsedAttrInfo(
12292     /*AttrKind=*/ParsedAttr::AT_ObjCBridgeRelated,
12293     /*NumArgs=*/3,
12294     /*OptArgs=*/0,
12295     /*NumArgMembers=*/3,
12296     /*HasCustomParsing=*/1,
12297     /*AcceptsExprPack=*/0,
12298     /*IsTargetSpecific=*/0,
12299     /*IsType=*/0,
12300     /*IsStmt=*/0,
12301     /*IsKnownToGCC=*/0,
12302     /*IsSupportedByPragmaAttribute=*/1,
12303     /*Spellings=*/ObjCBridgeRelatedSpellings,
12304     /*ArgNames=*/ObjCBridgeRelatedArgNames) {}
12305 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12306   if (!isa<RecordDecl>(D)) {
12307     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12308       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
12309     return false;
12310   }
12311   return true;
12312 }
12313 
12314 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12315   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12316     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12317   return false;
12318 }
12319 
12320 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12321   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
12322 }
12323 
12324 bool isParamExpr(size_t N) const override {
12325   return false;
12326 }
12327 
12328 static const ParsedAttrInfoObjCBridgeRelated Instance;
12329 };
12330 const ParsedAttrInfoObjCBridgeRelated ParsedAttrInfoObjCBridgeRelated::Instance;
12331 static constexpr ParsedAttrInfo::Spelling ObjCClassStubSpellings[] = {
12332   {AttributeCommonInfo::AS_GNU, "objc_class_stub"},
12333   {AttributeCommonInfo::AS_CXX11, "clang::objc_class_stub"},
12334   {AttributeCommonInfo::AS_C23, "clang::objc_class_stub"},
12335 };
12336 struct ParsedAttrInfoObjCClassStub final : public ParsedAttrInfo {
12337   constexpr ParsedAttrInfoObjCClassStub() : ParsedAttrInfo(
12338     /*AttrKind=*/ParsedAttr::AT_ObjCClassStub,
12339     /*NumArgs=*/0,
12340     /*OptArgs=*/0,
12341     /*NumArgMembers=*/0,
12342     /*HasCustomParsing=*/0,
12343     /*AcceptsExprPack=*/0,
12344     /*IsTargetSpecific=*/0,
12345     /*IsType=*/0,
12346     /*IsStmt=*/0,
12347     /*IsKnownToGCC=*/0,
12348     /*IsSupportedByPragmaAttribute=*/1,
12349     /*Spellings=*/ObjCClassStubSpellings,
12350     /*ArgNames=*/{}) {}
12351 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12352   if (!isa<ObjCInterfaceDecl>(D)) {
12353     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12354       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
12355     return false;
12356   }
12357   return true;
12358 }
12359 
12360 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12361   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12362     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12363   return false;
12364 }
12365 
12366 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12367   return (LangOpts.ObjCRuntime.allowsClassStubs());
12368 }
12369 
12370 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12371   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
12372 }
12373 
12374 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
12375   D->addAttr(::new (S.Context) ObjCClassStubAttr(S.Context, Attr));
12376   return AttributeApplied;
12377 }
12378 
12379 bool isParamExpr(size_t N) const override {
12380   return false;
12381 }
12382 
12383 static const ParsedAttrInfoObjCClassStub Instance;
12384 };
12385 const ParsedAttrInfoObjCClassStub ParsedAttrInfoObjCClassStub::Instance;
12386 static constexpr ParsedAttrInfo::Spelling ObjCDesignatedInitializerSpellings[] = {
12387   {AttributeCommonInfo::AS_GNU, "objc_designated_initializer"},
12388   {AttributeCommonInfo::AS_CXX11, "clang::objc_designated_initializer"},
12389   {AttributeCommonInfo::AS_C23, "clang::objc_designated_initializer"},
12390 };
12391 struct ParsedAttrInfoObjCDesignatedInitializer final : public ParsedAttrInfo {
12392   constexpr ParsedAttrInfoObjCDesignatedInitializer() : ParsedAttrInfo(
12393     /*AttrKind=*/ParsedAttr::AT_ObjCDesignatedInitializer,
12394     /*NumArgs=*/0,
12395     /*OptArgs=*/0,
12396     /*NumArgMembers=*/0,
12397     /*HasCustomParsing=*/0,
12398     /*AcceptsExprPack=*/0,
12399     /*IsTargetSpecific=*/0,
12400     /*IsType=*/0,
12401     /*IsStmt=*/0,
12402     /*IsKnownToGCC=*/0,
12403     /*IsSupportedByPragmaAttribute=*/1,
12404     /*Spellings=*/ObjCDesignatedInitializerSpellings,
12405     /*ArgNames=*/{}) {}
12406 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12407   if (!isa<ObjCMethodDecl>(D)) {
12408     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12409       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods";
12410     return false;
12411   }
12412   return true;
12413 }
12414 
12415 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12416   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12417     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12418   return false;
12419 }
12420 
12421 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12422   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
12423 }
12424 
12425 bool isParamExpr(size_t N) const override {
12426   return false;
12427 }
12428 
12429 static const ParsedAttrInfoObjCDesignatedInitializer Instance;
12430 };
12431 const ParsedAttrInfoObjCDesignatedInitializer ParsedAttrInfoObjCDesignatedInitializer::Instance;
12432 static constexpr ParsedAttrInfo::Spelling ObjCDirectSpellings[] = {
12433   {AttributeCommonInfo::AS_GNU, "objc_direct"},
12434   {AttributeCommonInfo::AS_CXX11, "clang::objc_direct"},
12435   {AttributeCommonInfo::AS_C23, "clang::objc_direct"},
12436 };
12437 struct ParsedAttrInfoObjCDirect final : public ParsedAttrInfo {
12438   constexpr ParsedAttrInfoObjCDirect() : ParsedAttrInfo(
12439     /*AttrKind=*/ParsedAttr::AT_ObjCDirect,
12440     /*NumArgs=*/0,
12441     /*OptArgs=*/0,
12442     /*NumArgMembers=*/0,
12443     /*HasCustomParsing=*/0,
12444     /*AcceptsExprPack=*/0,
12445     /*IsTargetSpecific=*/0,
12446     /*IsType=*/0,
12447     /*IsStmt=*/0,
12448     /*IsKnownToGCC=*/0,
12449     /*IsSupportedByPragmaAttribute=*/1,
12450     /*Spellings=*/ObjCDirectSpellings,
12451     /*ArgNames=*/{}) {}
12452 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12453   if (!isa<ObjCMethodDecl>(D)) {
12454     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12455       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods";
12456     return false;
12457   }
12458   return true;
12459 }
12460 
12461 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12462   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12463     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12464   return false;
12465 }
12466 
12467 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12468   return LangOpts.ObjC;
12469 }
12470 
12471 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12472   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
12473 }
12474 
12475 bool isParamExpr(size_t N) const override {
12476   return false;
12477 }
12478 
12479 static const ParsedAttrInfoObjCDirect Instance;
12480 };
12481 const ParsedAttrInfoObjCDirect ParsedAttrInfoObjCDirect::Instance;
12482 static constexpr ParsedAttrInfo::Spelling ObjCDirectMembersSpellings[] = {
12483   {AttributeCommonInfo::AS_GNU, "objc_direct_members"},
12484   {AttributeCommonInfo::AS_CXX11, "clang::objc_direct_members"},
12485   {AttributeCommonInfo::AS_C23, "clang::objc_direct_members"},
12486 };
12487 struct ParsedAttrInfoObjCDirectMembers final : public ParsedAttrInfo {
12488   constexpr ParsedAttrInfoObjCDirectMembers() : ParsedAttrInfo(
12489     /*AttrKind=*/ParsedAttr::AT_ObjCDirectMembers,
12490     /*NumArgs=*/0,
12491     /*OptArgs=*/0,
12492     /*NumArgMembers=*/0,
12493     /*HasCustomParsing=*/0,
12494     /*AcceptsExprPack=*/0,
12495     /*IsTargetSpecific=*/0,
12496     /*IsType=*/0,
12497     /*IsStmt=*/0,
12498     /*IsKnownToGCC=*/0,
12499     /*IsSupportedByPragmaAttribute=*/1,
12500     /*Spellings=*/ObjCDirectMembersSpellings,
12501     /*ArgNames=*/{}) {}
12502 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12503   if (!isa<ObjCImplDecl>(D) && !isa<ObjCInterfaceDecl>(D) && !isa<ObjCCategoryDecl>(D)) {
12504     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12505       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C implementation declarations, Objective-C interfaces, and Objective-C containers";
12506     return false;
12507   }
12508   return true;
12509 }
12510 
12511 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12512   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12513     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12514   return false;
12515 }
12516 
12517 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12518   return LangOpts.ObjC;
12519 }
12520 
12521 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12522   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /*IsSupported=*/LangOpts.ObjC));
12523   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
12524   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_category, /*IsSupported=*/LangOpts.ObjC));
12525 }
12526 
12527 bool isParamExpr(size_t N) const override {
12528   return false;
12529 }
12530 
12531 static const ParsedAttrInfoObjCDirectMembers Instance;
12532 };
12533 const ParsedAttrInfoObjCDirectMembers ParsedAttrInfoObjCDirectMembers::Instance;
12534 static constexpr ParsedAttrInfo::Spelling ObjCExceptionSpellings[] = {
12535   {AttributeCommonInfo::AS_GNU, "objc_exception"},
12536   {AttributeCommonInfo::AS_CXX11, "clang::objc_exception"},
12537   {AttributeCommonInfo::AS_C23, "clang::objc_exception"},
12538 };
12539 struct ParsedAttrInfoObjCException final : public ParsedAttrInfo {
12540   constexpr ParsedAttrInfoObjCException() : ParsedAttrInfo(
12541     /*AttrKind=*/ParsedAttr::AT_ObjCException,
12542     /*NumArgs=*/0,
12543     /*OptArgs=*/0,
12544     /*NumArgMembers=*/0,
12545     /*HasCustomParsing=*/0,
12546     /*AcceptsExprPack=*/0,
12547     /*IsTargetSpecific=*/0,
12548     /*IsType=*/0,
12549     /*IsStmt=*/0,
12550     /*IsKnownToGCC=*/0,
12551     /*IsSupportedByPragmaAttribute=*/1,
12552     /*Spellings=*/ObjCExceptionSpellings,
12553     /*ArgNames=*/{}) {}
12554 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12555   if (!isa<ObjCInterfaceDecl>(D)) {
12556     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12557       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
12558     return false;
12559   }
12560   return true;
12561 }
12562 
12563 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12564   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12565     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12566   return false;
12567 }
12568 
12569 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12570   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
12571 }
12572 
12573 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
12574   D->addAttr(::new (S.Context) ObjCExceptionAttr(S.Context, Attr));
12575   return AttributeApplied;
12576 }
12577 
12578 bool isParamExpr(size_t N) const override {
12579   return false;
12580 }
12581 
12582 static const ParsedAttrInfoObjCException Instance;
12583 };
12584 const ParsedAttrInfoObjCException ParsedAttrInfoObjCException::Instance;
12585 static constexpr ParsedAttrInfo::Spelling ObjCExplicitProtocolImplSpellings[] = {
12586   {AttributeCommonInfo::AS_GNU, "objc_protocol_requires_explicit_implementation"},
12587   {AttributeCommonInfo::AS_CXX11, "clang::objc_protocol_requires_explicit_implementation"},
12588   {AttributeCommonInfo::AS_C23, "clang::objc_protocol_requires_explicit_implementation"},
12589 };
12590 struct ParsedAttrInfoObjCExplicitProtocolImpl final : public ParsedAttrInfo {
12591   constexpr ParsedAttrInfoObjCExplicitProtocolImpl() : ParsedAttrInfo(
12592     /*AttrKind=*/ParsedAttr::AT_ObjCExplicitProtocolImpl,
12593     /*NumArgs=*/0,
12594     /*OptArgs=*/0,
12595     /*NumArgMembers=*/0,
12596     /*HasCustomParsing=*/0,
12597     /*AcceptsExprPack=*/0,
12598     /*IsTargetSpecific=*/0,
12599     /*IsType=*/0,
12600     /*IsStmt=*/0,
12601     /*IsKnownToGCC=*/0,
12602     /*IsSupportedByPragmaAttribute=*/1,
12603     /*Spellings=*/ObjCExplicitProtocolImplSpellings,
12604     /*ArgNames=*/{}) {}
12605 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12606   if (!isa<ObjCProtocolDecl>(D)) {
12607     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12608       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C protocols";
12609     return false;
12610   }
12611   return true;
12612 }
12613 
12614 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12615   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12616     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12617   return false;
12618 }
12619 
12620 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12621   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC));
12622 }
12623 
12624 bool isParamExpr(size_t N) const override {
12625   return false;
12626 }
12627 
12628 static const ParsedAttrInfoObjCExplicitProtocolImpl Instance;
12629 };
12630 const ParsedAttrInfoObjCExplicitProtocolImpl ParsedAttrInfoObjCExplicitProtocolImpl::Instance;
12631 static constexpr ParsedAttrInfo::Spelling ObjCExternallyRetainedSpellings[] = {
12632   {AttributeCommonInfo::AS_GNU, "objc_externally_retained"},
12633   {AttributeCommonInfo::AS_CXX11, "clang::objc_externally_retained"},
12634   {AttributeCommonInfo::AS_C23, "clang::objc_externally_retained"},
12635 };
12636 struct ParsedAttrInfoObjCExternallyRetained final : public ParsedAttrInfo {
12637   constexpr ParsedAttrInfoObjCExternallyRetained() : ParsedAttrInfo(
12638     /*AttrKind=*/ParsedAttr::AT_ObjCExternallyRetained,
12639     /*NumArgs=*/0,
12640     /*OptArgs=*/0,
12641     /*NumArgMembers=*/0,
12642     /*HasCustomParsing=*/0,
12643     /*AcceptsExprPack=*/0,
12644     /*IsTargetSpecific=*/0,
12645     /*IsType=*/0,
12646     /*IsStmt=*/0,
12647     /*IsKnownToGCC=*/0,
12648     /*IsSupportedByPragmaAttribute=*/1,
12649     /*Spellings=*/ObjCExternallyRetainedSpellings,
12650     /*ArgNames=*/{}) {}
12651 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12652   if (!isNonParmVar(D) && !isa<FunctionDecl>(D) && !isa<BlockDecl>(D) && !isa<ObjCMethodDecl>(D)) {
12653     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
12654       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, blocks, and Objective-C methods";
12655     return false;
12656   }
12657   return true;
12658 }
12659 
12660 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12661   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12662     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12663   return false;
12664 }
12665 
12666 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12667   return LangOpts.ObjCAutoRefCount;
12668 }
12669 
12670 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12671   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_not_is_parameter, /*IsSupported=*/true));
12672   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
12673   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_block, /*IsSupported=*/LangOpts.Blocks));
12674   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
12675 }
12676 
12677 bool isParamExpr(size_t N) const override {
12678   return false;
12679 }
12680 
12681 static const ParsedAttrInfoObjCExternallyRetained Instance;
12682 };
12683 const ParsedAttrInfoObjCExternallyRetained ParsedAttrInfoObjCExternallyRetained::Instance;
12684 static constexpr ParsedAttrInfo::Spelling ObjCGCSpellings[] = {
12685   {AttributeCommonInfo::AS_GNU, "objc_gc"},
12686   {AttributeCommonInfo::AS_CXX11, "clang::objc_gc"},
12687   {AttributeCommonInfo::AS_C23, "clang::objc_gc"},
12688 };
12689 static constexpr const char *ObjCGCArgNames[] = {
12690 "Kind",};
12691 struct ParsedAttrInfoObjCGC final : public ParsedAttrInfo {
12692   constexpr ParsedAttrInfoObjCGC() : ParsedAttrInfo(
12693     /*AttrKind=*/ParsedAttr::AT_ObjCGC,
12694     /*NumArgs=*/1,
12695     /*OptArgs=*/0,
12696     /*NumArgMembers=*/1,
12697     /*HasCustomParsing=*/0,
12698     /*AcceptsExprPack=*/0,
12699     /*IsTargetSpecific=*/0,
12700     /*IsType=*/1,
12701     /*IsStmt=*/0,
12702     /*IsKnownToGCC=*/0,
12703     /*IsSupportedByPragmaAttribute=*/0,
12704     /*Spellings=*/ObjCGCSpellings,
12705     /*ArgNames=*/ObjCGCArgNames) {}
12706 bool isParamExpr(size_t N) const override {
12707   return false;
12708 }
12709 
12710 static const ParsedAttrInfoObjCGC Instance;
12711 };
12712 const ParsedAttrInfoObjCGC ParsedAttrInfoObjCGC::Instance;
12713 static constexpr ParsedAttrInfo::Spelling ObjCIndependentClassSpellings[] = {
12714   {AttributeCommonInfo::AS_GNU, "objc_independent_class"},
12715   {AttributeCommonInfo::AS_CXX11, "clang::objc_independent_class"},
12716   {AttributeCommonInfo::AS_C23, "clang::objc_independent_class"},
12717 };
12718 struct ParsedAttrInfoObjCIndependentClass final : public ParsedAttrInfo {
12719   constexpr ParsedAttrInfoObjCIndependentClass() : ParsedAttrInfo(
12720     /*AttrKind=*/ParsedAttr::AT_ObjCIndependentClass,
12721     /*NumArgs=*/0,
12722     /*OptArgs=*/0,
12723     /*NumArgMembers=*/0,
12724     /*HasCustomParsing=*/0,
12725     /*AcceptsExprPack=*/0,
12726     /*IsTargetSpecific=*/0,
12727     /*IsType=*/0,
12728     /*IsStmt=*/0,
12729     /*IsKnownToGCC=*/0,
12730     /*IsSupportedByPragmaAttribute=*/0,
12731     /*Spellings=*/ObjCIndependentClassSpellings,
12732     /*ArgNames=*/{}) {}
12733 bool isParamExpr(size_t N) const override {
12734   return false;
12735 }
12736 
12737 static const ParsedAttrInfoObjCIndependentClass Instance;
12738 };
12739 const ParsedAttrInfoObjCIndependentClass ParsedAttrInfoObjCIndependentClass::Instance;
12740 static constexpr ParsedAttrInfo::Spelling ObjCInertUnsafeUnretainedSpellings[] = {
12741   {AttributeCommonInfo::AS_Keyword, "__unsafe_unretained"},
12742 };
12743 struct ParsedAttrInfoObjCInertUnsafeUnretained final : public ParsedAttrInfo {
12744   constexpr ParsedAttrInfoObjCInertUnsafeUnretained() : ParsedAttrInfo(
12745     /*AttrKind=*/ParsedAttr::AT_ObjCInertUnsafeUnretained,
12746     /*NumArgs=*/0,
12747     /*OptArgs=*/0,
12748     /*NumArgMembers=*/0,
12749     /*HasCustomParsing=*/0,
12750     /*AcceptsExprPack=*/0,
12751     /*IsTargetSpecific=*/0,
12752     /*IsType=*/1,
12753     /*IsStmt=*/0,
12754     /*IsKnownToGCC=*/0,
12755     /*IsSupportedByPragmaAttribute=*/0,
12756     /*Spellings=*/ObjCInertUnsafeUnretainedSpellings,
12757     /*ArgNames=*/{}) {}
12758 bool isParamExpr(size_t N) const override {
12759   return false;
12760 }
12761 
12762 static const ParsedAttrInfoObjCInertUnsafeUnretained Instance;
12763 };
12764 const ParsedAttrInfoObjCInertUnsafeUnretained ParsedAttrInfoObjCInertUnsafeUnretained::Instance;
12765 static constexpr ParsedAttrInfo::Spelling ObjCKindOfSpellings[] = {
12766   {AttributeCommonInfo::AS_Keyword, "__kindof"},
12767 };
12768 struct ParsedAttrInfoObjCKindOf final : public ParsedAttrInfo {
12769   constexpr ParsedAttrInfoObjCKindOf() : ParsedAttrInfo(
12770     /*AttrKind=*/ParsedAttr::AT_ObjCKindOf,
12771     /*NumArgs=*/0,
12772     /*OptArgs=*/0,
12773     /*NumArgMembers=*/0,
12774     /*HasCustomParsing=*/0,
12775     /*AcceptsExprPack=*/0,
12776     /*IsTargetSpecific=*/0,
12777     /*IsType=*/1,
12778     /*IsStmt=*/0,
12779     /*IsKnownToGCC=*/0,
12780     /*IsSupportedByPragmaAttribute=*/0,
12781     /*Spellings=*/ObjCKindOfSpellings,
12782     /*ArgNames=*/{}) {}
12783 bool isParamExpr(size_t N) const override {
12784   return false;
12785 }
12786 
12787 static const ParsedAttrInfoObjCKindOf Instance;
12788 };
12789 const ParsedAttrInfoObjCKindOf ParsedAttrInfoObjCKindOf::Instance;
12790 static constexpr ParsedAttrInfo::Spelling ObjCMethodFamilySpellings[] = {
12791   {AttributeCommonInfo::AS_GNU, "objc_method_family"},
12792   {AttributeCommonInfo::AS_CXX11, "clang::objc_method_family"},
12793   {AttributeCommonInfo::AS_C23, "clang::objc_method_family"},
12794 };
12795 static constexpr const char *ObjCMethodFamilyArgNames[] = {
12796 "Family",};
12797 struct ParsedAttrInfoObjCMethodFamily final : public ParsedAttrInfo {
12798   constexpr ParsedAttrInfoObjCMethodFamily() : ParsedAttrInfo(
12799     /*AttrKind=*/ParsedAttr::AT_ObjCMethodFamily,
12800     /*NumArgs=*/1,
12801     /*OptArgs=*/0,
12802     /*NumArgMembers=*/1,
12803     /*HasCustomParsing=*/0,
12804     /*AcceptsExprPack=*/0,
12805     /*IsTargetSpecific=*/0,
12806     /*IsType=*/0,
12807     /*IsStmt=*/0,
12808     /*IsKnownToGCC=*/0,
12809     /*IsSupportedByPragmaAttribute=*/1,
12810     /*Spellings=*/ObjCMethodFamilySpellings,
12811     /*ArgNames=*/ObjCMethodFamilyArgNames) {}
12812 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12813   if (!isa<ObjCMethodDecl>(D)) {
12814     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12815       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods";
12816     return false;
12817   }
12818   return true;
12819 }
12820 
12821 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12822   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12823     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12824   return false;
12825 }
12826 
12827 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12828   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
12829 }
12830 
12831 bool isParamExpr(size_t N) const override {
12832   return false;
12833 }
12834 
12835 static const ParsedAttrInfoObjCMethodFamily Instance;
12836 };
12837 const ParsedAttrInfoObjCMethodFamily ParsedAttrInfoObjCMethodFamily::Instance;
12838 static constexpr ParsedAttrInfo::Spelling ObjCNSObjectSpellings[] = {
12839   {AttributeCommonInfo::AS_GNU, "NSObject"},
12840   {AttributeCommonInfo::AS_CXX11, "clang::NSObject"},
12841   {AttributeCommonInfo::AS_C23, "clang::NSObject"},
12842 };
12843 struct ParsedAttrInfoObjCNSObject final : public ParsedAttrInfo {
12844   constexpr ParsedAttrInfoObjCNSObject() : ParsedAttrInfo(
12845     /*AttrKind=*/ParsedAttr::AT_ObjCNSObject,
12846     /*NumArgs=*/0,
12847     /*OptArgs=*/0,
12848     /*NumArgMembers=*/0,
12849     /*HasCustomParsing=*/0,
12850     /*AcceptsExprPack=*/0,
12851     /*IsTargetSpecific=*/0,
12852     /*IsType=*/0,
12853     /*IsStmt=*/0,
12854     /*IsKnownToGCC=*/0,
12855     /*IsSupportedByPragmaAttribute=*/0,
12856     /*Spellings=*/ObjCNSObjectSpellings,
12857     /*ArgNames=*/{}) {}
12858 bool isParamExpr(size_t N) const override {
12859   return false;
12860 }
12861 
12862 static const ParsedAttrInfoObjCNSObject Instance;
12863 };
12864 const ParsedAttrInfoObjCNSObject ParsedAttrInfoObjCNSObject::Instance;
12865 static constexpr ParsedAttrInfo::Spelling ObjCNonLazyClassSpellings[] = {
12866   {AttributeCommonInfo::AS_GNU, "objc_nonlazy_class"},
12867   {AttributeCommonInfo::AS_CXX11, "clang::objc_nonlazy_class"},
12868   {AttributeCommonInfo::AS_C23, "clang::objc_nonlazy_class"},
12869 };
12870 struct ParsedAttrInfoObjCNonLazyClass final : public ParsedAttrInfo {
12871   constexpr ParsedAttrInfoObjCNonLazyClass() : ParsedAttrInfo(
12872     /*AttrKind=*/ParsedAttr::AT_ObjCNonLazyClass,
12873     /*NumArgs=*/0,
12874     /*OptArgs=*/0,
12875     /*NumArgMembers=*/0,
12876     /*HasCustomParsing=*/0,
12877     /*AcceptsExprPack=*/0,
12878     /*IsTargetSpecific=*/0,
12879     /*IsType=*/0,
12880     /*IsStmt=*/0,
12881     /*IsKnownToGCC=*/0,
12882     /*IsSupportedByPragmaAttribute=*/1,
12883     /*Spellings=*/ObjCNonLazyClassSpellings,
12884     /*ArgNames=*/{}) {}
12885 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12886   if (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCImplDecl>(D)) {
12887     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12888       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces and Objective-C implementation declarations";
12889     return false;
12890   }
12891   return true;
12892 }
12893 
12894 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12895   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12896     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12897   return false;
12898 }
12899 
12900 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12901   return LangOpts.ObjC;
12902 }
12903 
12904 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12905   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
12906   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_implementation, /*IsSupported=*/LangOpts.ObjC));
12907 }
12908 
12909 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
12910   D->addAttr(::new (S.Context) ObjCNonLazyClassAttr(S.Context, Attr));
12911   return AttributeApplied;
12912 }
12913 
12914 bool isParamExpr(size_t N) const override {
12915   return false;
12916 }
12917 
12918 static const ParsedAttrInfoObjCNonLazyClass Instance;
12919 };
12920 const ParsedAttrInfoObjCNonLazyClass ParsedAttrInfoObjCNonLazyClass::Instance;
12921 static constexpr ParsedAttrInfo::Spelling ObjCNonRuntimeProtocolSpellings[] = {
12922   {AttributeCommonInfo::AS_GNU, "objc_non_runtime_protocol"},
12923   {AttributeCommonInfo::AS_CXX11, "clang::objc_non_runtime_protocol"},
12924   {AttributeCommonInfo::AS_C23, "clang::objc_non_runtime_protocol"},
12925 };
12926 struct ParsedAttrInfoObjCNonRuntimeProtocol final : public ParsedAttrInfo {
12927   constexpr ParsedAttrInfoObjCNonRuntimeProtocol() : ParsedAttrInfo(
12928     /*AttrKind=*/ParsedAttr::AT_ObjCNonRuntimeProtocol,
12929     /*NumArgs=*/0,
12930     /*OptArgs=*/0,
12931     /*NumArgMembers=*/0,
12932     /*HasCustomParsing=*/0,
12933     /*AcceptsExprPack=*/0,
12934     /*IsTargetSpecific=*/0,
12935     /*IsType=*/0,
12936     /*IsStmt=*/0,
12937     /*IsKnownToGCC=*/0,
12938     /*IsSupportedByPragmaAttribute=*/1,
12939     /*Spellings=*/ObjCNonRuntimeProtocolSpellings,
12940     /*ArgNames=*/{}) {}
12941 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
12942   if (!isa<ObjCProtocolDecl>(D)) {
12943     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
12944       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C protocols";
12945     return false;
12946   }
12947   return true;
12948 }
12949 
12950 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
12951   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
12952     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
12953   return false;
12954 }
12955 
12956 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
12957   return LangOpts.ObjC;
12958 }
12959 
12960 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
12961   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC));
12962 }
12963 
12964 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
12965   D->addAttr(::new (S.Context) ObjCNonRuntimeProtocolAttr(S.Context, Attr));
12966   return AttributeApplied;
12967 }
12968 
12969 bool isParamExpr(size_t N) const override {
12970   return false;
12971 }
12972 
12973 static const ParsedAttrInfoObjCNonRuntimeProtocol Instance;
12974 };
12975 const ParsedAttrInfoObjCNonRuntimeProtocol ParsedAttrInfoObjCNonRuntimeProtocol::Instance;
12976 static constexpr ParsedAttrInfo::Spelling ObjCOwnershipSpellings[] = {
12977   {AttributeCommonInfo::AS_GNU, "objc_ownership"},
12978   {AttributeCommonInfo::AS_CXX11, "clang::objc_ownership"},
12979   {AttributeCommonInfo::AS_C23, "clang::objc_ownership"},
12980 };
12981 static constexpr const char *ObjCOwnershipArgNames[] = {
12982 "Kind",};
12983 struct ParsedAttrInfoObjCOwnership final : public ParsedAttrInfo {
12984   constexpr ParsedAttrInfoObjCOwnership() : ParsedAttrInfo(
12985     /*AttrKind=*/ParsedAttr::AT_ObjCOwnership,
12986     /*NumArgs=*/1,
12987     /*OptArgs=*/0,
12988     /*NumArgMembers=*/1,
12989     /*HasCustomParsing=*/0,
12990     /*AcceptsExprPack=*/0,
12991     /*IsTargetSpecific=*/0,
12992     /*IsType=*/1,
12993     /*IsStmt=*/0,
12994     /*IsKnownToGCC=*/0,
12995     /*IsSupportedByPragmaAttribute=*/0,
12996     /*Spellings=*/ObjCOwnershipSpellings,
12997     /*ArgNames=*/ObjCOwnershipArgNames) {}
12998 bool isParamExpr(size_t N) const override {
12999   return false;
13000 }
13001 
13002 static const ParsedAttrInfoObjCOwnership Instance;
13003 };
13004 const ParsedAttrInfoObjCOwnership ParsedAttrInfoObjCOwnership::Instance;
13005 static constexpr ParsedAttrInfo::Spelling ObjCPreciseLifetimeSpellings[] = {
13006   {AttributeCommonInfo::AS_GNU, "objc_precise_lifetime"},
13007   {AttributeCommonInfo::AS_CXX11, "clang::objc_precise_lifetime"},
13008   {AttributeCommonInfo::AS_C23, "clang::objc_precise_lifetime"},
13009 };
13010 struct ParsedAttrInfoObjCPreciseLifetime final : public ParsedAttrInfo {
13011   constexpr ParsedAttrInfoObjCPreciseLifetime() : ParsedAttrInfo(
13012     /*AttrKind=*/ParsedAttr::AT_ObjCPreciseLifetime,
13013     /*NumArgs=*/0,
13014     /*OptArgs=*/0,
13015     /*NumArgMembers=*/0,
13016     /*HasCustomParsing=*/0,
13017     /*AcceptsExprPack=*/0,
13018     /*IsTargetSpecific=*/0,
13019     /*IsType=*/0,
13020     /*IsStmt=*/0,
13021     /*IsKnownToGCC=*/0,
13022     /*IsSupportedByPragmaAttribute=*/1,
13023     /*Spellings=*/ObjCPreciseLifetimeSpellings,
13024     /*ArgNames=*/{}) {}
13025 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13026   if (!isa<VarDecl>(D)) {
13027     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13028       << Attr << Attr.isRegularKeywordAttribute() << "variables";
13029     return false;
13030   }
13031   return true;
13032 }
13033 
13034 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13035   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13036     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13037   return false;
13038 }
13039 
13040 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13041   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
13042 }
13043 
13044 bool isParamExpr(size_t N) const override {
13045   return false;
13046 }
13047 
13048 static const ParsedAttrInfoObjCPreciseLifetime Instance;
13049 };
13050 const ParsedAttrInfoObjCPreciseLifetime ParsedAttrInfoObjCPreciseLifetime::Instance;
13051 static constexpr ParsedAttrInfo::Spelling ObjCRequiresPropertyDefsSpellings[] = {
13052   {AttributeCommonInfo::AS_GNU, "objc_requires_property_definitions"},
13053   {AttributeCommonInfo::AS_CXX11, "clang::objc_requires_property_definitions"},
13054   {AttributeCommonInfo::AS_C23, "clang::objc_requires_property_definitions"},
13055 };
13056 struct ParsedAttrInfoObjCRequiresPropertyDefs final : public ParsedAttrInfo {
13057   constexpr ParsedAttrInfoObjCRequiresPropertyDefs() : ParsedAttrInfo(
13058     /*AttrKind=*/ParsedAttr::AT_ObjCRequiresPropertyDefs,
13059     /*NumArgs=*/0,
13060     /*OptArgs=*/0,
13061     /*NumArgMembers=*/0,
13062     /*HasCustomParsing=*/0,
13063     /*AcceptsExprPack=*/0,
13064     /*IsTargetSpecific=*/0,
13065     /*IsType=*/0,
13066     /*IsStmt=*/0,
13067     /*IsKnownToGCC=*/0,
13068     /*IsSupportedByPragmaAttribute=*/1,
13069     /*Spellings=*/ObjCRequiresPropertyDefsSpellings,
13070     /*ArgNames=*/{}) {}
13071 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13072   if (!isa<ObjCInterfaceDecl>(D)) {
13073     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13074       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
13075     return false;
13076   }
13077   return true;
13078 }
13079 
13080 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13081   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13082     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13083   return false;
13084 }
13085 
13086 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13087   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
13088 }
13089 
13090 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
13091   D->addAttr(::new (S.Context) ObjCRequiresPropertyDefsAttr(S.Context, Attr));
13092   return AttributeApplied;
13093 }
13094 
13095 bool isParamExpr(size_t N) const override {
13096   return false;
13097 }
13098 
13099 static const ParsedAttrInfoObjCRequiresPropertyDefs Instance;
13100 };
13101 const ParsedAttrInfoObjCRequiresPropertyDefs ParsedAttrInfoObjCRequiresPropertyDefs::Instance;
13102 static constexpr ParsedAttrInfo::Spelling ObjCRequiresSuperSpellings[] = {
13103   {AttributeCommonInfo::AS_GNU, "objc_requires_super"},
13104   {AttributeCommonInfo::AS_CXX11, "clang::objc_requires_super"},
13105   {AttributeCommonInfo::AS_C23, "clang::objc_requires_super"},
13106 };
13107 struct ParsedAttrInfoObjCRequiresSuper final : public ParsedAttrInfo {
13108   constexpr ParsedAttrInfoObjCRequiresSuper() : ParsedAttrInfo(
13109     /*AttrKind=*/ParsedAttr::AT_ObjCRequiresSuper,
13110     /*NumArgs=*/0,
13111     /*OptArgs=*/0,
13112     /*NumArgMembers=*/0,
13113     /*HasCustomParsing=*/0,
13114     /*AcceptsExprPack=*/0,
13115     /*IsTargetSpecific=*/0,
13116     /*IsType=*/0,
13117     /*IsStmt=*/0,
13118     /*IsKnownToGCC=*/0,
13119     /*IsSupportedByPragmaAttribute=*/1,
13120     /*Spellings=*/ObjCRequiresSuperSpellings,
13121     /*ArgNames=*/{}) {}
13122 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13123   if (!isa<ObjCMethodDecl>(D)) {
13124     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13125       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods";
13126     return false;
13127   }
13128   return true;
13129 }
13130 
13131 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13132   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13133     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13134   return false;
13135 }
13136 
13137 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13138   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
13139 }
13140 
13141 bool isParamExpr(size_t N) const override {
13142   return false;
13143 }
13144 
13145 static const ParsedAttrInfoObjCRequiresSuper Instance;
13146 };
13147 const ParsedAttrInfoObjCRequiresSuper ParsedAttrInfoObjCRequiresSuper::Instance;
13148 static constexpr ParsedAttrInfo::Spelling ObjCReturnsInnerPointerSpellings[] = {
13149   {AttributeCommonInfo::AS_GNU, "objc_returns_inner_pointer"},
13150   {AttributeCommonInfo::AS_CXX11, "clang::objc_returns_inner_pointer"},
13151   {AttributeCommonInfo::AS_C23, "clang::objc_returns_inner_pointer"},
13152 };
13153 struct ParsedAttrInfoObjCReturnsInnerPointer final : public ParsedAttrInfo {
13154   constexpr ParsedAttrInfoObjCReturnsInnerPointer() : ParsedAttrInfo(
13155     /*AttrKind=*/ParsedAttr::AT_ObjCReturnsInnerPointer,
13156     /*NumArgs=*/0,
13157     /*OptArgs=*/0,
13158     /*NumArgMembers=*/0,
13159     /*HasCustomParsing=*/0,
13160     /*AcceptsExprPack=*/0,
13161     /*IsTargetSpecific=*/0,
13162     /*IsType=*/0,
13163     /*IsStmt=*/0,
13164     /*IsKnownToGCC=*/0,
13165     /*IsSupportedByPragmaAttribute=*/1,
13166     /*Spellings=*/ObjCReturnsInnerPointerSpellings,
13167     /*ArgNames=*/{}) {}
13168 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13169   if (!isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) {
13170     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13171       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and Objective-C properties";
13172     return false;
13173   }
13174   return true;
13175 }
13176 
13177 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13178   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13179     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13180   return false;
13181 }
13182 
13183 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13184   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
13185   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
13186 }
13187 
13188 bool isParamExpr(size_t N) const override {
13189   return false;
13190 }
13191 
13192 static const ParsedAttrInfoObjCReturnsInnerPointer Instance;
13193 };
13194 const ParsedAttrInfoObjCReturnsInnerPointer ParsedAttrInfoObjCReturnsInnerPointer::Instance;
13195 static constexpr ParsedAttrInfo::Spelling ObjCRootClassSpellings[] = {
13196   {AttributeCommonInfo::AS_GNU, "objc_root_class"},
13197   {AttributeCommonInfo::AS_CXX11, "clang::objc_root_class"},
13198   {AttributeCommonInfo::AS_C23, "clang::objc_root_class"},
13199 };
13200 struct ParsedAttrInfoObjCRootClass final : public ParsedAttrInfo {
13201   constexpr ParsedAttrInfoObjCRootClass() : ParsedAttrInfo(
13202     /*AttrKind=*/ParsedAttr::AT_ObjCRootClass,
13203     /*NumArgs=*/0,
13204     /*OptArgs=*/0,
13205     /*NumArgMembers=*/0,
13206     /*HasCustomParsing=*/0,
13207     /*AcceptsExprPack=*/0,
13208     /*IsTargetSpecific=*/0,
13209     /*IsType=*/0,
13210     /*IsStmt=*/0,
13211     /*IsKnownToGCC=*/0,
13212     /*IsSupportedByPragmaAttribute=*/1,
13213     /*Spellings=*/ObjCRootClassSpellings,
13214     /*ArgNames=*/{}) {}
13215 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13216   if (!isa<ObjCInterfaceDecl>(D)) {
13217     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13218       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
13219     return false;
13220   }
13221   return true;
13222 }
13223 
13224 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13225   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13226     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13227   return false;
13228 }
13229 
13230 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13231   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
13232 }
13233 
13234 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
13235   D->addAttr(::new (S.Context) ObjCRootClassAttr(S.Context, Attr));
13236   return AttributeApplied;
13237 }
13238 
13239 bool isParamExpr(size_t N) const override {
13240   return false;
13241 }
13242 
13243 static const ParsedAttrInfoObjCRootClass Instance;
13244 };
13245 const ParsedAttrInfoObjCRootClass ParsedAttrInfoObjCRootClass::Instance;
13246 static constexpr ParsedAttrInfo::Spelling ObjCRuntimeNameSpellings[] = {
13247   {AttributeCommonInfo::AS_GNU, "objc_runtime_name"},
13248   {AttributeCommonInfo::AS_CXX11, "clang::objc_runtime_name"},
13249   {AttributeCommonInfo::AS_C23, "clang::objc_runtime_name"},
13250 };
13251 static constexpr const char *ObjCRuntimeNameArgNames[] = {
13252 "MetadataName",};
13253 struct ParsedAttrInfoObjCRuntimeName final : public ParsedAttrInfo {
13254   constexpr ParsedAttrInfoObjCRuntimeName() : ParsedAttrInfo(
13255     /*AttrKind=*/ParsedAttr::AT_ObjCRuntimeName,
13256     /*NumArgs=*/1,
13257     /*OptArgs=*/0,
13258     /*NumArgMembers=*/1,
13259     /*HasCustomParsing=*/0,
13260     /*AcceptsExprPack=*/0,
13261     /*IsTargetSpecific=*/0,
13262     /*IsType=*/0,
13263     /*IsStmt=*/0,
13264     /*IsKnownToGCC=*/0,
13265     /*IsSupportedByPragmaAttribute=*/1,
13266     /*Spellings=*/ObjCRuntimeNameSpellings,
13267     /*ArgNames=*/ObjCRuntimeNameArgNames) {}
13268 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13269   if (!isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D)) {
13270     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13271       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces and Objective-C protocols";
13272     return false;
13273   }
13274   return true;
13275 }
13276 
13277 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13278   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13279     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13280   return false;
13281 }
13282 
13283 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13284   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
13285   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_protocol, /*IsSupported=*/LangOpts.ObjC));
13286 }
13287 
13288 bool isParamExpr(size_t N) const override {
13289   return false;
13290 }
13291 
13292 static const ParsedAttrInfoObjCRuntimeName Instance;
13293 };
13294 const ParsedAttrInfoObjCRuntimeName ParsedAttrInfoObjCRuntimeName::Instance;
13295 static constexpr ParsedAttrInfo::Spelling ObjCRuntimeVisibleSpellings[] = {
13296   {AttributeCommonInfo::AS_GNU, "objc_runtime_visible"},
13297   {AttributeCommonInfo::AS_CXX11, "clang::objc_runtime_visible"},
13298   {AttributeCommonInfo::AS_C23, "clang::objc_runtime_visible"},
13299 };
13300 struct ParsedAttrInfoObjCRuntimeVisible final : public ParsedAttrInfo {
13301   constexpr ParsedAttrInfoObjCRuntimeVisible() : ParsedAttrInfo(
13302     /*AttrKind=*/ParsedAttr::AT_ObjCRuntimeVisible,
13303     /*NumArgs=*/0,
13304     /*OptArgs=*/0,
13305     /*NumArgMembers=*/0,
13306     /*HasCustomParsing=*/0,
13307     /*AcceptsExprPack=*/0,
13308     /*IsTargetSpecific=*/0,
13309     /*IsType=*/0,
13310     /*IsStmt=*/0,
13311     /*IsKnownToGCC=*/0,
13312     /*IsSupportedByPragmaAttribute=*/1,
13313     /*Spellings=*/ObjCRuntimeVisibleSpellings,
13314     /*ArgNames=*/{}) {}
13315 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13316   if (!isa<ObjCInterfaceDecl>(D)) {
13317     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13318       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
13319     return false;
13320   }
13321   return true;
13322 }
13323 
13324 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13325   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13326     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13327   return false;
13328 }
13329 
13330 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13331   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
13332 }
13333 
13334 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
13335   D->addAttr(::new (S.Context) ObjCRuntimeVisibleAttr(S.Context, Attr));
13336   return AttributeApplied;
13337 }
13338 
13339 bool isParamExpr(size_t N) const override {
13340   return false;
13341 }
13342 
13343 static const ParsedAttrInfoObjCRuntimeVisible Instance;
13344 };
13345 const ParsedAttrInfoObjCRuntimeVisible ParsedAttrInfoObjCRuntimeVisible::Instance;
13346 static constexpr ParsedAttrInfo::Spelling ObjCSubclassingRestrictedSpellings[] = {
13347   {AttributeCommonInfo::AS_GNU, "objc_subclassing_restricted"},
13348   {AttributeCommonInfo::AS_CXX11, "clang::objc_subclassing_restricted"},
13349   {AttributeCommonInfo::AS_C23, "clang::objc_subclassing_restricted"},
13350 };
13351 struct ParsedAttrInfoObjCSubclassingRestricted final : public ParsedAttrInfo {
13352   constexpr ParsedAttrInfoObjCSubclassingRestricted() : ParsedAttrInfo(
13353     /*AttrKind=*/ParsedAttr::AT_ObjCSubclassingRestricted,
13354     /*NumArgs=*/0,
13355     /*OptArgs=*/0,
13356     /*NumArgMembers=*/0,
13357     /*HasCustomParsing=*/0,
13358     /*AcceptsExprPack=*/0,
13359     /*IsTargetSpecific=*/0,
13360     /*IsType=*/0,
13361     /*IsStmt=*/0,
13362     /*IsKnownToGCC=*/0,
13363     /*IsSupportedByPragmaAttribute=*/1,
13364     /*Spellings=*/ObjCSubclassingRestrictedSpellings,
13365     /*ArgNames=*/{}) {}
13366 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13367   if (!isa<ObjCInterfaceDecl>(D)) {
13368     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13369       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
13370     return false;
13371   }
13372   return true;
13373 }
13374 
13375 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13376   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13377     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13378   return false;
13379 }
13380 
13381 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13382   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
13383 }
13384 
13385 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
13386   D->addAttr(::new (S.Context) ObjCSubclassingRestrictedAttr(S.Context, Attr));
13387   return AttributeApplied;
13388 }
13389 
13390 bool isParamExpr(size_t N) const override {
13391   return false;
13392 }
13393 
13394 static const ParsedAttrInfoObjCSubclassingRestricted Instance;
13395 };
13396 const ParsedAttrInfoObjCSubclassingRestricted ParsedAttrInfoObjCSubclassingRestricted::Instance;
13397 static constexpr ParsedAttrInfo::Spelling OpenCLAccessSpellings[] = {
13398   {AttributeCommonInfo::AS_Keyword, "__read_only"},
13399   {AttributeCommonInfo::AS_Keyword, "read_only"},
13400   {AttributeCommonInfo::AS_Keyword, "__write_only"},
13401   {AttributeCommonInfo::AS_Keyword, "write_only"},
13402   {AttributeCommonInfo::AS_Keyword, "__read_write"},
13403   {AttributeCommonInfo::AS_Keyword, "read_write"},
13404 };
13405 struct ParsedAttrInfoOpenCLAccess final : public ParsedAttrInfo {
13406   constexpr ParsedAttrInfoOpenCLAccess() : ParsedAttrInfo(
13407     /*AttrKind=*/ParsedAttr::AT_OpenCLAccess,
13408     /*NumArgs=*/0,
13409     /*OptArgs=*/0,
13410     /*NumArgMembers=*/0,
13411     /*HasCustomParsing=*/0,
13412     /*AcceptsExprPack=*/0,
13413     /*IsTargetSpecific=*/0,
13414     /*IsType=*/0,
13415     /*IsStmt=*/0,
13416     /*IsKnownToGCC=*/0,
13417     /*IsSupportedByPragmaAttribute=*/0,
13418     /*Spellings=*/OpenCLAccessSpellings,
13419     /*ArgNames=*/{}) {}
13420 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13421   if (!isa<ParmVarDecl>(D) && !isa<TypedefNameDecl>(D)) {
13422     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13423       << Attr << Attr.isRegularKeywordAttribute() << "parameters and typedefs";
13424     return false;
13425   }
13426   return true;
13427 }
13428 
13429 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13430   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13431     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13432   return false;
13433 }
13434 
13435 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13436   enum Spelling {
13437     Keyword_read_only = 0,
13438     Keyword_write_only = 2,
13439     Keyword_read_write = 4,
13440   SpellingNotCalculated = 15
13441 
13442   };
13443 
13444   unsigned Idx = Attr.getAttributeSpellingListIndex();
13445   switch (Idx) {
13446     default: llvm_unreachable("Unknown spelling list index");
13447     case 0: return Keyword_read_only;
13448     case 1: return Keyword_read_only;
13449     case 2: return Keyword_write_only;
13450     case 3: return Keyword_write_only;
13451     case 4: return Keyword_read_write;
13452     case 5: return Keyword_read_write;
13453   }
13454 }
13455 
13456 bool isParamExpr(size_t N) const override {
13457   return false;
13458 }
13459 
13460 static const ParsedAttrInfoOpenCLAccess Instance;
13461 };
13462 const ParsedAttrInfoOpenCLAccess ParsedAttrInfoOpenCLAccess::Instance;
13463 static constexpr ParsedAttrInfo::Spelling OpenCLConstantAddressSpaceSpellings[] = {
13464   {AttributeCommonInfo::AS_Keyword, "__constant"},
13465   {AttributeCommonInfo::AS_Keyword, "constant"},
13466   {AttributeCommonInfo::AS_GNU, "opencl_constant"},
13467   {AttributeCommonInfo::AS_CXX11, "clang::opencl_constant"},
13468   {AttributeCommonInfo::AS_C23, "clang::opencl_constant"},
13469 };
13470 struct ParsedAttrInfoOpenCLConstantAddressSpace final : public ParsedAttrInfo {
13471   constexpr ParsedAttrInfoOpenCLConstantAddressSpace() : ParsedAttrInfo(
13472     /*AttrKind=*/ParsedAttr::AT_OpenCLConstantAddressSpace,
13473     /*NumArgs=*/0,
13474     /*OptArgs=*/0,
13475     /*NumArgMembers=*/0,
13476     /*HasCustomParsing=*/0,
13477     /*AcceptsExprPack=*/0,
13478     /*IsTargetSpecific=*/0,
13479     /*IsType=*/1,
13480     /*IsStmt=*/0,
13481     /*IsKnownToGCC=*/0,
13482     /*IsSupportedByPragmaAttribute=*/0,
13483     /*Spellings=*/OpenCLConstantAddressSpaceSpellings,
13484     /*ArgNames=*/{}) {}
13485 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13486   enum Spelling {
13487     Keyword_constant = 0,
13488     GNU_opencl_constant = 2,
13489     CXX11_clang_opencl_constant = 3,
13490     C23_clang_opencl_constant = 4,
13491   SpellingNotCalculated = 15
13492 
13493   };
13494 
13495   unsigned Idx = Attr.getAttributeSpellingListIndex();
13496   switch (Idx) {
13497     default: llvm_unreachable("Unknown spelling list index");
13498     case 0: return Keyword_constant;
13499     case 1: return Keyword_constant;
13500     case 2: return GNU_opencl_constant;
13501     case 3: return CXX11_clang_opencl_constant;
13502     case 4: return C23_clang_opencl_constant;
13503   }
13504 }
13505 
13506 bool isParamExpr(size_t N) const override {
13507   return false;
13508 }
13509 
13510 static const ParsedAttrInfoOpenCLConstantAddressSpace Instance;
13511 };
13512 const ParsedAttrInfoOpenCLConstantAddressSpace ParsedAttrInfoOpenCLConstantAddressSpace::Instance;
13513 static constexpr ParsedAttrInfo::Spelling OpenCLGenericAddressSpaceSpellings[] = {
13514   {AttributeCommonInfo::AS_Keyword, "__generic"},
13515   {AttributeCommonInfo::AS_Keyword, "generic"},
13516   {AttributeCommonInfo::AS_GNU, "opencl_generic"},
13517   {AttributeCommonInfo::AS_CXX11, "clang::opencl_generic"},
13518   {AttributeCommonInfo::AS_C23, "clang::opencl_generic"},
13519 };
13520 struct ParsedAttrInfoOpenCLGenericAddressSpace final : public ParsedAttrInfo {
13521   constexpr ParsedAttrInfoOpenCLGenericAddressSpace() : ParsedAttrInfo(
13522     /*AttrKind=*/ParsedAttr::AT_OpenCLGenericAddressSpace,
13523     /*NumArgs=*/0,
13524     /*OptArgs=*/0,
13525     /*NumArgMembers=*/0,
13526     /*HasCustomParsing=*/0,
13527     /*AcceptsExprPack=*/0,
13528     /*IsTargetSpecific=*/0,
13529     /*IsType=*/1,
13530     /*IsStmt=*/0,
13531     /*IsKnownToGCC=*/0,
13532     /*IsSupportedByPragmaAttribute=*/0,
13533     /*Spellings=*/OpenCLGenericAddressSpaceSpellings,
13534     /*ArgNames=*/{}) {}
13535 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13536   enum Spelling {
13537     Keyword_generic = 0,
13538     GNU_opencl_generic = 2,
13539     CXX11_clang_opencl_generic = 3,
13540     C23_clang_opencl_generic = 4,
13541   SpellingNotCalculated = 15
13542 
13543   };
13544 
13545   unsigned Idx = Attr.getAttributeSpellingListIndex();
13546   switch (Idx) {
13547     default: llvm_unreachable("Unknown spelling list index");
13548     case 0: return Keyword_generic;
13549     case 1: return Keyword_generic;
13550     case 2: return GNU_opencl_generic;
13551     case 3: return CXX11_clang_opencl_generic;
13552     case 4: return C23_clang_opencl_generic;
13553   }
13554 }
13555 
13556 bool isParamExpr(size_t N) const override {
13557   return false;
13558 }
13559 
13560 static const ParsedAttrInfoOpenCLGenericAddressSpace Instance;
13561 };
13562 const ParsedAttrInfoOpenCLGenericAddressSpace ParsedAttrInfoOpenCLGenericAddressSpace::Instance;
13563 static constexpr ParsedAttrInfo::Spelling OpenCLGlobalAddressSpaceSpellings[] = {
13564   {AttributeCommonInfo::AS_Keyword, "__global"},
13565   {AttributeCommonInfo::AS_Keyword, "global"},
13566   {AttributeCommonInfo::AS_GNU, "opencl_global"},
13567   {AttributeCommonInfo::AS_CXX11, "clang::opencl_global"},
13568   {AttributeCommonInfo::AS_C23, "clang::opencl_global"},
13569 };
13570 struct ParsedAttrInfoOpenCLGlobalAddressSpace final : public ParsedAttrInfo {
13571   constexpr ParsedAttrInfoOpenCLGlobalAddressSpace() : ParsedAttrInfo(
13572     /*AttrKind=*/ParsedAttr::AT_OpenCLGlobalAddressSpace,
13573     /*NumArgs=*/0,
13574     /*OptArgs=*/0,
13575     /*NumArgMembers=*/0,
13576     /*HasCustomParsing=*/0,
13577     /*AcceptsExprPack=*/0,
13578     /*IsTargetSpecific=*/0,
13579     /*IsType=*/1,
13580     /*IsStmt=*/0,
13581     /*IsKnownToGCC=*/0,
13582     /*IsSupportedByPragmaAttribute=*/0,
13583     /*Spellings=*/OpenCLGlobalAddressSpaceSpellings,
13584     /*ArgNames=*/{}) {}
13585 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13586   enum Spelling {
13587     Keyword_global = 0,
13588     GNU_opencl_global = 2,
13589     CXX11_clang_opencl_global = 3,
13590     C23_clang_opencl_global = 4,
13591   SpellingNotCalculated = 15
13592 
13593   };
13594 
13595   unsigned Idx = Attr.getAttributeSpellingListIndex();
13596   switch (Idx) {
13597     default: llvm_unreachable("Unknown spelling list index");
13598     case 0: return Keyword_global;
13599     case 1: return Keyword_global;
13600     case 2: return GNU_opencl_global;
13601     case 3: return CXX11_clang_opencl_global;
13602     case 4: return C23_clang_opencl_global;
13603   }
13604 }
13605 
13606 bool isParamExpr(size_t N) const override {
13607   return false;
13608 }
13609 
13610 static const ParsedAttrInfoOpenCLGlobalAddressSpace Instance;
13611 };
13612 const ParsedAttrInfoOpenCLGlobalAddressSpace ParsedAttrInfoOpenCLGlobalAddressSpace::Instance;
13613 static constexpr ParsedAttrInfo::Spelling OpenCLGlobalDeviceAddressSpaceSpellings[] = {
13614   {AttributeCommonInfo::AS_GNU, "opencl_global_device"},
13615   {AttributeCommonInfo::AS_CXX11, "clang::opencl_global_device"},
13616   {AttributeCommonInfo::AS_C23, "clang::opencl_global_device"},
13617 };
13618 struct ParsedAttrInfoOpenCLGlobalDeviceAddressSpace final : public ParsedAttrInfo {
13619   constexpr ParsedAttrInfoOpenCLGlobalDeviceAddressSpace() : ParsedAttrInfo(
13620     /*AttrKind=*/ParsedAttr::AT_OpenCLGlobalDeviceAddressSpace,
13621     /*NumArgs=*/0,
13622     /*OptArgs=*/0,
13623     /*NumArgMembers=*/0,
13624     /*HasCustomParsing=*/0,
13625     /*AcceptsExprPack=*/0,
13626     /*IsTargetSpecific=*/0,
13627     /*IsType=*/1,
13628     /*IsStmt=*/0,
13629     /*IsKnownToGCC=*/0,
13630     /*IsSupportedByPragmaAttribute=*/0,
13631     /*Spellings=*/OpenCLGlobalDeviceAddressSpaceSpellings,
13632     /*ArgNames=*/{}) {}
13633 bool isParamExpr(size_t N) const override {
13634   return false;
13635 }
13636 
13637 static const ParsedAttrInfoOpenCLGlobalDeviceAddressSpace Instance;
13638 };
13639 const ParsedAttrInfoOpenCLGlobalDeviceAddressSpace ParsedAttrInfoOpenCLGlobalDeviceAddressSpace::Instance;
13640 static constexpr ParsedAttrInfo::Spelling OpenCLGlobalHostAddressSpaceSpellings[] = {
13641   {AttributeCommonInfo::AS_GNU, "opencl_global_host"},
13642   {AttributeCommonInfo::AS_CXX11, "clang::opencl_global_host"},
13643   {AttributeCommonInfo::AS_C23, "clang::opencl_global_host"},
13644 };
13645 struct ParsedAttrInfoOpenCLGlobalHostAddressSpace final : public ParsedAttrInfo {
13646   constexpr ParsedAttrInfoOpenCLGlobalHostAddressSpace() : ParsedAttrInfo(
13647     /*AttrKind=*/ParsedAttr::AT_OpenCLGlobalHostAddressSpace,
13648     /*NumArgs=*/0,
13649     /*OptArgs=*/0,
13650     /*NumArgMembers=*/0,
13651     /*HasCustomParsing=*/0,
13652     /*AcceptsExprPack=*/0,
13653     /*IsTargetSpecific=*/0,
13654     /*IsType=*/1,
13655     /*IsStmt=*/0,
13656     /*IsKnownToGCC=*/0,
13657     /*IsSupportedByPragmaAttribute=*/0,
13658     /*Spellings=*/OpenCLGlobalHostAddressSpaceSpellings,
13659     /*ArgNames=*/{}) {}
13660 bool isParamExpr(size_t N) const override {
13661   return false;
13662 }
13663 
13664 static const ParsedAttrInfoOpenCLGlobalHostAddressSpace Instance;
13665 };
13666 const ParsedAttrInfoOpenCLGlobalHostAddressSpace ParsedAttrInfoOpenCLGlobalHostAddressSpace::Instance;
13667 static constexpr ParsedAttrInfo::Spelling OpenCLIntelReqdSubGroupSizeSpellings[] = {
13668   {AttributeCommonInfo::AS_GNU, "intel_reqd_sub_group_size"},
13669 };
13670 static constexpr const char *OpenCLIntelReqdSubGroupSizeArgNames[] = {
13671 "SubGroupSize",};
13672 struct ParsedAttrInfoOpenCLIntelReqdSubGroupSize final : public ParsedAttrInfo {
13673   constexpr ParsedAttrInfoOpenCLIntelReqdSubGroupSize() : ParsedAttrInfo(
13674     /*AttrKind=*/ParsedAttr::AT_OpenCLIntelReqdSubGroupSize,
13675     /*NumArgs=*/1,
13676     /*OptArgs=*/0,
13677     /*NumArgMembers=*/1,
13678     /*HasCustomParsing=*/0,
13679     /*AcceptsExprPack=*/0,
13680     /*IsTargetSpecific=*/0,
13681     /*IsType=*/0,
13682     /*IsStmt=*/0,
13683     /*IsKnownToGCC=*/0,
13684     /*IsSupportedByPragmaAttribute=*/1,
13685     /*Spellings=*/OpenCLIntelReqdSubGroupSizeSpellings,
13686     /*ArgNames=*/OpenCLIntelReqdSubGroupSizeArgNames) {}
13687 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13688   if (!isa<FunctionDecl>(D)) {
13689     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13690       << Attr << Attr.isRegularKeywordAttribute() << "functions";
13691     return false;
13692   }
13693   return true;
13694 }
13695 
13696 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13697   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13698     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13699   return false;
13700 }
13701 
13702 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13703   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
13704 }
13705 
13706 bool isParamExpr(size_t N) const override {
13707   return false;
13708 }
13709 
13710 static const ParsedAttrInfoOpenCLIntelReqdSubGroupSize Instance;
13711 };
13712 const ParsedAttrInfoOpenCLIntelReqdSubGroupSize ParsedAttrInfoOpenCLIntelReqdSubGroupSize::Instance;
13713 static constexpr ParsedAttrInfo::Spelling OpenCLKernelSpellings[] = {
13714   {AttributeCommonInfo::AS_Keyword, "__kernel"},
13715   {AttributeCommonInfo::AS_Keyword, "kernel"},
13716 };
13717 struct ParsedAttrInfoOpenCLKernel final : public ParsedAttrInfo {
13718   constexpr ParsedAttrInfoOpenCLKernel() : ParsedAttrInfo(
13719     /*AttrKind=*/ParsedAttr::AT_OpenCLKernel,
13720     /*NumArgs=*/0,
13721     /*OptArgs=*/0,
13722     /*NumArgMembers=*/0,
13723     /*HasCustomParsing=*/0,
13724     /*AcceptsExprPack=*/0,
13725     /*IsTargetSpecific=*/0,
13726     /*IsType=*/0,
13727     /*IsStmt=*/0,
13728     /*IsKnownToGCC=*/0,
13729     /*IsSupportedByPragmaAttribute=*/0,
13730     /*Spellings=*/OpenCLKernelSpellings,
13731     /*ArgNames=*/{}) {}
13732 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13733   if (!isa<FunctionDecl>(D)) {
13734     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13735       << Attr << Attr.isRegularKeywordAttribute() << "functions";
13736     return false;
13737   }
13738   return true;
13739 }
13740 
13741 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13742   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13743     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13744   return false;
13745 }
13746 
13747 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
13748   D->addAttr(::new (S.Context) OpenCLKernelAttr(S.Context, Attr));
13749   return AttributeApplied;
13750 }
13751 
13752 bool isParamExpr(size_t N) const override {
13753   return false;
13754 }
13755 
13756 static const ParsedAttrInfoOpenCLKernel Instance;
13757 };
13758 const ParsedAttrInfoOpenCLKernel ParsedAttrInfoOpenCLKernel::Instance;
13759 static constexpr ParsedAttrInfo::Spelling OpenCLLocalAddressSpaceSpellings[] = {
13760   {AttributeCommonInfo::AS_Keyword, "__local"},
13761   {AttributeCommonInfo::AS_Keyword, "local"},
13762   {AttributeCommonInfo::AS_GNU, "opencl_local"},
13763   {AttributeCommonInfo::AS_CXX11, "clang::opencl_local"},
13764   {AttributeCommonInfo::AS_C23, "clang::opencl_local"},
13765 };
13766 struct ParsedAttrInfoOpenCLLocalAddressSpace final : public ParsedAttrInfo {
13767   constexpr ParsedAttrInfoOpenCLLocalAddressSpace() : ParsedAttrInfo(
13768     /*AttrKind=*/ParsedAttr::AT_OpenCLLocalAddressSpace,
13769     /*NumArgs=*/0,
13770     /*OptArgs=*/0,
13771     /*NumArgMembers=*/0,
13772     /*HasCustomParsing=*/0,
13773     /*AcceptsExprPack=*/0,
13774     /*IsTargetSpecific=*/0,
13775     /*IsType=*/1,
13776     /*IsStmt=*/0,
13777     /*IsKnownToGCC=*/0,
13778     /*IsSupportedByPragmaAttribute=*/0,
13779     /*Spellings=*/OpenCLLocalAddressSpaceSpellings,
13780     /*ArgNames=*/{}) {}
13781 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13782   enum Spelling {
13783     Keyword_local = 0,
13784     GNU_opencl_local = 2,
13785     CXX11_clang_opencl_local = 3,
13786     C23_clang_opencl_local = 4,
13787   SpellingNotCalculated = 15
13788 
13789   };
13790 
13791   unsigned Idx = Attr.getAttributeSpellingListIndex();
13792   switch (Idx) {
13793     default: llvm_unreachable("Unknown spelling list index");
13794     case 0: return Keyword_local;
13795     case 1: return Keyword_local;
13796     case 2: return GNU_opencl_local;
13797     case 3: return CXX11_clang_opencl_local;
13798     case 4: return C23_clang_opencl_local;
13799   }
13800 }
13801 
13802 bool isParamExpr(size_t N) const override {
13803   return false;
13804 }
13805 
13806 static const ParsedAttrInfoOpenCLLocalAddressSpace Instance;
13807 };
13808 const ParsedAttrInfoOpenCLLocalAddressSpace ParsedAttrInfoOpenCLLocalAddressSpace::Instance;
13809 static constexpr ParsedAttrInfo::Spelling OpenCLNoSVMSpellings[] = {
13810   {AttributeCommonInfo::AS_GNU, "nosvm"},
13811 };
13812 struct ParsedAttrInfoOpenCLNoSVM final : public ParsedAttrInfo {
13813   constexpr ParsedAttrInfoOpenCLNoSVM() : ParsedAttrInfo(
13814     /*AttrKind=*/ParsedAttr::AT_OpenCLNoSVM,
13815     /*NumArgs=*/0,
13816     /*OptArgs=*/0,
13817     /*NumArgMembers=*/0,
13818     /*HasCustomParsing=*/0,
13819     /*AcceptsExprPack=*/0,
13820     /*IsTargetSpecific=*/0,
13821     /*IsType=*/0,
13822     /*IsStmt=*/0,
13823     /*IsKnownToGCC=*/0,
13824     /*IsSupportedByPragmaAttribute=*/1,
13825     /*Spellings=*/OpenCLNoSVMSpellings,
13826     /*ArgNames=*/{}) {}
13827 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13828   if (!isa<VarDecl>(D)) {
13829     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
13830       << Attr << Attr.isRegularKeywordAttribute() << "variables";
13831     return false;
13832   }
13833   return true;
13834 }
13835 
13836 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13837   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13838     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13839   return false;
13840 }
13841 
13842 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
13843   return LangOpts.OpenCL;
13844 }
13845 
13846 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13847   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
13848 }
13849 
13850 bool isParamExpr(size_t N) const override {
13851   return false;
13852 }
13853 
13854 static const ParsedAttrInfoOpenCLNoSVM Instance;
13855 };
13856 const ParsedAttrInfoOpenCLNoSVM ParsedAttrInfoOpenCLNoSVM::Instance;
13857 static constexpr ParsedAttrInfo::Spelling OpenCLPrivateAddressSpaceSpellings[] = {
13858   {AttributeCommonInfo::AS_Keyword, "__private"},
13859   {AttributeCommonInfo::AS_Keyword, "private"},
13860   {AttributeCommonInfo::AS_GNU, "opencl_private"},
13861   {AttributeCommonInfo::AS_CXX11, "clang::opencl_private"},
13862   {AttributeCommonInfo::AS_C23, "clang::opencl_private"},
13863 };
13864 struct ParsedAttrInfoOpenCLPrivateAddressSpace final : public ParsedAttrInfo {
13865   constexpr ParsedAttrInfoOpenCLPrivateAddressSpace() : ParsedAttrInfo(
13866     /*AttrKind=*/ParsedAttr::AT_OpenCLPrivateAddressSpace,
13867     /*NumArgs=*/0,
13868     /*OptArgs=*/0,
13869     /*NumArgMembers=*/0,
13870     /*HasCustomParsing=*/0,
13871     /*AcceptsExprPack=*/0,
13872     /*IsTargetSpecific=*/0,
13873     /*IsType=*/1,
13874     /*IsStmt=*/0,
13875     /*IsKnownToGCC=*/0,
13876     /*IsSupportedByPragmaAttribute=*/0,
13877     /*Spellings=*/OpenCLPrivateAddressSpaceSpellings,
13878     /*ArgNames=*/{}) {}
13879 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
13880   enum Spelling {
13881     Keyword_private = 0,
13882     GNU_opencl_private = 2,
13883     CXX11_clang_opencl_private = 3,
13884     C23_clang_opencl_private = 4,
13885   SpellingNotCalculated = 15
13886 
13887   };
13888 
13889   unsigned Idx = Attr.getAttributeSpellingListIndex();
13890   switch (Idx) {
13891     default: llvm_unreachable("Unknown spelling list index");
13892     case 0: return Keyword_private;
13893     case 1: return Keyword_private;
13894     case 2: return GNU_opencl_private;
13895     case 3: return CXX11_clang_opencl_private;
13896     case 4: return C23_clang_opencl_private;
13897   }
13898 }
13899 
13900 bool isParamExpr(size_t N) const override {
13901   return false;
13902 }
13903 
13904 static const ParsedAttrInfoOpenCLPrivateAddressSpace Instance;
13905 };
13906 const ParsedAttrInfoOpenCLPrivateAddressSpace ParsedAttrInfoOpenCLPrivateAddressSpace::Instance;
13907 static constexpr ParsedAttrInfo::Spelling OpenCLUnrollHintSpellings[] = {
13908   {AttributeCommonInfo::AS_GNU, "opencl_unroll_hint"},
13909 };
13910 static constexpr const char *OpenCLUnrollHintArgNames[] = {
13911 "UnrollHint",};
13912 struct ParsedAttrInfoOpenCLUnrollHint final : public ParsedAttrInfo {
13913   constexpr ParsedAttrInfoOpenCLUnrollHint() : ParsedAttrInfo(
13914     /*AttrKind=*/ParsedAttr::AT_OpenCLUnrollHint,
13915     /*NumArgs=*/0,
13916     /*OptArgs=*/1,
13917     /*NumArgMembers=*/1,
13918     /*HasCustomParsing=*/0,
13919     /*AcceptsExprPack=*/0,
13920     /*IsTargetSpecific=*/0,
13921     /*IsType=*/0,
13922     /*IsStmt=*/1,
13923     /*IsKnownToGCC=*/0,
13924     /*IsSupportedByPragmaAttribute=*/0,
13925     /*Spellings=*/OpenCLUnrollHintSpellings,
13926     /*ArgNames=*/OpenCLUnrollHintArgNames) {}
13927 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
13928   S.Diag(AL.getLoc(), diag::err_attribute_invalid_on_decl)
13929     << AL << AL.isRegularKeywordAttribute() << D->getLocation();
13930   return false;
13931 }
13932 
13933 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
13934   if (!isa<ForStmt>(St) && !isa<CXXForRangeStmt>(St) && !isa<WhileStmt>(St) && !isa<DoStmt>(St)) {
13935     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
13936       << Attr << Attr.isRegularKeywordAttribute() << "'for', 'while', and 'do' statements";
13937     return false;
13938   }
13939   return true;
13940 }
13941 
13942 bool isParamExpr(size_t N) const override {
13943   return false;
13944 }
13945 
13946 static const ParsedAttrInfoOpenCLUnrollHint Instance;
13947 };
13948 const ParsedAttrInfoOpenCLUnrollHint ParsedAttrInfoOpenCLUnrollHint::Instance;
13949 static constexpr ParsedAttrInfo::Spelling OptimizeNoneSpellings[] = {
13950   {AttributeCommonInfo::AS_GNU, "optnone"},
13951   {AttributeCommonInfo::AS_CXX11, "clang::optnone"},
13952   {AttributeCommonInfo::AS_C23, "clang::optnone"},
13953 };
13954 struct ParsedAttrInfoOptimizeNone final : public ParsedAttrInfo {
13955   constexpr ParsedAttrInfoOptimizeNone() : ParsedAttrInfo(
13956     /*AttrKind=*/ParsedAttr::AT_OptimizeNone,
13957     /*NumArgs=*/0,
13958     /*OptArgs=*/0,
13959     /*NumArgMembers=*/0,
13960     /*HasCustomParsing=*/0,
13961     /*AcceptsExprPack=*/0,
13962     /*IsTargetSpecific=*/0,
13963     /*IsType=*/0,
13964     /*IsStmt=*/0,
13965     /*IsKnownToGCC=*/0,
13966     /*IsSupportedByPragmaAttribute=*/1,
13967     /*Spellings=*/OptimizeNoneSpellings,
13968     /*ArgNames=*/{}) {}
13969 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
13970   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
13971     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
13972       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
13973     return false;
13974   }
13975   return true;
13976 }
13977 
13978 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
13979   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
13980     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
13981   return false;
13982 }
13983 
13984 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
13985   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
13986   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
13987 }
13988 
13989 bool isParamExpr(size_t N) const override {
13990   return false;
13991 }
13992 
13993 static const ParsedAttrInfoOptimizeNone Instance;
13994 };
13995 const ParsedAttrInfoOptimizeNone ParsedAttrInfoOptimizeNone::Instance;
13996 static constexpr ParsedAttrInfo::Spelling OverloadableSpellings[] = {
13997   {AttributeCommonInfo::AS_GNU, "overloadable"},
13998   {AttributeCommonInfo::AS_CXX11, "clang::overloadable"},
13999   {AttributeCommonInfo::AS_C23, "clang::overloadable"},
14000 };
14001 struct ParsedAttrInfoOverloadable final : public ParsedAttrInfo {
14002   constexpr ParsedAttrInfoOverloadable() : ParsedAttrInfo(
14003     /*AttrKind=*/ParsedAttr::AT_Overloadable,
14004     /*NumArgs=*/0,
14005     /*OptArgs=*/0,
14006     /*NumArgMembers=*/0,
14007     /*HasCustomParsing=*/0,
14008     /*AcceptsExprPack=*/0,
14009     /*IsTargetSpecific=*/0,
14010     /*IsType=*/0,
14011     /*IsStmt=*/0,
14012     /*IsKnownToGCC=*/0,
14013     /*IsSupportedByPragmaAttribute=*/1,
14014     /*Spellings=*/OverloadableSpellings,
14015     /*ArgNames=*/{}) {}
14016 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14017   if (!isa<FunctionDecl>(D)) {
14018     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14019       << Attr << Attr.isRegularKeywordAttribute() << "functions";
14020     return false;
14021   }
14022   return true;
14023 }
14024 
14025 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14026   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14027     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14028   return false;
14029 }
14030 
14031 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14032   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
14033 }
14034 
14035 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
14036   D->addAttr(::new (S.Context) OverloadableAttr(S.Context, Attr));
14037   return AttributeApplied;
14038 }
14039 
14040 bool isParamExpr(size_t N) const override {
14041   return false;
14042 }
14043 
14044 static const ParsedAttrInfoOverloadable Instance;
14045 };
14046 const ParsedAttrInfoOverloadable ParsedAttrInfoOverloadable::Instance;
14047 static constexpr ParsedAttrInfo::Spelling OwnerSpellings[] = {
14048   {AttributeCommonInfo::AS_CXX11, "gsl::Owner"},
14049 };
14050 static constexpr const char *OwnerArgNames[] = {
14051 "DerefType",};
14052 struct ParsedAttrInfoOwner final : public ParsedAttrInfo {
14053   constexpr ParsedAttrInfoOwner() : ParsedAttrInfo(
14054     /*AttrKind=*/ParsedAttr::AT_Owner,
14055     /*NumArgs=*/0,
14056     /*OptArgs=*/1,
14057     /*NumArgMembers=*/1,
14058     /*HasCustomParsing=*/0,
14059     /*AcceptsExprPack=*/0,
14060     /*IsTargetSpecific=*/0,
14061     /*IsType=*/0,
14062     /*IsStmt=*/0,
14063     /*IsKnownToGCC=*/0,
14064     /*IsSupportedByPragmaAttribute=*/1,
14065     /*Spellings=*/OwnerSpellings,
14066     /*ArgNames=*/OwnerArgNames) {}
14067 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14068   if (!isStruct(D)) {
14069     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14070       << Attr << Attr.isRegularKeywordAttribute() << "structs";
14071     return false;
14072   }
14073   return true;
14074 }
14075 
14076 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14077   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14078     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14079   return false;
14080 }
14081 
14082   using ParsedAttrInfo::diagMutualExclusion;
14083 
14084   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
14085     if (const auto *A = D->getAttr<PointerAttr>()) {
14086       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
14087       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
14088 return false;
14089     }
14090     return true;
14091   }
14092 
14093 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14094   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /*IsSupported=*/true));
14095 }
14096 
14097 bool isParamExpr(size_t N) const override {
14098   return false;
14099 }
14100 
14101 static const ParsedAttrInfoOwner Instance;
14102 };
14103 const ParsedAttrInfoOwner ParsedAttrInfoOwner::Instance;
14104 static constexpr ParsedAttrInfo::Spelling OwnershipSpellings[] = {
14105   {AttributeCommonInfo::AS_GNU, "ownership_holds"},
14106   {AttributeCommonInfo::AS_CXX11, "clang::ownership_holds"},
14107   {AttributeCommonInfo::AS_C23, "clang::ownership_holds"},
14108   {AttributeCommonInfo::AS_GNU, "ownership_returns"},
14109   {AttributeCommonInfo::AS_CXX11, "clang::ownership_returns"},
14110   {AttributeCommonInfo::AS_C23, "clang::ownership_returns"},
14111   {AttributeCommonInfo::AS_GNU, "ownership_takes"},
14112   {AttributeCommonInfo::AS_CXX11, "clang::ownership_takes"},
14113   {AttributeCommonInfo::AS_C23, "clang::ownership_takes"},
14114 };
14115 static constexpr const char *OwnershipArgNames[] = {
14116 "Module","Args...",};
14117 struct ParsedAttrInfoOwnership final : public ParsedAttrInfo {
14118   constexpr ParsedAttrInfoOwnership() : ParsedAttrInfo(
14119     /*AttrKind=*/ParsedAttr::AT_Ownership,
14120     /*NumArgs=*/1,
14121     /*OptArgs=*/15,
14122     /*NumArgMembers=*/2,
14123     /*HasCustomParsing=*/0,
14124     /*AcceptsExprPack=*/0,
14125     /*IsTargetSpecific=*/0,
14126     /*IsType=*/0,
14127     /*IsStmt=*/0,
14128     /*IsKnownToGCC=*/0,
14129     /*IsSupportedByPragmaAttribute=*/0,
14130     /*Spellings=*/OwnershipSpellings,
14131     /*ArgNames=*/OwnershipArgNames) {}
14132 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14133   if (!isHasFunctionProto(D)) {
14134     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14135       << Attr << Attr.isRegularKeywordAttribute() << "non-K&R-style functions";
14136     return false;
14137   }
14138   return true;
14139 }
14140 
14141 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14142   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14143     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14144   return false;
14145 }
14146 
14147 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
14148   enum Spelling {
14149     GNU_ownership_holds = 0,
14150     CXX11_clang_ownership_holds = 1,
14151     C23_clang_ownership_holds = 2,
14152     GNU_ownership_returns = 3,
14153     CXX11_clang_ownership_returns = 4,
14154     C23_clang_ownership_returns = 5,
14155     GNU_ownership_takes = 6,
14156     CXX11_clang_ownership_takes = 7,
14157     C23_clang_ownership_takes = 8,
14158   SpellingNotCalculated = 15
14159 
14160   };
14161 
14162   unsigned Idx = Attr.getAttributeSpellingListIndex();
14163   switch (Idx) {
14164     default: llvm_unreachable("Unknown spelling list index");
14165     case 0: return GNU_ownership_holds;
14166     case 1: return CXX11_clang_ownership_holds;
14167     case 2: return C23_clang_ownership_holds;
14168     case 3: return GNU_ownership_returns;
14169     case 4: return CXX11_clang_ownership_returns;
14170     case 5: return C23_clang_ownership_returns;
14171     case 6: return GNU_ownership_takes;
14172     case 7: return CXX11_clang_ownership_takes;
14173     case 8: return C23_clang_ownership_takes;
14174   }
14175 }
14176 
14177 bool isParamExpr(size_t N) const override {
14178   return false;
14179 }
14180 
14181 static const ParsedAttrInfoOwnership Instance;
14182 };
14183 const ParsedAttrInfoOwnership ParsedAttrInfoOwnership::Instance;
14184 static constexpr ParsedAttrInfo::Spelling PackedSpellings[] = {
14185   {AttributeCommonInfo::AS_GNU, "packed"},
14186   {AttributeCommonInfo::AS_CXX11, "gnu::packed"},
14187   {AttributeCommonInfo::AS_C23, "gnu::packed"},
14188 };
14189 struct ParsedAttrInfoPacked final : public ParsedAttrInfo {
14190   constexpr ParsedAttrInfoPacked() : ParsedAttrInfo(
14191     /*AttrKind=*/ParsedAttr::AT_Packed,
14192     /*NumArgs=*/0,
14193     /*OptArgs=*/0,
14194     /*NumArgMembers=*/0,
14195     /*HasCustomParsing=*/0,
14196     /*AcceptsExprPack=*/0,
14197     /*IsTargetSpecific=*/0,
14198     /*IsType=*/0,
14199     /*IsStmt=*/0,
14200     /*IsKnownToGCC=*/1,
14201     /*IsSupportedByPragmaAttribute=*/0,
14202     /*Spellings=*/PackedSpellings,
14203     /*ArgNames=*/{}) {}
14204 bool isParamExpr(size_t N) const override {
14205   return false;
14206 }
14207 
14208 static const ParsedAttrInfoPacked Instance;
14209 };
14210 const ParsedAttrInfoPacked ParsedAttrInfoPacked::Instance;
14211 static constexpr ParsedAttrInfo::Spelling ParamTypestateSpellings[] = {
14212   {AttributeCommonInfo::AS_GNU, "param_typestate"},
14213   {AttributeCommonInfo::AS_CXX11, "clang::param_typestate"},
14214 };
14215 static constexpr const char *ParamTypestateArgNames[] = {
14216 "ParamState",};
14217 struct ParsedAttrInfoParamTypestate final : public ParsedAttrInfo {
14218   constexpr ParsedAttrInfoParamTypestate() : ParsedAttrInfo(
14219     /*AttrKind=*/ParsedAttr::AT_ParamTypestate,
14220     /*NumArgs=*/1,
14221     /*OptArgs=*/0,
14222     /*NumArgMembers=*/1,
14223     /*HasCustomParsing=*/0,
14224     /*AcceptsExprPack=*/0,
14225     /*IsTargetSpecific=*/0,
14226     /*IsType=*/0,
14227     /*IsStmt=*/0,
14228     /*IsKnownToGCC=*/0,
14229     /*IsSupportedByPragmaAttribute=*/1,
14230     /*Spellings=*/ParamTypestateSpellings,
14231     /*ArgNames=*/ParamTypestateArgNames) {}
14232 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14233   if (!isa<ParmVarDecl>(D)) {
14234     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14235       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
14236     return false;
14237   }
14238   return true;
14239 }
14240 
14241 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14242   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14243     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14244   return false;
14245 }
14246 
14247 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14248   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
14249 }
14250 
14251 bool isParamExpr(size_t N) const override {
14252   return false;
14253 }
14254 
14255 static const ParsedAttrInfoParamTypestate Instance;
14256 };
14257 const ParsedAttrInfoParamTypestate ParsedAttrInfoParamTypestate::Instance;
14258 static constexpr ParsedAttrInfo::Spelling PascalSpellings[] = {
14259   {AttributeCommonInfo::AS_GNU, "pascal"},
14260   {AttributeCommonInfo::AS_CXX11, "clang::pascal"},
14261   {AttributeCommonInfo::AS_C23, "clang::pascal"},
14262   {AttributeCommonInfo::AS_Keyword, "__pascal"},
14263   {AttributeCommonInfo::AS_Keyword, "_pascal"},
14264 };
14265 struct ParsedAttrInfoPascal final : public ParsedAttrInfo {
14266   constexpr ParsedAttrInfoPascal() : ParsedAttrInfo(
14267     /*AttrKind=*/ParsedAttr::AT_Pascal,
14268     /*NumArgs=*/0,
14269     /*OptArgs=*/0,
14270     /*NumArgMembers=*/0,
14271     /*HasCustomParsing=*/0,
14272     /*AcceptsExprPack=*/0,
14273     /*IsTargetSpecific=*/0,
14274     /*IsType=*/1,
14275     /*IsStmt=*/0,
14276     /*IsKnownToGCC=*/0,
14277     /*IsSupportedByPragmaAttribute=*/0,
14278     /*Spellings=*/PascalSpellings,
14279     /*ArgNames=*/{}) {}
14280 bool isParamExpr(size_t N) const override {
14281   return false;
14282 }
14283 
14284 static const ParsedAttrInfoPascal Instance;
14285 };
14286 const ParsedAttrInfoPascal ParsedAttrInfoPascal::Instance;
14287 static constexpr ParsedAttrInfo::Spelling PassObjectSizeSpellings[] = {
14288   {AttributeCommonInfo::AS_GNU, "pass_object_size"},
14289   {AttributeCommonInfo::AS_CXX11, "clang::pass_object_size"},
14290   {AttributeCommonInfo::AS_C23, "clang::pass_object_size"},
14291   {AttributeCommonInfo::AS_GNU, "pass_dynamic_object_size"},
14292   {AttributeCommonInfo::AS_CXX11, "clang::pass_dynamic_object_size"},
14293   {AttributeCommonInfo::AS_C23, "clang::pass_dynamic_object_size"},
14294 };
14295 static constexpr const char *PassObjectSizeArgNames[] = {
14296 "Type",};
14297 struct ParsedAttrInfoPassObjectSize final : public ParsedAttrInfo {
14298   constexpr ParsedAttrInfoPassObjectSize() : ParsedAttrInfo(
14299     /*AttrKind=*/ParsedAttr::AT_PassObjectSize,
14300     /*NumArgs=*/1,
14301     /*OptArgs=*/0,
14302     /*NumArgMembers=*/1,
14303     /*HasCustomParsing=*/0,
14304     /*AcceptsExprPack=*/0,
14305     /*IsTargetSpecific=*/0,
14306     /*IsType=*/0,
14307     /*IsStmt=*/0,
14308     /*IsKnownToGCC=*/0,
14309     /*IsSupportedByPragmaAttribute=*/1,
14310     /*Spellings=*/PassObjectSizeSpellings,
14311     /*ArgNames=*/PassObjectSizeArgNames) {}
14312 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14313   if (!isa<ParmVarDecl>(D)) {
14314     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14315       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
14316     return false;
14317   }
14318   return true;
14319 }
14320 
14321 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14322   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14323     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14324   return false;
14325 }
14326 
14327 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
14328   enum Spelling {
14329     GNU_pass_object_size = 0,
14330     CXX11_clang_pass_object_size = 1,
14331     C23_clang_pass_object_size = 2,
14332     GNU_pass_dynamic_object_size = 3,
14333     CXX11_clang_pass_dynamic_object_size = 4,
14334     C23_clang_pass_dynamic_object_size = 5,
14335   SpellingNotCalculated = 15
14336 
14337   };
14338 
14339   unsigned Idx = Attr.getAttributeSpellingListIndex();
14340   switch (Idx) {
14341     default: llvm_unreachable("Unknown spelling list index");
14342     case 0: return GNU_pass_object_size;
14343     case 1: return CXX11_clang_pass_object_size;
14344     case 2: return C23_clang_pass_object_size;
14345     case 3: return GNU_pass_dynamic_object_size;
14346     case 4: return CXX11_clang_pass_dynamic_object_size;
14347     case 5: return C23_clang_pass_dynamic_object_size;
14348   }
14349 }
14350 
14351 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14352   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
14353 }
14354 
14355 bool isParamExpr(size_t N) const override {
14356   return false;
14357 }
14358 
14359 static const ParsedAttrInfoPassObjectSize Instance;
14360 };
14361 const ParsedAttrInfoPassObjectSize ParsedAttrInfoPassObjectSize::Instance;
14362 static constexpr ParsedAttrInfo::Spelling PatchableFunctionEntrySpellings[] = {
14363   {AttributeCommonInfo::AS_GNU, "patchable_function_entry"},
14364   {AttributeCommonInfo::AS_CXX11, "gnu::patchable_function_entry"},
14365   {AttributeCommonInfo::AS_C23, "gnu::patchable_function_entry"},
14366 };
14367 static constexpr const char *PatchableFunctionEntryArgNames[] = {
14368 "Count","Offset",};
14369 struct ParsedAttrInfoPatchableFunctionEntry final : public ParsedAttrInfo {
14370   constexpr ParsedAttrInfoPatchableFunctionEntry() : ParsedAttrInfo(
14371     /*AttrKind=*/ParsedAttr::AT_PatchableFunctionEntry,
14372     /*NumArgs=*/1,
14373     /*OptArgs=*/1,
14374     /*NumArgMembers=*/2,
14375     /*HasCustomParsing=*/0,
14376     /*AcceptsExprPack=*/0,
14377     /*IsTargetSpecific=*/1,
14378     /*IsType=*/0,
14379     /*IsStmt=*/0,
14380     /*IsKnownToGCC=*/1,
14381     /*IsSupportedByPragmaAttribute=*/1,
14382     /*Spellings=*/PatchableFunctionEntrySpellings,
14383     /*ArgNames=*/PatchableFunctionEntryArgNames) {}
14384 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14385   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
14386     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14387       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
14388     return false;
14389   }
14390   return true;
14391 }
14392 
14393 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14394   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14395     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14396   return false;
14397 }
14398 
14399 bool existsInTarget(const TargetInfo &Target) const override {
14400   const llvm::Triple &T = Target.getTriple(); (void)T;
14401   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 || T.getArch() == llvm::Triple::ppc || T.getArch() == llvm::Triple::ppc64);
14402 }
14403 
14404 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14405   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
14406   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
14407 }
14408 
14409 bool isParamExpr(size_t N) const override {
14410   return false;
14411 }
14412 
14413 static const ParsedAttrInfoPatchableFunctionEntry Instance;
14414 };
14415 const ParsedAttrInfoPatchableFunctionEntry ParsedAttrInfoPatchableFunctionEntry::Instance;
14416 static constexpr ParsedAttrInfo::Spelling PcsSpellings[] = {
14417   {AttributeCommonInfo::AS_GNU, "pcs"},
14418   {AttributeCommonInfo::AS_CXX11, "gnu::pcs"},
14419   {AttributeCommonInfo::AS_C23, "gnu::pcs"},
14420 };
14421 static constexpr const char *PcsArgNames[] = {
14422 "PCS",};
14423 struct ParsedAttrInfoPcs final : public ParsedAttrInfo {
14424   constexpr ParsedAttrInfoPcs() : ParsedAttrInfo(
14425     /*AttrKind=*/ParsedAttr::AT_Pcs,
14426     /*NumArgs=*/1,
14427     /*OptArgs=*/0,
14428     /*NumArgMembers=*/1,
14429     /*HasCustomParsing=*/0,
14430     /*AcceptsExprPack=*/0,
14431     /*IsTargetSpecific=*/0,
14432     /*IsType=*/1,
14433     /*IsStmt=*/0,
14434     /*IsKnownToGCC=*/1,
14435     /*IsSupportedByPragmaAttribute=*/0,
14436     /*Spellings=*/PcsSpellings,
14437     /*ArgNames=*/PcsArgNames) {}
14438 bool isParamExpr(size_t N) const override {
14439   return false;
14440 }
14441 
14442 static const ParsedAttrInfoPcs Instance;
14443 };
14444 const ParsedAttrInfoPcs ParsedAttrInfoPcs::Instance;
14445 static constexpr ParsedAttrInfo::Spelling PointerSpellings[] = {
14446   {AttributeCommonInfo::AS_CXX11, "gsl::Pointer"},
14447 };
14448 static constexpr const char *PointerArgNames[] = {
14449 "DerefType",};
14450 struct ParsedAttrInfoPointer final : public ParsedAttrInfo {
14451   constexpr ParsedAttrInfoPointer() : ParsedAttrInfo(
14452     /*AttrKind=*/ParsedAttr::AT_Pointer,
14453     /*NumArgs=*/0,
14454     /*OptArgs=*/1,
14455     /*NumArgMembers=*/1,
14456     /*HasCustomParsing=*/0,
14457     /*AcceptsExprPack=*/0,
14458     /*IsTargetSpecific=*/0,
14459     /*IsType=*/0,
14460     /*IsStmt=*/0,
14461     /*IsKnownToGCC=*/0,
14462     /*IsSupportedByPragmaAttribute=*/1,
14463     /*Spellings=*/PointerSpellings,
14464     /*ArgNames=*/PointerArgNames) {}
14465 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14466   if (!isStruct(D)) {
14467     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14468       << Attr << Attr.isRegularKeywordAttribute() << "structs";
14469     return false;
14470   }
14471   return true;
14472 }
14473 
14474 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14475   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14476     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14477   return false;
14478 }
14479 
14480   using ParsedAttrInfo::diagMutualExclusion;
14481 
14482   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
14483     if (const auto *A = D->getAttr<OwnerAttr>()) {
14484       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
14485       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
14486 return false;
14487     }
14488     return true;
14489   }
14490 
14491 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14492   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record_not_is_union, /*IsSupported=*/true));
14493 }
14494 
14495 bool isParamExpr(size_t N) const override {
14496   return false;
14497 }
14498 
14499 static const ParsedAttrInfoPointer Instance;
14500 };
14501 const ParsedAttrInfoPointer ParsedAttrInfoPointer::Instance;
14502 static constexpr const char *PragmaClangBSSSectionArgNames[] = {
14503 "Name",};
14504 struct ParsedAttrInfoPragmaClangBSSSection final : public ParsedAttrInfo {
14505   constexpr ParsedAttrInfoPragmaClangBSSSection() : ParsedAttrInfo(
14506     /*AttrKind=*/ParsedAttr::AT_PragmaClangBSSSection,
14507     /*NumArgs=*/1,
14508     /*OptArgs=*/0,
14509     /*NumArgMembers=*/1,
14510     /*HasCustomParsing=*/0,
14511     /*AcceptsExprPack=*/0,
14512     /*IsTargetSpecific=*/0,
14513     /*IsType=*/0,
14514     /*IsStmt=*/0,
14515     /*IsKnownToGCC=*/0,
14516     /*IsSupportedByPragmaAttribute=*/0,
14517     /*Spellings=*/{},
14518     /*ArgNames=*/PragmaClangBSSSectionArgNames) {}
14519 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14520   if (!isGlobalVar(D)) {
14521     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14522       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
14523     return false;
14524   }
14525   return true;
14526 }
14527 
14528 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14529   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14530     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14531   return false;
14532 }
14533 
14534 bool isParamExpr(size_t N) const override {
14535   return false;
14536 }
14537 
14538 static const ParsedAttrInfoPragmaClangBSSSection Instance;
14539 };
14540 const ParsedAttrInfoPragmaClangBSSSection ParsedAttrInfoPragmaClangBSSSection::Instance;
14541 static constexpr const char *PragmaClangDataSectionArgNames[] = {
14542 "Name",};
14543 struct ParsedAttrInfoPragmaClangDataSection final : public ParsedAttrInfo {
14544   constexpr ParsedAttrInfoPragmaClangDataSection() : ParsedAttrInfo(
14545     /*AttrKind=*/ParsedAttr::AT_PragmaClangDataSection,
14546     /*NumArgs=*/1,
14547     /*OptArgs=*/0,
14548     /*NumArgMembers=*/1,
14549     /*HasCustomParsing=*/0,
14550     /*AcceptsExprPack=*/0,
14551     /*IsTargetSpecific=*/0,
14552     /*IsType=*/0,
14553     /*IsStmt=*/0,
14554     /*IsKnownToGCC=*/0,
14555     /*IsSupportedByPragmaAttribute=*/0,
14556     /*Spellings=*/{},
14557     /*ArgNames=*/PragmaClangDataSectionArgNames) {}
14558 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14559   if (!isGlobalVar(D)) {
14560     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14561       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
14562     return false;
14563   }
14564   return true;
14565 }
14566 
14567 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14568   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14569     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14570   return false;
14571 }
14572 
14573 bool isParamExpr(size_t N) const override {
14574   return false;
14575 }
14576 
14577 static const ParsedAttrInfoPragmaClangDataSection Instance;
14578 };
14579 const ParsedAttrInfoPragmaClangDataSection ParsedAttrInfoPragmaClangDataSection::Instance;
14580 static constexpr const char *PragmaClangRelroSectionArgNames[] = {
14581 "Name",};
14582 struct ParsedAttrInfoPragmaClangRelroSection final : public ParsedAttrInfo {
14583   constexpr ParsedAttrInfoPragmaClangRelroSection() : ParsedAttrInfo(
14584     /*AttrKind=*/ParsedAttr::AT_PragmaClangRelroSection,
14585     /*NumArgs=*/1,
14586     /*OptArgs=*/0,
14587     /*NumArgMembers=*/1,
14588     /*HasCustomParsing=*/0,
14589     /*AcceptsExprPack=*/0,
14590     /*IsTargetSpecific=*/0,
14591     /*IsType=*/0,
14592     /*IsStmt=*/0,
14593     /*IsKnownToGCC=*/0,
14594     /*IsSupportedByPragmaAttribute=*/0,
14595     /*Spellings=*/{},
14596     /*ArgNames=*/PragmaClangRelroSectionArgNames) {}
14597 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14598   if (!isGlobalVar(D)) {
14599     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14600       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
14601     return false;
14602   }
14603   return true;
14604 }
14605 
14606 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14607   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14608     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14609   return false;
14610 }
14611 
14612 bool isParamExpr(size_t N) const override {
14613   return false;
14614 }
14615 
14616 static const ParsedAttrInfoPragmaClangRelroSection Instance;
14617 };
14618 const ParsedAttrInfoPragmaClangRelroSection ParsedAttrInfoPragmaClangRelroSection::Instance;
14619 static constexpr const char *PragmaClangRodataSectionArgNames[] = {
14620 "Name",};
14621 struct ParsedAttrInfoPragmaClangRodataSection final : public ParsedAttrInfo {
14622   constexpr ParsedAttrInfoPragmaClangRodataSection() : ParsedAttrInfo(
14623     /*AttrKind=*/ParsedAttr::AT_PragmaClangRodataSection,
14624     /*NumArgs=*/1,
14625     /*OptArgs=*/0,
14626     /*NumArgMembers=*/1,
14627     /*HasCustomParsing=*/0,
14628     /*AcceptsExprPack=*/0,
14629     /*IsTargetSpecific=*/0,
14630     /*IsType=*/0,
14631     /*IsStmt=*/0,
14632     /*IsKnownToGCC=*/0,
14633     /*IsSupportedByPragmaAttribute=*/0,
14634     /*Spellings=*/{},
14635     /*ArgNames=*/PragmaClangRodataSectionArgNames) {}
14636 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14637   if (!isGlobalVar(D)) {
14638     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14639       << Attr << Attr.isRegularKeywordAttribute() << "global variables";
14640     return false;
14641   }
14642   return true;
14643 }
14644 
14645 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14646   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14647     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14648   return false;
14649 }
14650 
14651 bool isParamExpr(size_t N) const override {
14652   return false;
14653 }
14654 
14655 static const ParsedAttrInfoPragmaClangRodataSection Instance;
14656 };
14657 const ParsedAttrInfoPragmaClangRodataSection ParsedAttrInfoPragmaClangRodataSection::Instance;
14658 static constexpr const char *PragmaClangTextSectionArgNames[] = {
14659 "Name",};
14660 struct ParsedAttrInfoPragmaClangTextSection final : public ParsedAttrInfo {
14661   constexpr ParsedAttrInfoPragmaClangTextSection() : ParsedAttrInfo(
14662     /*AttrKind=*/ParsedAttr::AT_PragmaClangTextSection,
14663     /*NumArgs=*/1,
14664     /*OptArgs=*/0,
14665     /*NumArgMembers=*/1,
14666     /*HasCustomParsing=*/0,
14667     /*AcceptsExprPack=*/0,
14668     /*IsTargetSpecific=*/0,
14669     /*IsType=*/0,
14670     /*IsStmt=*/0,
14671     /*IsKnownToGCC=*/0,
14672     /*IsSupportedByPragmaAttribute=*/0,
14673     /*Spellings=*/{},
14674     /*ArgNames=*/PragmaClangTextSectionArgNames) {}
14675 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14676   if (!isa<FunctionDecl>(D)) {
14677     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14678       << Attr << Attr.isRegularKeywordAttribute() << "functions";
14679     return false;
14680   }
14681   return true;
14682 }
14683 
14684 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14685   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14686     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14687   return false;
14688 }
14689 
14690 bool isParamExpr(size_t N) const override {
14691   return false;
14692 }
14693 
14694 static const ParsedAttrInfoPragmaClangTextSection Instance;
14695 };
14696 const ParsedAttrInfoPragmaClangTextSection ParsedAttrInfoPragmaClangTextSection::Instance;
14697 static constexpr ParsedAttrInfo::Spelling PreferredNameSpellings[] = {
14698   {AttributeCommonInfo::AS_GNU, "preferred_name"},
14699   {AttributeCommonInfo::AS_CXX11, "clang::preferred_name"},
14700 };
14701 static constexpr const char *PreferredNameArgNames[] = {
14702 "TypedefType",};
14703 struct ParsedAttrInfoPreferredName final : public ParsedAttrInfo {
14704   constexpr ParsedAttrInfoPreferredName() : ParsedAttrInfo(
14705     /*AttrKind=*/ParsedAttr::AT_PreferredName,
14706     /*NumArgs=*/1,
14707     /*OptArgs=*/0,
14708     /*NumArgMembers=*/1,
14709     /*HasCustomParsing=*/0,
14710     /*AcceptsExprPack=*/0,
14711     /*IsTargetSpecific=*/0,
14712     /*IsType=*/0,
14713     /*IsStmt=*/0,
14714     /*IsKnownToGCC=*/0,
14715     /*IsSupportedByPragmaAttribute=*/0,
14716     /*Spellings=*/PreferredNameSpellings,
14717     /*ArgNames=*/PreferredNameArgNames) {}
14718 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14719   if (!isClassTmpl(D)) {
14720     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14721       << Attr << Attr.isRegularKeywordAttribute() << "class templates";
14722     return false;
14723   }
14724   return true;
14725 }
14726 
14727 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14728   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14729     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14730   return false;
14731 }
14732 
14733 bool isParamExpr(size_t N) const override {
14734   return false;
14735 }
14736 
14737 static const ParsedAttrInfoPreferredName Instance;
14738 };
14739 const ParsedAttrInfoPreferredName ParsedAttrInfoPreferredName::Instance;
14740 static constexpr ParsedAttrInfo::Spelling PreferredTypeSpellings[] = {
14741   {AttributeCommonInfo::AS_GNU, "preferred_type"},
14742   {AttributeCommonInfo::AS_CXX11, "clang::preferred_type"},
14743   {AttributeCommonInfo::AS_C23, "clang::preferred_type"},
14744 };
14745 static constexpr const char *PreferredTypeArgNames[] = {
14746 "Type",};
14747 struct ParsedAttrInfoPreferredType final : public ParsedAttrInfo {
14748   constexpr ParsedAttrInfoPreferredType() : ParsedAttrInfo(
14749     /*AttrKind=*/ParsedAttr::AT_PreferredType,
14750     /*NumArgs=*/0,
14751     /*OptArgs=*/1,
14752     /*NumArgMembers=*/1,
14753     /*HasCustomParsing=*/0,
14754     /*AcceptsExprPack=*/0,
14755     /*IsTargetSpecific=*/0,
14756     /*IsType=*/0,
14757     /*IsStmt=*/0,
14758     /*IsKnownToGCC=*/0,
14759     /*IsSupportedByPragmaAttribute=*/0,
14760     /*Spellings=*/PreferredTypeSpellings,
14761     /*ArgNames=*/PreferredTypeArgNames) {}
14762 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14763   if (!isBitField(D)) {
14764     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
14765       << Attr << Attr.isRegularKeywordAttribute() << "bit-field data members";
14766     return false;
14767   }
14768   return true;
14769 }
14770 
14771 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14772   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14773     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14774   return false;
14775 }
14776 
14777 bool isParamExpr(size_t N) const override {
14778   return false;
14779 }
14780 
14781 static const ParsedAttrInfoPreferredType Instance;
14782 };
14783 const ParsedAttrInfoPreferredType ParsedAttrInfoPreferredType::Instance;
14784 static constexpr ParsedAttrInfo::Spelling PreserveAllSpellings[] = {
14785   {AttributeCommonInfo::AS_GNU, "preserve_all"},
14786   {AttributeCommonInfo::AS_CXX11, "clang::preserve_all"},
14787   {AttributeCommonInfo::AS_C23, "clang::preserve_all"},
14788 };
14789 struct ParsedAttrInfoPreserveAll final : public ParsedAttrInfo {
14790   constexpr ParsedAttrInfoPreserveAll() : ParsedAttrInfo(
14791     /*AttrKind=*/ParsedAttr::AT_PreserveAll,
14792     /*NumArgs=*/0,
14793     /*OptArgs=*/0,
14794     /*NumArgMembers=*/0,
14795     /*HasCustomParsing=*/0,
14796     /*AcceptsExprPack=*/0,
14797     /*IsTargetSpecific=*/0,
14798     /*IsType=*/1,
14799     /*IsStmt=*/0,
14800     /*IsKnownToGCC=*/0,
14801     /*IsSupportedByPragmaAttribute=*/0,
14802     /*Spellings=*/PreserveAllSpellings,
14803     /*ArgNames=*/{}) {}
14804 bool isParamExpr(size_t N) const override {
14805   return false;
14806 }
14807 
14808 static const ParsedAttrInfoPreserveAll Instance;
14809 };
14810 const ParsedAttrInfoPreserveAll ParsedAttrInfoPreserveAll::Instance;
14811 static constexpr ParsedAttrInfo::Spelling PreserveMostSpellings[] = {
14812   {AttributeCommonInfo::AS_GNU, "preserve_most"},
14813   {AttributeCommonInfo::AS_CXX11, "clang::preserve_most"},
14814   {AttributeCommonInfo::AS_C23, "clang::preserve_most"},
14815 };
14816 struct ParsedAttrInfoPreserveMost final : public ParsedAttrInfo {
14817   constexpr ParsedAttrInfoPreserveMost() : ParsedAttrInfo(
14818     /*AttrKind=*/ParsedAttr::AT_PreserveMost,
14819     /*NumArgs=*/0,
14820     /*OptArgs=*/0,
14821     /*NumArgMembers=*/0,
14822     /*HasCustomParsing=*/0,
14823     /*AcceptsExprPack=*/0,
14824     /*IsTargetSpecific=*/0,
14825     /*IsType=*/1,
14826     /*IsStmt=*/0,
14827     /*IsKnownToGCC=*/0,
14828     /*IsSupportedByPragmaAttribute=*/0,
14829     /*Spellings=*/PreserveMostSpellings,
14830     /*ArgNames=*/{}) {}
14831 bool isParamExpr(size_t N) const override {
14832   return false;
14833 }
14834 
14835 static const ParsedAttrInfoPreserveMost Instance;
14836 };
14837 const ParsedAttrInfoPreserveMost ParsedAttrInfoPreserveMost::Instance;
14838 static constexpr ParsedAttrInfo::Spelling PreserveNoneSpellings[] = {
14839   {AttributeCommonInfo::AS_GNU, "preserve_none"},
14840   {AttributeCommonInfo::AS_CXX11, "clang::preserve_none"},
14841   {AttributeCommonInfo::AS_C23, "clang::preserve_none"},
14842 };
14843 struct ParsedAttrInfoPreserveNone final : public ParsedAttrInfo {
14844   constexpr ParsedAttrInfoPreserveNone() : ParsedAttrInfo(
14845     /*AttrKind=*/ParsedAttr::AT_PreserveNone,
14846     /*NumArgs=*/0,
14847     /*OptArgs=*/0,
14848     /*NumArgMembers=*/0,
14849     /*HasCustomParsing=*/0,
14850     /*AcceptsExprPack=*/0,
14851     /*IsTargetSpecific=*/1,
14852     /*IsType=*/1,
14853     /*IsStmt=*/0,
14854     /*IsKnownToGCC=*/0,
14855     /*IsSupportedByPragmaAttribute=*/1,
14856     /*Spellings=*/PreserveNoneSpellings,
14857     /*ArgNames=*/{}) {}
14858 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14859   if (!isFunctionLike(D)) {
14860     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14861       << Attr << Attr.isRegularKeywordAttribute() << "functions and function pointers";
14862     return false;
14863   }
14864   return true;
14865 }
14866 
14867 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14868   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14869     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14870   return false;
14871 }
14872 
14873 bool existsInTarget(const TargetInfo &Target) const override {
14874   const llvm::Triple &T = Target.getTriple(); (void)T;
14875   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32 || T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
14876 }
14877 
14878 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
14879   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
14880 }
14881 
14882 bool isParamExpr(size_t N) const override {
14883   return false;
14884 }
14885 
14886 static const ParsedAttrInfoPreserveNone Instance;
14887 };
14888 const ParsedAttrInfoPreserveNone ParsedAttrInfoPreserveNone::Instance;
14889 static constexpr ParsedAttrInfo::Spelling PtGuardedBySpellings[] = {
14890   {AttributeCommonInfo::AS_GNU, "pt_guarded_by"},
14891 };
14892 static constexpr const char *PtGuardedByArgNames[] = {
14893 "Arg",};
14894 struct ParsedAttrInfoPtGuardedBy final : public ParsedAttrInfo {
14895   constexpr ParsedAttrInfoPtGuardedBy() : ParsedAttrInfo(
14896     /*AttrKind=*/ParsedAttr::AT_PtGuardedBy,
14897     /*NumArgs=*/1,
14898     /*OptArgs=*/0,
14899     /*NumArgMembers=*/1,
14900     /*HasCustomParsing=*/0,
14901     /*AcceptsExprPack=*/0,
14902     /*IsTargetSpecific=*/0,
14903     /*IsType=*/0,
14904     /*IsStmt=*/0,
14905     /*IsKnownToGCC=*/0,
14906     /*IsSupportedByPragmaAttribute=*/0,
14907     /*Spellings=*/PtGuardedBySpellings,
14908     /*ArgNames=*/PtGuardedByArgNames) {}
14909 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14910   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
14911     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14912       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
14913     return false;
14914   }
14915   return true;
14916 }
14917 
14918 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14919   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14920     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14921   return false;
14922 }
14923 
14924 bool isParamExpr(size_t N) const override {
14925   return (N == 0) || false;
14926 }
14927 
14928 static const ParsedAttrInfoPtGuardedBy Instance;
14929 };
14930 const ParsedAttrInfoPtGuardedBy ParsedAttrInfoPtGuardedBy::Instance;
14931 static constexpr ParsedAttrInfo::Spelling PtGuardedVarSpellings[] = {
14932   {AttributeCommonInfo::AS_GNU, "pt_guarded_var"},
14933   {AttributeCommonInfo::AS_CXX11, "clang::pt_guarded_var"},
14934 };
14935 struct ParsedAttrInfoPtGuardedVar final : public ParsedAttrInfo {
14936   constexpr ParsedAttrInfoPtGuardedVar() : ParsedAttrInfo(
14937     /*AttrKind=*/ParsedAttr::AT_PtGuardedVar,
14938     /*NumArgs=*/0,
14939     /*OptArgs=*/0,
14940     /*NumArgMembers=*/0,
14941     /*HasCustomParsing=*/0,
14942     /*AcceptsExprPack=*/0,
14943     /*IsTargetSpecific=*/0,
14944     /*IsType=*/0,
14945     /*IsStmt=*/0,
14946     /*IsKnownToGCC=*/0,
14947     /*IsSupportedByPragmaAttribute=*/0,
14948     /*Spellings=*/PtGuardedVarSpellings,
14949     /*ArgNames=*/{}) {}
14950 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
14951   if (!isa<FieldDecl>(D) && !isSharedVar(D)) {
14952     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
14953       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members and global variables";
14954     return false;
14955   }
14956   return true;
14957 }
14958 
14959 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
14960   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
14961     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
14962   return false;
14963 }
14964 
14965 bool isParamExpr(size_t N) const override {
14966   return false;
14967 }
14968 
14969 static const ParsedAttrInfoPtGuardedVar Instance;
14970 };
14971 const ParsedAttrInfoPtGuardedVar ParsedAttrInfoPtGuardedVar::Instance;
14972 static constexpr ParsedAttrInfo::Spelling Ptr32Spellings[] = {
14973   {AttributeCommonInfo::AS_Keyword, "__ptr32"},
14974 };
14975 struct ParsedAttrInfoPtr32 final : public ParsedAttrInfo {
14976   constexpr ParsedAttrInfoPtr32() : ParsedAttrInfo(
14977     /*AttrKind=*/ParsedAttr::AT_Ptr32,
14978     /*NumArgs=*/0,
14979     /*OptArgs=*/0,
14980     /*NumArgMembers=*/0,
14981     /*HasCustomParsing=*/0,
14982     /*AcceptsExprPack=*/0,
14983     /*IsTargetSpecific=*/0,
14984     /*IsType=*/1,
14985     /*IsStmt=*/0,
14986     /*IsKnownToGCC=*/0,
14987     /*IsSupportedByPragmaAttribute=*/0,
14988     /*Spellings=*/Ptr32Spellings,
14989     /*ArgNames=*/{}) {}
14990 bool isParamExpr(size_t N) const override {
14991   return false;
14992 }
14993 
14994 static const ParsedAttrInfoPtr32 Instance;
14995 };
14996 const ParsedAttrInfoPtr32 ParsedAttrInfoPtr32::Instance;
14997 static constexpr ParsedAttrInfo::Spelling Ptr64Spellings[] = {
14998   {AttributeCommonInfo::AS_Keyword, "__ptr64"},
14999 };
15000 struct ParsedAttrInfoPtr64 final : public ParsedAttrInfo {
15001   constexpr ParsedAttrInfoPtr64() : ParsedAttrInfo(
15002     /*AttrKind=*/ParsedAttr::AT_Ptr64,
15003     /*NumArgs=*/0,
15004     /*OptArgs=*/0,
15005     /*NumArgMembers=*/0,
15006     /*HasCustomParsing=*/0,
15007     /*AcceptsExprPack=*/0,
15008     /*IsTargetSpecific=*/0,
15009     /*IsType=*/1,
15010     /*IsStmt=*/0,
15011     /*IsKnownToGCC=*/0,
15012     /*IsSupportedByPragmaAttribute=*/0,
15013     /*Spellings=*/Ptr64Spellings,
15014     /*ArgNames=*/{}) {}
15015 bool isParamExpr(size_t N) const override {
15016   return false;
15017 }
15018 
15019 static const ParsedAttrInfoPtr64 Instance;
15020 };
15021 const ParsedAttrInfoPtr64 ParsedAttrInfoPtr64::Instance;
15022 static constexpr ParsedAttrInfo::Spelling PureSpellings[] = {
15023   {AttributeCommonInfo::AS_GNU, "pure"},
15024   {AttributeCommonInfo::AS_CXX11, "gnu::pure"},
15025   {AttributeCommonInfo::AS_C23, "gnu::pure"},
15026 };
15027 struct ParsedAttrInfoPure final : public ParsedAttrInfo {
15028   constexpr ParsedAttrInfoPure() : ParsedAttrInfo(
15029     /*AttrKind=*/ParsedAttr::AT_Pure,
15030     /*NumArgs=*/0,
15031     /*OptArgs=*/0,
15032     /*NumArgMembers=*/0,
15033     /*HasCustomParsing=*/0,
15034     /*AcceptsExprPack=*/0,
15035     /*IsTargetSpecific=*/0,
15036     /*IsType=*/0,
15037     /*IsStmt=*/0,
15038     /*IsKnownToGCC=*/1,
15039     /*IsSupportedByPragmaAttribute=*/0,
15040     /*Spellings=*/PureSpellings,
15041     /*ArgNames=*/{}) {}
15042 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
15043   D->addAttr(::new (S.Context) PureAttr(S.Context, Attr));
15044   return AttributeApplied;
15045 }
15046 
15047 bool isParamExpr(size_t N) const override {
15048   return false;
15049 }
15050 
15051 static const ParsedAttrInfoPure Instance;
15052 };
15053 const ParsedAttrInfoPure ParsedAttrInfoPure::Instance;
15054 static constexpr ParsedAttrInfo::Spelling RISCVRVVVectorBitsSpellings[] = {
15055   {AttributeCommonInfo::AS_GNU, "riscv_rvv_vector_bits"},
15056 };
15057 static constexpr const char *RISCVRVVVectorBitsArgNames[] = {
15058 "NumBits",};
15059 struct ParsedAttrInfoRISCVRVVVectorBits final : public ParsedAttrInfo {
15060   constexpr ParsedAttrInfoRISCVRVVVectorBits() : ParsedAttrInfo(
15061     /*AttrKind=*/ParsedAttr::AT_RISCVRVVVectorBits,
15062     /*NumArgs=*/1,
15063     /*OptArgs=*/0,
15064     /*NumArgMembers=*/1,
15065     /*HasCustomParsing=*/0,
15066     /*AcceptsExprPack=*/0,
15067     /*IsTargetSpecific=*/0,
15068     /*IsType=*/1,
15069     /*IsStmt=*/0,
15070     /*IsKnownToGCC=*/0,
15071     /*IsSupportedByPragmaAttribute=*/0,
15072     /*Spellings=*/RISCVRVVVectorBitsSpellings,
15073     /*ArgNames=*/RISCVRVVVectorBitsArgNames) {}
15074 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15075   if (!isa<TypedefNameDecl>(D)) {
15076     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
15077       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
15078     return false;
15079   }
15080   return true;
15081 }
15082 
15083 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15084   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15085     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15086   return false;
15087 }
15088 
15089 bool isParamExpr(size_t N) const override {
15090   return false;
15091 }
15092 
15093 static const ParsedAttrInfoRISCVRVVVectorBits Instance;
15094 };
15095 const ParsedAttrInfoRISCVRVVVectorBits ParsedAttrInfoRISCVRVVVectorBits::Instance;
15096 static constexpr ParsedAttrInfo::Spelling RISCVVectorCCSpellings[] = {
15097   {AttributeCommonInfo::AS_CXX11, "riscv::vector_cc"},
15098   {AttributeCommonInfo::AS_C23, "riscv::vector_cc"},
15099   {AttributeCommonInfo::AS_GNU, "riscv_vector_cc"},
15100   {AttributeCommonInfo::AS_CXX11, "clang::riscv_vector_cc"},
15101   {AttributeCommonInfo::AS_C23, "clang::riscv_vector_cc"},
15102 };
15103 struct ParsedAttrInfoRISCVVectorCC final : public ParsedAttrInfo {
15104   constexpr ParsedAttrInfoRISCVVectorCC() : ParsedAttrInfo(
15105     /*AttrKind=*/ParsedAttr::AT_RISCVVectorCC,
15106     /*NumArgs=*/0,
15107     /*OptArgs=*/0,
15108     /*NumArgMembers=*/0,
15109     /*HasCustomParsing=*/0,
15110     /*AcceptsExprPack=*/0,
15111     /*IsTargetSpecific=*/1,
15112     /*IsType=*/1,
15113     /*IsStmt=*/0,
15114     /*IsKnownToGCC=*/0,
15115     /*IsSupportedByPragmaAttribute=*/0,
15116     /*Spellings=*/RISCVVectorCCSpellings,
15117     /*ArgNames=*/{}) {}
15118 bool existsInTarget(const TargetInfo &Target) const override {
15119   const llvm::Triple &T = Target.getTriple(); (void)T;
15120   return true && (T.getArch() == llvm::Triple::riscv32 || T.getArch() == llvm::Triple::riscv64);
15121 }
15122 
15123 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
15124   enum Spelling {
15125     CXX11_riscv_vector_cc = 0,
15126     C23_riscv_vector_cc = 1,
15127     GNU_riscv_vector_cc = 2,
15128     CXX11_clang_riscv_vector_cc = 3,
15129     C23_clang_riscv_vector_cc = 4,
15130   SpellingNotCalculated = 15
15131 
15132   };
15133 
15134   unsigned Idx = Attr.getAttributeSpellingListIndex();
15135   switch (Idx) {
15136     default: llvm_unreachable("Unknown spelling list index");
15137     case 0: return CXX11_riscv_vector_cc;
15138     case 1: return C23_riscv_vector_cc;
15139     case 2: return GNU_riscv_vector_cc;
15140     case 3: return CXX11_clang_riscv_vector_cc;
15141     case 4: return C23_clang_riscv_vector_cc;
15142   }
15143 }
15144 
15145 bool isParamExpr(size_t N) const override {
15146   return false;
15147 }
15148 
15149 static const ParsedAttrInfoRISCVVectorCC Instance;
15150 };
15151 const ParsedAttrInfoRISCVVectorCC ParsedAttrInfoRISCVVectorCC::Instance;
15152 static constexpr ParsedAttrInfo::Spelling RandomizeLayoutSpellings[] = {
15153   {AttributeCommonInfo::AS_GNU, "randomize_layout"},
15154   {AttributeCommonInfo::AS_CXX11, "gnu::randomize_layout"},
15155   {AttributeCommonInfo::AS_C23, "gnu::randomize_layout"},
15156 };
15157 struct ParsedAttrInfoRandomizeLayout final : public ParsedAttrInfo {
15158   constexpr ParsedAttrInfoRandomizeLayout() : ParsedAttrInfo(
15159     /*AttrKind=*/ParsedAttr::AT_RandomizeLayout,
15160     /*NumArgs=*/0,
15161     /*OptArgs=*/0,
15162     /*NumArgMembers=*/0,
15163     /*HasCustomParsing=*/0,
15164     /*AcceptsExprPack=*/0,
15165     /*IsTargetSpecific=*/0,
15166     /*IsType=*/0,
15167     /*IsStmt=*/0,
15168     /*IsKnownToGCC=*/1,
15169     /*IsSupportedByPragmaAttribute=*/1,
15170     /*Spellings=*/RandomizeLayoutSpellings,
15171     /*ArgNames=*/{}) {}
15172 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15173   if (!isa<RecordDecl>(D)) {
15174     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15175       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
15176     return false;
15177   }
15178   return true;
15179 }
15180 
15181 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15182   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15183     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15184   return false;
15185 }
15186 
15187   using ParsedAttrInfo::diagMutualExclusion;
15188 
15189   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
15190     if (const auto *A = D->getAttr<NoRandomizeLayoutAttr>()) {
15191       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
15192       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
15193 return false;
15194     }
15195     return true;
15196   }
15197 
15198 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
15199   return (!LangOpts.CPlusPlus);
15200 }
15201 
15202 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15203   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
15204 }
15205 
15206 bool isParamExpr(size_t N) const override {
15207   return false;
15208 }
15209 
15210 static const ParsedAttrInfoRandomizeLayout Instance;
15211 };
15212 const ParsedAttrInfoRandomizeLayout ParsedAttrInfoRandomizeLayout::Instance;
15213 static constexpr ParsedAttrInfo::Spelling ReadOnlyPlacementSpellings[] = {
15214   {AttributeCommonInfo::AS_GNU, "enforce_read_only_placement"},
15215   {AttributeCommonInfo::AS_CXX11, "clang::enforce_read_only_placement"},
15216   {AttributeCommonInfo::AS_C23, "clang::enforce_read_only_placement"},
15217 };
15218 struct ParsedAttrInfoReadOnlyPlacement final : public ParsedAttrInfo {
15219   constexpr ParsedAttrInfoReadOnlyPlacement() : ParsedAttrInfo(
15220     /*AttrKind=*/ParsedAttr::AT_ReadOnlyPlacement,
15221     /*NumArgs=*/0,
15222     /*OptArgs=*/0,
15223     /*NumArgMembers=*/0,
15224     /*HasCustomParsing=*/0,
15225     /*AcceptsExprPack=*/0,
15226     /*IsTargetSpecific=*/0,
15227     /*IsType=*/0,
15228     /*IsStmt=*/0,
15229     /*IsKnownToGCC=*/0,
15230     /*IsSupportedByPragmaAttribute=*/1,
15231     /*Spellings=*/ReadOnlyPlacementSpellings,
15232     /*ArgNames=*/{}) {}
15233 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15234   if (!isa<RecordDecl>(D)) {
15235     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15236       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
15237     return false;
15238   }
15239   return true;
15240 }
15241 
15242 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15243   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15244     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15245   return false;
15246 }
15247 
15248 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15249   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
15250 }
15251 
15252 bool isParamExpr(size_t N) const override {
15253   return false;
15254 }
15255 
15256 static const ParsedAttrInfoReadOnlyPlacement Instance;
15257 };
15258 const ParsedAttrInfoReadOnlyPlacement ParsedAttrInfoReadOnlyPlacement::Instance;
15259 static constexpr ParsedAttrInfo::Spelling RegCallSpellings[] = {
15260   {AttributeCommonInfo::AS_GNU, "regcall"},
15261   {AttributeCommonInfo::AS_CXX11, "gnu::regcall"},
15262   {AttributeCommonInfo::AS_C23, "gnu::regcall"},
15263   {AttributeCommonInfo::AS_Keyword, "__regcall"},
15264 };
15265 struct ParsedAttrInfoRegCall final : public ParsedAttrInfo {
15266   constexpr ParsedAttrInfoRegCall() : ParsedAttrInfo(
15267     /*AttrKind=*/ParsedAttr::AT_RegCall,
15268     /*NumArgs=*/0,
15269     /*OptArgs=*/0,
15270     /*NumArgMembers=*/0,
15271     /*HasCustomParsing=*/0,
15272     /*AcceptsExprPack=*/0,
15273     /*IsTargetSpecific=*/0,
15274     /*IsType=*/1,
15275     /*IsStmt=*/0,
15276     /*IsKnownToGCC=*/1,
15277     /*IsSupportedByPragmaAttribute=*/0,
15278     /*Spellings=*/RegCallSpellings,
15279     /*ArgNames=*/{}) {}
15280 bool isParamExpr(size_t N) const override {
15281   return false;
15282 }
15283 
15284 static const ParsedAttrInfoRegCall Instance;
15285 };
15286 const ParsedAttrInfoRegCall ParsedAttrInfoRegCall::Instance;
15287 static constexpr ParsedAttrInfo::Spelling RegparmSpellings[] = {
15288   {AttributeCommonInfo::AS_GNU, "regparm"},
15289   {AttributeCommonInfo::AS_CXX11, "gnu::regparm"},
15290   {AttributeCommonInfo::AS_C23, "gnu::regparm"},
15291 };
15292 static constexpr const char *RegparmArgNames[] = {
15293 "NumParams",};
15294 struct ParsedAttrInfoRegparm final : public ParsedAttrInfo {
15295   constexpr ParsedAttrInfoRegparm() : ParsedAttrInfo(
15296     /*AttrKind=*/ParsedAttr::AT_Regparm,
15297     /*NumArgs=*/1,
15298     /*OptArgs=*/0,
15299     /*NumArgMembers=*/1,
15300     /*HasCustomParsing=*/0,
15301     /*AcceptsExprPack=*/0,
15302     /*IsTargetSpecific=*/0,
15303     /*IsType=*/1,
15304     /*IsStmt=*/0,
15305     /*IsKnownToGCC=*/1,
15306     /*IsSupportedByPragmaAttribute=*/0,
15307     /*Spellings=*/RegparmSpellings,
15308     /*ArgNames=*/RegparmArgNames) {}
15309 bool isParamExpr(size_t N) const override {
15310   return false;
15311 }
15312 
15313 static const ParsedAttrInfoRegparm Instance;
15314 };
15315 const ParsedAttrInfoRegparm ParsedAttrInfoRegparm::Instance;
15316 static constexpr ParsedAttrInfo::Spelling ReinitializesSpellings[] = {
15317   {AttributeCommonInfo::AS_GNU, "reinitializes"},
15318   {AttributeCommonInfo::AS_CXX11, "clang::reinitializes"},
15319 };
15320 struct ParsedAttrInfoReinitializes final : public ParsedAttrInfo {
15321   constexpr ParsedAttrInfoReinitializes() : ParsedAttrInfo(
15322     /*AttrKind=*/ParsedAttr::AT_Reinitializes,
15323     /*NumArgs=*/0,
15324     /*OptArgs=*/0,
15325     /*NumArgMembers=*/0,
15326     /*HasCustomParsing=*/0,
15327     /*AcceptsExprPack=*/0,
15328     /*IsTargetSpecific=*/0,
15329     /*IsType=*/0,
15330     /*IsStmt=*/0,
15331     /*IsKnownToGCC=*/0,
15332     /*IsSupportedByPragmaAttribute=*/0,
15333     /*Spellings=*/ReinitializesSpellings,
15334     /*ArgNames=*/{}) {}
15335 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15336   if (!isNonStaticNonConstCXXMethod(D)) {
15337     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
15338       << Attr << Attr.isRegularKeywordAttribute() << "non-static non-const member functions";
15339     return false;
15340   }
15341   return true;
15342 }
15343 
15344 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15345   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15346     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15347   return false;
15348 }
15349 
15350 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
15351   D->addAttr(::new (S.Context) ReinitializesAttr(S.Context, Attr));
15352   return AttributeApplied;
15353 }
15354 
15355 bool isParamExpr(size_t N) const override {
15356   return false;
15357 }
15358 
15359 static const ParsedAttrInfoReinitializes Instance;
15360 };
15361 const ParsedAttrInfoReinitializes ParsedAttrInfoReinitializes::Instance;
15362 static constexpr ParsedAttrInfo::Spelling ReleaseCapabilitySpellings[] = {
15363   {AttributeCommonInfo::AS_GNU, "release_capability"},
15364   {AttributeCommonInfo::AS_CXX11, "clang::release_capability"},
15365   {AttributeCommonInfo::AS_GNU, "release_shared_capability"},
15366   {AttributeCommonInfo::AS_CXX11, "clang::release_shared_capability"},
15367   {AttributeCommonInfo::AS_GNU, "release_generic_capability"},
15368   {AttributeCommonInfo::AS_CXX11, "clang::release_generic_capability"},
15369   {AttributeCommonInfo::AS_GNU, "unlock_function"},
15370   {AttributeCommonInfo::AS_CXX11, "clang::unlock_function"},
15371 };
15372 static constexpr const char *ReleaseCapabilityArgNames[] = {
15373 "Args...",};
15374 struct ParsedAttrInfoReleaseCapability final : public ParsedAttrInfo {
15375   constexpr ParsedAttrInfoReleaseCapability() : ParsedAttrInfo(
15376     /*AttrKind=*/ParsedAttr::AT_ReleaseCapability,
15377     /*NumArgs=*/0,
15378     /*OptArgs=*/15,
15379     /*NumArgMembers=*/1,
15380     /*HasCustomParsing=*/0,
15381     /*AcceptsExprPack=*/0,
15382     /*IsTargetSpecific=*/0,
15383     /*IsType=*/0,
15384     /*IsStmt=*/0,
15385     /*IsKnownToGCC=*/0,
15386     /*IsSupportedByPragmaAttribute=*/0,
15387     /*Spellings=*/ReleaseCapabilitySpellings,
15388     /*ArgNames=*/ReleaseCapabilityArgNames) {}
15389 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15390   if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) {
15391     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15392       << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters";
15393     return false;
15394   }
15395   return true;
15396 }
15397 
15398 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15399   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15400     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15401   return false;
15402 }
15403 
15404 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
15405   enum Spelling {
15406     GNU_release_capability = 0,
15407     CXX11_clang_release_capability = 1,
15408     GNU_release_shared_capability = 2,
15409     CXX11_clang_release_shared_capability = 3,
15410     GNU_release_generic_capability = 4,
15411     CXX11_clang_release_generic_capability = 5,
15412     GNU_unlock_function = 6,
15413     CXX11_clang_unlock_function = 7,
15414   SpellingNotCalculated = 15
15415 
15416   };
15417 
15418   unsigned Idx = Attr.getAttributeSpellingListIndex();
15419   switch (Idx) {
15420     default: llvm_unreachable("Unknown spelling list index");
15421     case 0: return GNU_release_capability;
15422     case 1: return CXX11_clang_release_capability;
15423     case 2: return GNU_release_shared_capability;
15424     case 3: return CXX11_clang_release_shared_capability;
15425     case 4: return GNU_release_generic_capability;
15426     case 5: return CXX11_clang_release_generic_capability;
15427     case 6: return GNU_unlock_function;
15428     case 7: return CXX11_clang_unlock_function;
15429   }
15430 }
15431 
15432 bool isParamExpr(size_t N) const override {
15433   return (N == 0) || false;
15434 }
15435 
15436 static const ParsedAttrInfoReleaseCapability Instance;
15437 };
15438 const ParsedAttrInfoReleaseCapability ParsedAttrInfoReleaseCapability::Instance;
15439 static constexpr ParsedAttrInfo::Spelling ReleaseHandleSpellings[] = {
15440   {AttributeCommonInfo::AS_GNU, "release_handle"},
15441   {AttributeCommonInfo::AS_CXX11, "clang::release_handle"},
15442   {AttributeCommonInfo::AS_C23, "clang::release_handle"},
15443 };
15444 static constexpr const char *ReleaseHandleArgNames[] = {
15445 "HandleType",};
15446 struct ParsedAttrInfoReleaseHandle final : public ParsedAttrInfo {
15447   constexpr ParsedAttrInfoReleaseHandle() : ParsedAttrInfo(
15448     /*AttrKind=*/ParsedAttr::AT_ReleaseHandle,
15449     /*NumArgs=*/1,
15450     /*OptArgs=*/0,
15451     /*NumArgMembers=*/1,
15452     /*HasCustomParsing=*/0,
15453     /*AcceptsExprPack=*/0,
15454     /*IsTargetSpecific=*/0,
15455     /*IsType=*/0,
15456     /*IsStmt=*/0,
15457     /*IsKnownToGCC=*/0,
15458     /*IsSupportedByPragmaAttribute=*/1,
15459     /*Spellings=*/ReleaseHandleSpellings,
15460     /*ArgNames=*/ReleaseHandleArgNames) {}
15461 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15462   if (!isa<ParmVarDecl>(D)) {
15463     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15464       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
15465     return false;
15466   }
15467   return true;
15468 }
15469 
15470 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15471   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15472     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15473   return false;
15474 }
15475 
15476 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15477   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
15478 }
15479 
15480 bool isParamExpr(size_t N) const override {
15481   return false;
15482 }
15483 
15484 static const ParsedAttrInfoReleaseHandle Instance;
15485 };
15486 const ParsedAttrInfoReleaseHandle ParsedAttrInfoReleaseHandle::Instance;
15487 static constexpr ParsedAttrInfo::Spelling ReqdWorkGroupSizeSpellings[] = {
15488   {AttributeCommonInfo::AS_GNU, "reqd_work_group_size"},
15489 };
15490 static constexpr const char *ReqdWorkGroupSizeArgNames[] = {
15491 "XDim","YDim","ZDim",};
15492 struct ParsedAttrInfoReqdWorkGroupSize final : public ParsedAttrInfo {
15493   constexpr ParsedAttrInfoReqdWorkGroupSize() : ParsedAttrInfo(
15494     /*AttrKind=*/ParsedAttr::AT_ReqdWorkGroupSize,
15495     /*NumArgs=*/3,
15496     /*OptArgs=*/0,
15497     /*NumArgMembers=*/3,
15498     /*HasCustomParsing=*/0,
15499     /*AcceptsExprPack=*/0,
15500     /*IsTargetSpecific=*/0,
15501     /*IsType=*/0,
15502     /*IsStmt=*/0,
15503     /*IsKnownToGCC=*/0,
15504     /*IsSupportedByPragmaAttribute=*/1,
15505     /*Spellings=*/ReqdWorkGroupSizeSpellings,
15506     /*ArgNames=*/ReqdWorkGroupSizeArgNames) {}
15507 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15508   if (!isa<FunctionDecl>(D)) {
15509     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
15510       << Attr << Attr.isRegularKeywordAttribute() << "functions";
15511     return false;
15512   }
15513   return true;
15514 }
15515 
15516 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15517   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15518     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15519   return false;
15520 }
15521 
15522 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15523   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15524 }
15525 
15526 bool isParamExpr(size_t N) const override {
15527   return false;
15528 }
15529 
15530 static const ParsedAttrInfoReqdWorkGroupSize Instance;
15531 };
15532 const ParsedAttrInfoReqdWorkGroupSize ParsedAttrInfoReqdWorkGroupSize::Instance;
15533 static constexpr ParsedAttrInfo::Spelling RequiresCapabilitySpellings[] = {
15534   {AttributeCommonInfo::AS_GNU, "requires_capability"},
15535   {AttributeCommonInfo::AS_CXX11, "clang::requires_capability"},
15536   {AttributeCommonInfo::AS_GNU, "exclusive_locks_required"},
15537   {AttributeCommonInfo::AS_CXX11, "clang::exclusive_locks_required"},
15538   {AttributeCommonInfo::AS_GNU, "requires_shared_capability"},
15539   {AttributeCommonInfo::AS_CXX11, "clang::requires_shared_capability"},
15540   {AttributeCommonInfo::AS_GNU, "shared_locks_required"},
15541   {AttributeCommonInfo::AS_CXX11, "clang::shared_locks_required"},
15542 };
15543 static constexpr const char *RequiresCapabilityArgNames[] = {
15544 "Args...",};
15545 struct ParsedAttrInfoRequiresCapability final : public ParsedAttrInfo {
15546   constexpr ParsedAttrInfoRequiresCapability() : ParsedAttrInfo(
15547     /*AttrKind=*/ParsedAttr::AT_RequiresCapability,
15548     /*NumArgs=*/0,
15549     /*OptArgs=*/15,
15550     /*NumArgMembers=*/1,
15551     /*HasCustomParsing=*/0,
15552     /*AcceptsExprPack=*/0,
15553     /*IsTargetSpecific=*/0,
15554     /*IsType=*/0,
15555     /*IsStmt=*/0,
15556     /*IsKnownToGCC=*/0,
15557     /*IsSupportedByPragmaAttribute=*/0,
15558     /*Spellings=*/RequiresCapabilitySpellings,
15559     /*ArgNames=*/RequiresCapabilityArgNames) {}
15560 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15561   if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) {
15562     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15563       << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters";
15564     return false;
15565   }
15566   return true;
15567 }
15568 
15569 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15570   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15571     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15572   return false;
15573 }
15574 
15575 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
15576   enum Spelling {
15577     GNU_requires_capability = 0,
15578     CXX11_clang_requires_capability = 1,
15579     GNU_exclusive_locks_required = 2,
15580     CXX11_clang_exclusive_locks_required = 3,
15581     GNU_requires_shared_capability = 4,
15582     CXX11_clang_requires_shared_capability = 5,
15583     GNU_shared_locks_required = 6,
15584     CXX11_clang_shared_locks_required = 7,
15585   SpellingNotCalculated = 15
15586 
15587   };
15588 
15589   unsigned Idx = Attr.getAttributeSpellingListIndex();
15590   switch (Idx) {
15591     default: llvm_unreachable("Unknown spelling list index");
15592     case 0: return GNU_requires_capability;
15593     case 1: return CXX11_clang_requires_capability;
15594     case 2: return GNU_exclusive_locks_required;
15595     case 3: return CXX11_clang_exclusive_locks_required;
15596     case 4: return GNU_requires_shared_capability;
15597     case 5: return CXX11_clang_requires_shared_capability;
15598     case 6: return GNU_shared_locks_required;
15599     case 7: return CXX11_clang_shared_locks_required;
15600   }
15601 }
15602 
15603 bool isParamExpr(size_t N) const override {
15604   return (N == 0) || false;
15605 }
15606 
15607 static const ParsedAttrInfoRequiresCapability Instance;
15608 };
15609 const ParsedAttrInfoRequiresCapability ParsedAttrInfoRequiresCapability::Instance;
15610 static constexpr ParsedAttrInfo::Spelling RestrictSpellings[] = {
15611   {AttributeCommonInfo::AS_Declspec, "restrict"},
15612   {AttributeCommonInfo::AS_GNU, "malloc"},
15613   {AttributeCommonInfo::AS_CXX11, "gnu::malloc"},
15614   {AttributeCommonInfo::AS_C23, "gnu::malloc"},
15615 };
15616 struct ParsedAttrInfoRestrict final : public ParsedAttrInfo {
15617   constexpr ParsedAttrInfoRestrict() : ParsedAttrInfo(
15618     /*AttrKind=*/ParsedAttr::AT_Restrict,
15619     /*NumArgs=*/0,
15620     /*OptArgs=*/0,
15621     /*NumArgMembers=*/0,
15622     /*HasCustomParsing=*/0,
15623     /*AcceptsExprPack=*/0,
15624     /*IsTargetSpecific=*/0,
15625     /*IsType=*/0,
15626     /*IsStmt=*/0,
15627     /*IsKnownToGCC=*/1,
15628     /*IsSupportedByPragmaAttribute=*/1,
15629     /*Spellings=*/RestrictSpellings,
15630     /*ArgNames=*/{}) {}
15631 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15632   if (!isa<FunctionDecl>(D)) {
15633     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15634       << Attr << Attr.isRegularKeywordAttribute() << "functions";
15635     return false;
15636   }
15637   return true;
15638 }
15639 
15640 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15641   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15642     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15643   return false;
15644 }
15645 
15646 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
15647   enum Spelling {
15648     Declspec_restrict = 0,
15649     GNU_malloc = 1,
15650     CXX11_gnu_malloc = 2,
15651     C23_gnu_malloc = 3,
15652   SpellingNotCalculated = 15
15653 
15654   };
15655 
15656   unsigned Idx = Attr.getAttributeSpellingListIndex();
15657   switch (Idx) {
15658     default: llvm_unreachable("Unknown spelling list index");
15659     case 0: return Declspec_restrict;
15660     case 1: return GNU_malloc;
15661     case 2: return CXX11_gnu_malloc;
15662     case 3: return C23_gnu_malloc;
15663   }
15664 }
15665 
15666 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15667   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15668 }
15669 
15670 bool isParamExpr(size_t N) const override {
15671   return false;
15672 }
15673 
15674 static const ParsedAttrInfoRestrict Instance;
15675 };
15676 const ParsedAttrInfoRestrict ParsedAttrInfoRestrict::Instance;
15677 static constexpr ParsedAttrInfo::Spelling RetainSpellings[] = {
15678   {AttributeCommonInfo::AS_GNU, "retain"},
15679   {AttributeCommonInfo::AS_CXX11, "gnu::retain"},
15680   {AttributeCommonInfo::AS_C23, "gnu::retain"},
15681 };
15682 struct ParsedAttrInfoRetain final : public ParsedAttrInfo {
15683   constexpr ParsedAttrInfoRetain() : ParsedAttrInfo(
15684     /*AttrKind=*/ParsedAttr::AT_Retain,
15685     /*NumArgs=*/0,
15686     /*OptArgs=*/0,
15687     /*NumArgMembers=*/0,
15688     /*HasCustomParsing=*/0,
15689     /*AcceptsExprPack=*/0,
15690     /*IsTargetSpecific=*/0,
15691     /*IsType=*/0,
15692     /*IsStmt=*/0,
15693     /*IsKnownToGCC=*/1,
15694     /*IsSupportedByPragmaAttribute=*/0,
15695     /*Spellings=*/RetainSpellings,
15696     /*ArgNames=*/{}) {}
15697 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15698   if (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
15699     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15700       << Attr << Attr.isRegularKeywordAttribute() << "variables with non-local storage, functions, and Objective-C methods";
15701     return false;
15702   }
15703   return true;
15704 }
15705 
15706 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15707   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15708     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15709   return false;
15710 }
15711 
15712 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
15713   D->addAttr(::new (S.Context) RetainAttr(S.Context, Attr));
15714   return AttributeApplied;
15715 }
15716 
15717 bool isParamExpr(size_t N) const override {
15718   return false;
15719 }
15720 
15721 static const ParsedAttrInfoRetain Instance;
15722 };
15723 const ParsedAttrInfoRetain ParsedAttrInfoRetain::Instance;
15724 static constexpr ParsedAttrInfo::Spelling ReturnTypestateSpellings[] = {
15725   {AttributeCommonInfo::AS_GNU, "return_typestate"},
15726   {AttributeCommonInfo::AS_CXX11, "clang::return_typestate"},
15727 };
15728 static constexpr const char *ReturnTypestateArgNames[] = {
15729 "State",};
15730 struct ParsedAttrInfoReturnTypestate final : public ParsedAttrInfo {
15731   constexpr ParsedAttrInfoReturnTypestate() : ParsedAttrInfo(
15732     /*AttrKind=*/ParsedAttr::AT_ReturnTypestate,
15733     /*NumArgs=*/1,
15734     /*OptArgs=*/0,
15735     /*NumArgMembers=*/1,
15736     /*HasCustomParsing=*/0,
15737     /*AcceptsExprPack=*/0,
15738     /*IsTargetSpecific=*/0,
15739     /*IsType=*/0,
15740     /*IsStmt=*/0,
15741     /*IsKnownToGCC=*/0,
15742     /*IsSupportedByPragmaAttribute=*/1,
15743     /*Spellings=*/ReturnTypestateSpellings,
15744     /*ArgNames=*/ReturnTypestateArgNames) {}
15745 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15746   if (!isa<FunctionDecl>(D) && !isa<ParmVarDecl>(D)) {
15747     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15748       << Attr << Attr.isRegularKeywordAttribute() << "functions and parameters";
15749     return false;
15750   }
15751   return true;
15752 }
15753 
15754 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15755   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15756     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15757   return false;
15758 }
15759 
15760 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15761   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15762   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
15763 }
15764 
15765 bool isParamExpr(size_t N) const override {
15766   return false;
15767 }
15768 
15769 static const ParsedAttrInfoReturnTypestate Instance;
15770 };
15771 const ParsedAttrInfoReturnTypestate ParsedAttrInfoReturnTypestate::Instance;
15772 static constexpr ParsedAttrInfo::Spelling ReturnsNonNullSpellings[] = {
15773   {AttributeCommonInfo::AS_GNU, "returns_nonnull"},
15774   {AttributeCommonInfo::AS_CXX11, "gnu::returns_nonnull"},
15775   {AttributeCommonInfo::AS_C23, "gnu::returns_nonnull"},
15776 };
15777 struct ParsedAttrInfoReturnsNonNull final : public ParsedAttrInfo {
15778   constexpr ParsedAttrInfoReturnsNonNull() : ParsedAttrInfo(
15779     /*AttrKind=*/ParsedAttr::AT_ReturnsNonNull,
15780     /*NumArgs=*/0,
15781     /*OptArgs=*/0,
15782     /*NumArgMembers=*/0,
15783     /*HasCustomParsing=*/0,
15784     /*AcceptsExprPack=*/0,
15785     /*IsTargetSpecific=*/0,
15786     /*IsType=*/0,
15787     /*IsStmt=*/0,
15788     /*IsKnownToGCC=*/1,
15789     /*IsSupportedByPragmaAttribute=*/1,
15790     /*Spellings=*/ReturnsNonNullSpellings,
15791     /*ArgNames=*/{}) {}
15792 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15793   if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) {
15794     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15795       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions";
15796     return false;
15797   }
15798   return true;
15799 }
15800 
15801 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15802   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15803     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15804   return false;
15805 }
15806 
15807 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15808   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
15809   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15810 }
15811 
15812 bool isParamExpr(size_t N) const override {
15813   return false;
15814 }
15815 
15816 static const ParsedAttrInfoReturnsNonNull Instance;
15817 };
15818 const ParsedAttrInfoReturnsNonNull ParsedAttrInfoReturnsNonNull::Instance;
15819 static constexpr ParsedAttrInfo::Spelling ReturnsTwiceSpellings[] = {
15820   {AttributeCommonInfo::AS_GNU, "returns_twice"},
15821   {AttributeCommonInfo::AS_CXX11, "gnu::returns_twice"},
15822   {AttributeCommonInfo::AS_C23, "gnu::returns_twice"},
15823 };
15824 struct ParsedAttrInfoReturnsTwice final : public ParsedAttrInfo {
15825   constexpr ParsedAttrInfoReturnsTwice() : ParsedAttrInfo(
15826     /*AttrKind=*/ParsedAttr::AT_ReturnsTwice,
15827     /*NumArgs=*/0,
15828     /*OptArgs=*/0,
15829     /*NumArgMembers=*/0,
15830     /*HasCustomParsing=*/0,
15831     /*AcceptsExprPack=*/0,
15832     /*IsTargetSpecific=*/0,
15833     /*IsType=*/0,
15834     /*IsStmt=*/0,
15835     /*IsKnownToGCC=*/1,
15836     /*IsSupportedByPragmaAttribute=*/1,
15837     /*Spellings=*/ReturnsTwiceSpellings,
15838     /*ArgNames=*/{}) {}
15839 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15840   if (!isa<FunctionDecl>(D)) {
15841     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15842       << Attr << Attr.isRegularKeywordAttribute() << "functions";
15843     return false;
15844   }
15845   return true;
15846 }
15847 
15848 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15849   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15850     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15851   return false;
15852 }
15853 
15854 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15855   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15856 }
15857 
15858 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
15859   D->addAttr(::new (S.Context) ReturnsTwiceAttr(S.Context, Attr));
15860   return AttributeApplied;
15861 }
15862 
15863 bool isParamExpr(size_t N) const override {
15864   return false;
15865 }
15866 
15867 static const ParsedAttrInfoReturnsTwice Instance;
15868 };
15869 const ParsedAttrInfoReturnsTwice ParsedAttrInfoReturnsTwice::Instance;
15870 static constexpr ParsedAttrInfo::Spelling SPtrSpellings[] = {
15871   {AttributeCommonInfo::AS_Keyword, "__sptr"},
15872 };
15873 struct ParsedAttrInfoSPtr final : public ParsedAttrInfo {
15874   constexpr ParsedAttrInfoSPtr() : ParsedAttrInfo(
15875     /*AttrKind=*/ParsedAttr::AT_SPtr,
15876     /*NumArgs=*/0,
15877     /*OptArgs=*/0,
15878     /*NumArgMembers=*/0,
15879     /*HasCustomParsing=*/0,
15880     /*AcceptsExprPack=*/0,
15881     /*IsTargetSpecific=*/0,
15882     /*IsType=*/1,
15883     /*IsStmt=*/0,
15884     /*IsKnownToGCC=*/0,
15885     /*IsSupportedByPragmaAttribute=*/0,
15886     /*Spellings=*/SPtrSpellings,
15887     /*ArgNames=*/{}) {}
15888 bool isParamExpr(size_t N) const override {
15889   return false;
15890 }
15891 
15892 static const ParsedAttrInfoSPtr Instance;
15893 };
15894 const ParsedAttrInfoSPtr ParsedAttrInfoSPtr::Instance;
15895 static constexpr ParsedAttrInfo::Spelling SYCLKernelSpellings[] = {
15896   {AttributeCommonInfo::AS_GNU, "sycl_kernel"},
15897   {AttributeCommonInfo::AS_CXX11, "clang::sycl_kernel"},
15898   {AttributeCommonInfo::AS_C23, "clang::sycl_kernel"},
15899 };
15900 struct ParsedAttrInfoSYCLKernel final : public ParsedAttrInfo {
15901   constexpr ParsedAttrInfoSYCLKernel() : ParsedAttrInfo(
15902     /*AttrKind=*/ParsedAttr::AT_SYCLKernel,
15903     /*NumArgs=*/0,
15904     /*OptArgs=*/0,
15905     /*NumArgMembers=*/0,
15906     /*HasCustomParsing=*/0,
15907     /*AcceptsExprPack=*/0,
15908     /*IsTargetSpecific=*/0,
15909     /*IsType=*/0,
15910     /*IsStmt=*/0,
15911     /*IsKnownToGCC=*/0,
15912     /*IsSupportedByPragmaAttribute=*/0,
15913     /*Spellings=*/SYCLKernelSpellings,
15914     /*ArgNames=*/{}) {}
15915 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15916   if (!isFunctionTmpl(D)) {
15917     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
15918       << Attr << Attr.isRegularKeywordAttribute() << "function templates";
15919     return false;
15920   }
15921   return true;
15922 }
15923 
15924 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15925   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15926     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15927   return false;
15928 }
15929 
15930 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
15931   return LangOpts.SYCLIsDevice;
15932 }
15933 
15934 bool isParamExpr(size_t N) const override {
15935   return false;
15936 }
15937 
15938 static const ParsedAttrInfoSYCLKernel Instance;
15939 };
15940 const ParsedAttrInfoSYCLKernel ParsedAttrInfoSYCLKernel::Instance;
15941 static constexpr ParsedAttrInfo::Spelling SYCLKernelEntryPointSpellings[] = {
15942   {AttributeCommonInfo::AS_GNU, "sycl_kernel_entry_point"},
15943   {AttributeCommonInfo::AS_CXX11, "clang::sycl_kernel_entry_point"},
15944   {AttributeCommonInfo::AS_C23, "clang::sycl_kernel_entry_point"},
15945 };
15946 static constexpr const char *SYCLKernelEntryPointArgNames[] = {
15947 "KernelName",};
15948 struct ParsedAttrInfoSYCLKernelEntryPoint final : public ParsedAttrInfo {
15949   constexpr ParsedAttrInfoSYCLKernelEntryPoint() : ParsedAttrInfo(
15950     /*AttrKind=*/ParsedAttr::AT_SYCLKernelEntryPoint,
15951     /*NumArgs=*/1,
15952     /*OptArgs=*/0,
15953     /*NumArgMembers=*/1,
15954     /*HasCustomParsing=*/0,
15955     /*AcceptsExprPack=*/0,
15956     /*IsTargetSpecific=*/0,
15957     /*IsType=*/0,
15958     /*IsStmt=*/0,
15959     /*IsKnownToGCC=*/0,
15960     /*IsSupportedByPragmaAttribute=*/1,
15961     /*Spellings=*/SYCLKernelEntryPointSpellings,
15962     /*ArgNames=*/SYCLKernelEntryPointArgNames) {}
15963 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
15964   if (!isa<FunctionDecl>(D)) {
15965     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
15966       << Attr << Attr.isRegularKeywordAttribute() << "functions";
15967     return false;
15968   }
15969   return true;
15970 }
15971 
15972 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
15973   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
15974     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
15975   return false;
15976 }
15977 
15978 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
15979   return LangOpts.SYCLIsHost || LangOpts.SYCLIsDevice;
15980 }
15981 
15982 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
15983   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
15984 }
15985 
15986 bool isParamExpr(size_t N) const override {
15987   return false;
15988 }
15989 
15990 static const ParsedAttrInfoSYCLKernelEntryPoint Instance;
15991 };
15992 const ParsedAttrInfoSYCLKernelEntryPoint ParsedAttrInfoSYCLKernelEntryPoint::Instance;
15993 static constexpr ParsedAttrInfo::Spelling SYCLSpecialClassSpellings[] = {
15994   {AttributeCommonInfo::AS_GNU, "sycl_special_class"},
15995   {AttributeCommonInfo::AS_CXX11, "clang::sycl_special_class"},
15996   {AttributeCommonInfo::AS_C23, "clang::sycl_special_class"},
15997 };
15998 struct ParsedAttrInfoSYCLSpecialClass final : public ParsedAttrInfo {
15999   constexpr ParsedAttrInfoSYCLSpecialClass() : ParsedAttrInfo(
16000     /*AttrKind=*/ParsedAttr::AT_SYCLSpecialClass,
16001     /*NumArgs=*/0,
16002     /*OptArgs=*/0,
16003     /*NumArgMembers=*/0,
16004     /*HasCustomParsing=*/0,
16005     /*AcceptsExprPack=*/0,
16006     /*IsTargetSpecific=*/0,
16007     /*IsType=*/0,
16008     /*IsStmt=*/0,
16009     /*IsKnownToGCC=*/0,
16010     /*IsSupportedByPragmaAttribute=*/1,
16011     /*Spellings=*/SYCLSpecialClassSpellings,
16012     /*ArgNames=*/{}) {}
16013 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16014   if (!isa<CXXRecordDecl>(D)) {
16015     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16016       << Attr << Attr.isRegularKeywordAttribute() << "classes";
16017     return false;
16018   }
16019   return true;
16020 }
16021 
16022 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16023   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16024     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16025   return false;
16026 }
16027 
16028 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
16029   return LangOpts.SYCLIsDevice;
16030 }
16031 
16032 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16033   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
16034 }
16035 
16036 bool isParamExpr(size_t N) const override {
16037   return false;
16038 }
16039 
16040 static const ParsedAttrInfoSYCLSpecialClass Instance;
16041 };
16042 const ParsedAttrInfoSYCLSpecialClass ParsedAttrInfoSYCLSpecialClass::Instance;
16043 static constexpr ParsedAttrInfo::Spelling ScopedLockableSpellings[] = {
16044   {AttributeCommonInfo::AS_GNU, "scoped_lockable"},
16045   {AttributeCommonInfo::AS_CXX11, "clang::scoped_lockable"},
16046 };
16047 struct ParsedAttrInfoScopedLockable final : public ParsedAttrInfo {
16048   constexpr ParsedAttrInfoScopedLockable() : ParsedAttrInfo(
16049     /*AttrKind=*/ParsedAttr::AT_ScopedLockable,
16050     /*NumArgs=*/0,
16051     /*OptArgs=*/0,
16052     /*NumArgMembers=*/0,
16053     /*HasCustomParsing=*/0,
16054     /*AcceptsExprPack=*/0,
16055     /*IsTargetSpecific=*/0,
16056     /*IsType=*/0,
16057     /*IsStmt=*/0,
16058     /*IsKnownToGCC=*/0,
16059     /*IsSupportedByPragmaAttribute=*/1,
16060     /*Spellings=*/ScopedLockableSpellings,
16061     /*ArgNames=*/{}) {}
16062 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16063   if (!isa<RecordDecl>(D)) {
16064     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16065       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
16066     return false;
16067   }
16068   return true;
16069 }
16070 
16071 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16072   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16073     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16074   return false;
16075 }
16076 
16077 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16078   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
16079 }
16080 
16081 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
16082   D->addAttr(::new (S.Context) ScopedLockableAttr(S.Context, Attr));
16083   return AttributeApplied;
16084 }
16085 
16086 bool isParamExpr(size_t N) const override {
16087   return false;
16088 }
16089 
16090 static const ParsedAttrInfoScopedLockable Instance;
16091 };
16092 const ParsedAttrInfoScopedLockable ParsedAttrInfoScopedLockable::Instance;
16093 static constexpr ParsedAttrInfo::Spelling SectionSpellings[] = {
16094   {AttributeCommonInfo::AS_GNU, "section"},
16095   {AttributeCommonInfo::AS_CXX11, "gnu::section"},
16096   {AttributeCommonInfo::AS_C23, "gnu::section"},
16097   {AttributeCommonInfo::AS_Declspec, "allocate"},
16098 };
16099 static constexpr const char *SectionArgNames[] = {
16100 "Name",};
16101 struct ParsedAttrInfoSection final : public ParsedAttrInfo {
16102   constexpr ParsedAttrInfoSection() : ParsedAttrInfo(
16103     /*AttrKind=*/ParsedAttr::AT_Section,
16104     /*NumArgs=*/1,
16105     /*OptArgs=*/0,
16106     /*NumArgMembers=*/1,
16107     /*HasCustomParsing=*/0,
16108     /*AcceptsExprPack=*/0,
16109     /*IsTargetSpecific=*/0,
16110     /*IsType=*/0,
16111     /*IsStmt=*/0,
16112     /*IsKnownToGCC=*/1,
16113     /*IsSupportedByPragmaAttribute=*/1,
16114     /*Spellings=*/SectionSpellings,
16115     /*ArgNames=*/SectionArgNames) {}
16116 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16117   if (!isa<FunctionDecl>(D) && !isGlobalVar(D) && !isa<ObjCMethodDecl>(D) && !isa<ObjCPropertyDecl>(D)) {
16118     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16119       << Attr << Attr.isRegularKeywordAttribute() << "functions, global variables, Objective-C methods, and Objective-C properties";
16120     return false;
16121   }
16122   return true;
16123 }
16124 
16125 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16126   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16127     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16128   return false;
16129 }
16130 
16131 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
16132   enum Spelling {
16133     GNU_section = 0,
16134     CXX11_gnu_section = 1,
16135     C23_gnu_section = 2,
16136     Declspec_allocate = 3,
16137   SpellingNotCalculated = 15
16138 
16139   };
16140 
16141   unsigned Idx = Attr.getAttributeSpellingListIndex();
16142   switch (Idx) {
16143     default: llvm_unreachable("Unknown spelling list index");
16144     case 0: return GNU_section;
16145     case 1: return CXX11_gnu_section;
16146     case 2: return C23_gnu_section;
16147     case 3: return Declspec_allocate;
16148   }
16149 }
16150 
16151 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16152   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
16153   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_global, /*IsSupported=*/true));
16154   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
16155   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_property, /*IsSupported=*/LangOpts.ObjC));
16156 }
16157 
16158 bool isParamExpr(size_t N) const override {
16159   return false;
16160 }
16161 
16162 static const ParsedAttrInfoSection Instance;
16163 };
16164 const ParsedAttrInfoSection ParsedAttrInfoSection::Instance;
16165 static constexpr ParsedAttrInfo::Spelling SelectAnySpellings[] = {
16166   {AttributeCommonInfo::AS_Declspec, "selectany"},
16167   {AttributeCommonInfo::AS_GNU, "selectany"},
16168   {AttributeCommonInfo::AS_CXX11, "gnu::selectany"},
16169   {AttributeCommonInfo::AS_C23, "gnu::selectany"},
16170 };
16171 struct ParsedAttrInfoSelectAny final : public ParsedAttrInfo {
16172   constexpr ParsedAttrInfoSelectAny() : ParsedAttrInfo(
16173     /*AttrKind=*/ParsedAttr::AT_SelectAny,
16174     /*NumArgs=*/0,
16175     /*OptArgs=*/0,
16176     /*NumArgMembers=*/0,
16177     /*HasCustomParsing=*/0,
16178     /*AcceptsExprPack=*/0,
16179     /*IsTargetSpecific=*/0,
16180     /*IsType=*/0,
16181     /*IsStmt=*/0,
16182     /*IsKnownToGCC=*/1,
16183     /*IsSupportedByPragmaAttribute=*/0,
16184     /*Spellings=*/SelectAnySpellings,
16185     /*ArgNames=*/{}) {}
16186 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
16187   D->addAttr(::new (S.Context) SelectAnyAttr(S.Context, Attr));
16188   return AttributeApplied;
16189 }
16190 
16191 bool isParamExpr(size_t N) const override {
16192   return false;
16193 }
16194 
16195 static const ParsedAttrInfoSelectAny Instance;
16196 };
16197 const ParsedAttrInfoSelectAny ParsedAttrInfoSelectAny::Instance;
16198 static constexpr ParsedAttrInfo::Spelling SentinelSpellings[] = {
16199   {AttributeCommonInfo::AS_GNU, "sentinel"},
16200   {AttributeCommonInfo::AS_CXX11, "gnu::sentinel"},
16201   {AttributeCommonInfo::AS_C23, "gnu::sentinel"},
16202 };
16203 static constexpr const char *SentinelArgNames[] = {
16204 "Sentinel","NullPos",};
16205 struct ParsedAttrInfoSentinel final : public ParsedAttrInfo {
16206   constexpr ParsedAttrInfoSentinel() : ParsedAttrInfo(
16207     /*AttrKind=*/ParsedAttr::AT_Sentinel,
16208     /*NumArgs=*/0,
16209     /*OptArgs=*/2,
16210     /*NumArgMembers=*/2,
16211     /*HasCustomParsing=*/0,
16212     /*AcceptsExprPack=*/0,
16213     /*IsTargetSpecific=*/0,
16214     /*IsType=*/0,
16215     /*IsStmt=*/0,
16216     /*IsKnownToGCC=*/1,
16217     /*IsSupportedByPragmaAttribute=*/0,
16218     /*Spellings=*/SentinelSpellings,
16219     /*ArgNames=*/SentinelArgNames) {}
16220 bool isParamExpr(size_t N) const override {
16221   return false;
16222 }
16223 
16224 static const ParsedAttrInfoSentinel Instance;
16225 };
16226 const ParsedAttrInfoSentinel ParsedAttrInfoSentinel::Instance;
16227 static constexpr ParsedAttrInfo::Spelling SetTypestateSpellings[] = {
16228   {AttributeCommonInfo::AS_GNU, "set_typestate"},
16229   {AttributeCommonInfo::AS_CXX11, "clang::set_typestate"},
16230 };
16231 static constexpr const char *SetTypestateArgNames[] = {
16232 "NewState",};
16233 struct ParsedAttrInfoSetTypestate final : public ParsedAttrInfo {
16234   constexpr ParsedAttrInfoSetTypestate() : ParsedAttrInfo(
16235     /*AttrKind=*/ParsedAttr::AT_SetTypestate,
16236     /*NumArgs=*/1,
16237     /*OptArgs=*/0,
16238     /*NumArgMembers=*/1,
16239     /*HasCustomParsing=*/0,
16240     /*AcceptsExprPack=*/0,
16241     /*IsTargetSpecific=*/0,
16242     /*IsType=*/0,
16243     /*IsStmt=*/0,
16244     /*IsKnownToGCC=*/0,
16245     /*IsSupportedByPragmaAttribute=*/1,
16246     /*Spellings=*/SetTypestateSpellings,
16247     /*ArgNames=*/SetTypestateArgNames) {}
16248 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16249   if (!isa<CXXMethodDecl>(D)) {
16250     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16251       << Attr << Attr.isRegularKeywordAttribute() << "functions";
16252     return false;
16253   }
16254   return true;
16255 }
16256 
16257 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16258   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16259     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16260   return false;
16261 }
16262 
16263 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16264   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
16265 }
16266 
16267 bool isParamExpr(size_t N) const override {
16268   return false;
16269 }
16270 
16271 static const ParsedAttrInfoSetTypestate Instance;
16272 };
16273 const ParsedAttrInfoSetTypestate ParsedAttrInfoSetTypestate::Instance;
16274 static constexpr ParsedAttrInfo::Spelling SharedTrylockFunctionSpellings[] = {
16275   {AttributeCommonInfo::AS_GNU, "shared_trylock_function"},
16276 };
16277 static constexpr const char *SharedTrylockFunctionArgNames[] = {
16278 "SuccessValue","Args...",};
16279 struct ParsedAttrInfoSharedTrylockFunction final : public ParsedAttrInfo {
16280   constexpr ParsedAttrInfoSharedTrylockFunction() : ParsedAttrInfo(
16281     /*AttrKind=*/ParsedAttr::AT_SharedTrylockFunction,
16282     /*NumArgs=*/1,
16283     /*OptArgs=*/15,
16284     /*NumArgMembers=*/2,
16285     /*HasCustomParsing=*/0,
16286     /*AcceptsExprPack=*/0,
16287     /*IsTargetSpecific=*/0,
16288     /*IsType=*/0,
16289     /*IsStmt=*/0,
16290     /*IsKnownToGCC=*/0,
16291     /*IsSupportedByPragmaAttribute=*/0,
16292     /*Spellings=*/SharedTrylockFunctionSpellings,
16293     /*ArgNames=*/SharedTrylockFunctionArgNames) {}
16294 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16295   if (!isa<FunctionDecl>(D)) {
16296     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16297       << Attr << Attr.isRegularKeywordAttribute() << "functions";
16298     return false;
16299   }
16300   return true;
16301 }
16302 
16303 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16304   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16305     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16306   return false;
16307 }
16308 
16309 bool isParamExpr(size_t N) const override {
16310   return (N == 0) || (N == 1) || false;
16311 }
16312 
16313 static const ParsedAttrInfoSharedTrylockFunction Instance;
16314 };
16315 const ParsedAttrInfoSharedTrylockFunction ParsedAttrInfoSharedTrylockFunction::Instance;
16316 static constexpr ParsedAttrInfo::Spelling SizedBySpellings[] = {
16317   {AttributeCommonInfo::AS_GNU, "sized_by"},
16318   {AttributeCommonInfo::AS_CXX11, "clang::sized_by"},
16319   {AttributeCommonInfo::AS_C23, "clang::sized_by"},
16320 };
16321 static constexpr const char *SizedByArgNames[] = {
16322 "Size","NestedLevel",};
16323 struct ParsedAttrInfoSizedBy final : public ParsedAttrInfo {
16324   constexpr ParsedAttrInfoSizedBy() : ParsedAttrInfo(
16325     /*AttrKind=*/ParsedAttr::AT_SizedBy,
16326     /*NumArgs=*/1,
16327     /*OptArgs=*/1,
16328     /*NumArgMembers=*/2,
16329     /*HasCustomParsing=*/0,
16330     /*AcceptsExprPack=*/0,
16331     /*IsTargetSpecific=*/0,
16332     /*IsType=*/1,
16333     /*IsStmt=*/0,
16334     /*IsKnownToGCC=*/0,
16335     /*IsSupportedByPragmaAttribute=*/0,
16336     /*Spellings=*/SizedBySpellings,
16337     /*ArgNames=*/SizedByArgNames) {}
16338 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16339   if (!isa<FieldDecl>(D)) {
16340     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16341       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members";
16342     return false;
16343   }
16344   return true;
16345 }
16346 
16347 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16348   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16349     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16350   return false;
16351 }
16352 
16353 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
16354   return (!LangOpts.CPlusPlus);
16355 }
16356 
16357 bool isParamExpr(size_t N) const override {
16358   return (N == 0) || false;
16359 }
16360 
16361 static const ParsedAttrInfoSizedBy Instance;
16362 };
16363 const ParsedAttrInfoSizedBy ParsedAttrInfoSizedBy::Instance;
16364 static constexpr ParsedAttrInfo::Spelling SizedByOrNullSpellings[] = {
16365   {AttributeCommonInfo::AS_GNU, "sized_by_or_null"},
16366   {AttributeCommonInfo::AS_CXX11, "clang::sized_by_or_null"},
16367   {AttributeCommonInfo::AS_C23, "clang::sized_by_or_null"},
16368 };
16369 static constexpr const char *SizedByOrNullArgNames[] = {
16370 "Size","NestedLevel",};
16371 struct ParsedAttrInfoSizedByOrNull final : public ParsedAttrInfo {
16372   constexpr ParsedAttrInfoSizedByOrNull() : ParsedAttrInfo(
16373     /*AttrKind=*/ParsedAttr::AT_SizedByOrNull,
16374     /*NumArgs=*/1,
16375     /*OptArgs=*/1,
16376     /*NumArgMembers=*/2,
16377     /*HasCustomParsing=*/0,
16378     /*AcceptsExprPack=*/0,
16379     /*IsTargetSpecific=*/0,
16380     /*IsType=*/1,
16381     /*IsStmt=*/0,
16382     /*IsKnownToGCC=*/0,
16383     /*IsSupportedByPragmaAttribute=*/0,
16384     /*Spellings=*/SizedByOrNullSpellings,
16385     /*ArgNames=*/SizedByOrNullArgNames) {}
16386 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16387   if (!isa<FieldDecl>(D)) {
16388     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16389       << Attr << Attr.isRegularKeywordAttribute() << "non-static data members";
16390     return false;
16391   }
16392   return true;
16393 }
16394 
16395 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16396   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16397     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16398   return false;
16399 }
16400 
16401 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
16402   return (!LangOpts.CPlusPlus);
16403 }
16404 
16405 bool isParamExpr(size_t N) const override {
16406   return (N == 0) || false;
16407 }
16408 
16409 static const ParsedAttrInfoSizedByOrNull Instance;
16410 };
16411 const ParsedAttrInfoSizedByOrNull ParsedAttrInfoSizedByOrNull::Instance;
16412 static constexpr ParsedAttrInfo::Spelling SpeculativeLoadHardeningSpellings[] = {
16413   {AttributeCommonInfo::AS_GNU, "speculative_load_hardening"},
16414   {AttributeCommonInfo::AS_CXX11, "clang::speculative_load_hardening"},
16415   {AttributeCommonInfo::AS_C23, "clang::speculative_load_hardening"},
16416 };
16417 struct ParsedAttrInfoSpeculativeLoadHardening final : public ParsedAttrInfo {
16418   constexpr ParsedAttrInfoSpeculativeLoadHardening() : ParsedAttrInfo(
16419     /*AttrKind=*/ParsedAttr::AT_SpeculativeLoadHardening,
16420     /*NumArgs=*/0,
16421     /*OptArgs=*/0,
16422     /*NumArgMembers=*/0,
16423     /*HasCustomParsing=*/0,
16424     /*AcceptsExprPack=*/0,
16425     /*IsTargetSpecific=*/0,
16426     /*IsType=*/0,
16427     /*IsStmt=*/0,
16428     /*IsKnownToGCC=*/0,
16429     /*IsSupportedByPragmaAttribute=*/1,
16430     /*Spellings=*/SpeculativeLoadHardeningSpellings,
16431     /*ArgNames=*/{}) {}
16432 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16433   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
16434     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16435       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
16436     return false;
16437   }
16438   return true;
16439 }
16440 
16441 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16442   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16443     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16444   return false;
16445 }
16446 
16447   using ParsedAttrInfo::diagMutualExclusion;
16448 
16449   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
16450     if (const auto *A = D->getAttr<NoSpeculativeLoadHardeningAttr>()) {
16451       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
16452       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
16453 return false;
16454     }
16455     return true;
16456   }
16457 
16458 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16459   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
16460   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
16461 }
16462 
16463 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
16464   D->addAttr(::new (S.Context) SpeculativeLoadHardeningAttr(S.Context, Attr));
16465   return AttributeApplied;
16466 }
16467 
16468 bool isParamExpr(size_t N) const override {
16469   return false;
16470 }
16471 
16472 static const ParsedAttrInfoSpeculativeLoadHardening Instance;
16473 };
16474 const ParsedAttrInfoSpeculativeLoadHardening ParsedAttrInfoSpeculativeLoadHardening::Instance;
16475 static constexpr ParsedAttrInfo::Spelling StandaloneDebugSpellings[] = {
16476   {AttributeCommonInfo::AS_GNU, "standalone_debug"},
16477   {AttributeCommonInfo::AS_CXX11, "clang::standalone_debug"},
16478 };
16479 struct ParsedAttrInfoStandaloneDebug final : public ParsedAttrInfo {
16480   constexpr ParsedAttrInfoStandaloneDebug() : ParsedAttrInfo(
16481     /*AttrKind=*/ParsedAttr::AT_StandaloneDebug,
16482     /*NumArgs=*/0,
16483     /*OptArgs=*/0,
16484     /*NumArgMembers=*/0,
16485     /*HasCustomParsing=*/0,
16486     /*AcceptsExprPack=*/0,
16487     /*IsTargetSpecific=*/0,
16488     /*IsType=*/0,
16489     /*IsStmt=*/0,
16490     /*IsKnownToGCC=*/0,
16491     /*IsSupportedByPragmaAttribute=*/1,
16492     /*Spellings=*/StandaloneDebugSpellings,
16493     /*ArgNames=*/{}) {}
16494 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16495   if (!isa<CXXRecordDecl>(D)) {
16496     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16497       << Attr << Attr.isRegularKeywordAttribute() << "classes";
16498     return false;
16499   }
16500   return true;
16501 }
16502 
16503 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16504   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16505     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16506   return false;
16507 }
16508 
16509 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
16510   return LangOpts.CPlusPlus;
16511 }
16512 
16513 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16514   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
16515 }
16516 
16517 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
16518   D->addAttr(::new (S.Context) StandaloneDebugAttr(S.Context, Attr));
16519   return AttributeApplied;
16520 }
16521 
16522 bool isParamExpr(size_t N) const override {
16523   return false;
16524 }
16525 
16526 static const ParsedAttrInfoStandaloneDebug Instance;
16527 };
16528 const ParsedAttrInfoStandaloneDebug ParsedAttrInfoStandaloneDebug::Instance;
16529 static constexpr ParsedAttrInfo::Spelling StdCallSpellings[] = {
16530   {AttributeCommonInfo::AS_GNU, "stdcall"},
16531   {AttributeCommonInfo::AS_CXX11, "gnu::stdcall"},
16532   {AttributeCommonInfo::AS_C23, "gnu::stdcall"},
16533   {AttributeCommonInfo::AS_Keyword, "__stdcall"},
16534   {AttributeCommonInfo::AS_Keyword, "_stdcall"},
16535 };
16536 struct ParsedAttrInfoStdCall final : public ParsedAttrInfo {
16537   constexpr ParsedAttrInfoStdCall() : ParsedAttrInfo(
16538     /*AttrKind=*/ParsedAttr::AT_StdCall,
16539     /*NumArgs=*/0,
16540     /*OptArgs=*/0,
16541     /*NumArgMembers=*/0,
16542     /*HasCustomParsing=*/0,
16543     /*AcceptsExprPack=*/0,
16544     /*IsTargetSpecific=*/0,
16545     /*IsType=*/1,
16546     /*IsStmt=*/0,
16547     /*IsKnownToGCC=*/1,
16548     /*IsSupportedByPragmaAttribute=*/0,
16549     /*Spellings=*/StdCallSpellings,
16550     /*ArgNames=*/{}) {}
16551 bool isParamExpr(size_t N) const override {
16552   return false;
16553 }
16554 
16555 static const ParsedAttrInfoStdCall Instance;
16556 };
16557 const ParsedAttrInfoStdCall ParsedAttrInfoStdCall::Instance;
16558 struct ParsedAttrInfoStrictFP final : public ParsedAttrInfo {
16559   constexpr ParsedAttrInfoStrictFP() : ParsedAttrInfo(
16560     /*AttrKind=*/ParsedAttr::AT_StrictFP,
16561     /*NumArgs=*/0,
16562     /*OptArgs=*/0,
16563     /*NumArgMembers=*/0,
16564     /*HasCustomParsing=*/0,
16565     /*AcceptsExprPack=*/0,
16566     /*IsTargetSpecific=*/0,
16567     /*IsType=*/0,
16568     /*IsStmt=*/0,
16569     /*IsKnownToGCC=*/0,
16570     /*IsSupportedByPragmaAttribute=*/0,
16571     /*Spellings=*/{},
16572     /*ArgNames=*/{}) {}
16573 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16574   if (!isa<FunctionDecl>(D)) {
16575     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16576       << Attr << Attr.isRegularKeywordAttribute() << "functions";
16577     return false;
16578   }
16579   return true;
16580 }
16581 
16582 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16583   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16584     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16585   return false;
16586 }
16587 
16588 bool isParamExpr(size_t N) const override {
16589   return false;
16590 }
16591 
16592 static const ParsedAttrInfoStrictFP Instance;
16593 };
16594 const ParsedAttrInfoStrictFP ParsedAttrInfoStrictFP::Instance;
16595 static constexpr ParsedAttrInfo::Spelling StrictGuardStackCheckSpellings[] = {
16596   {AttributeCommonInfo::AS_Declspec, "strict_gs_check"},
16597 };
16598 struct ParsedAttrInfoStrictGuardStackCheck final : public ParsedAttrInfo {
16599   constexpr ParsedAttrInfoStrictGuardStackCheck() : ParsedAttrInfo(
16600     /*AttrKind=*/ParsedAttr::AT_StrictGuardStackCheck,
16601     /*NumArgs=*/0,
16602     /*OptArgs=*/0,
16603     /*NumArgMembers=*/0,
16604     /*HasCustomParsing=*/0,
16605     /*AcceptsExprPack=*/0,
16606     /*IsTargetSpecific=*/0,
16607     /*IsType=*/0,
16608     /*IsStmt=*/0,
16609     /*IsKnownToGCC=*/0,
16610     /*IsSupportedByPragmaAttribute=*/0,
16611     /*Spellings=*/StrictGuardStackCheckSpellings,
16612     /*ArgNames=*/{}) {}
16613 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16614   if (!isa<FunctionDecl>(D)) {
16615     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16616       << Attr << Attr.isRegularKeywordAttribute() << "functions";
16617     return false;
16618   }
16619   return true;
16620 }
16621 
16622 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16623   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16624     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16625   return false;
16626 }
16627 
16628 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
16629   D->addAttr(::new (S.Context) StrictGuardStackCheckAttr(S.Context, Attr));
16630   return AttributeApplied;
16631 }
16632 
16633 bool isParamExpr(size_t N) const override {
16634   return false;
16635 }
16636 
16637 static const ParsedAttrInfoStrictGuardStackCheck Instance;
16638 };
16639 const ParsedAttrInfoStrictGuardStackCheck ParsedAttrInfoStrictGuardStackCheck::Instance;
16640 static constexpr ParsedAttrInfo::Spelling SuppressSpellings[] = {
16641   {AttributeCommonInfo::AS_CXX11, "gsl::suppress"},
16642   {AttributeCommonInfo::AS_GNU, "suppress"},
16643   {AttributeCommonInfo::AS_CXX11, "clang::suppress"},
16644   {AttributeCommonInfo::AS_C23, "clang::suppress"},
16645 };
16646 static constexpr const char *SuppressArgNames[] = {
16647 "DiagnosticIdentifiers...",};
16648 struct ParsedAttrInfoSuppress final : public ParsedAttrInfo {
16649   constexpr ParsedAttrInfoSuppress() : ParsedAttrInfo(
16650     /*AttrKind=*/ParsedAttr::AT_Suppress,
16651     /*NumArgs=*/0,
16652     /*OptArgs=*/15,
16653     /*NumArgMembers=*/1,
16654     /*HasCustomParsing=*/0,
16655     /*AcceptsExprPack=*/0,
16656     /*IsTargetSpecific=*/0,
16657     /*IsType=*/0,
16658     /*IsStmt=*/1,
16659     /*IsKnownToGCC=*/0,
16660     /*IsSupportedByPragmaAttribute=*/0,
16661     /*Spellings=*/SuppressSpellings,
16662     /*ArgNames=*/SuppressArgNames) {}
16663 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16664   if (!isa<VarDecl>(D) && !isa<FieldDecl>(D) && !isa<ObjCPropertyDecl>(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D) && !isa<RecordDecl>(D) && !isa<ObjCInterfaceDecl>(D) && !isa<ObjCImplementationDecl>(D) && !isa<NamespaceDecl>(D) && !isa<EmptyDecl>(D)) {
16665     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16666       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, structs, interfaces, and namespaces";
16667     return false;
16668   }
16669   return true;
16670 }
16671 
16672 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &Attr, const Stmt *St) const override {
16673   if (!isa<Stmt>(St)) {
16674     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16675       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, structs, interfaces, and namespaces";
16676     return false;
16677   }
16678   return true;
16679 }
16680 
16681 bool isParamExpr(size_t N) const override {
16682   return false;
16683 }
16684 
16685 static const ParsedAttrInfoSuppress Instance;
16686 };
16687 const ParsedAttrInfoSuppress ParsedAttrInfoSuppress::Instance;
16688 static constexpr ParsedAttrInfo::Spelling SwiftAsyncSpellings[] = {
16689   {AttributeCommonInfo::AS_GNU, "swift_async"},
16690   {AttributeCommonInfo::AS_CXX11, "clang::swift_async"},
16691   {AttributeCommonInfo::AS_C23, "clang::swift_async"},
16692 };
16693 static constexpr const char *SwiftAsyncArgNames[] = {
16694 "Kind","CompletionHandlerIndex",};
16695 struct ParsedAttrInfoSwiftAsync final : public ParsedAttrInfo {
16696   constexpr ParsedAttrInfoSwiftAsync() : ParsedAttrInfo(
16697     /*AttrKind=*/ParsedAttr::AT_SwiftAsync,
16698     /*NumArgs=*/1,
16699     /*OptArgs=*/1,
16700     /*NumArgMembers=*/2,
16701     /*HasCustomParsing=*/0,
16702     /*AcceptsExprPack=*/0,
16703     /*IsTargetSpecific=*/0,
16704     /*IsType=*/0,
16705     /*IsStmt=*/0,
16706     /*IsKnownToGCC=*/0,
16707     /*IsSupportedByPragmaAttribute=*/1,
16708     /*Spellings=*/SwiftAsyncSpellings,
16709     /*ArgNames=*/SwiftAsyncArgNames) {}
16710 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16711   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
16712     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16713       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
16714     return false;
16715   }
16716   return true;
16717 }
16718 
16719 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16720   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16721     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16722   return false;
16723 }
16724 
16725 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16726   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
16727   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
16728 }
16729 
16730 bool isParamExpr(size_t N) const override {
16731   return false;
16732 }
16733 
16734 static const ParsedAttrInfoSwiftAsync Instance;
16735 };
16736 const ParsedAttrInfoSwiftAsync ParsedAttrInfoSwiftAsync::Instance;
16737 static constexpr ParsedAttrInfo::Spelling SwiftAsyncCallSpellings[] = {
16738   {AttributeCommonInfo::AS_GNU, "swiftasynccall"},
16739   {AttributeCommonInfo::AS_CXX11, "clang::swiftasynccall"},
16740   {AttributeCommonInfo::AS_C23, "clang::swiftasynccall"},
16741 };
16742 struct ParsedAttrInfoSwiftAsyncCall final : public ParsedAttrInfo {
16743   constexpr ParsedAttrInfoSwiftAsyncCall() : ParsedAttrInfo(
16744     /*AttrKind=*/ParsedAttr::AT_SwiftAsyncCall,
16745     /*NumArgs=*/0,
16746     /*OptArgs=*/0,
16747     /*NumArgMembers=*/0,
16748     /*HasCustomParsing=*/0,
16749     /*AcceptsExprPack=*/0,
16750     /*IsTargetSpecific=*/0,
16751     /*IsType=*/1,
16752     /*IsStmt=*/0,
16753     /*IsKnownToGCC=*/0,
16754     /*IsSupportedByPragmaAttribute=*/0,
16755     /*Spellings=*/SwiftAsyncCallSpellings,
16756     /*ArgNames=*/{}) {}
16757 bool isParamExpr(size_t N) const override {
16758   return false;
16759 }
16760 
16761 static const ParsedAttrInfoSwiftAsyncCall Instance;
16762 };
16763 const ParsedAttrInfoSwiftAsyncCall ParsedAttrInfoSwiftAsyncCall::Instance;
16764 static constexpr ParsedAttrInfo::Spelling SwiftAsyncContextSpellings[] = {
16765   {AttributeCommonInfo::AS_GNU, "swift_async_context"},
16766   {AttributeCommonInfo::AS_CXX11, "clang::swift_async_context"},
16767   {AttributeCommonInfo::AS_C23, "clang::swift_async_context"},
16768 };
16769 struct ParsedAttrInfoSwiftAsyncContext final : public ParsedAttrInfo {
16770   constexpr ParsedAttrInfoSwiftAsyncContext() : ParsedAttrInfo(
16771     /*AttrKind=*/ParsedAttr::AT_SwiftAsyncContext,
16772     /*NumArgs=*/0,
16773     /*OptArgs=*/0,
16774     /*NumArgMembers=*/0,
16775     /*HasCustomParsing=*/0,
16776     /*AcceptsExprPack=*/0,
16777     /*IsTargetSpecific=*/0,
16778     /*IsType=*/0,
16779     /*IsStmt=*/0,
16780     /*IsKnownToGCC=*/0,
16781     /*IsSupportedByPragmaAttribute=*/1,
16782     /*Spellings=*/SwiftAsyncContextSpellings,
16783     /*ArgNames=*/{}) {}
16784 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16785   if (!isa<ParmVarDecl>(D)) {
16786     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16787       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
16788     return false;
16789   }
16790   return true;
16791 }
16792 
16793 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16794   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16795     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16796   return false;
16797 }
16798 
16799 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16800   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
16801 }
16802 
16803 bool isParamExpr(size_t N) const override {
16804   return false;
16805 }
16806 
16807 static const ParsedAttrInfoSwiftAsyncContext Instance;
16808 };
16809 const ParsedAttrInfoSwiftAsyncContext ParsedAttrInfoSwiftAsyncContext::Instance;
16810 static constexpr ParsedAttrInfo::Spelling SwiftAsyncErrorSpellings[] = {
16811   {AttributeCommonInfo::AS_GNU, "swift_async_error"},
16812   {AttributeCommonInfo::AS_CXX11, "clang::swift_async_error"},
16813   {AttributeCommonInfo::AS_C23, "clang::swift_async_error"},
16814 };
16815 static constexpr const char *SwiftAsyncErrorArgNames[] = {
16816 "Convention","HandlerParamIdx",};
16817 struct ParsedAttrInfoSwiftAsyncError final : public ParsedAttrInfo {
16818   constexpr ParsedAttrInfoSwiftAsyncError() : ParsedAttrInfo(
16819     /*AttrKind=*/ParsedAttr::AT_SwiftAsyncError,
16820     /*NumArgs=*/1,
16821     /*OptArgs=*/1,
16822     /*NumArgMembers=*/2,
16823     /*HasCustomParsing=*/0,
16824     /*AcceptsExprPack=*/0,
16825     /*IsTargetSpecific=*/0,
16826     /*IsType=*/0,
16827     /*IsStmt=*/0,
16828     /*IsKnownToGCC=*/0,
16829     /*IsSupportedByPragmaAttribute=*/1,
16830     /*Spellings=*/SwiftAsyncErrorSpellings,
16831     /*ArgNames=*/SwiftAsyncErrorArgNames) {}
16832 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16833   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
16834     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
16835       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
16836     return false;
16837   }
16838   return true;
16839 }
16840 
16841 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16842   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16843     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16844   return false;
16845 }
16846 
16847 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16848   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
16849   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
16850 }
16851 
16852 bool isParamExpr(size_t N) const override {
16853   return false;
16854 }
16855 
16856 static const ParsedAttrInfoSwiftAsyncError Instance;
16857 };
16858 const ParsedAttrInfoSwiftAsyncError ParsedAttrInfoSwiftAsyncError::Instance;
16859 static constexpr ParsedAttrInfo::Spelling SwiftAsyncNameSpellings[] = {
16860   {AttributeCommonInfo::AS_GNU, "swift_async_name"},
16861 };
16862 static constexpr const char *SwiftAsyncNameArgNames[] = {
16863 "Name",};
16864 struct ParsedAttrInfoSwiftAsyncName final : public ParsedAttrInfo {
16865   constexpr ParsedAttrInfoSwiftAsyncName() : ParsedAttrInfo(
16866     /*AttrKind=*/ParsedAttr::AT_SwiftAsyncName,
16867     /*NumArgs=*/1,
16868     /*OptArgs=*/0,
16869     /*NumArgMembers=*/1,
16870     /*HasCustomParsing=*/0,
16871     /*AcceptsExprPack=*/0,
16872     /*IsTargetSpecific=*/0,
16873     /*IsType=*/0,
16874     /*IsStmt=*/0,
16875     /*IsKnownToGCC=*/0,
16876     /*IsSupportedByPragmaAttribute=*/1,
16877     /*Spellings=*/SwiftAsyncNameSpellings,
16878     /*ArgNames=*/SwiftAsyncNameArgNames) {}
16879 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16880   if (!isa<ObjCMethodDecl>(D) && !isa<FunctionDecl>(D)) {
16881     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16882       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods and functions";
16883     return false;
16884   }
16885   return true;
16886 }
16887 
16888 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16889   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16890     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16891   return false;
16892 }
16893 
16894 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
16895   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
16896   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
16897 }
16898 
16899 bool isParamExpr(size_t N) const override {
16900   return false;
16901 }
16902 
16903 static const ParsedAttrInfoSwiftAsyncName Instance;
16904 };
16905 const ParsedAttrInfoSwiftAsyncName ParsedAttrInfoSwiftAsyncName::Instance;
16906 static constexpr ParsedAttrInfo::Spelling SwiftAttrSpellings[] = {
16907   {AttributeCommonInfo::AS_GNU, "swift_attr"},
16908 };
16909 static constexpr const char *SwiftAttrArgNames[] = {
16910 "Attribute",};
16911 struct ParsedAttrInfoSwiftAttr final : public ParsedAttrInfo {
16912   constexpr ParsedAttrInfoSwiftAttr() : ParsedAttrInfo(
16913     /*AttrKind=*/ParsedAttr::AT_SwiftAttr,
16914     /*NumArgs=*/1,
16915     /*OptArgs=*/0,
16916     /*NumArgMembers=*/1,
16917     /*HasCustomParsing=*/0,
16918     /*AcceptsExprPack=*/0,
16919     /*IsTargetSpecific=*/0,
16920     /*IsType=*/1,
16921     /*IsStmt=*/0,
16922     /*IsKnownToGCC=*/0,
16923     /*IsSupportedByPragmaAttribute=*/1,
16924     /*Spellings=*/SwiftAttrSpellings,
16925     /*ArgNames=*/SwiftAttrArgNames) {}
16926 bool isParamExpr(size_t N) const override {
16927   return false;
16928 }
16929 
16930 static const ParsedAttrInfoSwiftAttr Instance;
16931 };
16932 const ParsedAttrInfoSwiftAttr ParsedAttrInfoSwiftAttr::Instance;
16933 static constexpr ParsedAttrInfo::Spelling SwiftBridgeSpellings[] = {
16934   {AttributeCommonInfo::AS_GNU, "swift_bridge"},
16935 };
16936 static constexpr const char *SwiftBridgeArgNames[] = {
16937 "SwiftType",};
16938 struct ParsedAttrInfoSwiftBridge final : public ParsedAttrInfo {
16939   constexpr ParsedAttrInfoSwiftBridge() : ParsedAttrInfo(
16940     /*AttrKind=*/ParsedAttr::AT_SwiftBridge,
16941     /*NumArgs=*/1,
16942     /*OptArgs=*/0,
16943     /*NumArgMembers=*/1,
16944     /*HasCustomParsing=*/0,
16945     /*AcceptsExprPack=*/0,
16946     /*IsTargetSpecific=*/0,
16947     /*IsType=*/0,
16948     /*IsStmt=*/0,
16949     /*IsKnownToGCC=*/0,
16950     /*IsSupportedByPragmaAttribute=*/0,
16951     /*Spellings=*/SwiftBridgeSpellings,
16952     /*ArgNames=*/SwiftBridgeArgNames) {}
16953 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16954   if (!isa<TagDecl>(D) && !isa<TypedefNameDecl>(D) && !isa<ObjCInterfaceDecl>(D) && !isa<ObjCProtocolDecl>(D)) {
16955     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16956       << Attr << Attr.isRegularKeywordAttribute() << "tag types, typedefs, Objective-C interfaces, and Objective-C protocols";
16957     return false;
16958   }
16959   return true;
16960 }
16961 
16962 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
16963   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
16964     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
16965   return false;
16966 }
16967 
16968 bool isParamExpr(size_t N) const override {
16969   return false;
16970 }
16971 
16972 static const ParsedAttrInfoSwiftBridge Instance;
16973 };
16974 const ParsedAttrInfoSwiftBridge ParsedAttrInfoSwiftBridge::Instance;
16975 static constexpr ParsedAttrInfo::Spelling SwiftBridgedTypedefSpellings[] = {
16976   {AttributeCommonInfo::AS_GNU, "swift_bridged_typedef"},
16977 };
16978 struct ParsedAttrInfoSwiftBridgedTypedef final : public ParsedAttrInfo {
16979   constexpr ParsedAttrInfoSwiftBridgedTypedef() : ParsedAttrInfo(
16980     /*AttrKind=*/ParsedAttr::AT_SwiftBridgedTypedef,
16981     /*NumArgs=*/0,
16982     /*OptArgs=*/0,
16983     /*NumArgMembers=*/0,
16984     /*HasCustomParsing=*/0,
16985     /*AcceptsExprPack=*/0,
16986     /*IsTargetSpecific=*/0,
16987     /*IsType=*/0,
16988     /*IsStmt=*/0,
16989     /*IsKnownToGCC=*/0,
16990     /*IsSupportedByPragmaAttribute=*/1,
16991     /*Spellings=*/SwiftBridgedTypedefSpellings,
16992     /*ArgNames=*/{}) {}
16993 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
16994   if (!isa<TypedefNameDecl>(D)) {
16995     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
16996       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
16997     return false;
16998   }
16999   return true;
17000 }
17001 
17002 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17003   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17004     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17005   return false;
17006 }
17007 
17008 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17009   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
17010 }
17011 
17012 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
17013   D->addAttr(::new (S.Context) SwiftBridgedTypedefAttr(S.Context, Attr));
17014   return AttributeApplied;
17015 }
17016 
17017 bool isParamExpr(size_t N) const override {
17018   return false;
17019 }
17020 
17021 static const ParsedAttrInfoSwiftBridgedTypedef Instance;
17022 };
17023 const ParsedAttrInfoSwiftBridgedTypedef ParsedAttrInfoSwiftBridgedTypedef::Instance;
17024 static constexpr ParsedAttrInfo::Spelling SwiftCallSpellings[] = {
17025   {AttributeCommonInfo::AS_GNU, "swiftcall"},
17026   {AttributeCommonInfo::AS_CXX11, "clang::swiftcall"},
17027   {AttributeCommonInfo::AS_C23, "clang::swiftcall"},
17028 };
17029 struct ParsedAttrInfoSwiftCall final : public ParsedAttrInfo {
17030   constexpr ParsedAttrInfoSwiftCall() : ParsedAttrInfo(
17031     /*AttrKind=*/ParsedAttr::AT_SwiftCall,
17032     /*NumArgs=*/0,
17033     /*OptArgs=*/0,
17034     /*NumArgMembers=*/0,
17035     /*HasCustomParsing=*/0,
17036     /*AcceptsExprPack=*/0,
17037     /*IsTargetSpecific=*/0,
17038     /*IsType=*/1,
17039     /*IsStmt=*/0,
17040     /*IsKnownToGCC=*/0,
17041     /*IsSupportedByPragmaAttribute=*/0,
17042     /*Spellings=*/SwiftCallSpellings,
17043     /*ArgNames=*/{}) {}
17044 bool isParamExpr(size_t N) const override {
17045   return false;
17046 }
17047 
17048 static const ParsedAttrInfoSwiftCall Instance;
17049 };
17050 const ParsedAttrInfoSwiftCall ParsedAttrInfoSwiftCall::Instance;
17051 static constexpr ParsedAttrInfo::Spelling SwiftContextSpellings[] = {
17052   {AttributeCommonInfo::AS_GNU, "swift_context"},
17053   {AttributeCommonInfo::AS_CXX11, "clang::swift_context"},
17054   {AttributeCommonInfo::AS_C23, "clang::swift_context"},
17055 };
17056 struct ParsedAttrInfoSwiftContext final : public ParsedAttrInfo {
17057   constexpr ParsedAttrInfoSwiftContext() : ParsedAttrInfo(
17058     /*AttrKind=*/ParsedAttr::AT_SwiftContext,
17059     /*NumArgs=*/0,
17060     /*OptArgs=*/0,
17061     /*NumArgMembers=*/0,
17062     /*HasCustomParsing=*/0,
17063     /*AcceptsExprPack=*/0,
17064     /*IsTargetSpecific=*/0,
17065     /*IsType=*/0,
17066     /*IsStmt=*/0,
17067     /*IsKnownToGCC=*/0,
17068     /*IsSupportedByPragmaAttribute=*/1,
17069     /*Spellings=*/SwiftContextSpellings,
17070     /*ArgNames=*/{}) {}
17071 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17072   if (!isa<ParmVarDecl>(D)) {
17073     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17074       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
17075     return false;
17076   }
17077   return true;
17078 }
17079 
17080 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17081   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17082     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17083   return false;
17084 }
17085 
17086 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17087   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
17088 }
17089 
17090 bool isParamExpr(size_t N) const override {
17091   return false;
17092 }
17093 
17094 static const ParsedAttrInfoSwiftContext Instance;
17095 };
17096 const ParsedAttrInfoSwiftContext ParsedAttrInfoSwiftContext::Instance;
17097 static constexpr ParsedAttrInfo::Spelling SwiftErrorSpellings[] = {
17098   {AttributeCommonInfo::AS_GNU, "swift_error"},
17099 };
17100 static constexpr const char *SwiftErrorArgNames[] = {
17101 "Convention",};
17102 struct ParsedAttrInfoSwiftError final : public ParsedAttrInfo {
17103   constexpr ParsedAttrInfoSwiftError() : ParsedAttrInfo(
17104     /*AttrKind=*/ParsedAttr::AT_SwiftError,
17105     /*NumArgs=*/1,
17106     /*OptArgs=*/0,
17107     /*NumArgMembers=*/1,
17108     /*HasCustomParsing=*/0,
17109     /*AcceptsExprPack=*/0,
17110     /*IsTargetSpecific=*/0,
17111     /*IsType=*/0,
17112     /*IsStmt=*/0,
17113     /*IsKnownToGCC=*/0,
17114     /*IsSupportedByPragmaAttribute=*/1,
17115     /*Spellings=*/SwiftErrorSpellings,
17116     /*ArgNames=*/SwiftErrorArgNames) {}
17117 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17118   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
17119     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17120       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
17121     return false;
17122   }
17123   return true;
17124 }
17125 
17126 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17127   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17128     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17129   return false;
17130 }
17131 
17132 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17133   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
17134   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
17135 }
17136 
17137 bool isParamExpr(size_t N) const override {
17138   return false;
17139 }
17140 
17141 static const ParsedAttrInfoSwiftError Instance;
17142 };
17143 const ParsedAttrInfoSwiftError ParsedAttrInfoSwiftError::Instance;
17144 static constexpr ParsedAttrInfo::Spelling SwiftErrorResultSpellings[] = {
17145   {AttributeCommonInfo::AS_GNU, "swift_error_result"},
17146   {AttributeCommonInfo::AS_CXX11, "clang::swift_error_result"},
17147   {AttributeCommonInfo::AS_C23, "clang::swift_error_result"},
17148 };
17149 struct ParsedAttrInfoSwiftErrorResult final : public ParsedAttrInfo {
17150   constexpr ParsedAttrInfoSwiftErrorResult() : ParsedAttrInfo(
17151     /*AttrKind=*/ParsedAttr::AT_SwiftErrorResult,
17152     /*NumArgs=*/0,
17153     /*OptArgs=*/0,
17154     /*NumArgMembers=*/0,
17155     /*HasCustomParsing=*/0,
17156     /*AcceptsExprPack=*/0,
17157     /*IsTargetSpecific=*/0,
17158     /*IsType=*/0,
17159     /*IsStmt=*/0,
17160     /*IsKnownToGCC=*/0,
17161     /*IsSupportedByPragmaAttribute=*/1,
17162     /*Spellings=*/SwiftErrorResultSpellings,
17163     /*ArgNames=*/{}) {}
17164 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17165   if (!isa<ParmVarDecl>(D)) {
17166     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17167       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
17168     return false;
17169   }
17170   return true;
17171 }
17172 
17173 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17174   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17175     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17176   return false;
17177 }
17178 
17179 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17180   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
17181 }
17182 
17183 bool isParamExpr(size_t N) const override {
17184   return false;
17185 }
17186 
17187 static const ParsedAttrInfoSwiftErrorResult Instance;
17188 };
17189 const ParsedAttrInfoSwiftErrorResult ParsedAttrInfoSwiftErrorResult::Instance;
17190 static constexpr ParsedAttrInfo::Spelling SwiftIndirectResultSpellings[] = {
17191   {AttributeCommonInfo::AS_GNU, "swift_indirect_result"},
17192   {AttributeCommonInfo::AS_CXX11, "clang::swift_indirect_result"},
17193   {AttributeCommonInfo::AS_C23, "clang::swift_indirect_result"},
17194 };
17195 struct ParsedAttrInfoSwiftIndirectResult final : public ParsedAttrInfo {
17196   constexpr ParsedAttrInfoSwiftIndirectResult() : ParsedAttrInfo(
17197     /*AttrKind=*/ParsedAttr::AT_SwiftIndirectResult,
17198     /*NumArgs=*/0,
17199     /*OptArgs=*/0,
17200     /*NumArgMembers=*/0,
17201     /*HasCustomParsing=*/0,
17202     /*AcceptsExprPack=*/0,
17203     /*IsTargetSpecific=*/0,
17204     /*IsType=*/0,
17205     /*IsStmt=*/0,
17206     /*IsKnownToGCC=*/0,
17207     /*IsSupportedByPragmaAttribute=*/1,
17208     /*Spellings=*/SwiftIndirectResultSpellings,
17209     /*ArgNames=*/{}) {}
17210 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17211   if (!isa<ParmVarDecl>(D)) {
17212     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17213       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
17214     return false;
17215   }
17216   return true;
17217 }
17218 
17219 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17220   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17221     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17222   return false;
17223 }
17224 
17225 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17226   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
17227 }
17228 
17229 bool isParamExpr(size_t N) const override {
17230   return false;
17231 }
17232 
17233 static const ParsedAttrInfoSwiftIndirectResult Instance;
17234 };
17235 const ParsedAttrInfoSwiftIndirectResult ParsedAttrInfoSwiftIndirectResult::Instance;
17236 static constexpr ParsedAttrInfo::Spelling SwiftNameSpellings[] = {
17237   {AttributeCommonInfo::AS_GNU, "swift_name"},
17238 };
17239 static constexpr const char *SwiftNameArgNames[] = {
17240 "Name",};
17241 struct ParsedAttrInfoSwiftName final : public ParsedAttrInfo {
17242   constexpr ParsedAttrInfoSwiftName() : ParsedAttrInfo(
17243     /*AttrKind=*/ParsedAttr::AT_SwiftName,
17244     /*NumArgs=*/1,
17245     /*OptArgs=*/0,
17246     /*NumArgMembers=*/1,
17247     /*HasCustomParsing=*/0,
17248     /*AcceptsExprPack=*/0,
17249     /*IsTargetSpecific=*/0,
17250     /*IsType=*/0,
17251     /*IsStmt=*/0,
17252     /*IsKnownToGCC=*/0,
17253     /*IsSupportedByPragmaAttribute=*/0,
17254     /*Spellings=*/SwiftNameSpellings,
17255     /*ArgNames=*/SwiftNameArgNames) {}
17256 bool isParamExpr(size_t N) const override {
17257   return false;
17258 }
17259 
17260 static const ParsedAttrInfoSwiftName Instance;
17261 };
17262 const ParsedAttrInfoSwiftName ParsedAttrInfoSwiftName::Instance;
17263 static constexpr ParsedAttrInfo::Spelling SwiftNewTypeSpellings[] = {
17264   {AttributeCommonInfo::AS_GNU, "swift_newtype"},
17265   {AttributeCommonInfo::AS_GNU, "swift_wrapper"},
17266 };
17267 static constexpr const char *SwiftNewTypeArgNames[] = {
17268 "NewtypeKind",};
17269 struct ParsedAttrInfoSwiftNewType final : public ParsedAttrInfo {
17270   constexpr ParsedAttrInfoSwiftNewType() : ParsedAttrInfo(
17271     /*AttrKind=*/ParsedAttr::AT_SwiftNewType,
17272     /*NumArgs=*/1,
17273     /*OptArgs=*/0,
17274     /*NumArgMembers=*/1,
17275     /*HasCustomParsing=*/1,
17276     /*AcceptsExprPack=*/0,
17277     /*IsTargetSpecific=*/0,
17278     /*IsType=*/0,
17279     /*IsStmt=*/0,
17280     /*IsKnownToGCC=*/0,
17281     /*IsSupportedByPragmaAttribute=*/1,
17282     /*Spellings=*/SwiftNewTypeSpellings,
17283     /*ArgNames=*/SwiftNewTypeArgNames) {}
17284 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17285   if (!isa<TypedefNameDecl>(D)) {
17286     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17287       << Attr << Attr.isRegularKeywordAttribute() << "typedefs";
17288     return false;
17289   }
17290   return true;
17291 }
17292 
17293 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17294   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17295     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17296   return false;
17297 }
17298 
17299 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
17300   enum Spelling {
17301     GNU_swift_newtype = 0,
17302     GNU_swift_wrapper = 1,
17303   SpellingNotCalculated = 15
17304 
17305   };
17306 
17307   unsigned Idx = Attr.getAttributeSpellingListIndex();
17308   switch (Idx) {
17309     default: llvm_unreachable("Unknown spelling list index");
17310     case 0: return GNU_swift_newtype;
17311     case 1: return GNU_swift_wrapper;
17312   }
17313 }
17314 
17315 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17316   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
17317 }
17318 
17319 bool isParamExpr(size_t N) const override {
17320   return false;
17321 }
17322 
17323 static const ParsedAttrInfoSwiftNewType Instance;
17324 };
17325 const ParsedAttrInfoSwiftNewType ParsedAttrInfoSwiftNewType::Instance;
17326 static constexpr ParsedAttrInfo::Spelling SwiftObjCMembersSpellings[] = {
17327   {AttributeCommonInfo::AS_GNU, "swift_objc_members"},
17328 };
17329 struct ParsedAttrInfoSwiftObjCMembers final : public ParsedAttrInfo {
17330   constexpr ParsedAttrInfoSwiftObjCMembers() : ParsedAttrInfo(
17331     /*AttrKind=*/ParsedAttr::AT_SwiftObjCMembers,
17332     /*NumArgs=*/0,
17333     /*OptArgs=*/0,
17334     /*NumArgMembers=*/0,
17335     /*HasCustomParsing=*/0,
17336     /*AcceptsExprPack=*/0,
17337     /*IsTargetSpecific=*/0,
17338     /*IsType=*/0,
17339     /*IsStmt=*/0,
17340     /*IsKnownToGCC=*/0,
17341     /*IsSupportedByPragmaAttribute=*/1,
17342     /*Spellings=*/SwiftObjCMembersSpellings,
17343     /*ArgNames=*/{}) {}
17344 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17345   if (!isa<ObjCInterfaceDecl>(D)) {
17346     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17347       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C interfaces";
17348     return false;
17349   }
17350   return true;
17351 }
17352 
17353 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17354   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17355     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17356   return false;
17357 }
17358 
17359 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17360   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_interface, /*IsSupported=*/LangOpts.ObjC));
17361 }
17362 
17363 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
17364   D->addAttr(::new (S.Context) SwiftObjCMembersAttr(S.Context, Attr));
17365   return AttributeApplied;
17366 }
17367 
17368 bool isParamExpr(size_t N) const override {
17369   return false;
17370 }
17371 
17372 static const ParsedAttrInfoSwiftObjCMembers Instance;
17373 };
17374 const ParsedAttrInfoSwiftObjCMembers ParsedAttrInfoSwiftObjCMembers::Instance;
17375 static constexpr ParsedAttrInfo::Spelling SwiftPrivateSpellings[] = {
17376   {AttributeCommonInfo::AS_GNU, "swift_private"},
17377 };
17378 struct ParsedAttrInfoSwiftPrivate final : public ParsedAttrInfo {
17379   constexpr ParsedAttrInfoSwiftPrivate() : ParsedAttrInfo(
17380     /*AttrKind=*/ParsedAttr::AT_SwiftPrivate,
17381     /*NumArgs=*/0,
17382     /*OptArgs=*/0,
17383     /*NumArgMembers=*/0,
17384     /*HasCustomParsing=*/0,
17385     /*AcceptsExprPack=*/0,
17386     /*IsTargetSpecific=*/0,
17387     /*IsType=*/0,
17388     /*IsStmt=*/0,
17389     /*IsKnownToGCC=*/0,
17390     /*IsSupportedByPragmaAttribute=*/0,
17391     /*Spellings=*/SwiftPrivateSpellings,
17392     /*ArgNames=*/{}) {}
17393 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
17394   D->addAttr(::new (S.Context) SwiftPrivateAttr(S.Context, Attr));
17395   return AttributeApplied;
17396 }
17397 
17398 bool isParamExpr(size_t N) const override {
17399   return false;
17400 }
17401 
17402 static const ParsedAttrInfoSwiftPrivate Instance;
17403 };
17404 const ParsedAttrInfoSwiftPrivate ParsedAttrInfoSwiftPrivate::Instance;
17405 static constexpr ParsedAttrInfo::Spelling SysVABISpellings[] = {
17406   {AttributeCommonInfo::AS_GNU, "sysv_abi"},
17407   {AttributeCommonInfo::AS_CXX11, "gnu::sysv_abi"},
17408   {AttributeCommonInfo::AS_C23, "gnu::sysv_abi"},
17409 };
17410 struct ParsedAttrInfoSysVABI final : public ParsedAttrInfo {
17411   constexpr ParsedAttrInfoSysVABI() : ParsedAttrInfo(
17412     /*AttrKind=*/ParsedAttr::AT_SysVABI,
17413     /*NumArgs=*/0,
17414     /*OptArgs=*/0,
17415     /*NumArgMembers=*/0,
17416     /*HasCustomParsing=*/0,
17417     /*AcceptsExprPack=*/0,
17418     /*IsTargetSpecific=*/0,
17419     /*IsType=*/1,
17420     /*IsStmt=*/0,
17421     /*IsKnownToGCC=*/1,
17422     /*IsSupportedByPragmaAttribute=*/0,
17423     /*Spellings=*/SysVABISpellings,
17424     /*ArgNames=*/{}) {}
17425 bool isParamExpr(size_t N) const override {
17426   return false;
17427 }
17428 
17429 static const ParsedAttrInfoSysVABI Instance;
17430 };
17431 const ParsedAttrInfoSysVABI ParsedAttrInfoSysVABI::Instance;
17432 static constexpr ParsedAttrInfo::Spelling TLSModelSpellings[] = {
17433   {AttributeCommonInfo::AS_GNU, "tls_model"},
17434   {AttributeCommonInfo::AS_CXX11, "gnu::tls_model"},
17435   {AttributeCommonInfo::AS_C23, "gnu::tls_model"},
17436 };
17437 static constexpr const char *TLSModelArgNames[] = {
17438 "Model",};
17439 struct ParsedAttrInfoTLSModel final : public ParsedAttrInfo {
17440   constexpr ParsedAttrInfoTLSModel() : ParsedAttrInfo(
17441     /*AttrKind=*/ParsedAttr::AT_TLSModel,
17442     /*NumArgs=*/1,
17443     /*OptArgs=*/0,
17444     /*NumArgMembers=*/1,
17445     /*HasCustomParsing=*/0,
17446     /*AcceptsExprPack=*/0,
17447     /*IsTargetSpecific=*/0,
17448     /*IsType=*/0,
17449     /*IsStmt=*/0,
17450     /*IsKnownToGCC=*/1,
17451     /*IsSupportedByPragmaAttribute=*/1,
17452     /*Spellings=*/TLSModelSpellings,
17453     /*ArgNames=*/TLSModelArgNames) {}
17454 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17455   if (!isTLSVar(D)) {
17456     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17457       << Attr << Attr.isRegularKeywordAttribute() << "thread-local variables";
17458     return false;
17459   }
17460   return true;
17461 }
17462 
17463 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17464   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17465     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17466   return false;
17467 }
17468 
17469 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17470   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_thread_local, /*IsSupported=*/true));
17471 }
17472 
17473 bool isParamExpr(size_t N) const override {
17474   return false;
17475 }
17476 
17477 static const ParsedAttrInfoTLSModel Instance;
17478 };
17479 const ParsedAttrInfoTLSModel ParsedAttrInfoTLSModel::Instance;
17480 static constexpr ParsedAttrInfo::Spelling TargetSpellings[] = {
17481   {AttributeCommonInfo::AS_GNU, "target"},
17482   {AttributeCommonInfo::AS_CXX11, "gnu::target"},
17483   {AttributeCommonInfo::AS_C23, "gnu::target"},
17484 };
17485 static constexpr const char *TargetArgNames[] = {
17486 "featuresStr",};
17487 struct ParsedAttrInfoTarget final : public ParsedAttrInfo {
17488   constexpr ParsedAttrInfoTarget() : ParsedAttrInfo(
17489     /*AttrKind=*/ParsedAttr::AT_Target,
17490     /*NumArgs=*/1,
17491     /*OptArgs=*/0,
17492     /*NumArgMembers=*/1,
17493     /*HasCustomParsing=*/0,
17494     /*AcceptsExprPack=*/0,
17495     /*IsTargetSpecific=*/0,
17496     /*IsType=*/0,
17497     /*IsStmt=*/0,
17498     /*IsKnownToGCC=*/1,
17499     /*IsSupportedByPragmaAttribute=*/1,
17500     /*Spellings=*/TargetSpellings,
17501     /*ArgNames=*/TargetArgNames) {}
17502 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17503   if (!isa<FunctionDecl>(D)) {
17504     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17505       << Attr << Attr.isRegularKeywordAttribute() << "functions";
17506     return false;
17507   }
17508   return true;
17509 }
17510 
17511 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17512   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17513     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17514   return false;
17515 }
17516 
17517   using ParsedAttrInfo::diagMutualExclusion;
17518 
17519   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
17520     if (const auto *A = D->getAttr<TargetClonesAttr>()) {
17521       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17522       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17523 return false;
17524     }
17525     if (const auto *A = D->getAttr<TargetVersionAttr>()) {
17526       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17527       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17528 return false;
17529     }
17530     if (const auto *A = D->getAttr<CPUDispatchAttr>()) {
17531       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17532       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17533 return false;
17534     }
17535     if (const auto *A = D->getAttr<CPUSpecificAttr>()) {
17536       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17537       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17538 return false;
17539     }
17540     return true;
17541   }
17542 
17543 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17544   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
17545 }
17546 
17547 bool isParamExpr(size_t N) const override {
17548   return false;
17549 }
17550 
17551 static const ParsedAttrInfoTarget Instance;
17552 };
17553 const ParsedAttrInfoTarget ParsedAttrInfoTarget::Instance;
17554 static constexpr ParsedAttrInfo::Spelling TargetClonesSpellings[] = {
17555   {AttributeCommonInfo::AS_GNU, "target_clones"},
17556   {AttributeCommonInfo::AS_CXX11, "gnu::target_clones"},
17557   {AttributeCommonInfo::AS_C23, "gnu::target_clones"},
17558 };
17559 static constexpr const char *TargetClonesArgNames[] = {
17560 "featuresStrs...",};
17561 struct ParsedAttrInfoTargetClones final : public ParsedAttrInfo {
17562   constexpr ParsedAttrInfoTargetClones() : ParsedAttrInfo(
17563     /*AttrKind=*/ParsedAttr::AT_TargetClones,
17564     /*NumArgs=*/0,
17565     /*OptArgs=*/15,
17566     /*NumArgMembers=*/1,
17567     /*HasCustomParsing=*/0,
17568     /*AcceptsExprPack=*/0,
17569     /*IsTargetSpecific=*/0,
17570     /*IsType=*/0,
17571     /*IsStmt=*/0,
17572     /*IsKnownToGCC=*/1,
17573     /*IsSupportedByPragmaAttribute=*/1,
17574     /*Spellings=*/TargetClonesSpellings,
17575     /*ArgNames=*/TargetClonesArgNames) {}
17576 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17577   if (!isa<FunctionDecl>(D)) {
17578     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17579       << Attr << Attr.isRegularKeywordAttribute() << "functions";
17580     return false;
17581   }
17582   return true;
17583 }
17584 
17585 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17586   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17587     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17588   return false;
17589 }
17590 
17591   using ParsedAttrInfo::diagMutualExclusion;
17592 
17593   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
17594     if (const auto *A = D->getAttr<TargetVersionAttr>()) {
17595       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17596       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17597 return false;
17598     }
17599     if (const auto *A = D->getAttr<TargetAttr>()) {
17600       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17601       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17602 return false;
17603     }
17604     if (const auto *A = D->getAttr<CPUDispatchAttr>()) {
17605       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17606       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17607 return false;
17608     }
17609     if (const auto *A = D->getAttr<CPUSpecificAttr>()) {
17610       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17611       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17612 return false;
17613     }
17614     return true;
17615   }
17616 
17617 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17618   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
17619 }
17620 
17621 bool isParamExpr(size_t N) const override {
17622   return false;
17623 }
17624 
17625 static const ParsedAttrInfoTargetClones Instance;
17626 };
17627 const ParsedAttrInfoTargetClones ParsedAttrInfoTargetClones::Instance;
17628 static constexpr ParsedAttrInfo::Spelling TargetVersionSpellings[] = {
17629   {AttributeCommonInfo::AS_GNU, "target_version"},
17630   {AttributeCommonInfo::AS_CXX11, "gnu::target_version"},
17631   {AttributeCommonInfo::AS_C23, "gnu::target_version"},
17632 };
17633 static constexpr const char *TargetVersionArgNames[] = {
17634 "NamesStr",};
17635 struct ParsedAttrInfoTargetVersion final : public ParsedAttrInfo {
17636   constexpr ParsedAttrInfoTargetVersion() : ParsedAttrInfo(
17637     /*AttrKind=*/ParsedAttr::AT_TargetVersion,
17638     /*NumArgs=*/1,
17639     /*OptArgs=*/0,
17640     /*NumArgMembers=*/1,
17641     /*HasCustomParsing=*/0,
17642     /*AcceptsExprPack=*/0,
17643     /*IsTargetSpecific=*/1,
17644     /*IsType=*/0,
17645     /*IsStmt=*/0,
17646     /*IsKnownToGCC=*/1,
17647     /*IsSupportedByPragmaAttribute=*/1,
17648     /*Spellings=*/TargetVersionSpellings,
17649     /*ArgNames=*/TargetVersionArgNames) {}
17650 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17651   if (!isa<FunctionDecl>(D)) {
17652     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17653       << Attr << Attr.isRegularKeywordAttribute() << "functions";
17654     return false;
17655   }
17656   return true;
17657 }
17658 
17659 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17660   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17661     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17662   return false;
17663 }
17664 
17665   using ParsedAttrInfo::diagMutualExclusion;
17666 
17667   bool diagMutualExclusion(Sema &S, const ParsedAttr &AL, const Decl *D) const override {
17668     if (const auto *A = D->getAttr<TargetClonesAttr>()) {
17669       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17670       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17671 return false;
17672     }
17673     if (const auto *A = D->getAttr<TargetAttr>()) {
17674       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17675       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17676 return false;
17677     }
17678     if (const auto *A = D->getAttr<CPUDispatchAttr>()) {
17679       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17680       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17681 return false;
17682     }
17683     if (const auto *A = D->getAttr<CPUSpecificAttr>()) {
17684       S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
17685       S.Diag(A->getLocation(), diag::note_conflicting_attribute);      
17686 return false;
17687     }
17688     return true;
17689   }
17690 
17691 bool existsInTarget(const TargetInfo &Target) const override {
17692   const llvm::Triple &T = Target.getTriple(); (void)T;
17693   return true && (T.getArch() == llvm::Triple::aarch64 || T.getArch() == llvm::Triple::aarch64_be || T.getArch() == llvm::Triple::aarch64_32 || T.getArch() == llvm::Triple::riscv32 || T.getArch() == llvm::Triple::riscv64);
17694 }
17695 
17696 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17697   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
17698 }
17699 
17700 bool isParamExpr(size_t N) const override {
17701   return false;
17702 }
17703 
17704 static const ParsedAttrInfoTargetVersion Instance;
17705 };
17706 const ParsedAttrInfoTargetVersion ParsedAttrInfoTargetVersion::Instance;
17707 static constexpr ParsedAttrInfo::Spelling TestTypestateSpellings[] = {
17708   {AttributeCommonInfo::AS_GNU, "test_typestate"},
17709   {AttributeCommonInfo::AS_CXX11, "clang::test_typestate"},
17710 };
17711 static constexpr const char *TestTypestateArgNames[] = {
17712 "TestState",};
17713 struct ParsedAttrInfoTestTypestate final : public ParsedAttrInfo {
17714   constexpr ParsedAttrInfoTestTypestate() : ParsedAttrInfo(
17715     /*AttrKind=*/ParsedAttr::AT_TestTypestate,
17716     /*NumArgs=*/1,
17717     /*OptArgs=*/0,
17718     /*NumArgMembers=*/1,
17719     /*HasCustomParsing=*/0,
17720     /*AcceptsExprPack=*/0,
17721     /*IsTargetSpecific=*/0,
17722     /*IsType=*/0,
17723     /*IsStmt=*/0,
17724     /*IsKnownToGCC=*/0,
17725     /*IsSupportedByPragmaAttribute=*/1,
17726     /*Spellings=*/TestTypestateSpellings,
17727     /*ArgNames=*/TestTypestateArgNames) {}
17728 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17729   if (!isa<CXXMethodDecl>(D)) {
17730     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17731       << Attr << Attr.isRegularKeywordAttribute() << "functions";
17732     return false;
17733   }
17734   return true;
17735 }
17736 
17737 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17738   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17739     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17740   return false;
17741 }
17742 
17743 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17744   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function_is_member, /*IsSupported=*/LangOpts.CPlusPlus));
17745 }
17746 
17747 bool isParamExpr(size_t N) const override {
17748   return false;
17749 }
17750 
17751 static const ParsedAttrInfoTestTypestate Instance;
17752 };
17753 const ParsedAttrInfoTestTypestate ParsedAttrInfoTestTypestate::Instance;
17754 static constexpr ParsedAttrInfo::Spelling ThisCallSpellings[] = {
17755   {AttributeCommonInfo::AS_GNU, "thiscall"},
17756   {AttributeCommonInfo::AS_CXX11, "gnu::thiscall"},
17757   {AttributeCommonInfo::AS_C23, "gnu::thiscall"},
17758   {AttributeCommonInfo::AS_Keyword, "__thiscall"},
17759   {AttributeCommonInfo::AS_Keyword, "_thiscall"},
17760 };
17761 struct ParsedAttrInfoThisCall final : public ParsedAttrInfo {
17762   constexpr ParsedAttrInfoThisCall() : ParsedAttrInfo(
17763     /*AttrKind=*/ParsedAttr::AT_ThisCall,
17764     /*NumArgs=*/0,
17765     /*OptArgs=*/0,
17766     /*NumArgMembers=*/0,
17767     /*HasCustomParsing=*/0,
17768     /*AcceptsExprPack=*/0,
17769     /*IsTargetSpecific=*/0,
17770     /*IsType=*/1,
17771     /*IsStmt=*/0,
17772     /*IsKnownToGCC=*/1,
17773     /*IsSupportedByPragmaAttribute=*/0,
17774     /*Spellings=*/ThisCallSpellings,
17775     /*ArgNames=*/{}) {}
17776 bool isParamExpr(size_t N) const override {
17777   return false;
17778 }
17779 
17780 static const ParsedAttrInfoThisCall Instance;
17781 };
17782 const ParsedAttrInfoThisCall ParsedAttrInfoThisCall::Instance;
17783 static constexpr ParsedAttrInfo::Spelling ThreadSpellings[] = {
17784   {AttributeCommonInfo::AS_Declspec, "thread"},
17785 };
17786 struct ParsedAttrInfoThread final : public ParsedAttrInfo {
17787   constexpr ParsedAttrInfoThread() : ParsedAttrInfo(
17788     /*AttrKind=*/ParsedAttr::AT_Thread,
17789     /*NumArgs=*/0,
17790     /*OptArgs=*/0,
17791     /*NumArgMembers=*/0,
17792     /*HasCustomParsing=*/0,
17793     /*AcceptsExprPack=*/0,
17794     /*IsTargetSpecific=*/0,
17795     /*IsType=*/0,
17796     /*IsStmt=*/0,
17797     /*IsKnownToGCC=*/0,
17798     /*IsSupportedByPragmaAttribute=*/0,
17799     /*Spellings=*/ThreadSpellings,
17800     /*ArgNames=*/{}) {}
17801 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17802   if (!isa<VarDecl>(D)) {
17803     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17804       << Attr << Attr.isRegularKeywordAttribute() << "variables";
17805     return false;
17806   }
17807   return true;
17808 }
17809 
17810 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17811   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17812     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17813   return false;
17814 }
17815 
17816 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
17817   return LangOpts.MicrosoftExt;
17818 }
17819 
17820 bool isParamExpr(size_t N) const override {
17821   return false;
17822 }
17823 
17824 static const ParsedAttrInfoThread Instance;
17825 };
17826 const ParsedAttrInfoThread ParsedAttrInfoThread::Instance;
17827 static constexpr ParsedAttrInfo::Spelling TransparentUnionSpellings[] = {
17828   {AttributeCommonInfo::AS_GNU, "transparent_union"},
17829   {AttributeCommonInfo::AS_CXX11, "gnu::transparent_union"},
17830   {AttributeCommonInfo::AS_C23, "gnu::transparent_union"},
17831 };
17832 struct ParsedAttrInfoTransparentUnion final : public ParsedAttrInfo {
17833   constexpr ParsedAttrInfoTransparentUnion() : ParsedAttrInfo(
17834     /*AttrKind=*/ParsedAttr::AT_TransparentUnion,
17835     /*NumArgs=*/0,
17836     /*OptArgs=*/0,
17837     /*NumArgMembers=*/0,
17838     /*HasCustomParsing=*/0,
17839     /*AcceptsExprPack=*/0,
17840     /*IsTargetSpecific=*/0,
17841     /*IsType=*/0,
17842     /*IsStmt=*/0,
17843     /*IsKnownToGCC=*/1,
17844     /*IsSupportedByPragmaAttribute=*/0,
17845     /*Spellings=*/TransparentUnionSpellings,
17846     /*ArgNames=*/{}) {}
17847 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
17848   return (!LangOpts.CPlusPlus);
17849 }
17850 
17851 bool isParamExpr(size_t N) const override {
17852   return false;
17853 }
17854 
17855 static const ParsedAttrInfoTransparentUnion Instance;
17856 };
17857 const ParsedAttrInfoTransparentUnion ParsedAttrInfoTransparentUnion::Instance;
17858 static constexpr ParsedAttrInfo::Spelling TrivialABISpellings[] = {
17859   {AttributeCommonInfo::AS_GNU, "trivial_abi"},
17860   {AttributeCommonInfo::AS_CXX11, "clang::trivial_abi"},
17861 };
17862 struct ParsedAttrInfoTrivialABI final : public ParsedAttrInfo {
17863   constexpr ParsedAttrInfoTrivialABI() : ParsedAttrInfo(
17864     /*AttrKind=*/ParsedAttr::AT_TrivialABI,
17865     /*NumArgs=*/0,
17866     /*OptArgs=*/0,
17867     /*NumArgMembers=*/0,
17868     /*HasCustomParsing=*/0,
17869     /*AcceptsExprPack=*/0,
17870     /*IsTargetSpecific=*/0,
17871     /*IsType=*/0,
17872     /*IsStmt=*/0,
17873     /*IsKnownToGCC=*/0,
17874     /*IsSupportedByPragmaAttribute=*/1,
17875     /*Spellings=*/TrivialABISpellings,
17876     /*ArgNames=*/{}) {}
17877 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17878   if (!isa<CXXRecordDecl>(D)) {
17879     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
17880       << Attr << Attr.isRegularKeywordAttribute() << "classes";
17881     return false;
17882   }
17883   return true;
17884 }
17885 
17886 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17887   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17888     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17889   return false;
17890 }
17891 
17892 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
17893   return LangOpts.CPlusPlus;
17894 }
17895 
17896 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
17897   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
17898 }
17899 
17900 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
17901   D->addAttr(::new (S.Context) TrivialABIAttr(S.Context, Attr));
17902   return AttributeApplied;
17903 }
17904 
17905 bool isParamExpr(size_t N) const override {
17906   return false;
17907 }
17908 
17909 static const ParsedAttrInfoTrivialABI Instance;
17910 };
17911 const ParsedAttrInfoTrivialABI ParsedAttrInfoTrivialABI::Instance;
17912 static constexpr ParsedAttrInfo::Spelling TryAcquireCapabilitySpellings[] = {
17913   {AttributeCommonInfo::AS_GNU, "try_acquire_capability"},
17914   {AttributeCommonInfo::AS_CXX11, "clang::try_acquire_capability"},
17915   {AttributeCommonInfo::AS_GNU, "try_acquire_shared_capability"},
17916   {AttributeCommonInfo::AS_CXX11, "clang::try_acquire_shared_capability"},
17917 };
17918 static constexpr const char *TryAcquireCapabilityArgNames[] = {
17919 "SuccessValue","Args...",};
17920 struct ParsedAttrInfoTryAcquireCapability final : public ParsedAttrInfo {
17921   constexpr ParsedAttrInfoTryAcquireCapability() : ParsedAttrInfo(
17922     /*AttrKind=*/ParsedAttr::AT_TryAcquireCapability,
17923     /*NumArgs=*/1,
17924     /*OptArgs=*/15,
17925     /*NumArgMembers=*/2,
17926     /*HasCustomParsing=*/0,
17927     /*AcceptsExprPack=*/0,
17928     /*IsTargetSpecific=*/0,
17929     /*IsType=*/0,
17930     /*IsStmt=*/0,
17931     /*IsKnownToGCC=*/0,
17932     /*IsSupportedByPragmaAttribute=*/0,
17933     /*Spellings=*/TryAcquireCapabilitySpellings,
17934     /*ArgNames=*/TryAcquireCapabilityArgNames) {}
17935 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
17936   if (!isa<FunctionDecl>(D)) {
17937     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
17938       << Attr << Attr.isRegularKeywordAttribute() << "functions";
17939     return false;
17940   }
17941   return true;
17942 }
17943 
17944 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
17945   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
17946     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
17947   return false;
17948 }
17949 
17950 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
17951   enum Spelling {
17952     GNU_try_acquire_capability = 0,
17953     CXX11_clang_try_acquire_capability = 1,
17954     GNU_try_acquire_shared_capability = 2,
17955     CXX11_clang_try_acquire_shared_capability = 3,
17956   SpellingNotCalculated = 15
17957 
17958   };
17959 
17960   unsigned Idx = Attr.getAttributeSpellingListIndex();
17961   switch (Idx) {
17962     default: llvm_unreachable("Unknown spelling list index");
17963     case 0: return GNU_try_acquire_capability;
17964     case 1: return CXX11_clang_try_acquire_capability;
17965     case 2: return GNU_try_acquire_shared_capability;
17966     case 3: return CXX11_clang_try_acquire_shared_capability;
17967   }
17968 }
17969 
17970 bool isParamExpr(size_t N) const override {
17971   return (N == 0) || (N == 1) || false;
17972 }
17973 
17974 static const ParsedAttrInfoTryAcquireCapability Instance;
17975 };
17976 const ParsedAttrInfoTryAcquireCapability ParsedAttrInfoTryAcquireCapability::Instance;
17977 static constexpr ParsedAttrInfo::Spelling TypeNonNullSpellings[] = {
17978   {AttributeCommonInfo::AS_Keyword, "_Nonnull"},
17979 };
17980 struct ParsedAttrInfoTypeNonNull final : public ParsedAttrInfo {
17981   constexpr ParsedAttrInfoTypeNonNull() : ParsedAttrInfo(
17982     /*AttrKind=*/ParsedAttr::AT_TypeNonNull,
17983     /*NumArgs=*/0,
17984     /*OptArgs=*/0,
17985     /*NumArgMembers=*/0,
17986     /*HasCustomParsing=*/0,
17987     /*AcceptsExprPack=*/0,
17988     /*IsTargetSpecific=*/0,
17989     /*IsType=*/1,
17990     /*IsStmt=*/0,
17991     /*IsKnownToGCC=*/0,
17992     /*IsSupportedByPragmaAttribute=*/0,
17993     /*Spellings=*/TypeNonNullSpellings,
17994     /*ArgNames=*/{}) {}
17995 bool isParamExpr(size_t N) const override {
17996   return false;
17997 }
17998 
17999 static const ParsedAttrInfoTypeNonNull Instance;
18000 };
18001 const ParsedAttrInfoTypeNonNull ParsedAttrInfoTypeNonNull::Instance;
18002 static constexpr ParsedAttrInfo::Spelling TypeNullUnspecifiedSpellings[] = {
18003   {AttributeCommonInfo::AS_Keyword, "_Null_unspecified"},
18004 };
18005 struct ParsedAttrInfoTypeNullUnspecified final : public ParsedAttrInfo {
18006   constexpr ParsedAttrInfoTypeNullUnspecified() : ParsedAttrInfo(
18007     /*AttrKind=*/ParsedAttr::AT_TypeNullUnspecified,
18008     /*NumArgs=*/0,
18009     /*OptArgs=*/0,
18010     /*NumArgMembers=*/0,
18011     /*HasCustomParsing=*/0,
18012     /*AcceptsExprPack=*/0,
18013     /*IsTargetSpecific=*/0,
18014     /*IsType=*/1,
18015     /*IsStmt=*/0,
18016     /*IsKnownToGCC=*/0,
18017     /*IsSupportedByPragmaAttribute=*/0,
18018     /*Spellings=*/TypeNullUnspecifiedSpellings,
18019     /*ArgNames=*/{}) {}
18020 bool isParamExpr(size_t N) const override {
18021   return false;
18022 }
18023 
18024 static const ParsedAttrInfoTypeNullUnspecified Instance;
18025 };
18026 const ParsedAttrInfoTypeNullUnspecified ParsedAttrInfoTypeNullUnspecified::Instance;
18027 static constexpr ParsedAttrInfo::Spelling TypeNullableSpellings[] = {
18028   {AttributeCommonInfo::AS_Keyword, "_Nullable"},
18029 };
18030 struct ParsedAttrInfoTypeNullable final : public ParsedAttrInfo {
18031   constexpr ParsedAttrInfoTypeNullable() : ParsedAttrInfo(
18032     /*AttrKind=*/ParsedAttr::AT_TypeNullable,
18033     /*NumArgs=*/0,
18034     /*OptArgs=*/0,
18035     /*NumArgMembers=*/0,
18036     /*HasCustomParsing=*/0,
18037     /*AcceptsExprPack=*/0,
18038     /*IsTargetSpecific=*/0,
18039     /*IsType=*/1,
18040     /*IsStmt=*/0,
18041     /*IsKnownToGCC=*/0,
18042     /*IsSupportedByPragmaAttribute=*/0,
18043     /*Spellings=*/TypeNullableSpellings,
18044     /*ArgNames=*/{}) {}
18045 bool isParamExpr(size_t N) const override {
18046   return false;
18047 }
18048 
18049 static const ParsedAttrInfoTypeNullable Instance;
18050 };
18051 const ParsedAttrInfoTypeNullable ParsedAttrInfoTypeNullable::Instance;
18052 static constexpr ParsedAttrInfo::Spelling TypeNullableResultSpellings[] = {
18053   {AttributeCommonInfo::AS_Keyword, "_Nullable_result"},
18054 };
18055 struct ParsedAttrInfoTypeNullableResult final : public ParsedAttrInfo {
18056   constexpr ParsedAttrInfoTypeNullableResult() : ParsedAttrInfo(
18057     /*AttrKind=*/ParsedAttr::AT_TypeNullableResult,
18058     /*NumArgs=*/0,
18059     /*OptArgs=*/0,
18060     /*NumArgMembers=*/0,
18061     /*HasCustomParsing=*/0,
18062     /*AcceptsExprPack=*/0,
18063     /*IsTargetSpecific=*/0,
18064     /*IsType=*/1,
18065     /*IsStmt=*/0,
18066     /*IsKnownToGCC=*/0,
18067     /*IsSupportedByPragmaAttribute=*/0,
18068     /*Spellings=*/TypeNullableResultSpellings,
18069     /*ArgNames=*/{}) {}
18070 bool isParamExpr(size_t N) const override {
18071   return false;
18072 }
18073 
18074 static const ParsedAttrInfoTypeNullableResult Instance;
18075 };
18076 const ParsedAttrInfoTypeNullableResult ParsedAttrInfoTypeNullableResult::Instance;
18077 static constexpr ParsedAttrInfo::Spelling TypeTagForDatatypeSpellings[] = {
18078   {AttributeCommonInfo::AS_GNU, "type_tag_for_datatype"},
18079   {AttributeCommonInfo::AS_CXX11, "clang::type_tag_for_datatype"},
18080   {AttributeCommonInfo::AS_C23, "clang::type_tag_for_datatype"},
18081 };
18082 static constexpr const char *TypeTagForDatatypeArgNames[] = {
18083 "ArgumentKind","MatchingCType","LayoutCompatible","MustBeNull",};
18084 struct ParsedAttrInfoTypeTagForDatatype final : public ParsedAttrInfo {
18085   constexpr ParsedAttrInfoTypeTagForDatatype() : ParsedAttrInfo(
18086     /*AttrKind=*/ParsedAttr::AT_TypeTagForDatatype,
18087     /*NumArgs=*/4,
18088     /*OptArgs=*/0,
18089     /*NumArgMembers=*/4,
18090     /*HasCustomParsing=*/1,
18091     /*AcceptsExprPack=*/0,
18092     /*IsTargetSpecific=*/0,
18093     /*IsType=*/0,
18094     /*IsStmt=*/0,
18095     /*IsKnownToGCC=*/0,
18096     /*IsSupportedByPragmaAttribute=*/0,
18097     /*Spellings=*/TypeTagForDatatypeSpellings,
18098     /*ArgNames=*/TypeTagForDatatypeArgNames) {}
18099 bool isParamExpr(size_t N) const override {
18100   return false;
18101 }
18102 
18103 static const ParsedAttrInfoTypeTagForDatatype Instance;
18104 };
18105 const ParsedAttrInfoTypeTagForDatatype ParsedAttrInfoTypeTagForDatatype::Instance;
18106 static constexpr ParsedAttrInfo::Spelling TypeVisibilitySpellings[] = {
18107   {AttributeCommonInfo::AS_GNU, "type_visibility"},
18108   {AttributeCommonInfo::AS_CXX11, "clang::type_visibility"},
18109   {AttributeCommonInfo::AS_C23, "clang::type_visibility"},
18110 };
18111 static constexpr const char *TypeVisibilityArgNames[] = {
18112 "Visibility",};
18113 struct ParsedAttrInfoTypeVisibility final : public ParsedAttrInfo {
18114   constexpr ParsedAttrInfoTypeVisibility() : ParsedAttrInfo(
18115     /*AttrKind=*/ParsedAttr::AT_TypeVisibility,
18116     /*NumArgs=*/1,
18117     /*OptArgs=*/0,
18118     /*NumArgMembers=*/1,
18119     /*HasCustomParsing=*/0,
18120     /*AcceptsExprPack=*/0,
18121     /*IsTargetSpecific=*/0,
18122     /*IsType=*/0,
18123     /*IsStmt=*/0,
18124     /*IsKnownToGCC=*/0,
18125     /*IsSupportedByPragmaAttribute=*/0,
18126     /*Spellings=*/TypeVisibilitySpellings,
18127     /*ArgNames=*/TypeVisibilityArgNames) {}
18128 bool isParamExpr(size_t N) const override {
18129   return false;
18130 }
18131 
18132 static const ParsedAttrInfoTypeVisibility Instance;
18133 };
18134 const ParsedAttrInfoTypeVisibility ParsedAttrInfoTypeVisibility::Instance;
18135 static constexpr ParsedAttrInfo::Spelling UPtrSpellings[] = {
18136   {AttributeCommonInfo::AS_Keyword, "__uptr"},
18137 };
18138 struct ParsedAttrInfoUPtr final : public ParsedAttrInfo {
18139   constexpr ParsedAttrInfoUPtr() : ParsedAttrInfo(
18140     /*AttrKind=*/ParsedAttr::AT_UPtr,
18141     /*NumArgs=*/0,
18142     /*OptArgs=*/0,
18143     /*NumArgMembers=*/0,
18144     /*HasCustomParsing=*/0,
18145     /*AcceptsExprPack=*/0,
18146     /*IsTargetSpecific=*/0,
18147     /*IsType=*/1,
18148     /*IsStmt=*/0,
18149     /*IsKnownToGCC=*/0,
18150     /*IsSupportedByPragmaAttribute=*/0,
18151     /*Spellings=*/UPtrSpellings,
18152     /*ArgNames=*/{}) {}
18153 bool isParamExpr(size_t N) const override {
18154   return false;
18155 }
18156 
18157 static const ParsedAttrInfoUPtr Instance;
18158 };
18159 const ParsedAttrInfoUPtr ParsedAttrInfoUPtr::Instance;
18160 static constexpr ParsedAttrInfo::Spelling UnavailableSpellings[] = {
18161   {AttributeCommonInfo::AS_GNU, "unavailable"},
18162   {AttributeCommonInfo::AS_CXX11, "clang::unavailable"},
18163   {AttributeCommonInfo::AS_C23, "clang::unavailable"},
18164 };
18165 static constexpr const char *UnavailableArgNames[] = {
18166 "Message",};
18167 struct ParsedAttrInfoUnavailable final : public ParsedAttrInfo {
18168   constexpr ParsedAttrInfoUnavailable() : ParsedAttrInfo(
18169     /*AttrKind=*/ParsedAttr::AT_Unavailable,
18170     /*NumArgs=*/0,
18171     /*OptArgs=*/1,
18172     /*NumArgMembers=*/1,
18173     /*HasCustomParsing=*/0,
18174     /*AcceptsExprPack=*/0,
18175     /*IsTargetSpecific=*/0,
18176     /*IsType=*/0,
18177     /*IsStmt=*/0,
18178     /*IsKnownToGCC=*/0,
18179     /*IsSupportedByPragmaAttribute=*/0,
18180     /*Spellings=*/UnavailableSpellings,
18181     /*ArgNames=*/UnavailableArgNames) {}
18182 bool isParamExpr(size_t N) const override {
18183   return false;
18184 }
18185 
18186 static const ParsedAttrInfoUnavailable Instance;
18187 };
18188 const ParsedAttrInfoUnavailable ParsedAttrInfoUnavailable::Instance;
18189 static constexpr ParsedAttrInfo::Spelling UninitializedSpellings[] = {
18190   {AttributeCommonInfo::AS_GNU, "uninitialized"},
18191   {AttributeCommonInfo::AS_CXX11, "clang::uninitialized"},
18192 };
18193 struct ParsedAttrInfoUninitialized final : public ParsedAttrInfo {
18194   constexpr ParsedAttrInfoUninitialized() : ParsedAttrInfo(
18195     /*AttrKind=*/ParsedAttr::AT_Uninitialized,
18196     /*NumArgs=*/0,
18197     /*OptArgs=*/0,
18198     /*NumArgMembers=*/0,
18199     /*HasCustomParsing=*/0,
18200     /*AcceptsExprPack=*/0,
18201     /*IsTargetSpecific=*/0,
18202     /*IsType=*/0,
18203     /*IsStmt=*/0,
18204     /*IsKnownToGCC=*/0,
18205     /*IsSupportedByPragmaAttribute=*/1,
18206     /*Spellings=*/UninitializedSpellings,
18207     /*ArgNames=*/{}) {}
18208 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18209   if (!isLocalVar(D)) {
18210     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18211       << Attr << Attr.isRegularKeywordAttribute() << "local variables";
18212     return false;
18213   }
18214   return true;
18215 }
18216 
18217 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18218   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18219     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18220   return false;
18221 }
18222 
18223 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18224   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_local, /*IsSupported=*/true));
18225 }
18226 
18227 bool isParamExpr(size_t N) const override {
18228   return false;
18229 }
18230 
18231 static const ParsedAttrInfoUninitialized Instance;
18232 };
18233 const ParsedAttrInfoUninitialized ParsedAttrInfoUninitialized::Instance;
18234 static constexpr ParsedAttrInfo::Spelling UnlikelySpellings[] = {
18235   {AttributeCommonInfo::AS_CXX11, "unlikely"},
18236   {AttributeCommonInfo::AS_C23, "clang::unlikely"},
18237 };
18238 struct ParsedAttrInfoUnlikely final : public ParsedAttrInfo {
18239   constexpr ParsedAttrInfoUnlikely() : ParsedAttrInfo(
18240     /*AttrKind=*/ParsedAttr::AT_Unlikely,
18241     /*NumArgs=*/0,
18242     /*OptArgs=*/0,
18243     /*NumArgMembers=*/0,
18244     /*HasCustomParsing=*/0,
18245     /*AcceptsExprPack=*/0,
18246     /*IsTargetSpecific=*/0,
18247     /*IsType=*/0,
18248     /*IsStmt=*/1,
18249     /*IsKnownToGCC=*/0,
18250     /*IsSupportedByPragmaAttribute=*/0,
18251     /*Spellings=*/UnlikelySpellings,
18252     /*ArgNames=*/{}) {}
18253   using ParsedAttrInfo::diagMutualExclusion;
18254 
18255 bool isParamExpr(size_t N) const override {
18256   return false;
18257 }
18258 
18259 static const ParsedAttrInfoUnlikely Instance;
18260 };
18261 const ParsedAttrInfoUnlikely ParsedAttrInfoUnlikely::Instance;
18262 static constexpr ParsedAttrInfo::Spelling UnsafeBufferUsageSpellings[] = {
18263   {AttributeCommonInfo::AS_GNU, "unsafe_buffer_usage"},
18264   {AttributeCommonInfo::AS_CXX11, "clang::unsafe_buffer_usage"},
18265   {AttributeCommonInfo::AS_C23, "clang::unsafe_buffer_usage"},
18266 };
18267 struct ParsedAttrInfoUnsafeBufferUsage final : public ParsedAttrInfo {
18268   constexpr ParsedAttrInfoUnsafeBufferUsage() : ParsedAttrInfo(
18269     /*AttrKind=*/ParsedAttr::AT_UnsafeBufferUsage,
18270     /*NumArgs=*/0,
18271     /*OptArgs=*/0,
18272     /*NumArgMembers=*/0,
18273     /*HasCustomParsing=*/0,
18274     /*AcceptsExprPack=*/0,
18275     /*IsTargetSpecific=*/0,
18276     /*IsType=*/0,
18277     /*IsStmt=*/0,
18278     /*IsKnownToGCC=*/0,
18279     /*IsSupportedByPragmaAttribute=*/1,
18280     /*Spellings=*/UnsafeBufferUsageSpellings,
18281     /*ArgNames=*/{}) {}
18282 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18283   if (!isa<FunctionDecl>(D) && !isa<FieldDecl>(D)) {
18284     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18285       << Attr << Attr.isRegularKeywordAttribute() << "functions and non-static data members";
18286     return false;
18287   }
18288   return true;
18289 }
18290 
18291 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18292   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18293     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18294   return false;
18295 }
18296 
18297 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18298   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
18299   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_field, /*IsSupported=*/true));
18300 }
18301 
18302 bool isParamExpr(size_t N) const override {
18303   return false;
18304 }
18305 
18306 static const ParsedAttrInfoUnsafeBufferUsage Instance;
18307 };
18308 const ParsedAttrInfoUnsafeBufferUsage ParsedAttrInfoUnsafeBufferUsage::Instance;
18309 static constexpr ParsedAttrInfo::Spelling UnusedSpellings[] = {
18310   {AttributeCommonInfo::AS_CXX11, "maybe_unused"},
18311   {AttributeCommonInfo::AS_GNU, "unused"},
18312   {AttributeCommonInfo::AS_CXX11, "gnu::unused"},
18313   {AttributeCommonInfo::AS_C23, "gnu::unused"},
18314   {AttributeCommonInfo::AS_C23, "maybe_unused"},
18315 };
18316 struct ParsedAttrInfoUnused final : public ParsedAttrInfo {
18317   constexpr ParsedAttrInfoUnused() : ParsedAttrInfo(
18318     /*AttrKind=*/ParsedAttr::AT_Unused,
18319     /*NumArgs=*/0,
18320     /*OptArgs=*/0,
18321     /*NumArgMembers=*/0,
18322     /*HasCustomParsing=*/0,
18323     /*AcceptsExprPack=*/0,
18324     /*IsTargetSpecific=*/0,
18325     /*IsType=*/0,
18326     /*IsStmt=*/0,
18327     /*IsKnownToGCC=*/1,
18328     /*IsSupportedByPragmaAttribute=*/0,
18329     /*Spellings=*/UnusedSpellings,
18330     /*ArgNames=*/{}) {}
18331 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18332   if (!isa<VarDecl>(D) && !isa<BindingDecl>(D) && !isa<ObjCIvarDecl>(D) && !isa<TypeDecl>(D) && !isa<EnumDecl>(D) && !isa<EnumConstantDecl>(D) && !isa<LabelDecl>(D) && !isa<FieldDecl>(D) && !isa<ObjCMethodDecl>(D) && !isFunctionLike(D)) {
18333     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18334       << Attr << Attr.isRegularKeywordAttribute() << "variables, value declarations, non-static data members, types, enums, enumerators, labels, non-static data members, Objective-C methods, functions, and function pointers";
18335     return false;
18336   }
18337   return true;
18338 }
18339 
18340 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18341   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18342     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18343   return false;
18344 }
18345 
18346 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
18347   enum Spelling {
18348     CXX11_maybe_unused = 0,
18349     GNU_unused = 1,
18350     CXX11_gnu_unused = 2,
18351     C23_gnu_unused = 3,
18352     C23_maybe_unused = 4,
18353   SpellingNotCalculated = 15
18354 
18355   };
18356 
18357   unsigned Idx = Attr.getAttributeSpellingListIndex();
18358   switch (Idx) {
18359     default: llvm_unreachable("Unknown spelling list index");
18360     case 0: return CXX11_maybe_unused;
18361     case 1: return GNU_unused;
18362     case 2: return CXX11_gnu_unused;
18363     case 3: return C23_gnu_unused;
18364     case 4: return C23_maybe_unused;
18365   }
18366 }
18367 
18368 bool isParamExpr(size_t N) const override {
18369   return false;
18370 }
18371 
18372 static const ParsedAttrInfoUnused Instance;
18373 };
18374 const ParsedAttrInfoUnused ParsedAttrInfoUnused::Instance;
18375 static constexpr ParsedAttrInfo::Spelling UseHandleSpellings[] = {
18376   {AttributeCommonInfo::AS_GNU, "use_handle"},
18377   {AttributeCommonInfo::AS_CXX11, "clang::use_handle"},
18378   {AttributeCommonInfo::AS_C23, "clang::use_handle"},
18379 };
18380 static constexpr const char *UseHandleArgNames[] = {
18381 "HandleType",};
18382 struct ParsedAttrInfoUseHandle final : public ParsedAttrInfo {
18383   constexpr ParsedAttrInfoUseHandle() : ParsedAttrInfo(
18384     /*AttrKind=*/ParsedAttr::AT_UseHandle,
18385     /*NumArgs=*/1,
18386     /*OptArgs=*/0,
18387     /*NumArgMembers=*/1,
18388     /*HasCustomParsing=*/0,
18389     /*AcceptsExprPack=*/0,
18390     /*IsTargetSpecific=*/0,
18391     /*IsType=*/0,
18392     /*IsStmt=*/0,
18393     /*IsKnownToGCC=*/0,
18394     /*IsSupportedByPragmaAttribute=*/1,
18395     /*Spellings=*/UseHandleSpellings,
18396     /*ArgNames=*/UseHandleArgNames) {}
18397 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18398   if (!isa<ParmVarDecl>(D)) {
18399     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18400       << Attr << Attr.isRegularKeywordAttribute() << "parameters";
18401     return false;
18402   }
18403   return true;
18404 }
18405 
18406 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18407   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18408     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18409   return false;
18410 }
18411 
18412 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18413   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable_is_parameter, /*IsSupported=*/true));
18414 }
18415 
18416 bool isParamExpr(size_t N) const override {
18417   return false;
18418 }
18419 
18420 static const ParsedAttrInfoUseHandle Instance;
18421 };
18422 const ParsedAttrInfoUseHandle ParsedAttrInfoUseHandle::Instance;
18423 static constexpr ParsedAttrInfo::Spelling UsedSpellings[] = {
18424   {AttributeCommonInfo::AS_GNU, "used"},
18425   {AttributeCommonInfo::AS_CXX11, "gnu::used"},
18426   {AttributeCommonInfo::AS_C23, "gnu::used"},
18427 };
18428 struct ParsedAttrInfoUsed final : public ParsedAttrInfo {
18429   constexpr ParsedAttrInfoUsed() : ParsedAttrInfo(
18430     /*AttrKind=*/ParsedAttr::AT_Used,
18431     /*NumArgs=*/0,
18432     /*OptArgs=*/0,
18433     /*NumArgMembers=*/0,
18434     /*HasCustomParsing=*/0,
18435     /*AcceptsExprPack=*/0,
18436     /*IsTargetSpecific=*/0,
18437     /*IsType=*/0,
18438     /*IsStmt=*/0,
18439     /*IsKnownToGCC=*/1,
18440     /*IsSupportedByPragmaAttribute=*/0,
18441     /*Spellings=*/UsedSpellings,
18442     /*ArgNames=*/{}) {}
18443 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18444   if (!isNonLocalVar(D) && !isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
18445     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18446       << Attr << Attr.isRegularKeywordAttribute() << "variables with non-local storage, functions, and Objective-C methods";
18447     return false;
18448   }
18449   return true;
18450 }
18451 
18452 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18453   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18454     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18455   return false;
18456 }
18457 
18458 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
18459   D->addAttr(::new (S.Context) UsedAttr(S.Context, Attr));
18460   return AttributeApplied;
18461 }
18462 
18463 bool isParamExpr(size_t N) const override {
18464   return false;
18465 }
18466 
18467 static const ParsedAttrInfoUsed Instance;
18468 };
18469 const ParsedAttrInfoUsed ParsedAttrInfoUsed::Instance;
18470 static constexpr ParsedAttrInfo::Spelling UsingIfExistsSpellings[] = {
18471   {AttributeCommonInfo::AS_GNU, "using_if_exists"},
18472   {AttributeCommonInfo::AS_CXX11, "clang::using_if_exists"},
18473 };
18474 struct ParsedAttrInfoUsingIfExists final : public ParsedAttrInfo {
18475   constexpr ParsedAttrInfoUsingIfExists() : ParsedAttrInfo(
18476     /*AttrKind=*/ParsedAttr::AT_UsingIfExists,
18477     /*NumArgs=*/0,
18478     /*OptArgs=*/0,
18479     /*NumArgMembers=*/0,
18480     /*HasCustomParsing=*/0,
18481     /*AcceptsExprPack=*/0,
18482     /*IsTargetSpecific=*/0,
18483     /*IsType=*/0,
18484     /*IsStmt=*/0,
18485     /*IsKnownToGCC=*/0,
18486     /*IsSupportedByPragmaAttribute=*/0,
18487     /*Spellings=*/UsingIfExistsSpellings,
18488     /*ArgNames=*/{}) {}
18489 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18490   if (!isa<UsingDecl>(D) && !isa<UnresolvedUsingTypenameDecl>(D) && !isa<UnresolvedUsingValueDecl>(D)) {
18491     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
18492       << Attr << Attr.isRegularKeywordAttribute() << "named declarations, types, and value declarations";
18493     return false;
18494   }
18495   return true;
18496 }
18497 
18498 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18499   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18500     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18501   return false;
18502 }
18503 
18504 bool isParamExpr(size_t N) const override {
18505   return false;
18506 }
18507 
18508 static const ParsedAttrInfoUsingIfExists Instance;
18509 };
18510 const ParsedAttrInfoUsingIfExists ParsedAttrInfoUsingIfExists::Instance;
18511 static constexpr ParsedAttrInfo::Spelling UuidSpellings[] = {
18512   {AttributeCommonInfo::AS_Declspec, "uuid"},
18513   {AttributeCommonInfo::AS_Microsoft, "uuid"},
18514 };
18515 static constexpr const char *UuidArgNames[] = {
18516 "Guid",};
18517 struct ParsedAttrInfoUuid final : public ParsedAttrInfo {
18518   constexpr ParsedAttrInfoUuid() : ParsedAttrInfo(
18519     /*AttrKind=*/ParsedAttr::AT_Uuid,
18520     /*NumArgs=*/1,
18521     /*OptArgs=*/0,
18522     /*NumArgMembers=*/1,
18523     /*HasCustomParsing=*/0,
18524     /*AcceptsExprPack=*/0,
18525     /*IsTargetSpecific=*/0,
18526     /*IsType=*/0,
18527     /*IsStmt=*/0,
18528     /*IsKnownToGCC=*/0,
18529     /*IsSupportedByPragmaAttribute=*/0,
18530     /*Spellings=*/UuidSpellings,
18531     /*ArgNames=*/UuidArgNames) {}
18532 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18533   if (!isa<RecordDecl>(D) && !isa<EnumDecl>(D)) {
18534     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18535       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, classes, and enums";
18536     return false;
18537   }
18538   return true;
18539 }
18540 
18541 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18542   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18543     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18544   return false;
18545 }
18546 
18547 bool acceptsLangOpts(const LangOptions &LangOpts) const override {
18548   return LangOpts.MicrosoftExt || LangOpts.Borland;
18549 }
18550 
18551 bool isParamExpr(size_t N) const override {
18552   return false;
18553 }
18554 
18555 static const ParsedAttrInfoUuid Instance;
18556 };
18557 const ParsedAttrInfoUuid ParsedAttrInfoUuid::Instance;
18558 static constexpr ParsedAttrInfo::Spelling VTablePointerAuthenticationSpellings[] = {
18559   {AttributeCommonInfo::AS_GNU, "ptrauth_vtable_pointer"},
18560   {AttributeCommonInfo::AS_CXX11, "clang::ptrauth_vtable_pointer"},
18561   {AttributeCommonInfo::AS_C23, "clang::ptrauth_vtable_pointer"},
18562 };
18563 static constexpr const char *VTablePointerAuthenticationArgNames[] = {
18564 "Key","AddressDiscrimination","ExtraDiscrimination","CustomDiscriminationValue",};
18565 struct ParsedAttrInfoVTablePointerAuthentication final : public ParsedAttrInfo {
18566   constexpr ParsedAttrInfoVTablePointerAuthentication() : ParsedAttrInfo(
18567     /*AttrKind=*/ParsedAttr::AT_VTablePointerAuthentication,
18568     /*NumArgs=*/3,
18569     /*OptArgs=*/1,
18570     /*NumArgMembers=*/4,
18571     /*HasCustomParsing=*/0,
18572     /*AcceptsExprPack=*/0,
18573     /*IsTargetSpecific=*/0,
18574     /*IsType=*/0,
18575     /*IsStmt=*/0,
18576     /*IsKnownToGCC=*/0,
18577     /*IsSupportedByPragmaAttribute=*/1,
18578     /*Spellings=*/VTablePointerAuthenticationSpellings,
18579     /*ArgNames=*/VTablePointerAuthenticationArgNames) {}
18580 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18581   if (!isa<CXXRecordDecl>(D)) {
18582     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18583       << Attr << Attr.isRegularKeywordAttribute() << "classes";
18584     return false;
18585   }
18586   return true;
18587 }
18588 
18589 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18590   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18591     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18592   return false;
18593 }
18594 
18595 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18596   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
18597 }
18598 
18599 bool isParamExpr(size_t N) const override {
18600   return false;
18601 }
18602 
18603 static const ParsedAttrInfoVTablePointerAuthentication Instance;
18604 };
18605 const ParsedAttrInfoVTablePointerAuthentication ParsedAttrInfoVTablePointerAuthentication::Instance;
18606 static constexpr ParsedAttrInfo::Spelling VecReturnSpellings[] = {
18607   {AttributeCommonInfo::AS_GNU, "vecreturn"},
18608   {AttributeCommonInfo::AS_CXX11, "clang::vecreturn"},
18609 };
18610 struct ParsedAttrInfoVecReturn final : public ParsedAttrInfo {
18611   constexpr ParsedAttrInfoVecReturn() : ParsedAttrInfo(
18612     /*AttrKind=*/ParsedAttr::AT_VecReturn,
18613     /*NumArgs=*/0,
18614     /*OptArgs=*/0,
18615     /*NumArgMembers=*/0,
18616     /*HasCustomParsing=*/0,
18617     /*AcceptsExprPack=*/0,
18618     /*IsTargetSpecific=*/0,
18619     /*IsType=*/0,
18620     /*IsStmt=*/0,
18621     /*IsKnownToGCC=*/0,
18622     /*IsSupportedByPragmaAttribute=*/1,
18623     /*Spellings=*/VecReturnSpellings,
18624     /*ArgNames=*/{}) {}
18625 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18626   if (!isa<CXXRecordDecl>(D)) {
18627     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
18628       << Attr << Attr.isRegularKeywordAttribute() << "classes";
18629     return false;
18630   }
18631   return true;
18632 }
18633 
18634 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18635   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18636     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18637   return false;
18638 }
18639 
18640 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18641   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
18642 }
18643 
18644 bool isParamExpr(size_t N) const override {
18645   return false;
18646 }
18647 
18648 static const ParsedAttrInfoVecReturn Instance;
18649 };
18650 const ParsedAttrInfoVecReturn ParsedAttrInfoVecReturn::Instance;
18651 static constexpr ParsedAttrInfo::Spelling VecTypeHintSpellings[] = {
18652   {AttributeCommonInfo::AS_GNU, "vec_type_hint"},
18653 };
18654 static constexpr const char *VecTypeHintArgNames[] = {
18655 "TypeHint",};
18656 struct ParsedAttrInfoVecTypeHint final : public ParsedAttrInfo {
18657   constexpr ParsedAttrInfoVecTypeHint() : ParsedAttrInfo(
18658     /*AttrKind=*/ParsedAttr::AT_VecTypeHint,
18659     /*NumArgs=*/1,
18660     /*OptArgs=*/0,
18661     /*NumArgMembers=*/1,
18662     /*HasCustomParsing=*/0,
18663     /*AcceptsExprPack=*/0,
18664     /*IsTargetSpecific=*/0,
18665     /*IsType=*/0,
18666     /*IsStmt=*/0,
18667     /*IsKnownToGCC=*/0,
18668     /*IsSupportedByPragmaAttribute=*/1,
18669     /*Spellings=*/VecTypeHintSpellings,
18670     /*ArgNames=*/VecTypeHintArgNames) {}
18671 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18672   if (!isa<FunctionDecl>(D)) {
18673     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
18674       << Attr << Attr.isRegularKeywordAttribute() << "functions";
18675     return false;
18676   }
18677   return true;
18678 }
18679 
18680 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18681   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18682     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18683   return false;
18684 }
18685 
18686 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18687   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
18688 }
18689 
18690 bool isParamExpr(size_t N) const override {
18691   return false;
18692 }
18693 
18694 static const ParsedAttrInfoVecTypeHint Instance;
18695 };
18696 const ParsedAttrInfoVecTypeHint ParsedAttrInfoVecTypeHint::Instance;
18697 static constexpr ParsedAttrInfo::Spelling VectorCallSpellings[] = {
18698   {AttributeCommonInfo::AS_GNU, "vectorcall"},
18699   {AttributeCommonInfo::AS_CXX11, "clang::vectorcall"},
18700   {AttributeCommonInfo::AS_C23, "clang::vectorcall"},
18701   {AttributeCommonInfo::AS_Keyword, "__vectorcall"},
18702   {AttributeCommonInfo::AS_Keyword, "_vectorcall"},
18703 };
18704 struct ParsedAttrInfoVectorCall final : public ParsedAttrInfo {
18705   constexpr ParsedAttrInfoVectorCall() : ParsedAttrInfo(
18706     /*AttrKind=*/ParsedAttr::AT_VectorCall,
18707     /*NumArgs=*/0,
18708     /*OptArgs=*/0,
18709     /*NumArgMembers=*/0,
18710     /*HasCustomParsing=*/0,
18711     /*AcceptsExprPack=*/0,
18712     /*IsTargetSpecific=*/0,
18713     /*IsType=*/1,
18714     /*IsStmt=*/0,
18715     /*IsKnownToGCC=*/0,
18716     /*IsSupportedByPragmaAttribute=*/0,
18717     /*Spellings=*/VectorCallSpellings,
18718     /*ArgNames=*/{}) {}
18719 bool isParamExpr(size_t N) const override {
18720   return false;
18721 }
18722 
18723 static const ParsedAttrInfoVectorCall Instance;
18724 };
18725 const ParsedAttrInfoVectorCall ParsedAttrInfoVectorCall::Instance;
18726 static constexpr ParsedAttrInfo::Spelling VectorSizeSpellings[] = {
18727   {AttributeCommonInfo::AS_GNU, "vector_size"},
18728   {AttributeCommonInfo::AS_CXX11, "gnu::vector_size"},
18729   {AttributeCommonInfo::AS_C23, "gnu::vector_size"},
18730 };
18731 static constexpr const char *VectorSizeArgNames[] = {
18732 "NumBytes",};
18733 struct ParsedAttrInfoVectorSize final : public ParsedAttrInfo {
18734   constexpr ParsedAttrInfoVectorSize() : ParsedAttrInfo(
18735     /*AttrKind=*/ParsedAttr::AT_VectorSize,
18736     /*NumArgs=*/1,
18737     /*OptArgs=*/0,
18738     /*NumArgMembers=*/1,
18739     /*HasCustomParsing=*/0,
18740     /*AcceptsExprPack=*/0,
18741     /*IsTargetSpecific=*/0,
18742     /*IsType=*/1,
18743     /*IsStmt=*/0,
18744     /*IsKnownToGCC=*/1,
18745     /*IsSupportedByPragmaAttribute=*/0,
18746     /*Spellings=*/VectorSizeSpellings,
18747     /*ArgNames=*/VectorSizeArgNames) {}
18748 bool isParamExpr(size_t N) const override {
18749   return (N == 0) || false;
18750 }
18751 
18752 static const ParsedAttrInfoVectorSize Instance;
18753 };
18754 const ParsedAttrInfoVectorSize ParsedAttrInfoVectorSize::Instance;
18755 static constexpr ParsedAttrInfo::Spelling VisibilitySpellings[] = {
18756   {AttributeCommonInfo::AS_GNU, "visibility"},
18757   {AttributeCommonInfo::AS_CXX11, "gnu::visibility"},
18758   {AttributeCommonInfo::AS_C23, "gnu::visibility"},
18759 };
18760 static constexpr const char *VisibilityArgNames[] = {
18761 "Visibility",};
18762 struct ParsedAttrInfoVisibility final : public ParsedAttrInfo {
18763   constexpr ParsedAttrInfoVisibility() : ParsedAttrInfo(
18764     /*AttrKind=*/ParsedAttr::AT_Visibility,
18765     /*NumArgs=*/1,
18766     /*OptArgs=*/0,
18767     /*NumArgMembers=*/1,
18768     /*HasCustomParsing=*/0,
18769     /*AcceptsExprPack=*/0,
18770     /*IsTargetSpecific=*/0,
18771     /*IsType=*/0,
18772     /*IsStmt=*/0,
18773     /*IsKnownToGCC=*/1,
18774     /*IsSupportedByPragmaAttribute=*/0,
18775     /*Spellings=*/VisibilitySpellings,
18776     /*ArgNames=*/VisibilityArgNames) {}
18777 bool isParamExpr(size_t N) const override {
18778   return false;
18779 }
18780 
18781 static const ParsedAttrInfoVisibility Instance;
18782 };
18783 const ParsedAttrInfoVisibility ParsedAttrInfoVisibility::Instance;
18784 static constexpr ParsedAttrInfo::Spelling WarnUnusedSpellings[] = {
18785   {AttributeCommonInfo::AS_GNU, "warn_unused"},
18786   {AttributeCommonInfo::AS_CXX11, "gnu::warn_unused"},
18787   {AttributeCommonInfo::AS_C23, "gnu::warn_unused"},
18788 };
18789 struct ParsedAttrInfoWarnUnused final : public ParsedAttrInfo {
18790   constexpr ParsedAttrInfoWarnUnused() : ParsedAttrInfo(
18791     /*AttrKind=*/ParsedAttr::AT_WarnUnused,
18792     /*NumArgs=*/0,
18793     /*OptArgs=*/0,
18794     /*NumArgMembers=*/0,
18795     /*HasCustomParsing=*/0,
18796     /*AcceptsExprPack=*/0,
18797     /*IsTargetSpecific=*/0,
18798     /*IsType=*/0,
18799     /*IsStmt=*/0,
18800     /*IsKnownToGCC=*/1,
18801     /*IsSupportedByPragmaAttribute=*/1,
18802     /*Spellings=*/WarnUnusedSpellings,
18803     /*ArgNames=*/{}) {}
18804 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18805   if (!isa<RecordDecl>(D)) {
18806     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18807       << Attr << Attr.isRegularKeywordAttribute() << "structs, unions, and classes";
18808     return false;
18809   }
18810   return true;
18811 }
18812 
18813 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18814   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18815     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18816   return false;
18817 }
18818 
18819 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18820   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
18821 }
18822 
18823 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
18824   D->addAttr(::new (S.Context) WarnUnusedAttr(S.Context, Attr));
18825   return AttributeApplied;
18826 }
18827 
18828 bool isParamExpr(size_t N) const override {
18829   return false;
18830 }
18831 
18832 static const ParsedAttrInfoWarnUnused Instance;
18833 };
18834 const ParsedAttrInfoWarnUnused ParsedAttrInfoWarnUnused::Instance;
18835 static constexpr ParsedAttrInfo::Spelling WarnUnusedResultSpellings[] = {
18836   {AttributeCommonInfo::AS_CXX11, "nodiscard"},
18837   {AttributeCommonInfo::AS_C23, "nodiscard"},
18838   {AttributeCommonInfo::AS_CXX11, "clang::warn_unused_result"},
18839   {AttributeCommonInfo::AS_GNU, "warn_unused_result"},
18840   {AttributeCommonInfo::AS_CXX11, "gnu::warn_unused_result"},
18841   {AttributeCommonInfo::AS_C23, "gnu::warn_unused_result"},
18842 };
18843 static constexpr const char *WarnUnusedResultArgNames[] = {
18844 "Message",};
18845 struct ParsedAttrInfoWarnUnusedResult final : public ParsedAttrInfo {
18846   constexpr ParsedAttrInfoWarnUnusedResult() : ParsedAttrInfo(
18847     /*AttrKind=*/ParsedAttr::AT_WarnUnusedResult,
18848     /*NumArgs=*/0,
18849     /*OptArgs=*/1,
18850     /*NumArgMembers=*/1,
18851     /*HasCustomParsing=*/0,
18852     /*AcceptsExprPack=*/0,
18853     /*IsTargetSpecific=*/0,
18854     /*IsType=*/0,
18855     /*IsStmt=*/0,
18856     /*IsKnownToGCC=*/1,
18857     /*IsSupportedByPragmaAttribute=*/1,
18858     /*Spellings=*/WarnUnusedResultSpellings,
18859     /*ArgNames=*/WarnUnusedResultArgNames) {}
18860 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18861   if (!isa<ObjCMethodDecl>(D) && !isa<EnumDecl>(D) && !isa<RecordDecl>(D) && !isFunctionLike(D) && !isa<TypedefNameDecl>(D)) {
18862     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18863       << Attr << Attr.isRegularKeywordAttribute() << "Objective-C methods, enums, structs, unions, classes, functions, function pointers, and typedefs";
18864     return false;
18865   }
18866   return true;
18867 }
18868 
18869 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18870   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18871     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18872   return false;
18873 }
18874 
18875 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
18876   enum Spelling {
18877     CXX11_nodiscard = 0,
18878     C23_nodiscard = 1,
18879     CXX11_clang_warn_unused_result = 2,
18880     GNU_warn_unused_result = 3,
18881     CXX11_gnu_warn_unused_result = 4,
18882     C23_gnu_warn_unused_result = 5,
18883   SpellingNotCalculated = 15
18884 
18885   };
18886 
18887   unsigned Idx = Attr.getAttributeSpellingListIndex();
18888   switch (Idx) {
18889     default: llvm_unreachable("Unknown spelling list index");
18890     case 0: return CXX11_nodiscard;
18891     case 1: return C23_nodiscard;
18892     case 2: return CXX11_clang_warn_unused_result;
18893     case 3: return GNU_warn_unused_result;
18894     case 4: return CXX11_gnu_warn_unused_result;
18895     case 5: return C23_gnu_warn_unused_result;
18896   }
18897 }
18898 
18899 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18900   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
18901   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_enum, /*IsSupported=*/true));
18902   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
18903   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_hasType_functionType, /*IsSupported=*/true));
18904   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_type_alias, /*IsSupported=*/true));
18905 }
18906 
18907 bool isParamExpr(size_t N) const override {
18908   return false;
18909 }
18910 
18911 static const ParsedAttrInfoWarnUnusedResult Instance;
18912 };
18913 const ParsedAttrInfoWarnUnusedResult ParsedAttrInfoWarnUnusedResult::Instance;
18914 static constexpr ParsedAttrInfo::Spelling WeakSpellings[] = {
18915   {AttributeCommonInfo::AS_GNU, "weak"},
18916   {AttributeCommonInfo::AS_CXX11, "gnu::weak"},
18917   {AttributeCommonInfo::AS_C23, "gnu::weak"},
18918 };
18919 struct ParsedAttrInfoWeak final : public ParsedAttrInfo {
18920   constexpr ParsedAttrInfoWeak() : ParsedAttrInfo(
18921     /*AttrKind=*/ParsedAttr::AT_Weak,
18922     /*NumArgs=*/0,
18923     /*OptArgs=*/0,
18924     /*NumArgMembers=*/0,
18925     /*HasCustomParsing=*/0,
18926     /*AcceptsExprPack=*/0,
18927     /*IsTargetSpecific=*/0,
18928     /*IsType=*/0,
18929     /*IsStmt=*/0,
18930     /*IsKnownToGCC=*/1,
18931     /*IsSupportedByPragmaAttribute=*/1,
18932     /*Spellings=*/WeakSpellings,
18933     /*ArgNames=*/{}) {}
18934 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
18935   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D) && !isa<CXXRecordDecl>(D)) {
18936     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
18937       << Attr << Attr.isRegularKeywordAttribute() << "variables, functions, and classes";
18938     return false;
18939   }
18940   return true;
18941 }
18942 
18943 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
18944   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
18945     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
18946   return false;
18947 }
18948 
18949 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
18950   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
18951   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
18952   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_record, /*IsSupported=*/true));
18953 }
18954 
18955 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
18956   D->addAttr(::new (S.Context) WeakAttr(S.Context, Attr));
18957   return AttributeApplied;
18958 }
18959 
18960 bool isParamExpr(size_t N) const override {
18961   return false;
18962 }
18963 
18964 static const ParsedAttrInfoWeak Instance;
18965 };
18966 const ParsedAttrInfoWeak ParsedAttrInfoWeak::Instance;
18967 static constexpr ParsedAttrInfo::Spelling WeakImportSpellings[] = {
18968   {AttributeCommonInfo::AS_GNU, "weak_import"},
18969   {AttributeCommonInfo::AS_CXX11, "clang::weak_import"},
18970   {AttributeCommonInfo::AS_C23, "clang::weak_import"},
18971 };
18972 struct ParsedAttrInfoWeakImport final : public ParsedAttrInfo {
18973   constexpr ParsedAttrInfoWeakImport() : ParsedAttrInfo(
18974     /*AttrKind=*/ParsedAttr::AT_WeakImport,
18975     /*NumArgs=*/0,
18976     /*OptArgs=*/0,
18977     /*NumArgMembers=*/0,
18978     /*HasCustomParsing=*/0,
18979     /*AcceptsExprPack=*/0,
18980     /*IsTargetSpecific=*/0,
18981     /*IsType=*/0,
18982     /*IsStmt=*/0,
18983     /*IsKnownToGCC=*/0,
18984     /*IsSupportedByPragmaAttribute=*/0,
18985     /*Spellings=*/WeakImportSpellings,
18986     /*ArgNames=*/{}) {}
18987 bool isParamExpr(size_t N) const override {
18988   return false;
18989 }
18990 
18991 static const ParsedAttrInfoWeakImport Instance;
18992 };
18993 const ParsedAttrInfoWeakImport ParsedAttrInfoWeakImport::Instance;
18994 static constexpr ParsedAttrInfo::Spelling WeakRefSpellings[] = {
18995   {AttributeCommonInfo::AS_GNU, "weakref"},
18996   {AttributeCommonInfo::AS_CXX11, "gnu::weakref"},
18997   {AttributeCommonInfo::AS_C23, "gnu::weakref"},
18998 };
18999 static constexpr const char *WeakRefArgNames[] = {
19000 "Aliasee",};
19001 struct ParsedAttrInfoWeakRef final : public ParsedAttrInfo {
19002   constexpr ParsedAttrInfoWeakRef() : ParsedAttrInfo(
19003     /*AttrKind=*/ParsedAttr::AT_WeakRef,
19004     /*NumArgs=*/0,
19005     /*OptArgs=*/1,
19006     /*NumArgMembers=*/1,
19007     /*HasCustomParsing=*/0,
19008     /*AcceptsExprPack=*/0,
19009     /*IsTargetSpecific=*/0,
19010     /*IsType=*/0,
19011     /*IsStmt=*/0,
19012     /*IsKnownToGCC=*/1,
19013     /*IsSupportedByPragmaAttribute=*/1,
19014     /*Spellings=*/WeakRefSpellings,
19015     /*ArgNames=*/WeakRefArgNames) {}
19016 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19017   if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) {
19018     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19019       << Attr << Attr.isRegularKeywordAttribute() << "variables and functions";
19020     return false;
19021   }
19022   return true;
19023 }
19024 
19025 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19026   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19027     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19028   return false;
19029 }
19030 
19031 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19032   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_variable, /*IsSupported=*/true));
19033   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19034 }
19035 
19036 bool isParamExpr(size_t N) const override {
19037   return false;
19038 }
19039 
19040 static const ParsedAttrInfoWeakRef Instance;
19041 };
19042 const ParsedAttrInfoWeakRef ParsedAttrInfoWeakRef::Instance;
19043 static constexpr ParsedAttrInfo::Spelling WebAssemblyExportNameSpellings[] = {
19044   {AttributeCommonInfo::AS_GNU, "export_name"},
19045   {AttributeCommonInfo::AS_CXX11, "clang::export_name"},
19046   {AttributeCommonInfo::AS_C23, "clang::export_name"},
19047 };
19048 static constexpr const char *WebAssemblyExportNameArgNames[] = {
19049 "ExportName",};
19050 struct ParsedAttrInfoWebAssemblyExportName final : public ParsedAttrInfo {
19051   constexpr ParsedAttrInfoWebAssemblyExportName() : ParsedAttrInfo(
19052     /*AttrKind=*/ParsedAttr::AT_WebAssemblyExportName,
19053     /*NumArgs=*/1,
19054     /*OptArgs=*/0,
19055     /*NumArgMembers=*/1,
19056     /*HasCustomParsing=*/0,
19057     /*AcceptsExprPack=*/0,
19058     /*IsTargetSpecific=*/1,
19059     /*IsType=*/0,
19060     /*IsStmt=*/0,
19061     /*IsKnownToGCC=*/0,
19062     /*IsSupportedByPragmaAttribute=*/1,
19063     /*Spellings=*/WebAssemblyExportNameSpellings,
19064     /*ArgNames=*/WebAssemblyExportNameArgNames) {}
19065 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19066   if (!isa<FunctionDecl>(D)) {
19067     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19068       << Attr << Attr.isRegularKeywordAttribute() << "functions";
19069     return false;
19070   }
19071   return true;
19072 }
19073 
19074 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19075   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19076     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19077   return false;
19078 }
19079 
19080 bool existsInTarget(const TargetInfo &Target) const override {
19081   const llvm::Triple &T = Target.getTriple(); (void)T;
19082   return true && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64);
19083 }
19084 
19085 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19086   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19087 }
19088 
19089 bool isParamExpr(size_t N) const override {
19090   return false;
19091 }
19092 
19093 static const ParsedAttrInfoWebAssemblyExportName Instance;
19094 };
19095 const ParsedAttrInfoWebAssemblyExportName ParsedAttrInfoWebAssemblyExportName::Instance;
19096 static constexpr ParsedAttrInfo::Spelling WebAssemblyFuncrefSpellings[] = {
19097   {AttributeCommonInfo::AS_Keyword, "__funcref"},
19098 };
19099 struct ParsedAttrInfoWebAssemblyFuncref final : public ParsedAttrInfo {
19100   constexpr ParsedAttrInfoWebAssemblyFuncref() : ParsedAttrInfo(
19101     /*AttrKind=*/ParsedAttr::AT_WebAssemblyFuncref,
19102     /*NumArgs=*/0,
19103     /*OptArgs=*/0,
19104     /*NumArgMembers=*/0,
19105     /*HasCustomParsing=*/0,
19106     /*AcceptsExprPack=*/0,
19107     /*IsTargetSpecific=*/1,
19108     /*IsType=*/1,
19109     /*IsStmt=*/0,
19110     /*IsKnownToGCC=*/0,
19111     /*IsSupportedByPragmaAttribute=*/0,
19112     /*Spellings=*/WebAssemblyFuncrefSpellings,
19113     /*ArgNames=*/{}) {}
19114 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19115   if (!isFunctionPointer(D)) {
19116     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19117       << Attr << Attr.isRegularKeywordAttribute() << "functions pointers";
19118     return false;
19119   }
19120   return true;
19121 }
19122 
19123 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19124   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19125     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19126   return false;
19127 }
19128 
19129 bool existsInTarget(const TargetInfo &Target) const override {
19130   const llvm::Triple &T = Target.getTriple(); (void)T;
19131   return true && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64);
19132 }
19133 
19134 bool isParamExpr(size_t N) const override {
19135   return false;
19136 }
19137 
19138 static const ParsedAttrInfoWebAssemblyFuncref Instance;
19139 };
19140 const ParsedAttrInfoWebAssemblyFuncref ParsedAttrInfoWebAssemblyFuncref::Instance;
19141 static constexpr ParsedAttrInfo::Spelling WebAssemblyImportModuleSpellings[] = {
19142   {AttributeCommonInfo::AS_GNU, "import_module"},
19143   {AttributeCommonInfo::AS_CXX11, "clang::import_module"},
19144   {AttributeCommonInfo::AS_C23, "clang::import_module"},
19145 };
19146 static constexpr const char *WebAssemblyImportModuleArgNames[] = {
19147 "ImportModule",};
19148 struct ParsedAttrInfoWebAssemblyImportModule final : public ParsedAttrInfo {
19149   constexpr ParsedAttrInfoWebAssemblyImportModule() : ParsedAttrInfo(
19150     /*AttrKind=*/ParsedAttr::AT_WebAssemblyImportModule,
19151     /*NumArgs=*/1,
19152     /*OptArgs=*/0,
19153     /*NumArgMembers=*/1,
19154     /*HasCustomParsing=*/0,
19155     /*AcceptsExprPack=*/0,
19156     /*IsTargetSpecific=*/1,
19157     /*IsType=*/0,
19158     /*IsStmt=*/0,
19159     /*IsKnownToGCC=*/0,
19160     /*IsSupportedByPragmaAttribute=*/1,
19161     /*Spellings=*/WebAssemblyImportModuleSpellings,
19162     /*ArgNames=*/WebAssemblyImportModuleArgNames) {}
19163 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19164   if (!isa<FunctionDecl>(D)) {
19165     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19166       << Attr << Attr.isRegularKeywordAttribute() << "functions";
19167     return false;
19168   }
19169   return true;
19170 }
19171 
19172 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19173   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19174     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19175   return false;
19176 }
19177 
19178 bool existsInTarget(const TargetInfo &Target) const override {
19179   const llvm::Triple &T = Target.getTriple(); (void)T;
19180   return true && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64);
19181 }
19182 
19183 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19184   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19185 }
19186 
19187 bool isParamExpr(size_t N) const override {
19188   return false;
19189 }
19190 
19191 static const ParsedAttrInfoWebAssemblyImportModule Instance;
19192 };
19193 const ParsedAttrInfoWebAssemblyImportModule ParsedAttrInfoWebAssemblyImportModule::Instance;
19194 static constexpr ParsedAttrInfo::Spelling WebAssemblyImportNameSpellings[] = {
19195   {AttributeCommonInfo::AS_GNU, "import_name"},
19196   {AttributeCommonInfo::AS_CXX11, "clang::import_name"},
19197   {AttributeCommonInfo::AS_C23, "clang::import_name"},
19198 };
19199 static constexpr const char *WebAssemblyImportNameArgNames[] = {
19200 "ImportName",};
19201 struct ParsedAttrInfoWebAssemblyImportName final : public ParsedAttrInfo {
19202   constexpr ParsedAttrInfoWebAssemblyImportName() : ParsedAttrInfo(
19203     /*AttrKind=*/ParsedAttr::AT_WebAssemblyImportName,
19204     /*NumArgs=*/1,
19205     /*OptArgs=*/0,
19206     /*NumArgMembers=*/1,
19207     /*HasCustomParsing=*/0,
19208     /*AcceptsExprPack=*/0,
19209     /*IsTargetSpecific=*/1,
19210     /*IsType=*/0,
19211     /*IsStmt=*/0,
19212     /*IsKnownToGCC=*/0,
19213     /*IsSupportedByPragmaAttribute=*/1,
19214     /*Spellings=*/WebAssemblyImportNameSpellings,
19215     /*ArgNames=*/WebAssemblyImportNameArgNames) {}
19216 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19217   if (!isa<FunctionDecl>(D)) {
19218     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19219       << Attr << Attr.isRegularKeywordAttribute() << "functions";
19220     return false;
19221   }
19222   return true;
19223 }
19224 
19225 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19226   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19227     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19228   return false;
19229 }
19230 
19231 bool existsInTarget(const TargetInfo &Target) const override {
19232   const llvm::Triple &T = Target.getTriple(); (void)T;
19233   return true && (T.getArch() == llvm::Triple::wasm32 || T.getArch() == llvm::Triple::wasm64);
19234 }
19235 
19236 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19237   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19238 }
19239 
19240 bool isParamExpr(size_t N) const override {
19241   return false;
19242 }
19243 
19244 static const ParsedAttrInfoWebAssemblyImportName Instance;
19245 };
19246 const ParsedAttrInfoWebAssemblyImportName ParsedAttrInfoWebAssemblyImportName::Instance;
19247 static constexpr ParsedAttrInfo::Spelling WorkGroupSizeHintSpellings[] = {
19248   {AttributeCommonInfo::AS_GNU, "work_group_size_hint"},
19249 };
19250 static constexpr const char *WorkGroupSizeHintArgNames[] = {
19251 "XDim","YDim","ZDim",};
19252 struct ParsedAttrInfoWorkGroupSizeHint final : public ParsedAttrInfo {
19253   constexpr ParsedAttrInfoWorkGroupSizeHint() : ParsedAttrInfo(
19254     /*AttrKind=*/ParsedAttr::AT_WorkGroupSizeHint,
19255     /*NumArgs=*/3,
19256     /*OptArgs=*/0,
19257     /*NumArgMembers=*/3,
19258     /*HasCustomParsing=*/0,
19259     /*AcceptsExprPack=*/0,
19260     /*IsTargetSpecific=*/0,
19261     /*IsType=*/0,
19262     /*IsStmt=*/0,
19263     /*IsKnownToGCC=*/0,
19264     /*IsSupportedByPragmaAttribute=*/1,
19265     /*Spellings=*/WorkGroupSizeHintSpellings,
19266     /*ArgNames=*/WorkGroupSizeHintArgNames) {}
19267 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19268   if (!isa<FunctionDecl>(D)) {
19269     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19270       << Attr << Attr.isRegularKeywordAttribute() << "functions";
19271     return false;
19272   }
19273   return true;
19274 }
19275 
19276 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19277   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19278     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19279   return false;
19280 }
19281 
19282 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19283   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19284 }
19285 
19286 bool isParamExpr(size_t N) const override {
19287   return false;
19288 }
19289 
19290 static const ParsedAttrInfoWorkGroupSizeHint Instance;
19291 };
19292 const ParsedAttrInfoWorkGroupSizeHint ParsedAttrInfoWorkGroupSizeHint::Instance;
19293 static constexpr ParsedAttrInfo::Spelling X86ForceAlignArgPointerSpellings[] = {
19294   {AttributeCommonInfo::AS_GNU, "force_align_arg_pointer"},
19295   {AttributeCommonInfo::AS_CXX11, "gnu::force_align_arg_pointer"},
19296   {AttributeCommonInfo::AS_C23, "gnu::force_align_arg_pointer"},
19297 };
19298 struct ParsedAttrInfoX86ForceAlignArgPointer final : public ParsedAttrInfo {
19299   constexpr ParsedAttrInfoX86ForceAlignArgPointer() : ParsedAttrInfo(
19300     /*AttrKind=*/ParsedAttr::AT_X86ForceAlignArgPointer,
19301     /*NumArgs=*/0,
19302     /*OptArgs=*/0,
19303     /*NumArgMembers=*/0,
19304     /*HasCustomParsing=*/0,
19305     /*AcceptsExprPack=*/0,
19306     /*IsTargetSpecific=*/1,
19307     /*IsType=*/0,
19308     /*IsStmt=*/0,
19309     /*IsKnownToGCC=*/1,
19310     /*IsSupportedByPragmaAttribute=*/0,
19311     /*Spellings=*/X86ForceAlignArgPointerSpellings,
19312     /*ArgNames=*/{}) {}
19313 bool existsInTarget(const TargetInfo &Target) const override {
19314   const llvm::Triple &T = Target.getTriple(); (void)T;
19315   return true && (T.getArch() == llvm::Triple::x86 || T.getArch() == llvm::Triple::x86_64);
19316 }
19317 
19318 bool isParamExpr(size_t N) const override {
19319   return false;
19320 }
19321 
19322 static const ParsedAttrInfoX86ForceAlignArgPointer Instance;
19323 };
19324 const ParsedAttrInfoX86ForceAlignArgPointer ParsedAttrInfoX86ForceAlignArgPointer::Instance;
19325 static constexpr ParsedAttrInfo::Spelling XRayInstrumentSpellings[] = {
19326   {AttributeCommonInfo::AS_GNU, "xray_always_instrument"},
19327   {AttributeCommonInfo::AS_CXX11, "clang::xray_always_instrument"},
19328   {AttributeCommonInfo::AS_C23, "clang::xray_always_instrument"},
19329   {AttributeCommonInfo::AS_GNU, "xray_never_instrument"},
19330   {AttributeCommonInfo::AS_CXX11, "clang::xray_never_instrument"},
19331   {AttributeCommonInfo::AS_C23, "clang::xray_never_instrument"},
19332 };
19333 struct ParsedAttrInfoXRayInstrument final : public ParsedAttrInfo {
19334   constexpr ParsedAttrInfoXRayInstrument() : ParsedAttrInfo(
19335     /*AttrKind=*/ParsedAttr::AT_XRayInstrument,
19336     /*NumArgs=*/0,
19337     /*OptArgs=*/0,
19338     /*NumArgMembers=*/0,
19339     /*HasCustomParsing=*/0,
19340     /*AcceptsExprPack=*/0,
19341     /*IsTargetSpecific=*/0,
19342     /*IsType=*/0,
19343     /*IsStmt=*/0,
19344     /*IsKnownToGCC=*/0,
19345     /*IsSupportedByPragmaAttribute=*/1,
19346     /*Spellings=*/XRayInstrumentSpellings,
19347     /*ArgNames=*/{}) {}
19348 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19349   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
19350     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
19351       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
19352     return false;
19353   }
19354   return true;
19355 }
19356 
19357 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19358   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19359     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19360   return false;
19361 }
19362 
19363 unsigned spellingIndexToSemanticSpelling(const ParsedAttr &Attr) const override {
19364   enum Spelling {
19365     GNU_xray_always_instrument = 0,
19366     CXX11_clang_xray_always_instrument = 1,
19367     C23_clang_xray_always_instrument = 2,
19368     GNU_xray_never_instrument = 3,
19369     CXX11_clang_xray_never_instrument = 4,
19370     C23_clang_xray_never_instrument = 5,
19371   SpellingNotCalculated = 15
19372 
19373   };
19374 
19375   unsigned Idx = Attr.getAttributeSpellingListIndex();
19376   switch (Idx) {
19377     default: llvm_unreachable("Unknown spelling list index");
19378     case 0: return GNU_xray_always_instrument;
19379     case 1: return CXX11_clang_xray_always_instrument;
19380     case 2: return C23_clang_xray_always_instrument;
19381     case 3: return GNU_xray_never_instrument;
19382     case 4: return CXX11_clang_xray_never_instrument;
19383     case 5: return C23_clang_xray_never_instrument;
19384   }
19385 }
19386 
19387 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19388   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19389   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
19390 }
19391 
19392 AttrHandling handleDeclAttribute(Sema &S, Decl *D,const ParsedAttr &Attr) const override {
19393   D->addAttr(::new (S.Context) XRayInstrumentAttr(S.Context, Attr));
19394   return AttributeApplied;
19395 }
19396 
19397 bool isParamExpr(size_t N) const override {
19398   return false;
19399 }
19400 
19401 static const ParsedAttrInfoXRayInstrument Instance;
19402 };
19403 const ParsedAttrInfoXRayInstrument ParsedAttrInfoXRayInstrument::Instance;
19404 static constexpr ParsedAttrInfo::Spelling XRayLogArgsSpellings[] = {
19405   {AttributeCommonInfo::AS_GNU, "xray_log_args"},
19406   {AttributeCommonInfo::AS_CXX11, "clang::xray_log_args"},
19407   {AttributeCommonInfo::AS_C23, "clang::xray_log_args"},
19408 };
19409 static constexpr const char *XRayLogArgsArgNames[] = {
19410 "ArgumentCount",};
19411 struct ParsedAttrInfoXRayLogArgs final : public ParsedAttrInfo {
19412   constexpr ParsedAttrInfoXRayLogArgs() : ParsedAttrInfo(
19413     /*AttrKind=*/ParsedAttr::AT_XRayLogArgs,
19414     /*NumArgs=*/1,
19415     /*OptArgs=*/0,
19416     /*NumArgMembers=*/1,
19417     /*HasCustomParsing=*/0,
19418     /*AcceptsExprPack=*/0,
19419     /*IsTargetSpecific=*/0,
19420     /*IsType=*/0,
19421     /*IsStmt=*/0,
19422     /*IsKnownToGCC=*/0,
19423     /*IsSupportedByPragmaAttribute=*/1,
19424     /*Spellings=*/XRayLogArgsSpellings,
19425     /*ArgNames=*/XRayLogArgsArgNames) {}
19426 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19427   if (!isa<FunctionDecl>(D) && !isa<ObjCMethodDecl>(D)) {
19428     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str)
19429       << Attr << Attr.isRegularKeywordAttribute() << "functions and Objective-C methods";
19430     return false;
19431   }
19432   return true;
19433 }
19434 
19435 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19436   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19437     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19438   return false;
19439 }
19440 
19441 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19442   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19443   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_objc_method, /*IsSupported=*/LangOpts.ObjC));
19444 }
19445 
19446 bool isParamExpr(size_t N) const override {
19447   return false;
19448 }
19449 
19450 static const ParsedAttrInfoXRayLogArgs Instance;
19451 };
19452 const ParsedAttrInfoXRayLogArgs ParsedAttrInfoXRayLogArgs::Instance;
19453 static constexpr ParsedAttrInfo::Spelling ZeroCallUsedRegsSpellings[] = {
19454   {AttributeCommonInfo::AS_GNU, "zero_call_used_regs"},
19455   {AttributeCommonInfo::AS_CXX11, "gnu::zero_call_used_regs"},
19456   {AttributeCommonInfo::AS_C23, "gnu::zero_call_used_regs"},
19457 };
19458 static constexpr const char *ZeroCallUsedRegsArgNames[] = {
19459 "ZeroCallUsedRegs",};
19460 struct ParsedAttrInfoZeroCallUsedRegs final : public ParsedAttrInfo {
19461   constexpr ParsedAttrInfoZeroCallUsedRegs() : ParsedAttrInfo(
19462     /*AttrKind=*/ParsedAttr::AT_ZeroCallUsedRegs,
19463     /*NumArgs=*/1,
19464     /*OptArgs=*/0,
19465     /*NumArgMembers=*/1,
19466     /*HasCustomParsing=*/0,
19467     /*AcceptsExprPack=*/0,
19468     /*IsTargetSpecific=*/0,
19469     /*IsType=*/0,
19470     /*IsStmt=*/0,
19471     /*IsKnownToGCC=*/1,
19472     /*IsSupportedByPragmaAttribute=*/1,
19473     /*Spellings=*/ZeroCallUsedRegsSpellings,
19474     /*ArgNames=*/ZeroCallUsedRegsArgNames) {}
19475 bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {
19476   if (!isa<FunctionDecl>(D)) {
19477     S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type_str)
19478       << Attr << Attr.isRegularKeywordAttribute() << "functions";
19479     return false;
19480   }
19481   return true;
19482 }
19483 
19484 bool diagAppertainsToStmt(Sema &S, const ParsedAttr &AL, const Stmt *St) const override {
19485   S.Diag(AL.getLoc(), diag::err_decl_attribute_invalid_on_stmt)
19486     << AL << AL.isRegularKeywordAttribute() << St->getBeginLoc();
19487   return false;
19488 }
19489 
19490 void getPragmaAttributeMatchRules(llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules, const LangOptions &LangOpts) const override {
19491   MatchRules.push_back(std::make_pair(attr::SubjectMatchRule_function, /*IsSupported=*/true));
19492 }
19493 
19494 bool isParamExpr(size_t N) const override {
19495   return false;
19496 }
19497 
19498 static const ParsedAttrInfoZeroCallUsedRegs Instance;
19499 };
19500 const ParsedAttrInfoZeroCallUsedRegs ParsedAttrInfoZeroCallUsedRegs::Instance;
19501 static const ParsedAttrInfo *AttrInfoMap[] = {
19502 &ParsedAttrInfoAArch64SVEPcs::Instance,
19503 &ParsedAttrInfoAArch64VectorPcs::Instance,
19504 &ParsedAttrInfoAMDGPUFlatWorkGroupSize::Instance,
19505 &ParsedAttrInfoAMDGPUKernelCall::Instance,
19506 &ParsedAttrInfoAMDGPUMaxNumWorkGroups::Instance,
19507 &ParsedAttrInfoAMDGPUNumSGPR::Instance,
19508 &ParsedAttrInfoAMDGPUNumVGPR::Instance,
19509 &ParsedAttrInfoAMDGPUWavesPerEU::Instance,
19510 &ParsedAttrInfoInterrupt::Instance,
19511 &ParsedAttrInfoAVRSignal::Instance,
19512 &ParsedAttrInfoAbiTag::Instance,
19513 &ParsedAttrInfoAcquireCapability::Instance,
19514 &ParsedAttrInfoAcquireHandle::Instance,
19515 &ParsedAttrInfoAcquiredAfter::Instance,
19516 &ParsedAttrInfoAcquiredBefore::Instance,
19517 &ParsedAttrInfoAddressSpace::Instance,
19518 &ParsedAttrInfoAlias::Instance,
19519 &ParsedAttrInfoAlignValue::Instance,
19520 &ParsedAttrInfoAligned::Instance,
19521 &ParsedAttrInfoAllocAlign::Instance,
19522 &ParsedAttrInfoAllocSize::Instance,
19523 &ParsedAttrInfoAllocating::Instance,
19524 &ParsedAttrInfoAlwaysDestroy::Instance,
19525 &ParsedAttrInfoAlwaysInline::Instance,
19526 &ParsedAttrInfoAnalyzerNoReturn::Instance,
19527 &ParsedAttrInfoAnnotate::Instance,
19528 &ParsedAttrInfoAnnotateType::Instance,
19529 &ParsedAttrInfoAnyX86NoCallerSavedRegisters::Instance,
19530 &ParsedAttrInfoAnyX86NoCfCheck::Instance,
19531 &ParsedAttrInfoArcWeakrefUnavailable::Instance,
19532 &ParsedAttrInfoArgumentWithTypeTag::Instance,
19533 &ParsedAttrInfoArmAgnostic::Instance,
19534 &ParsedAttrInfoArmBuiltinAlias::Instance,
19535 &ParsedAttrInfoArmIn::Instance,
19536 &ParsedAttrInfoArmInOut::Instance,
19537 &ParsedAttrInfoArmLocallyStreaming::Instance,
19538 &ParsedAttrInfoArmMveStrictPolymorphism::Instance,
19539 &ParsedAttrInfoArmNew::Instance,
19540 &ParsedAttrInfoArmOut::Instance,
19541 &ParsedAttrInfoArmPreserves::Instance,
19542 &ParsedAttrInfoArmStreaming::Instance,
19543 &ParsedAttrInfoArmStreamingCompatible::Instance,
19544 &ParsedAttrInfoArmSveVectorBits::Instance,
19545 &ParsedAttrInfoArtificial::Instance,
19546 &ParsedAttrInfoAssertCapability::Instance,
19547 &ParsedAttrInfoAssertExclusiveLock::Instance,
19548 &ParsedAttrInfoAssertSharedLock::Instance,
19549 &ParsedAttrInfoAssumeAligned::Instance,
19550 &ParsedAttrInfoAvailability::Instance,
19551 &ParsedAttrInfoAvailableOnlyInDefaultEvalMethod::Instance,
19552 &ParsedAttrInfoBPFFastCall::Instance,
19553 &ParsedAttrInfoBPFPreserveAccessIndex::Instance,
19554 &ParsedAttrInfoBPFPreserveStaticOffset::Instance,
19555 &ParsedAttrInfoBTFDeclTag::Instance,
19556 &ParsedAttrInfoBTFTypeTag::Instance,
19557 &ParsedAttrInfoBlocking::Instance,
19558 &ParsedAttrInfoBlocks::Instance,
19559 &ParsedAttrInfoBuiltinAlias::Instance,
19560 &ParsedAttrInfoCDecl::Instance,
19561 &ParsedAttrInfoCFAuditedTransfer::Instance,
19562 &ParsedAttrInfoCFConsumed::Instance,
19563 &ParsedAttrInfoCFGuard::Instance,
19564 &ParsedAttrInfoCFICanonicalJumpTable::Instance,
19565 &ParsedAttrInfoCFReturnsNotRetained::Instance,
19566 &ParsedAttrInfoCFReturnsRetained::Instance,
19567 &ParsedAttrInfoCFUnknownTransfer::Instance,
19568 &ParsedAttrInfoCPUDispatch::Instance,
19569 &ParsedAttrInfoCPUSpecific::Instance,
19570 &ParsedAttrInfoCUDAConstant::Instance,
19571 &ParsedAttrInfoCUDADevice::Instance,
19572 &ParsedAttrInfoCUDADeviceBuiltinSurfaceType::Instance,
19573 &ParsedAttrInfoCUDADeviceBuiltinTextureType::Instance,
19574 &ParsedAttrInfoCUDAGlobal::Instance,
19575 &ParsedAttrInfoCUDAGridConstant::Instance,
19576 &ParsedAttrInfoCUDAHost::Instance,
19577 &ParsedAttrInfoCUDAInvalidTarget::Instance,
19578 &ParsedAttrInfoCUDALaunchBounds::Instance,
19579 &ParsedAttrInfoCUDAShared::Instance,
19580 &ParsedAttrInfoCXX11NoReturn::Instance,
19581 &ParsedAttrInfoCXXAssume::Instance,
19582 &ParsedAttrInfoCallableWhen::Instance,
19583 &ParsedAttrInfoCallback::Instance,
19584 &ParsedAttrInfoCalledOnce::Instance,
19585 &ParsedAttrInfoCapability::Instance,
19586 &ParsedAttrInfoCarriesDependency::Instance,
19587 &ParsedAttrInfoCleanup::Instance,
19588 &ParsedAttrInfoClspvLibclcBuiltin::Instance,
19589 &ParsedAttrInfoCmseNSCall::Instance,
19590 &ParsedAttrInfoCmseNSEntry::Instance,
19591 &ParsedAttrInfoCodeAlign::Instance,
19592 &ParsedAttrInfoCodeModel::Instance,
19593 &ParsedAttrInfoCodeSeg::Instance,
19594 &ParsedAttrInfoCold::Instance,
19595 &ParsedAttrInfoCommon::Instance,
19596 &ParsedAttrInfoConst::Instance,
19597 &ParsedAttrInfoConstInit::Instance,
19598 &ParsedAttrInfoConstructor::Instance,
19599 &ParsedAttrInfoConsumable::Instance,
19600 &ParsedAttrInfoConsumableAutoCast::Instance,
19601 &ParsedAttrInfoConsumableSetOnRead::Instance,
19602 &ParsedAttrInfoConvergent::Instance,
19603 &ParsedAttrInfoCoroAwaitElidable::Instance,
19604 &ParsedAttrInfoCoroAwaitElidableArgument::Instance,
19605 &ParsedAttrInfoCoroDisableLifetimeBound::Instance,
19606 &ParsedAttrInfoCoroLifetimeBound::Instance,
19607 &ParsedAttrInfoCoroOnlyDestroyWhenComplete::Instance,
19608 &ParsedAttrInfoCoroReturnType::Instance,
19609 &ParsedAttrInfoCoroWrapper::Instance,
19610 &ParsedAttrInfoCountedBy::Instance,
19611 &ParsedAttrInfoCountedByOrNull::Instance,
19612 &ParsedAttrInfoDLLExport::Instance,
19613 &ParsedAttrInfoDLLExportStaticLocal::Instance,
19614 &ParsedAttrInfoDLLImport::Instance,
19615 &ParsedAttrInfoDLLImportStaticLocal::Instance,
19616 &ParsedAttrInfoDeprecated::Instance,
19617 &ParsedAttrInfoDestructor::Instance,
19618 &ParsedAttrInfoDiagnoseAsBuiltin::Instance,
19619 &ParsedAttrInfoDiagnoseIf::Instance,
19620 &ParsedAttrInfoDisableSanitizerInstrumentation::Instance,
19621 &ParsedAttrInfoDisableTailCalls::Instance,
19622 &ParsedAttrInfoEmptyBases::Instance,
19623 &ParsedAttrInfoEnableIf::Instance,
19624 &ParsedAttrInfoEnforceTCB::Instance,
19625 &ParsedAttrInfoEnforceTCBLeaf::Instance,
19626 &ParsedAttrInfoEnumExtensibility::Instance,
19627 &ParsedAttrInfoError::Instance,
19628 &ParsedAttrInfoExcludeFromExplicitInstantiation::Instance,
19629 &ParsedAttrInfoExclusiveTrylockFunction::Instance,
19630 &ParsedAttrInfoExplicitInit::Instance,
19631 &ParsedAttrInfoExtVectorType::Instance,
19632 &ParsedAttrInfoExternalSourceSymbol::Instance,
19633 &ParsedAttrInfoFallThrough::Instance,
19634 &ParsedAttrInfoFastCall::Instance,
19635 &ParsedAttrInfoFlagEnum::Instance,
19636 &ParsedAttrInfoFlatten::Instance,
19637 &ParsedAttrInfoFormat::Instance,
19638 &ParsedAttrInfoFormatArg::Instance,
19639 &ParsedAttrInfoFunctionReturnThunks::Instance,
19640 &ParsedAttrInfoGNUInline::Instance,
19641 &ParsedAttrInfoGuardedBy::Instance,
19642 &ParsedAttrInfoGuardedVar::Instance,
19643 &ParsedAttrInfoHIPManaged::Instance,
19644 &ParsedAttrInfoHLSLContainedType::Instance,
19645 &ParsedAttrInfoHLSLControlFlowHint::Instance,
19646 &ParsedAttrInfoHLSLGroupSharedAddressSpace::Instance,
19647 &ParsedAttrInfoHLSLLoopHint::Instance,
19648 &ParsedAttrInfoHLSLNumThreads::Instance,
19649 &ParsedAttrInfoHLSLPackOffset::Instance,
19650 &ParsedAttrInfoHLSLParamModifier::Instance,
19651 &ParsedAttrInfoHLSLROV::Instance,
19652 &ParsedAttrInfoHLSLRawBuffer::Instance,
19653 &ParsedAttrInfoHLSLResource::Instance,
19654 &ParsedAttrInfoHLSLResourceBinding::Instance,
19655 &ParsedAttrInfoHLSLResourceClass::Instance,
19656 &ParsedAttrInfoHLSLSV_DispatchThreadID::Instance,
19657 &ParsedAttrInfoHLSLSV_GroupID::Instance,
19658 &ParsedAttrInfoHLSLSV_GroupIndex::Instance,
19659 &ParsedAttrInfoHLSLSV_GroupThreadID::Instance,
19660 &ParsedAttrInfoHLSLShader::Instance,
19661 &ParsedAttrInfoHLSLWaveSize::Instance,
19662 &ParsedAttrInfoHot::Instance,
19663 &ParsedAttrInfoHybridPatchable::Instance,
19664 &ParsedAttrInfoIBAction::Instance,
19665 &ParsedAttrInfoIBOutlet::Instance,
19666 &ParsedAttrInfoIBOutletCollection::Instance,
19667 &ParsedAttrInfoIFunc::Instance,
19668 &ParsedAttrInfoInitPriority::Instance,
19669 &ParsedAttrInfoIntelOclBicc::Instance,
19670 &ParsedAttrInfoInternalLinkage::Instance,
19671 &ParsedAttrInfoLTOVisibilityPublic::Instance,
19672 &ParsedAttrInfoLayoutVersion::Instance,
19673 &ParsedAttrInfoLeaf::Instance,
19674 &ParsedAttrInfoLifetimeBound::Instance,
19675 &ParsedAttrInfoLifetimeCaptureBy::Instance,
19676 &ParsedAttrInfoLikely::Instance,
19677 &ParsedAttrInfoLoaderUninitialized::Instance,
19678 &ParsedAttrInfoLockReturned::Instance,
19679 &ParsedAttrInfoLockable::Instance,
19680 &ParsedAttrInfoLocksExcluded::Instance,
19681 &ParsedAttrInfoLoopHint::Instance,
19682 &ParsedAttrInfoM68kRTD::Instance,
19683 &ParsedAttrInfoMIGServerRoutine::Instance,
19684 &ParsedAttrInfoMSABI::Instance,
19685 &ParsedAttrInfoMSAllocator::Instance,
19686 &ParsedAttrInfoMSConstexpr::Instance,
19687 &ParsedAttrInfoMSInheritance::Instance,
19688 &ParsedAttrInfoMSNoVTable::Instance,
19689 &ParsedAttrInfoMSStruct::Instance,
19690 &ParsedAttrInfoMatrixType::Instance,
19691 &ParsedAttrInfoMayAlias::Instance,
19692 &ParsedAttrInfoMaybeUndef::Instance,
19693 &ParsedAttrInfoMicroMips::Instance,
19694 &ParsedAttrInfoMinSize::Instance,
19695 &ParsedAttrInfoMinVectorWidth::Instance,
19696 &ParsedAttrInfoMips16::Instance,
19697 &ParsedAttrInfoMipsLongCall::Instance,
19698 &ParsedAttrInfoMipsShortCall::Instance,
19699 &ParsedAttrInfoMode::Instance,
19700 &ParsedAttrInfoMustTail::Instance,
19701 &ParsedAttrInfoNSConsumed::Instance,
19702 &ParsedAttrInfoNSConsumesSelf::Instance,
19703 &ParsedAttrInfoNSErrorDomain::Instance,
19704 &ParsedAttrInfoNSReturnsAutoreleased::Instance,
19705 &ParsedAttrInfoNSReturnsNotRetained::Instance,
19706 &ParsedAttrInfoNSReturnsRetained::Instance,
19707 &ParsedAttrInfoNVPTXKernel::Instance,
19708 &ParsedAttrInfoNaked::Instance,
19709 &ParsedAttrInfoNeonPolyVectorType::Instance,
19710 &ParsedAttrInfoNeonVectorType::Instance,
19711 &ParsedAttrInfoNoAlias::Instance,
19712 &ParsedAttrInfoNoBuiltin::Instance,
19713 &ParsedAttrInfoNoCommon::Instance,
19714 &ParsedAttrInfoNoConvergent::Instance,
19715 &ParsedAttrInfoNoDebug::Instance,
19716 &ParsedAttrInfoNoDeref::Instance,
19717 &ParsedAttrInfoNoDestroy::Instance,
19718 &ParsedAttrInfoNoDuplicate::Instance,
19719 &ParsedAttrInfoNoEscape::Instance,
19720 &ParsedAttrInfoNoInline::Instance,
19721 &ParsedAttrInfoNoInstrumentFunction::Instance,
19722 &ParsedAttrInfoNoMerge::Instance,
19723 &ParsedAttrInfoNoMicroMips::Instance,
19724 &ParsedAttrInfoNoMips16::Instance,
19725 &ParsedAttrInfoNoProfileFunction::Instance,
19726 &ParsedAttrInfoNoRandomizeLayout::Instance,
19727 &ParsedAttrInfoNoReturn::Instance,
19728 &ParsedAttrInfoNoSanitize::Instance,
19729 &ParsedAttrInfoNoSanitizeSpecific::Instance,
19730 &ParsedAttrInfoNoSpecializations::Instance,
19731 &ParsedAttrInfoNoSpeculativeLoadHardening::Instance,
19732 &ParsedAttrInfoNoSplitStack::Instance,
19733 &ParsedAttrInfoNoStackProtector::Instance,
19734 &ParsedAttrInfoNoThreadSafetyAnalysis::Instance,
19735 &ParsedAttrInfoNoThrow::Instance,
19736 &ParsedAttrInfoNoTrivialAutoVarInit::Instance,
19737 &ParsedAttrInfoNoUniqueAddress::Instance,
19738 &ParsedAttrInfoNoUwtable::Instance,
19739 &ParsedAttrInfoNonAllocating::Instance,
19740 &ParsedAttrInfoNonBlocking::Instance,
19741 &ParsedAttrInfoNonNull::Instance,
19742 &ParsedAttrInfoNotTailCalled::Instance,
19743 &ParsedAttrInfoOMPAssume::Instance,
19744 &ParsedAttrInfoOSConsumed::Instance,
19745 &ParsedAttrInfoOSConsumesThis::Instance,
19746 &ParsedAttrInfoOSReturnsNotRetained::Instance,
19747 &ParsedAttrInfoOSReturnsRetained::Instance,
19748 &ParsedAttrInfoOSReturnsRetainedOnNonZero::Instance,
19749 &ParsedAttrInfoOSReturnsRetainedOnZero::Instance,
19750 &ParsedAttrInfoObjCBoxable::Instance,
19751 &ParsedAttrInfoObjCBridge::Instance,
19752 &ParsedAttrInfoObjCBridgeMutable::Instance,
19753 &ParsedAttrInfoObjCBridgeRelated::Instance,
19754 &ParsedAttrInfoObjCClassStub::Instance,
19755 &ParsedAttrInfoObjCDesignatedInitializer::Instance,
19756 &ParsedAttrInfoObjCDirect::Instance,
19757 &ParsedAttrInfoObjCDirectMembers::Instance,
19758 &ParsedAttrInfoObjCException::Instance,
19759 &ParsedAttrInfoObjCExplicitProtocolImpl::Instance,
19760 &ParsedAttrInfoObjCExternallyRetained::Instance,
19761 &ParsedAttrInfoObjCGC::Instance,
19762 &ParsedAttrInfoObjCIndependentClass::Instance,
19763 &ParsedAttrInfoObjCInertUnsafeUnretained::Instance,
19764 &ParsedAttrInfoObjCKindOf::Instance,
19765 &ParsedAttrInfoObjCMethodFamily::Instance,
19766 &ParsedAttrInfoObjCNSObject::Instance,
19767 &ParsedAttrInfoObjCNonLazyClass::Instance,
19768 &ParsedAttrInfoObjCNonRuntimeProtocol::Instance,
19769 &ParsedAttrInfoObjCOwnership::Instance,
19770 &ParsedAttrInfoObjCPreciseLifetime::Instance,
19771 &ParsedAttrInfoObjCRequiresPropertyDefs::Instance,
19772 &ParsedAttrInfoObjCRequiresSuper::Instance,
19773 &ParsedAttrInfoObjCReturnsInnerPointer::Instance,
19774 &ParsedAttrInfoObjCRootClass::Instance,
19775 &ParsedAttrInfoObjCRuntimeName::Instance,
19776 &ParsedAttrInfoObjCRuntimeVisible::Instance,
19777 &ParsedAttrInfoObjCSubclassingRestricted::Instance,
19778 &ParsedAttrInfoOpenCLAccess::Instance,
19779 &ParsedAttrInfoOpenCLConstantAddressSpace::Instance,
19780 &ParsedAttrInfoOpenCLGenericAddressSpace::Instance,
19781 &ParsedAttrInfoOpenCLGlobalAddressSpace::Instance,
19782 &ParsedAttrInfoOpenCLGlobalDeviceAddressSpace::Instance,
19783 &ParsedAttrInfoOpenCLGlobalHostAddressSpace::Instance,
19784 &ParsedAttrInfoOpenCLIntelReqdSubGroupSize::Instance,
19785 &ParsedAttrInfoOpenCLKernel::Instance,
19786 &ParsedAttrInfoOpenCLLocalAddressSpace::Instance,
19787 &ParsedAttrInfoOpenCLNoSVM::Instance,
19788 &ParsedAttrInfoOpenCLPrivateAddressSpace::Instance,
19789 &ParsedAttrInfoOpenCLUnrollHint::Instance,
19790 &ParsedAttrInfoOptimizeNone::Instance,
19791 &ParsedAttrInfoOverloadable::Instance,
19792 &ParsedAttrInfoOwner::Instance,
19793 &ParsedAttrInfoOwnership::Instance,
19794 &ParsedAttrInfoPacked::Instance,
19795 &ParsedAttrInfoParamTypestate::Instance,
19796 &ParsedAttrInfoPascal::Instance,
19797 &ParsedAttrInfoPassObjectSize::Instance,
19798 &ParsedAttrInfoPatchableFunctionEntry::Instance,
19799 &ParsedAttrInfoPcs::Instance,
19800 &ParsedAttrInfoPointer::Instance,
19801 &ParsedAttrInfoPragmaClangBSSSection::Instance,
19802 &ParsedAttrInfoPragmaClangDataSection::Instance,
19803 &ParsedAttrInfoPragmaClangRelroSection::Instance,
19804 &ParsedAttrInfoPragmaClangRodataSection::Instance,
19805 &ParsedAttrInfoPragmaClangTextSection::Instance,
19806 &ParsedAttrInfoPreferredName::Instance,
19807 &ParsedAttrInfoPreferredType::Instance,
19808 &ParsedAttrInfoPreserveAll::Instance,
19809 &ParsedAttrInfoPreserveMost::Instance,
19810 &ParsedAttrInfoPreserveNone::Instance,
19811 &ParsedAttrInfoPtGuardedBy::Instance,
19812 &ParsedAttrInfoPtGuardedVar::Instance,
19813 &ParsedAttrInfoPtr32::Instance,
19814 &ParsedAttrInfoPtr64::Instance,
19815 &ParsedAttrInfoPure::Instance,
19816 &ParsedAttrInfoRISCVRVVVectorBits::Instance,
19817 &ParsedAttrInfoRISCVVectorCC::Instance,
19818 &ParsedAttrInfoRandomizeLayout::Instance,
19819 &ParsedAttrInfoReadOnlyPlacement::Instance,
19820 &ParsedAttrInfoRegCall::Instance,
19821 &ParsedAttrInfoRegparm::Instance,
19822 &ParsedAttrInfoReinitializes::Instance,
19823 &ParsedAttrInfoReleaseCapability::Instance,
19824 &ParsedAttrInfoReleaseHandle::Instance,
19825 &ParsedAttrInfoReqdWorkGroupSize::Instance,
19826 &ParsedAttrInfoRequiresCapability::Instance,
19827 &ParsedAttrInfoRestrict::Instance,
19828 &ParsedAttrInfoRetain::Instance,
19829 &ParsedAttrInfoReturnTypestate::Instance,
19830 &ParsedAttrInfoReturnsNonNull::Instance,
19831 &ParsedAttrInfoReturnsTwice::Instance,
19832 &ParsedAttrInfoSPtr::Instance,
19833 &ParsedAttrInfoSYCLKernel::Instance,
19834 &ParsedAttrInfoSYCLKernelEntryPoint::Instance,
19835 &ParsedAttrInfoSYCLSpecialClass::Instance,
19836 &ParsedAttrInfoScopedLockable::Instance,
19837 &ParsedAttrInfoSection::Instance,
19838 &ParsedAttrInfoSelectAny::Instance,
19839 &ParsedAttrInfoSentinel::Instance,
19840 &ParsedAttrInfoSetTypestate::Instance,
19841 &ParsedAttrInfoSharedTrylockFunction::Instance,
19842 &ParsedAttrInfoSizedBy::Instance,
19843 &ParsedAttrInfoSizedByOrNull::Instance,
19844 &ParsedAttrInfoSpeculativeLoadHardening::Instance,
19845 &ParsedAttrInfoStandaloneDebug::Instance,
19846 &ParsedAttrInfoStdCall::Instance,
19847 &ParsedAttrInfoStrictFP::Instance,
19848 &ParsedAttrInfoStrictGuardStackCheck::Instance,
19849 &ParsedAttrInfoSuppress::Instance,
19850 &ParsedAttrInfoSwiftAsync::Instance,
19851 &ParsedAttrInfoSwiftAsyncCall::Instance,
19852 &ParsedAttrInfoSwiftAsyncContext::Instance,
19853 &ParsedAttrInfoSwiftAsyncError::Instance,
19854 &ParsedAttrInfoSwiftAsyncName::Instance,
19855 &ParsedAttrInfoSwiftAttr::Instance,
19856 &ParsedAttrInfoSwiftBridge::Instance,
19857 &ParsedAttrInfoSwiftBridgedTypedef::Instance,
19858 &ParsedAttrInfoSwiftCall::Instance,
19859 &ParsedAttrInfoSwiftContext::Instance,
19860 &ParsedAttrInfoSwiftError::Instance,
19861 &ParsedAttrInfoSwiftErrorResult::Instance,
19862 &ParsedAttrInfoSwiftIndirectResult::Instance,
19863 &ParsedAttrInfoSwiftName::Instance,
19864 &ParsedAttrInfoSwiftNewType::Instance,
19865 &ParsedAttrInfoSwiftObjCMembers::Instance,
19866 &ParsedAttrInfoSwiftPrivate::Instance,
19867 &ParsedAttrInfoSysVABI::Instance,
19868 &ParsedAttrInfoTLSModel::Instance,
19869 &ParsedAttrInfoTarget::Instance,
19870 &ParsedAttrInfoTargetClones::Instance,
19871 &ParsedAttrInfoTargetVersion::Instance,
19872 &ParsedAttrInfoTestTypestate::Instance,
19873 &ParsedAttrInfoThisCall::Instance,
19874 &ParsedAttrInfoThread::Instance,
19875 &ParsedAttrInfoTransparentUnion::Instance,
19876 &ParsedAttrInfoTrivialABI::Instance,
19877 &ParsedAttrInfoTryAcquireCapability::Instance,
19878 &ParsedAttrInfoTypeNonNull::Instance,
19879 &ParsedAttrInfoTypeNullUnspecified::Instance,
19880 &ParsedAttrInfoTypeNullable::Instance,
19881 &ParsedAttrInfoTypeNullableResult::Instance,
19882 &ParsedAttrInfoTypeTagForDatatype::Instance,
19883 &ParsedAttrInfoTypeVisibility::Instance,
19884 &ParsedAttrInfoUPtr::Instance,
19885 &ParsedAttrInfoUnavailable::Instance,
19886 &ParsedAttrInfoUninitialized::Instance,
19887 &ParsedAttrInfoUnlikely::Instance,
19888 &ParsedAttrInfoUnsafeBufferUsage::Instance,
19889 &ParsedAttrInfoUnused::Instance,
19890 &ParsedAttrInfoUseHandle::Instance,
19891 &ParsedAttrInfoUsed::Instance,
19892 &ParsedAttrInfoUsingIfExists::Instance,
19893 &ParsedAttrInfoUuid::Instance,
19894 &ParsedAttrInfoVTablePointerAuthentication::Instance,
19895 &ParsedAttrInfoVecReturn::Instance,
19896 &ParsedAttrInfoVecTypeHint::Instance,
19897 &ParsedAttrInfoVectorCall::Instance,
19898 &ParsedAttrInfoVectorSize::Instance,
19899 &ParsedAttrInfoVisibility::Instance,
19900 &ParsedAttrInfoWarnUnused::Instance,
19901 &ParsedAttrInfoWarnUnusedResult::Instance,
19902 &ParsedAttrInfoWeak::Instance,
19903 &ParsedAttrInfoWeakImport::Instance,
19904 &ParsedAttrInfoWeakRef::Instance,
19905 &ParsedAttrInfoWebAssemblyExportName::Instance,
19906 &ParsedAttrInfoWebAssemblyFuncref::Instance,
19907 &ParsedAttrInfoWebAssemblyImportModule::Instance,
19908 &ParsedAttrInfoWebAssemblyImportName::Instance,
19909 &ParsedAttrInfoWorkGroupSizeHint::Instance,
19910 &ParsedAttrInfoX86ForceAlignArgPointer::Instance,
19911 &ParsedAttrInfoXRayInstrument::Instance,
19912 &ParsedAttrInfoXRayLogArgs::Instance,
19913 &ParsedAttrInfoZeroCallUsedRegs::Instance,
19914 };
19915 
19916 static void handleAttrWithDelayedArgs(Sema &S, Decl *D, const ParsedAttr &Attr) {
19917   SmallVector<Expr *, 4> ArgExprs;
19918   ArgExprs.reserve(Attr.getNumArgs());
19919   for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
19920     assert(!Attr.isArgIdent(I));
19921     ArgExprs.push_back(Attr.getArgAsExpr(I));
19922   }
19923   clang::Attr *CreatedAttr = nullptr;
19924   switch (Attr.getKind()) {
19925   default:
19926     llvm_unreachable("Attribute cannot hold delayed arguments.");
19927   case ParsedAttr::AT_Annotate: {
19928     CreatedAttr = AnnotateAttr::CreateWithDelayedArgs(S.Context, ArgExprs.data(), ArgExprs.size(), Attr);
19929     break;
19930   }
19931   case ParsedAttr::AT_AnnotateType: {
19932     CreatedAttr = AnnotateTypeAttr::CreateWithDelayedArgs(S.Context, ArgExprs.data(), ArgExprs.size(), Attr);
19933     break;
19934   }
19935   }
19936   D->addAttr(CreatedAttr);
19937 }
19938 
19939 static bool checkAttributeMatchRuleAppliesTo(const Decl *D, attr::SubjectMatchRule rule) {
19940   switch (rule) {
19941   case attr::SubjectMatchRule_block:
19942     return isa<BlockDecl>(D);
19943   case attr::SubjectMatchRule_enum:
19944     return isa<EnumDecl>(D);
19945   case attr::SubjectMatchRule_enum_constant:
19946     return isa<EnumConstantDecl>(D);
19947   case attr::SubjectMatchRule_field:
19948     return isa<FieldDecl>(D);
19949   case attr::SubjectMatchRule_function:
19950     return isa<FunctionDecl>(D);
19951   case attr::SubjectMatchRule_function_is_member:
19952     return isa<CXXMethodDecl>(D);
19953   case attr::SubjectMatchRule_namespace:
19954     return isa<NamespaceDecl>(D);
19955   case attr::SubjectMatchRule_objc_category:
19956     return isa<ObjCCategoryDecl>(D);
19957   case attr::SubjectMatchRule_objc_implementation:
19958     return isa<ObjCImplDecl>(D);
19959   case attr::SubjectMatchRule_objc_interface:
19960     return isa<ObjCInterfaceDecl>(D);
19961   case attr::SubjectMatchRule_objc_method:
19962     return isa<ObjCMethodDecl>(D);
19963   case attr::SubjectMatchRule_objc_method_is_instance:
19964     return isObjCInstanceMethod(D);
19965   case attr::SubjectMatchRule_objc_property:
19966     return isa<ObjCPropertyDecl>(D);
19967   case attr::SubjectMatchRule_objc_protocol:
19968     return isa<ObjCProtocolDecl>(D);
19969   case attr::SubjectMatchRule_record:
19970     return isa<RecordDecl>(D) || isa<CXXRecordDecl>(D);
19971   case attr::SubjectMatchRule_record_not_is_union:
19972     return isStruct(D);
19973   case attr::SubjectMatchRule_hasType_abstract:
19974     assert(false && "Abstract matcher rule isn't allowed");
19975     return false;
19976   case attr::SubjectMatchRule_hasType_functionType:
19977     return isFunctionLike(D);
19978   case attr::SubjectMatchRule_type_alias:
19979     return isa<TypedefNameDecl>(D);
19980   case attr::SubjectMatchRule_variable:
19981     return isa<VarDecl>(D);
19982   case attr::SubjectMatchRule_variable_is_thread_local:
19983     return isTLSVar(D);
19984   case attr::SubjectMatchRule_variable_is_global:
19985     return isGlobalVar(D);
19986   case attr::SubjectMatchRule_variable_is_local:
19987     return isLocalVar(D);
19988   case attr::SubjectMatchRule_variable_is_parameter:
19989     return isa<ParmVarDecl>(D);
19990   case attr::SubjectMatchRule_variable_not_is_parameter:
19991     return isNonParmVar(D);
19992   }
19993   llvm_unreachable("Invalid match rule");
19994 return false;
19995 }
19996 
19997 #elif defined(WANT_DECL_MERGE_LOGIC)
19998 
19999 static bool DiagnoseMutualExclusions(Sema &S, const NamedDecl *D, const Attr *A) {
20000   if (const auto *Second = dyn_cast<AlwaysDestroyAttr>(A)) {
20001     if (const auto *First = D->getAttr<NoDestroyAttr>()) {
20002       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20003       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20004       return false;
20005     }
20006     return true;
20007   }
20008   if (const auto *Second = dyn_cast<AlwaysInlineAttr>(A)) {
20009     if (const auto *First = D->getAttr<NotTailCalledAttr>()) {
20010       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20011       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20012       return false;
20013     }
20014     return true;
20015   }
20016   if (const auto *Second = dyn_cast<CFAuditedTransferAttr>(A)) {
20017     if (const auto *First = D->getAttr<CFUnknownTransferAttr>()) {
20018       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20019       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20020       return false;
20021     }
20022     return true;
20023   }
20024   if (const auto *Second = dyn_cast<CFUnknownTransferAttr>(A)) {
20025     if (const auto *First = D->getAttr<CFAuditedTransferAttr>()) {
20026       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20027       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20028       return false;
20029     }
20030     return true;
20031   }
20032   if (const auto *Second = dyn_cast<CPUDispatchAttr>(A)) {
20033     if (const auto *First = D->getAttr<TargetClonesAttr>()) {
20034       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20035       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20036       return false;
20037     }
20038     if (const auto *First = D->getAttr<TargetVersionAttr>()) {
20039       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20040       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20041       return false;
20042     }
20043     if (const auto *First = D->getAttr<TargetAttr>()) {
20044       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20045       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20046       return false;
20047     }
20048     if (const auto *First = D->getAttr<CPUSpecificAttr>()) {
20049       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20050       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20051       return false;
20052     }
20053     return true;
20054   }
20055   if (const auto *Second = dyn_cast<CPUSpecificAttr>(A)) {
20056     if (const auto *First = D->getAttr<TargetClonesAttr>()) {
20057       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20058       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20059       return false;
20060     }
20061     if (const auto *First = D->getAttr<TargetVersionAttr>()) {
20062       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20063       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20064       return false;
20065     }
20066     if (const auto *First = D->getAttr<TargetAttr>()) {
20067       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20068       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20069       return false;
20070     }
20071     if (const auto *First = D->getAttr<CPUDispatchAttr>()) {
20072       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20073       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20074       return false;
20075     }
20076     return true;
20077   }
20078   if (const auto *Second = dyn_cast<CUDAConstantAttr>(A)) {
20079     if (const auto *First = D->getAttr<CUDASharedAttr>()) {
20080       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20081       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20082       return false;
20083     }
20084     if (const auto *First = D->getAttr<HIPManagedAttr>()) {
20085       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20086       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20087       return false;
20088     }
20089     return true;
20090   }
20091   if (const auto *Second = dyn_cast<CUDADeviceAttr>(A)) {
20092     if (const auto *First = D->getAttr<CUDAGlobalAttr>()) {
20093       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20094       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20095       return false;
20096     }
20097     return true;
20098   }
20099   if (const auto *Second = dyn_cast<CUDADeviceBuiltinSurfaceTypeAttr>(A)) {
20100     if (const auto *First = D->getAttr<CUDADeviceBuiltinTextureTypeAttr>()) {
20101       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20102       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20103       return false;
20104     }
20105     return true;
20106   }
20107   if (const auto *Second = dyn_cast<CUDADeviceBuiltinTextureTypeAttr>(A)) {
20108     if (const auto *First = D->getAttr<CUDADeviceBuiltinSurfaceTypeAttr>()) {
20109       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20110       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20111       return false;
20112     }
20113     return true;
20114   }
20115   if (const auto *Second = dyn_cast<CUDAGlobalAttr>(A)) {
20116     if (const auto *First = D->getAttr<CUDADeviceAttr>()) {
20117       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20118       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20119       return false;
20120     }
20121     if (const auto *First = D->getAttr<CUDAHostAttr>()) {
20122       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20123       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20124       return false;
20125     }
20126     return true;
20127   }
20128   if (const auto *Second = dyn_cast<CUDAHostAttr>(A)) {
20129     if (const auto *First = D->getAttr<CUDAGlobalAttr>()) {
20130       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20131       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20132       return false;
20133     }
20134     return true;
20135   }
20136   if (const auto *Second = dyn_cast<CUDASharedAttr>(A)) {
20137     if (const auto *First = D->getAttr<CUDAConstantAttr>()) {
20138       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20139       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20140       return false;
20141     }
20142     if (const auto *First = D->getAttr<HIPManagedAttr>()) {
20143       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20144       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20145       return false;
20146     }
20147     return true;
20148   }
20149   if (const auto *Second = dyn_cast<ColdAttr>(A)) {
20150     if (const auto *First = D->getAttr<HotAttr>()) {
20151       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20152       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20153       return false;
20154     }
20155     return true;
20156   }
20157   if (const auto *Second = dyn_cast<CommonAttr>(A)) {
20158     if (const auto *First = D->getAttr<InternalLinkageAttr>()) {
20159       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20160       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20161       return false;
20162     }
20163     return true;
20164   }
20165   if (const auto *Second = dyn_cast<ConvergentAttr>(A)) {
20166     if (const auto *First = D->getAttr<NoConvergentAttr>()) {
20167       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20168       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20169       return false;
20170     }
20171     return true;
20172   }
20173   if (const auto *Second = dyn_cast<DisableTailCallsAttr>(A)) {
20174     if (const auto *First = D->getAttr<NakedAttr>()) {
20175       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20176       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20177       return false;
20178     }
20179     return true;
20180   }
20181   if (const auto *Second = dyn_cast<HIPManagedAttr>(A)) {
20182     if (const auto *First = D->getAttr<CUDAConstantAttr>()) {
20183       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20184       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20185       return false;
20186     }
20187     if (const auto *First = D->getAttr<CUDASharedAttr>()) {
20188       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20189       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20190       return false;
20191     }
20192     return true;
20193   }
20194   if (const auto *Second = dyn_cast<HotAttr>(A)) {
20195     if (const auto *First = D->getAttr<ColdAttr>()) {
20196       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20197       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20198       return false;
20199     }
20200     return true;
20201   }
20202   if (const auto *Second = dyn_cast<InternalLinkageAttr>(A)) {
20203     if (const auto *First = D->getAttr<CommonAttr>()) {
20204       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20205       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20206       return false;
20207     }
20208     return true;
20209   }
20210   if (const auto *Second = dyn_cast<MicroMipsAttr>(A)) {
20211     if (const auto *First = D->getAttr<Mips16Attr>()) {
20212       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20213       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20214       return false;
20215     }
20216     return true;
20217   }
20218   if (const auto *Second = dyn_cast<Mips16Attr>(A)) {
20219     if (const auto *First = D->getAttr<MipsInterruptAttr>()) {
20220       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20221       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20222       return false;
20223     }
20224     if (const auto *First = D->getAttr<MicroMipsAttr>()) {
20225       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20226       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20227       return false;
20228     }
20229     return true;
20230   }
20231   if (const auto *Second = dyn_cast<MipsLongCallAttr>(A)) {
20232     if (const auto *First = D->getAttr<MipsShortCallAttr>()) {
20233       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20234       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20235       return false;
20236     }
20237     return true;
20238   }
20239   if (const auto *Second = dyn_cast<MipsShortCallAttr>(A)) {
20240     if (const auto *First = D->getAttr<MipsLongCallAttr>()) {
20241       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20242       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20243       return false;
20244     }
20245     return true;
20246   }
20247   if (const auto *Second = dyn_cast<NakedAttr>(A)) {
20248     if (const auto *First = D->getAttr<DisableTailCallsAttr>()) {
20249       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20250       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20251       return false;
20252     }
20253     return true;
20254   }
20255   if (const auto *Second = dyn_cast<NoConvergentAttr>(A)) {
20256     if (const auto *First = D->getAttr<ConvergentAttr>()) {
20257       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20258       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20259       return false;
20260     }
20261     return true;
20262   }
20263   if (const auto *Second = dyn_cast<NoDestroyAttr>(A)) {
20264     if (const auto *First = D->getAttr<AlwaysDestroyAttr>()) {
20265       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20266       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20267       return false;
20268     }
20269     return true;
20270   }
20271   if (const auto *Second = dyn_cast<NoRandomizeLayoutAttr>(A)) {
20272     if (const auto *First = D->getAttr<RandomizeLayoutAttr>()) {
20273       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20274       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20275       return false;
20276     }
20277     return true;
20278   }
20279   if (const auto *Second = dyn_cast<NoSpeculativeLoadHardeningAttr>(A)) {
20280     if (const auto *First = D->getAttr<SpeculativeLoadHardeningAttr>()) {
20281       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20282       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20283       return false;
20284     }
20285     return true;
20286   }
20287   if (const auto *Second = dyn_cast<NotTailCalledAttr>(A)) {
20288     if (const auto *First = D->getAttr<AlwaysInlineAttr>()) {
20289       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20290       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20291       return false;
20292     }
20293     return true;
20294   }
20295   if (const auto *Second = dyn_cast<OwnerAttr>(A)) {
20296     if (const auto *First = D->getAttr<PointerAttr>()) {
20297       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20298       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20299       return false;
20300     }
20301     return true;
20302   }
20303   if (const auto *Second = dyn_cast<PointerAttr>(A)) {
20304     if (const auto *First = D->getAttr<OwnerAttr>()) {
20305       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20306       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20307       return false;
20308     }
20309     return true;
20310   }
20311   if (const auto *Second = dyn_cast<RandomizeLayoutAttr>(A)) {
20312     if (const auto *First = D->getAttr<NoRandomizeLayoutAttr>()) {
20313       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20314       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20315       return false;
20316     }
20317     return true;
20318   }
20319   if (const auto *Second = dyn_cast<SpeculativeLoadHardeningAttr>(A)) {
20320     if (const auto *First = D->getAttr<NoSpeculativeLoadHardeningAttr>()) {
20321       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20322       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20323       return false;
20324     }
20325     return true;
20326   }
20327   if (const auto *Second = dyn_cast<TargetAttr>(A)) {
20328     if (const auto *First = D->getAttr<TargetClonesAttr>()) {
20329       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20330       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20331       return false;
20332     }
20333     if (const auto *First = D->getAttr<TargetVersionAttr>()) {
20334       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20335       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20336       return false;
20337     }
20338     if (const auto *First = D->getAttr<CPUDispatchAttr>()) {
20339       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20340       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20341       return false;
20342     }
20343     if (const auto *First = D->getAttr<CPUSpecificAttr>()) {
20344       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20345       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20346       return false;
20347     }
20348     return true;
20349   }
20350   if (const auto *Second = dyn_cast<TargetClonesAttr>(A)) {
20351     if (const auto *First = D->getAttr<TargetVersionAttr>()) {
20352       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20353       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20354       return false;
20355     }
20356     if (const auto *First = D->getAttr<TargetAttr>()) {
20357       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20358       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20359       return false;
20360     }
20361     if (const auto *First = D->getAttr<CPUDispatchAttr>()) {
20362       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20363       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20364       return false;
20365     }
20366     if (const auto *First = D->getAttr<CPUSpecificAttr>()) {
20367       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20368       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20369       return false;
20370     }
20371     return true;
20372   }
20373   if (const auto *Second = dyn_cast<TargetVersionAttr>(A)) {
20374     if (const auto *First = D->getAttr<TargetClonesAttr>()) {
20375       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20376       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20377       return false;
20378     }
20379     if (const auto *First = D->getAttr<TargetAttr>()) {
20380       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20381       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20382       return false;
20383     }
20384     if (const auto *First = D->getAttr<CPUDispatchAttr>()) {
20385       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20386       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20387       return false;
20388     }
20389     if (const auto *First = D->getAttr<CPUSpecificAttr>()) {
20390       S.Diag(First->getLocation(), diag::err_attributes_are_not_compatible) << First << Second << (First->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20391       S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20392       return false;
20393     }
20394     return true;
20395   }
20396   return true;
20397 }
20398 
20399 #elif defined(WANT_STMT_MERGE_LOGIC)
20400 
20401 static bool DiagnoseMutualExclusions(Sema &S, const SmallVectorImpl<const Attr *> &C) {
20402   for (const Attr *A : C) {
20403     if (const auto *Second = dyn_cast<AlwaysInlineAttr>(A)) {
20404       auto Iter = llvm::find_if(C, [](const Attr *Check) { return isa<NotTailCalledAttr>(Check); });
20405       if (Iter != C.end()) {
20406         S.Diag((*Iter)->getLocation(), diag::err_attributes_are_not_compatible) << *Iter << Second << ((*Iter)->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20407         S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20408         return false;
20409       }
20410     }
20411     if (const auto *Second = dyn_cast<LikelyAttr>(A)) {
20412       auto Iter = llvm::find_if(C, [](const Attr *Check) { return isa<UnlikelyAttr>(Check); });
20413       if (Iter != C.end()) {
20414         S.Diag((*Iter)->getLocation(), diag::err_attributes_are_not_compatible) << *Iter << Second << ((*Iter)->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20415         S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20416         return false;
20417       }
20418     }
20419     if (const auto *Second = dyn_cast<UnlikelyAttr>(A)) {
20420       auto Iter = llvm::find_if(C, [](const Attr *Check) { return isa<LikelyAttr>(Check); });
20421       if (Iter != C.end()) {
20422         S.Diag((*Iter)->getLocation(), diag::err_attributes_are_not_compatible) << *Iter << Second << ((*Iter)->isRegularKeywordAttribute() || Second->isRegularKeywordAttribute());
20423         S.Diag(Second->getLocation(), diag::note_conflicting_attribute);
20424         return false;
20425       }
20426     }
20427   }
20428   return true;
20429 }
20430 
20431 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!