diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -2766,6 +2766,20 @@ let Documentation = [TypeTagForDatatypeDocs]; } +def Owner : InheritableAttr { + let Spellings = [CXX11<"gsl", "Owner">]; + let Subjects = SubjectList<[CXXRecord]>; + let Args = [TypeArgument<"DerefType", /*opt=*/1>]; + let Documentation = [LifetimeOwnerDocs]; +} + +def Pointer : InheritableAttr { + let Spellings = [CXX11<"gsl", "Pointer">]; + let Subjects = SubjectList<[CXXRecord]>; + let Args = [TypeArgument<"DerefType", /*opt=*/1>]; + let Documentation = [LifetimePointerDocs]; +} + // Microsoft-related attributes def MSNoVTable : InheritableAttr, TargetSpecificAttr { diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -4157,3 +4157,71 @@ ``__attribute__((malloc))``. }]; } + +def LifetimeOwnerDocs : Documentation { + let Category = DocCatDecl; + let Content = [{ +.. Note:: This attribute is experimental and its effect on analysis is subject to change in + a future version of clang. + +The attribute ``[[gsl::Owner(T)]]`` applies to structs and classes that own an +object of type ``T``: + +.. code-block:: c++ + + class [[gsl::Owner(int)]] IntOwner { + private: + int value; + public: + int *getInt() { return &value; } + }; + +The argument ``T`` is optional and currently ignored. +This attribute may be used by analysis tools and has no effect on code +generation. + +See Pointer_ for an example. +}]; +} + +def LifetimePointerDocs : Documentation { + let Category = DocCatDecl; + let Content = [{ +.. Note:: This attribute is experimental and its effect on analysis is subject to change in + a future version of clang. + +The attribute ``[[gsl::Pointer(T)]]`` applies to structs and classes that behave +like pointers to an object of type ``T``: + +.. code-block:: c++ + + class [[gsl::Pointer(int)]] IntPointer { + private: + int *valuePointer; + public: + int *getInt() { return &valuePointer; } + }; + +The argument ``T`` is optional and currently ignored. +This attribute may be used by analysis tools and has no effect on code +generation. + +Example: +When constructing an instance of a class annotated like this (a Pointer) from +an instance of a class annotated with ``[[gsl::Owner]]`` (an Owner), +then the analysis will consider the Pointer to point inside the Owner. +When the Owner's lifetime ends, it will consider the Pointer to be dangling. + +.. code-block:: c++ + + int f() { + IntPointer P; + if (true) { + IntOwner O(7); + P = IntPointer(O); // P "points into" O + } // P is dangling + return P.get(); // error: Using a dangling Pointer. + } + +}]; +} diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -2513,6 +2513,8 @@ "'NSObject' attribute is for pointer types only">; def err_attributes_are_not_compatible : Error< "%0 and %1 attributes are not compatible">; +def err_attribute_invalid_argument : Error< + "%0 is an invalid argument to attribute %1">; def err_attribute_wrong_number_arguments : Error< "%0 attribute %plural{0:takes no arguments|1:takes one argument|" ":requires exactly %1 arguments}1">; diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -335,6 +335,7 @@ ConsumeParen(); bool ChangeKWThisToIdent = attributeTreatsKeywordThisAsIdentifier(*AttrName); + bool AttributeIsTypeArgAttr = attributeIsTypeArgAttr(*AttrName); // Interpret "kw_this" as an identifier if the attributed requests it. if (ChangeKWThisToIdent && Tok.is(tok::kw_this)) @@ -360,6 +361,7 @@ ArgExprs.push_back(ParseIdentifierLoc()); } + ParsedType TheParsedType; if (!ArgExprs.empty() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren)) { // Eat the comma. if (!ArgExprs.empty()) @@ -372,8 +374,17 @@ Tok.setKind(tok::identifier); ExprResult ArgExpr; - if (Tok.is(tok::identifier) && - attributeHasVariadicIdentifierArg(*AttrName)) { + if (AttributeIsTypeArgAttr) { + TypeResult T = ParseTypeName(); + if (T.isInvalid()) { + SkipUntil(tok::r_paren, StopAtSemi); + return 0; + } + if (T.isUsable()) + TheParsedType = T.get(); + break; // Multiple type arguments are not implemented. + } else if (Tok.is(tok::identifier) && + attributeHasVariadicIdentifierArg(*AttrName)) { ArgExprs.push_back(ParseIdentifierLoc()); } else { bool Uneval = attributeParsedArgsUnevaluated(*AttrName); @@ -397,14 +408,20 @@ SourceLocation RParen = Tok.getLocation(); if (!ExpectAndConsume(tok::r_paren)) { SourceLocation AttrLoc = ScopeLoc.isValid() ? ScopeLoc : AttrNameLoc; - Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc, - ArgExprs.data(), ArgExprs.size(), Syntax); + + if (AttributeIsTypeArgAttr && !TheParsedType.get().isNull()) { + Attrs.addNewTypeAttr(AttrName, SourceRange(AttrNameLoc, RParen), + ScopeName, ScopeLoc, TheParsedType, Syntax); + } else { + Attrs.addNew(AttrName, SourceRange(AttrLoc, RParen), ScopeName, ScopeLoc, + ArgExprs.data(), ArgExprs.size(), Syntax); + } } if (EndLoc) *EndLoc = RParen; - return static_cast(ArgExprs.size()); + return static_cast(ArgExprs.size() + !TheParsedType.get().isNull()); } /// Parse the arguments to a parameterized GNU attribute or diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -4533,6 +4533,71 @@ DiagnosticIdentifiers.size(), AL.getAttributeSpellingListIndex())); } +static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) { + TypeSourceInfo *DerefTypeLoc = nullptr; + QualType ParmType; + if (AL.hasParsedType()) { + ParmType = S.GetTypeFromParser(AL.getTypeArg(), &DerefTypeLoc); + + if (ParmType->isVoidType()) { + S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) + << "'void'" << AL; + return; + } + + if (ParmType->isReferenceType()) { + S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) + << "A reference type" << AL; + return; + } + + if (ParmType->isArrayType()) { + S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) + << "An array type" << AL; + return; + } + } + + // To check if earlier decl attributes do not conflict the newly parsed ones + // we always add (and check) the attribute to the cannonical decl. + D = D->getCanonicalDecl(); + if (AL.getKind() == ParsedAttr::AT_Owner) { + if (checkAttrMutualExclusion(S, D, AL)) + return; + if (const auto *OAttr = D->getAttr()) { + const Type *ExistingDerefType = OAttr->getDerefTypeLoc() + ? OAttr->getDerefType().getTypePtr() + : nullptr; + if (ExistingDerefType != ParmType.getTypePtrOrNull()) { + S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) + << AL << OAttr; + S.Diag(OAttr->getLocation(), diag::note_conflicting_attribute); + } + return; + } + D->addAttr(::new (S.Context) + OwnerAttr(AL.getRange(), S.Context, DerefTypeLoc, + AL.getAttributeSpellingListIndex())); + } else { + if (checkAttrMutualExclusion(S, D, AL)) + return; + if (const auto *PAttr = D->getAttr()) { + const Type *ExistingDerefType = PAttr->getDerefTypeLoc() + ? PAttr->getDerefType().getTypePtr() + : nullptr; + if (ExistingDerefType != ParmType.getTypePtrOrNull()) { + S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) + << AL << PAttr; + S.Diag(PAttr->getLocation(), diag::note_conflicting_attribute); + } + return; + } + D->addAttr(::new (S.Context) + PointerAttr(AL.getRange(), S.Context, DerefTypeLoc, + AL.getAttributeSpellingListIndex())); + } +} + bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC, const FunctionDecl *FD) { if (Attrs.isInvalid()) @@ -7110,6 +7175,10 @@ case ParsedAttr::AT_Suppress: handleSuppressAttr(S, D, AL); break; + case ParsedAttr::AT_Owner: + case ParsedAttr::AT_Pointer: + handleLifetimeCategoryAttr(S, D, AL); + break; case ParsedAttr::AT_OpenCLKernel: handleSimpleAttribute(S, D, AL); break; diff --git a/clang/test/AST/ast-dump-attr.cpp b/clang/test/AST/ast-dump-attr.cpp --- a/clang/test/AST/ast-dump-attr.cpp +++ b/clang/test/AST/ast-dump-attr.cpp @@ -211,6 +211,23 @@ } } +namespace TestLifetimeCategories { +class [[gsl::Owner(int)]] AOwner{}; +// CHECK: CXXRecordDecl{{.*}} class AOwner +// CHECK: OwnerAttr {{.*}} int +class [[gsl::Pointer(int)]] APointer{}; +// CHECK: CXXRecordDecl{{.*}} class APointer +// CHECK: PointerAttr {{.*}} int + +class [[gsl::Pointer]] PointerWithoutArgument{}; +// CHECK: CXXRecordDecl{{.*}} class PointerWithoutArgument +// CHECK: PointerAttr + +class [[gsl::Owner]] OwnerWithoutArgument{}; +// CHECK: CXXRecordDecl{{.*}} class OwnerWithoutArgument +// CHECK: OwnerAttr +} // namespace TestLifetimeCategories + // Verify the order of attributes in the Ast. It must reflect the order // in the parsed source. int mergeAttrTest() __attribute__((deprecated)) __attribute__((warn_unused_result)); diff --git a/clang/test/Misc/pragma-attribute-supported-attributes-list.test b/clang/test/Misc/pragma-attribute-supported-attributes-list.test --- a/clang/test/Misc/pragma-attribute-supported-attributes-list.test +++ b/clang/test/Misc/pragma-attribute-supported-attributes-list.test @@ -116,8 +116,10 @@ // CHECK-NEXT: OpenCLNoSVM (SubjectMatchRule_variable) // CHECK-NEXT: OptimizeNone (SubjectMatchRule_function, SubjectMatchRule_objc_method) // CHECK-NEXT: Overloadable (SubjectMatchRule_function) +// CHECK-NEXT: Owner (SubjectMatchRule_record) // CHECK-NEXT: ParamTypestate (SubjectMatchRule_variable_is_parameter) // CHECK-NEXT: PassObjectSize (SubjectMatchRule_variable_is_parameter) +// CHECK-NEXT: Pointer (SubjectMatchRule_record) // CHECK-NEXT: RenderScriptKernel (SubjectMatchRule_function) // CHECK-NEXT: ReqdWorkGroupSize (SubjectMatchRule_function) // CHECK-NEXT: RequireConstantInit (SubjectMatchRule_variable_is_global) diff --git a/clang/test/SemaCXX/attr-gsl-owner-pointer-parsing.cpp b/clang/test/SemaCXX/attr-gsl-owner-pointer-parsing.cpp new file mode 100644 --- /dev/null +++ b/clang/test/SemaCXX/attr-gsl-owner-pointer-parsing.cpp @@ -0,0 +1,50 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +int [[gsl::Owner]] i; +// expected-error@-1 {{'Owner' attribute cannot be applied to types}} +void [[gsl::Owner]] f(); +// expected-error@-1 {{'Owner' attribute cannot be applied to types}} + +[[gsl::Owner]] void f(); +// expected-warning@-1 {{'Owner' attribute only applies to classes}} + +struct S { +}; + +S [[gsl::Owner]] Instance; +// expected-error@-1 {{'Owner' attribute cannot be applied to types}} + +class [[gsl::Owner(7)]] OwnerDerefNoType{}; +// expected-error@-1 {{expected a type}} + +class [[gsl::Pointer("int")]] PointerDerefNoType{}; +// expected-error@-1 {{expected a type}} + +class [[gsl::Owner(int)]] [[gsl::Pointer(int)]] BothOwnerPointer{}; +// expected-error@-1 {{'Pointer' and 'Owner' attributes are not compatible}} +// expected-note@-2 {{conflicting attribute is here}} + +class [[gsl::Owner(void)]] OwnerVoidDerefType{}; +// expected-error@-1 {{'void' is an invalid argument to attribute 'Owner'}} +class [[gsl::Pointer(void)]] PointerVoidDerefType{}; +// expected-error@-1 {{'void' is an invalid argument to attribute 'Pointer'}} + +class [[gsl::Pointer(int)]] AddConflictLater{}; +class [[gsl::Owner(int)]] AddConflictLater; +// expected-error@-1 {{'Owner' and 'Pointer' attributes are not compatible}} +// expected-note@-3 {{conflicting attribute is here}} + +class [[gsl::Owner(int)]] AddConflictLater2{}; +class [[gsl::Owner(float)]] AddConflictLater2; +// expected-error@-1 {{'Owner' and 'Owner' attributes are not compatible}} +// expected-note@-3 {{conflicting attribute is here}} + +class [[gsl::Owner()]] [[gsl::Owner(int)]] WithAndWithoutParameter{}; +// expected-error@-1 {{'Owner' and 'Owner' attributes are not compatible}} +// expected-note@-2 {{conflicting attribute is here}} + +class [[gsl::Owner(int &)]] ReferenceType{}; +// expected-error@-1 {{A reference type is an invalid argument to attribute 'Owner'}} + +class [[gsl::Pointer(int[])]] ArrayType{}; +// expected-error@-1 {{An array type is an invalid argument to attribute 'Pointer'}} diff --git a/clang/test/SemaCXX/attr-gsl-owner-pointer.cpp b/clang/test/SemaCXX/attr-gsl-owner-pointer.cpp new file mode 100644 --- /dev/null +++ b/clang/test/SemaCXX/attr-gsl-owner-pointer.cpp @@ -0,0 +1,43 @@ +// RUN: %clang_cc1 -ast-dump %s | \ +// RUN: FileCheck --implicit-check-not OwnerAttr --implicit-check-not PointerAttr %s + +class [[gsl::Owner]] OwnerMissingParameter{}; +// CHECK: CXXRecordDecl {{.*}} OwnerMissingParameter +// CHECK: OwnerAttr + +class [[gsl::Pointer]] PointerMissingParameter{}; +// CHECK: CXXRecordDecl {{.*}} PointerMissingParameter +// CHECK: PointerAttr + +class [[gsl::Owner()]] OwnerWithEmptyParameterList{}; +// CHECK: CXXRecordDecl {{.*}} OwnerWithEmptyParameterList +// CHECK: OwnerAttr {{.*}} + +class [[gsl::Pointer()]] PointerWithEmptyParameterList{}; +// CHECK: CXXRecordDecl {{.*}} PointerWithEmptyParameterList +// CHECK: PointerAttr {{.*}} + +class [[gsl::Owner(int)]] AnOwner{}; +// CHECK: CXXRecordDecl {{.*}} AnOwner +// CHECK: OwnerAttr {{.*}} int + +struct S; +class [[gsl::Pointer(S)]] APointer{}; +// CHECK: CXXRecordDecl {{.*}} APointer +// CHECK: PointerAttr {{.*}} S + +class [[gsl::Owner(int)]] [[gsl::Owner(int)]] DuplicateOwner{}; +// CHECK: CXXRecordDecl {{.*}} DuplicateOwner +// CHECK: OwnerAttr {{.*}} int + +class [[gsl::Pointer(int)]] [[gsl::Pointer(int)]] DuplicatePointer{}; +// CHECK: CXXRecordDecl {{.*}} DuplicatePointer +// CHECK: PointerAttr {{.*}} int + +class [[gsl::Owner(int)]] AddTheSameLater{}; +// CHECK: CXXRecordDecl {{.*}} AddTheSameLater +// CHECK: OwnerAttr {{.*}} int + +class [[gsl::Owner(int)]] AddTheSameLater; +// CHECK: CXXRecordDecl {{.*}} prev {{.*}} AddTheSameLater +// CHECK: OwnerAttr {{.*}} int diff --git a/clang/utils/TableGen/ClangAttrEmitter.cpp b/clang/utils/TableGen/ClangAttrEmitter.cpp --- a/clang/utils/TableGen/ClangAttrEmitter.cpp +++ b/clang/utils/TableGen/ClangAttrEmitter.cpp @@ -303,6 +303,8 @@ std::string getIsOmitted() const override { if (type == "IdentifierInfo *") return "!get" + getUpperName().str() + "()"; + if (type == "TypeSourceInfo *") + return "!get" + getUpperName().str() + "Loc()"; if (type == "ParamIdx") return "!get" + getUpperName().str() + "().isValid()"; return "false"; @@ -336,6 +338,8 @@ << " OS << \" \" << SA->get" << getUpperName() << "()->getName();\n"; } else if (type == "TypeSourceInfo *") { + if (isOptional()) + OS << " if (SA->get" << getUpperName() << "Loc())"; OS << " OS << \" \" << SA->get" << getUpperName() << "().getAsString();\n"; } else if (type == "bool") {