316 lines
9.9 KiB
TableGen
316 lines
9.9 KiB
TableGen
//===- 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 should be instrumented.
|
|
def NoProfile : EnumAttr<"noprofile">;
|
|
|
|
/// 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>">;
|