From 6ca0de7e07a02a91ed9ea1493e48c2d29806c537 Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Wed, 9 Oct 2024 22:12:50 +0000 Subject: [PATCH 1/6] [clang][frontend] Support applying annotate to statements The underlying code already works; this is just a matter of allowing application of this undocumented attribute. --- clang/include/clang/Basic/Attr.td | 7 ++++++- clang/utils/TableGen/ClangAttrEmitter.cpp | 11 +++++++---- 2 files changed, 13 insertions(+), 5 deletions(-) diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index fbcbf0ed41641..ec3d6e0079f63 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -759,6 +759,11 @@ class TargetSpecificAttr { /// redeclarations, even when it's written on a parameter. class InheritableParamAttr : InheritableAttr; +/// A attribute that is either a declaration attribute or a statement attribute, +/// and if used as a declaration attribute, is inherited by later +/// redeclarations, even when it's written on a parameter. +class InheritableParamOrStmtAttr : InheritableParamAttr; + /// An attribute which changes the ABI rules for a specific parameter. class ParameterABIAttr : InheritableParamAttr { let Subjects = SubjectList<[ParmVar]>; @@ -928,7 +933,7 @@ def AnalyzerNoReturn : InheritableAttr { let Documentation = [Undocumented]; } -def Annotate : InheritableParamAttr { +def Annotate : InheritableParamOrStmtAttr { let Spellings = [Clang<"annotate">]; let Args = [StringArgument<"Annotation">, VariadicExprArgument<"Args">]; // Ensure that the annotate attribute can be used with diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index 87be48c215e23..cee47fa8a283f 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -3295,6 +3295,7 @@ static const AttrClassDescriptor AttrClassDescriptors[] = { { "INHERITABLE_ATTR", "InheritableAttr" }, { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" }, { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" }, + { "INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr" }, { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }, { "HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"} }; @@ -4328,10 +4329,12 @@ static void GenerateMutualExclusionsChecks(const Record &Attr, // This means the attribute is either a statement attribute, a decl // attribute, or both; find out which. - bool CurAttrIsStmtAttr = - Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr"); - bool CurAttrIsDeclAttr = - !CurAttrIsStmtAttr || Attr.isSubClassOf("DeclOrStmtAttr"); + bool CurAttrIsStmtAttr = Attr.isSubClassOf("StmtAttr") || + Attr.isSubClassOf("DeclOrStmtAttr") || + Attr.isSubClassOf("InheritableParamOrStmtAttr"); + bool CurAttrIsDeclAttr = !CurAttrIsStmtAttr || + Attr.isSubClassOf("DeclOrStmtAttr") || + Attr.isSubClassOf("InheritableParamOrStmtAttr"); std::vector DeclAttrs, StmtAttrs; From 88e7bf70c327b85bcbd595503a593de80676d1b4 Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Thu, 10 Oct 2024 14:10:52 +0000 Subject: [PATCH 2/6] Add additional support for stmt-level AnnotateAttr --- clang/include/clang/AST/Attr.h | 17 ++++++++++ clang/lib/Sema/SemaStmtAttr.cpp | 20 ++++++++++++ clang/lib/Sema/SemaTemplateInstantiate.cpp | 14 ++++++++ clang/test/AST/attr-print-emit.cpp | 3 ++ clang/test/Sema/annotate.c | 3 ++ clang/test/SemaTemplate/attributes.cpp | 38 ++++++++++++++++++++++ 6 files changed, 95 insertions(+) diff --git a/clang/include/clang/AST/Attr.h b/clang/include/clang/AST/Attr.h index ac44e9fdd7c4e..725498e132fc2 100644 --- a/clang/include/clang/AST/Attr.h +++ b/clang/include/clang/AST/Attr.h @@ -197,6 +197,23 @@ class InheritableParamAttr : public InheritableAttr { } }; +class InheritableParamOrStmtAttr : public InheritableParamAttr { +protected: + InheritableParamOrStmtAttr(ASTContext &Context, + const AttributeCommonInfo &CommonInfo, + attr::Kind AK, bool IsLateParsed, + bool InheritEvenIfAlreadyPresent) + : InheritableParamAttr(Context, CommonInfo, AK, IsLateParsed, + InheritEvenIfAlreadyPresent) {} + +public: + // Implement isa/cast/dyncast/etc. + static bool classof(const Attr *A) { + return A->getKind() >= attr::FirstInheritableParamOrStmtAttr && + A->getKind() <= attr::LastInheritableParamOrStmtAttr; + } +}; + class HLSLAnnotationAttr : public InheritableAttr { protected: HLSLAnnotationAttr(ASTContext &Context, const AttributeCommonInfo &CommonInfo, diff --git a/clang/lib/Sema/SemaStmtAttr.cpp b/clang/lib/Sema/SemaStmtAttr.cpp index b9b3b4063bc38..ee6630bdb429c 100644 --- a/clang/lib/Sema/SemaStmtAttr.cpp +++ b/clang/lib/Sema/SemaStmtAttr.cpp @@ -242,6 +242,24 @@ static Attr *handleNoConvergentAttr(Sema &S, Stmt *St, const ParsedAttr &A, return ::new (S.Context) NoConvergentAttr(S.Context, A); } +static Attr *handleAnnotateAttr(Sema &S, Stmt *St, const ParsedAttr &A, + SourceRange Range) { + // Make sure that there is a string literal as the annotation's first + // argument. + StringRef Str; + if (!S.checkStringLiteralArgumentAttr(A, 0, Str)) + return nullptr; + + llvm::SmallVector Args; + Args.reserve(A.getNumArgs() - 1); + for (unsigned Idx = 1; Idx < A.getNumArgs(); Idx++) { + assert(!A.isArgIdent(Idx)); + Args.push_back(A.getArgAsExpr(Idx)); + } + + return AnnotateAttr::Create(S.Context, Str, Args.data(), Args.size(), A); +} + template static bool CheckStmtInlineAttr(Sema &SemaRef, const Stmt *OrigSt, const Stmt *CurSt, @@ -679,6 +697,8 @@ static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A, return handleMSConstexprAttr(S, St, A, Range); case ParsedAttr::AT_NoConvergent: return handleNoConvergentAttr(S, St, A, Range); + case ParsedAttr::AT_Annotate: + return handleAnnotateAttr(S, St, A, Range); default: // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a // declaration attribute is not written on a statement, but this code is diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index fd51fa4afcacb..00a5f81dbca8f 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -1537,6 +1537,7 @@ namespace { NamedDecl *FirstQualifierInScope = nullptr, bool AllowInjectedClassName = false); + const AnnotateAttr *TransformAnnotateAttr(const AnnotateAttr *AA); const CXXAssumeAttr *TransformCXXAssumeAttr(const CXXAssumeAttr *AA); const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH); const NoInlineAttr *TransformStmtNoInlineAttr(const Stmt *OrigS, @@ -2125,6 +2126,19 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E, Arg, PackIndex); } +const AnnotateAttr * +TemplateInstantiator::TransformAnnotateAttr(const AnnotateAttr *AA) { + SmallVector Args; + for (Expr *Arg : AA->args()) { + ExprResult Res = getDerived().TransformExpr(Arg); + if (!Res.isUsable()) + return AA; + Args.push_back(Res.get()); + } + return AnnotateAttr::CreateImplicit(getSema().Context, AA->getAnnotation(), + Args.data(), Args.size(), AA->getRange()); +} + const CXXAssumeAttr * TemplateInstantiator::TransformCXXAssumeAttr(const CXXAssumeAttr *AA) { ExprResult Res = getDerived().TransformExpr(AA->getAssumption()); diff --git a/clang/test/AST/attr-print-emit.cpp b/clang/test/AST/attr-print-emit.cpp index d8e62ed5f6cd1..a9bca6778d0f1 100644 --- a/clang/test/AST/attr-print-emit.cpp +++ b/clang/test/AST/attr-print-emit.cpp @@ -78,6 +78,9 @@ class C { ANNOTATE_ATTR int annotated_attr ANNOTATE_ATTR = 0; // CHECK: __attribute__((annotate("Annotated"))) int annotated_attr __attribute__((annotate("Annotated"))) = 0; +void increment() { [[clang::annotate("Annotated")]] annotated_attr++; } +// CHECK: {{\[\[}}clang::annotate("Annotated")]] annotated_attr++; + // FIXME: We do not print the attribute as written after the type specifier. int ANNOTATE_ATTR annotated_attr_fixme = 0; // CHECK: __attribute__((annotate("Annotated"))) int annotated_attr_fixme = 0; diff --git a/clang/test/Sema/annotate.c b/clang/test/Sema/annotate.c index b4551a102e617..f2ef08d637897 100644 --- a/clang/test/Sema/annotate.c +++ b/clang/test/Sema/annotate.c @@ -3,10 +3,12 @@ void __attribute__((annotate("foo"))) foo(float *a) { __attribute__((annotate("bar"))) int x; [[clang::annotate("bar")]] int x2; + [[clang::annotate("bar")]] x2 += 1; __attribute__((annotate(1))) int y; // expected-error {{expected string literal as argument of 'annotate' attribute}} [[clang::annotate(1)]] int y2; // expected-error {{expected string literal as argument of 'annotate' attribute}} __attribute__((annotate("bar", 1))) int z; [[clang::annotate("bar", 1)]] int z2; + [[clang::annotate("bar", 1)]] z2 += 1; int u = __builtin_annotation(z, (char*) 0); // expected-error {{second argument to __builtin_annotation must be a non-wide string constant}} int v = __builtin_annotation(z, (char*) L"bar"); // expected-error {{second argument to __builtin_annotation must be a non-wide string constant}} @@ -15,4 +17,5 @@ void __attribute__((annotate("foo"))) foo(float *a) { __attribute__((annotate())) int c; // expected-error {{'annotate' attribute takes at least 1 argument}} [[clang::annotate()]] int c2; // expected-error {{'annotate' attribute takes at least 1 argument}} + [[clang::annotate()]] c2 += 1; // expected-error {{'annotate' attribute takes at least 1 argument}} } diff --git a/clang/test/SemaTemplate/attributes.cpp b/clang/test/SemaTemplate/attributes.cpp index f6c9f13f0842d..dea19d09745ca 100644 --- a/clang/test/SemaTemplate/attributes.cpp +++ b/clang/test/SemaTemplate/attributes.cpp @@ -65,6 +65,17 @@ namespace attribute_annotate { template [[clang::annotate("ANNOTATE_FOO"), clang::annotate("ANNOTATE_BAR")]] void HasAnnotations(); void UseAnnotations() { HasAnnotations(); } +// CHECK: FunctionTemplateDecl {{.*}} HasStmtAnnotations +// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAZ" +// CHECK: FunctionDecl {{.*}} HasStmtAnnotations +// CHECK: TemplateArgument type 'int' +// CHECK: AnnotateAttr {{.*}} "ANNOTATE_BAZ" +template void HasStmtAnnotations() { + int x = 0; + [[clang::annotate("ANNOTATE_BAZ")]] x++; +} +void UseStmtAnnotations() { HasStmtAnnotations(); } + // CHECK: FunctionTemplateDecl {{.*}} HasPackAnnotations // CHECK-NEXT: NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is // CHECK-NEXT: FunctionDecl {{.*}} HasPackAnnotations 'void ()' @@ -95,6 +106,33 @@ void UseAnnotations() { HasAnnotations(); } template [[clang::annotate("ANNOTATE_BAZ", Is...)]] void HasPackAnnotations(); void UsePackAnnotations() { HasPackAnnotations<1, 2, 3>(); } +// CHECK: FunctionTemplateDecl {{.*}} HasStmtPackAnnotations +// CHECK-NEXT: NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is +// CHECK-NEXT: FunctionDecl {{.*}} HasStmtPackAnnotations 'void ()' +// CHECK: AttributedStmt {{.*}} +// CHECK-NEXT: AnnotateAttr {{.*}} "ANNOTATE_QUUX" +// CHECK-NEXT: PackExpansionExpr {{.*}} '' +// CHECK-NEXT: DeclRefExpr {{.*}} 'int' NonTypeTemplateParm {{.*}} 'Is' 'int' +// CHECK: FunctionDecl {{.*}} used HasStmtPackAnnotations 'void ()' +// CHECK-NEXT: TemplateArgument{{.*}} pack +// CHECK-NEXT: TemplateArgument{{.*}} integral '1' +// CHECK-NEXT: TemplateArgument{{.*}} integral '2' +// CHECK-NEXT: TemplateArgument{{.*}} integral '3' +// CHECK: AttributedStmt {{.*}} +// CHECK-NEXT: AnnotateAttr {{.*}} "ANNOTATE_QUUX" +// CHECK-NEXT: PackExpansionExpr {{.*}} +// CHECK-NEXT: SubstNonTypeTemplateParmPackExpr {{.*}} +// CHECK-NEXT: NonTypeTemplateParmDecl {{.*}} referenced 'int' depth 0 index 0 ... Is +// CHECK-NEXT: TemplateArgument pack '<1, 2, 3>' +// CHECK-NEXT: TemplateArgument integral '1' +// CHECK-NEXT: TemplateArgument integral '2' +// CHECK-NEXT: TemplateArgument integral '3' +template void HasStmtPackAnnotations() { + int x = 0; + [[clang::annotate("ANNOTATE_QUUX", Is...)]] x++; +} +void UseStmtPackAnnotations() { HasStmtPackAnnotations<1, 2, 3>(); } + template [[clang::annotate(Is...)]] void HasOnlyPackAnnotation() {} // expected-error {{expected string literal as argument of 'annotate' attribute}} void UseOnlyPackAnnotations() { From 3864b0e007b1647f3b274d1e42c1767466f96b44 Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Thu, 10 Oct 2024 14:23:22 +0000 Subject: [PATCH 3/6] Fix formatting --- clang/utils/TableGen/ClangAttrEmitter.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index cee47fa8a283f..cdd17fb48bcde 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -3288,17 +3288,16 @@ namespace { } // end anonymous namespace static const AttrClassDescriptor AttrClassDescriptors[] = { - { "ATTR", "Attr" }, - { "TYPE_ATTR", "TypeAttr" }, - { "STMT_ATTR", "StmtAttr" }, - { "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" }, - { "INHERITABLE_ATTR", "InheritableAttr" }, - { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" }, - { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" }, - { "INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr" }, - { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }, - { "HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"} -}; + {"ATTR", "Attr"}, + {"TYPE_ATTR", "TypeAttr"}, + {"STMT_ATTR", "StmtAttr"}, + {"DECL_OR_STMT_ATTR", "DeclOrStmtAttr"}, + {"INHERITABLE_ATTR", "InheritableAttr"}, + {"DECL_OR_TYPE_ATTR", "DeclOrTypeAttr"}, + {"INHERITABLE_PARAM_ATTR", "InheritableParamAttr"}, + {"INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr"}, + {"PARAMETER_ABI_ATTR", "ParameterABIAttr"}, + {"HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"}}; static void emitDefaultDefine(raw_ostream &OS, StringRef name, const char *superName) { From be28c2b9f04d7a996f9766bb7cd384cafb775596 Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Thu, 10 Oct 2024 16:04:01 +0000 Subject: [PATCH 4/6] Factor out the common logic for handling AnnotateAttr in Sema, and adjust error handling --- clang/include/clang/Sema/Sema.h | 7 +++-- clang/lib/Sema/Sema.cpp | 28 +++++++++++++++++++ clang/lib/Sema/SemaDeclAttr.cpp | 25 ++--------------- clang/lib/Sema/SemaStmtAttr.cpp | 2 +- clang/lib/Sema/SemaTemplateInstantiate.cpp | 5 ++-- .../lib/Sema/SemaTemplateInstantiateDecl.cpp | 5 +++- clang/utils/TableGen/ClangAttrEmitter.cpp | 21 +++++++------- 7 files changed, 53 insertions(+), 40 deletions(-) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index ef010fafb1573..f8118ca64ad3f 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -4528,9 +4528,10 @@ class Sema final : public SemaBase { /// declaration. void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E); - /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D. - void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, - StringRef Annot, MutableArrayRef Args); + /// CreateAnnotationAttr - Creates an annotation Annot with Args arguments. + Attr *CreateAnnotationAttr(const AttributeCommonInfo &CI, StringRef Annot, + MutableArrayRef Args); + Attr *CreateAnnotationAttr(const ParsedAttr &AL); bool checkMSInheritanceAttrOnDefinition(CXXRecordDecl *RD, SourceRange Range, bool BestCase, diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index f05760428458b..9f91ee9a39f2f 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -2777,3 +2777,31 @@ bool Sema::isDeclaratorFunctionLike(Declarator &D) { }); return Result; } + +Attr *Sema::CreateAnnotationAttr(const AttributeCommonInfo &CI, StringRef Annot, + MutableArrayRef Args) { + + auto *A = AnnotateAttr::Create(Context, Annot, Args.data(), Args.size(), CI); + if (!ConstantFoldAttrArgs( + CI, MutableArrayRef(A->args_begin(), A->args_end()))) { + return nullptr; + } + return A; +} + +Attr *Sema::CreateAnnotationAttr(const ParsedAttr &AL) { + // Make sure that there is a string literal as the annotation's first + // argument. + StringRef Str; + if (!checkStringLiteralArgumentAttr(AL, 0, Str)) + return nullptr; + + llvm::SmallVector Args; + Args.reserve(AL.getNumArgs() - 1); + for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) { + assert(!AL.isArgIdent(Idx)); + Args.push_back(AL.getArgAsExpr(Idx)); + } + + return CreateAnnotationAttr(AL, Str, Args); +} diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index e2174ba926f17..6759aae37afac 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -3958,30 +3958,11 @@ static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) { RD->addAttr(::new (S.Context) TransparentUnionAttr(S.Context, AL)); } -void Sema::AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI, - StringRef Str, MutableArrayRef Args) { - auto *Attr = AnnotateAttr::Create(Context, Str, Args.data(), Args.size(), CI); - if (ConstantFoldAttrArgs( - CI, MutableArrayRef(Attr->args_begin(), Attr->args_end()))) { - D->addAttr(Attr); - } -} - static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) { - // Make sure that there is a string literal as the annotation's first - // argument. - StringRef Str; - if (!S.checkStringLiteralArgumentAttr(AL, 0, Str)) - return; - - llvm::SmallVector Args; - Args.reserve(AL.getNumArgs() - 1); - for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) { - assert(!AL.isArgIdent(Idx)); - Args.push_back(AL.getArgAsExpr(Idx)); + auto *Attr = S.CreateAnnotationAttr(AL); + if (Attr) { + D->addAttr(Attr); } - - S.AddAnnotationAttr(D, AL, Str, Args); } static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) { diff --git a/clang/lib/Sema/SemaStmtAttr.cpp b/clang/lib/Sema/SemaStmtAttr.cpp index ee6630bdb429c..47e8f1ad4dde8 100644 --- a/clang/lib/Sema/SemaStmtAttr.cpp +++ b/clang/lib/Sema/SemaStmtAttr.cpp @@ -698,7 +698,7 @@ static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A, case ParsedAttr::AT_NoConvergent: return handleNoConvergentAttr(S, St, A, Range); case ParsedAttr::AT_Annotate: - return handleAnnotateAttr(S, St, A, Range); + return S.CreateAnnotationAttr(A); default: // N.B., ClangAttrEmitter.cpp emits a diagnostic helper that ensures a // declaration attribute is not written on a statement, but this code is diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp index 02f12f5c2d422..2f60c0beb22e7 100644 --- a/clang/lib/Sema/SemaTemplateInstantiate.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp @@ -2188,9 +2188,8 @@ TemplateInstantiator::TransformAnnotateAttr(const AnnotateAttr *AA) { SmallVector Args; for (Expr *Arg : AA->args()) { ExprResult Res = getDerived().TransformExpr(Arg); - if (!Res.isUsable()) - return AA; - Args.push_back(Res.get()); + if (Res.isUsable()) + Args.push_back(Res.get()); } return AnnotateAttr::CreateImplicit(getSema().Context, AA->getAnnotation(), Args.data(), Args.size(), AA->getRange()); diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 34558e1a005d5..6b1af35f5c80a 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -230,7 +230,10 @@ static void instantiateDependentAnnotationAttr( ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end()); std::swap(Args, ActualArgs); } - S.AddAnnotationAttr(New, *Attr, Str, Args); + auto *AA = S.CreateAnnotationAttr(*Attr, Str, Args); + if (AA) { + New->addAttr(AA); + } } static Expr *instantiateDependentFunctionAttrCondition( diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index 4890d249c6d8f..5e4827ec4a7c6 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -3282,16 +3282,17 @@ namespace { } // end anonymous namespace static const AttrClassDescriptor AttrClassDescriptors[] = { - {"ATTR", "Attr"}, - {"TYPE_ATTR", "TypeAttr"}, - {"STMT_ATTR", "StmtAttr"}, - {"DECL_OR_STMT_ATTR", "DeclOrStmtAttr"}, - {"INHERITABLE_ATTR", "InheritableAttr"}, - {"DECL_OR_TYPE_ATTR", "DeclOrTypeAttr"}, - {"INHERITABLE_PARAM_ATTR", "InheritableParamAttr"}, - {"INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr"}, - {"PARAMETER_ABI_ATTR", "ParameterABIAttr"}, - {"HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"}}; + { "ATTR", "Attr" }, + { "TYPE_ATTR", "TypeAttr" }, + { "STMT_ATTR", "StmtAttr" }, + { "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" }, + { "INHERITABLE_ATTR", "InheritableAttr" }, + { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" }, + { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" }, + { "INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr" }, + { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }, + { "HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"} +}; static void emitDefaultDefine(raw_ostream &OS, StringRef name, const char *superName) { From 6fd9661bcd2a51a6daa1a2ae9020b7cfdb07e941 Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Thu, 10 Oct 2024 16:07:09 +0000 Subject: [PATCH 5/6] Remove unused function --- clang/lib/Sema/SemaStmtAttr.cpp | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/clang/lib/Sema/SemaStmtAttr.cpp b/clang/lib/Sema/SemaStmtAttr.cpp index 47e8f1ad4dde8..d81c6de3428dc 100644 --- a/clang/lib/Sema/SemaStmtAttr.cpp +++ b/clang/lib/Sema/SemaStmtAttr.cpp @@ -242,24 +242,6 @@ static Attr *handleNoConvergentAttr(Sema &S, Stmt *St, const ParsedAttr &A, return ::new (S.Context) NoConvergentAttr(S.Context, A); } -static Attr *handleAnnotateAttr(Sema &S, Stmt *St, const ParsedAttr &A, - SourceRange Range) { - // Make sure that there is a string literal as the annotation's first - // argument. - StringRef Str; - if (!S.checkStringLiteralArgumentAttr(A, 0, Str)) - return nullptr; - - llvm::SmallVector Args; - Args.reserve(A.getNumArgs() - 1); - for (unsigned Idx = 1; Idx < A.getNumArgs(); Idx++) { - assert(!A.isArgIdent(Idx)); - Args.push_back(A.getArgAsExpr(Idx)); - } - - return AnnotateAttr::Create(S.Context, Str, Args.data(), Args.size(), A); -} - template static bool CheckStmtInlineAttr(Sema &SemaRef, const Stmt *OrigSt, const Stmt *CurSt, From 753b168bb9a4b448ce26276691f5a0515f5eaf3e Mon Sep 17 00:00:00 2001 From: Eric Astor Date: Thu, 10 Oct 2024 16:18:18 +0000 Subject: [PATCH 6/6] Fix formatting again --- clang/utils/TableGen/ClangAttrEmitter.cpp | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp index 5e4827ec4a7c6..4890d249c6d8f 100644 --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -3282,17 +3282,16 @@ namespace { } // end anonymous namespace static const AttrClassDescriptor AttrClassDescriptors[] = { - { "ATTR", "Attr" }, - { "TYPE_ATTR", "TypeAttr" }, - { "STMT_ATTR", "StmtAttr" }, - { "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" }, - { "INHERITABLE_ATTR", "InheritableAttr" }, - { "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" }, - { "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" }, - { "INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr" }, - { "PARAMETER_ABI_ATTR", "ParameterABIAttr" }, - { "HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"} -}; + {"ATTR", "Attr"}, + {"TYPE_ATTR", "TypeAttr"}, + {"STMT_ATTR", "StmtAttr"}, + {"DECL_OR_STMT_ATTR", "DeclOrStmtAttr"}, + {"INHERITABLE_ATTR", "InheritableAttr"}, + {"DECL_OR_TYPE_ATTR", "DeclOrTypeAttr"}, + {"INHERITABLE_PARAM_ATTR", "InheritableParamAttr"}, + {"INHERITABLE_PARAM_OR_STMT_ATTR", "InheritableParamOrStmtAttr"}, + {"PARAMETER_ABI_ATTR", "ParameterABIAttr"}, + {"HLSL_ANNOTATION_ATTR", "HLSLAnnotationAttr"}}; static void emitDefaultDefine(raw_ostream &OS, StringRef name, const char *superName) {