1 //==--- Attr.td - attribute definitions -----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // The documentation is organized by category. Attributes can have category-
11 // specific documentation that is collated within the larger document.
12 class DocumentationCategory<string name> {
16 def DocCatFunction : DocumentationCategory<"Function Attributes">;
17 def DocCatVariable : DocumentationCategory<"Variable Attributes">;
18 def DocCatType : DocumentationCategory<"Type Attributes">;
19 def DocCatStmt : DocumentationCategory<"Statement Attributes">;
20 // Attributes listed under the Undocumented category do not generate any public
21 // documentation. Ideally, this category should be used for internal-only
22 // attributes which contain no spellings.
23 def DocCatUndocumented : DocumentationCategory<"Undocumented">;
25 class DocDeprecated<string replacement = ""> {
26 // If the Replacement field is empty, no replacement will be listed with the
27 // documentation. Otherwise, the documentation will specify the attribute has
28 // been superseded by this replacement.
29 string Replacement = replacement;
32 // Specifies the documentation to be associated with the given category.
34 DocumentationCategory Category;
37 // If the heading is empty, one may be picked automatically. If the attribute
38 // only has one spelling, no heading is required as the attribute's sole
39 // spelling is sufficient. If all spellings are semantically common, the
40 // heading will be the semantic spelling. If the spellings are not
41 // semantically common and no heading is provided, an error will be emitted.
44 // When set, specifies that the attribute is deprecated and can optionally
45 // specify a replacement attribute.
46 DocDeprecated Deprecated;
49 // Specifies that the attribute is explicitly undocumented. This can be a
50 // helpful placeholder for the attribute while working on the implementation,
51 // but should not be used once feature work has been completed.
52 def Undocumented : Documentation {
53 let Category = DocCatUndocumented;
56 include "clang/Basic/AttrDocs.td"
58 // An attribute's subject is whatever it appertains to. In this file, it is
59 // more accurately a list of things that an attribute can appertain to. All
60 // Decls and Stmts are possibly AttrSubjects (even though the syntax may not
61 // allow attributes on a given Decl or Stmt).
64 include "clang/Basic/DeclNodes.td"
65 include "clang/Basic/StmtNodes.td"
67 // A subset-subject is an AttrSubject constrained to operate only on some subset
70 // The code fragment is a boolean expression that will confirm that the subject
71 // meets the requirements; the subject will have the name S, and will have the
72 // type specified by the base. It should be a simple boolean expression.
73 class SubsetSubject<AttrSubject base, code check> : AttrSubject {
74 AttrSubject Base = base;
75 code CheckCode = check;
78 // This is the type of a variable which C++11 allows alignas(...) to appertain
80 def NormalVar : SubsetSubject<Var,
81 [{S->getStorageClass() != VarDecl::Register &&
82 S->getKind() != Decl::ImplicitParam &&
83 S->getKind() != Decl::ParmVar &&
84 S->getKind() != Decl::NonTypeTemplateParm}]>;
85 def NonParmVar : SubsetSubject<Var,
86 [{S->getKind() != Decl::ParmVar}]>;
87 def NonBitField : SubsetSubject<Field,
88 [{!S->isBitField()}]>;
90 def ObjCInstanceMethod : SubsetSubject<ObjCMethod,
91 [{S->isInstanceMethod()}]>;
93 def ObjCInterfaceDeclInitMethod : SubsetSubject<ObjCMethod,
94 [{S->getMethodFamily() == OMF_init &&
95 (isa<ObjCInterfaceDecl>(S->getDeclContext()) ||
96 (isa<ObjCCategoryDecl>(S->getDeclContext()) &&
97 cast<ObjCCategoryDecl>(S->getDeclContext())->IsClassExtension()))}]>;
99 def Struct : SubsetSubject<Record,
102 def TLSVar : SubsetSubject<Var,
103 [{S->getTLSKind() != 0}]>;
105 def SharedVar : SubsetSubject<Var,
106 [{S->hasGlobalStorage() && !S->getTLSKind()}]>;
108 def GlobalVar : SubsetSubject<Var,
109 [{S->hasGlobalStorage()}]>;
111 // FIXME: this hack is needed because DeclNodes.td defines the base Decl node
112 // type to be a class, not a definition. This makes it impossible to create an
113 // attribute subject which accepts a Decl. Normally, this is not a problem,
114 // because the attribute can have no Subjects clause to accomplish this. But in
115 // the case of a SubsetSubject, there's no way to express it without this hack.
116 def DeclBase : AttrSubject;
117 def FunctionLike : SubsetSubject<DeclBase,
118 [{S->getFunctionType(false) != nullptr}]>;
120 def OpenCLKernelFunction : SubsetSubject<Function, [{
121 S->hasAttr<OpenCLKernelAttr>()
124 // HasFunctionProto is a more strict version of FunctionLike, so it should
125 // never be specified in a Subjects list along with FunctionLike (due to the
126 // inclusive nature of subject testing).
127 def HasFunctionProto : SubsetSubject<DeclBase,
128 [{(S->getFunctionType(true) != nullptr &&
129 isa<FunctionProtoType>(S->getFunctionType())) ||
130 isa<ObjCMethodDecl>(S) ||
131 isa<BlockDecl>(S)}]>;
133 // A single argument to an attribute
134 class Argument<string name, bit optional, bit fake = 0> {
136 bit Optional = optional;
138 /// A fake argument is used to store and serialize additional information
139 /// in an attribute without actually changing its parsing or pretty-printing.
143 class BoolArgument<string name, bit opt = 0> : Argument<name, opt>;
144 class IdentifierArgument<string name, bit opt = 0> : Argument<name, opt>;
145 class IntArgument<string name, bit opt = 0> : Argument<name, opt>;
146 class StringArgument<string name, bit opt = 0> : Argument<name, opt>;
147 class ExprArgument<string name, bit opt = 0> : Argument<name, opt>;
148 class FunctionArgument<string name, bit opt = 0> : Argument<name, opt>;
149 class TypeArgument<string name, bit opt = 0> : Argument<name, opt>;
150 class UnsignedArgument<string name, bit opt = 0> : Argument<name, opt>;
151 class VariadicUnsignedArgument<string name> : Argument<name, 1>;
152 class VariadicExprArgument<string name> : Argument<name, 1>;
153 class VariadicStringArgument<string name> : Argument<name, 1>;
155 // A version of the form major.minor[.subminor].
156 class VersionArgument<string name, bit opt = 0> : Argument<name, opt>;
158 // This one's a doozy, so it gets its own special type
159 // It can be an unsigned integer, or a type. Either can
161 class AlignedArgument<string name, bit opt = 0> : Argument<name, opt>;
163 // A bool argument with a default value
164 class DefaultBoolArgument<string name, bit default> : BoolArgument<name, 1> {
165 bit Default = default;
168 // An integer argument with a default value
169 class DefaultIntArgument<string name, int default> : IntArgument<name, 1> {
170 int Default = default;
173 // This argument is more complex, it includes the enumerator type name,
174 // a list of strings to accept, and a list of enumerators to map them to.
175 class EnumArgument<string name, string type, list<string> values,
176 list<string> enums, bit opt = 0, bit fake = 0>
177 : Argument<name, opt, fake> {
179 list<string> Values = values;
180 list<string> Enums = enums;
183 // FIXME: There should be a VariadicArgument type that takes any other type
184 // of argument and generates the appropriate type.
185 class VariadicEnumArgument<string name, string type, list<string> values,
186 list<string> enums> : Argument<name, 1> {
188 list<string> Values = values;
189 list<string> Enums = enums;
192 // This handles one spelling of an attribute.
193 class Spelling<string name, string variety> {
195 string Variety = variety;
199 class GNU<string name> : Spelling<name, "GNU">;
200 class Declspec<string name> : Spelling<name, "Declspec">;
201 class CXX11<string namespace, string name, int version = 1>
202 : Spelling<name, "CXX11"> {
203 string Namespace = namespace;
204 int Version = version;
206 class Keyword<string name> : Spelling<name, "Keyword">;
207 class Pragma<string namespace, string name> : Spelling<name, "Pragma"> {
208 string Namespace = namespace;
211 // The GCC spelling implies GNU<name, "GNU"> and CXX11<"gnu", name> and also
212 // sets KnownToGCC to 1. This spelling should be used for any GCC-compatible
214 class GCC<string name> : Spelling<name, "GCC"> {
218 class Accessor<string name, list<Spelling> spellings> {
220 list<Spelling> Spellings = spellings;
223 class SubjectDiag<bit warn> {
226 def WarnDiag : SubjectDiag<1>;
227 def ErrorDiag : SubjectDiag<0>;
229 class SubjectList<list<AttrSubject> subjects, SubjectDiag diag = WarnDiag,
230 string customDiag = ""> {
231 list<AttrSubject> Subjects = subjects;
232 SubjectDiag Diag = diag;
233 string CustomDiag = customDiag;
236 class LangOpt<string name, bit negated = 0> {
238 bit Negated = negated;
240 def MicrosoftExt : LangOpt<"MicrosoftExt">;
241 def Borland : LangOpt<"Borland">;
242 def CUDA : LangOpt<"CUDA">;
243 def COnly : LangOpt<"CPlusPlus", 1>;
244 def OpenCL : LangOpt<"OpenCL">;
245 def RenderScript : LangOpt<"RenderScript">;
247 // Defines targets for target-specific attributes. The list of strings should
248 // specify architectures for which the target applies, based off the ArchType
249 // enumeration in Triple.h.
250 class TargetArch<list<string> arches> {
251 list<string> Arches = arches;
253 list<string> CXXABIs;
255 def TargetARM : TargetArch<["arm", "thumb"]>;
256 def TargetMips : TargetArch<["mips", "mipsel"]>;
257 def TargetMSP430 : TargetArch<["msp430"]>;
258 def TargetX86 : TargetArch<["x86"]>;
259 def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
260 def TargetWindows : TargetArch<["x86", "x86_64", "arm", "thumb"]> {
261 let OSes = ["Win32"];
263 def TargetMicrosoftCXXABI : TargetArch<["x86", "x86_64", "arm", "thumb"]> {
264 let CXXABIs = ["Microsoft"];
268 // The various ways in which an attribute can be spelled in source
269 list<Spelling> Spellings;
270 // The things to which an attribute can appertain
271 SubjectList Subjects;
272 // The arguments allowed on an attribute
273 list<Argument> Args = [];
274 // Accessors which should be generated for the attribute.
275 list<Accessor> Accessors = [];
276 // Set to true for attributes with arguments which require delayed parsing.
278 // Set to false to prevent an attribute from being propagated from a template
279 // to the instantiation.
281 // Set to true for attributes which must be instantiated within templates
282 bit TemplateDependent = 0;
283 // Set to true for attributes that have a corresponding AST node.
285 // Set to true for attributes which have handler in Sema.
287 // Set to true for attributes that are completely ignored.
289 // Set to true if the attribute's parsing does not match its semantic
290 // content. Eg) It parses 3 args, but semantically takes 4 args. Opts out of
291 // common attribute error checking.
292 bit HasCustomParsing = 0;
293 // Set to true if all of the attribute's arguments should be parsed in an
294 // unevaluated context.
295 bit ParseArgumentsAsUnevaluated = 0;
296 // Set to true if this attribute can be duplicated on a subject when merging
297 // attributes. By default, attributes are not merged.
298 bit DuplicatesAllowedWhileMerging = 0;
299 // Lists language options, one of which is required to be true for the
300 // attribute to be applicable. If empty, no language options are required.
301 list<LangOpt> LangOpts = [];
302 // Any additional text that should be included verbatim in the class.
303 // Note: Any additional data members will leak and should be constructed
304 // externally on the ASTContext.
305 code AdditionalMembers = [{}];
306 // Any documentation that should be associated with the attribute. Since an
307 // attribute may be documented under multiple categories, more than one
308 // Documentation entry may be listed.
309 list<Documentation> Documentation;
312 /// A type attribute is not processed on a declaration or a statement.
313 class TypeAttr : Attr {
314 // By default, type attributes do not get an AST node.
318 /// A stmt attribute is not processed on a declaration or a type.
319 class StmtAttr : Attr;
321 /// An inheritable attribute is inherited by later redeclarations.
322 class InheritableAttr : Attr;
324 /// A target-specific attribute. This class is meant to be used as a mixin
325 /// with InheritableAttr or Attr depending on the attribute's needs.
326 class TargetSpecificAttr<TargetArch target> {
327 TargetArch Target = target;
328 // Attributes are generally required to have unique spellings for their names
329 // so that the parser can determine what kind of attribute it has parsed.
330 // However, target-specific attributes are special in that the attribute only
331 // "exists" for a given target. So two target-specific attributes can share
332 // the same name when they exist in different targets. To support this, a
333 // Kind can be explicitly specified for a target-specific attribute. This
334 // corresponds to the AttributeList::AT_* enum that is generated and it
335 // should contain a shared value between the attributes.
337 // Target-specific attributes which use this feature should ensure that the
338 // spellings match exactly betweeen the attributes, and if the arguments or
339 // subjects differ, should specify HasCustomParsing = 1 and implement their
340 // own parsing and semantic handling requirements as-needed.
344 /// An inheritable parameter attribute is inherited by later
345 /// redeclarations, even when it's written on a parameter.
346 class InheritableParamAttr : InheritableAttr;
348 /// An attribute which changes the ABI rules for a specific parameter.
349 class ParameterABIAttr : InheritableParamAttr {
350 let Subjects = SubjectList<[ParmVar]>;
353 /// An ignored attribute, which we parse but discard with no checking.
354 class IgnoredAttr : Attr {
358 let Documentation = [Undocumented];
362 // Attributes begin here
366 let Spellings = [GCC<"abi_tag">];
367 let Args = [VariadicStringArgument<"Tags">];
368 let Subjects = SubjectList<[Struct, Var, Function, Namespace], ErrorDiag,
369 "ExpectedStructClassVariableFunctionOrInlineNamespace">;
370 let Documentation = [AbiTagsDocs];
373 def AddressSpace : TypeAttr {
374 let Spellings = [GNU<"address_space">];
375 let Args = [IntArgument<"AddressSpace">];
376 let Documentation = [Undocumented];
380 let Spellings = [GCC<"alias">];
381 let Args = [StringArgument<"Aliasee">];
382 let Subjects = SubjectList<[Function, GlobalVar], ErrorDiag,
383 "ExpectedFunctionGlobalVarMethodOrProperty">;
384 let Documentation = [Undocumented];
387 def Aligned : InheritableAttr {
388 let Spellings = [GCC<"aligned">, Declspec<"align">, Keyword<"alignas">,
389 Keyword<"_Alignas">];
390 // let Subjects = SubjectList<[NonBitField, NormalVar, Tag]>;
391 let Args = [AlignedArgument<"Alignment", 1>];
392 let Accessors = [Accessor<"isGNU", [GCC<"aligned">]>,
393 Accessor<"isC11", [Keyword<"_Alignas">]>,
394 Accessor<"isAlignas", [Keyword<"alignas">,
395 Keyword<"_Alignas">]>,
396 Accessor<"isDeclspec",[Declspec<"align">]>];
397 let Documentation = [Undocumented];
400 def AlignValue : Attr {
402 // Unfortunately, this is semantically an assertion, not a directive
403 // (something else must ensure the alignment), so aligned_value is a
404 // probably a better name. We might want to add an aligned_value spelling in
405 // the future (and a corresponding C++ attribute), but this can be done
406 // later once we decide if we also want them to have slightly-different
407 // semantics than Intel's align_value.
409 // Intel's compiler on Windows also supports:
410 // , Declspec<"align_value">
412 let Args = [ExprArgument<"Alignment">];
413 let Subjects = SubjectList<[Var, TypedefName], WarnDiag,
414 "ExpectedVariableOrTypedef">;
415 let Documentation = [AlignValueDocs];
418 def AlignMac68k : InheritableAttr {
419 // This attribute has no spellings as it is only ever created implicitly.
422 let Documentation = [Undocumented];
425 def AlwaysInline : InheritableAttr {
426 let Spellings = [GCC<"always_inline">, Keyword<"__forceinline">];
427 let Subjects = SubjectList<[Function]>;
428 let Documentation = [Undocumented];
431 def XRayInstrument : InheritableAttr {
432 let Spellings = [GNU<"xray_always_instrument">,
433 CXX11<"clang", "xray_always_instrument">,
434 GNU<"xray_never_instrument">,
435 CXX11<"clang", "xray_never_instrument">];
436 let Subjects = SubjectList<[CXXMethod, ObjCMethod, Function], WarnDiag,
437 "ExpectedFunctionOrMethod">;
438 let Accessors = [Accessor<"alwaysXRayInstrument",
439 [GNU<"xray_always_instrument">,
440 CXX11<"clang", "xray_always_instrument">]>,
441 Accessor<"neverXRayInstrument",
442 [GNU<"xray_never_instrument">,
443 CXX11<"clang", "xray_never_instrument">]>];
444 let Documentation = [XRayDocs];
447 def TLSModel : InheritableAttr {
448 let Spellings = [GCC<"tls_model">];
449 let Subjects = SubjectList<[TLSVar], ErrorDiag, "ExpectedTLSVar">;
450 let Args = [StringArgument<"Model">];
451 let Documentation = [TLSModelDocs];
454 def AnalyzerNoReturn : InheritableAttr {
455 let Spellings = [GNU<"analyzer_noreturn">];
456 let Documentation = [Undocumented];
459 def Annotate : InheritableParamAttr {
460 let Spellings = [GNU<"annotate">];
461 let Args = [StringArgument<"Annotation">];
462 let Documentation = [Undocumented];
465 def ARMInterrupt : InheritableAttr, TargetSpecificAttr<TargetARM> {
466 // NOTE: If you add any additional spellings, MSP430Interrupt's,
467 // MipsInterrupt's and AnyX86Interrupt's spellings must match.
468 let Spellings = [GNU<"interrupt">];
469 let Args = [EnumArgument<"Interrupt", "InterruptType",
470 ["IRQ", "FIQ", "SWI", "ABORT", "UNDEF", ""],
471 ["IRQ", "FIQ", "SWI", "ABORT", "UNDEF", "Generic"],
473 let ParseKind = "Interrupt";
474 let HasCustomParsing = 1;
475 let Documentation = [ARMInterruptDocs];
478 def AsmLabel : InheritableAttr {
479 let Spellings = [Keyword<"asm">, Keyword<"__asm__">];
480 let Args = [StringArgument<"Label">];
482 let Documentation = [Undocumented];
485 def Availability : InheritableAttr {
486 let Spellings = [GNU<"availability">];
487 let Args = [IdentifierArgument<"platform">, VersionArgument<"introduced">,
488 VersionArgument<"deprecated">, VersionArgument<"obsoleted">,
489 BoolArgument<"unavailable">, StringArgument<"message">,
490 BoolArgument<"strict">, StringArgument<"replacement">];
491 let AdditionalMembers =
492 [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
493 return llvm::StringSwitch<llvm::StringRef>(Platform)
494 .Case("android", "Android")
496 .Case("macos", "macOS")
497 .Case("tvos", "tvOS")
498 .Case("watchos", "watchOS")
499 .Case("ios_app_extension", "iOS (App Extension)")
500 .Case("macos_app_extension", "macOS (App Extension)")
501 .Case("tvos_app_extension", "tvOS (App Extension)")
502 .Case("watchos_app_extension", "watchOS (App Extension)")
503 .Default(llvm::StringRef());
505 let HasCustomParsing = 1;
506 let DuplicatesAllowedWhileMerging = 1;
507 // let Subjects = SubjectList<[Named]>;
508 let Documentation = [AvailabilityDocs];
511 def Blocks : InheritableAttr {
512 let Spellings = [GNU<"blocks">];
513 let Args = [EnumArgument<"Type", "BlockType", ["byref"], ["ByRef"]>];
514 let Documentation = [Undocumented];
517 def Bounded : IgnoredAttr {
518 let Spellings = [GNU<"bounded">];
521 def CarriesDependency : InheritableParamAttr {
522 let Spellings = [GNU<"carries_dependency">,
523 CXX11<"","carries_dependency", 200809>];
524 let Subjects = SubjectList<[ParmVar, ObjCMethod, Function], ErrorDiag>;
525 let Documentation = [CarriesDependencyDocs];
528 def CDecl : InheritableAttr {
529 let Spellings = [GCC<"cdecl">, Keyword<"__cdecl">, Keyword<"_cdecl">];
530 // let Subjects = [Function, ObjCMethod];
531 let Documentation = [Undocumented];
534 // cf_audited_transfer indicates that the given function has been
535 // audited and has been marked with the appropriate cf_consumed and
536 // cf_returns_retained attributes. It is generally applied by
537 // '#pragma clang arc_cf_code_audited' rather than explicitly.
538 def CFAuditedTransfer : InheritableAttr {
539 let Spellings = [GNU<"cf_audited_transfer">];
540 let Subjects = SubjectList<[Function], ErrorDiag>;
541 let Documentation = [Undocumented];
544 // cf_unknown_transfer is an explicit opt-out of cf_audited_transfer.
545 // It indicates that the function has unknown or unautomatable
546 // transfer semantics.
547 def CFUnknownTransfer : InheritableAttr {
548 let Spellings = [GNU<"cf_unknown_transfer">];
549 let Subjects = SubjectList<[Function], ErrorDiag>;
550 let Documentation = [Undocumented];
553 def CFReturnsRetained : InheritableAttr {
554 let Spellings = [GNU<"cf_returns_retained">];
555 // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>;
556 let Documentation = [Undocumented];
559 def CFReturnsNotRetained : InheritableAttr {
560 let Spellings = [GNU<"cf_returns_not_retained">];
561 // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>;
562 let Documentation = [Undocumented];
565 def CFConsumed : InheritableParamAttr {
566 let Spellings = [GNU<"cf_consumed">];
567 let Subjects = SubjectList<[ParmVar]>;
568 let Documentation = [Undocumented];
571 def Cleanup : InheritableAttr {
572 let Spellings = [GCC<"cleanup">];
573 let Args = [FunctionArgument<"FunctionDecl">];
574 let Subjects = SubjectList<[Var]>;
575 let Documentation = [Undocumented];
578 def Cold : InheritableAttr {
579 let Spellings = [GCC<"cold">];
580 let Subjects = SubjectList<[Function]>;
581 let Documentation = [Undocumented];
584 def Common : InheritableAttr {
585 let Spellings = [GCC<"common">];
586 let Subjects = SubjectList<[Var]>;
587 let Documentation = [Undocumented];
590 def Const : InheritableAttr {
591 let Spellings = [GCC<"const">, GCC<"__const">];
592 let Documentation = [Undocumented];
595 def Constructor : InheritableAttr {
596 let Spellings = [GCC<"constructor">];
597 let Args = [DefaultIntArgument<"Priority", 65535>];
598 let Subjects = SubjectList<[Function]>;
599 let Documentation = [Undocumented];
602 def CUDAConstant : InheritableAttr {
603 let Spellings = [GNU<"constant">];
604 let Subjects = SubjectList<[Var]>;
605 let LangOpts = [CUDA];
606 let Documentation = [Undocumented];
609 def CUDACudartBuiltin : IgnoredAttr {
610 let Spellings = [GNU<"cudart_builtin">];
611 let LangOpts = [CUDA];
614 def CUDADevice : InheritableAttr {
615 let Spellings = [GNU<"device">];
616 let Subjects = SubjectList<[Function, Var]>;
617 let LangOpts = [CUDA];
618 let Documentation = [Undocumented];
621 def CUDADeviceBuiltin : IgnoredAttr {
622 let Spellings = [GNU<"device_builtin">];
623 let LangOpts = [CUDA];
626 def CUDADeviceBuiltinSurfaceType : IgnoredAttr {
627 let Spellings = [GNU<"device_builtin_surface_type">];
628 let LangOpts = [CUDA];
631 def CUDADeviceBuiltinTextureType : IgnoredAttr {
632 let Spellings = [GNU<"device_builtin_texture_type">];
633 let LangOpts = [CUDA];
636 def CUDAGlobal : InheritableAttr {
637 let Spellings = [GNU<"global">];
638 let Subjects = SubjectList<[Function]>;
639 let LangOpts = [CUDA];
640 let Documentation = [Undocumented];
643 def CUDAHost : InheritableAttr {
644 let Spellings = [GNU<"host">];
645 let Subjects = SubjectList<[Function]>;
646 let LangOpts = [CUDA];
647 let Documentation = [Undocumented];
650 def CUDAInvalidTarget : InheritableAttr {
652 let Subjects = SubjectList<[Function]>;
653 let LangOpts = [CUDA];
654 let Documentation = [Undocumented];
657 def CUDALaunchBounds : InheritableAttr {
658 let Spellings = [GNU<"launch_bounds">];
659 let Args = [ExprArgument<"MaxThreads">, ExprArgument<"MinBlocks", 1>];
660 let LangOpts = [CUDA];
661 let Subjects = SubjectList<[ObjCMethod, FunctionLike], WarnDiag,
662 "ExpectedFunctionOrMethod">;
663 // An AST node is created for this attribute, but is not used by other parts
664 // of the compiler. However, this node needs to exist in the AST because
665 // non-LLVM backends may be relying on the attribute's presence.
666 let Documentation = [Undocumented];
669 def CUDAShared : InheritableAttr {
670 let Spellings = [GNU<"shared">];
671 let Subjects = SubjectList<[Var]>;
672 let LangOpts = [CUDA];
673 let Documentation = [Undocumented];
676 def C11NoReturn : InheritableAttr {
677 let Spellings = [Keyword<"_Noreturn">];
678 let Subjects = SubjectList<[Function], ErrorDiag>;
680 let Documentation = [C11NoReturnDocs];
683 def CXX11NoReturn : InheritableAttr {
684 let Spellings = [CXX11<"","noreturn", 200809>];
685 let Subjects = SubjectList<[Function], ErrorDiag>;
686 let Documentation = [CXX11NoReturnDocs];
689 def OpenCLKernel : InheritableAttr {
690 let Spellings = [Keyword<"__kernel">, Keyword<"kernel">];
691 let Subjects = SubjectList<[Function], ErrorDiag>;
692 let Documentation = [Undocumented];
695 def OpenCLUnrollHint : InheritableAttr {
696 let Spellings = [GNU<"opencl_unroll_hint">];
697 let Args = [UnsignedArgument<"UnrollHint">];
698 let Documentation = [OpenCLUnrollHintDocs];
701 // This attribute is both a type attribute, and a declaration attribute (for
702 // parameter variables).
703 def OpenCLAccess : Attr {
704 let Spellings = [Keyword<"__read_only">, Keyword<"read_only">,
705 Keyword<"__write_only">, Keyword<"write_only">,
706 Keyword<"__read_write">, Keyword<"read_write">];
707 let Subjects = SubjectList<[ParmVar, TypedefName], ErrorDiag,
708 "ExpectedParameterOrTypedef">;
709 let Accessors = [Accessor<"isReadOnly", [Keyword<"__read_only">,
710 Keyword<"read_only">]>,
711 Accessor<"isReadWrite", [Keyword<"__read_write">,
712 Keyword<"read_write">]>,
713 Accessor<"isWriteOnly", [Keyword<"__write_only">,
714 Keyword<"write_only">]>];
715 let Documentation = [OpenCLAccessDocs];
718 def OpenCLPrivateAddressSpace : TypeAttr {
719 let Spellings = [Keyword<"__private">, Keyword<"private">];
720 let Documentation = [OpenCLAddressSpacePrivateDocs];
723 def OpenCLGlobalAddressSpace : TypeAttr {
724 let Spellings = [Keyword<"__global">, Keyword<"global">];
725 let Documentation = [OpenCLAddressSpaceGlobalDocs];
728 def OpenCLLocalAddressSpace : TypeAttr {
729 let Spellings = [Keyword<"__local">, Keyword<"local">];
730 let Documentation = [OpenCLAddressSpaceLocalDocs];
733 def OpenCLConstantAddressSpace : TypeAttr {
734 let Spellings = [Keyword<"__constant">, Keyword<"constant">];
735 let Documentation = [OpenCLAddressSpaceConstantDocs];
738 def OpenCLGenericAddressSpace : TypeAttr {
739 let Spellings = [Keyword<"__generic">, Keyword<"generic">];
740 let Documentation = [OpenCLAddressSpaceGenericDocs];
743 def OpenCLNoSVM : Attr {
744 let Spellings = [GNU<"nosvm">];
745 let Subjects = SubjectList<[Var]>;
746 let Documentation = [OpenCLNoSVMDocs];
747 let LangOpts = [OpenCL];
751 def RenderScriptKernel : Attr {
752 let Spellings = [GNU<"kernel">];
753 let Subjects = SubjectList<[Function]>;
754 let Documentation = [RenderScriptKernelAttributeDocs];
755 let LangOpts = [RenderScript];
758 def Deprecated : InheritableAttr {
759 let Spellings = [GCC<"deprecated">, Declspec<"deprecated">,
760 CXX11<"","deprecated", 201309>];
761 let Args = [StringArgument<"Message", 1>,
762 // An optional string argument that enables us to provide a
764 StringArgument<"Replacement", 1>];
765 let Documentation = [DeprecatedDocs];
768 def Destructor : InheritableAttr {
769 let Spellings = [GCC<"destructor">];
770 let Args = [DefaultIntArgument<"Priority", 65535>];
771 let Subjects = SubjectList<[Function]>;
772 let Documentation = [Undocumented];
775 def EmptyBases : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> {
776 let Spellings = [Declspec<"empty_bases">];
777 let Subjects = SubjectList<[CXXRecord]>;
778 let Documentation = [EmptyBasesDocs];
781 def EnableIf : InheritableAttr {
782 let Spellings = [GNU<"enable_if">];
783 let Subjects = SubjectList<[Function]>;
784 let Args = [ExprArgument<"Cond">, StringArgument<"Message">];
785 let TemplateDependent = 1;
786 let Documentation = [EnableIfDocs];
789 def ExtVectorType : Attr {
790 let Spellings = [GNU<"ext_vector_type">];
791 let Subjects = SubjectList<[TypedefName], ErrorDiag>;
792 let Args = [ExprArgument<"NumElements">];
794 let Documentation = [Undocumented];
797 def FallThrough : StmtAttr {
798 let Spellings = [CXX11<"", "fallthrough", 201603>,
799 CXX11<"clang", "fallthrough">];
800 // let Subjects = [NullStmt];
801 let Documentation = [FallthroughDocs];
804 def FastCall : InheritableAttr {
805 let Spellings = [GCC<"fastcall">, Keyword<"__fastcall">,
806 Keyword<"_fastcall">];
807 // let Subjects = [Function, ObjCMethod];
808 let Documentation = [FastCallDocs];
811 def Final : InheritableAttr {
812 let Spellings = [Keyword<"final">, Keyword<"sealed">];
813 let Accessors = [Accessor<"isSpelledAsSealed", [Keyword<"sealed">]>];
815 let Documentation = [Undocumented];
818 def MinSize : InheritableAttr {
819 let Spellings = [GNU<"minsize">];
820 let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
821 let Documentation = [Undocumented];
824 def FlagEnum : InheritableAttr {
825 let Spellings = [GNU<"flag_enum">];
826 let Subjects = SubjectList<[Enum]>;
827 let Documentation = [FlagEnumDocs];
828 let LangOpts = [COnly];
831 def Flatten : InheritableAttr {
832 let Spellings = [GCC<"flatten">];
833 let Subjects = SubjectList<[Function], ErrorDiag>;
834 let Documentation = [FlattenDocs];
837 def Format : InheritableAttr {
838 let Spellings = [GCC<"format">];
839 let Args = [IdentifierArgument<"Type">, IntArgument<"FormatIdx">,
840 IntArgument<"FirstArg">];
841 let Subjects = SubjectList<[ObjCMethod, Block, HasFunctionProto], WarnDiag,
842 "ExpectedFunctionWithProtoType">;
843 let Documentation = [FormatDocs];
846 def FormatArg : InheritableAttr {
847 let Spellings = [GCC<"format_arg">];
848 let Args = [IntArgument<"FormatIdx">];
849 let Subjects = SubjectList<[ObjCMethod, HasFunctionProto], WarnDiag,
850 "ExpectedFunctionWithProtoType">;
851 let Documentation = [Undocumented];
854 def GNUInline : InheritableAttr {
855 let Spellings = [GCC<"gnu_inline">];
856 let Subjects = SubjectList<[Function]>;
857 let Documentation = [Undocumented];
860 def Hot : InheritableAttr {
861 let Spellings = [GCC<"hot">];
862 let Subjects = SubjectList<[Function]>;
863 // An AST node is created for this attribute, but not actually used beyond
864 // semantic checking for mutual exclusion with the Cold attribute.
865 let Documentation = [Undocumented];
868 def IBAction : InheritableAttr {
869 let Spellings = [GNU<"ibaction">];
870 let Subjects = SubjectList<[ObjCInstanceMethod], WarnDiag,
871 "ExpectedObjCInstanceMethod">;
872 // An AST node is created for this attribute, but is not used by other parts
873 // of the compiler. However, this node needs to exist in the AST because
874 // external tools rely on it.
875 let Documentation = [Undocumented];
878 def IBOutlet : InheritableAttr {
879 let Spellings = [GNU<"iboutlet">];
880 // let Subjects = [ObjCIvar, ObjCProperty];
881 let Documentation = [Undocumented];
884 def IBOutletCollection : InheritableAttr {
885 let Spellings = [GNU<"iboutletcollection">];
886 let Args = [TypeArgument<"Interface", 1>];
887 // let Subjects = [ObjCIvar, ObjCProperty];
888 let Documentation = [Undocumented];
892 let Spellings = [GCC<"ifunc">];
893 let Args = [StringArgument<"Resolver">];
894 let Subjects = SubjectList<[Function]>;
895 let Documentation = [IFuncDocs];
898 def Restrict : InheritableAttr {
899 let Spellings = [Declspec<"restrict">, GCC<"malloc">];
900 let Subjects = SubjectList<[Function]>;
901 let Documentation = [Undocumented];
904 def LayoutVersion : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> {
905 let Spellings = [Declspec<"layout_version">];
906 let Args = [UnsignedArgument<"Version">];
907 let Subjects = SubjectList<[CXXRecord]>;
908 let Documentation = [LayoutVersionDocs];
911 def MaxFieldAlignment : InheritableAttr {
912 // This attribute has no spellings as it is only ever created implicitly.
914 let Args = [UnsignedArgument<"Alignment">];
916 let Documentation = [Undocumented];
919 def MayAlias : InheritableAttr {
920 // FIXME: this is a type attribute in GCC, but a declaration attribute here.
921 let Spellings = [GCC<"may_alias">];
922 let Documentation = [Undocumented];
925 def MSABI : InheritableAttr {
926 let Spellings = [GCC<"ms_abi">];
927 // let Subjects = [Function, ObjCMethod];
928 let Documentation = [MSABIDocs];
931 def MSP430Interrupt : InheritableAttr, TargetSpecificAttr<TargetMSP430> {
932 // NOTE: If you add any additional spellings, ARMInterrupt's, MipsInterrupt's
933 // and AnyX86Interrupt's spellings must match.
934 let Spellings = [GNU<"interrupt">];
935 let Args = [UnsignedArgument<"Number">];
936 let ParseKind = "Interrupt";
937 let HasCustomParsing = 1;
938 let Documentation = [Undocumented];
941 def Mips16 : InheritableAttr, TargetSpecificAttr<TargetMips> {
942 let Spellings = [GCC<"mips16">];
943 let Subjects = SubjectList<[Function], ErrorDiag>;
944 let Documentation = [Undocumented];
947 def MipsInterrupt : InheritableAttr, TargetSpecificAttr<TargetMips> {
948 // NOTE: If you add any additional spellings, ARMInterrupt's,
949 // MSP430Interrupt's and AnyX86Interrupt's spellings must match.
950 let Spellings = [GNU<"interrupt">];
951 let Subjects = SubjectList<[Function]>;
952 let Args = [EnumArgument<"Interrupt", "InterruptType",
953 ["vector=sw0", "vector=sw1", "vector=hw0",
954 "vector=hw1", "vector=hw2", "vector=hw3",
955 "vector=hw4", "vector=hw5", "eic", ""],
956 ["sw0", "sw1", "hw0", "hw1", "hw2", "hw3",
957 "hw4", "hw5", "eic", "eic"]
959 let ParseKind = "Interrupt";
960 let Documentation = [MipsInterruptDocs];
964 let Spellings = [GCC<"mode">];
965 let Subjects = SubjectList<[Var, Enum, TypedefName, Field], ErrorDiag,
966 "ExpectedVariableEnumFieldOrTypedef">;
967 let Args = [IdentifierArgument<"Mode">];
968 let Documentation = [Undocumented];
971 def Naked : InheritableAttr {
972 let Spellings = [GCC<"naked">, Declspec<"naked">];
973 let Subjects = SubjectList<[Function]>;
974 let Documentation = [Undocumented];
977 def NeonPolyVectorType : TypeAttr {
978 let Spellings = [GNU<"neon_polyvector_type">];
979 let Args = [IntArgument<"NumElements">];
980 let Documentation = [Undocumented];
983 def NeonVectorType : TypeAttr {
984 let Spellings = [GNU<"neon_vector_type">];
985 let Args = [IntArgument<"NumElements">];
986 let Documentation = [Undocumented];
989 def ReturnsTwice : InheritableAttr {
990 let Spellings = [GCC<"returns_twice">];
991 let Subjects = SubjectList<[Function]>;
992 let Documentation = [Undocumented];
995 def DisableTailCalls : InheritableAttr {
996 let Spellings = [GNU<"disable_tail_calls">,
997 CXX11<"clang", "disable_tail_calls">];
998 let Subjects = SubjectList<[Function, ObjCMethod]>;
999 let Documentation = [DisableTailCallsDocs];
1002 def NoAlias : InheritableAttr {
1003 let Spellings = [Declspec<"noalias">];
1004 let Subjects = SubjectList<[Function]>;
1005 let Documentation = [NoAliasDocs];
1008 def NoCommon : InheritableAttr {
1009 let Spellings = [GCC<"nocommon">];
1010 let Subjects = SubjectList<[Var]>;
1011 let Documentation = [Undocumented];
1014 def NoDebug : InheritableAttr {
1015 let Spellings = [GCC<"nodebug">];
1016 let Subjects = SubjectList<[FunctionLike, ObjCMethod, NonParmVar], WarnDiag,
1017 "ExpectedVariableOrFunction">;
1018 let Documentation = [NoDebugDocs];
1021 def NoDuplicate : InheritableAttr {
1022 let Spellings = [GNU<"noduplicate">, CXX11<"clang", "noduplicate">];
1023 let Subjects = SubjectList<[Function]>;
1024 let Documentation = [NoDuplicateDocs];
1027 def NoInline : InheritableAttr {
1028 let Spellings = [GCC<"noinline">, Declspec<"noinline">];
1029 let Subjects = SubjectList<[Function]>;
1030 let Documentation = [Undocumented];
1033 def NoMips16 : InheritableAttr, TargetSpecificAttr<TargetMips> {
1034 let Spellings = [GCC<"nomips16">];
1035 let Subjects = SubjectList<[Function], ErrorDiag>;
1036 let Documentation = [Undocumented];
1039 // This is not a TargetSpecificAttr so that is silently accepted and
1040 // ignored on other targets as encouraged by the OpenCL spec.
1042 // See OpenCL 1.2 6.11.5: "It is our intention that a particular
1043 // implementation of OpenCL be free to ignore all attributes and the
1044 // resulting executable binary will produce the same result."
1046 // However, only AMD GPU targets will emit the corresponding IR
1049 // FIXME: This provides a sub-optimal error message if you attempt to
1050 // use this in CUDA, since CUDA does not use the same terminology.
1051 def AMDGPUNumVGPR : InheritableAttr {
1052 let Spellings = [GNU<"amdgpu_num_vgpr">];
1053 let Args = [UnsignedArgument<"NumVGPR">];
1054 let Documentation = [AMDGPUNumVGPRDocs];
1056 // FIXME: This should be for OpenCLKernelFunction, but is not to
1057 // workaround needing to see kernel attribute before others to know if
1058 // this should be rejected on non-kernels.
1059 let Subjects = SubjectList<[Function], ErrorDiag,
1060 "ExpectedKernelFunction">;
1063 def AMDGPUNumSGPR : InheritableAttr {
1064 let Spellings = [GNU<"amdgpu_num_sgpr">];
1065 let Args = [UnsignedArgument<"NumSGPR">];
1066 let Documentation = [AMDGPUNumSGPRDocs];
1067 let Subjects = SubjectList<[Function], ErrorDiag,
1068 "ExpectedKernelFunction">;
1071 def NoSplitStack : InheritableAttr {
1072 let Spellings = [GCC<"no_split_stack">];
1073 let Subjects = SubjectList<[Function], ErrorDiag>;
1074 let Documentation = [NoSplitStackDocs];
1077 def NonNull : InheritableAttr {
1078 let Spellings = [GCC<"nonnull">];
1079 let Subjects = SubjectList<[ObjCMethod, HasFunctionProto, ParmVar], WarnDiag,
1080 "ExpectedFunctionMethodOrParameter">;
1081 let Args = [VariadicUnsignedArgument<"Args">];
1082 let AdditionalMembers =
1083 [{bool isNonNull(unsigned idx) const {
1086 for (const auto &V : args())
1091 // FIXME: We should merge duplicates into a single nonnull attribute.
1092 let DuplicatesAllowedWhileMerging = 1;
1093 let Documentation = [NonNullDocs];
1096 def ReturnsNonNull : InheritableAttr {
1097 let Spellings = [GCC<"returns_nonnull">];
1098 let Subjects = SubjectList<[ObjCMethod, Function], WarnDiag,
1099 "ExpectedFunctionOrMethod">;
1100 let Documentation = [ReturnsNonNullDocs];
1103 // pass_object_size(N) indicates that the parameter should have
1104 // __builtin_object_size with Type=N evaluated on the parameter at the callsite.
1105 def PassObjectSize : InheritableParamAttr {
1106 let Spellings = [GNU<"pass_object_size">];
1107 let Args = [IntArgument<"Type">];
1108 let Subjects = SubjectList<[ParmVar]>;
1109 let Documentation = [PassObjectSizeDocs];
1112 // Nullability type attributes.
1113 def TypeNonNull : TypeAttr {
1114 let Spellings = [Keyword<"_Nonnull">];
1115 let Documentation = [TypeNonNullDocs];
1118 def TypeNullable : TypeAttr {
1119 let Spellings = [Keyword<"_Nullable">];
1120 let Documentation = [TypeNullableDocs];
1123 def TypeNullUnspecified : TypeAttr {
1124 let Spellings = [Keyword<"_Null_unspecified">];
1125 let Documentation = [TypeNullUnspecifiedDocs];
1128 def ObjCKindOf : TypeAttr {
1129 let Spellings = [Keyword<"__kindof">];
1130 let Documentation = [Undocumented];
1133 def AssumeAligned : InheritableAttr {
1134 let Spellings = [GCC<"assume_aligned">];
1135 let Subjects = SubjectList<[ObjCMethod, Function]>;
1136 let Args = [ExprArgument<"Alignment">, ExprArgument<"Offset", 1>];
1137 let Documentation = [AssumeAlignedDocs];
1140 def NoReturn : InheritableAttr {
1141 let Spellings = [GCC<"noreturn">, Declspec<"noreturn">];
1142 // FIXME: Does GCC allow this on the function instead?
1143 let Documentation = [Undocumented];
1146 def NoInstrumentFunction : InheritableAttr {
1147 let Spellings = [GCC<"no_instrument_function">];
1148 let Subjects = SubjectList<[Function]>;
1149 let Documentation = [Undocumented];
1152 def NotTailCalled : InheritableAttr {
1153 let Spellings = [GNU<"not_tail_called">, CXX11<"clang", "not_tail_called">];
1154 let Subjects = SubjectList<[Function]>;
1155 let Documentation = [NotTailCalledDocs];
1158 def NoThrow : InheritableAttr {
1159 let Spellings = [GCC<"nothrow">, Declspec<"nothrow">];
1160 let Documentation = [Undocumented];
1163 def NvWeak : IgnoredAttr {
1164 let Spellings = [GNU<"nv_weak">];
1165 let LangOpts = [CUDA];
1168 def ObjCBridge : InheritableAttr {
1169 let Spellings = [GNU<"objc_bridge">];
1170 let Subjects = SubjectList<[Record, TypedefName], ErrorDiag,
1171 "ExpectedStructOrUnionOrTypedef">;
1172 let Args = [IdentifierArgument<"BridgedType">];
1173 let Documentation = [Undocumented];
1176 def ObjCBridgeMutable : InheritableAttr {
1177 let Spellings = [GNU<"objc_bridge_mutable">];
1178 let Subjects = SubjectList<[Record], ErrorDiag>;
1179 let Args = [IdentifierArgument<"BridgedType">];
1180 let Documentation = [Undocumented];
1183 def ObjCBridgeRelated : InheritableAttr {
1184 let Spellings = [GNU<"objc_bridge_related">];
1185 let Subjects = SubjectList<[Record], ErrorDiag>;
1186 let Args = [IdentifierArgument<"RelatedClass">,
1187 IdentifierArgument<"ClassMethod", 1>,
1188 IdentifierArgument<"InstanceMethod", 1>];
1189 let HasCustomParsing = 1;
1190 let Documentation = [Undocumented];
1193 def NSReturnsRetained : InheritableAttr {
1194 let Spellings = [GNU<"ns_returns_retained">];
1195 // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>;
1196 let Documentation = [Undocumented];
1199 def NSReturnsNotRetained : InheritableAttr {
1200 let Spellings = [GNU<"ns_returns_not_retained">];
1201 // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>;
1202 let Documentation = [Undocumented];
1205 def NSReturnsAutoreleased : InheritableAttr {
1206 let Spellings = [GNU<"ns_returns_autoreleased">];
1207 // let Subjects = SubjectList<[ObjCMethod, ObjCProperty, Function]>;
1208 let Documentation = [Undocumented];
1211 def NSConsumesSelf : InheritableAttr {
1212 let Spellings = [GNU<"ns_consumes_self">];
1213 let Subjects = SubjectList<[ObjCMethod]>;
1214 let Documentation = [Undocumented];
1217 def NSConsumed : InheritableParamAttr {
1218 let Spellings = [GNU<"ns_consumed">];
1219 let Subjects = SubjectList<[ParmVar]>;
1220 let Documentation = [Undocumented];
1223 def ObjCException : InheritableAttr {
1224 let Spellings = [GNU<"objc_exception">];
1225 let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
1226 let Documentation = [Undocumented];
1229 def ObjCMethodFamily : InheritableAttr {
1230 let Spellings = [GNU<"objc_method_family">];
1231 let Subjects = SubjectList<[ObjCMethod], ErrorDiag>;
1232 let Args = [EnumArgument<"Family", "FamilyKind",
1233 ["none", "alloc", "copy", "init", "mutableCopy", "new"],
1234 ["OMF_None", "OMF_alloc", "OMF_copy", "OMF_init",
1235 "OMF_mutableCopy", "OMF_new"]>];
1236 let Documentation = [ObjCMethodFamilyDocs];
1239 def ObjCNSObject : InheritableAttr {
1240 let Spellings = [GNU<"NSObject">];
1241 let Documentation = [Undocumented];
1244 def ObjCIndependentClass : InheritableAttr {
1245 let Spellings = [GNU<"objc_independent_class">];
1246 let Documentation = [Undocumented];
1249 def ObjCPreciseLifetime : InheritableAttr {
1250 let Spellings = [GNU<"objc_precise_lifetime">];
1251 let Subjects = SubjectList<[Var], ErrorDiag>;
1252 let Documentation = [Undocumented];
1255 def ObjCReturnsInnerPointer : InheritableAttr {
1256 let Spellings = [GNU<"objc_returns_inner_pointer">];
1257 let Subjects = SubjectList<[ObjCMethod, ObjCProperty], ErrorDiag>;
1258 let Documentation = [Undocumented];
1261 def ObjCRequiresSuper : InheritableAttr {
1262 let Spellings = [GNU<"objc_requires_super">];
1263 let Subjects = SubjectList<[ObjCMethod], ErrorDiag>;
1264 let Documentation = [ObjCRequiresSuperDocs];
1267 def ObjCRootClass : InheritableAttr {
1268 let Spellings = [GNU<"objc_root_class">];
1269 let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
1270 let Documentation = [Undocumented];
1273 def ObjCExplicitProtocolImpl : InheritableAttr {
1274 let Spellings = [GNU<"objc_protocol_requires_explicit_implementation">];
1275 let Subjects = SubjectList<[ObjCProtocol], ErrorDiag>;
1276 let Documentation = [Undocumented];
1279 def ObjCDesignatedInitializer : Attr {
1280 let Spellings = [GNU<"objc_designated_initializer">];
1281 let Subjects = SubjectList<[ObjCInterfaceDeclInitMethod], ErrorDiag,
1282 "ExpectedObjCInterfaceDeclInitMethod">;
1283 let Documentation = [Undocumented];
1286 def ObjCRuntimeName : Attr {
1287 let Spellings = [GNU<"objc_runtime_name">];
1288 let Subjects = SubjectList<[ObjCInterface, ObjCProtocol], ErrorDiag>;
1289 let Args = [StringArgument<"MetadataName">];
1290 let Documentation = [ObjCRuntimeNameDocs];
1293 def ObjCRuntimeVisible : Attr {
1294 let Spellings = [GNU<"objc_runtime_visible">];
1295 let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
1296 let Documentation = [ObjCRuntimeVisibleDocs];
1299 def ObjCBoxable : Attr {
1300 let Spellings = [GNU<"objc_boxable">];
1301 let Subjects = SubjectList<[Record], ErrorDiag, "ExpectedStructOrUnion">;
1302 let Documentation = [ObjCBoxableDocs];
1305 def OptimizeNone : InheritableAttr {
1306 let Spellings = [GNU<"optnone">, CXX11<"clang", "optnone">];
1307 let Subjects = SubjectList<[Function, ObjCMethod]>;
1308 let Documentation = [OptnoneDocs];
1311 def Overloadable : Attr {
1312 let Spellings = [GNU<"overloadable">];
1313 let Subjects = SubjectList<[Function], ErrorDiag>;
1314 let Documentation = [OverloadableDocs];
1317 def Override : InheritableAttr {
1318 let Spellings = [Keyword<"override">];
1319 let SemaHandler = 0;
1320 let Documentation = [Undocumented];
1323 def Ownership : InheritableAttr {
1324 let Spellings = [GNU<"ownership_holds">, GNU<"ownership_returns">,
1325 GNU<"ownership_takes">];
1326 let Accessors = [Accessor<"isHolds", [GNU<"ownership_holds">]>,
1327 Accessor<"isReturns", [GNU<"ownership_returns">]>,
1328 Accessor<"isTakes", [GNU<"ownership_takes">]>];
1329 let AdditionalMembers = [{
1330 enum OwnershipKind { Holds, Returns, Takes };
1331 OwnershipKind getOwnKind() const {
1332 return isHolds() ? Holds :
1337 let Args = [IdentifierArgument<"Module">, VariadicUnsignedArgument<"Args">];
1338 let Subjects = SubjectList<[HasFunctionProto], WarnDiag,
1339 "ExpectedFunctionWithProtoType">;
1340 let Documentation = [Undocumented];
1343 def Packed : InheritableAttr {
1344 let Spellings = [GCC<"packed">];
1345 // let Subjects = [Tag, Field];
1346 let Documentation = [Undocumented];
1349 def IntelOclBicc : InheritableAttr {
1350 let Spellings = [GNU<"intel_ocl_bicc">];
1351 // let Subjects = [Function, ObjCMethod];
1352 let Documentation = [Undocumented];
1355 def Pcs : InheritableAttr {
1356 let Spellings = [GCC<"pcs">];
1357 let Args = [EnumArgument<"PCS", "PCSType",
1358 ["aapcs", "aapcs-vfp"],
1359 ["AAPCS", "AAPCS_VFP"]>];
1360 // let Subjects = [Function, ObjCMethod];
1361 let Documentation = [PcsDocs];
1364 def Pure : InheritableAttr {
1365 let Spellings = [GCC<"pure">];
1366 let Documentation = [Undocumented];
1369 def Regparm : TypeAttr {
1370 let Spellings = [GCC<"regparm">];
1371 let Args = [UnsignedArgument<"NumParams">];
1372 let Documentation = [RegparmDocs];
1375 def ReqdWorkGroupSize : InheritableAttr {
1376 let Spellings = [GNU<"reqd_work_group_size">];
1377 let Args = [UnsignedArgument<"XDim">, UnsignedArgument<"YDim">,
1378 UnsignedArgument<"ZDim">];
1379 let Subjects = SubjectList<[Function], ErrorDiag>;
1380 let Documentation = [Undocumented];
1383 def WorkGroupSizeHint : InheritableAttr {
1384 let Spellings = [GNU<"work_group_size_hint">];
1385 let Args = [UnsignedArgument<"XDim">,
1386 UnsignedArgument<"YDim">,
1387 UnsignedArgument<"ZDim">];
1388 let Subjects = SubjectList<[Function], ErrorDiag>;
1389 let Documentation = [Undocumented];
1392 def InitPriority : InheritableAttr {
1393 let Spellings = [GNU<"init_priority">];
1394 let Args = [UnsignedArgument<"Priority">];
1395 let Subjects = SubjectList<[Var], ErrorDiag>;
1396 let Documentation = [Undocumented];
1399 def Section : InheritableAttr {
1400 let Spellings = [GCC<"section">, Declspec<"allocate">];
1401 let Args = [StringArgument<"Name">];
1402 let Subjects = SubjectList<[Function, GlobalVar,
1403 ObjCMethod, ObjCProperty], ErrorDiag,
1404 "ExpectedFunctionGlobalVarMethodOrProperty">;
1405 let Documentation = [SectionDocs];
1408 def Sentinel : InheritableAttr {
1409 let Spellings = [GCC<"sentinel">];
1410 let Args = [DefaultIntArgument<"Sentinel", 0>,
1411 DefaultIntArgument<"NullPos", 0>];
1412 // let Subjects = SubjectList<[Function, ObjCMethod, Block, Var]>;
1413 let Documentation = [Undocumented];
1416 def StdCall : InheritableAttr {
1417 let Spellings = [GCC<"stdcall">, Keyword<"__stdcall">, Keyword<"_stdcall">];
1418 // let Subjects = [Function, ObjCMethod];
1419 let Documentation = [StdCallDocs];
1422 def SwiftCall : InheritableAttr {
1423 let Spellings = [GCC<"swiftcall">];
1424 // let Subjects = SubjectList<[Function]>;
1425 let Documentation = [SwiftCallDocs];
1428 def SwiftContext : ParameterABIAttr {
1429 let Spellings = [GCC<"swift_context">];
1430 let Documentation = [SwiftContextDocs];
1433 def SwiftErrorResult : ParameterABIAttr {
1434 let Spellings = [GCC<"swift_error_result">];
1435 let Documentation = [SwiftErrorResultDocs];
1438 def SwiftIndirectResult : ParameterABIAttr {
1439 let Spellings = [GCC<"swift_indirect_result">];
1440 let Documentation = [SwiftIndirectResultDocs];
1443 def SysVABI : InheritableAttr {
1444 let Spellings = [GCC<"sysv_abi">];
1445 // let Subjects = [Function, ObjCMethod];
1446 let Documentation = [Undocumented];
1449 def ThisCall : InheritableAttr {
1450 let Spellings = [GCC<"thiscall">, Keyword<"__thiscall">,
1451 Keyword<"_thiscall">];
1452 // let Subjects = [Function, ObjCMethod];
1453 let Documentation = [ThisCallDocs];
1456 def VectorCall : InheritableAttr {
1457 let Spellings = [GNU<"vectorcall">, Keyword<"__vectorcall">,
1458 Keyword<"_vectorcall">];
1459 // let Subjects = [Function, ObjCMethod];
1460 let Documentation = [VectorCallDocs];
1463 def Pascal : InheritableAttr {
1464 let Spellings = [GNU<"pascal">, Keyword<"__pascal">, Keyword<"_pascal">];
1465 // let Subjects = [Function, ObjCMethod];
1466 let Documentation = [Undocumented];
1469 def PreserveMost : InheritableAttr {
1470 let Spellings = [GNU<"preserve_most">];
1471 let Documentation = [PreserveMostDocs];
1474 def PreserveAll : InheritableAttr {
1475 let Spellings = [GNU<"preserve_all">];
1476 let Documentation = [PreserveAllDocs];
1479 def Target : InheritableAttr {
1480 let Spellings = [GCC<"target">];
1481 let Args = [StringArgument<"featuresStr">];
1482 let Subjects = SubjectList<[Function], ErrorDiag>;
1483 let Documentation = [TargetDocs];
1484 let AdditionalMembers = [{
1485 typedef std::pair<std::vector<std::string>, StringRef> ParsedTargetAttr;
1486 ParsedTargetAttr parse() const {
1487 ParsedTargetAttr Ret;
1488 SmallVector<StringRef, 1> AttrFeatures;
1489 getFeaturesStr().split(AttrFeatures, ",");
1491 // Grab the various features and prepend a "+" to turn on the feature to
1492 // the backend and add them to our existing set of features.
1493 for (auto &Feature : AttrFeatures) {
1494 // Go ahead and trim whitespace rather than either erroring or
1495 // accepting it weirdly.
1496 Feature = Feature.trim();
1498 // We don't support cpu tuning this way currently.
1499 // TODO: Support the fpmath option. It will require checking
1500 // overall feature validity for the function with the rest of the
1501 // attributes on the function.
1502 if (Feature.startswith("fpmath=") || Feature.startswith("tune="))
1505 // While we're here iterating check for a different target cpu.
1506 if (Feature.startswith("arch="))
1507 Ret.second = Feature.split("=").second.trim();
1508 else if (Feature.startswith("no-"))
1509 Ret.first.push_back("-" + Feature.split("-").second.str());
1511 Ret.first.push_back("+" + Feature.str());
1518 def TransparentUnion : InheritableAttr {
1519 let Spellings = [GCC<"transparent_union">];
1520 // let Subjects = SubjectList<[Record, TypedefName]>;
1521 let Documentation = [Undocumented];
1524 def Unavailable : InheritableAttr {
1525 let Spellings = [GNU<"unavailable">];
1526 let Args = [StringArgument<"Message", 1>,
1527 EnumArgument<"ImplicitReason", "ImplicitReason",
1530 "IR_ARCForbiddenType",
1532 "IR_ARCForbiddenConversion",
1533 "IR_ARCInitReturnsUnrelated",
1534 "IR_ARCFieldWithOwnership"], 1, /*fake*/ 1>];
1535 let Documentation = [Undocumented];
1538 def ArcWeakrefUnavailable : InheritableAttr {
1539 let Spellings = [GNU<"objc_arc_weak_reference_unavailable">];
1540 let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
1541 let Documentation = [Undocumented];
1544 def ObjCGC : TypeAttr {
1545 let Spellings = [GNU<"objc_gc">];
1546 let Args = [IdentifierArgument<"Kind">];
1547 let Documentation = [Undocumented];
1550 def ObjCOwnership : InheritableAttr {
1551 let Spellings = [GNU<"objc_ownership">];
1552 let Args = [IdentifierArgument<"Kind">];
1554 let Documentation = [Undocumented];
1557 def ObjCRequiresPropertyDefs : InheritableAttr {
1558 let Spellings = [GNU<"objc_requires_property_definitions">];
1559 let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
1560 let Documentation = [Undocumented];
1563 def Unused : InheritableAttr {
1564 let Spellings = [CXX11<"", "maybe_unused", 201603>, GCC<"unused">];
1565 let Subjects = SubjectList<[Var, ObjCIvar, Type, Enum, EnumConstant, Label,
1566 Field, ObjCMethod, FunctionLike], WarnDiag,
1567 "ExpectedForMaybeUnused">;
1568 let Documentation = [WarnMaybeUnusedDocs];
1571 def Used : InheritableAttr {
1572 let Spellings = [GCC<"used">];
1573 let Documentation = [Undocumented];
1576 def Uuid : InheritableAttr {
1577 let Spellings = [Declspec<"uuid">];
1578 let Args = [StringArgument<"Guid">];
1579 // let Subjects = SubjectList<[CXXRecord]>;
1580 let LangOpts = [MicrosoftExt, Borland];
1581 let Documentation = [Undocumented];
1584 def VectorSize : TypeAttr {
1585 let Spellings = [GCC<"vector_size">];
1586 let Args = [ExprArgument<"NumBytes">];
1587 let Documentation = [Undocumented];
1590 def VecTypeHint : InheritableAttr {
1591 let Spellings = [GNU<"vec_type_hint">];
1592 let Args = [TypeArgument<"TypeHint">];
1593 let Subjects = SubjectList<[Function], ErrorDiag>;
1594 let Documentation = [Undocumented];
1597 def Visibility : InheritableAttr {
1599 let Spellings = [GCC<"visibility">];
1600 let Args = [EnumArgument<"Visibility", "VisibilityType",
1601 ["default", "hidden", "internal", "protected"],
1602 ["Default", "Hidden", "Hidden", "Protected"]>];
1603 let Documentation = [Undocumented];
1606 def TypeVisibility : InheritableAttr {
1608 let Spellings = [GNU<"type_visibility">, CXX11<"clang", "type_visibility">];
1609 let Args = [EnumArgument<"Visibility", "VisibilityType",
1610 ["default", "hidden", "internal", "protected"],
1611 ["Default", "Hidden", "Hidden", "Protected"]>];
1612 // let Subjects = [Tag, ObjCInterface, Namespace];
1613 let Documentation = [Undocumented];
1616 def VecReturn : InheritableAttr {
1617 let Spellings = [GNU<"vecreturn">];
1618 let Subjects = SubjectList<[CXXRecord], ErrorDiag>;
1619 let Documentation = [Undocumented];
1622 def WarnUnused : InheritableAttr {
1623 let Spellings = [GNU<"warn_unused">];
1624 let Subjects = SubjectList<[Record]>;
1625 let Documentation = [Undocumented];
1628 def WarnUnusedResult : InheritableAttr {
1629 let Spellings = [CXX11<"", "nodiscard", 201603>,
1630 CXX11<"clang", "warn_unused_result">,
1631 GCC<"warn_unused_result">];
1632 let Subjects = SubjectList<[ObjCMethod, Enum, CXXRecord, FunctionLike],
1633 WarnDiag, "ExpectedFunctionMethodEnumOrClass">;
1634 let Documentation = [WarnUnusedResultsDocs];
1637 def Weak : InheritableAttr {
1638 let Spellings = [GCC<"weak">];
1639 let Subjects = SubjectList<[Var, Function, CXXRecord]>;
1640 let Documentation = [Undocumented];
1643 def WeakImport : InheritableAttr {
1644 let Spellings = [GNU<"weak_import">];
1645 let Documentation = [Undocumented];
1648 def WeakRef : InheritableAttr {
1649 let Spellings = [GCC<"weakref">];
1650 // A WeakRef that has an argument is treated as being an AliasAttr
1651 let Args = [StringArgument<"Aliasee", 1>];
1652 let Subjects = SubjectList<[Var, Function], ErrorDiag>;
1653 let Documentation = [Undocumented];
1656 def LTOVisibilityPublic : InheritableAttr {
1657 let Spellings = [CXX11<"clang", "lto_visibility_public">];
1658 let Subjects = SubjectList<[Record]>;
1659 let Documentation = [LTOVisibilityDocs];
1662 def AnyX86Interrupt : InheritableAttr, TargetSpecificAttr<TargetAnyX86> {
1663 // NOTE: If you add any additional spellings, ARMInterrupt's,
1664 // MSP430Interrupt's and MipsInterrupt's spellings must match.
1665 let Spellings = [GNU<"interrupt">];
1666 let Subjects = SubjectList<[HasFunctionProto]>;
1667 let ParseKind = "Interrupt";
1668 let HasCustomParsing = 1;
1669 let Documentation = [AnyX86InterruptDocs];
1672 def X86ForceAlignArgPointer : InheritableAttr, TargetSpecificAttr<TargetX86> {
1673 let Spellings = [GNU<"force_align_arg_pointer">];
1674 // Technically, this appertains to a FunctionDecl, but the target-specific
1675 // code silently allows anything function-like (such as typedefs or function
1676 // pointers), but does not apply the attribute to them.
1677 let Documentation = [Undocumented];
1680 def NoSanitize : InheritableAttr {
1681 let Spellings = [GNU<"no_sanitize">, CXX11<"clang", "no_sanitize">];
1682 let Args = [VariadicStringArgument<"Sanitizers">];
1683 let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>;
1684 let Documentation = [NoSanitizeDocs];
1685 let AdditionalMembers = [{
1686 SanitizerMask getMask() const {
1687 SanitizerMask Mask = 0;
1688 for (auto SanitizerName : sanitizers()) {
1689 SanitizerMask ParsedMask =
1690 parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
1691 Mask |= expandSanitizerGroups(ParsedMask);
1698 // Attributes to disable a specific sanitizer. No new sanitizers should be added
1699 // to this list; the no_sanitize attribute should be extended instead.
1700 def NoSanitizeSpecific : InheritableAttr {
1701 let Spellings = [GCC<"no_address_safety_analysis">,
1702 GCC<"no_sanitize_address">,
1703 GCC<"no_sanitize_thread">,
1704 GNU<"no_sanitize_memory">];
1705 let Subjects = SubjectList<[Function], ErrorDiag>;
1706 let Documentation = [NoSanitizeAddressDocs, NoSanitizeThreadDocs,
1707 NoSanitizeMemoryDocs];
1711 // C/C++ Thread safety attributes (e.g. for deadlock, data race checking)
1713 def GuardedVar : InheritableAttr {
1714 let Spellings = [GNU<"guarded_var">];
1715 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1716 "ExpectedFieldOrGlobalVar">;
1717 let Documentation = [Undocumented];
1720 def PtGuardedVar : InheritableAttr {
1721 let Spellings = [GNU<"pt_guarded_var">];
1722 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1723 "ExpectedFieldOrGlobalVar">;
1724 let Documentation = [Undocumented];
1727 def Lockable : InheritableAttr {
1728 let Spellings = [GNU<"lockable">];
1729 let Subjects = SubjectList<[Record]>;
1730 let Documentation = [Undocumented];
1731 let ASTNode = 0; // Replaced by Capability
1734 def ScopedLockable : InheritableAttr {
1735 let Spellings = [GNU<"scoped_lockable">];
1736 let Subjects = SubjectList<[Record]>;
1737 let Documentation = [Undocumented];
1740 def Capability : InheritableAttr {
1741 let Spellings = [GNU<"capability">, CXX11<"clang", "capability">,
1742 GNU<"shared_capability">,
1743 CXX11<"clang", "shared_capability">];
1744 let Subjects = SubjectList<[Record, TypedefName], ErrorDiag,
1745 "ExpectedStructOrUnionOrTypedef">;
1746 let Args = [StringArgument<"Name">];
1747 let Accessors = [Accessor<"isShared",
1748 [GNU<"shared_capability">,
1749 CXX11<"clang","shared_capability">]>];
1750 let Documentation = [Undocumented];
1751 let AdditionalMembers = [{
1752 bool isMutex() const { return getName().equals_lower("mutex"); }
1753 bool isRole() const { return getName().equals_lower("role"); }
1757 def AssertCapability : InheritableAttr {
1758 let Spellings = [GNU<"assert_capability">,
1759 CXX11<"clang", "assert_capability">,
1760 GNU<"assert_shared_capability">,
1761 CXX11<"clang", "assert_shared_capability">];
1762 let Subjects = SubjectList<[Function]>;
1764 let TemplateDependent = 1;
1765 let ParseArgumentsAsUnevaluated = 1;
1766 let DuplicatesAllowedWhileMerging = 1;
1767 let Args = [ExprArgument<"Expr">];
1768 let Accessors = [Accessor<"isShared",
1769 [GNU<"assert_shared_capability">,
1770 CXX11<"clang", "assert_shared_capability">]>];
1771 let Documentation = [AssertCapabilityDocs];
1774 def AcquireCapability : InheritableAttr {
1775 let Spellings = [GNU<"acquire_capability">,
1776 CXX11<"clang", "acquire_capability">,
1777 GNU<"acquire_shared_capability">,
1778 CXX11<"clang", "acquire_shared_capability">,
1779 GNU<"exclusive_lock_function">,
1780 GNU<"shared_lock_function">];
1781 let Subjects = SubjectList<[Function]>;
1783 let TemplateDependent = 1;
1784 let ParseArgumentsAsUnevaluated = 1;
1785 let DuplicatesAllowedWhileMerging = 1;
1786 let Args = [VariadicExprArgument<"Args">];
1787 let Accessors = [Accessor<"isShared",
1788 [GNU<"acquire_shared_capability">,
1789 CXX11<"clang", "acquire_shared_capability">,
1790 GNU<"shared_lock_function">]>];
1791 let Documentation = [AcquireCapabilityDocs];
1794 def TryAcquireCapability : InheritableAttr {
1795 let Spellings = [GNU<"try_acquire_capability">,
1796 CXX11<"clang", "try_acquire_capability">,
1797 GNU<"try_acquire_shared_capability">,
1798 CXX11<"clang", "try_acquire_shared_capability">];
1799 let Subjects = SubjectList<[Function],
1802 let TemplateDependent = 1;
1803 let ParseArgumentsAsUnevaluated = 1;
1804 let DuplicatesAllowedWhileMerging = 1;
1805 let Args = [ExprArgument<"SuccessValue">, VariadicExprArgument<"Args">];
1806 let Accessors = [Accessor<"isShared",
1807 [GNU<"try_acquire_shared_capability">,
1808 CXX11<"clang", "try_acquire_shared_capability">]>];
1809 let Documentation = [TryAcquireCapabilityDocs];
1812 def ReleaseCapability : InheritableAttr {
1813 let Spellings = [GNU<"release_capability">,
1814 CXX11<"clang", "release_capability">,
1815 GNU<"release_shared_capability">,
1816 CXX11<"clang", "release_shared_capability">,
1817 GNU<"release_generic_capability">,
1818 CXX11<"clang", "release_generic_capability">,
1819 GNU<"unlock_function">];
1820 let Subjects = SubjectList<[Function]>;
1822 let TemplateDependent = 1;
1823 let ParseArgumentsAsUnevaluated = 1;
1824 let DuplicatesAllowedWhileMerging = 1;
1825 let Args = [VariadicExprArgument<"Args">];
1826 let Accessors = [Accessor<"isShared",
1827 [GNU<"release_shared_capability">,
1828 CXX11<"clang", "release_shared_capability">]>,
1829 Accessor<"isGeneric",
1830 [GNU<"release_generic_capability">,
1831 CXX11<"clang", "release_generic_capability">,
1832 GNU<"unlock_function">]>];
1833 let Documentation = [ReleaseCapabilityDocs];
1836 def RequiresCapability : InheritableAttr {
1837 let Spellings = [GNU<"requires_capability">,
1838 CXX11<"clang", "requires_capability">,
1839 GNU<"exclusive_locks_required">,
1840 GNU<"requires_shared_capability">,
1841 CXX11<"clang", "requires_shared_capability">,
1842 GNU<"shared_locks_required">];
1843 let Args = [VariadicExprArgument<"Args">];
1845 let TemplateDependent = 1;
1846 let ParseArgumentsAsUnevaluated = 1;
1847 let DuplicatesAllowedWhileMerging = 1;
1848 let Subjects = SubjectList<[Function]>;
1849 let Accessors = [Accessor<"isShared", [GNU<"requires_shared_capability">,
1850 GNU<"shared_locks_required">,
1851 CXX11<"clang","requires_shared_capability">]>];
1852 let Documentation = [Undocumented];
1855 def NoThreadSafetyAnalysis : InheritableAttr {
1856 let Spellings = [GNU<"no_thread_safety_analysis">];
1857 let Subjects = SubjectList<[Function]>;
1858 let Documentation = [Undocumented];
1861 def GuardedBy : InheritableAttr {
1862 let Spellings = [GNU<"guarded_by">];
1863 let Args = [ExprArgument<"Arg">];
1865 let TemplateDependent = 1;
1866 let ParseArgumentsAsUnevaluated = 1;
1867 let DuplicatesAllowedWhileMerging = 1;
1868 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1869 "ExpectedFieldOrGlobalVar">;
1870 let Documentation = [Undocumented];
1873 def PtGuardedBy : InheritableAttr {
1874 let Spellings = [GNU<"pt_guarded_by">];
1875 let Args = [ExprArgument<"Arg">];
1877 let TemplateDependent = 1;
1878 let ParseArgumentsAsUnevaluated = 1;
1879 let DuplicatesAllowedWhileMerging = 1;
1880 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1881 "ExpectedFieldOrGlobalVar">;
1882 let Documentation = [Undocumented];
1885 def AcquiredAfter : InheritableAttr {
1886 let Spellings = [GNU<"acquired_after">];
1887 let Args = [VariadicExprArgument<"Args">];
1889 let TemplateDependent = 1;
1890 let ParseArgumentsAsUnevaluated = 1;
1891 let DuplicatesAllowedWhileMerging = 1;
1892 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1893 "ExpectedFieldOrGlobalVar">;
1894 let Documentation = [Undocumented];
1897 def AcquiredBefore : InheritableAttr {
1898 let Spellings = [GNU<"acquired_before">];
1899 let Args = [VariadicExprArgument<"Args">];
1901 let TemplateDependent = 1;
1902 let ParseArgumentsAsUnevaluated = 1;
1903 let DuplicatesAllowedWhileMerging = 1;
1904 let Subjects = SubjectList<[Field, SharedVar], WarnDiag,
1905 "ExpectedFieldOrGlobalVar">;
1906 let Documentation = [Undocumented];
1909 def AssertExclusiveLock : InheritableAttr {
1910 let Spellings = [GNU<"assert_exclusive_lock">];
1911 let Args = [VariadicExprArgument<"Args">];
1913 let TemplateDependent = 1;
1914 let ParseArgumentsAsUnevaluated = 1;
1915 let DuplicatesAllowedWhileMerging = 1;
1916 let Subjects = SubjectList<[Function]>;
1917 let Documentation = [Undocumented];
1920 def AssertSharedLock : InheritableAttr {
1921 let Spellings = [GNU<"assert_shared_lock">];
1922 let Args = [VariadicExprArgument<"Args">];
1924 let TemplateDependent = 1;
1925 let ParseArgumentsAsUnevaluated = 1;
1926 let DuplicatesAllowedWhileMerging = 1;
1927 let Subjects = SubjectList<[Function]>;
1928 let Documentation = [Undocumented];
1931 // The first argument is an integer or boolean value specifying the return value
1932 // of a successful lock acquisition.
1933 def ExclusiveTrylockFunction : InheritableAttr {
1934 let Spellings = [GNU<"exclusive_trylock_function">];
1935 let Args = [ExprArgument<"SuccessValue">, VariadicExprArgument<"Args">];
1937 let TemplateDependent = 1;
1938 let ParseArgumentsAsUnevaluated = 1;
1939 let DuplicatesAllowedWhileMerging = 1;
1940 let Subjects = SubjectList<[Function]>;
1941 let Documentation = [Undocumented];
1944 // The first argument is an integer or boolean value specifying the return value
1945 // of a successful lock acquisition.
1946 def SharedTrylockFunction : InheritableAttr {
1947 let Spellings = [GNU<"shared_trylock_function">];
1948 let Args = [ExprArgument<"SuccessValue">, VariadicExprArgument<"Args">];
1950 let TemplateDependent = 1;
1951 let ParseArgumentsAsUnevaluated = 1;
1952 let DuplicatesAllowedWhileMerging = 1;
1953 let Subjects = SubjectList<[Function]>;
1954 let Documentation = [Undocumented];
1957 def LockReturned : InheritableAttr {
1958 let Spellings = [GNU<"lock_returned">];
1959 let Args = [ExprArgument<"Arg">];
1961 let TemplateDependent = 1;
1962 let ParseArgumentsAsUnevaluated = 1;
1963 let Subjects = SubjectList<[Function]>;
1964 let Documentation = [Undocumented];
1967 def LocksExcluded : InheritableAttr {
1968 let Spellings = [GNU<"locks_excluded">];
1969 let Args = [VariadicExprArgument<"Args">];
1971 let TemplateDependent = 1;
1972 let ParseArgumentsAsUnevaluated = 1;
1973 let DuplicatesAllowedWhileMerging = 1;
1974 let Subjects = SubjectList<[Function]>;
1975 let Documentation = [Undocumented];
1978 // C/C++ consumed attributes.
1980 def Consumable : InheritableAttr {
1981 let Spellings = [GNU<"consumable">];
1982 let Subjects = SubjectList<[CXXRecord]>;
1983 let Args = [EnumArgument<"DefaultState", "ConsumedState",
1984 ["unknown", "consumed", "unconsumed"],
1985 ["Unknown", "Consumed", "Unconsumed"]>];
1986 let Documentation = [ConsumableDocs];
1989 def ConsumableAutoCast : InheritableAttr {
1990 let Spellings = [GNU<"consumable_auto_cast_state">];
1991 let Subjects = SubjectList<[CXXRecord]>;
1992 let Documentation = [Undocumented];
1995 def ConsumableSetOnRead : InheritableAttr {
1996 let Spellings = [GNU<"consumable_set_state_on_read">];
1997 let Subjects = SubjectList<[CXXRecord]>;
1998 let Documentation = [Undocumented];
2001 def CallableWhen : InheritableAttr {
2002 let Spellings = [GNU<"callable_when">];
2003 let Subjects = SubjectList<[CXXMethod]>;
2004 let Args = [VariadicEnumArgument<"CallableStates", "ConsumedState",
2005 ["unknown", "consumed", "unconsumed"],
2006 ["Unknown", "Consumed", "Unconsumed"]>];
2007 let Documentation = [CallableWhenDocs];
2010 def ParamTypestate : InheritableAttr {
2011 let Spellings = [GNU<"param_typestate">];
2012 let Subjects = SubjectList<[ParmVar]>;
2013 let Args = [EnumArgument<"ParamState", "ConsumedState",
2014 ["unknown", "consumed", "unconsumed"],
2015 ["Unknown", "Consumed", "Unconsumed"]>];
2016 let Documentation = [ParamTypestateDocs];
2019 def ReturnTypestate : InheritableAttr {
2020 let Spellings = [GNU<"return_typestate">];
2021 let Subjects = SubjectList<[Function, ParmVar]>;
2022 let Args = [EnumArgument<"State", "ConsumedState",
2023 ["unknown", "consumed", "unconsumed"],
2024 ["Unknown", "Consumed", "Unconsumed"]>];
2025 let Documentation = [ReturnTypestateDocs];
2028 def SetTypestate : InheritableAttr {
2029 let Spellings = [GNU<"set_typestate">];
2030 let Subjects = SubjectList<[CXXMethod]>;
2031 let Args = [EnumArgument<"NewState", "ConsumedState",
2032 ["unknown", "consumed", "unconsumed"],
2033 ["Unknown", "Consumed", "Unconsumed"]>];
2034 let Documentation = [SetTypestateDocs];
2037 def TestTypestate : InheritableAttr {
2038 let Spellings = [GNU<"test_typestate">];
2039 let Subjects = SubjectList<[CXXMethod]>;
2040 let Args = [EnumArgument<"TestState", "ConsumedState",
2041 ["consumed", "unconsumed"],
2042 ["Consumed", "Unconsumed"]>];
2043 let Documentation = [TestTypestateDocs];
2046 // Type safety attributes for `void *' pointers and type tags.
2048 def ArgumentWithTypeTag : InheritableAttr {
2049 let Spellings = [GNU<"argument_with_type_tag">,
2050 GNU<"pointer_with_type_tag">];
2051 let Args = [IdentifierArgument<"ArgumentKind">,
2052 UnsignedArgument<"ArgumentIdx">,
2053 UnsignedArgument<"TypeTagIdx">,
2054 BoolArgument<"IsPointer">];
2055 let HasCustomParsing = 1;
2056 let Documentation = [ArgumentWithTypeTagDocs, PointerWithTypeTagDocs];
2059 def TypeTagForDatatype : InheritableAttr {
2060 let Spellings = [GNU<"type_tag_for_datatype">];
2061 let Args = [IdentifierArgument<"ArgumentKind">,
2062 TypeArgument<"MatchingCType">,
2063 BoolArgument<"LayoutCompatible">,
2064 BoolArgument<"MustBeNull">];
2065 // let Subjects = SubjectList<[Var], ErrorDiag>;
2066 let HasCustomParsing = 1;
2067 let Documentation = [TypeTagForDatatypeDocs];
2070 // Microsoft-related attributes
2072 def MSNoVTable : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> {
2073 let Spellings = [Declspec<"novtable">];
2074 let Subjects = SubjectList<[CXXRecord]>;
2075 let Documentation = [MSNoVTableDocs];
2079 let Spellings = [Declspec<"property">];
2082 def MSStruct : InheritableAttr {
2083 let Spellings = [GCC<"ms_struct">];
2084 let Subjects = SubjectList<[Record]>;
2085 let Documentation = [Undocumented];
2088 def DLLExport : InheritableAttr, TargetSpecificAttr<TargetWindows> {
2089 let Spellings = [Declspec<"dllexport">, GCC<"dllexport">];
2090 let Subjects = SubjectList<[Function, Var, CXXRecord, ObjCInterface]>;
2091 let Documentation = [DLLExportDocs];
2094 def DLLImport : InheritableAttr, TargetSpecificAttr<TargetWindows> {
2095 let Spellings = [Declspec<"dllimport">, GCC<"dllimport">];
2096 let Subjects = SubjectList<[Function, Var, CXXRecord, ObjCInterface]>;
2097 let Documentation = [DLLImportDocs];
2100 def SelectAny : InheritableAttr {
2101 let Spellings = [Declspec<"selectany">];
2102 let LangOpts = [MicrosoftExt];
2103 let Documentation = [Undocumented];
2107 let Spellings = [Declspec<"thread">];
2108 let LangOpts = [MicrosoftExt];
2109 let Documentation = [ThreadDocs];
2110 let Subjects = SubjectList<[Var]>;
2113 def Win64 : IgnoredAttr {
2114 let Spellings = [Keyword<"__w64">];
2115 let LangOpts = [MicrosoftExt];
2118 def Ptr32 : TypeAttr {
2119 let Spellings = [Keyword<"__ptr32">];
2120 let Documentation = [Undocumented];
2123 def Ptr64 : TypeAttr {
2124 let Spellings = [Keyword<"__ptr64">];
2125 let Documentation = [Undocumented];
2128 def SPtr : TypeAttr {
2129 let Spellings = [Keyword<"__sptr">];
2130 let Documentation = [Undocumented];
2133 def UPtr : TypeAttr {
2134 let Spellings = [Keyword<"__uptr">];
2135 let Documentation = [Undocumented];
2138 def MSInheritance : InheritableAttr {
2139 let LangOpts = [MicrosoftExt];
2140 let Args = [DefaultBoolArgument<"BestCase", 1>];
2141 let Spellings = [Keyword<"__single_inheritance">,
2142 Keyword<"__multiple_inheritance">,
2143 Keyword<"__virtual_inheritance">,
2144 Keyword<"__unspecified_inheritance">];
2145 let AdditionalMembers = [{
2146 static bool hasVBPtrOffsetField(Spelling Inheritance) {
2147 return Inheritance == Keyword_unspecified_inheritance;
2150 // Only member pointers to functions need a this adjustment, since it can be
2151 // combined with the field offset for data pointers.
2152 static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) {
2153 return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance;
2156 static bool hasVBTableOffsetField(Spelling Inheritance) {
2157 return Inheritance >= Keyword_virtual_inheritance;
2160 static bool hasOnlyOneField(bool IsMemberFunction,
2161 Spelling Inheritance) {
2162 if (IsMemberFunction)
2163 return Inheritance <= Keyword_single_inheritance;
2164 return Inheritance <= Keyword_multiple_inheritance;
2167 let Documentation = [MSInheritanceDocs];
2170 def MSVtorDisp : InheritableAttr {
2171 // This attribute has no spellings as it is only ever created implicitly.
2173 let Args = [UnsignedArgument<"vdm">];
2174 let SemaHandler = 0;
2176 let AdditionalMembers = [{
2183 Mode getVtorDispMode() const { return Mode(vdm); }
2185 let Documentation = [Undocumented];
2188 def InitSeg : Attr {
2189 let Spellings = [Pragma<"", "init_seg">];
2190 let Args = [StringArgument<"Section">];
2191 let SemaHandler = 0;
2192 let Documentation = [InitSegDocs];
2193 let AdditionalMembers = [{
2194 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
2195 OS << '(' << getSection() << ')';
2200 def LoopHint : Attr {
2201 /// #pragma clang loop <option> directive
2202 /// vectorize: vectorizes loop operations if State == Enable.
2203 /// vectorize_width: vectorize loop operations with width 'Value'.
2204 /// interleave: interleave multiple loop iterations if State == Enable.
2205 /// interleave_count: interleaves 'Value' loop interations.
2206 /// unroll: fully unroll loop if State == Enable.
2207 /// unroll_count: unrolls loop 'Value' times.
2208 /// distribute: attempt to distribute loop if State == Enable
2210 /// #pragma unroll <argument> directive
2211 /// <no arg>: fully unrolls loop.
2212 /// boolean: fully unrolls loop if State == Enable.
2213 /// expression: unrolls loop 'Value' times.
2215 let Spellings = [Pragma<"clang", "loop">, Pragma<"", "unroll">,
2216 Pragma<"", "nounroll">];
2218 /// State of the loop optimization specified by the spelling.
2219 let Args = [EnumArgument<"Option", "OptionType",
2220 ["vectorize", "vectorize_width", "interleave", "interleave_count",
2221 "unroll", "unroll_count", "distribute"],
2222 ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount",
2223 "Unroll", "UnrollCount", "Distribute"]>,
2224 EnumArgument<"State", "LoopHintState",
2225 ["enable", "disable", "numeric", "assume_safety", "full"],
2226 ["Enable", "Disable", "Numeric", "AssumeSafety", "Full"]>,
2227 ExprArgument<"Value">];
2229 let AdditionalMembers = [{
2230 static const char *getOptionName(int Option) {
2232 case Vectorize: return "vectorize";
2233 case VectorizeWidth: return "vectorize_width";
2234 case Interleave: return "interleave";
2235 case InterleaveCount: return "interleave_count";
2236 case Unroll: return "unroll";
2237 case UnrollCount: return "unroll_count";
2238 case Distribute: return "distribute";
2240 llvm_unreachable("Unhandled LoopHint option.");
2243 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
2244 unsigned SpellingIndex = getSpellingListIndex();
2245 // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
2246 // "nounroll" is already emitted as the pragma name.
2247 if (SpellingIndex == Pragma_nounroll)
2249 else if (SpellingIndex == Pragma_unroll) {
2250 OS << getValueString(Policy);
2254 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
2255 OS << getOptionName(option) << getValueString(Policy);
2258 // Return a string containing the loop hint argument including the
2259 // enclosing parentheses.
2260 std::string getValueString(const PrintingPolicy &Policy) const {
2261 std::string ValueName;
2262 llvm::raw_string_ostream OS(ValueName);
2264 if (state == Numeric)
2265 value->printPretty(OS, nullptr, Policy);
2266 else if (state == Enable)
2268 else if (state == Full)
2270 else if (state == AssumeSafety)
2271 OS << "assume_safety";
2278 // Return a string suitable for identifying this attribute in diagnostics.
2279 std::string getDiagnosticName(const PrintingPolicy &Policy) const {
2280 unsigned SpellingIndex = getSpellingListIndex();
2281 if (SpellingIndex == Pragma_nounroll)
2282 return "#pragma nounroll";
2283 else if (SpellingIndex == Pragma_unroll)
2284 return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : "");
2286 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
2287 return getOptionName(option) + getValueString(Policy);
2291 let Documentation = [LoopHintDocs, UnrollHintDocs];
2294 def CapturedRecord : InheritableAttr {
2295 // This attribute has no spellings as it is only ever created implicitly.
2297 let SemaHandler = 0;
2298 let Documentation = [Undocumented];
2301 def OMPThreadPrivateDecl : InheritableAttr {
2302 // This attribute has no spellings as it is only ever created implicitly.
2304 let SemaHandler = 0;
2305 let Documentation = [Undocumented];
2308 def OMPCaptureNoInit : InheritableAttr {
2309 // This attribute has no spellings as it is only ever created implicitly.
2311 let SemaHandler = 0;
2312 let Documentation = [Undocumented];
2315 def OMPDeclareSimdDecl : Attr {
2316 let Spellings = [Pragma<"omp", "declare simd">];
2317 let Subjects = SubjectList<[Function]>;
2318 let SemaHandler = 0;
2319 let HasCustomParsing = 1;
2320 let Documentation = [OMPDeclareSimdDocs];
2322 EnumArgument<"BranchState", "BranchStateTy",
2323 [ "", "inbranch", "notinbranch" ],
2324 [ "BS_Undefined", "BS_Inbranch", "BS_Notinbranch" ]>,
2325 ExprArgument<"Simdlen">, VariadicExprArgument<"Uniforms">,
2326 VariadicExprArgument<"Aligneds">, VariadicExprArgument<"Alignments">,
2327 VariadicExprArgument<"Linears">, VariadicUnsignedArgument<"Modifiers">,
2328 VariadicExprArgument<"Steps">
2330 let AdditionalMembers = [{
2331 void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
2333 if (getBranchState() != BS_Undefined)
2334 OS << ConvertBranchStateTyToStr(getBranchState()) << " ";
2335 if (auto *E = getSimdlen()) {
2337 E->printPretty(OS, nullptr, Policy);
2340 if (uniforms_size() > 0) {
2342 StringRef Sep = "(";
2343 for (auto *E : uniforms()) {
2345 E->printPretty(OS, nullptr, Policy);
2350 alignments_iterator NI = alignments_begin();
2351 for (auto *E : aligneds()) {
2353 E->printPretty(OS, nullptr, Policy);
2356 (*NI)->printPretty(OS, nullptr, Policy);
2361 steps_iterator I = steps_begin();
2362 modifiers_iterator MI = modifiers_begin();
2363 for (auto *E : linears()) {
2365 if (*MI != OMPC_LINEAR_unknown)
2366 OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
2367 E->printPretty(OS, nullptr, Policy);
2368 if (*MI != OMPC_LINEAR_unknown)
2372 (*I)->printPretty(OS, nullptr, Policy);
2382 def OMPDeclareTargetDecl : Attr {
2383 let Spellings = [Pragma<"omp", "declare target">];
2384 let SemaHandler = 0;
2385 let Documentation = [OMPDeclareTargetDocs];
2387 EnumArgument<"MapType", "MapTypeTy",
2389 [ "MT_To", "MT_Link" ]>
2391 let AdditionalMembers = [{
2392 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
2393 // Use fake syntax because it is for testing and debugging purpose only.
2394 if (getMapType() != MT_To)
2395 OS << ConvertMapTypeTyToStr(getMapType()) << " ";
2400 def InternalLinkage : InheritableAttr {
2401 let Spellings = [GNU<"internal_linkage">, CXX11<"clang", "internal_linkage">];
2402 let Subjects = SubjectList<[Var, Function, CXXRecord]>;
2403 let Documentation = [InternalLinkageDocs];