| //===- Attributes.td - Defines all LLVM attributes ---------*- tablegen -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines all the LLVM attributes. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| /// Attribute base class. |
| class Attr<string S> { |
| // String representation of this attribute in the IR. |
| string AttrString = S; |
| } |
| |
| /// Enum attribute. |
| class EnumAttr<string S> : Attr<S>; |
| |
| /// Int attribute. |
| class IntAttr<string S> : Attr<S>; |
| |
| /// StringBool attribute. |
| class StrBoolAttr<string S> : Attr<S>; |
| |
| /// Type attribute. |
| class TypeAttr<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">; |
| |
| /// 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">; |
| |
| /// inline=always. |
| def AlwaysInline : EnumAttr<"alwaysinline">; |
| |
| /// Function can access memory only using pointers based on its arguments. |
| def ArgMemOnly : EnumAttr<"argmemonly">; |
| |
| /// Callee is recognized as a builtin, despite nobuiltin attribute on its |
| /// declaration. |
| def Builtin : EnumAttr<"builtin">; |
| |
| /// Pass structure by value. |
| def ByVal : TypeAttr<"byval">; |
| |
| /// Mark in-memory ABI type. |
| def ByRef : TypeAttr<"byref">; |
| |
| /// Parameter or return value may not contain uninitialized or poison bits. |
| def NoUndef : EnumAttr<"noundef">; |
| |
| /// Marks function as being in a cold path. |
| def Cold : EnumAttr<"cold">; |
| |
| /// Can only be moved to control-equivalent blocks. |
| def Convergent : EnumAttr<"convergent">; |
| |
| /// Marks function as being in a hot path and frequently called. |
| def Hot: EnumAttr<"hot">; |
| |
| /// Pointer is known to be dereferenceable. |
| def Dereferenceable : IntAttr<"dereferenceable">; |
| |
| /// Pointer is either null or dereferenceable. |
| def DereferenceableOrNull : IntAttr<"dereferenceable_or_null">; |
| |
| /// Function may only access memory that is inaccessible from IR. |
| def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly">; |
| |
| /// 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">; |
| |
| /// Pass structure in an alloca. |
| def InAlloca : EnumAttr<"inalloca">; |
| |
| /// Source said inlining was desirable. |
| def InlineHint : EnumAttr<"inlinehint">; |
| |
| /// Force argument to be passed in register. |
| def InReg : EnumAttr<"inreg">; |
| |
| /// Build jump-instruction tables and replace refs. |
| def JumpTable : EnumAttr<"jumptable">; |
| |
| /// Function must be optimized for size first. |
| def MinSize : EnumAttr<"minsize">; |
| |
| /// Naked function. |
| def Naked : EnumAttr<"naked">; |
| |
| /// Nested function static chain. |
| def Nest : EnumAttr<"nest">; |
| |
| /// Considered to not alias after call. |
| def NoAlias : EnumAttr<"noalias">; |
| |
| /// Callee isn't recognized as a builtin. |
| def NoBuiltin : EnumAttr<"nobuiltin">; |
| |
| /// Function cannot enter into caller's translation unit. |
| def NoCallback : EnumAttr<"nocallback">; |
| |
| /// Function creates no aliases of pointer. |
| def NoCapture : EnumAttr<"nocapture">; |
| |
| /// Call cannot be duplicated. |
| def NoDuplicate : EnumAttr<"noduplicate">; |
| |
| /// Function does not deallocate memory. |
| def NoFree : EnumAttr<"nofree">; |
| |
| /// Disable implicit floating point insts. |
| def NoImplicitFloat : EnumAttr<"noimplicitfloat">; |
| |
| /// inline=never. |
| def NoInline : EnumAttr<"noinline">; |
| |
| /// Function is called early and/or often, so lazy binding isn't worthwhile. |
| def NonLazyBind : EnumAttr<"nonlazybind">; |
| |
| /// Disable merging for specified functions or call sites. |
| def NoMerge : EnumAttr<"nomerge">; |
| |
| /// Pointer is known to be not null. |
| def NonNull : EnumAttr<"nonnull">; |
| |
| /// The function does not recurse. |
| def NoRecurse : EnumAttr<"norecurse">; |
| |
| /// Disable redzone. |
| def NoRedZone : EnumAttr<"noredzone">; |
| |
| /// Mark the function as not returning. |
| def NoReturn : EnumAttr<"noreturn">; |
| |
| /// Function does not synchronize. |
| def NoSync : EnumAttr<"nosync">; |
| |
| /// Disable Indirect Branch Tracking. |
| def NoCfCheck : EnumAttr<"nocf_check">; |
| |
| /// Function doesn't unwind stack. |
| def NoUnwind : EnumAttr<"nounwind">; |
| |
| /// Null pointer in address space zero is valid. |
| def NullPointerIsValid : EnumAttr<"null_pointer_is_valid">; |
| |
| /// Select optimizations for best fuzzing signal. |
| def OptForFuzzing : EnumAttr<"optforfuzzing">; |
| |
| /// opt_size. |
| def OptimizeForSize : EnumAttr<"optsize">; |
| |
| /// Function must not be optimized. |
| def OptimizeNone : EnumAttr<"optnone">; |
| |
| /// Similar to byval but without a copy. |
| def Preallocated : TypeAttr<"preallocated">; |
| |
| /// Function does not access memory. |
| def ReadNone : EnumAttr<"readnone">; |
| |
| /// Function only reads from memory. |
| def ReadOnly : EnumAttr<"readonly">; |
| |
| /// Return value is always equal to this argument. |
| def Returned : EnumAttr<"returned">; |
| |
| /// Parameter is required to be a trivial constant. |
| def ImmArg : EnumAttr<"immarg">; |
| |
| /// Function can return twice. |
| def ReturnsTwice : EnumAttr<"returns_twice">; |
| |
| /// Safe Stack protection. |
| def SafeStack : EnumAttr<"safestack">; |
| |
| /// Shadow Call Stack protection. |
| def ShadowCallStack : EnumAttr<"shadowcallstack">; |
| |
| /// Sign extended before/after call. |
| def SExt : EnumAttr<"signext">; |
| |
| /// 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">; |
| |
| /// Function can be speculated. |
| def Speculatable : EnumAttr<"speculatable">; |
| |
| /// Stack protection. |
| def StackProtect : EnumAttr<"ssp">; |
| |
| /// Stack protection required. |
| def StackProtectReq : EnumAttr<"sspreq">; |
| |
| /// Strong Stack protection. |
| def StackProtectStrong : EnumAttr<"sspstrong">; |
| |
| /// Function was called in a scope requiring strict floating point semantics. |
| def StrictFP : EnumAttr<"strictfp">; |
| |
| /// Hidden pointer to structure to return. |
| def StructRet : TypeAttr<"sret">; |
| |
| /// AddressSanitizer is on. |
| def SanitizeAddress : EnumAttr<"sanitize_address">; |
| |
| /// ThreadSanitizer is on. |
| def SanitizeThread : EnumAttr<"sanitize_thread">; |
| |
| /// MemorySanitizer is on. |
| def SanitizeMemory : EnumAttr<"sanitize_memory">; |
| |
| /// HWAddressSanitizer is on. |
| def SanitizeHWAddress : EnumAttr<"sanitize_hwaddress">; |
| |
| /// MemTagSanitizer is on. |
| def SanitizeMemTag : EnumAttr<"sanitize_memtag">; |
| |
| /// Speculative Load Hardening is enabled. |
| /// |
| /// Note that this uses the default compatibility (always compatible during |
| /// 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">; |
| |
| /// Argument is swift error. |
| def SwiftError : EnumAttr<"swifterror">; |
| |
| /// Argument is swift self/context. |
| def SwiftSelf : EnumAttr<"swiftself">; |
| |
| /// Function must be in a unwind table. |
| def UWTable : EnumAttr<"uwtable">; |
| |
| /// Function always comes back to callsite. |
| def WillReturn : EnumAttr<"willreturn">; |
| |
| /// Function only writes to memory. |
| def WriteOnly : EnumAttr<"writeonly">; |
| |
| /// Zero extended before/after call. |
| def ZExt : EnumAttr<"zeroext">; |
| |
| /// Function is required to make Forward Progress. |
| def MustProgress : TypeAttr<"mustprogress">; |
| |
| /// Target-independent string attributes. |
| def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">; |
| def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">; |
| def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">; |
| def NoSignedZerosFPMath : StrBoolAttr<"no-signed-zeros-fp-math">; |
| def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">; |
| def NoJumpTables : StrBoolAttr<"no-jump-tables">; |
| def NoInlineLineTables : StrBoolAttr<"no-inline-line-tables">; |
| def ProfileSampleAccurate : StrBoolAttr<"profile-sample-accurate">; |
| def UseSampleProfile : StrBoolAttr<"use-sample-profile">; |
| |
| class CompatRule<string F> { |
| // The name of the function called to check the attribute of the caller and |
| // callee and decide whether inlining should be allowed. The function's |
| // signature must match "bool(const Function&, const Function &)", where the |
| // first parameter is the reference to the caller and the second parameter is |
| // the reference to the callee. It must return false if the attributes of the |
| // caller and callee are incompatible, and true otherwise. |
| string CompatFunc = F; |
| } |
| |
| def : CompatRule<"isEqual<SanitizeAddressAttr>">; |
| def : CompatRule<"isEqual<SanitizeThreadAttr>">; |
| def : CompatRule<"isEqual<SanitizeMemoryAttr>">; |
| def : CompatRule<"isEqual<SanitizeHWAddressAttr>">; |
| def : CompatRule<"isEqual<SanitizeMemTagAttr>">; |
| def : CompatRule<"isEqual<SafeStackAttr>">; |
| def : CompatRule<"isEqual<ShadowCallStackAttr>">; |
| def : CompatRule<"isEqual<UseSampleProfileAttr>">; |
| |
| class MergeRule<string F> { |
| // The name of the function called to merge the attributes of the caller and |
| // callee. The function's signature must match |
| // "void(Function&, const Function &)", where the first parameter is the |
| // reference to the caller and the second parameter is the reference to the |
| // callee. |
| string MergeFunc = F; |
| } |
| |
| def : MergeRule<"setAND<LessPreciseFPMADAttr>">; |
| def : MergeRule<"setAND<NoInfsFPMathAttr>">; |
| def : MergeRule<"setAND<NoNansFPMathAttr>">; |
| def : MergeRule<"setAND<NoSignedZerosFPMathAttr>">; |
| def : MergeRule<"setAND<UnsafeFPMathAttr>">; |
| def : MergeRule<"setOR<NoImplicitFloatAttr>">; |
| def : MergeRule<"setOR<NoJumpTablesAttr>">; |
| def : MergeRule<"setOR<ProfileSampleAccurateAttr>">; |
| def : MergeRule<"setOR<SpeculativeLoadHardeningAttr>">; |
| def : MergeRule<"adjustCallerSSPLevel">; |
| def : MergeRule<"adjustCallerStackProbes">; |
| def : MergeRule<"adjustCallerStackProbeSize">; |
| def : MergeRule<"adjustMinLegalVectorWidth">; |
| def : MergeRule<"adjustNullPointerValidAttr">; |
| def : MergeRule<"setAND<MustProgressAttr>">; |