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

Add a new attribute definition spelling, Clang<"attr">, that expands to two attribute spellings: GNU<"attr"> and CXX11<"clang", "attr">. This is similar to how the GCC spelling works and is intended to be used for attributes introduced for Clang. 

Changes all existing attributes that currently use GNU<"attr"> and CXX11<"clang", "attr> spellings to instead use the Clang<"attr"> spelling.

No additional tests are necessary because the existing tests already use both spellings for the attributes converted to the new spelling. No functional changes are expected.

llvm-svn: 316658
This commit is contained in:
Aaron Ballman 2017-10-26 12:19:02 +00:00
parent 7f6e910745
commit ffc4336665
2 changed files with 53 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -219,13 +219,17 @@ class Pragma<string namespace, string name> : Spelling<name, "Pragma"> {
string Namespace = namespace; string Namespace = namespace;
} }
// The GCC spelling implies GNU<name, "GNU"> and CXX11<"gnu", name> and also // The GCC spelling implies GNU<name> and CXX11<"gnu", name> and also sets
// sets KnownToGCC to 1. This spelling should be used for any GCC-compatible // KnownToGCC to 1. This spelling should be used for any GCC-compatible
// attributes. // attributes.
class GCC<string name> : Spelling<name, "GCC"> { class GCC<string name> : Spelling<name, "GCC"> {
let KnownToGCC = 1; let KnownToGCC = 1;
} }
// The Clang spelling implies GNU<name> and CXX11<"clang", name>. This spelling
// should be used for any Clang-specific attributes.
class Clang<string name> : Spelling<name, "Clang">;
class Accessor<string name, list<Spelling> spellings> { class Accessor<string name, list<Spelling> spellings> {
string Name = name; string Name = name;
list<Spelling> Spellings = spellings; list<Spelling> Spellings = spellings;
@ -563,23 +567,19 @@ def AlwaysInline : InheritableAttr {
} }
def XRayInstrument : InheritableAttr { def XRayInstrument : InheritableAttr {
let Spellings = [GNU<"xray_always_instrument">, let Spellings = [Clang<"xray_always_instrument">,
CXX11<"clang", "xray_always_instrument">, Clang<"xray_never_instrument">];
GNU<"xray_never_instrument">,
CXX11<"clang", "xray_never_instrument">];
let Subjects = SubjectList<[CXXMethod, ObjCMethod, Function], WarnDiag, let Subjects = SubjectList<[CXXMethod, ObjCMethod, Function], WarnDiag,
"ExpectedFunctionOrMethod">; "ExpectedFunctionOrMethod">;
let Accessors = [Accessor<"alwaysXRayInstrument", let Accessors = [Accessor<"alwaysXRayInstrument",
[GNU<"xray_always_instrument">, [Clang<"xray_always_instrument">]>,
CXX11<"clang", "xray_always_instrument">]>,
Accessor<"neverXRayInstrument", Accessor<"neverXRayInstrument",
[GNU<"xray_never_instrument">, [Clang<"xray_never_instrument">]>];
CXX11<"clang", "xray_never_instrument">]>];
let Documentation = [XRayDocs]; let Documentation = [XRayDocs];
} }
def XRayLogArgs : InheritableAttr { def XRayLogArgs : InheritableAttr {
let Spellings = [GNU<"xray_log_args">, CXX11<"clang", "xray_log_args">]; let Spellings = [Clang<"xray_log_args">];
let Subjects = SubjectList< let Subjects = SubjectList<
[CXXMethod, ObjCMethod, Function], WarnDiag, "ExpectedFunctionOrMethod" [CXXMethod, ObjCMethod, Function], WarnDiag, "ExpectedFunctionOrMethod"
>; >;
@ -692,8 +692,7 @@ static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
} }
def ExternalSourceSymbol : InheritableAttr { def ExternalSourceSymbol : InheritableAttr {
let Spellings = [GNU<"external_source_symbol">, let Spellings = [Clang<"external_source_symbol">];
CXX11<"clang", "external_source_symbol">];
let Args = [StringArgument<"language", 1>, let Args = [StringArgument<"language", 1>,
StringArgument<"definedIn", 1>, StringArgument<"definedIn", 1>,
BoolArgument<"generatedDeclaration", 1>]; BoolArgument<"generatedDeclaration", 1>];
@ -1047,8 +1046,7 @@ def FlagEnum : InheritableAttr {
} }
def EnumExtensibility : InheritableAttr { def EnumExtensibility : InheritableAttr {
let Spellings = [GNU<"enum_extensibility">, let Spellings = [Clang<"enum_extensibility">];
CXX11<"clang", "enum_extensibility">];
let Subjects = SubjectList<[Enum]>; let Subjects = SubjectList<[Enum]>;
let Args = [EnumArgument<"Extensibility", "Kind", let Args = [EnumArgument<"Extensibility", "Kind",
["closed", "open"], ["Closed", "Open"]>]; ["closed", "open"], ["Closed", "Open"]>];
@ -1238,8 +1236,7 @@ def ReturnsTwice : InheritableAttr {
} }
def DisableTailCalls : InheritableAttr { def DisableTailCalls : InheritableAttr {
let Spellings = [GNU<"disable_tail_calls">, let Spellings = [Clang<"disable_tail_calls">];
CXX11<"clang", "disable_tail_calls">];
let Subjects = SubjectList<[Function, ObjCMethod]>; let Subjects = SubjectList<[Function, ObjCMethod]>;
let Documentation = [DisableTailCallsDocs]; let Documentation = [DisableTailCallsDocs];
} }
@ -1264,13 +1261,13 @@ def NoDebug : InheritableAttr {
} }
def NoDuplicate : InheritableAttr { def NoDuplicate : InheritableAttr {
let Spellings = [GNU<"noduplicate">, CXX11<"clang", "noduplicate">]; let Spellings = [Clang<"noduplicate">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let Documentation = [NoDuplicateDocs]; let Documentation = [NoDuplicateDocs];
} }
def Convergent : InheritableAttr { def Convergent : InheritableAttr {
let Spellings = [GNU<"convergent">, CXX11<"clang", "convergent">]; let Spellings = [Clang<"convergent">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let Documentation = [ConvergentDocs]; let Documentation = [ConvergentDocs];
} }
@ -1401,7 +1398,7 @@ def ObjCKindOf : TypeAttr {
} }
def NoEscape : Attr { def NoEscape : Attr {
let Spellings = [GNU<"noescape">, CXX11<"clang", "noescape">]; let Spellings = [Clang<"noescape">];
let Subjects = SubjectList<[ParmVar]>; let Subjects = SubjectList<[ParmVar]>;
let Documentation = [NoEscapeDocs]; let Documentation = [NoEscapeDocs];
} }
@ -1434,7 +1431,7 @@ def NoInstrumentFunction : InheritableAttr {
} }
def NotTailCalled : InheritableAttr { def NotTailCalled : InheritableAttr {
let Spellings = [GNU<"not_tail_called">, CXX11<"clang", "not_tail_called">]; let Spellings = [Clang<"not_tail_called">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let Documentation = [NotTailCalledDocs]; let Documentation = [NotTailCalledDocs];
} }
@ -1596,7 +1593,7 @@ def ObjCBoxable : Attr {
} }
def OptimizeNone : InheritableAttr { def OptimizeNone : InheritableAttr {
let Spellings = [GNU<"optnone">, CXX11<"clang", "optnone">]; let Spellings = [Clang<"optnone">];
let Subjects = SubjectList<[Function, ObjCMethod]>; let Subjects = SubjectList<[Function, ObjCMethod]>;
let Documentation = [OptnoneDocs]; let Documentation = [OptnoneDocs];
} }
@ -1674,8 +1671,7 @@ def ReqdWorkGroupSize : InheritableAttr {
} }
def RequireConstantInit : InheritableAttr { def RequireConstantInit : InheritableAttr {
let Spellings = [GNU<"require_constant_initialization">, let Spellings = [Clang<"require_constant_initialization">];
CXX11<"clang", "require_constant_initialization">];
let Subjects = SubjectList<[GlobalVar], ErrorDiag, let Subjects = SubjectList<[GlobalVar], ErrorDiag,
"ExpectedStaticOrTLSVar">; "ExpectedStaticOrTLSVar">;
let Documentation = [RequireConstantInitDocs]; let Documentation = [RequireConstantInitDocs];
@ -1984,7 +1980,7 @@ def Visibility : InheritableAttr {
def TypeVisibility : InheritableAttr { def TypeVisibility : InheritableAttr {
let Clone = 0; let Clone = 0;
let Spellings = [GNU<"type_visibility">, CXX11<"clang", "type_visibility">]; let Spellings = [Clang<"type_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"]>];
@ -2063,7 +2059,7 @@ def X86ForceAlignArgPointer : InheritableAttr, TargetSpecificAttr<TargetAnyX86>
} }
def NoSanitize : InheritableAttr { def NoSanitize : InheritableAttr {
let Spellings = [GNU<"no_sanitize">, CXX11<"clang", "no_sanitize">]; let Spellings = [Clang<"no_sanitize">];
let Args = [VariadicStringArgument<"Sanitizers">]; let Args = [VariadicStringArgument<"Sanitizers">];
let Subjects = SubjectList<[Function, ObjCMethod, GlobalVar], ErrorDiag, let Subjects = SubjectList<[Function, ObjCMethod, GlobalVar], ErrorDiag,
"ExpectedFunctionMethodOrGlobalVar">; "ExpectedFunctionMethodOrGlobalVar">;
@ -2125,15 +2121,12 @@ def ScopedLockable : InheritableAttr {
} }
def Capability : InheritableAttr { def Capability : InheritableAttr {
let Spellings = [GNU<"capability">, CXX11<"clang", "capability">, let Spellings = [Clang<"capability">, Clang<"shared_capability">];
GNU<"shared_capability">,
CXX11<"clang", "shared_capability">];
let Subjects = SubjectList<[Record, TypedefName], ErrorDiag, let Subjects = SubjectList<[Record, TypedefName], ErrorDiag,
"ExpectedStructOrUnionOrTypedef">; "ExpectedStructOrUnionOrTypedef">;
let Args = [StringArgument<"Name">]; let Args = [StringArgument<"Name">];
let Accessors = [Accessor<"isShared", let Accessors = [Accessor<"isShared",
[GNU<"shared_capability">, [Clang<"shared_capability">]>];
CXX11<"clang","shared_capability">]>];
let Documentation = [Undocumented]; let Documentation = [Undocumented];
let AdditionalMembers = [{ let AdditionalMembers = [{
bool isMutex() const { return getName().equals_lower("mutex"); } bool isMutex() const { return getName().equals_lower("mutex"); }
@ -2142,10 +2135,8 @@ def Capability : InheritableAttr {
} }
def AssertCapability : InheritableAttr { def AssertCapability : InheritableAttr {
let Spellings = [GNU<"assert_capability">, let Spellings = [Clang<"assert_capability">,
CXX11<"clang", "assert_capability">, Clang<"assert_shared_capability">];
GNU<"assert_shared_capability">,
CXX11<"clang", "assert_shared_capability">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let LateParsed = 1; let LateParsed = 1;
let TemplateDependent = 1; let TemplateDependent = 1;
@ -2153,16 +2144,13 @@ def AssertCapability : InheritableAttr {
let DuplicatesAllowedWhileMerging = 1; let DuplicatesAllowedWhileMerging = 1;
let Args = [VariadicExprArgument<"Args">]; let Args = [VariadicExprArgument<"Args">];
let Accessors = [Accessor<"isShared", let Accessors = [Accessor<"isShared",
[GNU<"assert_shared_capability">, [Clang<"assert_shared_capability">]>];
CXX11<"clang", "assert_shared_capability">]>];
let Documentation = [AssertCapabilityDocs]; let Documentation = [AssertCapabilityDocs];
} }
def AcquireCapability : InheritableAttr { def AcquireCapability : InheritableAttr {
let Spellings = [GNU<"acquire_capability">, let Spellings = [Clang<"acquire_capability">,
CXX11<"clang", "acquire_capability">, Clang<"acquire_shared_capability">,
GNU<"acquire_shared_capability">,
CXX11<"clang", "acquire_shared_capability">,
GNU<"exclusive_lock_function">, GNU<"exclusive_lock_function">,
GNU<"shared_lock_function">]; GNU<"shared_lock_function">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
@ -2172,17 +2160,14 @@ def AcquireCapability : InheritableAttr {
let DuplicatesAllowedWhileMerging = 1; let DuplicatesAllowedWhileMerging = 1;
let Args = [VariadicExprArgument<"Args">]; let Args = [VariadicExprArgument<"Args">];
let Accessors = [Accessor<"isShared", let Accessors = [Accessor<"isShared",
[GNU<"acquire_shared_capability">, [Clang<"acquire_shared_capability">,
CXX11<"clang", "acquire_shared_capability">,
GNU<"shared_lock_function">]>]; GNU<"shared_lock_function">]>];
let Documentation = [AcquireCapabilityDocs]; let Documentation = [AcquireCapabilityDocs];
} }
def TryAcquireCapability : InheritableAttr { def TryAcquireCapability : InheritableAttr {
let Spellings = [GNU<"try_acquire_capability">, let Spellings = [Clang<"try_acquire_capability">,
CXX11<"clang", "try_acquire_capability">, Clang<"try_acquire_shared_capability">];
GNU<"try_acquire_shared_capability">,
CXX11<"clang", "try_acquire_shared_capability">];
let Subjects = SubjectList<[Function], let Subjects = SubjectList<[Function],
ErrorDiag>; ErrorDiag>;
let LateParsed = 1; let LateParsed = 1;
@ -2191,18 +2176,14 @@ def TryAcquireCapability : InheritableAttr {
let DuplicatesAllowedWhileMerging = 1; let DuplicatesAllowedWhileMerging = 1;
let Args = [ExprArgument<"SuccessValue">, VariadicExprArgument<"Args">]; let Args = [ExprArgument<"SuccessValue">, VariadicExprArgument<"Args">];
let Accessors = [Accessor<"isShared", let Accessors = [Accessor<"isShared",
[GNU<"try_acquire_shared_capability">, [Clang<"try_acquire_shared_capability">]>];
CXX11<"clang", "try_acquire_shared_capability">]>];
let Documentation = [TryAcquireCapabilityDocs]; let Documentation = [TryAcquireCapabilityDocs];
} }
def ReleaseCapability : InheritableAttr { def ReleaseCapability : InheritableAttr {
let Spellings = [GNU<"release_capability">, let Spellings = [Clang<"release_capability">,
CXX11<"clang", "release_capability">, Clang<"release_shared_capability">,
GNU<"release_shared_capability">, Clang<"release_generic_capability">,
CXX11<"clang", "release_shared_capability">,
GNU<"release_generic_capability">,
CXX11<"clang", "release_generic_capability">,
GNU<"unlock_function">]; GNU<"unlock_function">];
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let LateParsed = 1; let LateParsed = 1;
@ -2211,21 +2192,17 @@ def ReleaseCapability : InheritableAttr {
let DuplicatesAllowedWhileMerging = 1; let DuplicatesAllowedWhileMerging = 1;
let Args = [VariadicExprArgument<"Args">]; let Args = [VariadicExprArgument<"Args">];
let Accessors = [Accessor<"isShared", let Accessors = [Accessor<"isShared",
[GNU<"release_shared_capability">, [Clang<"release_shared_capability">]>,
CXX11<"clang", "release_shared_capability">]>,
Accessor<"isGeneric", Accessor<"isGeneric",
[GNU<"release_generic_capability">, [Clang<"release_generic_capability">,
CXX11<"clang", "release_generic_capability">,
GNU<"unlock_function">]>]; GNU<"unlock_function">]>];
let Documentation = [ReleaseCapabilityDocs]; let Documentation = [ReleaseCapabilityDocs];
} }
def RequiresCapability : InheritableAttr { def RequiresCapability : InheritableAttr {
let Spellings = [GNU<"requires_capability">, let Spellings = [Clang<"requires_capability">,
CXX11<"clang", "requires_capability">,
GNU<"exclusive_locks_required">, GNU<"exclusive_locks_required">,
GNU<"requires_shared_capability">, Clang<"requires_shared_capability">,
CXX11<"clang", "requires_shared_capability">,
GNU<"shared_locks_required">]; GNU<"shared_locks_required">];
let Args = [VariadicExprArgument<"Args">]; let Args = [VariadicExprArgument<"Args">];
let LateParsed = 1; let LateParsed = 1;
@ -2233,9 +2210,8 @@ def RequiresCapability : InheritableAttr {
let ParseArgumentsAsUnevaluated = 1; let ParseArgumentsAsUnevaluated = 1;
let DuplicatesAllowedWhileMerging = 1; let DuplicatesAllowedWhileMerging = 1;
let Subjects = SubjectList<[Function]>; let Subjects = SubjectList<[Function]>;
let Accessors = [Accessor<"isShared", [GNU<"requires_shared_capability">, let Accessors = [Accessor<"isShared", [Clang<"requires_shared_capability">,
GNU<"shared_locks_required">, GNU<"shared_locks_required">]>];
CXX11<"clang","requires_shared_capability">]>];
let Documentation = [Undocumented]; let Documentation = [Undocumented];
} }
@ -2792,7 +2768,7 @@ def OMPDeclareTargetDecl : Attr {
} }
def InternalLinkage : InheritableAttr { def InternalLinkage : InheritableAttr {
let Spellings = [GNU<"internal_linkage">, CXX11<"clang", "internal_linkage">]; let Spellings = [Clang<"internal_linkage">];
let Subjects = SubjectList<[Var, Function, CXXRecord]>; let Subjects = SubjectList<[Var, Function, CXXRecord]>;
let Documentation = [InternalLinkageDocs]; let Documentation = [InternalLinkageDocs];
} }

16
clang/utils/TableGen/ClangAttrEmitter.cpp
View File

@ -56,8 +56,8 @@ public:
V(Spelling.getValueAsString("Variety")), V(Spelling.getValueAsString("Variety")),
N(Spelling.getValueAsString("Name")) { N(Spelling.getValueAsString("Name")) {
assert(V != "GCC" && "Given a GCC spelling, which means this hasn't been" assert(V != "GCC" && V != "Clang" &&
"flattened!"); "Given a GCC spelling, which means this hasn't been flattened!");
if (V == "CXX11" || V == "C2x" || V == "Pragma") if (V == "CXX11" || V == "C2x" || V == "Pragma")
NS = Spelling.getValueAsString("Namespace"); NS = Spelling.getValueAsString("Namespace");
bool Unset; bool Unset;
@ -78,11 +78,15 @@ GetFlattenedSpellings(const Record &Attr) {
std::vector<FlattenedSpelling> Ret; std::vector<FlattenedSpelling> Ret;
for (const auto &Spelling : Spellings) { for (const auto &Spelling : Spellings) {
if (Spelling->getValueAsString("Variety") == "GCC") { StringRef Variety = Spelling->getValueAsString("Variety");
StringRef Name = Spelling->getValueAsString("Name");
if (Variety == "GCC") {
// Gin up two new spelling objects to add into the list. // Gin up two new spelling objects to add into the list.
Ret.emplace_back("GNU", Spelling->getValueAsString("Name"), "", true); Ret.emplace_back("GNU", Name, "", true);
Ret.emplace_back("CXX11", Spelling->getValueAsString("Name"), "gnu", Ret.emplace_back("CXX11", Name, "gnu", true);
true); } else if (Variety == "Clang") {
Ret.emplace_back("GNU", Name, "", false);
Ret.emplace_back("CXX11", Name, "clang", false);
} else } else
Ret.push_back(FlattenedSpelling(*Spelling)); Ret.push_back(FlattenedSpelling(*Spelling));
} }