diff options
Diffstat (limited to 'llvm/include/llvm/IR/Attributes.td')
| -rw-r--r-- | llvm/include/llvm/IR/Attributes.td | 191 |
1 files changed, 110 insertions, 81 deletions
diff --git a/llvm/include/llvm/IR/Attributes.td b/llvm/include/llvm/IR/Attributes.td index f7ffc888c65a..99b474161df7 100644 --- a/llvm/include/llvm/IR/Attributes.td +++ b/llvm/include/llvm/IR/Attributes.td @@ -10,225 +10,246 @@ // //===----------------------------------------------------------------------===// +/// Attribute property base class. +class AttrProperty; + +/// Can be used as function attribute. +def FnAttr : AttrProperty; + +/// Can be used as parameter attribute. +def ParamAttr : AttrProperty; + +/// Can be used as return attribute. +def RetAttr : AttrProperty; + /// Attribute base class. -class Attr<string S> { +class Attr<string S, list<AttrProperty> P> { // String representation of this attribute in the IR. string AttrString = S; + list<AttrProperty> Properties = P; } /// Enum attribute. -class EnumAttr<string S> : Attr<S>; +class EnumAttr<string S, list<AttrProperty> P> : Attr<S, P>; /// Int attribute. -class IntAttr<string S> : Attr<S>; - -/// StringBool attribute. -class StrBoolAttr<string S> : Attr<S>; +class IntAttr<string S, list<AttrProperty> P> : Attr<S, P>; /// Type attribute. -class TypeAttr<string S> : Attr<S>; +class TypeAttr<string S, list<AttrProperty> P> : Attr<S, P>; + +/// StringBool attribute. +class StrBoolAttr<string S> : Attr<S, []>; /// Target-independent enum attributes. /// Alignment of parameter (5 bits) stored as log2 of alignment with +1 bias. /// 0 means unaligned (different from align(1)). -def Alignment : IntAttr<"align">; +def Alignment : IntAttr<"align", [ParamAttr, RetAttr]>; /// The result of the function is guaranteed to point to a number of bytes that /// we can determine if we know the value of the function's arguments. -def AllocSize : IntAttr<"allocsize">; +def AllocSize : IntAttr<"allocsize", [FnAttr]>; /// inline=always. -def AlwaysInline : EnumAttr<"alwaysinline">; +def AlwaysInline : EnumAttr<"alwaysinline", [FnAttr]>; /// Function can access memory only using pointers based on its arguments. -def ArgMemOnly : EnumAttr<"argmemonly">; +def ArgMemOnly : EnumAttr<"argmemonly", [FnAttr]>; /// Callee is recognized as a builtin, despite nobuiltin attribute on its /// declaration. -def Builtin : EnumAttr<"builtin">; +def Builtin : EnumAttr<"builtin", [FnAttr]>; /// Pass structure by value. -def ByVal : TypeAttr<"byval">; +def ByVal : TypeAttr<"byval", [ParamAttr]>; /// Mark in-memory ABI type. -def ByRef : TypeAttr<"byref">; +def ByRef : TypeAttr<"byref", [ParamAttr]>; /// Parameter or return value may not contain uninitialized or poison bits. -def NoUndef : EnumAttr<"noundef">; +def NoUndef : EnumAttr<"noundef", [ParamAttr, RetAttr]>; /// Marks function as being in a cold path. -def Cold : EnumAttr<"cold">; +def Cold : EnumAttr<"cold", [FnAttr]>; /// Can only be moved to control-equivalent blocks. -def Convergent : EnumAttr<"convergent">; +def Convergent : EnumAttr<"convergent", [FnAttr]>; /// Marks function as being in a hot path and frequently called. -def Hot: EnumAttr<"hot">; +def Hot: EnumAttr<"hot", [FnAttr]>; /// Pointer is known to be dereferenceable. -def Dereferenceable : IntAttr<"dereferenceable">; +def Dereferenceable : IntAttr<"dereferenceable", [ParamAttr, RetAttr]>; /// Pointer is either null or dereferenceable. -def DereferenceableOrNull : IntAttr<"dereferenceable_or_null">; +def DereferenceableOrNull : IntAttr<"dereferenceable_or_null", + [ParamAttr, RetAttr]>; + +/// Provide pointer element type to intrinsic. +def ElementType : TypeAttr<"elementtype", [ParamAttr]>; /// Function may only access memory that is inaccessible from IR. -def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly">; +def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly", [FnAttr]>; /// Function may only access memory that is either inaccessible from the IR, /// or pointed to by its pointer arguments. -def InaccessibleMemOrArgMemOnly : EnumAttr<"inaccessiblemem_or_argmemonly">; +def InaccessibleMemOrArgMemOnly : EnumAttr<"inaccessiblemem_or_argmemonly", + [FnAttr]>; /// Pass structure in an alloca. -def InAlloca : EnumAttr<"inalloca">; +def InAlloca : TypeAttr<"inalloca", [ParamAttr]>; /// Source said inlining was desirable. -def InlineHint : EnumAttr<"inlinehint">; +def InlineHint : EnumAttr<"inlinehint", [FnAttr]>; /// Force argument to be passed in register. -def InReg : EnumAttr<"inreg">; +def InReg : EnumAttr<"inreg", [ParamAttr, RetAttr]>; /// Build jump-instruction tables and replace refs. -def JumpTable : EnumAttr<"jumptable">; +def JumpTable : EnumAttr<"jumptable", [FnAttr]>; /// Function must be optimized for size first. -def MinSize : EnumAttr<"minsize">; +def MinSize : EnumAttr<"minsize", [FnAttr]>; /// Naked function. -def Naked : EnumAttr<"naked">; +def Naked : EnumAttr<"naked", [FnAttr]>; /// Nested function static chain. -def Nest : EnumAttr<"nest">; +def Nest : EnumAttr<"nest", [ParamAttr]>; /// Considered to not alias after call. -def NoAlias : EnumAttr<"noalias">; +def NoAlias : EnumAttr<"noalias", [ParamAttr, RetAttr]>; /// Callee isn't recognized as a builtin. -def NoBuiltin : EnumAttr<"nobuiltin">; +def NoBuiltin : EnumAttr<"nobuiltin", [FnAttr]>; /// Function cannot enter into caller's translation unit. -def NoCallback : EnumAttr<"nocallback">; +def NoCallback : EnumAttr<"nocallback", [FnAttr]>; /// Function creates no aliases of pointer. -def NoCapture : EnumAttr<"nocapture">; +def NoCapture : EnumAttr<"nocapture", [ParamAttr]>; /// Call cannot be duplicated. -def NoDuplicate : EnumAttr<"noduplicate">; +def NoDuplicate : EnumAttr<"noduplicate", [FnAttr]>; /// Function does not deallocate memory. -def NoFree : EnumAttr<"nofree">; +def NoFree : EnumAttr<"nofree", [FnAttr, ParamAttr]>; /// Disable implicit floating point insts. -def NoImplicitFloat : EnumAttr<"noimplicitfloat">; +def NoImplicitFloat : EnumAttr<"noimplicitfloat", [FnAttr]>; /// inline=never. -def NoInline : EnumAttr<"noinline">; +def NoInline : EnumAttr<"noinline", [FnAttr]>; /// Function is called early and/or often, so lazy binding isn't worthwhile. -def NonLazyBind : EnumAttr<"nonlazybind">; +def NonLazyBind : EnumAttr<"nonlazybind", [FnAttr]>; /// Disable merging for specified functions or call sites. -def NoMerge : EnumAttr<"nomerge">; +def NoMerge : EnumAttr<"nomerge", [FnAttr]>; /// Pointer is known to be not null. -def NonNull : EnumAttr<"nonnull">; +def NonNull : EnumAttr<"nonnull", [ParamAttr, RetAttr]>; /// The function does not recurse. -def NoRecurse : EnumAttr<"norecurse">; +def NoRecurse : EnumAttr<"norecurse", [FnAttr]>; /// Disable redzone. -def NoRedZone : EnumAttr<"noredzone">; +def NoRedZone : EnumAttr<"noredzone", [FnAttr]>; /// Mark the function as not returning. -def NoReturn : EnumAttr<"noreturn">; +def NoReturn : EnumAttr<"noreturn", [FnAttr]>; /// Function does not synchronize. -def NoSync : EnumAttr<"nosync">; +def NoSync : EnumAttr<"nosync", [FnAttr]>; /// Disable Indirect Branch Tracking. -def NoCfCheck : EnumAttr<"nocf_check">; +def NoCfCheck : EnumAttr<"nocf_check", [FnAttr]>; -/// Function should be instrumented. -def NoProfile : EnumAttr<"noprofile">; +/// Function should not be instrumented. +def NoProfile : EnumAttr<"noprofile", [FnAttr]>; /// Function doesn't unwind stack. -def NoUnwind : EnumAttr<"nounwind">; +def NoUnwind : EnumAttr<"nounwind", [FnAttr]>; + +/// No SanitizeCoverage instrumentation. +def NoSanitizeCoverage : EnumAttr<"nosanitize_coverage", [FnAttr]>; /// Null pointer in address space zero is valid. -def NullPointerIsValid : EnumAttr<"null_pointer_is_valid">; +def NullPointerIsValid : EnumAttr<"null_pointer_is_valid", [FnAttr]>; /// Select optimizations for best fuzzing signal. -def OptForFuzzing : EnumAttr<"optforfuzzing">; +def OptForFuzzing : EnumAttr<"optforfuzzing", [FnAttr]>; /// opt_size. -def OptimizeForSize : EnumAttr<"optsize">; +def OptimizeForSize : EnumAttr<"optsize", [FnAttr]>; /// Function must not be optimized. -def OptimizeNone : EnumAttr<"optnone">; +def OptimizeNone : EnumAttr<"optnone", [FnAttr]>; /// Similar to byval but without a copy. -def Preallocated : TypeAttr<"preallocated">; +def Preallocated : TypeAttr<"preallocated", [FnAttr, ParamAttr]>; /// Function does not access memory. -def ReadNone : EnumAttr<"readnone">; +def ReadNone : EnumAttr<"readnone", [FnAttr, ParamAttr]>; /// Function only reads from memory. -def ReadOnly : EnumAttr<"readonly">; +def ReadOnly : EnumAttr<"readonly", [FnAttr, ParamAttr]>; /// Return value is always equal to this argument. -def Returned : EnumAttr<"returned">; +def Returned : EnumAttr<"returned", [ParamAttr]>; /// Parameter is required to be a trivial constant. -def ImmArg : EnumAttr<"immarg">; +def ImmArg : EnumAttr<"immarg", [ParamAttr]>; /// Function can return twice. -def ReturnsTwice : EnumAttr<"returns_twice">; +def ReturnsTwice : EnumAttr<"returns_twice", [FnAttr]>; /// Safe Stack protection. -def SafeStack : EnumAttr<"safestack">; +def SafeStack : EnumAttr<"safestack", [FnAttr]>; /// Shadow Call Stack protection. -def ShadowCallStack : EnumAttr<"shadowcallstack">; +def ShadowCallStack : EnumAttr<"shadowcallstack", [FnAttr]>; /// Sign extended before/after call. -def SExt : EnumAttr<"signext">; +def SExt : EnumAttr<"signext", [ParamAttr, RetAttr]>; /// Alignment of stack for function (3 bits) stored as log2 of alignment with /// +1 bias 0 means unaligned (different from alignstack=(1)). -def StackAlignment : IntAttr<"alignstack">; +def StackAlignment : IntAttr<"alignstack", [FnAttr, ParamAttr]>; /// Function can be speculated. -def Speculatable : EnumAttr<"speculatable">; +def Speculatable : EnumAttr<"speculatable", [FnAttr]>; /// Stack protection. -def StackProtect : EnumAttr<"ssp">; +def StackProtect : EnumAttr<"ssp", [FnAttr]>; /// Stack protection required. -def StackProtectReq : EnumAttr<"sspreq">; +def StackProtectReq : EnumAttr<"sspreq", [FnAttr]>; /// Strong Stack protection. -def StackProtectStrong : EnumAttr<"sspstrong">; +def StackProtectStrong : EnumAttr<"sspstrong", [FnAttr]>; /// Function was called in a scope requiring strict floating point semantics. -def StrictFP : EnumAttr<"strictfp">; +def StrictFP : EnumAttr<"strictfp", [FnAttr]>; /// Hidden pointer to structure to return. -def StructRet : TypeAttr<"sret">; +def StructRet : TypeAttr<"sret", [ParamAttr]>; /// AddressSanitizer is on. -def SanitizeAddress : EnumAttr<"sanitize_address">; +def SanitizeAddress : EnumAttr<"sanitize_address", [FnAttr]>; /// ThreadSanitizer is on. -def SanitizeThread : EnumAttr<"sanitize_thread">; +def SanitizeThread : EnumAttr<"sanitize_thread", [FnAttr]>; /// MemorySanitizer is on. -def SanitizeMemory : EnumAttr<"sanitize_memory">; +def SanitizeMemory : EnumAttr<"sanitize_memory", [FnAttr]>; /// HWAddressSanitizer is on. -def SanitizeHWAddress : EnumAttr<"sanitize_hwaddress">; +def SanitizeHWAddress : EnumAttr<"sanitize_hwaddress", [FnAttr]>; /// MemTagSanitizer is on. -def SanitizeMemTag : EnumAttr<"sanitize_memtag">; +def SanitizeMemTag : EnumAttr<"sanitize_memtag", [FnAttr]>; /// Speculative Load Hardening is enabled. /// @@ -236,28 +257,35 @@ def SanitizeMemTag : EnumAttr<"sanitize_memtag">; /// inlining) and a conservative merge strategy where inlining an attributed /// body will add the attribute to the caller. This ensures that code carrying /// this attribute will always be lowered with hardening enabled. -def SpeculativeLoadHardening : EnumAttr<"speculative_load_hardening">; +def SpeculativeLoadHardening : EnumAttr<"speculative_load_hardening", + [FnAttr]>; /// Argument is swift error. -def SwiftError : EnumAttr<"swifterror">; +def SwiftError : EnumAttr<"swifterror", [ParamAttr]>; /// Argument is swift self/context. -def SwiftSelf : EnumAttr<"swiftself">; +def SwiftSelf : EnumAttr<"swiftself", [ParamAttr]>; + +/// Argument is swift async context. +def SwiftAsync : EnumAttr<"swiftasync", [ParamAttr]>; /// Function must be in a unwind table. -def UWTable : EnumAttr<"uwtable">; +def UWTable : EnumAttr<"uwtable", [FnAttr]>; + +/// Minimum/Maximum vscale value for function. +def VScaleRange : IntAttr<"vscale_range", [FnAttr]>; /// Function always comes back to callsite. -def WillReturn : EnumAttr<"willreturn">; +def WillReturn : EnumAttr<"willreturn", [FnAttr]>; /// Function only writes to memory. -def WriteOnly : EnumAttr<"writeonly">; +def WriteOnly : EnumAttr<"writeonly", [FnAttr, ParamAttr]>; /// Zero extended before/after call. -def ZExt : EnumAttr<"zeroext">; +def ZExt : EnumAttr<"zeroext", [ParamAttr, RetAttr]>; /// Function is required to make Forward Progress. -def MustProgress : TypeAttr<"mustprogress">; +def MustProgress : EnumAttr<"mustprogress", [FnAttr]>; /// Target-independent string attributes. def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">; @@ -288,6 +316,7 @@ def : CompatRule<"isEqual<SanitizeMemTagAttr>">; def : CompatRule<"isEqual<SafeStackAttr>">; def : CompatRule<"isEqual<ShadowCallStackAttr>">; def : CompatRule<"isEqual<UseSampleProfileAttr>">; +def : CompatRule<"isEqual<NoProfileAttr>">; class MergeRule<string F> { // The name of the function called to merge the attributes of the caller and |