diff options
Diffstat (limited to 'contrib/llvm-project/clang/include/clang/Basic/Attr.td')
| -rw-r--r-- | contrib/llvm-project/clang/include/clang/Basic/Attr.td | 1057 |
1 files changed, 846 insertions, 211 deletions
diff --git a/contrib/llvm-project/clang/include/clang/Basic/Attr.td b/contrib/llvm-project/clang/include/clang/Basic/Attr.td index 12d09181a2ea..58838b01b4fd 100644 --- a/contrib/llvm-project/clang/include/clang/Basic/Attr.td +++ b/contrib/llvm-project/clang/include/clang/Basic/Attr.td @@ -19,10 +19,19 @@ def DocCatType : DocumentationCategory<"Type Attributes">; def DocCatStmt : DocumentationCategory<"Statement Attributes">; def DocCatDecl : DocumentationCategory<"Declaration Attributes">; -// Attributes listed under the Undocumented category do not generate any public -// documentation. Ideally, this category should be used for internal-only -// attributes which contain no spellings. -def DocCatUndocumented : DocumentationCategory<"Undocumented">; +// This category is for attributes which have not yet been properly documented, +// but should be. +def DocCatUndocumented : DocumentationCategory<"Undocumented"> { + let Content = [{ +This section lists attributes which are recognized by Clang, but which are +currently missing documentation. +}]; +} + +// Attributes listed under the InternalOnly category do not generate any entry +// in the documentation. This category should be used only when we _want_ +// to not document the attribute, e.g. if the attribute has no spellings. +def DocCatInternalOnly : DocumentationCategory<"InternalOnly">; class DocDeprecated<string replacement = ""> { // If the Replacement field is empty, no replacement will be listed with the @@ -48,11 +57,17 @@ class Documentation { DocDeprecated Deprecated; } -// Specifies that the attribute is explicitly undocumented. This can be a -// helpful placeholder for the attribute while working on the implementation, -// but should not be used once feature work has been completed. +// Specifies that the attribute is explicitly omitted from the documentation, +// because it is not intended to be user-facing. +def InternalOnly : Documentation { + let Category = DocCatInternalOnly; +} + +// Specifies that the attribute is undocumented, but that it _should_ have +// documentation. def Undocumented : Documentation { let Category = DocCatUndocumented; + let Content = "No documentation."; } include "clang/Basic/AttrDocs.td" @@ -92,6 +107,10 @@ def NonBitField : SubsetSubject<Field, [{!S->isBitField()}], "non-bit-field non-static data members">; +def BitField : SubsetSubject<Field, + [{S->isBitField()}], + "bit-field data members">; + def NonStaticCXXMethod : SubsetSubject<CXXMethod, [{!S->isStatic()}], "non-static member functions">; @@ -118,6 +137,17 @@ def SharedVar : SubsetSubject<Var, def GlobalVar : SubsetSubject<Var, [{S->hasGlobalStorage()}], "global variables">; +def ExternalGlobalVar : SubsetSubject<Var, + [{S->hasGlobalStorage() && + S->getStorageClass()!=StorageClass::SC_Static && + !S->isLocalExternDecl()}], + "external global variables">; + +def NonTLSGlobalVar : SubsetSubject<Var, + [{S->hasGlobalStorage() && + S->getTLSKind() == 0}], + "non-TLS global variables">; + def InlineFunction : SubsetSubject<Function, [{S->isInlineSpecified()}], "inline functions">; @@ -126,6 +156,14 @@ def FunctionTmpl FunctionDecl::TK_FunctionTemplate}], "function templates">; +def HLSLEntry + : SubsetSubject<Function, + [{S->isExternallyVisible() && !isa<CXXMethodDecl>(S)}], + "global functions">; +def HLSLBufferObj : SubsetSubject<HLSLBuffer, + [{isa<HLSLBufferDecl>(S)}], + "cbuffer/tbuffer">; + def ClassTmpl : SubsetSubject<CXXRecord, [{S->getDescribedClassTemplate()}], "class templates">; @@ -139,6 +177,12 @@ def FunctionLike : SubsetSubject<DeclBase, [{S->getFunctionType(false) != nullptr}], "functions, function pointers">; +// Function Pointer is a stricter version of FunctionLike that only allows function +// pointers. +def FunctionPointer : SubsetSubject<DeclBase, + [{S->isFunctionPointerType()}], + "functions pointers">; + def OpenCLKernelFunction : SubsetSubject<Function, [{S->hasAttr<OpenCLKernelAttr>()}], "kernel functions">; @@ -201,6 +245,7 @@ class DeclArgument<DeclNode kind, string name, bit opt = 0, bit fake = 0> // OMPTraitProperty := {Kind} // class OMPTraitInfoArgument<string name> : Argument<name, 0>; +class VariadicOMPInteropInfoArgument<string name> : Argument<name, 0>; class TypeArgument<string name, bit opt = 0> : Argument<name, opt>; class UnsignedArgument<string name, bit opt = 0> : Argument<name, opt>; @@ -237,64 +282,91 @@ class DefaultIntArgument<string name, int default> : IntArgument<name, 1> { int Default = default; } -// This argument is more complex, it includes the enumerator type name, -// a list of strings to accept, and a list of enumerators to map them to. +// This argument is more complex, it includes the enumerator type +// name, whether the enum type is externally defined, a list of +// strings to accept, and a list of enumerators to map them to. class EnumArgument<string name, string type, list<string> values, - list<string> enums, bit opt = 0, bit fake = 0> + list<string> enums, bit opt = 0, bit fake = 0, + bit isExternalType = 0> : Argument<name, opt, fake> { string Type = type; list<string> Values = values; list<string> Enums = enums; + bit IsExternalType = isExternalType; } // FIXME: There should be a VariadicArgument type that takes any other type // of argument and generates the appropriate type. class VariadicEnumArgument<string name, string type, list<string> values, - list<string> enums> : Argument<name, 1> { + list<string> enums, bit isExternalType = 0> + : Argument<name, 1> { string Type = type; list<string> Values = values; list<string> Enums = enums; + bit IsExternalType = isExternalType; } +// Represents an attribute wrapped by another attribute. +class WrappedAttr<string name, bit opt = 0> : Argument<name, opt>; + // This handles one spelling of an attribute. -class Spelling<string name, string variety> { +class Spelling<string name, string variety, int version = 1> { string Name = name; string Variety = variety; + int Version = version; } class GNU<string name> : Spelling<name, "GNU">; -class Declspec<string name> : Spelling<name, "Declspec">; +class Declspec<string name> : Spelling<name, "Declspec"> { + bit PrintOnLeft = 1; +} class Microsoft<string name> : Spelling<name, "Microsoft">; class CXX11<string namespace, string name, int version = 1> - : Spelling<name, "CXX11"> { + : Spelling<name, "CXX11", version> { + bit CanPrintOnLeft = 0; string Namespace = namespace; - int Version = version; } -class C2x<string namespace, string name, int version = 1> - : Spelling<name, "C2x"> { +class C23<string namespace, string name, int version = 1> + : Spelling<name, "C23", version> { string Namespace = namespace; - int Version = version; } -class Keyword<string name> : Spelling<name, "Keyword">; +class Keyword<string name, bit hasOwnParseRules> + : Spelling<name, "Keyword"> { + bit HasOwnParseRules = hasOwnParseRules; +} + +// A keyword that can appear wherever a standard attribute can appear, +// and that appertains to whatever a standard attribute would appertain to. +// This is useful for things that affect semantics but that should otherwise +// be treated like standard attributes. +class RegularKeyword<string name> : Keyword<name, 0> {} + +// A keyword that has its own individual parsing rules. +class CustomKeyword<string name> : Keyword<name, 1> {} + class Pragma<string namespace, string name> : Spelling<name, "Pragma"> { string Namespace = namespace; } // The GCC spelling implies GNU<name>, CXX11<"gnu", name>, and optionally, -// C2x<"gnu", name>. This spelling should be used for any GCC-compatible +// C23<"gnu", name>. This spelling should be used for any GCC-compatible // attributes. class GCC<string name, bit allowInC = 1> : Spelling<name, "GCC"> { bit AllowInC = allowInC; } // The Clang spelling implies GNU<name>, CXX11<"clang", name>, and optionally, -// C2x<"clang", name>. This spelling should be used for any Clang-specific +// C23<"clang", name>. This spelling should be used for any Clang-specific // attributes. -class Clang<string name, bit allowInC = 1> : Spelling<name, "Clang"> { +class Clang<string name, bit allowInC = 1, int version = 1> + : Spelling<name, "Clang", version> { bit AllowInC = allowInC; } +// HLSL Semantic spellings +class HLSLSemantic<string name> : Spelling<name, "HLSLSemantic">; + class Accessor<string name, list<Spelling> spellings> { string Name = name; list<Spelling> Spellings = spellings; @@ -336,6 +408,8 @@ def ObjCAutoRefCount : LangOpt<"ObjCAutoRefCount">; def ObjCNonFragileRuntime : LangOpt<"", "LangOpts.ObjCRuntime.allowsClassStubs()">; +def HLSL : LangOpt<"HLSL">; + // Language option for CMSE extensions def Cmse : LangOpt<"Cmse">; @@ -361,10 +435,11 @@ class TargetArch<list<string> arches> : TargetSpec { let Arches = arches; } def TargetARM : TargetArch<["arm", "thumb", "armeb", "thumbeb"]>; -def TargetAArch64 : TargetArch<["aarch64"]>; +def TargetAArch64 : TargetArch<["aarch64", "aarch64_be", "aarch64_32"]>; def TargetAnyArm : TargetArch<!listconcat(TargetARM.Arches, TargetAArch64.Arches)>; def TargetAVR : TargetArch<["avr"]>; def TargetBPF : TargetArch<["bpfel", "bpfeb"]>; +def TargetLoongArch : TargetArch<["loongarch32", "loongarch64"]>; def TargetMips32 : TargetArch<["mips", "mipsel"]>; def TargetAnyMips : TargetArch<["mips", "mipsel", "mips64", "mips64el"]>; def TargetMSP430 : TargetArch<["msp430"]>; @@ -373,6 +448,10 @@ def TargetRISCV : TargetArch<["riscv32", "riscv64"]>; def TargetX86 : TargetArch<["x86"]>; def TargetAnyX86 : TargetArch<["x86", "x86_64"]>; def TargetWebAssembly : TargetArch<["wasm32", "wasm64"]>; +def TargetNVPTX : TargetArch<["nvptx", "nvptx64"]>; +def TargetWindows : TargetSpec { + let OSes = ["Win32"]; +} def TargetHasDLLImportExport : TargetSpec { let CustomCode = [{ Target.getTriple().hasDLLImportExport() }]; } @@ -385,10 +464,19 @@ def TargetMicrosoftCXXABI : TargetArch<["x86", "x86_64", "arm", "thumb", "aarch6 def TargetELF : TargetSpec { let ObjectFormats = ["ELF"]; } +def TargetELFOrMachO : TargetSpec { + let ObjectFormats = ["ELF", "MachO"]; +} def TargetSupportsInitPriority : TargetSpec { let CustomCode = [{ !Target.getTriple().isOSzOS() }]; } + +class TargetSpecificSpelling<TargetSpec target, list<Spelling> spellings> { + TargetSpec Target = target; + list<Spelling> Spellings = spellings; +} + // Attribute subject match rules that are used for #pragma clang attribute. // // A instance of AttrSubjectMatcherRule represents an individual match rule. @@ -501,6 +589,12 @@ class AttrSubjectMatcherAggregateRule<AttrSubject subject> { def SubjectMatcherForNamed : AttrSubjectMatcherAggregateRule<Named>; class Attr { + // Specifies that when printed, this attribute is meaningful on the + // 'left side' of the declaration. + bit CanPrintOnLeft = 1; + // Specifies that when printed, this attribute is required to be printed on + // the 'left side' of the declaration. + bit PrintOnLeft = 0; // The various ways in which an attribute can be spelled in source list<Spelling> Spellings; // The things to which an attribute can appertain @@ -509,6 +603,8 @@ class Attr { list<Argument> Args = []; // Accessors which should be generated for the attribute. list<Accessor> Accessors = []; + // Specify targets for spellings. + list<TargetSpecificSpelling> TargetSpecificSpellings = []; // Set to true for attributes with arguments which require delayed parsing. bit LateParsed = 0; // Set to false to prevent an attribute from being propagated from a template @@ -541,6 +637,8 @@ class Attr { // match rules. // - It has GNU/CXX11 spelling and doesn't require delayed parsing. bit PragmaAttributeSupport; + // Set to true if this attribute accepts parameter pack expansion expressions. + bit AcceptsExprPack = 0; // Lists language options, one of which is required to be true for the // attribute to be applicable. If empty, no language options are required. list<LangOpt> LangOpts = []; @@ -580,6 +678,9 @@ class DeclOrTypeAttr : InheritableAttr; /// A attribute is either a declaration attribute or a statement attribute. class DeclOrStmtAttr : InheritableAttr; +/// An attribute class for HLSL Annotations. +class HLSLAnnotationAttr : InheritableAttr; + /// A target-specific attribute. This class is meant to be used as a mixin /// with InheritableAttr or Attr depending on the attribute's needs. class TargetSpecificAttr<TargetSpec target> { @@ -614,7 +715,7 @@ class IgnoredAttr : Attr { let Ignored = 1; let ASTNode = 0; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } // @@ -644,7 +745,7 @@ def Alias : Attr { def BuiltinAlias : Attr { let Spellings = [CXX11<"clang", "builtin_alias">, - C2x<"clang", "builtin_alias">, + C23<"clang", "builtin_alias">, GNU<"clang_builtin_alias">]; let Args = [IdentifierArgument<"BuiltinName">]; let Subjects = SubjectList<[Function], ErrorDiag>; @@ -659,13 +760,13 @@ def ArmBuiltinAlias : InheritableAttr, TargetSpecificAttr<TargetAnyArm> { } def Aligned : InheritableAttr { - let Spellings = [GCC<"aligned">, Declspec<"align">, Keyword<"alignas">, - Keyword<"_Alignas">]; + let Spellings = [GCC<"aligned">, Declspec<"align">, CustomKeyword<"alignas">, + CustomKeyword<"_Alignas">]; let Args = [AlignedArgument<"Alignment", 1>]; let Accessors = [Accessor<"isGNU", [GCC<"aligned">]>, - Accessor<"isC11", [Keyword<"_Alignas">]>, - Accessor<"isAlignas", [Keyword<"alignas">, - Keyword<"_Alignas">]>, + Accessor<"isC11", [CustomKeyword<"_Alignas">]>, + Accessor<"isAlignas", [CustomKeyword<"alignas">, + CustomKeyword<"_Alignas">]>, Accessor<"isDeclspec",[Declspec<"align">]>]; let Documentation = [Undocumented]; } @@ -694,19 +795,23 @@ def AlignMac68k : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def AlignNatural : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } -def AlwaysInline : InheritableAttr { - let Spellings = [GCC<"always_inline">, Keyword<"__forceinline">]; - let Subjects = SubjectList<[Function]>; +def AlwaysInline : DeclOrStmtAttr { + let Spellings = [GCC<"always_inline">, CXX11<"clang", "always_inline">, + C23<"clang", "always_inline">, CustomKeyword<"__forceinline">]; + let Accessors = [Accessor<"isClangAlwaysInline", [CXX11<"clang", "always_inline">, + C23<"clang", "always_inline">]>]; + let Subjects = SubjectList<[Function, Stmt], WarnDiag, + "functions and statements">; let Documentation = [AlwaysInlineDocs]; } @@ -745,7 +850,8 @@ def XRayLogArgs : InheritableAttr { def PatchableFunctionEntry : InheritableAttr, TargetSpecificAttr<TargetArch< - ["aarch64", "aarch64_be", "riscv32", "riscv64", "x86", "x86_64"]>> { + ["aarch64", "aarch64_be", "loongarch32", "loongarch64", "riscv32", + "riscv64", "x86", "x86_64"]>> { let Spellings = [GCC<"patchable_function_entry">]; let Subjects = SubjectList<[Function, ObjCMethod]>; let Args = [UnsignedArgument<"Count">, DefaultIntArgument<"Offset", 0>]; @@ -779,14 +885,23 @@ def Annotate : InheritableParamAttr { return AnnotateAttr::Create(Ctx, Annotation, nullptr, 0, CommonInfo); } static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, \ - const AttributeCommonInfo &CommonInfo = {SourceRange{}}) { + const AttributeCommonInfo &CommonInfo) { return AnnotateAttr::CreateImplicit(Ctx, Annotation, nullptr, 0, CommonInfo); } }]; let PragmaAttributeSupport = 1; + let AcceptsExprPack = 1; let Documentation = [Undocumented]; } +def AnnotateType : TypeAttr { + let Spellings = [CXX11<"clang", "annotate_type">, C23<"clang", "annotate_type">]; + let Args = [StringArgument<"Annotation">, VariadicExprArgument<"Args">]; + let HasCustomParsing = 1; + let AcceptsExprPack = 1; + let Documentation = [AnnotateTypeDocs]; +} + def ARMInterrupt : InheritableAttr, TargetSpecificAttr<TargetARM> { // NOTE: If you add any additional spellings, M68kInterrupt's, // MSP430Interrupt's, MipsInterrupt's and AnyX86Interrupt's spellings @@ -815,7 +930,8 @@ def AVRSignal : InheritableAttr, TargetSpecificAttr<TargetAVR> { } def AsmLabel : InheritableAttr { - let Spellings = [Keyword<"asm">, Keyword<"__asm__">]; + let CanPrintOnLeft = 0; + let Spellings = [CustomKeyword<"asm">, CustomKeyword<"__asm__">]; let Args = [ // Label specifies the mangled name for the decl. StringArgument<"Label">, @@ -848,10 +964,12 @@ def Availability : InheritableAttr { [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { return llvm::StringSwitch<llvm::StringRef>(Platform) .Case("android", "Android") + .Case("fuchsia", "Fuchsia") .Case("ios", "iOS") .Case("macos", "macOS") .Case("tvos", "tvOS") .Case("watchos", "watchOS") + .Case("driverkit", "DriverKit") .Case("ios_app_extension", "iOS (App Extension)") .Case("macos_app_extension", "macOS (App Extension)") .Case("tvos_app_extension", "tvOS (App Extension)") @@ -859,6 +977,8 @@ def Availability : InheritableAttr { .Case("maccatalyst", "macCatalyst") .Case("maccatalyst_app_extension", "macCatalyst (App Extension)") .Case("swift", "Swift") + .Case("shadermodel", "HLSL ShaderModel") + .Case("ohos", "OpenHarmony OS") .Default(llvm::StringRef()); } static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { @@ -874,6 +994,7 @@ static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) { .Case("maccatalyst", "macCatalyst") .Case("maccatalyst_app_extension", "macCatalystApplicationExtension") .Case("zos", "z/OS") + .Case("shadermodel", "ShaderModel") .Default(Platform); } static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { @@ -888,6 +1009,7 @@ static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { .Case("watchOSApplicationExtension", "watchos_app_extension") .Case("macCatalyst", "maccatalyst") .Case("macCatalystApplicationExtension", "maccatalyst_app_extension") + .Case("ShaderModel", "shadermodel") .Default(Platform); } }]; let HasCustomParsing = 1; @@ -897,10 +1019,12 @@ static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) { } def ExternalSourceSymbol : InheritableAttr { - let Spellings = [Clang<"external_source_symbol">]; + let Spellings = [Clang<"external_source_symbol", /*allowInC=*/1, + /*version=*/20230206>]; let Args = [StringArgument<"language", 1>, StringArgument<"definedIn", 1>, - BoolArgument<"generatedDeclaration", 1>]; + BoolArgument<"generatedDeclaration", 1>, + StringArgument<"USR", 1>]; let HasCustomParsing = 1; let Subjects = SubjectList<[Named]>; let Documentation = [ExternalSourceSymbolDocs]; @@ -925,7 +1049,7 @@ def CarriesDependency : InheritableParamAttr { } def CDecl : DeclOrTypeAttr { - let Spellings = [GCC<"cdecl">, Keyword<"__cdecl">, Keyword<"_cdecl">]; + let Spellings = [GCC<"cdecl">, CustomKeyword<"__cdecl">, CustomKeyword<"_cdecl">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [Undocumented]; } @@ -970,6 +1094,50 @@ def CFConsumed : InheritableParamAttr { let Documentation = [RetainBehaviorDocs]; } + +// coro_only_destroy_when_complete indicates the coroutines whose return type +// is marked by coro_only_destroy_when_complete can only be destroyed when the +// coroutine completes. Then the space for the destroy functions can be saved. +def CoroOnlyDestroyWhenComplete : InheritableAttr { + let Spellings = [Clang<"coro_only_destroy_when_complete">]; + let Subjects = SubjectList<[CXXRecord]>; + let LangOpts = [CPlusPlus]; + let Documentation = [CoroOnlyDestroyWhenCompleteDocs]; + let SimpleHandler = 1; +} + +def CoroReturnType : InheritableAttr { + let Spellings = [Clang<"coro_return_type">]; + let Subjects = SubjectList<[CXXRecord]>; + let LangOpts = [CPlusPlus]; + let Documentation = [CoroReturnTypeAndWrapperDoc]; + let SimpleHandler = 1; +} + +def CoroWrapper : InheritableAttr { + let Spellings = [Clang<"coro_wrapper">]; + let Subjects = SubjectList<[Function]>; + let LangOpts = [CPlusPlus]; + let Documentation = [CoroReturnTypeAndWrapperDoc]; + let SimpleHandler = 1; +} + +def CoroLifetimeBound : InheritableAttr { + let Spellings = [Clang<"coro_lifetimebound">]; + let Subjects = SubjectList<[CXXRecord]>; + let LangOpts = [CPlusPlus]; + let Documentation = [CoroLifetimeBoundDoc]; + let SimpleHandler = 1; +} + +def CoroDisableLifetimeBound : InheritableAttr { + let Spellings = [Clang<"coro_disable_lifetimebound">]; + let Subjects = SubjectList<[Function]>; + let LangOpts = [CPlusPlus]; + let Documentation = [CoroLifetimeBoundDoc]; + let SimpleHandler = 1; +} + // OSObject-based attributes. def OSConsumed : InheritableParamAttr { let Spellings = [Clang<"os_consumed">]; @@ -1012,7 +1180,7 @@ def Cleanup : InheritableAttr { let Spellings = [GCC<"cleanup">]; let Args = [DeclArgument<Function, "FunctionDecl">]; let Subjects = SubjectList<[LocalVar]>; - let Documentation = [Undocumented]; + let Documentation = [CleanupDocs]; } def CmseNSEntry : InheritableAttr, TargetSpecificAttr<TargetARM> { @@ -1031,7 +1199,7 @@ def CmseNSCall : TypeAttr, TargetSpecificAttr<TargetARM> { def Cold : InheritableAttr { let Spellings = [GCC<"cold">]; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [ColdFunctionEntryDocs]; let SimpleHandler = 1; } @@ -1050,10 +1218,10 @@ def Const : InheritableAttr { def ConstInit : InheritableAttr { // This attribute does not have a C [[]] spelling because it requires the // CPlusPlus language option. - let Spellings = [Keyword<"constinit">, + let Spellings = [CustomKeyword<"constinit">, Clang<"require_constant_initialization", 0>]; let Subjects = SubjectList<[GlobalVar], ErrorDiag>; - let Accessors = [Accessor<"isConstinit", [Keyword<"constinit">]>]; + let Accessors = [Accessor<"isConstinit", [CustomKeyword<"constinit">]>]; let Documentation = [ConstInitDocs]; let LangOpts = [CPlusPlus]; let SimpleHandler = 1; @@ -1063,7 +1231,7 @@ def Constructor : InheritableAttr { let Spellings = [GCC<"constructor">]; let Args = [DefaultIntArgument<"Priority", 65535>]; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [CtorDtorDocs]; } def CPUSpecific : InheritableAttr { @@ -1150,6 +1318,12 @@ def CUDAHost : InheritableAttr { } def : MutualExclusions<[CUDAGlobal, CUDAHost]>; +def NVPTXKernel : InheritableAttr, TargetSpecificAttr<TargetNVPTX> { + let Spellings = [Clang<"nvptx_kernel">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [Undocumented]; +} + def HIPManaged : InheritableAttr { let Spellings = [GNU<"managed">, Declspec<"__managed__">]; let Subjects = SubjectList<[Var]>; @@ -1161,12 +1335,13 @@ def CUDAInvalidTarget : InheritableAttr { let Spellings = []; let Subjects = SubjectList<[Function]>; let LangOpts = [CUDA]; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def CUDALaunchBounds : InheritableAttr { let Spellings = [GNU<"launch_bounds">, Declspec<"__launch_bounds__">]; - let Args = [ExprArgument<"MaxThreads">, ExprArgument<"MinBlocks", 1>]; + let Args = [ExprArgument<"MaxThreads">, ExprArgument<"MinBlocks", 1>, + ExprArgument<"MaxBlocks", 1>]; let LangOpts = [CUDA]; let Subjects = SubjectList<[ObjCMethod, FunctionLike]>; // An AST node is created for this attribute, but is not used by other parts @@ -1190,24 +1365,31 @@ def SYCLKernel : InheritableAttr { let Documentation = [SYCLKernelDocs]; } +def SYCLSpecialClass: InheritableAttr { + let Spellings = [Clang<"sycl_special_class">]; + let Subjects = SubjectList<[CXXRecord]>; + let LangOpts = [SYCL]; + let Documentation = [SYCLSpecialClassDocs]; +} + def C11NoReturn : InheritableAttr { - let Spellings = [Keyword<"_Noreturn">]; + let Spellings = [CustomKeyword<"_Noreturn">]; let Subjects = SubjectList<[Function], ErrorDiag>; let SemaHandler = 0; let Documentation = [C11NoReturnDocs]; } def CXX11NoReturn : InheritableAttr { - let Spellings = [CXX11<"", "noreturn", 200809>]; + let Spellings = [CXX11<"", "noreturn", 200809>, + C23<"", "noreturn", 202202>, C23<"", "_Noreturn", 202202>]; let Subjects = SubjectList<[Function], ErrorDiag>; let Documentation = [CXX11NoReturnDocs]; - let SimpleHandler = 1; } // Similar to CUDA, OpenCL attributes do not receive a [[]] spelling because // the specification does not expose them with one currently. def OpenCLKernel : InheritableAttr { - let Spellings = [Keyword<"__kernel">, Keyword<"kernel">]; + let Spellings = [CustomKeyword<"__kernel">, CustomKeyword<"kernel">]; let Subjects = SubjectList<[Function], ErrorDiag>; let Documentation = [Undocumented]; let SimpleHandler = 1; @@ -1231,26 +1413,28 @@ def OpenCLIntelReqdSubGroupSize: InheritableAttr { // This attribute is both a type attribute, and a declaration attribute (for // parameter variables). def OpenCLAccess : Attr { - let Spellings = [Keyword<"__read_only">, Keyword<"read_only">, - Keyword<"__write_only">, Keyword<"write_only">, - Keyword<"__read_write">, Keyword<"read_write">]; + let Spellings = [CustomKeyword<"__read_only">, CustomKeyword<"read_only">, + CustomKeyword<"__write_only">, CustomKeyword<"write_only">, + CustomKeyword<"__read_write">, CustomKeyword<"read_write">]; let Subjects = SubjectList<[ParmVar, TypedefName], ErrorDiag>; - let Accessors = [Accessor<"isReadOnly", [Keyword<"__read_only">, - Keyword<"read_only">]>, - Accessor<"isReadWrite", [Keyword<"__read_write">, - Keyword<"read_write">]>, - Accessor<"isWriteOnly", [Keyword<"__write_only">, - Keyword<"write_only">]>]; + let Accessors = [Accessor<"isReadOnly", [CustomKeyword<"__read_only">, + CustomKeyword<"read_only">]>, + Accessor<"isReadWrite", [CustomKeyword<"__read_write">, + CustomKeyword<"read_write">]>, + Accessor<"isWriteOnly", [CustomKeyword<"__write_only">, + CustomKeyword<"write_only">]>]; let Documentation = [OpenCLAccessDocs]; } def OpenCLPrivateAddressSpace : TypeAttr { - let Spellings = [Keyword<"__private">, Keyword<"private">, Clang<"opencl_private">]; + let Spellings = [CustomKeyword<"__private">, CustomKeyword<"private">, + Clang<"opencl_private">]; let Documentation = [OpenCLAddressSpacePrivateDocs]; } def OpenCLGlobalAddressSpace : TypeAttr { - let Spellings = [Keyword<"__global">, Keyword<"global">, Clang<"opencl_global">]; + let Spellings = [CustomKeyword<"__global">, CustomKeyword<"global">, + Clang<"opencl_global">]; let Documentation = [OpenCLAddressSpaceGlobalDocs]; } @@ -1265,17 +1449,20 @@ def OpenCLGlobalHostAddressSpace : TypeAttr { } def OpenCLLocalAddressSpace : TypeAttr { - let Spellings = [Keyword<"__local">, Keyword<"local">, Clang<"opencl_local">]; + let Spellings = [CustomKeyword<"__local">, CustomKeyword<"local">, + Clang<"opencl_local">]; let Documentation = [OpenCLAddressSpaceLocalDocs]; } def OpenCLConstantAddressSpace : TypeAttr { - let Spellings = [Keyword<"__constant">, Keyword<"constant">, Clang<"opencl_constant">]; + let Spellings = [CustomKeyword<"__constant">, CustomKeyword<"constant">, + Clang<"opencl_constant">]; let Documentation = [OpenCLAddressSpaceConstantDocs]; } def OpenCLGenericAddressSpace : TypeAttr { - let Spellings = [Keyword<"__generic">, Keyword<"generic">, Clang<"opencl_generic">]; + let Spellings = [CustomKeyword<"__generic">, CustomKeyword<"generic">, + Clang<"opencl_generic">]; let Documentation = [OpenCLAddressSpaceGenericDocs]; } @@ -1298,7 +1485,7 @@ def RenderScriptKernel : Attr { def Deprecated : InheritableAttr { let Spellings = [GCC<"deprecated">, Declspec<"deprecated">, CXX11<"","deprecated", 201309>, - C2x<"", "deprecated", 201904>]; + C23<"", "deprecated", 201904>]; let Args = [StringArgument<"Message", 1>, // An optional string argument that enables us to provide a // Fix-It. @@ -1311,7 +1498,7 @@ def Destructor : InheritableAttr { let Spellings = [GCC<"destructor">]; let Args = [DefaultIntArgument<"Priority", 65535>]; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [CtorDtorDocs]; } def EmptyBases : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> { @@ -1331,6 +1518,7 @@ def AllocSize : InheritableAttr { } def EnableIf : InheritableAttr { + let CanPrintOnLeft = 0; // Does not have a [[]] spelling because this attribute requires the ability // to parse function arguments but the attribute is not written in the type // position. @@ -1356,7 +1544,7 @@ def ExtVectorType : Attr { def FallThrough : StmtAttr { let Spellings = [CXX11<"", "fallthrough", 201603>, - C2x<"", "fallthrough", 201904>, + C23<"", "fallthrough", 201910>, CXX11<"clang", "fallthrough">, GCC<"fallthrough">]; // The attribute only applies to a NullStmt, but we have special fix-it // behavior if applied to a case label. @@ -1366,12 +1554,12 @@ def FallThrough : StmtAttr { } def Likely : StmtAttr { - let Spellings = [CXX11<"", "likely", 201803>, C2x<"clang", "likely">]; + let Spellings = [CXX11<"", "likely", 201803>, C23<"clang", "likely">]; let Documentation = [LikelihoodDocs]; } def Unlikely : StmtAttr { - let Spellings = [CXX11<"", "unlikely", 201803>, C2x<"clang", "unlikely">]; + let Spellings = [CXX11<"", "unlikely", 201803>, C23<"clang", "unlikely">]; let Documentation = [LikelihoodDocs]; } def : MutualExclusions<[Likely, Unlikely]>; @@ -1379,10 +1567,8 @@ def : MutualExclusions<[Likely, Unlikely]>; def NoMerge : DeclOrStmtAttr { let Spellings = [Clang<"nomerge">]; let Documentation = [NoMergeDocs]; - let InheritEvenIfAlreadyPresent = 1; - let Subjects = SubjectList<[Function, Stmt], ErrorDiag, - "functions and statements">; - let SimpleHandler = 1; + let Subjects = SubjectList<[Function, Stmt, Var], ErrorDiag, + "functions, statements and variables">; } def MustTail : StmtAttr { @@ -1392,28 +1578,30 @@ def MustTail : StmtAttr { } def FastCall : DeclOrTypeAttr { - let Spellings = [GCC<"fastcall">, Keyword<"__fastcall">, - Keyword<"_fastcall">]; + let Spellings = [GCC<"fastcall">, CustomKeyword<"__fastcall">, + CustomKeyword<"_fastcall">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [FastCallDocs]; } def RegCall : DeclOrTypeAttr { - let Spellings = [GCC<"regcall">, Keyword<"__regcall">]; + let Spellings = [GCC<"regcall">, CustomKeyword<"__regcall">]; let Documentation = [RegCallDocs]; } def Final : InheritableAttr { - let Spellings = [Keyword<"final">, Keyword<"sealed">]; - let Accessors = [Accessor<"isSpelledAsSealed", [Keyword<"sealed">]>]; + let Spellings = [CustomKeyword<"final">, CustomKeyword<"sealed">]; + let Accessors = [Accessor<"isSpelledAsSealed", [CustomKeyword<"sealed">]>]; let SemaHandler = 0; - let Documentation = [Undocumented]; + // Omitted from docs, since this is language syntax, not an attribute, as far + // as users are concerned. + let Documentation = [InternalOnly]; } def MinSize : InheritableAttr { let Spellings = [Clang<"minsize">]; let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [MinSizeDocs]; } def FlagEnum : InheritableAttr { @@ -1469,9 +1657,7 @@ def GNUInline : InheritableAttr { def Hot : InheritableAttr { let Spellings = [GCC<"hot">]; let Subjects = SubjectList<[Function]>; - // An AST node is created for this attribute, but not actually used beyond - // semantic checking for mutual exclusion with the Cold attribute. - let Documentation = [Undocumented]; + let Documentation = [HotFunctionEntryDocs]; let SimpleHandler = 1; } def : MutualExclusions<[Hot, Cold]>; @@ -1499,7 +1685,7 @@ def IBOutletCollection : InheritableAttr { let Documentation = [Undocumented]; } -def IFunc : Attr, TargetSpecificAttr<TargetELF> { +def IFunc : Attr, TargetSpecificAttr<TargetELFOrMachO> { let Spellings = [GCC<"ifunc">]; let Args = [StringArgument<"Resolver">]; let Subjects = SubjectList<[Function]>; @@ -1549,7 +1735,7 @@ def MaxFieldAlignment : InheritableAttr { let Spellings = []; let Args = [UnsignedArgument<"Alignment">]; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def MayAlias : InheritableAttr { @@ -1686,11 +1872,14 @@ def ArmMveStrictPolymorphism : TypeAttr, TargetSpecificAttr<TargetARM> { let Documentation = [ArmMveStrictPolymorphismDocs]; } -def NoUniqueAddress : InheritableAttr, TargetSpecificAttr<TargetItaniumCXXABI> { - let Spellings = [CXX11<"", "no_unique_address", 201803>]; +def NoUniqueAddress : InheritableAttr { let Subjects = SubjectList<[NonBitField], ErrorDiag>; + let Spellings = [CXX11<"", "no_unique_address", 201803>, CXX11<"msvc", "no_unique_address", 201803>]; + let TargetSpecificSpellings = [ + TargetSpecificSpelling<TargetItaniumCXXABI, [CXX11<"", "no_unique_address", 201803>]>, + TargetSpecificSpelling<TargetMicrosoftCXXABI, [CXX11<"msvc", "no_unique_address", 201803>]>, + ]; let Documentation = [NoUniqueAddressDocs]; - let SimpleHandler = 1; } def ReturnsTwice : InheritableAttr { @@ -1750,10 +1939,15 @@ def Convergent : InheritableAttr { let SimpleHandler = 1; } -def NoInline : InheritableAttr { - let Spellings = [GCC<"noinline">, Declspec<"noinline">]; - let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; +def NoInline : DeclOrStmtAttr { + let Spellings = [CustomKeyword<"__noinline__">, GCC<"noinline">, + CXX11<"clang", "noinline">, C23<"clang", "noinline">, + Declspec<"noinline">]; + let Accessors = [Accessor<"isClangNoInline", [CXX11<"clang", "noinline">, + C23<"clang", "noinline">]>]; + let Documentation = [NoInlineDocs]; + let Subjects = SubjectList<[Function, Stmt], WarnDiag, + "functions and statements">; let SimpleHandler = 1; } @@ -1775,13 +1969,23 @@ def RISCVInterrupt : InheritableAttr, TargetSpecificAttr<TargetRISCV> { let Spellings = [GCC<"interrupt">]; let Subjects = SubjectList<[Function]>; let Args = [EnumArgument<"Interrupt", "InterruptType", - ["user", "supervisor", "machine"], - ["user", "supervisor", "machine"], + ["supervisor", "machine"], + ["supervisor", "machine"], 1>]; let ParseKind = "Interrupt"; let Documentation = [RISCVInterruptDocs]; } +def RISCVRVVVectorBits : TypeAttr { + let Spellings = [GNU<"riscv_rvv_vector_bits">]; + let Subjects = SubjectList<[TypedefName], ErrorDiag>; + let Args = [UnsignedArgument<"NumBits">]; + let Documentation = [RISCVRVVVectorBitsDocs]; + let PragmaAttributeSupport = 0; + // Represented as VectorType instead. + let ASTNode = 0; +} + // This is not a TargetSpecificAttr so that is silently accepted and // ignored on other targets as encouraged by the OpenCL spec. // @@ -1827,6 +2031,11 @@ def AMDGPUNumVGPR : InheritableAttr { let Subjects = SubjectList<[Function], ErrorDiag, "kernel functions">; } +def AMDGPUKernelCall : DeclOrTypeAttr { + let Spellings = [Clang<"amdgpu_kernel">]; + let Documentation = [Undocumented]; +} + def BPFPreserveAccessIndex : InheritableAttr, TargetSpecificAttr<TargetBPF> { let Spellings = [Clang<"preserve_access_index">]; @@ -1835,6 +2044,30 @@ def BPFPreserveAccessIndex : InheritableAttr, let LangOpts = [COnly]; } +def BPFPreserveStaticOffset : InheritableAttr, + TargetSpecificAttr<TargetBPF> { + let Spellings = [Clang<"preserve_static_offset">]; + let Subjects = SubjectList<[Record], ErrorDiag>; + let Documentation = [BPFPreserveStaticOffsetDocs]; + let LangOpts = [COnly]; +} + +def BTFDeclTag : InheritableAttr { + let Spellings = [Clang<"btf_decl_tag">]; + let Args = [StringArgument<"BTFDeclTag">]; + let Subjects = SubjectList<[Var, Function, Record, Field, TypedefName], + ErrorDiag>; + let Documentation = [BTFDeclTagDocs]; + let LangOpts = [COnly]; +} + +def BTFTypeTag : TypeAttr { + let Spellings = [Clang<"btf_type_tag">]; + let Args = [StringArgument<"BTFTypeTag">]; + let Documentation = [BTFTypeTagDocs]; + let LangOpts = [COnly]; +} + def WebAssemblyExportName : InheritableAttr, TargetSpecificAttr<TargetWebAssembly> { let Spellings = [Clang<"export_name">]; @@ -1875,9 +2108,9 @@ def NonNull : InheritableParamAttr { bool isNonNull(unsigned IdxAST) const { if (!args_size()) return true; - return args_end() != std::find_if( - args_begin(), args_end(), - [=](const ParamIdx &Idx) { return Idx.getASTIndex() == IdxAST; }); + return llvm::any_of(args(), [=](const ParamIdx &Idx) { + return Idx.getASTIndex() == IdxAST; + }); } }]; // FIXME: We should merge duplicates into a single nonnull attribute. @@ -1911,22 +2144,22 @@ def PassObjectSize : InheritableParamAttr { // Nullability type attributes. def TypeNonNull : TypeAttr { - let Spellings = [Keyword<"_Nonnull">]; + let Spellings = [CustomKeyword<"_Nonnull">]; let Documentation = [TypeNonNullDocs]; } def TypeNullable : TypeAttr { - let Spellings = [Keyword<"_Nullable">]; + let Spellings = [CustomKeyword<"_Nullable">]; let Documentation = [TypeNullableDocs]; } def TypeNullableResult : TypeAttr { - let Spellings = [Keyword<"_Nullable_result">]; + let Spellings = [CustomKeyword<"_Nullable_result">]; let Documentation = [TypeNullableResultDocs]; } def TypeNullUnspecified : TypeAttr { - let Spellings = [Keyword<"_Null_unspecified">]; + let Spellings = [CustomKeyword<"_Null_unspecified">]; let Documentation = [TypeNullUnspecifiedDocs]; } @@ -1934,12 +2167,12 @@ def TypeNullUnspecified : TypeAttr { // ignored because ARC is not enabled. The usual representation for this // qualifier is as an ObjCOwnership attribute with Kind == "none". def ObjCInertUnsafeUnretained : TypeAttr { - let Spellings = [Keyword<"__unsafe_unretained">]; - let Documentation = [Undocumented]; + let Spellings = [CustomKeyword<"__unsafe_unretained">]; + let Documentation = [InternalOnly]; } def ObjCKindOf : TypeAttr { - let Spellings = [Keyword<"__kindof">]; + let Spellings = [CustomKeyword<"__kindof">]; let Documentation = [Undocumented]; } @@ -1949,6 +2182,13 @@ def NoEscape : Attr { let Documentation = [NoEscapeDocs]; } +def MaybeUndef : InheritableAttr { + let Spellings = [Clang<"maybe_undef">]; + let Subjects = SubjectList<[ParmVar]>; + let Documentation = [MaybeUndefDocs]; + let SimpleHandler = 1; +} + def AssumeAligned : InheritableAttr { let Spellings = [GCC<"assume_aligned">]; let Subjects = SubjectList<[ObjCMethod, Function]>; @@ -1971,7 +2211,7 @@ def NoReturn : InheritableAttr { def NoInstrumentFunction : InheritableAttr { let Spellings = [GCC<"no_instrument_function">]; - let Subjects = SubjectList<[Function]>; + let Subjects = SubjectList<[Function, ObjCMethod]>; let Documentation = [Undocumented]; let SimpleHandler = 1; } @@ -1992,18 +2232,33 @@ def NotTailCalled : InheritableAttr { def : MutualExclusions<[AlwaysInline, NotTailCalled]>; def NoStackProtector : InheritableAttr { - let Spellings = [Clang<"no_stack_protector">]; + let Spellings = [Clang<"no_stack_protector">, CXX11<"gnu", "no_stack_protector">, + C23<"gnu", "no_stack_protector">, Declspec<"safebuffers">]; let Subjects = SubjectList<[Function]>; let Documentation = [NoStackProtectorDocs]; let SimpleHandler = 1; } +def StrictGuardStackCheck : InheritableAttr { + let Spellings = [Declspec<"strict_gs_check">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [StrictGuardStackCheckDocs]; + let SimpleHandler = 1; +} + def NoThrow : InheritableAttr { let Spellings = [GCC<"nothrow">, Declspec<"nothrow">]; let Subjects = SubjectList<[FunctionLike]>; let Documentation = [NoThrowDocs]; } +def NoUwtable : InheritableAttr { + let Spellings = [Clang<"nouwtable">]; + let Subjects = SubjectList<[FunctionLike]>; + let Documentation = [NoUwtableDocs]; + let SimpleHandler = 1; +} + def NvWeak : IgnoredAttr { // No Declspec spelling of this attribute; the CUDA headers use // __attribute__((nv_weak)) unconditionally. Does not receive an [[]] @@ -2039,7 +2294,7 @@ def ObjCBridgeRelated : InheritableAttr { def NSErrorDomain : InheritableAttr { let Spellings = [GNU<"ns_error_domain">]; let Subjects = SubjectList<[Enum], ErrorDiag>; - let Args = [DeclArgument<Var, "ErrorDomain">]; + let Args = [IdentifierArgument<"ErrorDomain">]; let Documentation = [NSErrorDomainDocs]; } @@ -2217,9 +2472,11 @@ def Overloadable : Attr { } def Override : InheritableAttr { - let Spellings = [Keyword<"override">]; + let Spellings = [CustomKeyword<"override">]; let SemaHandler = 0; - let Documentation = [Undocumented]; + // Omitted from docs, since this is language syntax, not an attribute, as far + // as users are concerned. + let Documentation = [InternalOnly]; } def Ownership : InheritableAttr { @@ -2268,6 +2525,74 @@ def AArch64VectorPcs: DeclOrTypeAttr { let Documentation = [AArch64VectorPcsDocs]; } +def AArch64SVEPcs: DeclOrTypeAttr { + let Spellings = [Clang<"aarch64_sve_pcs">]; + let Documentation = [AArch64SVEPcsDocs]; +} + +def ArmStreaming : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_streaming">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmSmeStreamingDocs]; +} + +def ArmStreamingCompatible : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_streaming_compatible">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmSmeStreamingCompatibleDocs]; +} + +def ArmNew : InheritableAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_new">]; + let Args = [VariadicStringArgument<"NewArgs">]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let Documentation = [ArmNewDocs]; + + let AdditionalMembers = [{ + bool isNewZA() const { + return llvm::is_contained(newArgs(), "za"); + } + bool isNewZT0() const { + return llvm::is_contained(newArgs(), "zt0"); + } + }]; +} + +def ArmIn : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_in">]; + let Args = [VariadicStringArgument<"InArgs">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmInDocs]; +} + +def ArmOut : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_out">]; + let Args = [VariadicStringArgument<"OutArgs">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmOutDocs]; +} + +def ArmInOut : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_inout">]; + let Args = [VariadicStringArgument<"InOutArgs">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmInOutDocs]; +} + +def ArmPreserves : TypeAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_preserves">]; + let Args = [VariadicStringArgument<"PreserveArgs">]; + let Subjects = SubjectList<[HasFunctionProto], ErrorDiag>; + let Documentation = [ArmPreservesDocs]; +} + +def ArmLocallyStreaming : InheritableAttr, TargetSpecificAttr<TargetAArch64> { + let Spellings = [RegularKeyword<"__arm_locally_streaming">]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let Documentation = [ArmSmeLocallyStreamingDocs]; +} + + def Pure : InheritableAttr { let Spellings = [GCC<"pure">]; let Documentation = [Undocumented]; @@ -2293,6 +2618,7 @@ def SwiftAttr : InheritableAttr { let Spellings = [GNU<"swift_attr">]; let Args = [StringArgument<"Attribute">]; let Documentation = [SwiftAttrDocs]; + let PragmaAttributeSupport = 1; } def SwiftBridge : InheritableAttr { @@ -2328,6 +2654,22 @@ def SwiftError : InheritableAttr { let Documentation = [SwiftErrorDocs]; } +def SwiftImportAsNonGeneric : InheritableAttr { + // This attribute has no spellings as it is only ever created implicitly + // from API notes. + let Spellings = []; + let SemaHandler = 0; + let Documentation = [InternalOnly]; +} + +def SwiftImportPropertyAsAccessors : InheritableAttr { + // This attribute has no spellings as it is only ever created implicitly + // from API notes. + let Spellings = []; + let SemaHandler = 0; + let Documentation = [InternalOnly]; +} + def SwiftName : InheritableAttr { let Spellings = [GNU<"swift_name">]; let Args = [StringArgument<"Name">]; @@ -2349,6 +2691,31 @@ def SwiftPrivate : InheritableAttr { let SimpleHandler = 1; } +def SwiftVersionedAddition : Attr { + // This attribute has no spellings as it is only ever created implicitly + // from API notes. + let Spellings = []; + let Args = [VersionArgument<"Version">, WrappedAttr<"AdditionalAttr">, + BoolArgument<"IsReplacedByActive">]; + let SemaHandler = 0; + let Documentation = [InternalOnly]; +} + +def SwiftVersionedRemoval : Attr { + // This attribute has no spellings as it is only ever created implicitly + // from API notes. + let Spellings = []; + let Args = [VersionArgument<"Version">, UnsignedArgument<"RawKind">, + BoolArgument<"IsReplacedByActive">]; + let SemaHandler = 0; + let Documentation = [InternalOnly]; + let AdditionalMembers = [{ + attr::Kind getAttrKindToRemove() const { + return static_cast<attr::Kind>(getRawKind()); + } + }]; +} + def NoDeref : TypeAttr { let Spellings = [Clang<"noderef">]; let Documentation = [NoDerefDocs]; @@ -2402,7 +2769,7 @@ def PragmaClangBSSSection : InheritableAttr { let Spellings = []; let Args = [StringArgument<"Name">]; let Subjects = SubjectList<[GlobalVar], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def PragmaClangDataSection : InheritableAttr { @@ -2410,7 +2777,7 @@ def PragmaClangDataSection : InheritableAttr { let Spellings = []; let Args = [StringArgument<"Name">]; let Subjects = SubjectList<[GlobalVar], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def PragmaClangRodataSection : InheritableAttr { @@ -2418,7 +2785,7 @@ def PragmaClangRodataSection : InheritableAttr { let Spellings = []; let Args = [StringArgument<"Name">]; let Subjects = SubjectList<[GlobalVar], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def PragmaClangRelroSection : InheritableAttr { @@ -2426,7 +2793,7 @@ def PragmaClangRelroSection : InheritableAttr { let Spellings = []; let Args = [StringArgument<"Name">]; let Subjects = SubjectList<[GlobalVar], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def StrictFP : InheritableAttr { @@ -2434,7 +2801,7 @@ def StrictFP : InheritableAttr { // Function uses strict floating point operations. let Spellings = []; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def PragmaClangTextSection : InheritableAttr { @@ -2442,7 +2809,16 @@ def PragmaClangTextSection : InheritableAttr { let Spellings = []; let Args = [StringArgument<"Name">]; let Subjects = SubjectList<[Function], ErrorDiag>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; +} + +def CodeModel : InheritableAttr, TargetSpecificAttr<TargetLoongArch> { + let Spellings = [GCC<"model">]; + let Args = [EnumArgument<"Model", "llvm::CodeModel::Model", + ["normal", "medium", "extreme"], ["Small", "Medium", "Large"], + /*opt=*/0, /*fake=*/0, /*isExternalType=*/1>]; + let Subjects = SubjectList<[NonTLSGlobalVar], ErrorDiag>; + let Documentation = [CodeModelDocs]; } def Sentinel : InheritableAttr { @@ -2454,7 +2830,8 @@ def Sentinel : InheritableAttr { } def StdCall : DeclOrTypeAttr { - let Spellings = [GCC<"stdcall">, Keyword<"__stdcall">, Keyword<"_stdcall">]; + let Spellings = [GCC<"stdcall">, CustomKeyword<"__stdcall">, + CustomKeyword<"_stdcall">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [StdCallDocs]; } @@ -2510,9 +2887,10 @@ def SwiftAsyncError : InheritableAttr { let Documentation = [SwiftAsyncErrorDocs]; } -def Suppress : StmtAttr { - let Spellings = [CXX11<"gsl", "suppress">]; +def Suppress : DeclOrStmtAttr { + let Spellings = [CXX11<"gsl", "suppress">, Clang<"suppress">]; let Args = [VariadicStringArgument<"DiagnosticIdentifiers">]; + let Accessors = [Accessor<"isGSL", [CXX11<"gsl", "suppress">]>]; let Documentation = [SuppressDocs]; } @@ -2523,21 +2901,35 @@ def SysVABI : DeclOrTypeAttr { } def ThisCall : DeclOrTypeAttr { - let Spellings = [GCC<"thiscall">, Keyword<"__thiscall">, - Keyword<"_thiscall">]; + let Spellings = [GCC<"thiscall">, CustomKeyword<"__thiscall">, + CustomKeyword<"_thiscall">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [ThisCallDocs]; } def VectorCall : DeclOrTypeAttr { - let Spellings = [Clang<"vectorcall">, Keyword<"__vectorcall">, - Keyword<"_vectorcall">]; + let Spellings = [Clang<"vectorcall">, CustomKeyword<"__vectorcall">, + CustomKeyword<"_vectorcall">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [VectorCallDocs]; } +def ZeroCallUsedRegs : InheritableAttr { + let Spellings = [GCC<"zero_call_used_regs">]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let Args = [ + EnumArgument<"ZeroCallUsedRegs", "ZeroCallUsedRegsKind", + ["skip", "used-gpr-arg", "used-gpr", "used-arg", "used", + "all-gpr-arg", "all-gpr", "all-arg", "all"], + ["Skip", "UsedGPRArg", "UsedGPR", "UsedArg", "Used", + "AllGPRArg", "AllGPR", "AllArg", "All"]> + ]; + let Documentation = [ZeroCallUsedRegsDocs]; +} + def Pascal : DeclOrTypeAttr { - let Spellings = [Clang<"pascal">, Keyword<"__pascal">, Keyword<"_pascal">]; + let Spellings = [Clang<"pascal">, CustomKeyword<"__pascal">, + CustomKeyword<"_pascal">]; // let Subjects = [Function, ObjCMethod]; let Documentation = [Undocumented]; } @@ -2562,16 +2954,17 @@ def PreserveAll : DeclOrTypeAttr { let Documentation = [PreserveAllDocs]; } +def M68kRTD: DeclOrTypeAttr { + let Spellings = [Clang<"m68k_rtd">]; + let Documentation = [M68kRTDDocs]; +} + def Target : InheritableAttr { let Spellings = [GCC<"target">]; let Args = [StringArgument<"featuresStr">]; let Subjects = SubjectList<[Function], ErrorDiag>; let Documentation = [TargetDocs]; let AdditionalMembers = [{ - ParsedTargetAttr parse() const { - return parse(getFeaturesStr()); - } - StringRef getArchitecture() const { StringRef Features = getFeaturesStr(); if (Features == "default") return {}; @@ -2581,7 +2974,7 @@ def Target : InheritableAttr { for (auto &Feature : AttrFeatures) { Feature = Feature.trim(); - if (Feature.startswith("arch=")) + if (Feature.starts_with("arch=")) return Feature.drop_front(sizeof("arch=") - 1); } return ""; @@ -2599,66 +2992,81 @@ def Target : InheritableAttr { for (auto &Feature : AttrFeatures) { Feature = Feature.trim(); - if (!Feature.startswith("no-") && !Feature.startswith("arch=") && - !Feature.startswith("fpmath=") && !Feature.startswith("tune=")) + if (!Feature.starts_with("no-") && !Feature.starts_with("arch=") && + !Feature.starts_with("fpmath=") && !Feature.starts_with("tune=")) Out.push_back(Feature); } } - template<class Compare> - ParsedTargetAttr parse(Compare cmp) const { - ParsedTargetAttr Attrs = parse(); - llvm::sort(std::begin(Attrs.Features), std::end(Attrs.Features), cmp); - return Attrs; - } - bool isDefaultVersion() const { return getFeaturesStr() == "default"; } + }]; +} - static ParsedTargetAttr parse(StringRef Features) { - ParsedTargetAttr Ret; - if (Features == "default") return Ret; - SmallVector<StringRef, 1> AttrFeatures; - Features.split(AttrFeatures, ","); +def TargetVersion : InheritableAttr { + let Spellings = [GCC<"target_version">]; + let Args = [StringArgument<"NamesStr">]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let Documentation = [TargetVersionDocs]; + let AdditionalMembers = [{ + StringRef getName() const { return getNamesStr().trim(); } + bool isDefaultVersion() const { + return getName() == "default"; + } + void getFeatures(llvm::SmallVectorImpl<StringRef> &Out) const { + if (isDefaultVersion()) return; + StringRef Features = getName(); + + SmallVector<StringRef, 8> AttrFeatures; + Features.split(AttrFeatures, "+"); - // Grab the various features and prepend a "+" to turn on the feature to - // the backend and add them to our existing set of features. for (auto &Feature : AttrFeatures) { - // Go ahead and trim whitespace rather than either erroring or - // accepting it weirdly. Feature = Feature.trim(); - - // TODO: Support the fpmath option. It will require checking - // overall feature validity for the function with the rest of the - // attributes on the function. - if (Feature.startswith("fpmath=")) - continue; - - if (Feature.startswith("branch-protection=")) { - Ret.BranchProtection = Feature.split('=').second.trim(); - continue; - } - - // While we're here iterating check for a different target cpu. - if (Feature.startswith("arch=")) { - if (!Ret.Architecture.empty()) - Ret.DuplicateArchitecture = true; - else - Ret.Architecture = Feature.split("=").second.trim(); - } else if (Feature.startswith("tune=")) { - if (!Ret.Tune.empty()) - Ret.DuplicateTune = true; - else - Ret.Tune = Feature.split("=").second.trim(); - } else if (Feature.startswith("no-")) - Ret.Features.push_back("-" + Feature.split("-").second.str()); - else - Ret.Features.push_back("+" + Feature.str()); + Out.push_back(Feature); } - return Ret; } }]; } +def TargetClones : InheritableAttr { + let Spellings = [GCC<"target_clones">]; + let Args = [VariadicStringArgument<"featuresStrs">]; + let Documentation = [TargetClonesDocs]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let AdditionalMembers = [{ + StringRef getFeatureStr(unsigned Index) const { + return *(featuresStrs_begin() + Index); + } + // Given an index into the 'featuresStrs' sequence, compute a unique + // ID to be used with function name mangling for the associated variant. + // This mapping is necessary due to a requirement that the mangling ID + // used for the "default" variant be the largest mangling ID in the + // variant set. Duplicate variants present in 'featuresStrs' are also + // assigned their own unique ID (the mapping is bijective). + unsigned getMangledIndex(unsigned Index) const { + if (getFeatureStr(Index) == "default") + return std::count_if(featuresStrs_begin(), featuresStrs_end(), + [](StringRef S) { return S != "default"; }); + + return std::count_if(featuresStrs_begin(), featuresStrs_begin() + Index, + [](StringRef S) { return S != "default"; }); + } + + // Given an index into the 'featuresStrs' sequence, determine if the + // index corresponds to the first instance of the named variant. This + // is used to skip over duplicate variant instances when iterating over + // 'featuresStrs'. + bool isFirstOfVersion(unsigned Index) const { + StringRef FeatureStr(getFeatureStr(Index)); + return 0 == std::count_if( + featuresStrs_begin(), featuresStrs_begin() + Index, + [FeatureStr](StringRef S) { return S == FeatureStr; }); + + } + }]; +} + +def : MutualExclusions<[TargetClones, TargetVersion, Target, CPUDispatch, CPUSpecific]>; + def MinVectorWidth : InheritableAttr { let Spellings = [Clang<"min_vector_width">]; let Args = [UnsignedArgument<"VectorWidth">]; @@ -2685,9 +3093,11 @@ def Unavailable : InheritableAttr { "IR_ARCInitReturnsUnrelated", "IR_ARCFieldWithOwnership"], 1, /*fake*/ 1>]; let Documentation = [Undocumented]; + let MeaningfulToClassTemplateDefinition = 1; } def DiagnoseIf : InheritableAttr { + let CanPrintOnLeft = 0; // Does not have a [[]] spelling because this attribute requires the ability // to parse function arguments but the attribute is not written in the type // position. @@ -2738,7 +3148,7 @@ def ObjCRequiresPropertyDefs : InheritableAttr { def Unused : InheritableAttr { let Spellings = [CXX11<"", "maybe_unused", 201603>, GCC<"unused">, - C2x<"", "maybe_unused", 201904>]; + C23<"", "maybe_unused", 202106>]; let Subjects = SubjectList<[Var, ObjCIvar, Type, Enum, EnumConstant, Label, Field, ObjCMethod, FunctionLike]>; let Documentation = [WarnMaybeUnusedDocs]; @@ -2832,10 +3242,10 @@ def WarnUnused : InheritableAttr { def WarnUnusedResult : InheritableAttr { let Spellings = [CXX11<"", "nodiscard", 201907>, - C2x<"", "nodiscard", 201904>, + C23<"", "nodiscard", 202003>, CXX11<"clang", "warn_unused_result">, GCC<"warn_unused_result">]; - let Subjects = SubjectList<[ObjCMethod, Enum, Record, FunctionLike]>; + let Subjects = SubjectList<[ObjCMethod, Enum, Record, FunctionLike, TypedefName]>; let Args = [StringArgument<"Message", 1>]; let Documentation = [WarnUnusedResultsDocs]; let AdditionalMembers = [{ @@ -2850,7 +3260,7 @@ def WarnUnusedResult : InheritableAttr { def Weak : InheritableAttr { let Spellings = [GCC<"weak">]; let Subjects = SubjectList<[Var, Function, CXXRecord]>; - let Documentation = [Undocumented]; + let Documentation = [WeakDocs]; let SimpleHandler = 1; } @@ -2881,7 +3291,7 @@ def AnyX86Interrupt : InheritableAttr, TargetSpecificAttr<TargetAnyX86> { let Subjects = SubjectList<[HasFunctionProto]>; let ParseKind = "Interrupt"; let HasCustomParsing = 1; - let Documentation = [Undocumented]; + let Documentation = [AnyX86InterruptDocs]; } def AnyX86NoCallerSavedRegisters : InheritableAttr, @@ -2940,6 +3350,13 @@ def NoSanitizeSpecific : InheritableAttr { let ASTNode = 0; } +def DisableSanitizerInstrumentation : InheritableAttr { + let Spellings = [Clang<"disable_sanitizer_instrumentation">]; + let Subjects = SubjectList<[Function, ObjCMethod, GlobalVar]>; + let Documentation = [DisableSanitizerInstrumentationDocs]; + let SimpleHandler = 1; +} + def CFICanonicalJumpTable : InheritableAttr { let Spellings = [Clang<"cfi_canonical_jump_table">]; let Subjects = SubjectList<[Function], ErrorDiag>; @@ -3325,6 +3742,14 @@ def : MutualExclusions<[Owner, Pointer]>; // Microsoft-related attributes +def MSConstexpr : InheritableAttr { + let LangOpts = [MicrosoftExt]; + let Spellings = [CXX11<"msvc", "constexpr">]; + let Subjects = SubjectList<[Function, ReturnStmt], ErrorDiag, + "functions and return statements">; + let Documentation = [MSConstexprDocs]; +} + def MSNoVTable : InheritableAttr, TargetSpecificAttr<TargetMicrosoftCXXABI> { let Spellings = [Declspec<"novtable">]; let Subjects = SubjectList<[CXXRecord]>; @@ -3342,10 +3767,10 @@ def MSAllocator : InheritableAttr { let Documentation = [MSAllocatorDocs]; } -def CFGuard : InheritableAttr { +def CFGuard : InheritableAttr, TargetSpecificAttr<TargetWindows> { // Currently only the __declspec(guard(nocf)) modifier is supported. In future // we might also want to support __declspec(guard(suppress)). - let Spellings = [Declspec<"guard">]; + let Spellings = [Declspec<"guard">, Clang<"guard">]; let Subjects = SubjectList<[Function]>; let Args = [EnumArgument<"Guard", "GuardArg", ["nocf"], ["nocf"]>]; let Documentation = [CFGuardDocs]; @@ -3372,7 +3797,7 @@ def DLLExportStaticLocal : InheritableAttr, TargetSpecificAttr<TargetHasDLLImpor // the function has local static variables, the function is dllexported too. let Spellings = []; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def DLLImport : InheritableAttr, TargetSpecificAttr<TargetHasDLLImportExport> { @@ -3398,7 +3823,7 @@ def DLLImportStaticLocal : InheritableAttr, TargetSpecificAttr<TargetHasDLLImpor // attribute is used to determine whether the variables are imported or not. let Spellings = []; let Subjects = SubjectList<[Function]>; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def SelectAny : InheritableAttr { @@ -3415,37 +3840,37 @@ def Thread : Attr { } def Win64 : IgnoredAttr { - let Spellings = [Keyword<"__w64">]; + let Spellings = [CustomKeyword<"__w64">]; let LangOpts = [MicrosoftExt]; } def Ptr32 : TypeAttr { - let Spellings = [Keyword<"__ptr32">]; + let Spellings = [CustomKeyword<"__ptr32">]; let Documentation = [Ptr32Docs]; } def Ptr64 : TypeAttr { - let Spellings = [Keyword<"__ptr64">]; + let Spellings = [CustomKeyword<"__ptr64">]; let Documentation = [Ptr64Docs]; } def SPtr : TypeAttr { - let Spellings = [Keyword<"__sptr">]; + let Spellings = [CustomKeyword<"__sptr">]; let Documentation = [SPtrDocs]; } def UPtr : TypeAttr { - let Spellings = [Keyword<"__uptr">]; + let Spellings = [CustomKeyword<"__uptr">]; let Documentation = [UPtrDocs]; } def MSInheritance : InheritableAttr { let LangOpts = [MicrosoftExt]; let Args = [DefaultBoolArgument<"BestCase", /*default*/1, /*fake*/1>]; - let Spellings = [Keyword<"__single_inheritance">, - Keyword<"__multiple_inheritance">, - Keyword<"__virtual_inheritance">, - Keyword<"__unspecified_inheritance">]; + let Spellings = [CustomKeyword<"__single_inheritance">, + CustomKeyword<"__multiple_inheritance">, + CustomKeyword<"__virtual_inheritance">, + CustomKeyword<"__unspecified_inheritance">]; let AdditionalMembers = [{ MSInheritanceModel getInheritanceModel() const { // The spelling enum should agree with MSInheritanceModel. @@ -3464,7 +3889,7 @@ def MSVtorDisp : InheritableAttr { let AdditionalMembers = [{ MSVtorDispMode getVtorDispMode() const { return MSVtorDispMode(vdm); } }]; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def InitSeg : Attr { @@ -3556,21 +3981,21 @@ def CapturedRecord : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def OMPThreadPrivateDecl : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def OMPCaptureNoInit : InheritableAttr { // This attribute has no spellings as it is only ever created implicitly. let Spellings = []; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def OMPCaptureKind : Attr { @@ -3578,7 +4003,7 @@ def OMPCaptureKind : Attr { let Spellings = []; let SemaHandler = 0; let Args = [UnsignedArgument<"CaptureKindVal">]; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; let AdditionalMembers = [{ llvm::omp::Clause getCaptureKind() const { return static_cast<llvm::omp::Clause>(getCaptureKindVal()); @@ -3591,7 +4016,7 @@ def OMPReferencedVar : Attr { let Spellings = []; let SemaHandler = 0; let Args = [ExprArgument<"Ref">]; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def OMPDeclareSimdDecl : Attr { @@ -3622,20 +4047,22 @@ def OMPDeclareTargetDecl : InheritableAttr { let Documentation = [OMPDeclareTargetDocs]; let Args = [ EnumArgument<"MapType", "MapTypeTy", - [ "to", "link" ], - [ "MT_To", "MT_Link" ]>, + [ "to", "enter", "link" ], + [ "MT_To", "MT_Enter", "MT_Link" ]>, EnumArgument<"DevType", "DevTypeTy", [ "host", "nohost", "any" ], [ "DT_Host", "DT_NoHost", "DT_Any" ]>, + ExprArgument<"IndirectExpr">, + BoolArgument<"Indirect">, UnsignedArgument<"Level"> ]; let AdditionalMembers = [{ void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const; - static llvm::Optional<MapTypeTy> + static std::optional<MapTypeTy> isDeclareTargetDeclaration(const ValueDecl *VD); - static llvm::Optional<OMPDeclareTargetDeclAttr*> getActiveAttr(const ValueDecl *VD); - static llvm::Optional<DevTypeTy> getDeviceType(const ValueDecl *VD); - static llvm::Optional<SourceLocation> getLocation(const ValueDecl *VD); + static std::optional<OMPDeclareTargetDeclAttr*> getActiveAttr(const ValueDecl *VD); + static std::optional<DevTypeTy> getDeviceType(const ValueDecl *VD); + static std::optional<SourceLocation> getLocation(const ValueDecl *VD); }]; } @@ -3659,9 +4086,10 @@ def OMPAllocateDecl : InheritableAttr { "OMPCGroupMemAlloc", "OMPPTeamMemAlloc", "OMPThreadMemAlloc", "OMPUserDefinedMemAlloc" ]>, - ExprArgument<"Allocator"> + ExprArgument<"Allocator">, + ExprArgument<"Alignment"> ]; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def OMPDeclareVariant : InheritableAttr { @@ -3674,11 +4102,21 @@ def OMPDeclareVariant : InheritableAttr { let Args = [ ExprArgument<"VariantFuncRef">, OMPTraitInfoArgument<"TraitInfos">, + VariadicExprArgument<"AdjustArgsNothing">, + VariadicExprArgument<"AdjustArgsNeedDevicePtr">, + VariadicOMPInteropInfoArgument<"AppendArgs">, ]; let AdditionalMembers = [{ OMPTraitInfo &getTraitInfo() { return *traitInfos; } void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy) const; + static StringRef getInteropTypeString(const OMPInteropInfo *I) { + if (I->IsTarget && I->IsTargetSync) + return "target,targetsync"; + if (I->IsTarget) + return "target"; + return "targetsync"; + } }]; } @@ -3800,17 +4238,31 @@ def ReleaseHandle : InheritableParamAttr { let Documentation = [ReleaseHandleDocs]; } +def UnsafeBufferUsage : InheritableAttr { + let Spellings = [Clang<"unsafe_buffer_usage">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [UnsafeBufferUsageDocs]; +} + +def DiagnoseAsBuiltin : InheritableAttr { + let Spellings = [Clang<"diagnose_as_builtin">]; + let Args = [DeclArgument<Function, "Function">, + VariadicUnsignedArgument<"ArgIndices">]; + let Subjects = SubjectList<[Function]>; + let Documentation = [DiagnoseAsBuiltinDocs]; +} + def Builtin : InheritableAttr { let Spellings = []; let Args = [UnsignedArgument<"ID">]; let Subjects = SubjectList<[Function]>; let SemaHandler = 0; - let Documentation = [Undocumented]; + let Documentation = [InternalOnly]; } def EnforceTCB : InheritableAttr { let Spellings = [Clang<"enforce_tcb">]; - let Subjects = SubjectList<[Function]>; + let Subjects = SubjectList<[Function, ObjCMethod]>; let Args = [StringArgument<"TCBName">]; let Documentation = [EnforceTCBDocs]; bit InheritEvenIfAlreadyPresent = 1; @@ -3818,8 +4270,191 @@ def EnforceTCB : InheritableAttr { def EnforceTCBLeaf : InheritableAttr { let Spellings = [Clang<"enforce_tcb_leaf">]; - let Subjects = SubjectList<[Function]>; + let Subjects = SubjectList<[Function, ObjCMethod]>; let Args = [StringArgument<"TCBName">]; let Documentation = [EnforceTCBLeafDocs]; bit InheritEvenIfAlreadyPresent = 1; } + +def Error : InheritableAttr { + let Spellings = [GCC<"error">, GCC<"warning">]; + let Accessors = [Accessor<"isError", [GCC<"error">]>, + Accessor<"isWarning", [GCC<"warning">]>]; + let Args = [StringArgument<"UserDiagnostic">]; + let Subjects = SubjectList<[Function], ErrorDiag>; + let Documentation = [ErrorAttrDocs]; +} + +def HLSLNumThreads: InheritableAttr { + let Spellings = [Microsoft<"numthreads">]; + let Args = [IntArgument<"X">, IntArgument<"Y">, IntArgument<"Z">]; + let Subjects = SubjectList<[HLSLEntry]>; + let LangOpts = [HLSL]; + let Documentation = [NumThreadsDocs]; +} + +def HLSLSV_GroupIndex: HLSLAnnotationAttr { + let Spellings = [HLSLSemantic<"SV_GroupIndex">]; + let Subjects = SubjectList<[ParmVar, GlobalVar]>; + let LangOpts = [HLSL]; + let Documentation = [HLSLSV_GroupIndexDocs]; +} + +def HLSLResourceBinding: InheritableAttr { + let Spellings = [HLSLSemantic<"register">]; + let Subjects = SubjectList<[HLSLBufferObj, ExternalGlobalVar]>; + let LangOpts = [HLSL]; + let Args = [StringArgument<"Slot">, StringArgument<"Space", 1>]; + let Documentation = [HLSLResourceBindingDocs]; +} + +def HLSLSV_DispatchThreadID: HLSLAnnotationAttr { + let Spellings = [HLSLSemantic<"SV_DispatchThreadID">]; + let Subjects = SubjectList<[ParmVar, Field]>; + let LangOpts = [HLSL]; + let Documentation = [HLSLSV_DispatchThreadIDDocs]; +} + +def HLSLShader : InheritableAttr { + let Spellings = [Microsoft<"shader">]; + let Subjects = SubjectList<[HLSLEntry]>; + let LangOpts = [HLSL]; + let Args = [ + EnumArgument<"Type", "ShaderType", + ["pixel", "vertex", "geometry", "hull", "domain", "compute", + "raygeneration", "intersection", "anyhit", "closesthit", + "miss", "callable", "mesh", "amplification"], + ["Pixel", "Vertex", "Geometry", "Hull", "Domain", "Compute", + "RayGeneration", "Intersection", "AnyHit", "ClosestHit", + "Miss", "Callable", "Mesh", "Amplification"]> + ]; + let Documentation = [HLSLSV_ShaderTypeAttrDocs]; +} + +def HLSLResource : InheritableAttr { + let Spellings = []; + let Subjects = SubjectList<[Struct]>; + let LangOpts = [HLSL]; + let Args = [EnumArgument<"ResourceClass", "llvm::hlsl::ResourceClass", + ["SRV", "UAV", "CBuffer", "Sampler"], + ["SRV", "UAV", "CBuffer", "Sampler"], + /*opt=*/0, /*fake=*/0, /*isExternalType=*/1>, + EnumArgument<"ResourceKind", "llvm::hlsl::ResourceKind", + ["Texture1D", "Texture2D", "Texture2DMS", + "Texture3D", "TextureCube", "Texture1DArray", + "Texture2DArray", "Texture2DMSArray", + "TextureCubeArray", "TypedBuffer", "RawBuffer", + "StructuredBuffer", "CBuffer", "Sampler", + "TBuffer", "RTAccelerationStructure", + "FeedbackTexture2D", "FeedbackTexture2DArray"], + ["Texture1D", "Texture2D", "Texture2DMS", + "Texture3D", "TextureCube", "Texture1DArray", + "Texture2DArray", "Texture2DMSArray", + "TextureCubeArray", "TypedBuffer", "RawBuffer", + "StructuredBuffer", "CBuffer", "Sampler", + "TBuffer", "RTAccelerationStructure", + "FeedbackTexture2D", "FeedbackTexture2DArray"], + /*opt=*/0, /*fake=*/0, /*isExternalType=*/1>, + DefaultBoolArgument<"isROV", /*default=*/0> + ]; + let Documentation = [InternalOnly]; +} + +def HLSLGroupSharedAddressSpace : TypeAttr { + let Spellings = [CustomKeyword<"groupshared">]; + let Subjects = SubjectList<[Var]>; + let Documentation = [HLSLGroupSharedAddressSpaceDocs]; +} + +def HLSLParamModifier : TypeAttr { + let Spellings = [CustomKeyword<"in">, CustomKeyword<"inout">, CustomKeyword<"out">]; + let Accessors = [Accessor<"isIn", [CustomKeyword<"in">]>, + Accessor<"isInOut", [CustomKeyword<"inout">]>, + Accessor<"isOut", [CustomKeyword<"out">]>, + Accessor<"isAnyOut", [CustomKeyword<"out">, CustomKeyword<"inout">]>, + Accessor<"isAnyIn", [CustomKeyword<"in">, CustomKeyword<"inout">]>]; + let Subjects = SubjectList<[ParmVar]>; + let Documentation = [HLSLParamQualifierDocs]; + let Args = [DefaultBoolArgument<"MergedSpelling", /*default*/0, /*fake*/1>]; +} + +def RandomizeLayout : InheritableAttr { + let Spellings = [GCC<"randomize_layout">]; + let Subjects = SubjectList<[Record]>; + let Documentation = [ClangRandomizeLayoutDocs]; + let LangOpts = [COnly]; +} + +def NoRandomizeLayout : InheritableAttr { + let Spellings = [GCC<"no_randomize_layout">]; + let Subjects = SubjectList<[Record]>; + let Documentation = [ClangRandomizeLayoutDocs]; + let LangOpts = [COnly]; +} +def : MutualExclusions<[RandomizeLayout, NoRandomizeLayout]>; + +def FunctionReturnThunks : InheritableAttr, + TargetSpecificAttr<TargetAnyX86> { + let Spellings = [GCC<"function_return">]; + let Args = [EnumArgument<"ThunkType", "Kind", + ["keep", "thunk-extern"], + ["Keep", "Extern"] + >]; + let Subjects = SubjectList<[Function]>; + let Documentation = [FunctionReturnThunksDocs]; +} + +def WebAssemblyFuncref : TypeAttr, TargetSpecificAttr<TargetWebAssembly> { + let Spellings = [CustomKeyword<"__funcref">]; + let Documentation = [WebAssemblyExportNameDocs]; + let Subjects = SubjectList<[FunctionPointer], ErrorDiag>; +} + +def ReadOnlyPlacement : InheritableAttr { + let Spellings = [Clang<"enforce_read_only_placement">]; + let Subjects = SubjectList<[Record]>; + let Documentation = [ReadOnlyPlacementDocs]; +} + +def AvailableOnlyInDefaultEvalMethod : InheritableAttr { + let Spellings = [Clang<"available_only_in_default_eval_method">]; + let Subjects = SubjectList<[TypedefName], ErrorDiag>; + let Documentation = [Undocumented]; +} + +def PreferredType: InheritableAttr { + let Spellings = [Clang<"preferred_type">]; + let Subjects = SubjectList<[BitField], ErrorDiag>; + let Args = [TypeArgument<"Type", 1>]; + let Documentation = [PreferredTypeDocumentation]; +} + +def CodeAlign: StmtAttr { + let Spellings = [Clang<"code_align">]; + let Subjects = SubjectList<[ForStmt, CXXForRangeStmt, WhileStmt, DoStmt], + ErrorDiag, "'for', 'while', and 'do' statements">; + let Args = [ExprArgument<"Alignment">]; + let Documentation = [CodeAlignAttrDocs]; + let AdditionalMembers = [{ + static constexpr int MinimumAlignment = 1; + static constexpr int MaximumAlignment = 4096; + }]; +} + +def CountedBy : InheritableAttr { + let Spellings = [Clang<"counted_by">]; + let Subjects = SubjectList<[Field]>; + let Args = [IdentifierArgument<"CountedByField">]; + let Documentation = [CountedByDocs]; + let LangOpts = [COnly]; + // FIXME: This is ugly. Let using a DeclArgument would be nice, but a Decl + // isn't yet available due to the fact that we're still parsing the + // structure. Maybe that code could be changed sometime in the future. + code AdditionalMembers = [{ + private: + SourceRange CountedByFieldLoc; + public: + SourceRange getCountedByFieldLoc() const { return CountedByFieldLoc; } + void setCountedByFieldLoc(SourceRange Loc) { CountedByFieldLoc = Loc; } + }]; +} |