[#llvm-TargetLoweringBase]
= xref:llvm.adoc[llvm]::TargetLoweringBase
:relfileprefix: ../
:mrdocs:

This base class for TargetLowering contains the SelectionDAG‐independent parts that can be used from the rest of CodeGen.

== Synopsis

Declared in `<llvm/CodeGen/TargetLowering.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class TargetLoweringBase;
----

== Types

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/AddrMode.adoc[`AddrMode`] 
| Describes a target addressing mode of base, offset, register, and scale components.
| xref:llvm/TargetLoweringBase/ArgListEntry.adoc[`ArgListEntry`] 
| Describes a single call argument, including its value, type, and ABI attribute flags.
| xref:llvm/TargetLoweringBase/CondMergingParams.adoc[`CondMergingParams`] 
| Holds cost parameters that control whether two merged branch conditions should be split.
| xref:llvm/TargetLoweringBase/IntrinsicInfo.adoc[`IntrinsicInfo`] 
| Holds memory‐access information describing how a target intrinsic touches memory.
| xref:llvm/TargetLoweringBase/ValueTypeActionImpl.adoc[`ValueTypeActionImpl`] 
| Tracks the legalize‐type action to use for each value type.
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/ArgListTy.adoc[`ArgListTy`] 
| A list of call arguments.
| xref:llvm/TargetLoweringBase/LegalizeKind.adoc[`LegalizeKind`] 
| LegalizeKind holds the legalization kind that needs to happen to EVT in order to type‐legalize it.
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/AndOrSETCCFoldKind.adoc[`AndOrSETCCFoldKind`] 
| Enum of different potentially desirable ways to fold (and/or (setcc ...), (setcc ...)).
| xref:llvm/TargetLoweringBase/AtomicExpansionKind.adoc[`AtomicExpansionKind`] 
| Specifies how an atomic instruction should be expanded, if at all.
| xref:llvm/TargetLoweringBase/BooleanContent.adoc[`BooleanContent`] 
| Enum that describes how the target represents true/false values.
| xref:llvm/TargetLoweringBase/ExtractSubvectorCost.adoc[`ExtractSubvectorCost`] 
| Enum that specifies how expensive lowering an EXTRACT_SUBVECTOR is.
| xref:llvm/TargetLoweringBase/LegalizeAction.adoc[`LegalizeAction`] 
| This enum indicates whether operations are valid for a target, and if not, what action should be used to make them valid.
| xref:llvm/TargetLoweringBase/LegalizeTypeAction.adoc[`LegalizeTypeAction`] 
| This enum indicates whether a types are legal for a target, and if not, what action should be used to make them valid.
| xref:llvm/TargetLoweringBase/MulExpansionKind.adoc[`MulExpansionKind`] 
| Enum that specifies when a multiplication should be expanded.
| xref:llvm/TargetLoweringBase/NegatibleCost.adoc[`NegatibleCost`] 
| Enum that specifies when a float negation is beneficial.
| xref:llvm/TargetLoweringBase/ReciprocalEstimate.adoc[`ReciprocalEstimate`] 
| Reciprocal estimate status values used by the functions below.
| xref:llvm/TargetLoweringBase/SelectSupportKind.adoc[`SelectSupportKind`] 
| Enum that describes what type of support for selects the target has.
| xref:llvm/TargetLoweringBase/ShiftLegalizationStrategy.adoc[`ShiftLegalizationStrategy`] 
| Return the preferred strategy to legalize tihs SHIFT instruction, with `ExpansionFactor` being the recursion depth ‐ how many expansion needed.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/2constructor-08.adoc[`TargetLoweringBase`]         [.small]#[constructor]#
| Constructors
| xref:llvm/TargetLoweringBase/2destructor.adoc[`~TargetLoweringBase`] [.small]#[destructor]# [.small]#[virtual]#
| Virtual destructor.
| xref:llvm/TargetLoweringBase/operator_assign.adoc[`operator=`]  [.small]#[deleted]#
| Deleted copy‐assignment operator.
| xref:llvm/TargetLoweringBase/EmitKCFICheck.adoc[`EmitKCFICheck`]  [.small]#[virtual]#
| Emit a KCFI type‐check instruction before an indirect call.
| xref:llvm/TargetLoweringBase/InstructionOpcodeToISD.adoc[`InstructionOpcodeToISD`] 
| Get the ISD node that corresponds to the Instruction class opcode.
| xref:llvm/TargetLoweringBase/IntrinsicIDToISD.adoc[`IntrinsicIDToISD`] 
| Get the ISD node that corresponds to the Intrinsic ID. Returns ISD::DELETED_NODE by default for an unsupported Intrinsic ID.
| xref:llvm/TargetLoweringBase/ShouldShrinkFPConstant.adoc[`ShouldShrinkFPConstant`]  [.small]#[virtual]#
| Return true if the FP constant of the given type should be shrunk to a smaller type.
| xref:llvm/TargetLoweringBase/addressingModeSupportsTLS.adoc[`addressingModeSupportsTLS`]  [.small]#[virtual]#
| Returns true if the targets addressing mode can target thread local storage (TLS).
| xref:llvm/TargetLoweringBase/aggressivelyPreferBuildVectorSources.adoc[`aggressivelyPreferBuildVectorSources`]  [.small]#[virtual]#
| Return true if it is profitable to use a scalar input to a BUILD_VECTOR even with multiple uses.
| xref:llvm/TargetLoweringBase/alignLoopsWithOptSize.adoc[`alignLoopsWithOptSize`]  [.small]#[virtual]#
| Should loops be aligned even when the function is marked OptSize (but not MinSize).
| xref:llvm/TargetLoweringBase/allowTruncateForTailCall.adoc[`allowTruncateForTailCall`]  [.small]#[virtual]#
| Return true if truncating from FromTy to ToTy is permitted for a tail call.
| xref:llvm/TargetLoweringBase/allowsMemoryAccess-0e.adoc[`allowsMemoryAccess`] 
| Return true if the target supports a memory access of the given type, address space, and alignment.
| xref:llvm/TargetLoweringBase/allowsMemoryAccessForAlignment-03.adoc[`allowsMemoryAccessForAlignment`] 
| Return true if the memory access is aligned or the target allows the given unaligned access.
| xref:llvm/TargetLoweringBase/allowsMisalignedMemoryAccesses-06.adoc[`allowsMisalignedMemoryAccesses`] 
| `allowsMisalignedMemoryAccesses` overloads
| xref:llvm/TargetLoweringBase/areJTsAllowed.adoc[`areJTsAllowed`]  [.small]#[virtual]#
| Return true if lowering to a jump table is allowed.
| xref:llvm/TargetLoweringBase/areTwoSDNodeTargetMMOFlagsMergeable.adoc[`areTwoSDNodeTargetMMOFlagsMergeable`]  [.small]#[virtual]#
| Return true if it is valid to merge the TargetMMOFlags in two SDNodes.
| xref:llvm/TargetLoweringBase/atomicOperationOrderAfterFenceSplit.adoc[`atomicOperationOrderAfterFenceSplit`]  [.small]#[virtual]#
| Return the memory ordering to assign to an atomic instruction after AtomicExpandPass splits out its fences.
| xref:llvm/TargetLoweringBase/canCombineStoreAndExtract.adoc[`canCombineStoreAndExtract`]  [.small]#[virtual]#
| Return true if the target can combine store(extractelement VectorTy, Idx). `Cost[out]` gives the cost of that transformation when this is true.
| xref:llvm/TargetLoweringBase/canCombineTruncStore.adoc[`canCombineTruncStore`]  [.small]#[virtual]#
| Return true if a truncating store of the given types can be combined, optionally requiring it to be legal.
| xref:llvm/TargetLoweringBase/canMergeStoresTo.adoc[`canMergeStoresTo`]  [.small]#[virtual]#
| Returns if it's reasonable to merge stores to MemVT size.
| xref:llvm/TargetLoweringBase/canOpTrap.adoc[`canOpTrap`]  [.small]#[virtual]#
| Returns true if the operation can trap for the value type.
| xref:llvm/TargetLoweringBase/canTransformPtrArithOutOfBounds.adoc[`canTransformPtrArithOutOfBounds`]  [.small]#[virtual]#
| True if the target allows transformations of in‐bounds pointer arithmetic that cause out‐of‐bounds intermediate results.
| xref:llvm/TargetLoweringBase/convertSelectOfConstantsToMath.adoc[`convertSelectOfConstantsToMath`]  [.small]#[virtual]#
| Return true if a select between two constants should be converted into simple arithmetic on the condition.
| xref:llvm/TargetLoweringBase/convertSetCCLogicToBitwiseLogic.adoc[`convertSetCCLogicToBitwiseLogic`]  [.small]#[virtual]#
| Return true if pairs of comparisons should be combined using bitwise logic instead of logical ops.
| xref:llvm/TargetLoweringBase/createComplexDeinterleavingIR.adoc[`createComplexDeinterleavingIR`]  [.small]#[virtual]#
| Create the IR node for the given complex deinterleaving operation. If one cannot be created using all the given inputs, nullptr should be returned.
| xref:llvm/TargetLoweringBase/decomposeMulByConstant.adoc[`decomposeMulByConstant`]  [.small]#[virtual]#
| Return true if multiplying by this constant should be decomposed into shifts and adds.
| xref:llvm/TargetLoweringBase/emitAtomicCmpXchgNoStoreLLBalance.adoc[`emitAtomicCmpXchgNoStoreLLBalance`]  [.small]#[virtual]#
| Emit balancing code for the load‐linked when the store‐conditional of a cmpxchg will not execute.
| xref:llvm/TargetLoweringBase/emitBitTestAtomicRMWIntrinsic.adoc[`emitBitTestAtomicRMWIntrinsic`]  [.small]#[virtual]#
| Expand an atomicrmw into a target‐specific bit‐test intrinsic.
| xref:llvm/TargetLoweringBase/emitCmpArithAtomicRMWIntrinsic.adoc[`emitCmpArithAtomicRMWIntrinsic`]  [.small]#[virtual]#
| Expand an atomicrmw whose result is only compared into a target‐specific compare‐and‐arith intrinsic.
| xref:llvm/TargetLoweringBase/emitExpandAtomicCmpXchg.adoc[`emitExpandAtomicCmpXchg`]  [.small]#[virtual]#
| Perform a cmpxchg expansion using a target‐specific method.
| xref:llvm/TargetLoweringBase/emitExpandAtomicLoad.adoc[`emitExpandAtomicLoad`]  [.small]#[virtual]#
| Perform a atomic load using a target‐specific way.
| xref:llvm/TargetLoweringBase/emitExpandAtomicRMW.adoc[`emitExpandAtomicRMW`]  [.small]#[virtual]#
| Expand an atomicrmw instruction using a target‐specific lowering.
| xref:llvm/TargetLoweringBase/emitExpandAtomicStore.adoc[`emitExpandAtomicStore`]  [.small]#[virtual]#
| Perform a atomic store using a target‐specific way.
| xref:llvm/TargetLoweringBase/emitLeadingFence.adoc[`emitLeadingFence`]  [.small]#[virtual]#
| Insert a fence before an atomic instruction, as needed for the target's memory model.
| xref:llvm/TargetLoweringBase/emitLoadLinked.adoc[`emitLoadLinked`]  [.small]#[virtual]#
| Emit a load‐linked operation on the given address for an ll/sc atomic sequence.
| xref:llvm/TargetLoweringBase/emitMaskedAtomicCmpXchgIntrinsic.adoc[`emitMaskedAtomicCmpXchgIntrinsic`]  [.small]#[virtual]#
| Expand a masked cmpxchg into a target‐specific ll/sc intrinsic.
| xref:llvm/TargetLoweringBase/emitMaskedAtomicRMWIntrinsic.adoc[`emitMaskedAtomicRMWIntrinsic`]  [.small]#[virtual]#
| Expand a masked atomicrmw into a target‐specific ll/sc intrinsic.
| xref:llvm/TargetLoweringBase/emitStoreConditional.adoc[`emitStoreConditional`]  [.small]#[virtual]#
| Perform a store‐conditional operation to Addr. Return the status of the store. This should be 0 if the store succeeded, non‐zero otherwise.
| xref:llvm/TargetLoweringBase/emitTrailingFence.adoc[`emitTrailingFence`]  [.small]#[virtual]#
| Emit a trailing fence after expanding an atomic operation.
| xref:llvm/TargetLoweringBase/enableAggressiveFMAFusion-05.adoc[`enableAggressiveFMAFusion`] 
| Return true if the target always benefits from fusing multiply‐add into FMA for this type.
| xref:llvm/TargetLoweringBase/enableExtLdPromotion-025.adoc[`enableExtLdPromotion`] 
| Return true if extending loads should be promoted through chains of promotable instructions.
| xref:llvm/TargetLoweringBase/fallBackToDAGISel.adoc[`fallBackToDAGISel`]  [.small]#[virtual]#
| Return true if GlobalISel should fall back to SelectionDAG ISel for the given instruction.
| xref:llvm/TargetLoweringBase/finalizeLowering.adoc[`finalizeLowering`]  [.small]#[virtual]#
| Perform target‐specific finalization after instruction selection, such as freezing reserved registers.
| xref:llvm/TargetLoweringBase/generateFMAsInMachineCombiner.adoc[`generateFMAsInMachineCombiner`]  [.small]#[virtual]#
| Return true if forming FMAs should be delegated to the machine combiner instead of done during selection.
| xref:llvm/TargetLoweringBase/getABIAlignmentForCallingConv.adoc[`getABIAlignmentForCallingConv`]  [.small]#[virtual]#
| Certain targets have context sensitive alignment requirements, where one type has the alignment requirement of another type.
| xref:llvm/TargetLoweringBase/getAddrModeArguments.adoc[`getAddrModeArguments`]  [.small]#[virtual]#
| Return the address operands of an intrinsic that should be sunk into the address mode.
| xref:llvm/TargetLoweringBase/getAsmOperandValueType.adoc[`getAsmOperandValueType`]  [.small]#[virtual]#
| Return the EVT to use for an inline asm operand of the given IR type.
| xref:llvm/TargetLoweringBase/getAtomicMemOperandFlags.adoc[`getAtomicMemOperandFlags`] 
| Return the MachineMemOperand flags to use for the given atomic instruction.
| xref:llvm/TargetLoweringBase/getBitWidthForCttzElements.adoc[`getBitWidthForCttzElements`] 
| Return the minimum number of bits required to hold the maximum possible number of trailing zero vector elements.
| xref:llvm/TargetLoweringBase/getBooleanContents-07.adoc[`getBooleanContents`] 
| `getBooleanContents` overloads
| xref:llvm/TargetLoweringBase/getByValTypeAlignment.adoc[`getByValTypeAlignment`]  [.small]#[virtual]#
| Returns the desired alignment for ByVal or InAlloca aggregate function arguments in the caller parameter area.
| xref:llvm/TargetLoweringBase/getBypassSlowDivWidths.adoc[`getBypassSlowDivWidths`] 
| Returns map of slow types for division or remainder with corresponding fast types
| xref:llvm/TargetLoweringBase/getCmpLibcallReturnType.adoc[`getCmpLibcallReturnType`]  [.small]#[virtual]#
| Return the value type used for floating‐point comparison libcalls.
| xref:llvm/TargetLoweringBase/getCondCodeAction.adoc[`getCondCodeAction`] 
| Return how the given condition code should be treated for comparisons of the given type.
| xref:llvm/TargetLoweringBase/getCustomCtpopCost.adoc[`getCustomCtpopCost`]  [.small]#[virtual]#
| Return the maximum number of "x & (x ‐ 1)" operations that can be done instead of deferring to a custom CTPOP.
| xref:llvm/TargetLoweringBase/getCustomLoadAction.adoc[`getCustomLoadAction`]  [.small]#[virtual]#
| Return the custom action to use for a load when the coarse lookup yields Custom.
| xref:llvm/TargetLoweringBase/getCustomOperationAction.adoc[`getCustomOperationAction`]  [.small]#[virtual]#
| How to legalize this custom operation?
| xref:llvm/TargetLoweringBase/getCustomTruncStoreAction.adoc[`getCustomTruncStoreAction`]  [.small]#[virtual]#
| Return the custom action to use for a truncating store when the coarse lookup yields Custom.
| xref:llvm/TargetLoweringBase/getDivRefinementSteps.adoc[`getDivRefinementSteps`] 
| Return the number of Newton‐Raphson refinement steps for a reciprocal division estimate.
| xref:llvm/TargetLoweringBase/getExceptionPointerRegister.adoc[`getExceptionPointerRegister`]  [.small]#[virtual]#
| If a physical register, this returns the register that receives the exception address on entry to an EH pad.
| xref:llvm/TargetLoweringBase/getExceptionSelectorRegister.adoc[`getExceptionSelectorRegister`]  [.small]#[virtual]#
| If a physical register, this returns the register that receives the exception typeid on entry to a landing pad.
| xref:llvm/TargetLoweringBase/getExtendForAtomicCmpSwapArg.adoc[`getExtendForAtomicCmpSwapArg`]  [.small]#[virtual]#
| Return how the comparison operand of an atomic compare‐and‐swap should be extended.
| xref:llvm/TargetLoweringBase/getExtendForAtomicOps.adoc[`getExtendForAtomicOps`]  [.small]#[virtual]#
| Returns how the platform's atomic operations are extended (ZERO_EXTEND, SIGN_EXTEND, or ANY_EXTEND).
| xref:llvm/TargetLoweringBase/getExtendForAtomicRMWArg.adoc[`getExtendForAtomicRMWArg`]  [.small]#[virtual]#
| Returns how the platform's atomic rmw operations expect their input argument to be extended (ZERO_EXTEND, SIGN_EXTEND, or ANY_EXTEND).
| xref:llvm/TargetLoweringBase/getExtractSubvectorCost.adoc[`getExtractSubvectorCost`]  [.small]#[virtual]#
| Return the cost of extracting a subvector of type `ResVT` from a vector of type `SrcVT,` starting at element `Index.`
| xref:llvm/TargetLoweringBase/getFenceOperandTy.adoc[`getFenceOperandTy`]  [.small]#[virtual]#
| Return the type for operands of fence. TODO: Let fence operands be of i32 type and remove this.
| xref:llvm/TargetLoweringBase/getFixedPointOperationAction.adoc[`getFixedPointOperationAction`] 
| Return how a fixed‐point operation with the given scale should be treated by the target.
| xref:llvm/TargetLoweringBase/getFrameIndexTy.adoc[`getFrameIndexTy`] 
| Return the type for frame index, which is determined by the alloca address space specified through the data layout.
| xref:llvm/TargetLoweringBase/getGatherAllAliasesMaxDepth.adoc[`getGatherAllAliasesMaxDepth`] 
| Return the maximum alias‐chain search depth used by GatherAllAliases.
| xref:llvm/TargetLoweringBase/getIRStackGuard.adoc[`getIRStackGuard`]  [.small]#[virtual]#
| Return the address of the target's standard stack protector guard, or nullptr if none.
| xref:llvm/TargetLoweringBase/getIndexedLoadAction.adoc[`getIndexedLoadAction`] 
| Return how the given indexed load addressing mode should be treated for the given type.
| xref:llvm/TargetLoweringBase/getIndexedMaskedLoadAction.adoc[`getIndexedMaskedLoadAction`] 
| Return how the given indexed masked load addressing mode should be treated for the given type.
| xref:llvm/TargetLoweringBase/getIndexedMaskedStoreAction.adoc[`getIndexedMaskedStoreAction`] 
| Return how the given indexed masked store addressing mode should be treated for the given type.
| xref:llvm/TargetLoweringBase/getIndexedStoreAction.adoc[`getIndexedStoreAction`] 
| Return how the given indexed store addressing mode should be treated for the given type.
| xref:llvm/TargetLoweringBase/getJumpConditionMergingParams.adoc[`getJumpConditionMergingParams`]  [.small]#[virtual]#
| Return the cost parameters used to decide whether to keep two branch conditions merged.
| xref:llvm/TargetLoweringBase/getLegalTypeToTransformTo.adoc[`getLegalTypeToTransformTo`] 
| Perform getTypeToTransformTo repeatedly until a legal type is obtained. Useful for vector operations that might take multiple steps to legalize.
| xref:llvm/TargetLoweringBase/getLibcallCallingConv.adoc[`getLibcallCallingConv`] 
| Get the CallingConv that should be used for the specified libcall. Return the libcall Calling Conv.
| xref:llvm/TargetLoweringBase/getLibcallImpl.adoc[`getLibcallImpl`] 
| Get the libcall impl routine name for the specified libcall.
| xref:llvm/TargetLoweringBase/getLibcallImplCallingConv.adoc[`getLibcallImplCallingConv`] 
| Get the CallingConv that should be used for the specified libcall implementation.
| xref:llvm/TargetLoweringBase/getLibcallLoweringInfo.adoc[`getLibcallLoweringInfo`] 
| Return the libcall lowering info for this target.
| xref:llvm/TargetLoweringBase/getLibcallName.adoc[`getLibcallName`] 
| Return the libcall routine name for the specified libcall.
| xref:llvm/TargetLoweringBase/getLoadAction.adoc[`getLoadAction`] 
| Return how a load with the given extension type should be treated for the given types.
| xref:llvm/TargetLoweringBase/getLoadMemOperandFlags.adoc[`getLoadMemOperandFlags`] 
| Return the MachineMemOperand flags to use for the given load instruction.
| xref:llvm/TargetLoweringBase/getMaxAtomicSizeInBitsSupported.adoc[`getMaxAtomicSizeInBitsSupported`] 
| Return the maximum atomic operation size in bits supported by the backend.
| xref:llvm/TargetLoweringBase/getMaxDivRemBitWidthSupported.adoc[`getMaxDivRemBitWidthSupported`] 
| Returns the size in bits of the maximum div/rem the backend supports. Larger operations will be expanded by ExpandIRInsts.
| xref:llvm/TargetLoweringBase/getMaxExpandSizeMemcmp.adoc[`getMaxExpandSizeMemcmp`] 
| Get maximum # of load operations permitted for memcmp
| xref:llvm/TargetLoweringBase/getMaxGluedStoresPerMemcpy.adoc[`getMaxGluedStoresPerMemcpy`]  [.small]#[virtual]#
| Get maximum # of store operations to be glued together
| xref:llvm/TargetLoweringBase/getMaxLargeFPConvertBitWidthSupported.adoc[`getMaxLargeFPConvertBitWidthSupported`] 
| Returns the size in bits of the maximum fp to/from int conversion the backend supports. Larger operations will be expanded by ExpandIRInsts.
| xref:llvm/TargetLoweringBase/getMaxPermittedBytesForAlignment.adoc[`getMaxPermittedBytesForAlignment`]  [.small]#[virtual]#
| Return the maximum amount of bytes allowed to be emitted when padding for alignment
| xref:llvm/TargetLoweringBase/getMaxStoresPerMemcpy.adoc[`getMaxStoresPerMemcpy`] 
| Get maximum # of store operations permitted for llvm.memcpy
| xref:llvm/TargetLoweringBase/getMaxStoresPerMemmove.adoc[`getMaxStoresPerMemmove`] 
| Get maximum # of store operations permitted for llvm.memmove
| xref:llvm/TargetLoweringBase/getMaxStoresPerMemset.adoc[`getMaxStoresPerMemset`] 
| Get maximum # of store operations permitted for llvm.memset
| xref:llvm/TargetLoweringBase/getMaxSupportedInterleaveFactor.adoc[`getMaxSupportedInterleaveFactor`]  [.small]#[virtual]#
| Get the maximum supported factor for interleaved memory accesses. Default to be the minimum interleave factor: 2.
| xref:llvm/TargetLoweringBase/getMaximumJumpTableSize.adoc[`getMaximumJumpTableSize`] 
| Return upper limit for number of entries in a jump table. Zero if no limit.
| xref:llvm/TargetLoweringBase/getMaximumLegalStoreInBits.adoc[`getMaximumLegalStoreInBits`] 
| Return maximum known‐legal store size, which can be guaranteed for scalable vectors.
| xref:llvm/TargetLoweringBase/getMemValueType.adoc[`getMemValueType`] 
| Return the in‐memory EVT corresponding to the given LLVM IR type.
| xref:llvm/TargetLoweringBase/getMemcpyImpl.adoc[`getMemcpyImpl`] 
| Return the libcall implementation to use for memcpy.
| xref:llvm/TargetLoweringBase/getMinCmpXchgSizeInBits.adoc[`getMinCmpXchgSizeInBits`] 
| Returns the size of the smallest cmpxchg or ll/sc instruction the backend supports. Any smaller operations are widened in AtomicExpandPass.
| xref:llvm/TargetLoweringBase/getMinFunctionAlignment.adoc[`getMinFunctionAlignment`] 
| Return the minimum function alignment.
| xref:llvm/TargetLoweringBase/getMinStackArgumentAlignment.adoc[`getMinStackArgumentAlignment`] 
| Return the minimum stack alignment of an argument.
| xref:llvm/TargetLoweringBase/getMinimumBitTestCmps.adoc[`getMinimumBitTestCmps`] 
| Retuen the minimum of largest number of comparisons in BitTest.
| xref:llvm/TargetLoweringBase/getMinimumJumpTableDensity.adoc[`getMinimumJumpTableDensity`] 
| Return lower limit of the density in a jump table.
| xref:llvm/TargetLoweringBase/getMinimumJumpTableEntries.adoc[`getMinimumJumpTableEntries`]  [.small]#[virtual]#
| Return lower limit for number of blocks in a jump table.
| xref:llvm/TargetLoweringBase/getNumRegisters.adoc[`getNumRegisters`]  [.small]#[virtual]#
| Return the number of registers that this ValueType will eventually require.
| xref:llvm/TargetLoweringBase/getNumRegistersForCallingConv.adoc[`getNumRegistersForCallingConv`]  [.small]#[virtual]#
| Return the number of registers needed to pass a value of this type under the given calling convention.
| xref:llvm/TargetLoweringBase/getOperationAction.adoc[`getOperationAction`] 
| Return how the given operation should be treated for the given value type.
| xref:llvm/TargetLoweringBase/getOptimalMemOpLLT.adoc[`getOptimalMemOpLLT`]  [.small]#[virtual]#
| Return the optimal LLT for load/store operations when lowering mem* ops.
| xref:llvm/TargetLoweringBase/getOptimalMemOpType.adoc[`getOptimalMemOpType`]  [.small]#[virtual]#
| Return the optimal type to use for load/store operations when lowering memset, memcpy, or memmove.
| xref:llvm/TargetLoweringBase/getPartialReduceMLAAction.adoc[`getPartialReduceMLAAction`] 
| Return how a partial‐reduce multiply‐accumulate node with the given accumulator and input types should be treated.
| xref:llvm/TargetLoweringBase/getPointerMemTy.adoc[`getPointerMemTy`]  [.small]#[virtual]#
| Return the in‐memory pointer type for the given address space.
| xref:llvm/TargetLoweringBase/getPointerTy.adoc[`getPointerTy`]  [.small]#[virtual]#
| Return the pointer type for the given address space.
| xref:llvm/TargetLoweringBase/getPrefFunctionAlignment.adoc[`getPrefFunctionAlignment`] 
| Return the preferred function alignment.
| xref:llvm/TargetLoweringBase/getPrefLoopAlignment.adoc[`getPrefLoopAlignment`]  [.small]#[virtual]#
| Return the preferred loop alignment.
| xref:llvm/TargetLoweringBase/getPreferredFPToIntOpcode.adoc[`getPreferredFPToIntOpcode`]  [.small]#[virtual]#
| Return the preferred FP‐to‐integer conversion opcode to use as a replacement for an illegal one.
| xref:llvm/TargetLoweringBase/getPreferredLargeGEPBaseOffset.adoc[`getPreferredLargeGEPBaseOffset`]  [.small]#[virtual]#
| Return the prefered common base offset.
| xref:llvm/TargetLoweringBase/getPreferredShiftAmountTy.adoc[`getPreferredShiftAmountTy`]  [.small]#[virtual]#
| Return the preferred type to use for a shift opcode, given the shifted amount type is `ShiftValueTy.`
| xref:llvm/TargetLoweringBase/getPreferredSwitchConditionType.adoc[`getPreferredSwitchConditionType`]  [.small]#[virtual]#
| Returns preferred type for switch condition.
| xref:llvm/TargetLoweringBase/getPreferredVectorAction.adoc[`getPreferredVectorAction`]  [.small]#[virtual]#
| Return the preferred vector type legalization action.
| xref:llvm/TargetLoweringBase/getProgramPointerTy.adoc[`getProgramPointerTy`] 
| Return the type for code pointers, which is determined by the program address space specified through the data layout.
| xref:llvm/TargetLoweringBase/getRecipEstimateDivEnabled.adoc[`getRecipEstimateDivEnabled`] 
| Return whether reciprocal division estimation is enabled for the given type.
| xref:llvm/TargetLoweringBase/getRecipEstimateSqrtEnabled.adoc[`getRecipEstimateSqrtEnabled`] 
| Return whether reciprocal square‐root estimation is enabled for the given type.
| xref:llvm/TargetLoweringBase/getRegClassFor.adoc[`getRegClassFor`]  [.small]#[virtual]#
| Return the register class that should be used for the specified value type.
| xref:llvm/TargetLoweringBase/getRegisterType.adoc[`getRegisterType`] 
| Return the type of registers that this ValueType will eventually require.
| xref:llvm/TargetLoweringBase/getRegisterTypeForCallingConv.adoc[`getRegisterTypeForCallingConv`]  [.small]#[virtual]#
| Return the register type to use for a value of this type under the given calling convention.
| xref:llvm/TargetLoweringBase/getRepRegClassCostFor.adoc[`getRepRegClassCostFor`]  [.small]#[virtual]#
| Return the cost of the 'representative' register class for the specified value type.
| xref:llvm/TargetLoweringBase/getRepRegClassFor.adoc[`getRepRegClassFor`]  [.small]#[virtual]#
| Return the 'representative' register class for the specified value type.
| xref:llvm/TargetLoweringBase/getRuntimeLibcallsInfo.adoc[`getRuntimeLibcallsInfo`] 
| Return the runtime libcalls info for this target.
| xref:llvm/TargetLoweringBase/getSDagStackGuard.adoc[`getSDagStackGuard`]  [.small]#[virtual]#
| Return the stack guard variable previously inserted by insertSSPDeclarations.
| xref:llvm/TargetLoweringBase/getSSPStackGuardCheck.adoc[`getSSPStackGuardCheck`] 
| Return the target's stack protector check function, if previously inserted.
| xref:llvm/TargetLoweringBase/getSafeStackPointerLocation.adoc[`getSafeStackPointerLocation`]  [.small]#[virtual]#
| Returns the target‐specific address of the unsafe stack pointer.
| xref:llvm/TargetLoweringBase/getScalarShiftAmountTy.adoc[`getScalarShiftAmountTy`]  [.small]#[virtual]#
| Return the type to use for the amount operand of a scalar shift operation.
| xref:llvm/TargetLoweringBase/getSchedulingPreference-0e.adoc[`getSchedulingPreference`] 
| Return the target's preferred scheduling heuristic, optionally specialized for a given node.
| xref:llvm/TargetLoweringBase/getSetCCResultType.adoc[`getSetCCResultType`]  [.small]#[virtual]#
| Return the ValueType of the result of SETCC operations.
| xref:llvm/TargetLoweringBase/getShiftAmountTy.adoc[`getShiftAmountTy`] 
| Return the type to use for the shift amount operand of a shift opcode.
| xref:llvm/TargetLoweringBase/getSimpleValueType.adoc[`getSimpleValueType`] 
| Return the MVT corresponding to this LLVM type. See getValueType.
| xref:llvm/TargetLoweringBase/getSqrtRefinementSteps.adoc[`getSqrtRefinementSteps`] 
| Return the number of Newton‐Raphson refinement steps for a square‐root estimate.
| xref:llvm/TargetLoweringBase/getStackPointerRegisterToSaveRestore.adoc[`getStackPointerRegisterToSaveRestore`] 
| If a physical register, this specifies the register that llvm.savestack/llvm.restorestack should save and restore.
| xref:llvm/TargetLoweringBase/getStackProbeSymbolName.adoc[`getStackProbeSymbolName`]  [.small]#[virtual]#
| Return the name of the symbol used to emit stack probes, or empty if not applicable.
| xref:llvm/TargetLoweringBase/getStoreMemOperandFlags.adoc[`getStoreMemOperandFlags`] 
| Return the MachineMemOperand flags to use for the given store instruction.
| xref:llvm/TargetLoweringBase/getStrictFPOperationAction.adoc[`getStrictFPOperationAction`] 
| Return the legalization action for a strict floating‐point operation using its non‐strict equivalent.
| xref:llvm/TargetLoweringBase/getSupportedLibcallImpl.adoc[`getSupportedLibcallImpl`] 
| Check if this is valid libcall for the current module, otherwise RTLIB::Unsupported.
| xref:llvm/TargetLoweringBase/getTargetMMOFlags-0c.adoc[`getTargetMMOFlags`] 
| `getTargetMMOFlags` overloads
| xref:llvm/TargetLoweringBase/getTargetMachine.adoc[`getTargetMachine`] 
| Return the target machine associated with this lowering.
| xref:llvm/TargetLoweringBase/getTgtMemIntrinsic.adoc[`getTgtMemIntrinsic`]  [.small]#[virtual]#
| Return the memory‐access information for an intrinsic that touches memory, if any.
| xref:llvm/TargetLoweringBase/getTruncStoreAction.adoc[`getTruncStoreAction`] 
| Return how a truncating store should be treated for the given value and memory types.
| xref:llvm/TargetLoweringBase/getTypeAction-03.adoc[`getTypeAction`] 
| Return how values of this type should be legalized: as legal, promoted, or expanded.
| xref:llvm/TargetLoweringBase/getTypeConversion.adoc[`getTypeConversion`] 
| Return pair that represents the legalization kind (first) that needs to happen to EVT (second) in order to type‐legalize it.
| xref:llvm/TargetLoweringBase/getTypeToExpandTo.adoc[`getTypeToExpandTo`] 
| Return the largest legal type that this type will be expanded to.
| xref:llvm/TargetLoweringBase/getTypeToPromoteTo.adoc[`getTypeToPromoteTo`] 
| If the action for this operation is to promote, this method returns the ValueType to promote to.
| xref:llvm/TargetLoweringBase/getTypeToTransformTo.adoc[`getTypeToTransformTo`]  [.small]#[virtual]#
| Return the type that this type is promoted, expanded, or otherwise transformed to.
| xref:llvm/TargetLoweringBase/getVPExplicitVectorLengthTy.adoc[`getVPExplicitVectorLengthTy`]  [.small]#[virtual]#
| Return the type to use for the explicit vector length operand of VP nodes.
| xref:llvm/TargetLoweringBase/getVPIntrinsicMemOperandFlags.adoc[`getVPIntrinsicMemOperandFlags`] 
| Return the MachineMemOperand flags to use for the given vector‐predicated intrinsic.
| xref:llvm/TargetLoweringBase/getVaListSizeInBits.adoc[`getVaListSizeInBits`]  [.small]#[virtual]#
| Returns the size of the platform's va_list object.
| xref:llvm/TargetLoweringBase/getValueType.adoc[`getValueType`] 
| Return the EVT corresponding to the given LLVM IR type.
| xref:llvm/TargetLoweringBase/getValueTypeActions.adoc[`getValueTypeActions`] 
| Return the table of per‐EVT legalization actions.
| xref:llvm/TargetLoweringBase/getVectorIdxLLT.adoc[`getVectorIdxLLT`] 
| Returns the type to be used for the index operand of: G_INSERT_VECTOR_ELT, G_EXTRACT_VECTOR_ELT, G_INSERT_SUBVECTOR, and G_EXTRACT_SUBVECTOR
| xref:llvm/TargetLoweringBase/getVectorIdxTy.adoc[`getVectorIdxTy`] 
| Returns the type to be used for the index operand of: ISD::INSERT_VECTOR_ELT, ISD::EXTRACT_VECTOR_ELT, ISD::INSERT_SUBVECTOR, and ISD::EXTRACT_SUBVECTOR
| xref:llvm/TargetLoweringBase/getVectorIdxWidth.adoc[`getVectorIdxWidth`]  [.small]#[virtual]#
| Returns the type to be used for the index operand vector operations. By default we assume it will have the same size as an address space 0 pointer.
| xref:llvm/TargetLoweringBase/getVectorTypeBreakdown.adoc[`getVectorTypeBreakdown`] 
| Return the number of registers and intermediate type needed to break a vector type into legal parts.
| xref:llvm/TargetLoweringBase/getVectorTypeBreakdownForCallingConv.adoc[`getVectorTypeBreakdownForCallingConv`]  [.small]#[virtual]#
| Return the register breakdown of a vector type under the given calling convention.
| xref:llvm/TargetLoweringBase/hasAndNot.adoc[`hasAndNot`]  [.small]#[virtual]#
| Return true if the target has a bitwise and‐not operation: X = ~A & B This can be used to simplify select or other instructions.
| xref:llvm/TargetLoweringBase/hasAndNotCompare.adoc[`hasAndNotCompare`]  [.small]#[virtual]#
| Return true if the target should transform: (X & Y) == Y ‐‐‐> (~X & Y) == 0 (X & Y) != Y ‐‐‐> (~X & Y) != 0
| xref:llvm/TargetLoweringBase/hasBigEndianPartOrdering.adoc[`hasBigEndianPartOrdering`] 
| Return true if the high part comes first when splitting a value of this type into parts.
| xref:llvm/TargetLoweringBase/hasBitTest.adoc[`hasBitTest`]  [.small]#[virtual]#
| Return true if the target has a bit‐test instruction for testing a single bit of X selected by Y.
| xref:llvm/TargetLoweringBase/hasExtractBitsInsn-01.adoc[`hasExtractBitsInsn`] 
| Return true if the target has BitExtract instructions.
| xref:llvm/TargetLoweringBase/hasFastEqualityCompare.adoc[`hasFastEqualityCompare`]  [.small]#[virtual]#
| Return the preferred type for an efficient equality comparison of integers with the given bit width.
| xref:llvm/TargetLoweringBase/hasInlineStackProbe.adoc[`hasInlineStackProbe`]  [.small]#[virtual]#
| Return true if the target emits inline stack probes instead of calling a probe function.
| xref:llvm/TargetLoweringBase/hasMultipleConditionRegisters.adoc[`hasMultipleConditionRegisters`]  [.small]#[virtual]#
| Return true if the target has multiple condition registers that can hold comparison results.
| xref:llvm/TargetLoweringBase/hasPairedLoad.adoc[`hasPairedLoad`]  [.small]#[virtual]#
| Return true if the target can combine two adjacent loads into a single paired load.
| xref:llvm/TargetLoweringBase/hasStackProbeSymbol.adoc[`hasStackProbeSymbol`]  [.small]#[virtual]#
| Returns the name of the symbol used to emit stack probes or the empty string if not applicable.
| xref:llvm/TargetLoweringBase/hasStandaloneRem.adoc[`hasStandaloneRem`]  [.small]#[virtual]#
| Return true if the target can handle a standalone remainder operation.
| xref:llvm/TargetLoweringBase/hasTargetDAGCombine.adoc[`hasTargetDAGCombine`] 
| If true, the target has custom DAG combine transformations that it can perform for the specified node.
| xref:llvm/TargetLoweringBase/hasVectorBlend.adoc[`hasVectorBlend`]  [.small]#[virtual]#
| Return true if the target has a vector blend instruction.
| xref:llvm/TargetLoweringBase/insertSSPDeclarations.adoc[`insertSSPDeclarations`]  [.small]#[virtual]#
| Inserts necessary declarations for SSP (stack protection) purpose. Should be used only when getIRStackGuard returns nullptr.
| xref:llvm/TargetLoweringBase/isAnyExtFree.adoc[`isAnyExtFree`]  [.small]#[virtual]#
| Return true is an anyext is free from FromTy to ToTy. Usually true for scalar types when not trying to pack elements into vector lanes.
| xref:llvm/TargetLoweringBase/isBeneficialToExpandPowI.adoc[`isBeneficialToExpandPowI`] 
| Return true if it is beneficial to expand an llvm.powi intrinsic into multiplies.
| xref:llvm/TargetLoweringBase/isBinOp.adoc[`isBinOp`]  [.small]#[virtual]#
| Return true if the node is a math/logic binary operator.
| xref:llvm/TargetLoweringBase/isCheapToSpeculateCtlz.adoc[`isCheapToSpeculateCtlz`]  [.small]#[virtual]#
| Return true if it is cheap to speculate a call to intrinsic ctlz.
| xref:llvm/TargetLoweringBase/isCheapToSpeculateCttz.adoc[`isCheapToSpeculateCttz`]  [.small]#[virtual]#
| Return true if it is cheap to speculate a call to intrinsic cttz.
| xref:llvm/TargetLoweringBase/isCommutativeBinOp.adoc[`isCommutativeBinOp`]  [.small]#[virtual]#
| Returns true if the opcode is a commutative binary operation.
| xref:llvm/TargetLoweringBase/isComplexDeinterleavingOperationSupported.adoc[`isComplexDeinterleavingOperationSupported`]  [.small]#[virtual]#
| Does this target support complex deinterleaving with the given operation and type
| xref:llvm/TargetLoweringBase/isComplexDeinterleavingSupported.adoc[`isComplexDeinterleavingSupported`]  [.small]#[virtual]#
| Does this target support complex deinterleaving
| xref:llvm/TargetLoweringBase/isCondCodeLegal.adoc[`isCondCodeLegal`] 
| Return true if the specified condition code is legal for a comparison of the specified types on this target.
| xref:llvm/TargetLoweringBase/isCondCodeLegalOrCustom.adoc[`isCondCodeLegalOrCustom`] 
| Return true if the specified condition code is legal or custom for a comparison of the specified types on this target.
| xref:llvm/TargetLoweringBase/isCtlzFast.adoc[`isCtlzFast`]  [.small]#[virtual]#
| Return true if ctlz instruction is fast.
| xref:llvm/TargetLoweringBase/isCtpopFast.adoc[`isCtpopFast`]  [.small]#[virtual]#
| Return true if ctpop instruction is fast.
| xref:llvm/TargetLoweringBase/isEqualityCmpFoldedWithSignedCmp.adoc[`isEqualityCmpFoldedWithSignedCmp`]  [.small]#[virtual]#
| Return true if instruction generated for equality comparison is folded with instruction generated for signed comparison.
| xref:llvm/TargetLoweringBase/isExtFree.adoc[`isExtFree`] 
| Return true if the sign, zero, or fp extension represented by this instruction is free.
| xref:llvm/TargetLoweringBase/isExtLoad.adoc[`isExtLoad`] 
| Return true if a load and a subsequent extend can be combined into a single extending load.
| xref:llvm/TargetLoweringBase/isExtractVecEltCheap.adoc[`isExtractVecEltCheap`]  [.small]#[virtual]#
| Return true if extracting a scalar element at the given index from this vector type is cheap.
| xref:llvm/TargetLoweringBase/isFAbsFree.adoc[`isFAbsFree`]  [.small]#[virtual]#
| Return true if an fabs operation is free to the point where it is never worthwhile to replace it with a bitwise operation.
| xref:llvm/TargetLoweringBase/isFMADLegal-05.adoc[`isFMADLegal`] 
| Return true if the operation can be combined with another to form an FMAD node.
| xref:llvm/TargetLoweringBase/isFMAFasterThanFMulAndFAdd-07.adoc[`isFMAFasterThanFMulAndFAdd`] 
| Return true if an FMA is faster than a separate fmul and fadd for this type.
| xref:llvm/TargetLoweringBase/isFNegFree.adoc[`isFNegFree`]  [.small]#[virtual]#
| Return true if an fneg operation is free to the point where it is never worthwhile to replace it with a bitwise operation.
| xref:llvm/TargetLoweringBase/isFPExtFoldable-0d.adoc[`isFPExtFoldable`] 
| Return true if an fpext feeding this opcode can be folded away, as for an FMA instruction.
| xref:llvm/TargetLoweringBase/isFPExtFree.adoc[`isFPExtFree`]  [.small]#[virtual]#
| Return true if an fpext operation is free (for instance, because single‐precision floating‐point numbers are implicitly extended to double‐precision).
| xref:llvm/TargetLoweringBase/isFPImmLegal.adoc[`isFPImmLegal`]  [.small]#[virtual]#
| Return true if the target can natively materialize the given floating‐point immediate.
| xref:llvm/TargetLoweringBase/isFreeAddrSpaceCast.adoc[`isFreeAddrSpaceCast`]  [.small]#[virtual]#
| Return true if casting a pointer from SrcAS to DestAS is free.
| xref:llvm/TargetLoweringBase/isFsqrtCheap.adoc[`isFsqrtCheap`]  [.small]#[virtual]#
| Return true if SQRT(X) shouldn't be replaced with X*RSQRT(X).
| xref:llvm/TargetLoweringBase/isIndexedLoadLegal.adoc[`isIndexedLoadLegal`] 
| Return true if the specified indexed load is legal on this target.
| xref:llvm/TargetLoweringBase/isIndexedMaskedLoadLegal.adoc[`isIndexedMaskedLoadLegal`] 
| Return true if the specified indexed load is legal on this target.
| xref:llvm/TargetLoweringBase/isIndexedMaskedStoreLegal.adoc[`isIndexedMaskedStoreLegal`] 
| Return true if the specified indexed load is legal on this target.
| xref:llvm/TargetLoweringBase/isIndexedStoreLegal.adoc[`isIndexedStoreLegal`] 
| Return true if the specified indexed load is legal on this target.
| xref:llvm/TargetLoweringBase/isIntDivCheap.adoc[`isIntDivCheap`]  [.small]#[virtual]#
| Return true if integer division is cheaper than an equivalent sequence of shifts, adds, and multiplies.
| xref:llvm/TargetLoweringBase/isJumpExpensive.adoc[`isJumpExpensive`] 
| Return true if Flow Control is an expensive operation that should be avoided.
| xref:llvm/TargetLoweringBase/isJumpTableRelative.adoc[`isJumpTableRelative`]  [.small]#[virtual]#
| Return true if jump table entries are relative to the table's address.
| xref:llvm/TargetLoweringBase/isLegalAddImmediate.adoc[`isLegalAddImmediate`]  [.small]#[virtual]#
| Return true if the target can add this immediate to a register without materializing it.
| xref:llvm/TargetLoweringBase/isLegalAddScalableImmediate.adoc[`isLegalAddScalableImmediate`]  [.small]#[virtual]#
| Return true if the target can add this scalable immediate (multiplied by vscale) without materializing it.
| xref:llvm/TargetLoweringBase/isLegalAddressingMode.adoc[`isLegalAddressingMode`]  [.small]#[virtual]#
| Return true if the addressing mode represented by AM is legal for this target, for a load/store of the specified type.
| xref:llvm/TargetLoweringBase/isLegalICmpImmediate.adoc[`isLegalICmpImmediate`]  [.small]#[virtual]#
| Return true if the target can compare a register against this immediate without materializing it.
| xref:llvm/TargetLoweringBase/isLegalScaleForGatherScatter.adoc[`isLegalScaleForGatherScatter`]  [.small]#[virtual]#
| Return true if the target supports scaling gather/scatter indices by the given amount.
| xref:llvm/TargetLoweringBase/isLegalStoreImmediate.adoc[`isLegalStoreImmediate`]  [.small]#[virtual]#
| Return true if the specified immediate is legal for the value input of a store instruction.
| xref:llvm/TargetLoweringBase/isLoadBitCastBeneficial.adoc[`isLoadBitCastBeneficial`]  [.small]#[virtual]#
| Return true if folding a bitcast into a load is beneficial for this target.
| xref:llvm/TargetLoweringBase/isLoadLegal.adoc[`isLoadLegal`] 
| Return true if the specified load with extension is legal on this target.
| xref:llvm/TargetLoweringBase/isLoadLegalOrCustom.adoc[`isLoadLegalOrCustom`] 
| Return true if the specified load with extension is legal or custom on this target.
| xref:llvm/TargetLoweringBase/isMaskAndCmp0FoldingBeneficial.adoc[`isMaskAndCmp0FoldingBeneficial`]  [.small]#[virtual]#
| Return if the target supports combining a chain like:
| xref:llvm/TargetLoweringBase/isMulAddWithConstProfitable.adoc[`isMulAddWithConstProfitable`]  [.small]#[virtual]#
| Return true if distributing a constant multiply over a constant add is profitable.
| xref:llvm/TargetLoweringBase/isMultiStoresCheaperThanBitsMerge.adoc[`isMultiStoresCheaperThanBitsMerge`]  [.small]#[virtual]#
| Return true if it is cheaper to split the store of a merged int val from a pair of smaller values into multiple stores.
| xref:llvm/TargetLoweringBase/isNarrowingProfitable.adoc[`isNarrowingProfitable`]  [.small]#[virtual]#
| Return true if it's profitable to narrow operations of type SrcVT to DestVT. e.g. on x86, it's profitable to narrow from i32 to i8 but not from i32 to i16.
| xref:llvm/TargetLoweringBase/isOperationCustom.adoc[`isOperationCustom`] 
| Return true if the operation uses custom lowering, regardless of whether the type is legal or not.
| xref:llvm/TargetLoweringBase/isOperationExpand.adoc[`isOperationExpand`] 
| Return true if the given operation must be expanded for this type.
| xref:llvm/TargetLoweringBase/isOperationExpandOrLibCall.adoc[`isOperationExpandOrLibCall`] 
| Return true if the given operation must be expanded or lowered to a libcall for this type.
| xref:llvm/TargetLoweringBase/isOperationLegal.adoc[`isOperationLegal`] 
| Return true if the specified operation is legal on this target.
| xref:llvm/TargetLoweringBase/isOperationLegalOrCustom.adoc[`isOperationLegalOrCustom`] 
| Return true if the given operation is legal or custom for this type.
| xref:llvm/TargetLoweringBase/isOperationLegalOrCustomOrPromote.adoc[`isOperationLegalOrCustomOrPromote`] 
| Return true if the given operation is legal, custom, or promotable for this type.
| xref:llvm/TargetLoweringBase/isOperationLegalOrPromote.adoc[`isOperationLegalOrPromote`] 
| Return true if the given operation is legal or can be made legal via promotion for this type.
| xref:llvm/TargetLoweringBase/isPaddedAtMostSignificantBitsWhenStored.adoc[`isPaddedAtMostSignificantBitsWhenStored`] 
| Indicates if any padding is guaranteed to go at the most significant bits when storing the type to memory and the type size isn't equal to the store size.
| xref:llvm/TargetLoweringBase/isPartialReduceMLALegalOrCustom.adoc[`isPartialReduceMLALegalOrCustom`] 
| Return true if a PARTIAL_REDUCE_U/SMLA node with the specified types is legal or custom for this target.
| xref:llvm/TargetLoweringBase/isPredictableSelectExpensive.adoc[`isPredictableSelectExpensive`] 
| Return true if selects are only cheaper than branches if the branch is unlikely to be predicted right.
| xref:llvm/TargetLoweringBase/isProfitableToCombineMinNumMaxNum.adoc[`isProfitableToCombineMinNumMaxNum`]  [.small]#[virtual]#
| Return true if combining min/max‐num operations is profitable for this type.
| xref:llvm/TargetLoweringBase/isProfitableToHoist.adoc[`isProfitableToHoist`]  [.small]#[virtual]#
| Return true if it is profitable to hoist the given instruction out of a loop.
| xref:llvm/TargetLoweringBase/isSExtCheaperThanZExt.adoc[`isSExtCheaperThanZExt`]  [.small]#[virtual]#
| Return true if sign‐extension from FromTy to ToTy is cheaper than zero‐extension.
| xref:llvm/TargetLoweringBase/isSafeMemOpType.adoc[`isSafeMemOpType`]  [.small]#[virtual]#
| Returns true if it's safe to use load / store of the specified type to expand memcpy / memset inline.
| xref:llvm/TargetLoweringBase/isSelectSupported.adoc[`isSelectSupported`]  [.small]#[virtual]#
| Return true if the target supports the given kind of select operation.
| xref:llvm/TargetLoweringBase/isShuffleMaskLegal.adoc[`isShuffleMaskLegal`]  [.small]#[virtual]#
| Return true if the given shuffle mask is legal for this vector type.
| xref:llvm/TargetLoweringBase/isSlowDivBypassed.adoc[`isSlowDivBypassed`] 
| Returns true if target has indicated at least one type should be bypassed.
| xref:llvm/TargetLoweringBase/isStoreBitCastBeneficial.adoc[`isStoreBitCastBeneficial`]  [.small]#[virtual]#
| Return true if the following transform is beneficial: (store (y (conv x)), y*)) ‐> (store x, (x*))
| xref:llvm/TargetLoweringBase/isStrictFPEnabled-02.adoc[`isStrictFPEnabled`] 
| Return true if the target support strict float operation
| xref:llvm/TargetLoweringBase/isSuitableForBitTests.adoc[`isSuitableForBitTests`] 
| Return true if a switch with the given case clusters is suitable for lowering to bit tests.
| xref:llvm/TargetLoweringBase/isSuitableForJumpTable.adoc[`isSuitableForJumpTable`]  [.small]#[virtual]#
| Return true if lowering to a jump table is suitable for a set of case clusters which may contain `NumCases` cases, `Range` range of values.
| xref:llvm/TargetLoweringBase/isSupportedFixedPointOperation.adoc[`isSupportedFixedPointOperation`]  [.small]#[virtual]#
| Return true if the target natively supports the given fixed‐point operation at the given scale.
| xref:llvm/TargetLoweringBase/isTruncStoreLegal.adoc[`isTruncStoreLegal`] 
| Return true if the specified store with truncation is legal on this target.
| xref:llvm/TargetLoweringBase/isTruncStoreLegalOrCustom.adoc[`isTruncStoreLegalOrCustom`] 
| Return true if the specified store with truncation has solution on this target.
| xref:llvm/TargetLoweringBase/isTruncateFree-014.adoc[`isTruncateFree`] 
| `isTruncateFree` overloads
| xref:llvm/TargetLoweringBase/isTypeLegal.adoc[`isTypeLegal`] 
| Return true if the target has native register support for the given value type.
| xref:llvm/TargetLoweringBase/isVectorClearMaskLegal.adoc[`isVectorClearMaskLegal`]  [.small]#[virtual]#
| Return true if the given mask can replace a vector AND with a shuffle from a constant pool.
| xref:llvm/TargetLoweringBase/isVectorLoadExtDesirable.adoc[`isVectorLoadExtDesirable`]  [.small]#[virtual]#
| Return true if folding a vector load into ExtVal (a sign, zero, or any extend node) is profitable.
| xref:llvm/TargetLoweringBase/isZExtFree-012.adoc[`isZExtFree`] 
| Return true if a value of type FromTy is implicitly zero‐extended to ToTy for free.
| xref:llvm/TargetLoweringBase/lowerDeinterleaveIntrinsicToLoad.adoc[`lowerDeinterleaveIntrinsicToLoad`]  [.small]#[virtual]#
| Lower a deinterleave intrinsic to a target specific load intrinsic. Return true on success. Currently only supports llvm.vector.deinterleave{2,3,5,7}
| xref:llvm/TargetLoweringBase/lowerIdempotentRMWIntoFencedLoad.adoc[`lowerIdempotentRMWIntoFencedLoad`]  [.small]#[virtual]#
| Try to convert an idempotent atomicrmw into a fence followed by an atomic load.
| xref:llvm/TargetLoweringBase/lowerInterleaveIntrinsicToStore.adoc[`lowerInterleaveIntrinsicToStore`]  [.small]#[virtual]#
| Lower an interleave intrinsic to a target specific store intrinsic. Return true on success. Currently only supports llvm.vector.interleave{2,3,5,7}
| xref:llvm/TargetLoweringBase/lowerInterleavedLoad.adoc[`lowerInterleavedLoad`]  [.small]#[virtual]#
| Lower an interleaved load to target specific intrinsics. Return true on success.
| xref:llvm/TargetLoweringBase/lowerInterleavedStore.adoc[`lowerInterleavedStore`]  [.small]#[virtual]#
| Lower an interleaved store to target specific intrinsics. Return true on success.
| xref:llvm/TargetLoweringBase/mergeStoresAfterLegalization.adoc[`mergeStoresAfterLegalization`]  [.small]#[virtual]#
| Return true if stores of this type may be merged even after legalization.
| xref:llvm/TargetLoweringBase/needsFixedCatchObjects.adoc[`needsFixedCatchObjects`]  [.small]#[virtual]#
| Return true if the target requires catch objects to be allocated at fixed stack offsets.
| xref:llvm/TargetLoweringBase/optimizeExtendOrTruncateConversion.adoc[`optimizeExtendOrTruncateConversion`]  [.small]#[virtual]#
| Try to optimize extending or truncating conversion instructions (like zext, trunc, fptoui, uitofp) for the target.
| xref:llvm/TargetLoweringBase/optimizeFMulOrFDivAsShiftAddBitcast.adoc[`optimizeFMulOrFDivAsShiftAddBitcast`]  [.small]#[virtual]#
| Return true if transforming a float multiply/divide by a power of two into a bitcast add/sub is desirable.
| xref:llvm/TargetLoweringBase/preferABDSToABSWithNSW.adoc[`preferABDSToABSWithNSW`]  [.small]#[virtual]#
| Return true if folding abs(sub nsw x, y) into an absolute‐difference op is preferred.
| xref:llvm/TargetLoweringBase/preferIncOfAddToSubOfNot.adoc[`preferIncOfAddToSubOfNot`]  [.small]#[virtual]#
| These two forms are equivalent: sub %y, (xor %x, ‐1) add (add %x, 1), %y The variant with two add's is IR‐canonical. Some targets may prefer one to the other.
| xref:llvm/TargetLoweringBase/preferScalarizeSplat.adoc[`preferScalarizeSplat`]  [.small]#[virtual]#
| Return true if scalarizing an operation on a splat vector is preferred.
| xref:llvm/TargetLoweringBase/preferSelectsOverBooleanArithmetic.adoc[`preferSelectsOverBooleanArithmetic`]  [.small]#[virtual]#
| Should we prefer selects to doing arithmetic on boolean types
| xref:llvm/TargetLoweringBase/preferSextInRegOfTruncate.adoc[`preferSextInRegOfTruncate`]  [.small]#[virtual]#
| Return true if hoisting a sign‐extend‐in‐reg before a truncate is preferred.
| xref:llvm/TargetLoweringBase/preferVectorizedNonPowerOfTwoTypeBreakdown.adoc[`preferVectorizedNonPowerOfTwoTypeBreakdown`]  [.small]#[virtual]#
| Return true if fixed‐length, non‐power‐of‐two vectors should be broken down into legal vector parts instead of scalars for internal values.
| xref:llvm/TargetLoweringBase/preferZeroCompareBranch.adoc[`preferZeroCompareBranch`]  [.small]#[virtual]#
| Return true if the heuristic to prefer icmp eq zero should be used in code gen prepare.
| xref:llvm/TargetLoweringBase/preferedOpcodeForCmpEqPiecesOfOperand.adoc[`preferedOpcodeForCmpEqPiecesOfOperand`]  [.small]#[virtual]#
| Return the preferred shift or rotate opcode for comparing pieces of an operand for equality.
| xref:llvm/TargetLoweringBase/preferredShiftLegalizationStrategy.adoc[`preferredShiftLegalizationStrategy`]  [.small]#[virtual]#
| Return the preferred strategy for legalizing an oversized shift instruction.
| xref:llvm/TargetLoweringBase/promoteTargetBoolean.adoc[`promoteTargetBoolean`] 
| Promote a target boolean value to the boolean representation of the given type.
| xref:llvm/TargetLoweringBase/rangeFitsInWord.adoc[`rangeFitsInWord`] 
| Check whether the range [Low,High]fits in a machine word.
| xref:llvm/TargetLoweringBase/reduceSelectOfFPConstantLoads.adoc[`reduceSelectOfFPConstantLoads`]  [.small]#[virtual]#
| Return true if converting a select of FP constants to a conditional constant‐pool load is profitable.
| xref:llvm/TargetLoweringBase/requiresUniformRegister.adoc[`requiresUniformRegister`]  [.small]#[virtual]#
| Return true if the given value requires a uniform register class across divergent control flow.
| xref:llvm/TargetLoweringBase/setLibcallImpl.adoc[`setLibcallImpl`] 
| Set the libcall implementation to use for the given libcall.
| xref:llvm/TargetLoweringBase/shallExtractConstSplatVectorElementToStore.adoc[`shallExtractConstSplatVectorElementToStore`]  [.small]#[virtual]#
| Return true if a constant vector splat should be stored by extracting a single element.
| xref:llvm/TargetLoweringBase/shouldAlignPointerArgs.adoc[`shouldAlignPointerArgs`]  [.small]#[virtual]#
| Return true if pointer arguments to this call should be aligned by aligning the pointee object.
| xref:llvm/TargetLoweringBase/shouldAvoidTransformToShift.adoc[`shouldAvoidTransformToShift`]  [.small]#[virtual]#
| Return true if creating a shift of the type by the given amount is not profitable.
| xref:llvm/TargetLoweringBase/shouldCastAtomicLoadInIR.adoc[`shouldCastAtomicLoadInIR`]  [.small]#[virtual]#
| Returns how the given (atomic) load should be cast by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldCastAtomicRMWIInIR.adoc[`shouldCastAtomicRMWIInIR`]  [.small]#[virtual]#
| Returns how the given atomic atomicrmw should be cast by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldCastAtomicStoreInIR.adoc[`shouldCastAtomicStoreInIR`]  [.small]#[virtual]#
| Return how an atomic store should be cast by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldConsiderGEPOffsetSplit.adoc[`shouldConsiderGEPOffsetSplit`]  [.small]#[virtual]#
| Return true if CodeGenPrepare should consider splitting a large GEP offset to fit the addressing mode.
| xref:llvm/TargetLoweringBase/shouldConvertConstantLoadToIntImm.adoc[`shouldConvertConstantLoadToIntImm`]  [.small]#[virtual]#
| Return true if replacing a load of this constant with an immediate is beneficial.
| xref:llvm/TargetLoweringBase/shouldConvertFpToSat.adoc[`shouldConvertFpToSat`]  [.small]#[virtual]#
| Return true if a saturating fp‐to‐int conversion should be generated for the given types.
| xref:llvm/TargetLoweringBase/shouldConvertPhiType.adoc[`shouldConvertPhiType`]  [.small]#[virtual]#
| Given a set in interconnected phis of type 'From' that are loaded/stored or bitcast to type 'To', return true if the set should be converted to 'To'.
| xref:llvm/TargetLoweringBase/shouldConvertSplatType.adoc[`shouldConvertSplatType`]  [.small]#[virtual]#
| Return a more profitable scalar type to use for a vector splat, or nullptr if none.
| xref:llvm/TargetLoweringBase/shouldExpandAtomicCmpXchgInIR.adoc[`shouldExpandAtomicCmpXchgInIR`]  [.small]#[virtual]#
| Returns how the given atomic cmpxchg should be expanded by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldExpandAtomicLoadInIR.adoc[`shouldExpandAtomicLoadInIR`]  [.small]#[virtual]#
| Returns how the given (atomic) load should be expanded by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldExpandAtomicRMWInIR.adoc[`shouldExpandAtomicRMWInIR`]  [.small]#[virtual]#
| Returns how the IR‐level AtomicExpand pass should expand the given AtomicRMW, if at all. Default is to never expand.
| xref:llvm/TargetLoweringBase/shouldExpandAtomicStoreInIR.adoc[`shouldExpandAtomicStoreInIR`]  [.small]#[virtual]#
| Return how an atomic store should be expanded by the IR‐level AtomicExpand pass.
| xref:llvm/TargetLoweringBase/shouldExpandBuildVectorWithShuffles.adoc[`shouldExpandBuildVectorWithShuffles`]  [.small]#[virtual]#
| Return true if BUILD_VECTOR should be expanded using shuffles rather than a stack store/load.
| xref:llvm/TargetLoweringBase/shouldExpandGetActiveLaneMask.adoc[`shouldExpandGetActiveLaneMask`]  [.small]#[virtual]#
| Return true if the llvm.get.active.lane.mask intrinsic should be expanded using generic code in SelectionDAGBuilder.
| xref:llvm/TargetLoweringBase/shouldExpandGetVectorLength.adoc[`shouldExpandGetVectorLength`]  [.small]#[virtual]#
| Return true if the get.vector.length intrinsic should be expanded using generic code.
| xref:llvm/TargetLoweringBase/shouldExtendGSIndex.adoc[`shouldExtendGSIndex`]  [.small]#[virtual]#
| Returns true if the index type for a masked gather/scatter requires extending
| xref:llvm/TargetLoweringBase/shouldExtendTypeInLibCall.adoc[`shouldExtendTypeInLibCall`]  [.small]#[virtual]#
| Returns true if arguments should be extended in lib calls.
| xref:llvm/TargetLoweringBase/shouldFoldConstantShiftPairToMask.adoc[`shouldFoldConstantShiftPairToMask`]  [.small]#[virtual]#
| Return true if folding a pair of constant shifts into a mask is profitable.
| xref:llvm/TargetLoweringBase/shouldFoldMaskToVariableShiftPair.adoc[`shouldFoldMaskToVariableShiftPair`]  [.small]#[virtual]#
| Return true if clearing extreme bits with two variable shifts is preferred over masking.
| xref:llvm/TargetLoweringBase/shouldFoldSelectWithIdentityConstant.adoc[`shouldFoldSelectWithIdentityConstant`]  [.small]#[virtual]#
| Return true if folding a binary op into a select with an identity constant is profitable.
| xref:llvm/TargetLoweringBase/shouldFoldSelectWithSingleBitTest.adoc[`shouldFoldSelectWithSingleBitTest`]  [.small]#[virtual]#
| Return true if a select on a single‐bit AND test should be folded into a shift sequence.
| xref:llvm/TargetLoweringBase/shouldFormOverflowOp.adoc[`shouldFormOverflowOp`]  [.small]#[virtual]#
| Return true if an overflow‐checked math operation should be formed for the given opcode and type.
| xref:llvm/TargetLoweringBase/shouldInsertFencesForAtomic.adoc[`shouldInsertFencesForAtomic`]  [.small]#[virtual]#
| Return true if AtomicExpandPass should insert fences and relax ordering for this atomic instruction.
| xref:llvm/TargetLoweringBase/shouldInsertTrailingSeqCstFenceForAtomicStore.adoc[`shouldInsertTrailingSeqCstFenceForAtomicStore`]  [.small]#[virtual]#
| Whether AtomicExpandPass should automatically insert a seq_cst trailing fence without reducing the ordering for this atomic store. Defaults to false.
| xref:llvm/TargetLoweringBase/shouldIssueAtomicLoadForAtomicEmulationLoop.adoc[`shouldIssueAtomicLoadForAtomicEmulationLoop`]  [.small]#[virtual]#
| Return true if an atomic load should be issued for the initial value before an atomicrmw/cmpxchg emulation loop.
| xref:llvm/TargetLoweringBase/shouldKeepZExtForFP16Conv.adoc[`shouldKeepZExtForFP16Conv`]  [.small]#[virtual]#
| Does this target require the clearing of high‐order bits in a register passed to the fp16 to fp conversion library function.
| xref:llvm/TargetLoweringBase/shouldLocalize.adoc[`shouldLocalize`]  [.small]#[virtual]#
| Check whether or not `MI` needs to be moved close to its uses.
| xref:llvm/TargetLoweringBase/shouldMergeStoreOfLoadsOverCall.adoc[`shouldMergeStoreOfLoadsOverCall`]  [.small]#[virtual]#
| Returns true if it's profitable to allow merging store of loads when there are functions calls between the load and the store.
| xref:llvm/TargetLoweringBase/shouldNormalizeToSelectSequence.adoc[`shouldNormalizeToSelectSequence`]  [.small]#[virtual]#
| Return true if a select on a logical combination of conditions should be normalized to nested selects.
| xref:llvm/TargetLoweringBase/shouldOptimizeMulOverflowWithZeroHighBits.adoc[`shouldOptimizeMulOverflowWithZeroHighBits`]  [.small]#[virtual]#
| Return true if the multiply‐with‐overflow intrinsic should be optimized using known zero high bits.
| xref:llvm/TargetLoweringBase/shouldPreservePtrArith.adoc[`shouldPreservePtrArith`]  [.small]#[virtual]#
| Return true if pointer arithmetic semantics should be preserved for this pointer type.
| xref:llvm/TargetLoweringBase/shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd.adoc[`shouldProduceAndByConstByHoistingConstFromShiftsLHSOfAnd`]  [.small]#[virtual]#
| Return true if a shifted‐constant AND pattern should be transformed by hoisting the constant out of the shift.
| xref:llvm/TargetLoweringBase/shouldReassociateReduction.adoc[`shouldReassociateReduction`]  [.small]#[virtual]#
| Return true if two vector reductions combined by an operation should be reassociated into one reduction.
| xref:llvm/TargetLoweringBase/shouldReduceLoadWidth.adoc[`shouldReduceLoadWidth`]  [.small]#[virtual]#
| Return true if narrowing a load to a smaller type is profitable.
| xref:llvm/TargetLoweringBase/shouldRemoveExtendFromGSIndex.adoc[`shouldRemoveExtendFromGSIndex`]  [.small]#[virtual]#
| Return true if an extend can be folded into the index operand of a masked gather or scatter.
| xref:llvm/TargetLoweringBase/shouldRemoveRedundantExtend.adoc[`shouldRemoveRedundantExtend`]  [.small]#[virtual]#
| Return true (the default) if it is profitable to remove a sext_inreg(x) where the sext is redundant, and use x directly.
| xref:llvm/TargetLoweringBase/shouldScalarizeBinop.adoc[`shouldScalarizeBinop`]  [.small]#[virtual]#
| Try to convert an extract element of a vector binary operation into an extract element followed by a scalar operation.
| xref:llvm/TargetLoweringBase/shouldSignExtendTypeInLibCall.adoc[`shouldSignExtendTypeInLibCall`]  [.small]#[virtual]#
| Returns true if arguments should be sign‐extended in lib calls.
| xref:llvm/TargetLoweringBase/shouldSplatInsEltVarIndex.adoc[`shouldSplatInsEltVarIndex`]  [.small]#[virtual]#
| Return true if inserting a scalar into a variable element of an undef vector is more efficiently handled by splatting the scalar instead.
| xref:llvm/TargetLoweringBase/shouldTransformSignedTruncationCheck.adoc[`shouldTransformSignedTruncationCheck`]  [.small]#[virtual]#
| Return true if a signed‐truncation‐overflow check should be rewritten using shifts.
| xref:llvm/TargetLoweringBase/shouldUseDynamicVectorTypeBreakdown.adoc[`shouldUseDynamicVectorTypeBreakdown`] 
| Return true if this vector type should use a dynamic, non‐power‐of‐two register breakdown.
| xref:llvm/TargetLoweringBase/shouldUseStrictFP_TO_INT.adoc[`shouldUseStrictFP_TO_INT`]  [.small]#[virtual]#
| Return true if a strict, canonicalizing FP‐to‐int conversion should be used instead of selecting after the fact.
| xref:llvm/TargetLoweringBase/signExtendConstant.adoc[`signExtendConstant`]  [.small]#[virtual]#
| Return true if this constant should be sign extended when promoting to a larger type.
| xref:llvm/TargetLoweringBase/storeOfVectorConstantIsCheap.adoc[`storeOfVectorConstantIsCheap`]  [.small]#[virtual]#
| Return true if storing this vector constant directly is cheaper than storing its scalar elements.
| xref:llvm/TargetLoweringBase/supportsUnalignedAtomics-09.adoc[`supportsUnalignedAtomics`] 
| Whether the target supports unaligned atomic operations.
| xref:llvm/TargetLoweringBase/useFPRegsForHalfType.adoc[`useFPRegsForHalfType`]  [.small]#[virtual]#
| Return true if soft‐promoted half values should be passed and returned as f32 in FP registers.
| xref:llvm/TargetLoweringBase/useSoftFloat.adoc[`useSoftFloat`]  [.small]#[virtual]#
| Return true if the target should use software floating‐point emulation.
| xref:llvm/TargetLoweringBase/useStackGuardMixFP.adoc[`useStackGuardMixFP`]  [.small]#[virtual]#
| Return true if stack protector checks should mix the frame pointer into the guard value.
|===


== Static Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/getExtendForContent.adoc[`getExtendForContent`] 
| Return the extension kind implied by the given boolean‐content representation.
| xref:llvm/TargetLoweringBase/getLibcallImplName.adoc[`getLibcallImplName`] 
| Get the libcall routine name for the specified libcall implementation
|===


== Protected Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/AddPromotedToType.adoc[`AddPromotedToType`] 
| Override the default promotion type for the specified operation and value type.
| xref:llvm/TargetLoweringBase/addBypassSlowDiv.adoc[`addBypassSlowDiv`] 
| Tells the code generator which bitwidths to bypass.
| xref:llvm/TargetLoweringBase/addRegisterClass.adoc[`addRegisterClass`] 
| Add the specified register class as an available regclass for the specified value type. This indicates the selector can handle values of that class natively.
| xref:llvm/TargetLoweringBase/computeRegisterProperties.adoc[`computeRegisterProperties`] 
| Once all of the register classes are added, this allows us to compute derived properties we expose.
| xref:llvm/TargetLoweringBase/emitPatchPoint.adoc[`emitPatchPoint`] 
| Replace/modify any TargetFrameIndex operands with a targte‐dependent sequence of memory operands that is recognized by PrologEpilogInserter.
| xref:llvm/TargetLoweringBase/findRepresentativeClass.adoc[`findRepresentativeClass`]  [.small]#[virtual]#
| Return the largest legal super‐reg register class of the register class for the specified type and its associated "cost".
| xref:llvm/TargetLoweringBase/getDefaultSafeStackPointerLocation.adoc[`getDefaultSafeStackPointerLocation`] 
| Return the default safe‐stack pointer location.
| xref:llvm/TargetLoweringBase/initActions.adoc[`initActions`] 
| Initialize all of the actions to default values.
| xref:llvm/TargetLoweringBase/isExtFreeImpl.adoc[`isExtFreeImpl`]  [.small]#[virtual]#
| Return true if the extension represented by `I` is free.
| xref:llvm/TargetLoweringBase/isLegalRC.adoc[`isLegalRC`] 
| Return true if the value types that can be represented by the specified register class are all legal.
| xref:llvm/TargetLoweringBase/setAtomicLoadExtAction-04.adoc[`setAtomicLoadExtAction`] 
| `setAtomicLoadExtAction` overloads
| xref:llvm/TargetLoweringBase/setBooleanContents-02.adoc[`setBooleanContents`] 
| Specify how the target extends the result of integer and floating point boolean values from i1 to a wider type. See getBooleanContents.
| xref:llvm/TargetLoweringBase/setBooleanVectorContents.adoc[`setBooleanVectorContents`] 
| Specify how the target extends the result of a vector boolean value from a vector of i1 to a wider type. See getBooleanContents.
| xref:llvm/TargetLoweringBase/setCondCodeAction-05.adoc[`setCondCodeAction`] 
| `setCondCodeAction` overloads
| xref:llvm/TargetLoweringBase/setHasExtractBitsInsn.adoc[`setHasExtractBitsInsn`] 
| Set whether the target has bit‐extract instructions.
| xref:llvm/TargetLoweringBase/setIndexedLoadAction-02.adoc[`setIndexedLoadAction`] 
| `setIndexedLoadAction` overloads
| xref:llvm/TargetLoweringBase/setIndexedMaskedLoadAction.adoc[`setIndexedMaskedLoadAction`] 
| Indicate that the specified indexed masked load does or does not work with the specified type and indicate what to do about it.
| xref:llvm/TargetLoweringBase/setIndexedMaskedStoreAction.adoc[`setIndexedMaskedStoreAction`] 
| Indicate that the specified indexed masked store does or does not work with the specified type and indicate what to do about it.
| xref:llvm/TargetLoweringBase/setIndexedStoreAction-00.adoc[`setIndexedStoreAction`] 
| `setIndexedStoreAction` overloads
| xref:llvm/TargetLoweringBase/setJumpIsExpensive.adoc[`setJumpIsExpensive`] 
| Tells the code generator not to expand logic operations on comparison predicates into separate sequences that increase the amount of flow control.
| xref:llvm/TargetLoweringBase/setLoadExtAction-026.adoc[`setLoadExtAction`] 
| `setLoadExtAction` overloads
| xref:llvm/TargetLoweringBase/setMaxAtomicSizeInBitsSupported.adoc[`setMaxAtomicSizeInBitsSupported`] 
| Set the maximum atomic operation size, in bits, supported by the backend.
| xref:llvm/TargetLoweringBase/setMaxBytesForAlignment.adoc[`setMaxBytesForAlignment`] 
| Set the maximum number of bytes allowed to be emitted for loop alignment padding.
| xref:llvm/TargetLoweringBase/setMaxDivRemBitWidthSupported.adoc[`setMaxDivRemBitWidthSupported`] 
| Set the size in bits of the maximum div/rem the backend supports. Larger operations will be expanded by ExpandIRInsts.
| xref:llvm/TargetLoweringBase/setMaxLargeFPConvertBitWidthSupported.adoc[`setMaxLargeFPConvertBitWidthSupported`] 
| Set the size in bits of the maximum fp to/from int conversion the backend supports. Larger operations will be expanded by ExpandIRInsts.
| xref:llvm/TargetLoweringBase/setMaximumJumpTableSize.adoc[`setMaximumJumpTableSize`] 
| Indicate the maximum number of entries in jump tables. Set to zero to generate unlimited jump tables.
| xref:llvm/TargetLoweringBase/setMinCmpXchgSizeInBits.adoc[`setMinCmpXchgSizeInBits`] 
| Sets the minimum cmpxchg or ll/sc size supported by the backend.
| xref:llvm/TargetLoweringBase/setMinFunctionAlignment.adoc[`setMinFunctionAlignment`] 
| Set the target's minimum function alignment.
| xref:llvm/TargetLoweringBase/setMinStackArgumentAlignment.adoc[`setMinStackArgumentAlignment`] 
| Set the minimum stack alignment of an argument.
| xref:llvm/TargetLoweringBase/setMinimumBitTestCmps.adoc[`setMinimumBitTestCmps`] 
| Set the minimum of largest of number of comparisons to generate BitTest.
| xref:llvm/TargetLoweringBase/setMinimumJumpTableEntries.adoc[`setMinimumJumpTableEntries`] 
| Indicate the minimum number of blocks to generate jump tables.
| xref:llvm/TargetLoweringBase/setOperationAction-0a.adoc[`setOperationAction`] 
| Set the legalization action to use for the given operation and value type.
| xref:llvm/TargetLoweringBase/setOperationPromotedToType-0b.adoc[`setOperationPromotedToType`] 
| `setOperationPromotedToType` overloads
| xref:llvm/TargetLoweringBase/setPartialReduceMLAAction-01.adoc[`setPartialReduceMLAAction`] 
| Set the legalization action for a partial‐reduce multiply‐accumulate node with the given types.
| xref:llvm/TargetLoweringBase/setPrefFunctionAlignment.adoc[`setPrefFunctionAlignment`] 
| Set the target's preferred function alignment. This should be set if there is a performance benefit to higher‐than‐minimum alignment
| xref:llvm/TargetLoweringBase/setPrefLoopAlignment.adoc[`setPrefLoopAlignment`] 
| Set the target's preferred loop alignment.
| xref:llvm/TargetLoweringBase/setSchedulingPreference.adoc[`setSchedulingPreference`] 
| Specify the target scheduling preference.
| xref:llvm/TargetLoweringBase/setStackPointerRegisterToSaveRestore.adoc[`setStackPointerRegisterToSaveRestore`] 
| If set to a physical register, this specifies the register that llvm.savestack/llvm.restorestack should save and restore.
| xref:llvm/TargetLoweringBase/setSupportsUnalignedAtomics.adoc[`setSupportsUnalignedAtomics`] 
| Sets whether unaligned atomic operations are supported.
| xref:llvm/TargetLoweringBase/setTargetDAGCombine.adoc[`setTargetDAGCombine`] 
| Register the given target‐independent node types for custom DAG combining.
| xref:llvm/TargetLoweringBase/setTruncStoreAction.adoc[`setTruncStoreAction`] 
| Indicate that the specified truncating store does not work with the specified type and indicate what to do about it.
|===


== Protected Data Members

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLoweringBase/EnableExtLdPromotion-02f.adoc[`EnableExtLdPromotion`] 
| Whether extending‐load promotion through chains of promotable instructions is enabled.
| xref:llvm/TargetLoweringBase/GatherAllAliasesMaxDepth.adoc[`GatherAllAliasesMaxDepth`] 
| The maximum depth to search for alias‐chain dependencies when merging stores.
| xref:llvm/TargetLoweringBase/IsStrictFPEnabled-03.adoc[`IsStrictFPEnabled`] 
| Whether the target supports strict floating‐point operations.
| xref:llvm/TargetLoweringBase/MaxGluedStoresPerMemcpy.adoc[`MaxGluedStoresPerMemcpy`] 
| Specify max number of store instructions to glue in inlined memcpy.
| xref:llvm/TargetLoweringBase/MaxLoadsPerMemcmp.adoc[`MaxLoadsPerMemcmp`] 
| Specify maximum number of load instructions per memcmp call.
| xref:llvm/TargetLoweringBase/MaxLoadsPerMemcmpOptSize.adoc[`MaxLoadsPerMemcmpOptSize`] 
| Likewise for functions with the OptSize attribute.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemcpy.adoc[`MaxStoresPerMemcpy`] 
| Specify maximum number of store instructions per memcpy call.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemcpyOptSize.adoc[`MaxStoresPerMemcpyOptSize`] 
| Likewise for functions with the OptSize attribute.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemmove.adoc[`MaxStoresPerMemmove`] 
| Specify maximum number of store instructions per memmove call.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemmoveOptSize.adoc[`MaxStoresPerMemmoveOptSize`] 
| Likewise for functions with the OptSize attribute.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemset.adoc[`MaxStoresPerMemset`] 
| Specify maximum number of store instructions per memset call.
| xref:llvm/TargetLoweringBase/MaxStoresPerMemsetOptSize.adoc[`MaxStoresPerMemsetOptSize`] 
| Likewise for functions with the OptSize attribute.
| xref:llvm/TargetLoweringBase/PredictableSelectIsExpensive.adoc[`PredictableSelectIsExpensive`] 
| Tells the code generator that select is more expensive than a branch if the branch is usually predicted right.
|===


== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:llvm/TargetLowering.adoc[`TargetLowering`] 
| This class defines information used to lower LLVM code to legal SelectionDAG operators that the target instruction selector can accept natively.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#