maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Accept [[gnu::*]] for all __attribute__((*))s which are: 

1) Supported by Clang, and
 2) Supported by GCC, and
 3) Documented in GCC's manual.

g++ allows its C++11-style attributes to appertain only to the entity being
declared, and never to a type (even for a type attribute), so we do the same.

llvm-svn: 172382
This commit is contained in:
Richard Smith 2013-01-14 07:53:01 +00:00
parent 3d462f89de
commit 368ca52cd9
4 changed files with 94 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
clang/include/clang/Basic/Attr.td
View File

@ -29,7 +29,7 @@ class SubsetSubject<AttrSubject base, string description, code check>
code CheckCode = check; code CheckCode = check;
} }
// This is the type of a variable which C++0x defines [[aligned()]] as being // This is the type of a variable which C++11 defines [[aligned()]] as being
// a possible subject. // a possible subject.
def NormalVar : SubsetSubject<Var, "non-register, non-parameter variable", def NormalVar : SubsetSubject<Var, "non-register, non-parameter variable",
[{S->getStorageClass() != VarDecl::Register && [{S->getStorageClass() != VarDecl::Register &&
@ -136,12 +136,12 @@ def AddressSpace : Attr {
} }
def Alias : InheritableAttr { def Alias : InheritableAttr {
let Spellings = [GNU<"alias">]; let Spellings = [GNU<"alias">, CXX11<"gnu", "alias">];
let Args = [StringArgument<"Aliasee">]; let Args = [StringArgument<"Aliasee">];
} }
def Aligned : InheritableAttr { def Aligned : InheritableAttr {
let Spellings = [GNU<"aligned">, GNU<"align">]; let Spellings = [GNU<"aligned">, GNU<"align">, CXX11<"gnu", "aligned">];
let Subjects = [NonBitField, NormalVar, Tag]; let Subjects = [NonBitField, NormalVar, Tag];
let Args = [AlignedArgument<"Alignment">, BoolArgument<"IsMSDeclSpec">]; let Args = [AlignedArgument<"Alignment">, BoolArgument<"IsMSDeclSpec">];
} }
@ -152,16 +152,16 @@ def AlignMac68k : InheritableAttr {
} }
def AllocSize : Attr { def AllocSize : Attr {
let Spellings = [GNU<"alloc_size">]; let Spellings = [GNU<"alloc_size">, CXX11<"gnu", "alloc_size">];
let Args = [VariadicUnsignedArgument<"Args">]; let Args = [VariadicUnsignedArgument<"Args">];
} }
def AlwaysInline : InheritableAttr { def AlwaysInline : InheritableAttr {
let Spellings = [GNU<"always_inline">]; let Spellings = [GNU<"always_inline">, CXX11<"gnu", "always_inline">];
} }
def TLSModel : InheritableAttr { def TLSModel : InheritableAttr {
let Spellings = [GNU<"tls_model">]; let Spellings = [GNU<"tls_model">, CXX11<"gnu", "tls_model">];
let Subjects = [Var]; let Subjects = [Var];
let Args = [StringArgument<"Model">]; let Args = [StringArgument<"Model">];
} }
@ -214,7 +214,7 @@ def CarriesDependency : InheritableParamAttr {
} }
def CDecl : InheritableAttr { def CDecl : InheritableAttr {
let Spellings = [GNU<"cdecl">, GNU<"__cdecl">]; let Spellings = [GNU<"cdecl">, GNU<"__cdecl">, CXX11<"gnu", "cdecl">];
} }
// cf_audited_transfer indicates that the given function has been // cf_audited_transfer indicates that the given function has been
@ -250,24 +250,24 @@ def CFConsumed : InheritableParamAttr {
} }
def Cleanup : InheritableAttr { def Cleanup : InheritableAttr {
let Spellings = [GNU<"cleanup">]; let Spellings = [GNU<"cleanup">, CXX11<"gnu", "cleanup">];
let Args = [FunctionArgument<"FunctionDecl">]; let Args = [FunctionArgument<"FunctionDecl">];
} }
def Cold : InheritableAttr { def Cold : InheritableAttr {
let Spellings = [GNU<"cold">]; let Spellings = [GNU<"cold">, CXX11<"gnu", "cold">];
} }
def Common : InheritableAttr { def Common : InheritableAttr {
let Spellings = [GNU<"common">]; let Spellings = [GNU<"common">, CXX11<"gnu", "common">];
} }
def Const : InheritableAttr { def Const : InheritableAttr {
let Spellings = [GNU<"const">, GNU<"__const">]; let Spellings = [GNU<"const">, GNU<"__const">, CXX11<"gnu", "const">];
} }
def Constructor : InheritableAttr { def Constructor : InheritableAttr {
let Spellings = [GNU<"constructor">]; let Spellings = [GNU<"constructor">, CXX11<"gnu", "constructor">];
let Args = [IntArgument<"Priority">]; let Args = [IntArgument<"Priority">];
} }
@ -307,12 +307,12 @@ def OpenCLImageAccess : Attr {
} }
def Deprecated : InheritableAttr { def Deprecated : InheritableAttr {
let Spellings = [GNU<"deprecated">]; let Spellings = [GNU<"deprecated">, CXX11<"gnu", "deprecated">];
let Args = [StringArgument<"Message">]; let Args = [StringArgument<"Message">];
} }
def Destructor : InheritableAttr { def Destructor : InheritableAttr {
let Spellings = [GNU<"destructor">]; let Spellings = [GNU<"destructor">, CXX11<"gnu", "destructor">];
let Args = [IntArgument<"Priority">]; let Args = [IntArgument<"Priority">];
} }
@ -323,12 +323,13 @@ def ExtVectorType : Attr {
} }
def FallThrough : Attr { def FallThrough : Attr {
let Spellings = [CXX11<"clang","fallthrough">]; let Spellings = [CXX11<"clang", "fallthrough">];
let Subjects = [NullStmt]; let Subjects = [NullStmt];
} }
def FastCall : InheritableAttr { def FastCall : InheritableAttr {
let Spellings = [GNU<"fastcall">, GNU<"__fastcall">]; let Spellings = [GNU<"fastcall">, GNU<"__fastcall">,
CXX11<"gnu", "fastcall">];
} }
def Final : InheritableAttr { def Final : InheritableAttr {
@ -342,22 +343,22 @@ def MinSize : InheritableAttr {
} }
def Format : InheritableAttr { def Format : InheritableAttr {
let Spellings = [GNU<"format">]; let Spellings = [GNU<"format">, CXX11<"gnu", "format">];
let Args = [StringArgument<"Type">, IntArgument<"FormatIdx">, let Args = [StringArgument<"Type">, IntArgument<"FormatIdx">,
IntArgument<"FirstArg">]; IntArgument<"FirstArg">];
} }
def FormatArg : InheritableAttr { def FormatArg : InheritableAttr {
let Spellings = [GNU<"format_arg">]; let Spellings = [GNU<"format_arg">, CXX11<"gnu", "format_arg">];
let Args = [IntArgument<"FormatIdx">]; let Args = [IntArgument<"FormatIdx">];
} }
def GNUInline : InheritableAttr { def GNUInline : InheritableAttr {
let Spellings = [GNU<"gnu_inline">]; let Spellings = [GNU<"gnu_inline">, CXX11<"gnu", "gnu_inline">];
} }
def Hot : InheritableAttr { def Hot : InheritableAttr {
let Spellings = [GNU<"hot">]; let Spellings = [GNU<"hot">, CXX11<"gnu", "hot">];
} }
def IBAction : InheritableAttr { def IBAction : InheritableAttr {
@ -374,7 +375,7 @@ def IBOutletCollection : InheritableAttr {
} }
def Malloc : InheritableAttr { def Malloc : InheritableAttr {
let Spellings = [GNU<"malloc">]; let Spellings = [GNU<"malloc">, CXX11<"gnu", "malloc">];
} }
def MaxFieldAlignment : InheritableAttr { def MaxFieldAlignment : InheritableAttr {
@ -384,7 +385,7 @@ def MaxFieldAlignment : InheritableAttr {
} }
def MayAlias : InheritableAttr { def MayAlias : InheritableAttr {
let Spellings = [GNU<"may_alias">]; let Spellings = [GNU<"may_alias">, CXX11<"gnu", "may_alias">];
} }
def MSP430Interrupt : InheritableAttr { def MSP430Interrupt : InheritableAttr {
@ -404,13 +405,13 @@ def MBlazeSaveVolatiles : InheritableAttr {
} }
def Mode : Attr { def Mode : Attr {
let Spellings = [GNU<"mode">]; let Spellings = [GNU<"mode">, CXX11<"gnu", "mode">];
let Args = [IdentifierArgument<"Mode">]; let Args = [IdentifierArgument<"Mode">];
let ASTNode = 0; let ASTNode = 0;
} }
def Naked : InheritableAttr { def Naked : InheritableAttr {
let Spellings = [GNU<"naked">]; let Spellings = [GNU<"naked">, CXX11<"gnu", "naked">];
} }
def NeonPolyVectorType : Attr { def NeonPolyVectorType : Attr {
@ -426,11 +427,11 @@ def NeonVectorType : Attr {
} }
def ReturnsTwice : InheritableAttr { def ReturnsTwice : InheritableAttr {
let Spellings = [GNU<"returns_twice">]; let Spellings = [GNU<"returns_twice">, CXX11<"gnu", "returns_twice">];
} }
def NoCommon : InheritableAttr { def NoCommon : InheritableAttr {
let Spellings = [GNU<"nocommon">]; let Spellings = [GNU<"nocommon">, CXX11<"gnu", "nocommon">];
} }
def NoDebug : InheritableAttr { def NoDebug : InheritableAttr {
@ -438,11 +439,11 @@ def NoDebug : InheritableAttr {
} }
def NoInline : InheritableAttr { def NoInline : InheritableAttr {
let Spellings = [GNU<"noinline">]; let Spellings = [GNU<"noinline">, CXX11<"gnu", "noinline">];
} }
def NonNull : InheritableAttr { def NonNull : InheritableAttr {
let Spellings = [GNU<"nonnull">]; let Spellings = [GNU<"nonnull">, CXX11<"gnu", "nonnull">];
let Args = [VariadicUnsignedArgument<"Args">]; let Args = [VariadicUnsignedArgument<"Args">];
let AdditionalMembers = let AdditionalMembers =
[{bool isNonNull(unsigned idx) const { [{bool isNonNull(unsigned idx) const {
@ -455,19 +456,20 @@ def NonNull : InheritableAttr {
} }
def NoReturn : InheritableAttr { def NoReturn : InheritableAttr {
let Spellings = [GNU<"noreturn">, CXX11<"","noreturn">, let Spellings = [GNU<"noreturn">, CXX11<"gnu", "noreturn">,
CXX11<"std","noreturn">]; CXX11<"", "noreturn">, CXX11<"std", "noreturn">];
// FIXME: Does GCC allow this on the function instead? // FIXME: Does GCC allow this on the function instead?
let Subjects = [Function]; let Subjects = [Function];
} }
def NoInstrumentFunction : InheritableAttr { def NoInstrumentFunction : InheritableAttr {
let Spellings = [GNU<"no_instrument_function">]; let Spellings = [GNU<"no_instrument_function">,
CXX11<"gnu", "no_instrument_function">];
let Subjects = [Function]; let Subjects = [Function];
} }
def NoThrow : InheritableAttr { def NoThrow : InheritableAttr {
let Spellings = [GNU<"nothrow">]; let Spellings = [GNU<"nothrow">, CXX11<"gnu", "nothrow">];
} }
def NSBridged : InheritableAttr { def NSBridged : InheritableAttr {
@ -558,7 +560,7 @@ def Ownership : InheritableAttr {
} }
def Packed : InheritableAttr { def Packed : InheritableAttr {
let Spellings = [GNU<"packed">]; let Spellings = [GNU<"packed">, CXX11<"gnu", "packed">];
} }
def PnaclCall : InheritableAttr { def PnaclCall : InheritableAttr {
@ -570,18 +572,18 @@ def IntelOclBicc : InheritableAttr {
} }
def Pcs : InheritableAttr { def Pcs : InheritableAttr {
let Spellings = [GNU<"pcs">]; let Spellings = [GNU<"pcs">, CXX11<"gnu", "pcs">];
let Args = [EnumArgument<"PCS", "PCSType", let Args = [EnumArgument<"PCS", "PCSType",
["aapcs", "aapcs-vfp"], ["aapcs", "aapcs-vfp"],
["AAPCS", "AAPCS_VFP"]>]; ["AAPCS", "AAPCS_VFP"]>];
} }
def Pure : InheritableAttr { def Pure : InheritableAttr {
let Spellings = [GNU<"pure">]; let Spellings = [GNU<"pure">, CXX11<"gnu", "pure">];
} }
def Regparm : InheritableAttr { def Regparm : InheritableAttr {
let Spellings = [GNU<"regparm">]; let Spellings = [GNU<"regparm">, CXX11<"gnu", "regparm">];
let Args = [UnsignedArgument<"NumParams">]; let Args = [UnsignedArgument<"NumParams">];
} }
@ -604,22 +606,23 @@ def InitPriority : InheritableAttr {
} }
def Section : InheritableAttr { def Section : InheritableAttr {
let Spellings = [GNU<"section">]; let Spellings = [GNU<"section">, CXX11<"gnu", "section">];
let Args = [StringArgument<"Name">]; let Args = [StringArgument<"Name">];
} }
def Sentinel : InheritableAttr { def Sentinel : InheritableAttr {
let Spellings = [GNU<"sentinel">]; let Spellings = [GNU<"sentinel">, CXX11<"gnu", "sentinel">];
let Args = [DefaultIntArgument<"Sentinel", 0>, let Args = [DefaultIntArgument<"Sentinel", 0>,
DefaultIntArgument<"NullPos", 0>]; DefaultIntArgument<"NullPos", 0>];
} }
def StdCall : InheritableAttr { def StdCall : InheritableAttr {
let Spellings = [GNU<"stdcall">, GNU<"__stdcall">]; let Spellings = [GNU<"stdcall">, GNU<"__stdcall">, CXX11<"gnu", "stdcall">];
} }
def ThisCall : InheritableAttr { def ThisCall : InheritableAttr {
let Spellings = [GNU<"thiscall">, GNU<"__thiscall">]; let Spellings = [GNU<"thiscall">, GNU<"__thiscall">,
CXX11<"gnu", "thiscall">];
} }
def Pascal : InheritableAttr { def Pascal : InheritableAttr {
@ -627,7 +630,7 @@ def Pascal : InheritableAttr {
} }
def TransparentUnion : InheritableAttr { def TransparentUnion : InheritableAttr {
let Spellings = [GNU<"transparent_union">]; let Spellings = [GNU<"transparent_union">, CXX11<"gnu", "transparent_union">];
} }
def Unavailable : InheritableAttr { def Unavailable : InheritableAttr {
@ -658,11 +661,11 @@ def ObjCRequiresPropertyDefs : InheritableAttr {
} }
def Unused : InheritableAttr { def Unused : InheritableAttr {
let Spellings = [GNU<"unused">]; let Spellings = [GNU<"unused">, CXX11<"gnu", "unused">];
} }
def Used : InheritableAttr { def Used : InheritableAttr {
let Spellings = [GNU<"used">]; let Spellings = [GNU<"used">, CXX11<"gnu", "used">];
} }
def Uuid : InheritableAttr { def Uuid : InheritableAttr {
@ -672,7 +675,7 @@ def Uuid : InheritableAttr {
} }
def VectorSize : Attr { def VectorSize : Attr {
let Spellings = [GNU<"vector_size">]; let Spellings = [GNU<"vector_size">, CXX11<"gnu", "vector_size">];
let Args = [ExprArgument<"NumBytes">]; let Args = [ExprArgument<"NumBytes">];
let ASTNode = 0; let ASTNode = 0;
} }
@ -686,7 +689,7 @@ def VecTypeHint : Attr {
def Visibility : InheritableAttr { def Visibility : InheritableAttr {
let Clone = 0; let Clone = 0;
let Spellings = [GNU<"visibility">]; let Spellings = [GNU<"visibility">, CXX11<"gnu", "visibility">];
let Args = [EnumArgument<"Visibility", "VisibilityType", let Args = [EnumArgument<"Visibility", "VisibilityType",
["default", "hidden", "internal", "protected"], ["default", "hidden", "internal", "protected"],
["Default", "Hidden", "Hidden", "Protected"]>]; ["Default", "Hidden", "Hidden", "Protected"]>];
@ -698,11 +701,13 @@ def VecReturn : InheritableAttr {
} }
def WarnUnusedResult : InheritableAttr { def WarnUnusedResult : InheritableAttr {
let Spellings = [GNU<"warn_unused_result">, CXX11<"clang","warn_unused_result">]; let Spellings = [GNU<"warn_unused_result">,
CXX11<"clang", "warn_unused_result">,
CXX11<"gnu", "warn_unused_result">];
} }
def Weak : InheritableAttr { def Weak : InheritableAttr {
let Spellings = [GNU<"weak">]; let Spellings = [GNU<"weak">, CXX11<"gnu", "weak">];
} }
def WeakImport : InheritableAttr { def WeakImport : InheritableAttr {
@ -710,7 +715,7 @@ def WeakImport : InheritableAttr {
} }
def WeakRef : InheritableAttr { def WeakRef : InheritableAttr {
let Spellings = [GNU<"weakref">]; let Spellings = [GNU<"weakref">, CXX11<"gnu", "weakref">];
} }
def X86ForceAlignArgPointer : InheritableAttr { def X86ForceAlignArgPointer : InheritableAttr {

3
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -1761,6 +1761,9 @@ def warn_attribute_after_definition_ignored : Warning<
InGroup<IgnoredAttributes>; InGroup<IgnoredAttributes>;
def warn_unknown_attribute_ignored : Warning< def warn_unknown_attribute_ignored : Warning<
"unknown attribute %0 ignored">, InGroup<UnknownAttributes>; "unknown attribute %0 ignored">, InGroup<UnknownAttributes>;
def warn_cxx11_gnu_attribute_on_type : Warning<
"attribute %0 ignored, because it cannot be applied to a type">,
InGroup<IgnoredAttributes>;
def warn_unhandled_ms_attribute_ignored : Warning< def warn_unhandled_ms_attribute_ignored : Warning<
"__declspec attribute %0 is not supported">, "__declspec attribute %0 is not supported">,
InGroup<IgnoredAttributes>; InGroup<IgnoredAttributes>;

38
clang/lib/Sema/SemaType.cpp
View File

@ -270,8 +270,18 @@ static void moveAttrFromListToList(AttributeList &attr,
spliceAttrIntoList(attr, toList); spliceAttrIntoList(attr, toList);
} }
/// The location of a type attribute.
enum TypeAttrLocation {
/// The attribute is in the decl-specifier-seq.
TAL_DeclSpec,
/// The attribute is part of a DeclaratorChunk.
TAL_DeclChunk,
/// The attribute is immediately after the declaration's name.
TAL_DeclName
};
static void processTypeAttrs(TypeProcessingState &state, static void processTypeAttrs(TypeProcessingState &state,
QualType &type, bool isDeclSpec, QualType &type, TypeAttrLocation TAL,
AttributeList *attrs); AttributeList *attrs);
static bool handleFunctionTypeAttr(TypeProcessingState &state, static bool handleFunctionTypeAttr(TypeProcessingState &state,
@ -963,7 +973,7 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
// list of type attributes to be temporarily saved while the type // list of type attributes to be temporarily saved while the type
// attributes are pushed around. // attributes are pushed around.
if (AttributeList *attrs = DS.getAttributes().getList()) if (AttributeList *attrs = DS.getAttributes().getList())
processTypeAttrs(state, Result, true, attrs); processTypeAttrs(state, Result, TAL_DeclSpec, attrs);
// Apply const/volatile/restrict qualifiers to T. // Apply const/volatile/restrict qualifiers to T.
if (unsigned TypeQuals = DS.getTypeQualifiers()) { if (unsigned TypeQuals = DS.getTypeQualifiers()) {
@ -1859,7 +1869,7 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
// "void" instead. // "void" instead.
T = SemaRef.Context.VoidTy; T = SemaRef.Context.VoidTy;
if (AttributeList *attrs = D.getDeclSpec().getAttributes().getList()) if (AttributeList *attrs = D.getDeclSpec().getAttributes().getList())
processTypeAttrs(state, T, true, attrs); processTypeAttrs(state, T, TAL_DeclSpec, attrs);
break; break;
case UnqualifiedId::IK_ConversionFunctionId: case UnqualifiedId::IK_ConversionFunctionId:
@ -2665,7 +2675,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
// See if there are any attributes on this declarator chunk. // See if there are any attributes on this declarator chunk.
if (AttributeList *attrs = const_cast<AttributeList*>(DeclType.getAttrs())) if (AttributeList *attrs = const_cast<AttributeList*>(DeclType.getAttrs()))
processTypeAttrs(state, T, false, attrs); processTypeAttrs(state, T, TAL_DeclChunk, attrs);
} }
if (LangOpts.CPlusPlus && T->isFunctionType()) { if (LangOpts.CPlusPlus && T->isFunctionType()) {
@ -2753,7 +2763,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
// Apply any undistributed attributes from the declarator. // Apply any undistributed attributes from the declarator.
if (!T.isNull()) if (!T.isNull())
if (AttributeList *attrs = D.getAttributes()) if (AttributeList *attrs = D.getAttributes())
processTypeAttrs(state, T, false, attrs); processTypeAttrs(state, T, TAL_DeclName, attrs);
// Diagnose any ignored type attributes. // Diagnose any ignored type attributes.
if (!T.isNull()) state.diagnoseIgnoredTypeAttrs(T); if (!T.isNull()) state.diagnoseIgnoredTypeAttrs(T);
@ -4150,7 +4160,7 @@ static void HandleNeonVectorTypeAttr(QualType& CurType,
} }
static void processTypeAttrs(TypeProcessingState &state, QualType &type, static void processTypeAttrs(TypeProcessingState &state, QualType &type,
bool isDeclSpec, AttributeList *attrs) { TypeAttrLocation TAL, AttributeList *attrs) {
// Scan through and apply attributes to this type where it makes sense. Some // Scan through and apply attributes to this type where it makes sense. Some
// attributes (such as __address_space__, __vector_size__, etc) apply to the // attributes (such as __address_space__, __vector_size__, etc) apply to the
// type, but others can be present in the type specifiers even though they // type, but others can be present in the type specifiers even though they
@ -4165,6 +4175,20 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type,
if (attr.isInvalid()) if (attr.isInvalid())
continue; continue;
// [[gnu::...]] attributes are treated as declaration attributes, so may
// not appertain to a DeclaratorChunk, even if we handle them as type
// attributes.
// FIXME: All other C++11 type attributes may *only* appertain to a type,
// and should only be considered here if they appertain to a
// DeclaratorChunk.
if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk &&
attr.getScopeName() && attr.getScopeName()->isStr("gnu")) {
state.getSema().Diag(attr.getLoc(),
diag::warn_cxx11_gnu_attribute_on_type)
<< attr.getName();
continue;
}
// If this is an attribute we can handle, do so now, // If this is an attribute we can handle, do so now,
// otherwise, add it to the FnAttrs list for rechaining. // otherwise, add it to the FnAttrs list for rechaining.
switch (attr.getKind()) { switch (attr.getKind()) {
@ -4225,7 +4249,7 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type,
// Never process function type attributes as part of the // Never process function type attributes as part of the
// declaration-specifiers. // declaration-specifiers.
if (isDeclSpec) if (TAL == TAL_DeclSpec)
distributeFunctionTypeAttrFromDeclSpec(state, attr, type); distributeFunctionTypeAttrFromDeclSpec(state, attr, type);
// Otherwise, handle the possible delays. // Otherwise, handle the possible delays.

10
clang/test/Parser/cxx0x-attributes.cpp
View File

@ -247,14 +247,18 @@ enum class __attribute__((visibility("hidden"))) SecretKeepers {
enum class [[]] EvenMoreSecrets {}; enum class [[]] EvenMoreSecrets {};
namespace arguments { namespace arguments {
// FIXME: remove the sema warnings after migrating existing gnu attributes to c++11 syntax. void f[[gnu::format(printf, 1, 2)]](const char*, ...);
void f(const char*, ...) [[gnu::format(printf, 1, 2)]]; // expected-warning {{unknown attribute 'format' ignored}}
void g() [[unknown::foo(currently arguments of attributes from unknown namespace other than 'gnu' namespace are ignored... blah...)]]; // expected-warning {{unknown attribute 'foo' ignored}} void g() [[unknown::foo(currently arguments of attributes from unknown namespace other than 'gnu' namespace are ignored... blah...)]]; // expected-warning {{unknown attribute 'foo' ignored}}
} }
// forbid attributes on decl specifiers // Forbid attributes on decl specifiers.
unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-warning {{attribute 'unused' ignored, because it is not attached to a declaration}} \ unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-warning {{attribute 'unused' ignored, because it is not attached to a declaration}} \
expected-error {{an attribute list cannot appear here}} expected-error {{an attribute list cannot appear here}}
typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-warning {{attribute 'unused' ignored, because it is not attached to a declaration}} \ typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-warning {{attribute 'unused' ignored, because it is not attached to a declaration}} \
expected-error {{an attribute list cannot appear here}} expected-error {{an attribute list cannot appear here}}
int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-warning 2{{attribute 'carries_dependency' ignored, because it is not attached to a declaration}} int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-warning 2{{attribute 'carries_dependency' ignored, because it is not attached to a declaration}}
// Forbid [[gnu::...]] attributes on declarator chunks.
int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}}
int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}