|
LLVM 22.0.0git
|
This pass provides access to the codegen interfaces that are needed for IR-level transformations. More...
#include "llvm/Analysis/TargetTransformInfo.h"
Classes | |
| struct | LSRCost |
| struct | MemCmpExpansionOptions |
| Returns options for expansion of memcmp. IsZeroCmp is. More... | |
| struct | OperandValueInfo |
| struct | PeelingPreferences |
| struct | PointersChainInfo |
| Describe known properties for a set of pointers. More... | |
| struct | UnrollingPreferences |
| Parameters that control the generic loop unrolling transformation. More... | |
| struct | VPLegalization |
Public Types | |
| enum | PartialReductionExtendKind { PR_None , PR_SignExtend , PR_ZeroExtend } |
Public Member Functions | |
| LLVM_ABI | TargetTransformInfo (std::unique_ptr< const TargetTransformInfoImplBase > Impl) |
Construct a TTI object using a type implementing the Concept API below. | |
| LLVM_ABI | TargetTransformInfo (const DataLayout &DL) |
Construct a baseline TTI object using a minimal implementation of the Concept API below. | |
| LLVM_ABI | TargetTransformInfo (TargetTransformInfo &&Arg) |
| LLVM_ABI TargetTransformInfo & | operator= (TargetTransformInfo &&RHS) |
| LLVM_ABI | ~TargetTransformInfo () |
| bool | invalidate (Function &, const PreservedAnalyses &, FunctionAnalysisManager::Invalidator &) |
| Handle the invalidation of this information. | |
| LLVM_ABI bool | hasArmWideBranch (bool Thumb) const |
| LLVM_ABI APInt | getFeatureMask (const Function &F) const |
| Returns a bitmask constructed from the target-features or fmv-features metadata of a function. | |
| LLVM_ABI bool | isMultiversionedFunction (const Function &F) const |
| Returns true if this is an instance of a function with multiple versions. | |
| LLVM_ABI unsigned | getMaxNumArgs () const |
| LLVM_ABI unsigned | getNumBytesToPadGlobalArray (unsigned Size, Type *ArrayType) const |
| LLVM_ABI void | collectKernelLaunchBounds (const Function &F, SmallVectorImpl< std::pair< StringRef, int64_t > > &LB) const |
Collect kernel launch bounds for F into LB. | |
| LLVM_ABI bool | allowVectorElementIndexingUsingGEP () const |
| Returns true if GEP should not be used to index into vectors for this target. | |
Vector Predication Information | |
Whether the target supports the evl parameter of VP intrinsic efficiently in hardware. (see LLVM Language Reference - "Vector Predication Intrinsics"). Use of evl is discouraged when that is not the case. | |
| LLVM_ABI bool | hasActiveVectorLength () const |
| LLVM_ABI bool | isProfitableToSinkOperands (Instruction *I, SmallVectorImpl< Use * > &Ops) const |
| Return true if sinking I's operands to the same basic block as I is profitable, e.g. | |
| LLVM_ABI bool | isVectorShiftByScalarCheap (Type *Ty) const |
| Return true if it's significantly cheaper to shift a vector by a uniform scalar than by an amount which will vary across each lane. | |
| LLVM_ABI VPLegalization | getVPLegalizationStrategy (const VPIntrinsic &PI) const |
Static Public Member Functions | |
| static LLVM_ABI PartialReductionExtendKind | getPartialReductionExtendKind (Instruction *I) |
| Get the kind of extension that an instruction represents. | |
Generic Target Information | |
| enum | TargetCostKind { TCK_RecipThroughput , TCK_Latency , TCK_CodeSize , TCK_SizeAndLatency } |
| The kind of cost model. More... | |
| enum | TargetCostConstants { TCC_Free = 0 , TCC_Basic = 1 , TCC_Expensive = 4 } |
| Underlying constants for 'cost' values in this interface. More... | |
| LLVM_ABI InstructionCost | getGEPCost (Type *PointeeType, const Value *Ptr, ArrayRef< const Value * > Operands, Type *AccessType=nullptr, TargetCostKind CostKind=TCK_SizeAndLatency) const |
| Estimate the cost of a GEP operation when lowered. | |
| LLVM_ABI InstructionCost | getPointersChainCost (ArrayRef< const Value * > Ptrs, const Value *Base, const PointersChainInfo &Info, Type *AccessTy, TargetCostKind CostKind=TTI::TCK_RecipThroughput) const |
| Estimate the cost of a chain of pointers (typically pointer operands of a chain of loads or stores within same block) operations set when lowered. | |
| LLVM_ABI unsigned | getInliningThresholdMultiplier () const |
| LLVM_ABI unsigned | getInliningCostBenefitAnalysisSavingsMultiplier () const |
| LLVM_ABI unsigned | getInliningCostBenefitAnalysisProfitableMultiplier () const |
| LLVM_ABI int | getInliningLastCallToStaticBonus () const |
| LLVM_ABI unsigned | adjustInliningThreshold (const CallBase *CB) const |
| LLVM_ABI unsigned | getCallerAllocaCost (const CallBase *CB, const AllocaInst *AI) const |
| LLVM_ABI int | getInlinerVectorBonusPercent () const |
| LLVM_ABI InstructionCost | getMemcpyCost (const Instruction *I) const |
| LLVM_ABI uint64_t | getMaxMemIntrinsicInlineSizeThreshold () const |
| Returns the maximum memset / memcpy size in bytes that still makes it profitable to inline the call. | |
| LLVM_ABI unsigned | getEstimatedNumberOfCaseClusters (const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI) const |
| LLVM_ABI InstructionCost | getInstructionCost (const User *U, ArrayRef< const Value * > Operands, TargetCostKind CostKind) const |
| Estimate the cost of a given IR user when lowered. | |
| InstructionCost | getInstructionCost (const User *U, TargetCostKind CostKind) const |
This is a helper function which calls the three-argument getInstructionCost with Operands which are the current operands U has. | |
| LLVM_ABI BranchProbability | getPredictableBranchThreshold () const |
| If a branch or a select condition is skewed in one direction by more than this factor, it is very likely to be predicted correctly. | |
| LLVM_ABI InstructionCost | getBranchMispredictPenalty () const |
| Returns estimated penalty of a branch misprediction in latency. | |
| LLVM_ABI bool | hasBranchDivergence (const Function *F=nullptr) const |
| Return true if branch divergence exists. | |
| LLVM_ABI bool | isSourceOfDivergence (const Value *V) const |
| Returns whether V is a source of divergence. | |
| LLVM_ABI bool | isAlwaysUniform (const Value *V) const |
| LLVM_ABI bool | isValidAddrSpaceCast (unsigned FromAS, unsigned ToAS) const |
| Query the target whether the specified address space cast from FromAS to ToAS is valid. | |
| LLVM_ABI bool | addrspacesMayAlias (unsigned AS0, unsigned AS1) const |
Return false if a AS0 address cannot possibly alias a AS1 address. | |
| LLVM_ABI unsigned | getFlatAddressSpace () const |
| Returns the address space ID for a target's 'flat' address space. | |
| LLVM_ABI bool | collectFlatAddressOperands (SmallVectorImpl< int > &OpIndexes, Intrinsic::ID IID) const |
| Return any intrinsic address operand indexes which may be rewritten if they use a flat address space pointer. | |
| LLVM_ABI bool | isNoopAddrSpaceCast (unsigned FromAS, unsigned ToAS) const |
| LLVM_ABI bool | canHaveNonUndefGlobalInitializerInAddressSpace (unsigned AS) const |
Return true if globals in this address space can have initializers other than undef. | |
| LLVM_ABI unsigned | getAssumedAddrSpace (const Value *V) const |
| LLVM_ABI bool | isSingleThreaded () const |
| LLVM_ABI std::pair< const Value *, unsigned > | getPredicatedAddrSpace (const Value *V) const |
| LLVM_ABI Value * | rewriteIntrinsicWithAddressSpace (IntrinsicInst *II, Value *OldV, Value *NewV) const |
Rewrite intrinsic call II such that OldV will be replaced with NewV, which has a different address space. | |
| LLVM_ABI bool | isLoweredToCall (const Function *F) const |
| Test whether calls to a function lower to actual program function calls. | |
| LLVM_ABI void | getUnrollingPreferences (Loop *L, ScalarEvolution &, UnrollingPreferences &UP, OptimizationRemarkEmitter *ORE) const |
| Get target-customized preferences for the generic loop unrolling transformation. | |
| LLVM_ABI bool | isHardwareLoopProfitable (Loop *L, ScalarEvolution &SE, AssumptionCache &AC, TargetLibraryInfo *LibInfo, HardwareLoopInfo &HWLoopInfo) const |
| Query the target whether it would be profitable to convert the given loop into a hardware loop. | |
| LLVM_ABI unsigned | getEpilogueVectorizationMinVF () const |
| LLVM_ABI bool | preferPredicateOverEpilogue (TailFoldingInfo *TFI) const |
| Query the target whether it would be prefered to create a predicated vector loop, which can avoid the need to emit a scalar epilogue loop. | |
| LLVM_ABI TailFoldingStyle | getPreferredTailFoldingStyle (bool IVUpdateMayOverflow=true) const |
| Query the target what the preferred style of tail folding is. | |
| LLVM_ABI void | getPeelingPreferences (Loop *L, ScalarEvolution &SE, PeelingPreferences &PP) const |
| Get target-customized preferences for the generic loop peeling transformation. | |
| LLVM_ABI std::optional< Instruction * > | instCombineIntrinsic (InstCombiner &IC, IntrinsicInst &II) const |
| Targets can implement their own combinations for target-specific intrinsics. | |
| LLVM_ABI std::optional< Value * > | simplifyDemandedUseBitsIntrinsic (InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, KnownBits &Known, bool &KnownBitsComputed) const |
| Can be used to implement target-specific instruction combining. | |
| LLVM_ABI std::optional< Value * > | simplifyDemandedVectorEltsIntrinsic (InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, std::function< void(Instruction *, unsigned, APInt, APInt &)> SimplifyAndSetOp) const |
| Can be used to implement target-specific instruction combining. | |
Scalar Target Information | |
| enum | PopcntSupportKind { PSK_Software , PSK_SlowHardware , PSK_FastHardware } |
| Flags indicating the kind of support for population count. More... | |
| enum | AddressingModeKind { AMK_PreIndexed , AMK_PostIndexed , AMK_None } |
| LLVM_ABI bool | isLegalAddImmediate (int64_t Imm) const |
| Return true if the specified immediate is legal add immediate, that is the target has add instructions which can add a register with the immediate without having to materialize the immediate into a register. | |
| LLVM_ABI bool | isLegalAddScalableImmediate (int64_t Imm) const |
| Return true if adding the specified scalable immediate is legal, that is the target has add instructions which can add a register with the immediate (multiplied by vscale) without having to materialize the immediate into a register. | |
| LLVM_ABI bool | isLegalICmpImmediate (int64_t Imm) const |
| Return true if the specified immediate is legal icmp immediate, that is the target has icmp instructions which can compare a register against the immediate without having to materialize the immediate into a register. | |
| LLVM_ABI bool | isLegalAddressingMode (Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace=0, Instruction *I=nullptr, int64_t ScalableOffset=0) const |
| Return true if the addressing mode represented by AM is legal for this target, for a load/store of the specified type. | |
| LLVM_ABI bool | isLSRCostLess (const TargetTransformInfo::LSRCost &C1, const TargetTransformInfo::LSRCost &C2) const |
| Return true if LSR cost of C1 is lower than C2. | |
| LLVM_ABI bool | isNumRegsMajorCostOfLSR () const |
| Return true if LSR major cost is number of registers. | |
| LLVM_ABI bool | shouldDropLSRSolutionIfLessProfitable () const |
| Return true if LSR should drop a found solution if it's calculated to be less profitable than the baseline. | |
| LLVM_ABI bool | isProfitableLSRChainElement (Instruction *I) const |
| LLVM_ABI bool | canMacroFuseCmp () const |
| Return true if the target can fuse a compare and branch. | |
| LLVM_ABI bool | canSaveCmp (Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC, TargetLibraryInfo *LibInfo) const |
| Return true if the target can save a compare for loop count, for example hardware loop saves a compare. | |
| LLVM_ABI AddressingModeKind | getPreferredAddressingMode (const Loop *L, ScalarEvolution *SE) const |
| Return the preferred addressing mode LSR should make efforts to generate. | |
| LLVM_ABI bool | isLegalMaskedStore (Type *DataType, Align Alignment, unsigned AddressSpace) const |
| Return true if the target supports masked store. | |
| LLVM_ABI bool | isLegalMaskedLoad (Type *DataType, Align Alignment, unsigned AddressSpace) const |
| Return true if the target supports masked load. | |
| LLVM_ABI bool | isLegalNTStore (Type *DataType, Align Alignment) const |
| Return true if the target supports nontemporal store. | |
| LLVM_ABI bool | isLegalNTLoad (Type *DataType, Align Alignment) const |
| Return true if the target supports nontemporal load. | |
| LLVM_ABI bool | isLegalBroadcastLoad (Type *ElementTy, ElementCount NumElements) const |
| \Returns true if the target supports broadcasting a load to a vector of type <NumElements x ElementTy>. | |
| LLVM_ABI bool | isLegalMaskedScatter (Type *DataType, Align Alignment) const |
| Return true if the target supports masked scatter. | |
| LLVM_ABI bool | isLegalMaskedGather (Type *DataType, Align Alignment) const |
| Return true if the target supports masked gather. | |
| LLVM_ABI bool | forceScalarizeMaskedGather (VectorType *Type, Align Alignment) const |
| Return true if the target forces scalarizing of llvm.masked.gather intrinsics. | |
| LLVM_ABI bool | forceScalarizeMaskedScatter (VectorType *Type, Align Alignment) const |
| Return true if the target forces scalarizing of llvm.masked.scatter intrinsics. | |
| LLVM_ABI bool | isLegalMaskedCompressStore (Type *DataType, Align Alignment) const |
| Return true if the target supports masked compress store. | |
| LLVM_ABI bool | isLegalMaskedExpandLoad (Type *DataType, Align Alignment) const |
| Return true if the target supports masked expand load. | |
| LLVM_ABI bool | isLegalStridedLoadStore (Type *DataType, Align Alignment) const |
| Return true if the target supports strided load. | |
| LLVM_ABI bool | isLegalInterleavedAccessType (VectorType *VTy, unsigned Factor, Align Alignment, unsigned AddrSpace) const |
Return true is the target supports interleaved access for the given vector type VTy, interleave factor Factor, alignment Alignment and address space AddrSpace. | |
| LLVM_ABI bool | isLegalMaskedVectorHistogram (Type *AddrType, Type *DataType) const |
| LLVM_ABI bool | isLegalAltInstr (VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask) const |
| Return true if this is an alternating opcode pattern that can be lowered to a single instruction on the target. | |
| LLVM_ABI bool | enableOrderedReductions () const |
| Return true if we should be enabling ordered reductions for the target. | |
| LLVM_ABI bool | hasDivRemOp (Type *DataType, bool IsSigned) const |
| Return true if the target has a unified operation to calculate division and remainder. | |
| LLVM_ABI bool | hasVolatileVariant (Instruction *I, unsigned AddrSpace) const |
| Return true if the given instruction (assumed to be a memory access instruction) has a volatile variant. | |
| LLVM_ABI bool | prefersVectorizedAddressing () const |
| Return true if target doesn't mind addresses in vectors. | |
| LLVM_ABI InstructionCost | getScalingFactorCost (Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace=0) const |
| Return the cost of the scaling factor used in the addressing mode represented by AM for this target, for a load/store of the specified type. | |
| LLVM_ABI bool | LSRWithInstrQueries () const |
| Return true if the loop strength reduce pass should make Instruction* based TTI queries to isLegalAddressingMode(). | |
| LLVM_ABI bool | isTruncateFree (Type *Ty1, Type *Ty2) const |
| Return true if it's free to truncate a value of type Ty1 to type Ty2. | |
| LLVM_ABI bool | isProfitableToHoist (Instruction *I) const |
| Return true if it is profitable to hoist instruction in the then/else to before if. | |
| LLVM_ABI bool | useAA () const |
| LLVM_ABI bool | isTypeLegal (Type *Ty) const |
| Return true if this type is legal. | |
| LLVM_ABI unsigned | getRegUsageForType (Type *Ty) const |
Returns the estimated number of registers required to represent Ty. | |
| LLVM_ABI bool | shouldBuildLookupTables () const |
| Return true if switches should be turned into lookup tables for the target. | |
| LLVM_ABI bool | shouldBuildLookupTablesForConstant (Constant *C) const |
| Return true if switches should be turned into lookup tables containing this constant value for the target. | |
| LLVM_ABI bool | shouldBuildRelLookupTables () const |
| Return true if lookup tables should be turned into relative lookup tables. | |
| LLVM_ABI bool | useColdCCForColdCall (Function &F) const |
| Return true if the input function which is cold at all call sites, should use coldcc calling convention. | |
| LLVM_ABI bool | isTargetIntrinsicTriviallyScalarizable (Intrinsic::ID ID) const |
| LLVM_ABI bool | isTargetIntrinsicWithScalarOpAtArg (Intrinsic::ID ID, unsigned ScalarOpdIdx) const |
| Identifies if the vector form of the intrinsic has a scalar operand. | |
| LLVM_ABI bool | isTargetIntrinsicWithOverloadTypeAtArg (Intrinsic::ID ID, int OpdIdx) const |
Identifies if the vector form of the intrinsic is overloaded on the type of the operand at index OpdIdx, or on the return type if OpdIdx is -1. | |
| LLVM_ABI bool | isTargetIntrinsicWithStructReturnOverloadAtField (Intrinsic::ID ID, int RetIdx) const |
Identifies if the vector form of the intrinsic that returns a struct is overloaded at the struct element index RetIdx. | |
| LLVM_ABI InstructionCost | getScalarizationOverhead (VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract, TTI::TargetCostKind CostKind, bool ForPoisonSrc=true, ArrayRef< Value * > VL={}) const |
| Estimate the overhead of scalarizing an instruction. | |
| LLVM_ABI InstructionCost | getOperandsScalarizationOverhead (ArrayRef< Type * > Tys, TTI::TargetCostKind CostKind) const |
| Estimate the overhead of scalarizing operands with the given types. | |
| LLVM_ABI bool | supportsEfficientVectorElementLoadStore () const |
| If target has efficient vector element load/store instructions, it can return true here so that insertion/extraction costs are not added to the scalarization cost of a load/store. | |
| LLVM_ABI bool | supportsTailCalls () const |
| If the target supports tail calls. | |
| LLVM_ABI bool | supportsTailCallFor (const CallBase *CB) const |
If target supports tail call on CB. | |
| LLVM_ABI bool | enableAggressiveInterleaving (bool LoopHasReductions) const |
| Don't restrict interleaved unrolling to small loops. | |
| LLVM_ABI MemCmpExpansionOptions | enableMemCmpExpansion (bool OptSize, bool IsZeroCmp) const |
| LLVM_ABI bool | enableSelectOptimize () const |
| Should the Select Optimization pass be enabled and ran. | |
| LLVM_ABI bool | shouldTreatInstructionLikeSelect (const Instruction *I) const |
| Should the Select Optimization pass treat the given instruction like a select, potentially converting it to a conditional branch. | |
| LLVM_ABI bool | enableInterleavedAccessVectorization () const |
| Enable matching of interleaved access groups. | |
| LLVM_ABI bool | enableMaskedInterleavedAccessVectorization () const |
| Enable matching of interleaved access groups that contain predicated accesses or gaps and therefore vectorized using masked vector loads/stores. | |
| LLVM_ABI bool | isFPVectorizationPotentiallyUnsafe () const |
| Indicate that it is potentially unsafe to automatically vectorize floating-point operations because the semantics of vector and scalar floating-point semantics may differ. | |
| LLVM_ABI bool | allowsMisalignedMemoryAccesses (LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace=0, Align Alignment=Align(1), unsigned *Fast=nullptr) const |
| Determine if the target supports unaligned memory accesses. | |
| LLVM_ABI PopcntSupportKind | getPopcntSupport (unsigned IntTyWidthInBit) const |
| Return hardware support for population count. | |
| LLVM_ABI bool | haveFastSqrt (Type *Ty) const |
| Return true if the hardware has a fast square-root instruction. | |
| LLVM_ABI bool | isExpensiveToSpeculativelyExecute (const Instruction *I) const |
| Return true if the cost of the instruction is too high to speculatively execute and should be kept behind a branch. | |
| LLVM_ABI bool | isFCmpOrdCheaperThanFCmpZero (Type *Ty) const |
| Return true if it is faster to check if a floating-point value is NaN (or not-NaN) versus a comparison against a constant FP zero value. | |
| LLVM_ABI InstructionCost | getFPOpCost (Type *Ty) const |
| Return the expected cost of supporting the floating point operation of the specified type. | |
| LLVM_ABI InstructionCost | getIntImmCost (const APInt &Imm, Type *Ty, TargetCostKind CostKind) const |
| Return the expected cost of materializing for the given integer immediate of the specified type. | |
| LLVM_ABI InstructionCost | getIntImmCostInst (unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty, TargetCostKind CostKind, Instruction *Inst=nullptr) const |
| Return the expected cost of materialization for the given integer immediate of the specified type for a given instruction. | |
| LLVM_ABI InstructionCost | getIntImmCostIntrin (Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty, TargetCostKind CostKind) const |
| LLVM_ABI InstructionCost | getIntImmCodeSizeCost (unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty) const |
| Return the expected cost for the given integer when optimising for size. | |
| LLVM_ABI bool | preferToKeepConstantsAttached (const Instruction &Inst, const Function &Fn) const |
| It can be advantageous to detach complex constants from their uses to make their generation cheaper. | |
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition at line 219 of file TargetTransformInfo.h.
| Enumerator | |
|---|---|
| AMK_PreIndexed | |
| AMK_PostIndexed | |
| AMK_None | |
Definition at line 797 of file TargetTransformInfo.h.
|
strong |
|
strong |
Represents a hint about the context in which a cast is used.
For zext/sext, the context of the cast is the operand, which must be a load of some kind. For trunc, the context is of the cast is the single user of the instruction, which must be a store of some kind.
This enum allows the vectorizer to give getCastInstrCost an idea of the type of cast it's dealing with, as not every cast is equal. For instance, the zext of a load may be free, but the zext of an interleaving load can be (very) expensive!
See getCastContextHint to compute a CastContextHint from a cast Instruction*. Callers can use it if they don't need to override the context and just want it to be calculated from the instruction.
FIXME: This handles the types of load/store that the vectorizer can produce, which are the cases where the context instruction is most likely to be incorrect. There are other situations where that can happen too, which might be handled here but in the long run a more general solution of costing multiple instructions at the same times may be better.
Definition at line 1428 of file TargetTransformInfo.h.
The type of load/store indexing.
| Enumerator | |
|---|---|
| MIM_Unindexed | No indexing. |
| MIM_PreInc | Pre-incrementing. |
| MIM_PreDec | Pre-decrementing. |
| MIM_PostInc | Post-incrementing. |
| MIM_PostDec | Post-decrementing. |
Definition at line 1762 of file TargetTransformInfo.h.
Additional information about an operand's possible values.
| Enumerator | |
|---|---|
| OK_AnyValue | |
| OK_UniformValue | |
| OK_UniformConstantValue | |
| OK_NonUniformConstantValue | |
Definition at line 1143 of file TargetTransformInfo.h.
Additional properties of an operand's values.
| Enumerator | |
|---|---|
| OP_None | |
| OP_PowerOf2 | |
| OP_NegatedPowerOf2 | |
Definition at line 1151 of file TargetTransformInfo.h.
| Enumerator | |
|---|---|
| PR_None | |
| PR_SignExtend | |
| PR_ZeroExtend | |
Definition at line 221 of file TargetTransformInfo.h.
Flags indicating the kind of support for population count.
Compared to the SW implementation, HW support is supposed to significantly boost the performance when the population is dense, and it may or may not degrade performance if the population is sparse. A HW support is considered as "Fast" if it can outperform, or is on a par with, SW implementation when the population is sparse; otherwise, it is considered as "Slow".
| Enumerator | |
|---|---|
| PSK_Software | |
| PSK_SlowHardware | |
| PSK_FastHardware | |
Definition at line 735 of file TargetTransformInfo.h.
|
strong |
| Enumerator | |
|---|---|
| SplitHalf | |
| Pairwise | |
Definition at line 1849 of file TargetTransformInfo.h.
| Enumerator | |
|---|---|
| RGK_Scalar | |
| RGK_FixedWidthVector | |
| RGK_ScalableVector | |
Definition at line 1206 of file TargetTransformInfo.h.
The various kinds of shuffle patterns for vector queries.
Definition at line 1123 of file TargetTransformInfo.h.
Underlying constants for 'cost' values in this interface.
Many APIs in this interface return a cost. This enum defines the fundamental values that should be used to interpret (and produce) those costs. The costs are returned as an int rather than a member of this enumeration because it is expected that the cost of one IR instruction may have a multiplicative factor to it or otherwise won't fit directly into the enum. Moreover, it is common to sum or average costs which works better as simple integral values. Thus this enum only provides constants. Also note that the returned costs are signed integers to make it natural to add, subtract, and test with zero (a common boundary condition). It is not expected that 2^32 is a realistic cost to be modeling at any point.
Note that these costs should usually reflect the intersection of code-size cost and execution cost. A free instruction is typically one that folds into another instruction. For example, reg-to-reg moves can often be skipped by renaming the registers in the CPU, but they still are encoded and thus wouldn't be considered 'free' here.
| Enumerator | |
|---|---|
| TCC_Free | Expected to fold away in lowering. |
| TCC_Basic | The cost of a typical 'add' instruction. |
| TCC_Expensive | The cost of a 'div' instruction on x86. |
Definition at line 296 of file TargetTransformInfo.h.
The kind of cost model.
There are several different cost models that can be customized by the target. The normalization of each cost model may be target specific. e.g. TCK_SizeAndLatency should be comparable to target thresholds such as those derived from MCSchedModel::LoopMicroOpBufferSize etc.
| Enumerator | |
|---|---|
| TCK_RecipThroughput | Reciprocal throughput. |
| TCK_Latency | The latency of instruction. |
| TCK_CodeSize | Instruction code size. |
| TCK_SizeAndLatency | The weighted sum of size and latency. |
Definition at line 271 of file TargetTransformInfo.h.
|
explicit |
Construct a TTI object using a type implementing the Concept API below.
This is used by targets to construct a TTI wrapping their target-specific implementation that encodes appropriate costs for their target.
Definition at line 60 of file TargetTransformInfo.cpp.
|
explicit |
Construct a baseline TTI object using a minimal implementation of the Concept API below.
The TTI implementation will reflect the information in the DataLayout provided if non-null.
Definition at line 205 of file TargetTransformInfo.cpp.
| TargetTransformInfo::TargetTransformInfo | ( | TargetTransformInfo && | Arg | ) |
Definition at line 210 of file TargetTransformInfo.cpp.
|
default |
Return false if a AS0 address cannot possibly alias a AS1 address.
Definition at line 313 of file TargetTransformInfo.cpp.
Referenced by llvm::expandMemMoveAsLoop().
Definition at line 238 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::allowsMisalignedMemoryAccesses | ( | LLVMContext & | Context, |
| unsigned | BitWidth, | ||
| unsigned | AddressSpace = 0, |
||
| Align | Alignment = Align(1), |
||
| unsigned * | Fast = nullptr |
||
| ) | const |
Determine if the target supports unaligned memory accesses.
Definition at line 688 of file TargetTransformInfo.cpp.
References llvm::BitWidth, Context, and llvm::CallingConv::Fast.
Referenced by foldConsecutiveLoads(), and mergeConsecutivePartStores().
| bool TargetTransformInfo::allowVectorElementIndexingUsingGEP | ( | ) | const |
Returns true if GEP should not be used to index into vectors for this target.
Definition at line 1499 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::areInlineCompatible | ( | const Function * | Caller, |
| const Function * | Callee | ||
| ) | const |
Definition at line 1331 of file TargetTransformInfo.cpp.
Referenced by functionsHaveCompatibleAttributes().
| bool TargetTransformInfo::areTypesABICompatible | ( | const Function * | Caller, |
| const Function * | Callee, | ||
| const ArrayRef< Type * > & | Types | ||
| ) | const |
Types will be passed to or returned from the callee. to the callee. | Types | List of types to check. |
Definition at line 1343 of file TargetTransformInfo.cpp.
Return true if globals in this address space can have initializers other than undef.
Definition at line 332 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::canMacroFuseCmp | ( | ) | const |
Return true if the target can fuse a compare and branch.
Loop-strength-reduction (LSR) uses that knowledge to adjust its cost calculation for the instructions in a loop.
Definition at line 452 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::canSaveCmp | ( | Loop * | L, |
| BranchInst ** | BI, | ||
| ScalarEvolution * | SE, | ||
| LoopInfo * | LI, | ||
| DominatorTree * | DT, | ||
| AssumptionCache * | AC, | ||
| TargetLibraryInfo * | LibInfo | ||
| ) | const |
Return true if the target can save a compare for loop count, for example hardware loop saves a compare.
Definition at line 456 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::collectFlatAddressOperands | ( | SmallVectorImpl< int > & | OpIndexes, |
| Intrinsic::ID | IID | ||
| ) | const |
Return any intrinsic address operand indexes which may be rewritten if they use a flat address space pointer.
Definition at line 322 of file TargetTransformInfo.cpp.
| void TargetTransformInfo::collectKernelLaunchBounds | ( | const Function & | F, |
| SmallVectorImpl< std::pair< StringRef, int64_t > > & | LB | ||
| ) | const |
Collect kernel launch bounds for F into LB.
Definition at line 1493 of file TargetTransformInfo.cpp.
References F.
Don't restrict interleaved unrolling to small loops.
Definition at line 656 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationPlanner::selectInterleaveCount().
| bool TargetTransformInfo::enableInterleavedAccessVectorization | ( | ) | const |
Enable matching of interleaved access groups.
Definition at line 675 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::processLoop().
| bool TargetTransformInfo::enableMaskedInterleavedAccessVectorization | ( | ) | const |
Enable matching of interleaved access groups that contain predicated accesses or gaps and therefore vectorized using masked vector loads/stores.
Definition at line 679 of file TargetTransformInfo.cpp.
Referenced by useMaskedInterleavedAccesses().
| TargetTransformInfo::MemCmpExpansionOptions TargetTransformInfo::enableMemCmpExpansion | ( | bool | OptSize, |
| bool | IsZeroCmp | ||
| ) | const |
Definition at line 662 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::enableOrderedReductions | ( | ) | const |
Return true if we should be enabling ordered reductions for the target.
Definition at line 546 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::processLoop().
| bool TargetTransformInfo::enableScalableVectorization | ( | ) | const |
Definition at line 1470 of file TargetTransformInfo.cpp.
Referenced by determineVPlanVF(), llvm::LoopAccessInfo::LoopAccessInfo(), and llvm::LoopVectorizeHints::LoopVectorizeHints().
| bool TargetTransformInfo::enableSelectOptimize | ( | ) | const |
Should the Select Optimization pass be enabled and ran.
Definition at line 666 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::enableWritePrefetching | ( | ) | const |
Definition at line 862 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::forceScalarizeMaskedGather | ( | VectorType * | Type, |
| Align | Alignment | ||
| ) | const |
Return true if the target forces scalarizing of llvm.masked.gather intrinsics.
Definition at line 509 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), and optimizeCallInst().
| bool TargetTransformInfo::forceScalarizeMaskedScatter | ( | VectorType * | Type, |
| Align | Alignment | ||
| ) | const |
Return true if the target forces scalarizing of llvm.masked.scatter intrinsics.
Definition at line 514 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
| InstructionCost TargetTransformInfo::getAddressComputationCost | ( | Type * | PtrTy, |
| ScalarEvolution * | SE, | ||
| const SCEV * | Ptr, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
SE holds the pointer for the scalar evolution object which was used in order to get the Ptr step value. Ptr holds the SCEV of the access pointer. Definition at line 1241 of file TargetTransformInfo.cpp.
References assert(), CostKind, and Ptr.
Referenced by chainToBasePointerCost(), and llvm::VPWidenMemoryRecipe::computeCost().
| InstructionCost TargetTransformInfo::getAltInstrCost | ( | VectorType * | VecTy, |
| unsigned | Opcode0, | ||
| unsigned | Opcode1, | ||
| const SmallBitVector & | OpcodeMask, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Returns the cost estimation for alternating opcode pattern that can be lowered to a single instruction on the target.
In X86 this is for the addsub instruction which corrsponds to a Shuffle + Fadd + FSub pattern in IR. This function expects two opcodes: Opcode1 and Opcode2 being selected by OpcodeMask. The mask contains one bit per lane and is a 0 when Opcode0 is selected and 1 when Opcode1 is selected. VecTy is the vector type of the instruction to be generated.
Definition at line 977 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getArithmeticInstrCost | ( | unsigned | Opcode, |
| Type * | Ty, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| TTI::OperandValueInfo | Opd1Info = {TTI::OK_AnyValue, TTI::OP_None}, |
||
| TTI::OperandValueInfo | Opd2Info = {TTI::OK_AnyValue, TTI::OP_None}, |
||
| ArrayRef< const Value * > | Args = {}, |
||
| const Instruction * | CxtI = nullptr, |
||
| const TargetLibraryInfo * | TLibInfo = nullptr |
||
| ) | const |
This is an approximation of reciprocal throughput of a math/logic op.
A higher cost indicates less expected throughput. From Agner Fog's guides, reciprocal throughput is "the average number of
clock cycles per instruction when the instructions are not part of a
limiting dependency chain." Therefore, costs should be scaled to account for multiple execution units on the target that can process this type of instruction. For example, if there are 5 scalar integer units and 2 vector integer units that can calculate an 'add' in a single cycle, this model should indicate that the cost of the vector add instruction is 2.5 times the cost of the scalar add instruction. Args is an optional argument which holds the instruction operands values so the TTI can analyze those values searching for special cases or optimizations based on those values. CxtI is the optional original context instruction, if one exists, to provide even more information. TLibInfo is used to search for platform specific vector library functions for instructions that might be converted to calls (e.g. frem).
Definition at line 950 of file TargetTransformInfo.cpp.
References assert(), CostKind, getCallInstrCost(), llvm::VectorType::getElementCount(), llvm::TargetLibraryInfo::getLibFunc(), llvm::TargetLibraryInfo::getName(), llvm::Type::getScalarType(), and llvm::TargetLibraryInfo::isFunctionVectorizable().
Referenced by analyzeCostOfVecReduction(), llvm::VPHistogramRecipe::computeCost(), llvm::VPWidenSelectRecipe::computeCost(), costAndCollectOperands(), llvm::foldBranchToCommonDest(), llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode(), llvm::LoopVectorizationCostModel::getDivRemSpeculationCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::LoopVectorizationCostModel::getReductionPatternCost(), tryNarrowMathIfNoOverflow(), and visitIVCast().
| InstructionCost TargetTransformInfo::getArithmeticReductionCost | ( | unsigned | Opcode, |
| VectorType * | Ty, | ||
| std::optional< FastMathFlags > | FMF, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Calculate the cost of vector reduction intrinsics.
This is the cost of reducing the vector value of type Ty to a scalar value using the operation denoted by Opcode. The FastMathFlags parameter FMF indicates what type of reduction we are performing:
FMF indicates that reassociation is allowed.Definition at line 1260 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by analyzeCostOfVecReduction(), llvm::VPInstruction::computeCost(), llvm::VPReductionRecipe::computeCost(), and llvm::LoopVectorizationCostModel::getReductionPatternCost().
Definition at line 337 of file TargetTransformInfo.cpp.
Referenced by isAddressExpression().
| unsigned TargetTransformInfo::getAtomicMemIntrinsicMaxElementSize | ( | ) | const |
Definition at line 1302 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getBranchMispredictPenalty | ( | ) | const |
Returns estimated penalty of a branch misprediction in latency.
Indicates how aggressive the target wants for eliminating unpredictable branches. A zero return value means extra optimization applied to them should be minimal.
Definition at line 288 of file TargetTransformInfo.cpp.
Referenced by foldTwoEntryPHINode().
| std::optional< unsigned > TargetTransformInfo::getCacheAssociativity | ( | CacheLevel | Level | ) | const |
Definition at line 838 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getCacheLineSize | ( | ) | const |
Definition at line 827 of file TargetTransformInfo.cpp.
References CacheLineSize.
| std::optional< unsigned > TargetTransformInfo::getCacheSize | ( | CacheLevel | Level | ) | const |
Definition at line 833 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getCallerAllocaCost | ( | const CallBase * | CB, |
| const AllocaInst * | AI | ||
| ) | const |
Definition at line 242 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getCallInstrCost | ( | Function * | F, |
| Type * | RetTy, | ||
| ArrayRef< Type * > | Tys, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_SizeAndLatency |
||
| ) | const |
Definition at line 1229 of file TargetTransformInfo.cpp.
References assert(), CostKind, F, and RetTy.
Referenced by llvm::VPWidenCallRecipe::computeCost(), llvm::VPReplicateRecipe::computeCost(), getArithmeticInstrCost(), llvm::slpvectorizer::BoUpSLP::getSpillCost(), llvm::LoopVectorizationCostModel::getVectorCallCost(), getVectorCallCosts(), and llvm::LoopVectorizationCostModel::setVectorizedCallDecision().
|
static |
Calculates a CastContextHint from I.
This should be used by callers of getCastInstrCost if they wish to determine the context from some instruction.
I is nullptr, or if it's another type of cast. Definition at line 1011 of file TargetTransformInfo.cpp.
References GatherScatter, I, II, Masked, None, and Normal.
Referenced by chainToBasePointerCost(), llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(), llvm::AArch64TargetLowering::optimizeExtendOrTruncateConversion(), and tryNarrowMathIfNoOverflow().
| InstructionCost TargetTransformInfo::getCastInstrCost | ( | unsigned | Opcode, |
| Type * | Dst, | ||
| Type * | Src, | ||
| TTI::CastContextHint | CCH, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_SizeAndLatency, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Definition at line 1054 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by analyzeCostOfVecReduction(), chainToBasePointerCost(), llvm::VPWidenCastRecipe::computeCost(), costAndCollectOperands(), llvm::BasicTTIImplBase< T >::getCastInstrCost(), getExtractWithExtendCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::LoopVectorizationCostModel::getReductionPatternCost(), llvm::slpvectorizer::BoUpSLP::getTreeCost(), llvm::AArch64TargetLowering::optimizeExtendOrTruncateConversion(), tryNarrowMathIfNoOverflow(), and tryToFPToSat().
| InstructionCost TargetTransformInfo::getCFInstrCost | ( | unsigned | Opcode, |
| TTI::TargetCostKind | CostKind = TTI::TCK_SizeAndLatency, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Definition at line 1074 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by llvm::VPHeaderPHIRecipe::computeCost(), llvm::VPFirstOrderRecurrencePHIRecipe::computeCost(), llvm::VPBlendRecipe::computeCost(), llvm::VPRegionBlock::cost(), costAndCollectOperands(), findCostForOutputBlocks(), llvm::LoopVectorizationCostModel::getDivRemSpeculationCost(), and llvm::LoopVectorizationCostModel::getInstructionCost().
| InstructionCost TargetTransformInfo::getCmpSelInstrCost | ( | unsigned | Opcode, |
| Type * | ValTy, | ||
| Type * | CondTy, | ||
| CmpInst::Predicate | VecPred, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| OperandValueInfo | Op1Info = {OK_AnyValue, OP_None}, |
||
| OperandValueInfo | Op2Info = {OK_AnyValue, OP_None}, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
VecPred parameter can be used to indicate the select is using a compare with the specified predicate as condition. When vector types are passed, VecPred must be used for all lanes. For a comparison, the two operands are the natural values. For a select, the two operands are the value operands, not the condition operand. Definition at line 1083 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by llvm::VPInstruction::computeCost(), llvm::VPWidenSelectRecipe::computeCost(), llvm::VPBlendRecipe::computeCost(), costAndCollectOperands(), findCostForOutputBlocks(), llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode(), llvm::LoopVectorizationCostModel::getDivRemSpeculationCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), and validateAndCostRequiredSelects().
| InstructionCost TargetTransformInfo::getCostOfKeepingLiveOverCall | ( | ArrayRef< Type * > | Tys | ) | const |
Some types may require the use of register classes that do not have any callee-saved registers, so would require a spill and fill.
Definition at line 1293 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::getSpillCost().
| unsigned TargetTransformInfo::getEpilogueVectorizationMinVF | ( | ) | const |
Definition at line 365 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isEpilogueVectorizationProfitable().
| unsigned TargetTransformInfo::getEstimatedNumberOfCaseClusters | ( | const SwitchInst & | SI, |
| unsigned & | JTSize, | ||
| ProfileSummaryInfo * | PSI, | ||
| BlockFrequencyInfo * | BFI | ||
| ) | const |
'SI'. JTSize Set a jump table size only when SI is suitable for a jump table. Definition at line 266 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getExpandCompressMemoryOpCost | ( | unsigned | Opcode, |
| Type * | DataTy, | ||
| bool | VariableMask, | ||
| Align | Alignment, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Opcode - is a type of memory access Load or Store Src - a vector type of the data to be loaded or stored VariableMask - true when the memory access is predicated with a mask that is not a compile-time constant Alignment - alignment of single element I - the optional original context instruction, if one exists, e.g. the load/store to transform or the call to the gather/scatter intrinsic Definition at line 1191 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getExtendedReductionCost | ( | unsigned | Opcode, |
| bool | IsUnsigned, | ||
| Type * | ResTy, | ||
| VectorType * | Ty, | ||
| std::optional< FastMathFlags > | FMF, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Calculate the cost of an extended reduction pattern, similar to getArithmeticReductionCost of a reduction with an extension.
This is the cost of as: ResTy vecreduce.opcode(ext(Ty A)).
Definition at line 1278 of file TargetTransformInfo.cpp.
References CostKind.
Referenced by analyzeCostOfVecReduction(), llvm::VPExpressionRecipe::computeCost(), llvm::LoopVectorizationCostModel::getReductionPatternCost(), and tryToMatchAndCreateExtendedReduction().
| InstructionCost TargetTransformInfo::getExtractWithExtendCost | ( | unsigned | Opcode, |
| Type * | Dst, | ||
| VectorType * | VecTy, | ||
| unsigned | Index, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Definition at line 1065 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by getExtractWithExtendCost().
Returns a bitmask constructed from the target-features or fmv-features metadata of a function.
Definition at line 1436 of file TargetTransformInfo.cpp.
References F.
Referenced by OptimizeNonTrivialIFuncs().
| unsigned TargetTransformInfo::getFlatAddressSpace | ( | ) | const |
Returns the address space ID for a target's 'flat' address space.
Note this is not necessarily the same as addrspace(0), which LLVM sometimes refers to as the generic address space. The flat address space is a generic address space that can be used access multiple segments of memory with different address spaces. Access of a memory location through a pointer with this address space is expected to be legal but slower compared to the same memory location accessed through a pointer with a different address space. This is for targets with different pointer representations which can be converted with the addrspacecast instruction. If a pointer is converted to this address space, optimizations should attempt to replace the access with the source address space.
Definition at line 318 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getFPOpCost | ( | Type * | Ty | ) | const |
Return the expected cost of supporting the floating point operation of the specified type.
Definition at line 715 of file TargetTransformInfo.cpp.
References assert().
| InstructionCost TargetTransformInfo::getGatherScatterOpCost | ( | unsigned | Opcode, |
| Type * | DataTy, | ||
| const Value * | Ptr, | ||
| bool | VariableMask, | ||
| Align | Alignment, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Opcode - is a type of memory access Load or Store DataTy - a vector type of the data to be loaded or stored Ptr - pointer [or vector of pointers] - address[es] in memory VariableMask - true when the memory access is predicated with a mask that is not a compile-time constant Alignment - alignment of single element I - the optional original context instruction, if one exists, e.g. the load/store to transform or the call to the gather/scatter intrinsic Definition at line 1181 of file TargetTransformInfo.cpp.
References assert(), CostKind, I, llvm::InstructionCost::isValid(), and Ptr.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), and llvm::VPWidenMemoryRecipe::computeCost().
| InstructionCost TargetTransformInfo::getGEPCost | ( | Type * | PointeeType, |
| const Value * | Ptr, | ||
| ArrayRef< const Value * > | Operands, | ||
| Type * | AccessType = nullptr, |
||
| TTI::TargetCostKind | CostKind = TCK_SizeAndLatency |
||
| ) | const |
Estimate the cost of a GEP operation when lowered.
PointeeType is the source element type of the GEP. Ptr is the base pointer operand. Operands is the list of indices following the base pointer.
AccessType is a hint as to what type of memory might be accessed by users of the GEP. getGEPCost will use it to determine if the GEP can be folded into the addressing mode of a load/store. If AccessType is null, then the resulting target type based off of PointeeType will be used as an approximation.
Definition at line 251 of file TargetTransformInfo.cpp.
References CostKind, Operands, and Ptr.
Referenced by getGEPCosts(), and isGEPFoldable().
| unsigned TargetTransformInfo::getGISelRematGlobalCost | ( | ) | const |
Definition at line 1458 of file TargetTransformInfo.cpp.
Referenced by llvm::TargetLoweringBase::shouldLocalize().
| InstructionCost TargetTransformInfo::getIndexedVectorInstrCostFromEnd | ( | unsigned | Opcode, |
| Type * | Val, | ||
| TTI::TargetCostKind | CostKind, | ||
| unsigned | Index | ||
| ) | const |
Index elements from the end of a vector, i.e. the mathematical expression for the lane is (VF - 1 - Index). This is required for scalable vectors where the exact lane index is unknown at compile time. Definition at line 1132 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::VPInstruction::computeCost().
| unsigned TargetTransformInfo::getInlineCallPenalty | ( | const Function * | F, |
| const CallBase & | Call, | ||
| unsigned | DefaultCallPenalty | ||
| ) | const |
Returns a penalty for invoking call Call in F.
For example, if a function F calls a function G, which in turn calls function H, then getInlineCallPenalty(F, H()) would return the penalty of calling H from F, e.g. after inlining G into F. DefaultCallPenalty is passed to give a default penalty that the target can amend or override.
Definition at line 1337 of file TargetTransformInfo.cpp.
References F.
Referenced by llvm::getCallsiteCost().
| int TargetTransformInfo::getInlinerVectorBonusPercent | ( | ) | const |
Vector bonuses: We want to more aggressively inline vector-dense kernels and apply this bonus based on the percentage of vector instructions. A bonus is applied if the vector instructions exceed 50% and half that amount is applied if it exceeds 10%. Note that these bonuses are some what arbitrary and evolved over time by accident as much as because they are principled bonuses. FIXME: It would be nice to base the bonus values on something more scientific. A target may has no bonus on vector instructions.
Definition at line 247 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getInliningCostBenefitAnalysisProfitableMultiplier | ( | ) | const |
Definition at line 228 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getInliningCostBenefitAnalysisSavingsMultiplier | ( | ) | const |
Definition at line 223 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getInliningLastCallToStaticBonus | ( | ) | const |
Definition at line 233 of file TargetTransformInfo.cpp.
Referenced by shouldBeDeferred().
| unsigned TargetTransformInfo::getInliningThresholdMultiplier | ( | ) | const |
TODO: This is a rather blunt instrument. Perhaps altering the costs of individual classes of instructions would be better.
Definition at line 218 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getInsertExtractValueCost | ( | unsigned | Opcode, |
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Definition at line 1141 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::VPRecipeWithIRFlags::getCostForRecipeWithOpcode().
| InstructionCost TargetTransformInfo::getInstructionCost | ( | const User * | U, |
| ArrayRef< const Value * > | Operands, | ||
| TargetCostKind | CostKind | ||
| ) | const |
Estimate the cost of a given IR user when lowered.
This can estimate the cost of either a ConstantExpr or Instruction when lowered.
Operands is a list of operands which can be a result of transformations of the current operands. The number of the operands on the list must equal to the number of the current operands the IR user has. Their order on the list must be the same as the order of the current operands the IR user has.
The returned cost is defined in terms of TargetCostConstants, see its comments for a detailed explanation of the cost values.
Definition at line 273 of file TargetTransformInfo.cpp.
References assert(), CostKind, Operands, and TCK_RecipThroughput.
Referenced by llvm::CodeMetrics::analyzeBasicBlock(), analyzeLoopUnrollCost(), canConvertToFMA(), canSplitCallSite(), llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), checkOuterLoopInsts(), llvm::ComputeSpeculationCost(), computeSpeculationCost(), findBestNonTrivialUnswitchCandidate(), llvm::foldBranchToCommonDest(), llvm::OutlinableRegion::getBenefit(), getCost(), getInstructionCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), getJumpThreadDuplicationCost(), llvm::InstCostVisitor::getLatencySavingsForKnownConstants(), getOutliningBenefit(), llvm::slpvectorizer::BoUpSLP::getTreeCost(), isFoldableInLoop(), isHoistableInstruction(), isLoopSizeWithinBudget(), isMaskedLoadCompress(), mergeConditionalStoreToAddress(), and llvm::SelectionDAGBuilder::shouldKeepJumpConditionsTogether().
|
inline |
This is a helper function which calls the three-argument getInstructionCost with Operands which are the current operands U has.
Definition at line 426 of file TargetTransformInfo.h.
References CostKind, getInstructionCost(), and Operands.
| InstructionCost TargetTransformInfo::getInterleavedMemoryOpCost | ( | unsigned | Opcode, |
| Type * | VecTy, | ||
| unsigned | Factor, | ||
| ArrayRef< unsigned > | Indices, | ||
| Align | Alignment, | ||
| unsigned | AddressSpace, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| bool | UseMaskForCond = false, |
||
| bool | UseMaskForGaps = false |
||
| ) | const |
Opcode is the memory operation code VecTy is the vector type of the interleaved access. Factor is the interleave factor Indices is the indices for interleaved load members (as interleaved load allows gaps) Alignment is the alignment of the memory operation AddressSpace is address space of the pointer. UseMaskForCond indicates if the memory access is predicated. UseMaskForGaps indicates if gaps should be masked. Definition at line 1209 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::VPInterleaveBase::computeCost(), and isMaskedLoadCompress().
| InstructionCost TargetTransformInfo::getIntImmCodeSizeCost | ( | unsigned | Opc, |
| unsigned | Idx, | ||
| const APInt & | Imm, | ||
| Type * | Ty | ||
| ) | const |
Return the expected cost for the given integer when optimising for size.
This is different than the other integer immediate cost functions in that it is subtarget agnostic. This is useful when you e.g. target one ISA such as Aarch32 but smaller encodings could be possible with another such as Thumb. This return value is used as a penalty when the total costs for a constant is calculated (the bigger the cost, the more beneficial constant hoisting is).
Definition at line 721 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getIntImmCost | ( | const APInt & | Imm, |
| Type * | Ty, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Return the expected cost of materializing for the given integer immediate of the specified type.
Definition at line 731 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by tryUnmergingGEPsAcrossIndirectBr().
| InstructionCost TargetTransformInfo::getIntImmCostInst | ( | unsigned | Opc, |
| unsigned | Idx, | ||
| const APInt & | Imm, | ||
| Type * | Ty, | ||
| TTI::TargetCostKind | CostKind, | ||
| Instruction * | Inst = nullptr |
||
| ) | const |
Return the expected cost of materialization for the given integer immediate of the specified type for a given instruction.
The cost can be zero if the immediate can be folded into the specified instruction.
Definition at line 738 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getIntImmCostIntrin | ( | Intrinsic::ID | IID, |
| unsigned | Idx, | ||
| const APInt & | Imm, | ||
| Type * | Ty, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Definition at line 748 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getIntrinsicInstrCost | ( | const IntrinsicCostAttributes & | ICA, |
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Definition at line 1221 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by canConvertToFMA(), llvm::VPInstruction::computeCost(), llvm::VPHistogramRecipe::computeCost(), getCost(), getCostForIntrinsics(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::slpvectorizer::BoUpSLP::getSpillCost(), getVectorCallCosts(), llvm::LoopVectorizationCostModel::getVectorIntrinsicCost(), simplifySwitchOfPowersOfTwo(), and tryToFPToSat().
Definition at line 1359 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getLoadVectorFactor | ( | unsigned | VF, |
| unsigned | LoadSize, | ||
| unsigned | ChainSizeInBytes, | ||
| VectorType * | VecTy | ||
| ) | const |
SizeInBytes loads or has a better vector factor. Definition at line 1392 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getMaskedMemoryOpCost | ( | unsigned | Opcode, |
| Type * | Src, | ||
| Align | Alignment, | ||
| unsigned | AddressSpace, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Definition at line 1172 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), llvm::VPWidenMemoryRecipe::computeCost(), llvm::VPWidenLoadEVLRecipe::computeCost(), llvm::VPWidenStoreEVLRecipe::computeCost(), and isMaskedLoadCompress().
Definition at line 811 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::getMaximumVF().
| unsigned TargetTransformInfo::getMaxInterleaveFactor | ( | ElementCount | VF | ) | const |
Definition at line 880 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isEpilogueVectorizationProfitable(), llvm::LoopVectorizePass::runImpl(), and llvm::LoopVectorizationPlanner::selectInterleaveCount().
| uint64_t TargetTransformInfo::getMaxMemIntrinsicInlineSizeThreshold | ( | ) | const |
Returns the maximum memset / memcpy size in bytes that still makes it profitable to inline the call.
Definition at line 1256 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getMaxNumArgs | ( | ) | const |
Definition at line 1444 of file TargetTransformInfo.cpp.
Referenced by promoteArguments().
| unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead | ( | ) | const |
Definition at line 858 of file TargetTransformInfo.cpp.
| std::optional< unsigned > TargetTransformInfo::getMaxVScale | ( | ) | const |
Definition at line 789 of file TargetTransformInfo.cpp.
Referenced by getMaxVScale().
| InstructionCost TargetTransformInfo::getMemcpyCost | ( | const Instruction * | I | ) | const |
Definition at line 1250 of file TargetTransformInfo.cpp.
| Type * TargetTransformInfo::getMemcpyLoopLoweringType | ( | LLVMContext & | Context, |
| Value * | Length, | ||
| unsigned | SrcAddrSpace, | ||
| unsigned | DestAddrSpace, | ||
| Align | SrcAlign, | ||
| Align | DestAlign, | ||
| std::optional< uint32_t > | AtomicElementSize = std::nullopt |
||
| ) | const |
Definition at line 1312 of file TargetTransformInfo.cpp.
References Context, and llvm::Length.
Referenced by llvm::createMemCpyLoopKnownSize(), createMemMoveLoopKnownSize(), and createMemMoveLoopUnknownSize().
| void TargetTransformInfo::getMemcpyLoopResidualLoweringType | ( | SmallVectorImpl< Type * > & | OpsOut, |
| LLVMContext & | Context, | ||
| unsigned | RemainingBytes, | ||
| unsigned | SrcAddrSpace, | ||
| unsigned | DestAddrSpace, | ||
| Align | SrcAlign, | ||
| Align | DestAlign, | ||
| std::optional< uint32_t > | AtomicCpySize = std::nullopt |
||
| ) | const |
| [out] | OpsOut | The operand types to copy RemainingBytes of memory. |
| RemainingBytes | The number of bytes to copy. |
Calculates the operand types to use when copying RemainingBytes of memory, where source and destination alignments are SrcAlign and DestAlign respectively.
Definition at line 1321 of file TargetTransformInfo.cpp.
References Context.
Referenced by llvm::createMemCpyLoopKnownSize(), and createMemMoveLoopKnownSize().
| InstructionCost TargetTransformInfo::getMemoryOpCost | ( | unsigned | Opcode, |
| Type * | Src, | ||
| Align | Alignment, | ||
| unsigned | AddressSpace, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| TTI::OperandValueInfo | OpInfo = {OK_AnyValue, OP_None}, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Definition at line 1160 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), llvm::VPWidenMemoryRecipe::computeCost(), findCostForOutputBlocks(), and isMaskedLoadCompress().
| ElementCount TargetTransformInfo::getMinimumVF | ( | unsigned | ElemWidth, |
| bool | IsScalable | ||
| ) | const |
Definition at line 806 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getMinMaxReductionCost | ( | Intrinsic::ID | IID, |
| VectorType * | Ty, | ||
| FastMathFlags | FMF = FastMathFlags(), |
||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Definition at line 1269 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::VPReductionRecipe::computeCost(), and llvm::LoopVectorizationCostModel::getReductionPatternCost().
| std::optional< unsigned > TargetTransformInfo::getMinPageSize | ( | ) | const |
Definition at line 842 of file TargetTransformInfo.cpp.
References MinPageSize.
| unsigned TargetTransformInfo::getMinPrefetchStride | ( | unsigned | NumMemAccesses, |
| unsigned | NumStridedMemAccesses, | ||
| unsigned | NumPrefetches, | ||
| bool | HasCall | ||
| ) | const |
Some HW prefetchers can handle accesses up to a certain constant stride.
Sometimes prefetching is beneficial even below the HW prefetcher limit, and the arguments provided are meant to serve as a basis for deciding this for a particular loop.
| NumMemAccesses | Number of memory accesses in the loop. |
| NumStridedMemAccesses | Number of the memory accesses that ScalarEvolution could find a known stride for. |
| NumPrefetches | Number of software prefetches that will be emitted as determined by the addresses involved and the cache line size. |
| HasCall | True if the loop contains a call. |
Definition at line 851 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getMinTripCountTailFoldingThreshold | ( | ) | const |
Definition at line 1462 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::computeMaxVF().
| unsigned TargetTransformInfo::getMinVectorRegisterBitWidth | ( | ) | const |
Definition at line 785 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::BoUpSLP(), and canWidenLoad().
| InstructionCost TargetTransformInfo::getMulAccReductionCost | ( | bool | IsUnsigned, |
| unsigned | RedOpcode, | ||
| Type * | ResTy, | ||
| VectorType * | Ty, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Calculate the cost of an extended reduction pattern, similar to getArithmeticReductionCost of an Add/Sub reduction with multiply and optional extensions.
This is the cost of as:
Definition at line 1285 of file TargetTransformInfo.cpp.
References CostKind.
Referenced by analyzeCostOfVecReduction(), llvm::VPExpressionRecipe::computeCost(), llvm::LoopVectorizationCostModel::getReductionPatternCost(), and tryToMatchAndCreateMulAccumulateReduction().
Definition at line 1237 of file TargetTransformInfo.cpp.
Referenced by getFloorFullVectorNumberOfElements(), getFullVectorNumberOfElements(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::getNumberOfParts(), llvm::hasFullVectorsOrPowerOf2(), and willGenerateVectors().
Definition at line 762 of file TargetTransformInfo.cpp.
Referenced by llvm::VPRegisterUsage::exceedsMaxNumRegs(), llvm::LoopVectorizePass::runImpl(), llvm::SLPVectorizerPass::runImpl(), and llvm::LoopVectorizationPlanner::selectInterleaveCount().
Definition at line 1488 of file TargetTransformInfo.cpp.
References Size.
|
static |
Collect properties of V used in cost analysis, e.g. OP_PowerOf2.
Definition at line 885 of file TargetTransformInfo.cpp.
References llvm::getSplatValue(), I, OK_AnyValue, OK_NonUniformConstantValue, OK_UniformConstantValue, OK_UniformValue, OP_NegatedPowerOf2, OP_None, OP_PowerOf2, and llvm::Splat.
Referenced by llvm::LoopVectorizationCostModel::getDivRemSpeculationCost(), llvm::TargetTransformInfoImplCRTPBase< T >::getInstructionCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::BasicTTIImplBase< T >::getIntrinsicInstrCost(), llvm::AArch64TTIImpl::getIntrinsicInstrCost(), and llvm::VPCostContext::getOperandInfo().
| InstructionCost TargetTransformInfo::getOperandsScalarizationOverhead | ( | ArrayRef< Type * > | Tys, |
| TTI::TargetCostKind | CostKind | ||
| ) | const |
Estimate the overhead of scalarizing operands with the given types.
The (potentially vector) types to use for each of argument are passes via Tys.
Definition at line 639 of file TargetTransformInfo.cpp.
References CostKind.
Referenced by llvm::VPReplicateRecipe::computeCost().
| Value * TargetTransformInfo::getOrCreateResultFromMemIntrinsic | ( | IntrinsicInst * | Inst, |
| Type * | ExpectedType, | ||
| bool | CanCreate = true |
||
| ) | const |
CanCreate is true, new instructions may be created to extract the result from the given intrinsic memory operation. Returns nullptr if the target cannot create a result from the given intrinsic. Definition at line 1306 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getPartialReductionCost | ( | unsigned | Opcode, |
| Type * | InputTypeA, | ||
| Type * | InputTypeB, | ||
| Type * | AccumType, | ||
| ElementCount | VF, | ||
| PartialReductionExtendKind | OpAExtend, | ||
| PartialReductionExtendKind | OpBExtend, | ||
| std::optional< unsigned > | BinOp, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
AccumType and a second vector operand to be accumulated, whose element count is specified by VF. The type of reduction is specified by Opcode. The second operand passed to the intrinsic could be the result of an extend, such as sext or zext. In this case BinOp is nullopt, InputTypeA represents the type being extended and OpAExtend the operation, i.e. sign- or zero-extend. Also, InputTypeB should be nullptr and OpBExtend should be None. Alternatively, the second operand could be the result of a binary operation performed on two extends, i.e. mul(zext i8 a -> i32, zext i8 b -> i32). In this case BinOp may specify the opcode of the binary operation, InputTypeA and InputTypeB the types being extended, and OpAExtend, OpBExtend the form of extensions. An example of an operation that uses a partial reduction is a dot product, which reduces two vectors in binary mul operation to another of 4 times fewer and 4 times larger elements. Definition at line 870 of file TargetTransformInfo.cpp.
References CostKind.
Referenced by llvm::VPPartialReductionRecipe::computeCost().
|
static |
Get the kind of extension that an instruction represents.
Definition at line 1002 of file TargetTransformInfo.cpp.
References I, PR_None, PR_SignExtend, and PR_ZeroExtend.
| void TargetTransformInfo::getPeelingPreferences | ( | Loop * | L, |
| ScalarEvolution & | SE, | ||
| PeelingPreferences & | PP | ||
| ) | const |
Get target-customized preferences for the generic loop peeling transformation.
The caller will initialize PP with the current target-independent defaults with information from L and SE.
Definition at line 408 of file TargetTransformInfo.cpp.
Referenced by llvm::gatherPeelingPreferences().
| InstructionCost TargetTransformInfo::getPointersChainCost | ( | ArrayRef< const Value * > | Ptrs, |
| const Value * | Base, | ||
| const PointersChainInfo & | Info, | ||
| Type * | AccessTy, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
| ) | const |
Estimate the cost of a chain of pointers (typically pointer operands of a chain of loads or stores within same block) operations set when lowered.
AccessTy is the type of the loads/stores that will ultimately use the Ptrs.
Definition at line 257 of file TargetTransformInfo.cpp.
References assert(), llvm::sampleprof::Base, CostKind, and Info.
Referenced by getGEPCosts().
| TargetTransformInfo::PopcntSupportKind TargetTransformInfo::getPopcntSupport | ( | unsigned | IntTyWidthInBit | ) | const |
Return hardware support for population count.
Definition at line 698 of file TargetTransformInfo.cpp.
| std::pair< const Value *, unsigned > TargetTransformInfo::getPredicatedAddrSpace | ( | const Value * | V | ) | const |
Definition at line 346 of file TargetTransformInfo.cpp.
Referenced by findAffectedValues().
| BranchProbability TargetTransformInfo::getPredictableBranchThreshold | ( | ) | const |
If a branch or a select condition is skewed in one direction by more than this factor, it is very likely to be predicted correctly.
Definition at line 282 of file TargetTransformInfo.cpp.
References PredictableBranchThreshold.
Referenced by foldTwoEntryPHINode(), isFormingBranchFromSelectProfitable(), isProfitableToSpeculate(), shouldFoldCondBranchesToCommonDestination(), and SimplifyCondBranchToCondBranch().
| TTI::AddressingModeKind TargetTransformInfo::getPreferredAddressingMode | ( | const Loop * | L, |
| ScalarEvolution * | SE | ||
| ) | const |
Return the preferred addressing mode LSR should make efforts to generate.
Definition at line 464 of file TargetTransformInfo.cpp.
| TargetTransformInfo::ReductionShuffle TargetTransformInfo::getPreferredExpandedReductionShuffle | ( | const IntrinsicInst * | II | ) | const |
Definition at line 1453 of file TargetTransformInfo.cpp.
References II.
| TailFoldingStyle TargetTransformInfo::getPreferredTailFoldingStyle | ( | bool | IVUpdateMayOverflow = true | ) | const |
Query the target what the preferred style of tail folding is.
| IVUpdateMayOverflow | Tells whether it is known if the IV update may (or will never) overflow for the suggested VF/UF in the given loop. Targets can use this information to select a more optimal tail folding style. The value conservatively defaults to true, such that no assumptions are made on overflow. |
Definition at line 374 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::setTailFoldingStyles().
| unsigned TargetTransformInfo::getPrefetchDistance | ( | ) | const |
Definition at line 847 of file TargetTransformInfo.cpp.
| TypeSize TargetTransformInfo::getRegisterBitWidth | ( | TargetTransformInfo::RegisterKind | K | ) | const |
Definition at line 780 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::BoUpSLP(), determineVPlanVF(), llvm::LoopVectorizationPlanner::executePlan(), isMaskedLoadCompress(), and llvm::LoopAccessInfo::LoopAccessInfo().
Definition at line 771 of file TargetTransformInfo.cpp.
References llvm::Vector.
Referenced by llvm::calculateRegisterUsageForPlan(), llvm::LoopVectorizePass::runImpl(), and llvm::SLPVectorizerPass::runImpl().
Definition at line 776 of file TargetTransformInfo.cpp.
Referenced by llvm::calculateRegisterUsageForPlan(), and llvm::LoopVectorizationPlanner::selectInterleaveCount().
Returns the estimated number of registers required to represent Ty.
Definition at line 590 of file TargetTransformInfo.cpp.
Referenced by llvm::calculateRegisterUsageForPlan().
| InstructionCost TargetTransformInfo::getReplicationShuffleCost | ( | Type * | EltTy, |
| int | ReplicationFactor, | ||
| int | VF, | ||
| const APInt & | DemandedDstElts, | ||
| TTI::TargetCostKind | CostKind | ||
| ) | const |
VF elements typed EltTy ReplicationFactor times.For example, the mask for ReplicationFactor=3 and VF=4 is: <0,0,0,1,1,1,2,2,2,3,3,3>
Definition at line 1151 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getScalarizationOverhead | ( | VectorType * | Ty, |
| const APInt & | DemandedElts, | ||
| bool | Insert, | ||
| bool | Extract, | ||
| TTI::TargetCostKind | CostKind, | ||
| bool | ForPoisonSrc = true, |
||
| ArrayRef< Value * > | VL = {} |
||
| ) | const |
Estimate the overhead of scalarizing an instruction.
Insert and Extract are set if the demanded result elements need to be inserted and/or extracted from vectors. The involved values may be passed in VL if Insert is true.
Definition at line 631 of file TargetTransformInfo.cpp.
References CostKind.
Referenced by llvm::VPReplicateRecipe::computeCost(), llvm::LoopVectorizationCostModel::getInstructionCost(), llvm::slpvectorizer::BoUpSLP::getTreeCost(), and llvm::slpvectorizer::BoUpSLP::isTreeTinyAndNotFullyVectorizable().
| InstructionCost TargetTransformInfo::getScalingFactorCost | ( | Type * | Ty, |
| GlobalValue * | BaseGV, | ||
| StackOffset | BaseOffset, | ||
| bool | HasBaseReg, | ||
| int64_t | Scale, | ||
| unsigned | AddrSpace = 0 |
||
| ) | const |
Return the cost of the scaling factor used in the addressing mode represented by AM for this target, for a load/store of the specified type.
If the AM is supported, the return value must be >= 0. If the AM is not supported, it returns a negative value. TODO: Handle pre/postinc as well.
Definition at line 563 of file TargetTransformInfo.cpp.
References assert().
Referenced by getScalingFactorCost().
| InstructionCost TargetTransformInfo::getShuffleCost | ( | ShuffleKind | Kind, |
| VectorType * | DstTy, | ||
| VectorType * | SrcTy, | ||
| ArrayRef< int > | Mask = {}, |
||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| int | Index = 0, |
||
| VectorType * | SubTp = nullptr, |
||
| ArrayRef< const Value * > | Args = {}, |
||
| const Instruction * | CxtI = nullptr |
||
| ) | const |
Args, which helps improve the cost estimation in some cases, like in broadcast loads. Definition at line 986 of file TargetTransformInfo.cpp.
References assert(), CostKind, llvm::VectorType::getElementCount(), llvm::details::FixedOrScalableQuantity< LeafTy, ValueTy >::getKnownMinValue(), llvm::Type::getScalarType(), and llvm::Type::isScalableTy().
Referenced by llvm::VPInstruction::computeCost(), llvm::VPInterleaveBase::computeCost(), llvm::VPWidenMemoryRecipe::computeCost(), llvm::VPWidenLoadEVLRecipe::computeCost(), llvm::VPWidenStoreEVLRecipe::computeCost(), costShuffleViaSplitting(), costShuffleViaVRegSplitting(), llvm::LoopVectorizationCostModel::getInstructionCost(), and isFreeConcat().
| unsigned TargetTransformInfo::getStoreMinimumVF | ( | unsigned | VF, |
| Type * | ScalarMemTy, | ||
| Type * | ScalarValTy | ||
| ) | const |
| VF | Initial estimation of the minimum vector factor. |
| ScalarMemTy | Scalar memory type of the store operation. |
| ScalarValTy | Scalar type of the stored value. Currently only used by the SLP vectorizer. |
Definition at line 816 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getStoreVectorFactor | ( | unsigned | VF, |
| unsigned | StoreSize, | ||
| unsigned | ChainSizeInBytes, | ||
| VectorType * | VecTy | ||
| ) | const |
SizeInBytes stores or has a better vector factor. Definition at line 1399 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getStridedMemoryOpCost | ( | unsigned | Opcode, |
| Type * | DataTy, | ||
| const Value * | Ptr, | ||
| bool | VariableMask, | ||
| Align | Alignment, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
Opcode - is a type of memory access Load or Store DataTy - a vector type of the data to be loaded or stored Ptr - pointer [or vector of pointers] - address[es] in memory VariableMask - true when the memory access is predicated with a mask that is not a compile-time constant Alignment - alignment of single element I - the optional original context instruction, if one exists, e.g. the load/store to transform or the call to the gather/scatter intrinsic Definition at line 1200 of file TargetTransformInfo.cpp.
References assert(), CostKind, I, and Ptr.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads().
| bool TargetTransformInfo::getTgtMemIntrinsic | ( | IntrinsicInst * | Inst, |
| MemIntrinsicInfo & | Info | ||
| ) | const |
Definition at line 1297 of file TargetTransformInfo.cpp.
References Info.
Referenced by getAccessType(), and isAddressUse().
| void TargetTransformInfo::getUnrollingPreferences | ( | Loop * | L, |
| ScalarEvolution & | SE, | ||
| UnrollingPreferences & | UP, | ||
| OptimizationRemarkEmitter * | ORE | ||
| ) | const |
Get target-customized preferences for the generic loop unrolling transformation.
The caller will initialize UP with the current target-independent defaults.
Definition at line 402 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationPlanner::executePlan(), and llvm::gatherUnrollingPreferences().
| InstructionCost TargetTransformInfo::getVectorInstrCost | ( | const Instruction & | I, |
| Type * | Val, | ||
| TTI::TargetCostKind | CostKind, | ||
| unsigned | Index = -1 |
||
| ) | const |
A typical suitable use case is cost estimation when vector instruction exists (e.g., from basic blocks during transformation).
Definition at line 1121 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getVectorInstrCost | ( | unsigned | Opcode, |
| Type * | Val, | ||
| TTI::TargetCostKind | CostKind, | ||
| unsigned | Index, | ||
| Value * | Scalar, | ||
| ArrayRef< std::tuple< Value *, User *, int > > | ScalarUserAndIdx | ||
| ) | const |
| ScalarUserAndIdx | encodes the information about extracts from a vector with 'Scalar' being the value being extracted,'User' being the user of the extract(nullptr if user is not known before vectorization) and 'Idx' being the extract lane. |
Definition at line 1107 of file TargetTransformInfo.cpp.
| InstructionCost TargetTransformInfo::getVectorInstrCost | ( | unsigned | Opcode, |
| Type * | Val, | ||
| TTI::TargetCostKind | CostKind, | ||
| unsigned | Index = -1, |
||
| const Value * | Op0 = nullptr, |
||
| const Value * | Op1 = nullptr |
||
| ) | const |
Definition at line 1095 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by llvm::VPInstruction::computeCost(), llvm::slpvectorizer::BoUpSLP::getReorderingData(), getVectorInstrCost(), and isMaskedLoadCompress().
| TargetTransformInfo::VPLegalization TargetTransformInfo::getVPLegalizationStrategy | ( | const VPIntrinsic & | PI | ) | const |
Definition at line 1428 of file TargetTransformInfo.cpp.
| LLVM_ABI InstructionCost llvm::TargetTransformInfo::getVPMemoryOpCost | ( | unsigned | Opcode, |
| Type * | Src, | ||
| Align | Alignment, | ||
| unsigned | AddressSpace, | ||
| TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput, |
||
| const Instruction * | I = nullptr |
||
| ) | const |
| std::optional< unsigned > TargetTransformInfo::getVScaleForTuning | ( | ) | const |
Definition at line 793 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::hasActiveVectorLength | ( | ) | const |
Definition at line 1474 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::setTailFoldingStyles().
Used by the LowerTypeTests pass, which constructs an IR inline assembler node containing a jump table in a format suitable for the target, so it needs to know what format of jump table it can legally use.
For non-Arm targets, this function isn't used. It defaults to returning false, but it shouldn't matter what it returns anyway.
Definition at line 1432 of file TargetTransformInfo.cpp.
Return true if branch divergence exists.
Branch divergence has a significantly negative impact on GPU performance when threads in the same wavefront take different paths due to conditional branches.
If F is passed, provides a context function. If F is known to only execute in a single threaded environment, the target may choose to skip uniformity analysis and assume all values are uniform.
Definition at line 292 of file TargetTransformInfo.cpp.
References F.
Referenced by llvm::LoopVectorizationCostModel::computeMaxVF(), llvm::UniformityInfoAnalysis::run(), llvm::JumpThreadingPass::run(), llvm::MachineUniformityAnalysis::run(), runImpl(), llvm::SpeculativeExecutionPass::runImpl(), and unswitchLoop().
Definition at line 766 of file TargetTransformInfo.cpp.
Referenced by isSafeCheapLoadStore().
Return true if the target has a unified operation to calculate division and remainder.
If so, the additional implicit multiplication and subtraction required to calculate a remainder from division are free. This can enable more aggressive transformations for division and remainder than would typically be allowed using throughput or size cost models.
Definition at line 550 of file TargetTransformInfo.cpp.
Referenced by optimizeDivRem().
| bool TargetTransformInfo::hasVolatileVariant | ( | Instruction * | I, |
| unsigned | AddrSpace | ||
| ) | const |
Return true if the given instruction (assumed to be a memory access instruction) has a volatile variant.
If that's the case then we can avoid addrspacecast to generic AS for volatile loads/stores. Default implementation returns false, which prevents address space inference for volatile loads/stores.
Definition at line 554 of file TargetTransformInfo.cpp.
References I.
Referenced by replaceSimplePointerUse().
Return true if the hardware has a fast square-root instruction.
Definition at line 702 of file TargetTransformInfo.cpp.
Referenced by foldSqrt(), and runPartiallyInlineLibCalls().
| std::optional< Instruction * > TargetTransformInfo::instCombineIntrinsic | ( | InstCombiner & | IC, |
| IntrinsicInst & | II | ||
| ) | const |
Targets can implement their own combinations for target-specific intrinsics.
This function will be called from the InstCombine pass every time a target-specific intrinsic is encountered.
Definition at line 380 of file TargetTransformInfo.cpp.
References II.
Referenced by llvm::InstCombiner::targetInstCombineIntrinsic().
|
inline |
Handle the invalidation of this information.
When used as a result of TargetIRAnalysis this method will be called when the function this was computed for changes. When it returns false, the information is preserved across those changes.
Definition at line 255 of file TargetTransformInfo.h.
Definition at line 304 of file TargetTransformInfo.cpp.
Referenced by llvm::GenericUniformityAnalysisImpl< ContextT >::initialize().
Definition at line 1388 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isExpensiveToSpeculativelyExecute | ( | const Instruction * | I | ) | const |
Return true if the cost of the instruction is too high to speculatively execute and should be kept behind a branch.
This normally just wraps around a getInstructionCost() call, but some targets might report a low TCK_SizeAndLatency value that is incompatible with the fixed TCC_Expensive value. NOTE: This assumes the instruction passes isSafeToSpeculativelyExecute().
Definition at line 706 of file TargetTransformInfo.cpp.
References I.
Referenced by sinkSelectOperand().
Return true if it is faster to check if a floating-point value is NaN (or not-NaN) versus a comparison against a constant FP zero value.
Targets should override this if materializing a 0.0 for comparison is generally as cheap as checking for ordered/unordered.
Definition at line 711 of file TargetTransformInfo.cpp.
Referenced by optimizeSQRT().
| bool TargetTransformInfo::isFPVectorizationPotentiallyUnsafe | ( | ) | const |
Indicate that it is potentially unsafe to automatically vectorize floating-point operations because the semantics of vector and scalar floating-point semantics may differ.
For example, ARM NEON v7 SIMD math does not support IEEE-754 denormal numbers, while depending on the platform, scalar floating-point math does. This applies to floating-point math operations and calls, not memory operations, shuffles, or casts.
Definition at line 683 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::processLoop().
| bool TargetTransformInfo::isHardwareLoopProfitable | ( | Loop * | L, |
| ScalarEvolution & | SE, | ||
| AssumptionCache & | AC, | ||
| TargetLibraryInfo * | LibInfo, | ||
| HardwareLoopInfo & | HWLoopInfo | ||
| ) | const |
Query the target whether it would be profitable to convert the given loop into a hardware loop.
Definition at line 359 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isIndexedLoadLegal | ( | enum MemIndexedMode | Mode, |
| Type * | Ty | ||
| ) | const |
Definition at line 1349 of file TargetTransformInfo.cpp.
Referenced by canHoistIVInc(), and mayUsePostIncMode().
| bool TargetTransformInfo::isIndexedStoreLegal | ( | enum MemIndexedMode | Mode, |
| Type * | Ty | ||
| ) | const |
Definition at line 1354 of file TargetTransformInfo.cpp.
Referenced by canHoistIVInc(), and mayUsePostIncMode().
| bool TargetTransformInfo::isLegalAddImmediate | ( | int64_t | Imm | ) | const |
Return true if the specified immediate is legal add immediate, that is the target has add instructions which can add a register with the immediate without having to materialize the immediate into a register.
Definition at line 413 of file TargetTransformInfo.cpp.
Referenced by isLegalAddImmediate().
| bool TargetTransformInfo::isLegalAddressingMode | ( | Type * | Ty, |
| GlobalValue * | BaseGV, | ||
| int64_t | BaseOffset, | ||
| bool | HasBaseReg, | ||
| int64_t | Scale, | ||
| unsigned | AddrSpace = 0, |
||
| Instruction * | I = nullptr, |
||
| int64_t | ScalableOffset = 0 |
||
| ) | const |
Return true if the addressing mode represented by AM is legal for this target, for a load/store of the specified type.
The type may be VoidTy, in which case only return true if the addressing mode is legal for a load/store of any legal type. If target returns true in LSRWithInstrQueries(), I may be valid.
| ScalableOffset | represents a quantity of bytes multiplied by vscale, an invariant value known only at runtime. Most targets should not accept a scalable offset. |
TODO: Handle pre/postinc as well.
Definition at line 425 of file TargetTransformInfo.cpp.
References I.
Referenced by isAddFoldable(), isAMCompletelyFolded(), and IsSimplerBaseSCEVForTarget().
| bool TargetTransformInfo::isLegalAddScalableImmediate | ( | int64_t | Imm | ) | const |
Return true if adding the specified scalable immediate is legal, that is the target has add instructions which can add a register with the immediate (multiplied by vscale) without having to materialize the immediate into a register.
Definition at line 417 of file TargetTransformInfo.cpp.
Referenced by isLegalAddImmediate().
| bool TargetTransformInfo::isLegalAltInstr | ( | VectorType * | VecTy, |
| unsigned | Opcode0, | ||
| unsigned | Opcode1, | ||
| const SmallBitVector & | OpcodeMask | ||
| ) | const |
Return true if this is an alternating opcode pattern that can be lowered to a single instruction on the target.
In X86 this is for the addsub instruction which corrsponds to a Shuffle + Fadd + FSub pattern in IR. This function expectes two opcodes: Opcode1 and Opcode2 being selected by OpcodeMask. The mask contains one bit per lane and is a 0 when Opcode0 is selected and 1 when Opcode1 is selected. VecTy is the vector type of the instruction to be generated.
Definition at line 498 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalBroadcastLoad | ( | Type * | ElementTy, |
| ElementCount | NumElements | ||
| ) | const |
\Returns true if the target supports broadcasting a load to a vector of type <NumElements x ElementTy>.
Definition at line 488 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalICmpImmediate | ( | int64_t | Imm | ) | const |
Return true if the specified immediate is legal icmp immediate, that is the target has icmp instructions which can compare a register against the immediate without having to materialize the immediate into a register.
Definition at line 421 of file TargetTransformInfo.cpp.
Referenced by isAMCompletelyFolded().
| bool TargetTransformInfo::isLegalInterleavedAccessType | ( | VectorType * | VTy, |
| unsigned | Factor, | ||
| Align | Alignment, | ||
| unsigned | AddrSpace | ||
| ) | const |
Return true is the target supports interleaved access for the given vector type VTy, interleave factor Factor, alignment Alignment and address space AddrSpace.
Definition at line 534 of file TargetTransformInfo.cpp.
Referenced by isMaskedLoadCompress().
Return true if the target supports masked compress store.
Definition at line 519 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
Return true if the target supports masked expand load.
Definition at line 524 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
Return true if the target supports masked gather.
Definition at line 493 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), llvm::LoopVectorizationCostModel::isLegalGatherOrScatter(), llvm::LoopVectorizationCostModel::isScalarWithPredication(), and optimizeCallInst().
| bool TargetTransformInfo::isLegalMaskedLoad | ( | Type * | DataType, |
| Align | Alignment, | ||
| unsigned | AddressSpace | ||
| ) | const |
Return true if the target supports masked load.
Definition at line 474 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::interleavedAccessCanBeWidened(), llvm::LoopVectorizationCostModel::isLegalMaskedLoad(), isMaskedLoadCompress(), and optimizeCallInst().
Return true if the target supports masked scatter.
Definition at line 504 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isLegalGatherOrScatter(), llvm::LoopVectorizationCostModel::isScalarWithPredication(), and optimizeCallInst().
| bool TargetTransformInfo::isLegalMaskedStore | ( | Type * | DataType, |
| Align | Alignment, | ||
| unsigned | AddressSpace | ||
| ) | const |
Return true if the target supports masked store.
Definition at line 469 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::interleavedAccessCanBeWidened(), llvm::LoopVectorizationCostModel::isLegalMaskedStore(), and optimizeCallInst().
Definition at line 541 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
Return true if the target supports nontemporal load.
Definition at line 484 of file TargetTransformInfo.cpp.
Return true if the target supports nontemporal store.
Definition at line 479 of file TargetTransformInfo.cpp.
Return true if the target supports strided load.
Definition at line 529 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), and isStridedLoad().
Definition at line 1363 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalToVectorizeLoadChain | ( | unsigned | ChainSizeInBytes, |
| Align | Alignment, | ||
| unsigned | AddrSpace | ||
| ) | const |
Definition at line 1371 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalToVectorizeReduction | ( | const RecurrenceDescriptor & | RdxDesc, |
| ElementCount | VF | ||
| ) | const |
Definition at line 1383 of file TargetTransformInfo.cpp.
Definition at line 1367 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalToVectorizeStoreChain | ( | unsigned | ChainSizeInBytes, |
| Align | Alignment, | ||
| unsigned | AddrSpace | ||
| ) | const |
Definition at line 1377 of file TargetTransformInfo.cpp.
Test whether calls to a function lower to actual program function calls.
The idea is to test whether the program is likely to require a 'call' instruction or equivalent in order to call the given function.
FIXME: It's not clear that this is a good or useful query API. Client's should probably move to simpler cost metrics using the above. Alternatively, we could split the cost interface into distinct code-size and execution-speed costs. This would allow modelling the core of this query more accurately as a call is a single small instruction, but incurs significant execution cost.
Definition at line 355 of file TargetTransformInfo.cpp.
References F.
Referenced by llvm::CodeMetrics::analyzeBasicBlock(), analyzeLoopUnrollCost(), and runCGProfilePass().
| bool TargetTransformInfo::isLSRCostLess | ( | const TargetTransformInfo::LSRCost & | C1, |
| const TargetTransformInfo::LSRCost & | C2 | ||
| ) | const |
Return true if LSR cost of C1 is lower than C2.
Definition at line 435 of file TargetTransformInfo.cpp.
Returns true if this is an instance of a function with multiple versions.
Definition at line 1440 of file TargetTransformInfo.cpp.
References F.
Referenced by collectVersions(), and OptimizeNonTrivialIFuncs().
Definition at line 327 of file TargetTransformInfo.cpp.
Referenced by isNoopPtrIntCastPair().
| bool TargetTransformInfo::isNumRegsMajorCostOfLSR | ( | ) | const |
Return true if LSR major cost is number of registers.
Targets which implement their own isLSRCostLess and unset number of registers as major cost should return false, otherwise return true.
Definition at line 440 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isProfitableLSRChainElement | ( | Instruction * | I | ) | const |
I. Definition at line 448 of file TargetTransformInfo.cpp.
References I.
Referenced by isProfitableChain().
| bool TargetTransformInfo::isProfitableToHoist | ( | Instruction * | I | ) | const |
Return true if it is profitable to hoist instruction in the then/else to before if.
Definition at line 580 of file TargetTransformInfo.cpp.
References I.
Referenced by shouldHoistCommonInstructions().
| bool TargetTransformInfo::isProfitableToSinkOperands | ( | Instruction * | I, |
| SmallVectorImpl< Use * > & | Ops | ||
| ) | const |
Return true if sinking I's operands to the same basic block as I is profitable, e.g.
because the operands can be folded into a target instruction during instruction selection. After calling the function Ops contains the Uses to sink ordered by dominance (dominating users come first).
Definition at line 1478 of file TargetTransformInfo.cpp.
References I.
| bool TargetTransformInfo::isSingleThreaded | ( | ) | const |
Definition at line 341 of file TargetTransformInfo.cpp.
Returns whether V is a source of divergence.
This function provides the target-dependent information for the target-independent UniformityAnalysis.
Definition at line 296 of file TargetTransformInfo.cpp.
Referenced by llvm::GenericUniformityAnalysisImpl< ContextT >::initialize().
| bool TargetTransformInfo::isTargetIntrinsicTriviallyScalarizable | ( | Intrinsic::ID | ID | ) | const |
Definition at line 611 of file TargetTransformInfo.cpp.
Referenced by llvm::isTriviallyScalarizable().
| bool TargetTransformInfo::isTargetIntrinsicWithOverloadTypeAtArg | ( | Intrinsic::ID | ID, |
| int | OpdIdx | ||
| ) | const |
Identifies if the vector form of the intrinsic is overloaded on the type of the operand at index OpdIdx, or on the return type if OpdIdx is -1.
Definition at line 621 of file TargetTransformInfo.cpp.
Referenced by llvm::isVectorIntrinsicWithOverloadTypeAtArg().
| bool TargetTransformInfo::isTargetIntrinsicWithScalarOpAtArg | ( | Intrinsic::ID | ID, |
| unsigned | ScalarOpdIdx | ||
| ) | const |
Identifies if the vector form of the intrinsic has a scalar operand.
Definition at line 616 of file TargetTransformInfo.cpp.
Referenced by llvm::isVectorIntrinsicWithScalarOpAtArg().
| bool TargetTransformInfo::isTargetIntrinsicWithStructReturnOverloadAtField | ( | Intrinsic::ID | ID, |
| int | RetIdx | ||
| ) | const |
Identifies if the vector form of the intrinsic that returns a struct is overloaded at the struct element index RetIdx.
Definition at line 626 of file TargetTransformInfo.cpp.
Referenced by llvm::isVectorIntrinsicWithStructReturnOverloadAtField().
Return true if it's free to truncate a value of type Ty1 to type Ty2.
e.g. On x86 it's free to truncate a i32 value in register EAX to i16 by referencing its sub-register AX.
Definition at line 576 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isOptimizableIVTruncate(), and llvm::SCEVExpander::replaceCongruentIVs().
Return true if this type is legal.
Definition at line 586 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::canVectorizeLoads(), llvm::computeMinimumValueSizes(), foldConsecutiveLoads(), isLoadCombineCandidateImpl(), isTypeLegalForLookupTable(), and mergeConsecutivePartStores().
Query the target whether the specified address space cast from FromAS to ToAS is valid.
Definition at line 308 of file TargetTransformInfo.cpp.
Referenced by llvm::expandMemMoveAsLoop(), llvm::InstCombiner::isValidAddrSpaceCast(), and tryInsertCastToCommonAddrSpace().
Return true if it's significantly cheaper to shift a vector by a uniform scalar than by an amount which will vary across each lane.
On x86 before AVX2 for example, there is a "psllw" instruction for the former case, but no simple instruction for a general "a << b" operation on vectors. This should also apply to lowering for vector funnel shifts (rotates).
Definition at line 1483 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isVScaleKnownToBeAPowerOfTwo | ( | ) | const |
Definition at line 797 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationPlanner::addMinimumIterationCheck(), llvm::LoopVectorizationCostModel::computeMaxVF(), and llvm::EpilogueVectorizerMainLoop::createIterationCountCheck().
| bool TargetTransformInfo::LSRWithInstrQueries | ( | ) | const |
Return true if the loop strength reduce pass should make Instruction* based TTI queries to isLegalAddressingMode().
This is needed on SystemZ, where e.g. a memcpy can only have a 12 bit unsigned immediate offset and no index register.
Definition at line 572 of file TargetTransformInfo.cpp.
Referenced by isAMCompletelyFolded().
| TargetTransformInfo & TargetTransformInfo::operator= | ( | TargetTransformInfo && | RHS | ) |
Definition at line 213 of file TargetTransformInfo.cpp.
References RHS.
| bool TargetTransformInfo::preferAlternateOpcodeVectorization | ( | ) | const |
Definition at line 1415 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::preferEpilogueVectorization | ( | ) | const |
Return true if the loop vectorizer should consider vectorizing an otherwise scalar epilogue loop.
Definition at line 1423 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isEpilogueVectorizationProfitable().
| bool TargetTransformInfo::preferFixedOverScalableIfEqualCost | ( | ) | const |
Definition at line 1406 of file TargetTransformInfo.cpp.
Kind to be performed in the loop. Definition at line 1410 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::collectElementTypesForWidening(), and llvm::LoopVectorizationCostModel::collectInLoopReductions().
| bool TargetTransformInfo::preferPredicatedReductionSelect | ( | ) | const |
As opposed to the normal scheme of p = phi (0, a) which allows the select to be pulled out of the loop. If the select(.., add, ..) can be predicated by the target, this can lead to cleaner code generation.
Definition at line 1419 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::usePredicatedReductionSelect().
| bool TargetTransformInfo::preferPredicateOverEpilogue | ( | TailFoldingInfo * | TFI | ) | const |
Query the target whether it would be prefered to create a predicated vector loop, which can avoid the need to emit a scalar epilogue loop.
Definition at line 369 of file TargetTransformInfo.cpp.
Referenced by getScalarEpilogueLowering().
| bool TargetTransformInfo::prefersVectorizedAddressing | ( | ) | const |
Return true if target doesn't mind addresses in vectors.
Definition at line 559 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::setCostBasedWideningDecision().
| bool TargetTransformInfo::preferToKeepConstantsAttached | ( | const Instruction & | Inst, |
| const Function & | Fn | ||
| ) | const |
It can be advantageous to detach complex constants from their uses to make their generation cheaper.
This hook allows targets to report when such transformations might negatively effect the code generation of the underlying operation. The motivating example is divides whereby hoisting constants prevents the code generator's ability to transform them into combinations of simpler operations.
Definition at line 757 of file TargetTransformInfo.cpp.
|
inlinestatic |
A helper function to determine the type of reduction algorithm used for a given Opcode and set of FastMathFlags FMF.
Definition at line 1613 of file TargetTransformInfo.h.
Referenced by llvm::BasicTTIImplBase< T >::getArithmeticReductionCost(), llvm::AArch64TTIImpl::getArithmeticReductionCost(), llvm::GCNTTIImpl::getArithmeticReductionCost(), llvm::RISCVTTIImpl::getArithmeticReductionCost(), llvm::SystemZTTIImpl::getArithmeticReductionCost(), llvm::X86TTIImpl::getArithmeticReductionCost(), and llvm::ARMTTIImpl::getArithmeticReductionCost().
| Value * TargetTransformInfo::rewriteIntrinsicWithAddressSpace | ( | IntrinsicInst * | II, |
| Value * | OldV, | ||
| Value * | NewV | ||
| ) | const |
Rewrite intrinsic call II such that OldV will be replaced with NewV, which has a different address space.
This should happen for every operand index that collectFlatAddressOperands returned for the intrinsic.
II with modified operands). Definition at line 350 of file TargetTransformInfo.cpp.
References II.
| bool TargetTransformInfo::shouldBuildLookupTables | ( | ) | const |
Return true if switches should be turned into lookup tables for the target.
Definition at line 594 of file TargetTransformInfo.cpp.
Referenced by simplifySwitchLookup().
Return true if switches should be turned into lookup tables containing this constant value for the target.
Definition at line 598 of file TargetTransformInfo.cpp.
References llvm::CallingConv::C.
Referenced by validLookupTableConstant().
| bool TargetTransformInfo::shouldBuildRelLookupTables | ( | ) | const |
Return true if lookup tables should be turned into relative lookup tables.
Definition at line 603 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::shouldConsiderAddressTypePromotion | ( | const Instruction & | I, |
| bool & | AllowPromotionWithoutCommonHeader | ||
| ) | const |
AllowPromotionWithoutCommonHeader Set true if promoting I is profitable without finding other extensions fed by the same input. Definition at line 821 of file TargetTransformInfo.cpp.
References I.
| bool TargetTransformInfo::shouldDropLSRSolutionIfLessProfitable | ( | ) | const |
Return true if LSR should drop a found solution if it's calculated to be less profitable than the baseline.
Definition at line 444 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::shouldExpandReduction | ( | const IntrinsicInst * | II | ) | const |
Definition at line 1448 of file TargetTransformInfo.cpp.
References II.
| bool TargetTransformInfo::shouldMaximizeVectorBandwidth | ( | TargetTransformInfo::RegisterKind | K | ) | const |
K Register Kind for vectorization. Definition at line 801 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::useMaxBandwidth().
AS. Definition at line 866 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::shouldTreatInstructionLikeSelect | ( | const Instruction * | I | ) | const |
Should the Select Optimization pass treat the given instruction like a select, potentially converting it to a conditional branch.
This can include select-like instructions like or(zext(c), x) that can be converted to selects.
Definition at line 670 of file TargetTransformInfo.cpp.
References I.
| std::optional< Value * > TargetTransformInfo::simplifyDemandedUseBitsIntrinsic | ( | InstCombiner & | IC, |
| IntrinsicInst & | II, | ||
| APInt | DemandedMask, | ||
| KnownBits & | Known, | ||
| bool & | KnownBitsComputed | ||
| ) | const |
Can be used to implement target-specific instruction combining.
Definition at line 385 of file TargetTransformInfo.cpp.
References II.
Referenced by llvm::InstCombiner::targetSimplifyDemandedUseBitsIntrinsic().
| std::optional< Value * > TargetTransformInfo::simplifyDemandedVectorEltsIntrinsic | ( | InstCombiner & | IC, |
| IntrinsicInst & | II, | ||
| APInt | DemandedElts, | ||
| APInt & | UndefElts, | ||
| APInt & | UndefElts2, | ||
| APInt & | UndefElts3, | ||
| std::function< void(Instruction *, unsigned, APInt, APInt &)> | SimplifyAndSetOp | ||
| ) | const |
Can be used to implement target-specific instruction combining.
Definition at line 392 of file TargetTransformInfo.cpp.
References II.
Referenced by llvm::InstCombiner::targetSimplifyDemandedVectorEltsIntrinsic().
| bool TargetTransformInfo::supportsEfficientVectorElementLoadStore | ( | ) | const |
If target has efficient vector element load/store instructions, it can return true here so that insertion/extraction costs are not added to the scalarization cost of a load/store.
Definition at line 644 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::supportsScalableVectors | ( | ) | const |
Definition at line 1466 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::LoopVectorizationCostModel(), and llvm::LoopVectorizationPlanner::planInVPlanNativePath().
If target supports tail call on CB.
Definition at line 652 of file TargetTransformInfo.cpp.
Referenced by llvm::coro::BaseCloner::create(), and llvm::coro::createMustTailCall().
| bool TargetTransformInfo::supportsTailCalls | ( | ) | const |
If the target supports tail calls.
Definition at line 648 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::useAA | ( | ) | const |
Definition at line 584 of file TargetTransformInfo.cpp.
Return true if the input function which is cold at all call sites, should use coldcc calling convention.
Definition at line 607 of file TargetTransformInfo.cpp.
References F.
Referenced by OptimizeFunctions().
1.9.6