LLVM
15.0.0git
|
This pass provides access to the codegen interfaces that are needed for IR-level transformations. More...
#include "llvm/Analysis/TargetTransformInfo.h"
Classes | |
class | Concept |
struct | LSRCost |
struct | MemCmpExpansionOptions |
Returns options for expansion of memcmp. IsZeroCmp is. More... | |
struct | PeelingPreferences |
struct | ReductionFlags |
Flags describing the kind of vector reduction. More... | |
struct | UnrollingPreferences |
Parameters that control the generic loop unrolling transformation. More... | |
struct | VPLegalization |
Public Member Functions | |
template<typename T > | |
TargetTransformInfo (T Impl) | |
Construct a TTI object using a type implementing the Concept API below. More... | |
TargetTransformInfo (const DataLayout &DL) | |
Construct a baseline TTI object using a minimal implementation of the Concept API below. More... | |
TargetTransformInfo (TargetTransformInfo &&Arg) | |
TargetTransformInfo & | operator= (TargetTransformInfo &&RHS) |
~TargetTransformInfo () | |
bool | invalidate (Function &, const PreservedAnalyses &, FunctionAnalysisManager::Invalidator &) |
Handle the invalidation of this information. More... | |
Vector Predication Information | |
Whether the target supports the evl parameter of VP intrinsic efficiently in hardware, for the given opcode and type/alignment. (see LLVM Language Reference - "Vector Predication Intrinsics"). Use of evl is discouraged when that is not the case. | |
bool | hasActiveVectorLength (unsigned Opcode, Type *DataType, Align Alignment) const |
VPLegalization | getVPLegalizationStrategy (const VPIntrinsic &PI) const |
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... | |
InstructionCost | getInstructionCost (const Instruction *I, enum TargetCostKind kind) const |
Query the cost of a specified instruction. More... | |
InstructionCost | getGEPCost (Type *PointeeType, const Value *Ptr, ArrayRef< const Value * > Operands, TargetCostKind CostKind=TCK_SizeAndLatency) const |
Estimate the cost of a GEP operation when lowered. More... | |
unsigned | getInliningThresholdMultiplier () const |
unsigned | adjustInliningThreshold (const CallBase *CB) const |
int | getInlinerVectorBonusPercent () const |
InstructionCost | getMemcpyCost (const Instruction *I) const |
unsigned | getEstimatedNumberOfCaseClusters (const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI) const |
InstructionCost | getUserCost (const User *U, ArrayRef< const Value * > Operands, TargetCostKind CostKind) const |
Estimate the cost of a given IR user when lowered. More... | |
InstructionCost | getUserCost (const User *U, TargetCostKind CostKind) const |
This is a helper function which calls the two-argument getUserCost with Operands which are the current operands U has. More... | |
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. More... | |
bool | hasBranchDivergence () const |
Return true if branch divergence exists. More... | |
bool | useGPUDivergenceAnalysis () const |
Return true if the target prefers to use GPU divergence analysis to replace the legacy version. More... | |
bool | isSourceOfDivergence (const Value *V) const |
Returns whether V is a source of divergence. More... | |
bool | isAlwaysUniform (const Value *V) const |
unsigned | getFlatAddressSpace () const |
Returns the address space ID for a target's 'flat' address space. More... | |
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. More... | |
bool | isNoopAddrSpaceCast (unsigned FromAS, unsigned ToAS) const |
bool | canHaveNonUndefGlobalInitializerInAddressSpace (unsigned AS) const |
Return true if globals in this address space can have initializers other than undef . More... | |
unsigned | getAssumedAddrSpace (const Value *V) const |
std::pair< const Value *, unsigned > | getPredicatedAddrSpace (const Value *V) const |
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. More... | |
bool | isLoweredToCall (const Function *F) const |
Test whether calls to a function lower to actual program function calls. More... | |
void | getUnrollingPreferences (Loop *L, ScalarEvolution &, UnrollingPreferences &UP, OptimizationRemarkEmitter *ORE) const |
Get target-customized preferences for the generic loop unrolling transformation. More... | |
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. More... | |
bool | preferPredicateOverEpilogue (Loop *L, LoopInfo *LI, ScalarEvolution &SE, AssumptionCache &AC, TargetLibraryInfo *TLI, DominatorTree *DT, const LoopAccessInfo *LAI) 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. More... | |
bool | emitGetActiveLaneMask () const |
Query the target whether lowering of the llvm.get.active.lane.mask intrinsic is supported. More... | |
void | getPeelingPreferences (Loop *L, ScalarEvolution &SE, PeelingPreferences &PP) const |
Get target-customized preferences for the generic loop peeling transformation. More... | |
Optional< Instruction * > | instCombineIntrinsic (InstCombiner &IC, IntrinsicInst &II) const |
Targets can implement their own combinations for target-specific intrinsics. More... | |
Optional< Value * > | simplifyDemandedUseBitsIntrinsic (InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, KnownBits &Known, bool &KnownBitsComputed) const |
Can be used to implement target-specific instruction combining. More... | |
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. More... | |
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 } |
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. More... | |
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. More... | |
bool | isLegalAddressingMode (Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace=0, Instruction *I=nullptr) const |
Return true if the addressing mode represented by AM is legal for this target, for a load/store of the specified type. More... | |
bool | isLSRCostLess (const TargetTransformInfo::LSRCost &C1, const TargetTransformInfo::LSRCost &C2) const |
Return true if LSR cost of C1 is lower than C1. More... | |
bool | isNumRegsMajorCostOfLSR () const |
Return true if LSR major cost is number of registers. More... | |
bool | isProfitableLSRChainElement (Instruction *I) const |
bool | canMacroFuseCmp () const |
Return true if the target can fuse a compare and branch. More... | |
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. More... | |
AddressingModeKind | getPreferredAddressingMode (const Loop *L, ScalarEvolution *SE) const |
Return the preferred addressing mode LSR should make efforts to generate. More... | |
bool | isLegalMaskedStore (Type *DataType, Align Alignment) const |
Return true if the target supports masked store. More... | |
bool | isLegalMaskedLoad (Type *DataType, Align Alignment) const |
Return true if the target supports masked load. More... | |
bool | isLegalNTStore (Type *DataType, Align Alignment) const |
Return true if the target supports nontemporal store. More... | |
bool | isLegalNTLoad (Type *DataType, Align Alignment) const |
Return true if the target supports nontemporal load. More... | |
bool | isLegalBroadcastLoad (Type *ElementTy, ElementCount NumElements) const |
\Returns true if the target supports broadcasting a load to a vector of type <NumElements x ElementTy>. More... | |
bool | isLegalMaskedScatter (Type *DataType, Align Alignment) const |
Return true if the target supports masked scatter. More... | |
bool | isLegalMaskedGather (Type *DataType, Align Alignment) const |
Return true if the target supports masked gather. More... | |
bool | forceScalarizeMaskedGather (VectorType *Type, Align Alignment) const |
Return true if the target forces scalarizing of llvm.masked.gather intrinsics. More... | |
bool | forceScalarizeMaskedScatter (VectorType *Type, Align Alignment) const |
Return true if the target forces scalarizing of llvm.masked.scatter intrinsics. More... | |
bool | isLegalMaskedCompressStore (Type *DataType) const |
Return true if the target supports masked compress store. More... | |
bool | isLegalMaskedExpandLoad (Type *DataType) const |
Return true if the target supports masked expand load. More... | |
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. More... | |
bool | enableOrderedReductions () const |
Return true if we should be enabling ordered reductions for the target. More... | |
bool | hasDivRemOp (Type *DataType, bool IsSigned) const |
Return true if the target has a unified operation to calculate division and remainder. More... | |
bool | hasVolatileVariant (Instruction *I, unsigned AddrSpace) const |
Return true if the given instruction (assumed to be a memory access instruction) has a volatile variant. More... | |
bool | prefersVectorizedAddressing () const |
Return true if target doesn't mind addresses in vectors. More... | |
InstructionCost | getScalingFactorCost (Type *Ty, GlobalValue *BaseGV, int64_t 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. More... | |
bool | LSRWithInstrQueries () const |
Return true if the loop strength reduce pass should make Instruction* based TTI queries to isLegalAddressingMode(). More... | |
bool | isTruncateFree (Type *Ty1, Type *Ty2) const |
Return true if it's free to truncate a value of type Ty1 to type Ty2. More... | |
bool | isProfitableToHoist (Instruction *I) const |
Return true if it is profitable to hoist instruction in the then/else to before if. More... | |
bool | useAA () const |
bool | isTypeLegal (Type *Ty) const |
Return true if this type is legal. More... | |
unsigned | getRegUsageForType (Type *Ty) const |
Returns the estimated number of registers required to represent Ty . More... | |
bool | shouldBuildLookupTables () const |
Return true if switches should be turned into lookup tables for the target. More... | |
bool | shouldBuildLookupTablesForConstant (Constant *C) const |
Return true if switches should be turned into lookup tables containing this constant value for the target. More... | |
bool | shouldBuildRelLookupTables () const |
Return true if lookup tables should be turned into relative lookup tables. More... | |
bool | useColdCCForColdCall (Function &F) const |
Return true if the input function which is cold at all call sites, should use coldcc calling convention. More... | |
InstructionCost | getScalarizationOverhead (VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract) const |
Estimate the overhead of scalarizing an instruction. More... | |
InstructionCost | getOperandsScalarizationOverhead (ArrayRef< const Value * > Args, ArrayRef< Type * > Tys) const |
Estimate the overhead of scalarizing an instructions unique non-constant operands. More... | |
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. More... | |
bool | enableAggressiveInterleaving (bool LoopHasReductions) const |
Don't restrict interleaved unrolling to small loops. More... | |
MemCmpExpansionOptions | enableMemCmpExpansion (bool OptSize, bool IsZeroCmp) const |
bool | enableInterleavedAccessVectorization () const |
Enable matching of interleaved access groups. More... | |
bool | enableMaskedInterleavedAccessVectorization () const |
Enable matching of interleaved access groups that contain predicated accesses or gaps and therefore vectorized using masked vector loads/stores. More... | |
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. More... | |
bool | allowsMisalignedMemoryAccesses (LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace=0, Align Alignment=Align(1), bool *Fast=nullptr) const |
Determine if the target supports unaligned memory accesses. More... | |
PopcntSupportKind | getPopcntSupport (unsigned IntTyWidthInBit) const |
Return hardware support for population count. More... | |
bool | haveFastSqrt (Type *Ty) const |
Return true if the hardware has a fast square-root instruction. More... | |
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. More... | |
InstructionCost | getFPOpCost (Type *Ty) const |
Return the expected cost of supporting the floating point operation of the specified type. More... | |
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. More... | |
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. More... | |
InstructionCost | getIntImmCostIntrin (Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty, TargetCostKind CostKind) const |
InstructionCost | getIntImmCodeSizeCost (unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty) const |
Return the expected cost for the given integer when optimising for size. More... | |
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition at line 168 of file TargetTransformInfo.h.
Enumerator | |
---|---|
AMK_PreIndexed | |
AMK_PostIndexed | |
AMK_None |
Definition at line 642 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 1103 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 1346 of file TargetTransformInfo.h.
Additional information about an operand's possible values.
Enumerator | |
---|---|
OK_AnyValue | |
OK_UniformValue | |
OK_UniformConstantValue | |
OK_NonUniformConstantValue |
Definition at line 901 of file TargetTransformInfo.h.
Additional properties of an operand's values.
Enumerator | |
---|---|
OP_None | |
OP_PowerOf2 |
Definition at line 909 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 595 of file TargetTransformInfo.h.
Enumerator | |
---|---|
RGK_Scalar | |
RGK_FixedWidthVector | |
RGK_ScalableVector |
Definition at line 930 of file TargetTransformInfo.h.
The various kinds of shuffle patterns for vector queries.
Definition at line 882 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 261 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.
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 211 of file TargetTransformInfo.h.
llvm::TargetTransformInfo::TargetTransformInfo | ( | T | Impl | ) |
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 2465 of file TargetTransformInfo.h.
References T.
|
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 182 of file TargetTransformInfo.cpp.
TargetTransformInfo::TargetTransformInfo | ( | TargetTransformInfo && | Arg | ) |
Definition at line 187 of file TargetTransformInfo.cpp.
|
default |
Definition at line 200 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::allowsMisalignedMemoryAccesses | ( | LLVMContext & | Context, |
unsigned | BitWidth, | ||
unsigned | AddressSpace = 0 , |
||
Align | Alignment = Align(1) , |
||
bool * | Fast = nullptr |
||
) | const |
Determine if the target supports unaligned memory accesses.
Definition at line 547 of file TargetTransformInfo.cpp.
References llvm::BitWidth, and Context.
bool TargetTransformInfo::areInlineCompatible | ( | const Function * | Caller, |
const Function * | Callee | ||
) | const |
Definition at line 1014 of file TargetTransformInfo.cpp.
References Callee.
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 1019 of file TargetTransformInfo.cpp.
References Callee.
bool TargetTransformInfo::canHaveNonUndefGlobalInitializerInAddressSpace | ( | unsigned | AS | ) | const |
Return true if globals in this address space can have initializers other than undef
.
Definition at line 265 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 369 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 373 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 255 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::emitGetActiveLaneMask | ( | ) | const |
Query the target whether lowering of the llvm.get.active.lane.mask intrinsic is supported.
Definition at line 301 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::enableAggressiveInterleaving | ( | bool | LoopHasReductions | ) | const |
Don't restrict interleaved unrolling to small loops.
Definition at line 525 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::selectInterleaveCount().
bool TargetTransformInfo::enableInterleavedAccessVectorization | ( | ) | const |
Enable matching of interleaved access groups.
Definition at line 535 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 539 of file TargetTransformInfo.cpp.
Referenced by useMaskedInterleavedAccesses().
TargetTransformInfo::MemCmpExpansionOptions TargetTransformInfo::enableMemCmpExpansion | ( | bool | OptSize, |
bool | IsZeroCmp | ||
) | const |
Definition at line 531 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::enableOrderedReductions | ( | ) | const |
Return true if we should be enabling ordered reductions for the target.
Definition at line 444 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::processLoop().
bool TargetTransformInfo::enableScalableVectorization | ( | ) | const |
Definition at line 1109 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizeHints::LoopVectorizeHints().
bool TargetTransformInfo::enableWritePrefetching | ( | ) | const |
Definition at line 697 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 426 of file TargetTransformInfo.cpp.
Referenced by 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 431 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
InstructionCost TargetTransformInfo::getAddressComputationCost | ( | Type * | Ty, |
ScalarEvolution * | SE = nullptr , |
||
const SCEV * | Ptr = nullptr |
||
) | const |
Definition at line 938 of file TargetTransformInfo.cpp.
References assert().
Referenced by chainToBasePointerCost().
InstructionCost TargetTransformInfo::getArithmeticInstrCost | ( | unsigned | Opcode, |
Type * | Ty, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput , |
||
OperandValueKind | Opd1Info = OK_AnyValue , |
||
OperandValueKind | Opd2Info = OK_AnyValue , |
||
OperandValueProperties | Opd1PropInfo = OP_None , |
||
OperandValueProperties | Opd2PropInfo = OP_None , |
||
ArrayRef< const Value * > | Args = ArrayRef<const Value *>() , |
||
const Instruction * | CxtI = 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.
Definition at line 755 of file TargetTransformInfo.cpp.
References llvm::AMDGPU::HSAMD::Kernel::Key::Args, assert(), and CostKind.
Referenced by costAndCollectOperands(), llvm::FoldBranchToCommonDest(), and visitIVCast().
InstructionCost TargetTransformInfo::getArithmeticReductionCost | ( | unsigned | Opcode, |
VectorType * | Ty, | ||
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 951 of file TargetTransformInfo.cpp.
Definition at line 270 of file TargetTransformInfo.cpp.
Referenced by isAddressExpression().
unsigned TargetTransformInfo::getAtomicMemIntrinsicMaxElementSize | ( | ) | const |
Definition at line 986 of file TargetTransformInfo.cpp.
llvm::Optional< unsigned > TargetTransformInfo::getCacheAssociativity | ( | CacheLevel | Level | ) | const |
Definition at line 678 of file TargetTransformInfo.cpp.
unsigned TargetTransformInfo::getCacheLineSize | ( | ) | const |
Definition at line 667 of file TargetTransformInfo.cpp.
References CacheLineSize.
llvm::Optional< unsigned > TargetTransformInfo::getCacheSize | ( | CacheLevel | Level | ) | const |
Definition at line 673 of file TargetTransformInfo.cpp.
InstructionCost TargetTransformInfo::getCallInstrCost | ( | Function * | F, |
Type * | RetTy, | ||
ArrayRef< Type * > | Tys, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_SizeAndLatency |
||
) | const |
Definition at line 925 of file TargetTransformInfo.cpp.
References assert(), CostKind, and F.
Referenced by llvm::LoopVectorizationCostModel::getVectorCallCost(), and getVectorCallCosts().
|
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 777 of file TargetTransformInfo.cpp.
References GatherScatter, llvm::IntrinsicInst::getIntrinsicID(), I, llvm::SPII::Load, Masked, None, Normal, and llvm::SPII::Store.
Referenced by chainToBasePointerCost(), and llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getUserCost().
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 820 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by chainToBasePointerCost(), costAndCollectOperands(), llvm::BasicTTIImplBase< AMDGPUTTIImpl >::getCastInstrCost(), and tryToFPToSat().
InstructionCost TargetTransformInfo::getCFInstrCost | ( | unsigned | Opcode, |
TTI::TargetCostKind | CostKind = TTI::TCK_SizeAndLatency , |
||
const Instruction * | I = nullptr |
||
) | const |
Definition at line 839 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by findCostForOutputBlocks().
InstructionCost TargetTransformInfo::getCmpSelInstrCost | ( | unsigned | Opcode, |
Type * | ValTy, | ||
Type * | CondTy, | ||
CmpInst::Predicate | VecPred, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput , |
||
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. Definition at line 848 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by costAndCollectOperands(), findCostForOutputBlocks(), 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 977 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::getSpillCost().
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 215 of file TargetTransformInfo.cpp.
References llvm::AMDGPUISD::BFI, and SI.
InstructionCost TargetTransformInfo::getExtendedAddReductionCost | ( | bool | IsMLA, |
bool | IsUnsigned, | ||
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 reduction with an extension and optional multiply.
This is the cost of as: ResTy vecreduce.add(ext(Ty A)), or if IsMLA flag is set then: ResTy vecreduce.add(mul(ext(Ty A), ext(Ty B)). The reduction happens on a VectorType with ResTy elements and Ty lanes.
Definition at line 969 of file TargetTransformInfo.cpp.
References CostKind.
InstructionCost TargetTransformInfo::getExtractWithExtendCost | ( | unsigned | Opcode, |
Type * | Dst, | ||
VectorType * | VecTy, | ||
unsigned | Index = -1 |
||
) | const |
Definition at line 831 of file TargetTransformInfo.cpp.
References assert().
Referenced by llvm::slpvectorizer::BoUpSLP::getTreeCost().
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 251 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 569 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 896 of file TargetTransformInfo.cpp.
InstructionCost TargetTransformInfo::getGEPCost | ( | Type * | PointeeType, |
const Value * | Ptr, | ||
ArrayRef< const Value * > | Operands, | ||
TTI::TargetCostKind | CostKind = TCK_SizeAndLatency |
||
) | const |
Estimate the cost of a GEP operation when lowered.
Definition at line 209 of file TargetTransformInfo.cpp.
References CostKind, and Operands.
Referenced by isGEPFoldable().
unsigned TargetTransformInfo::getGISelRematGlobalCost | ( | ) | const |
Definition at line 1101 of file TargetTransformInfo.cpp.
Referenced by llvm::TargetLoweringBase::shouldLocalize().
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 204 of file TargetTransformInfo.cpp.
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 195 of file TargetTransformInfo.cpp.
|
inline |
Query the cost of a specified instruction.
Clients should use this interface to query the cost of an existing instruction. The instruction must have a valid parent (basic block).
Note, this method does not cache the cost calculation and it can be expensive in some cases.
Definition at line 225 of file TargetTransformInfo.h.
References getUserCost(), I, TCK_CodeSize, TCK_Latency, TCK_RecipThroughput, and TCK_SizeAndLatency.
Referenced by canSplitCallSite(), llvm::OutlinableRegion::getBenefit(), getOutliningBenefit(), and llvm::CostModelPrinterPass::run().
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 905 of file TargetTransformInfo.cpp.
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 575 of file TargetTransformInfo.cpp.
References assert(), and llvm::RISCVMatInt::Imm.
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 585 of file TargetTransformInfo.cpp.
References assert(), CostKind, and llvm::RISCVMatInt::Imm.
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 592 of file TargetTransformInfo.cpp.
References assert(), CostKind, and llvm::RISCVMatInt::Imm.
InstructionCost TargetTransformInfo::getIntImmCostIntrin | ( | Intrinsic::ID | IID, |
unsigned | Idx, | ||
const APInt & | Imm, | ||
Type * | Ty, | ||
TTI::TargetCostKind | CostKind | ||
) | const |
Definition at line 602 of file TargetTransformInfo.cpp.
References assert(), CostKind, and llvm::RISCVMatInt::Imm.
InstructionCost TargetTransformInfo::getIntrinsicInstrCost | ( | const IntrinsicCostAttributes & | ICA, |
TTI::TargetCostKind | CostKind | ||
) | const |
Definition at line 917 of file TargetTransformInfo.cpp.
References assert(), and CostKind.
Referenced by getVectorCallCosts(), llvm::LoopVectorizationCostModel::getVectorIntrinsicCost(), and tryToFPToSat().
unsigned TargetTransformInfo::getLoadStoreVecRegBitWidth | ( | unsigned | AddrSpace | ) | const |
Definition at line 1035 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 1068 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 887 of file TargetTransformInfo.cpp.
unsigned TargetTransformInfo::getMaximumVF | ( | unsigned | ElemWidth, |
unsigned | Opcode | ||
) | const |
Definition at line 651 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::getMaximumVF().
unsigned TargetTransformInfo::getMaxInterleaveFactor | ( | unsigned | VF | ) | const |
Definition at line 701 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::runImpl(), and llvm::LoopVectorizationCostModel::selectInterleaveCount().
unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead | ( | ) | const |
Definition at line 693 of file TargetTransformInfo.cpp.
Optional< unsigned > TargetTransformInfo::getMaxVScale | ( | ) | const |
Definition at line 633 of file TargetTransformInfo.cpp.
InstructionCost TargetTransformInfo::getMemcpyCost | ( | const Instruction * | I | ) | const |
Definition at line 945 of file TargetTransformInfo.cpp.
Type * TargetTransformInfo::getMemcpyLoopLoweringType | ( | LLVMContext & | Context, |
Value * | Length, | ||
unsigned | SrcAddrSpace, | ||
unsigned | DestAddrSpace, | ||
unsigned | SrcAlign, | ||
unsigned | DestAlign, | ||
Optional< uint32_t > | AtomicElementSize = None |
||
) | const |
Definition at line 995 of file TargetTransformInfo.cpp.
References Context.
Referenced by llvm::createMemCpyLoopKnownSize().
void TargetTransformInfo::getMemcpyLoopResidualLoweringType | ( | SmallVectorImpl< Type * > & | OpsOut, |
LLVMContext & | Context, | ||
unsigned | RemainingBytes, | ||
unsigned | SrcAddrSpace, | ||
unsigned | DestAddrSpace, | ||
unsigned | SrcAlign, | ||
unsigned | DestAlign, | ||
Optional< uint32_t > | AtomicCpySize = None |
||
) | 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 1004 of file TargetTransformInfo.cpp.
References Context.
Referenced by llvm::createMemCpyLoopKnownSize().
InstructionCost TargetTransformInfo::getMemoryOpCost | ( | unsigned | Opcode, |
Type * | Src, | ||
Align | Alignment, | ||
unsigned | AddressSpace, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput , |
||
const Instruction * | I = nullptr |
||
) | const |
Definition at line 876 of file TargetTransformInfo.cpp.
References assert(), CostKind, and I.
Referenced by findCostForOutputBlocks().
ElementCount TargetTransformInfo::getMinimumVF | ( | unsigned | ElemWidth, |
bool | IsScalable | ||
) | const |
Definition at line 646 of file TargetTransformInfo.cpp.
InstructionCost TargetTransformInfo::getMinMaxReductionCost | ( | VectorType * | Ty, |
VectorType * | CondTy, | ||
bool | IsUnsigned, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput |
||
) | const |
Definition at line 960 of file TargetTransformInfo.cpp.
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 686 of file TargetTransformInfo.cpp.
unsigned TargetTransformInfo::getMinVectorRegisterBitWidth | ( | ) | const |
Definition at line 629 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::BoUpSLP().
unsigned TargetTransformInfo::getNumberOfParts | ( | Type * | Tp | ) | const |
Definition at line 933 of file TargetTransformInfo.cpp.
Referenced by computeExtractCost(), and llvm::slpvectorizer::BoUpSLP::optimizeGatherSequence().
unsigned TargetTransformInfo::getNumberOfRegisters | ( | unsigned | ClassID | ) | const |
Definition at line 611 of file TargetTransformInfo.cpp.
Referenced by llvm::SLPVectorizerPass::runImpl(), llvm::LoopVectorizePass::runImpl(), and llvm::LoopVectorizationCostModel::selectInterleaveCount().
|
static |
Collect properties of V used in cost analysis, e.g. OP_PowerOf2.
Definition at line 706 of file TargetTransformInfo.cpp.
References E, llvm::getSplatValue(), I, OK_AnyValue, OK_NonUniformConstantValue, OK_UniformConstantValue, OK_UniformValue, OP_None, and OP_PowerOf2.
Referenced by llvm::BasicTTIImplBase< AMDGPUTTIImpl >::getIntrinsicInstrCost(), and llvm::TargetTransformInfoImplCRTPBase< AMDGPUTTIImpl >::getUserCost().
InstructionCost TargetTransformInfo::getOperandsScalarizationOverhead | ( | ArrayRef< const Value * > | Args, |
ArrayRef< Type * > | Tys | ||
) | const |
Estimate the overhead of scalarizing an instructions unique non-constant operands.
The (potentially vector) types to use for each of argument are passes via Tys.
Definition at line 516 of file TargetTransformInfo.cpp.
References llvm::AMDGPU::HSAMD::Kernel::Key::Args.
Value * TargetTransformInfo::getOrCreateResultFromMemIntrinsic | ( | IntrinsicInst * | Inst, |
Type * | ExpectedType | ||
) | const |
Definition at line 990 of file TargetTransformInfo.cpp.
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 334 of file TargetTransformInfo.cpp.
Referenced by llvm::gatherPeelingPreferences().
TargetTransformInfo::PopcntSupportKind TargetTransformInfo::getPopcntSupport | ( | unsigned | IntTyWidthInBit | ) | const |
Return hardware support for population count.
Definition at line 557 of file TargetTransformInfo.cpp.
std::pair< const Value *, unsigned > TargetTransformInfo::getPredicatedAddrSpace | ( | const Value * | V | ) | const |
Definition at line 275 of file TargetTransformInfo.cpp.
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 231 of file TargetTransformInfo.cpp.
Referenced by FoldTwoEntryPHINode(), isFormingBranchFromSelectProfitable(), and shouldFoldCondBranchesToCommonDestination().
TTI::AddressingModeKind TargetTransformInfo::getPreferredAddressingMode | ( | const Loop * | L, |
ScalarEvolution * | SE | ||
) | const |
Return the preferred addressing mode LSR should make efforts to generate.
Definition at line 381 of file TargetTransformInfo.cpp.
unsigned TargetTransformInfo::getPrefetchDistance | ( | ) | const |
Definition at line 682 of file TargetTransformInfo.cpp.
TypeSize TargetTransformInfo::getRegisterBitWidth | ( | TargetTransformInfo::RegisterKind | K | ) | const |
Definition at line 624 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::BoUpSLP(), and llvm::LoopVectorizationPlanner::planInVPlanNativePath().
unsigned TargetTransformInfo::getRegisterClassForType | ( | bool | Vector, |
Type * | Ty = nullptr |
||
) | const |
Definition at line 615 of file TargetTransformInfo.cpp.
References Vector.
Referenced by llvm::LoopVectorizationCostModel::calculateRegisterUsage(), llvm::SLPVectorizerPass::runImpl(), and llvm::LoopVectorizePass::runImpl().
const char * TargetTransformInfo::getRegisterClassName | ( | unsigned | ClassID | ) | const |
Definition at line 620 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::calculateRegisterUsage(), and llvm::LoopVectorizationCostModel::selectInterleaveCount().
unsigned TargetTransformInfo::getRegUsageForType | ( | Type * | Ty | ) | const |
Returns the estimated number of registers required to represent Ty
.
Definition at line 488 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::calculateRegisterUsage().
InstructionCost TargetTransformInfo::getReplicationShuffleCost | ( | Type * | EltTy, |
int | ReplicationFactor, | ||
int | VF, | ||
const APInt & | DemandedDstElts, | ||
TTI::TargetCostKind | CostKind | ||
) |
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 867 of file TargetTransformInfo.cpp.
InstructionCost TargetTransformInfo::getScalarizationOverhead | ( | VectorType * | Ty, |
const APInt & | DemandedElts, | ||
bool | Insert, | ||
bool | Extract | ||
) | 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.
Definition at line 510 of file TargetTransformInfo.cpp.
References Insert.
Referenced by llvm::slpvectorizer::BoUpSLP::getTreeCost().
InstructionCost TargetTransformInfo::getScalingFactorCost | ( | Type * | Ty, |
GlobalValue * | BaseGV, | ||
int64_t | 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 461 of file TargetTransformInfo.cpp.
References assert().
Referenced by getScalingFactorCost().
InstructionCost TargetTransformInfo::getShuffleCost | ( | ShuffleKind | Kind, |
VectorType * | Tp, | ||
ArrayRef< int > | Mask = None , |
||
int | Index = 0 , |
||
VectorType * | SubTp = nullptr , |
||
ArrayRef< const Value * > | Args = None |
||
) | const |
Args
, which helps improve the cost estimation in some cases, like in broadcast loads. NOTE: For subvector extractions Tp represents the source type. Definition at line 767 of file TargetTransformInfo.cpp.
References llvm::AMDGPU::HSAMD::Kernel::Key::Args, assert(), and llvm::BitmaskEnumDetail::Mask().
Referenced by computeExtractCost(), and llvm::slpvectorizer::BoUpSLP::getTreeCost().
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 656 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 1075 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::getTgtMemIntrinsic | ( | IntrinsicInst * | Inst, |
MemIntrinsicInfo & | Info | ||
) | const |
Definition at line 981 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 328 of file TargetTransformInfo.cpp.
Referenced by llvm::gatherUnrollingPreferences().
InstructionCost TargetTransformInfo::getUserCost | ( | 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 222 of file TargetTransformInfo.cpp.
References assert(), CostKind, Operands, and TCK_RecipThroughput.
Referenced by llvm::CodeMetrics::analyzeBasicBlock(), analyzeLoopUnrollCost(), checkOuterLoopInsts(), llvm::ComputeSpeculationCost(), computeSpeculationCost(), llvm::FoldBranchToCommonDest(), getInstructionCost(), getJumpThreadDuplicationCost(), getUserCost(), isFreeInLoop(), mergeConditionalStoreToAddress(), sinkSelectOperand(), and unswitchBestCondition().
|
inline |
This is a helper function which calls the two-argument getUserCost with Operands
which are the current operands U has.
Definition at line 326 of file TargetTransformInfo.h.
References CostKind, getUserCost(), llvm::User::operand_values(), and Operands.
InstructionCost TargetTransformInfo::getVectorInstrCost | ( | unsigned | Opcode, |
Type * | Val, | ||
unsigned | Index = -1 |
||
) | const |
Definition at line 859 of file TargetTransformInfo.cpp.
References assert().
Referenced by llvm::slpvectorizer::BoUpSLP::getTreeCost().
TargetTransformInfo::VPLegalization TargetTransformInfo::getVPLegalizationStrategy | ( | const VPIntrinsic & | PI | ) | const |
Definition at line 1093 of file TargetTransformInfo.cpp.
InstructionCost llvm::TargetTransformInfo::getVPMemoryOpCost | ( | unsigned | Opcode, |
Type * | Src, | ||
Align | Alignment, | ||
unsigned | AddressSpace, | ||
TTI::TargetCostKind | CostKind = TTI::TCK_RecipThroughput , |
||
const Instruction * | I = nullptr |
||
) | const |
Optional< unsigned > TargetTransformInfo::getVScaleForTuning | ( | ) | const |
Definition at line 637 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::hasActiveVectorLength | ( | unsigned | Opcode, |
Type * | DataType, | ||
Align | Alignment | ||
) | const |
Definition at line 1113 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::hasBranchDivergence | ( | ) | const |
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.
Definition at line 235 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::computeMaxVF(), llvm::JumpThreadingPass::run(), llvm::SpeculativeExecutionPass::runImpl(), llvm::LegacyDivergenceAnalysis::runOnFunction(), and unswitchLoop().
bool TargetTransformInfo::hasDivRemOp | ( | Type * | DataType, |
bool | IsSigned | ||
) | const |
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 448 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 452 of file TargetTransformInfo.cpp.
References I.
Referenced by isSimplePointerUseValidToReplace().
bool TargetTransformInfo::haveFastSqrt | ( | Type * | Ty | ) | const |
Return true if the hardware has a fast square-root instruction.
Definition at line 561 of file TargetTransformInfo.cpp.
Referenced by runPartiallyInlineLibCalls().
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 306 of file TargetTransformInfo.cpp.
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 197 of file TargetTransformInfo.h.
Definition at line 247 of file TargetTransformInfo.cpp.
Referenced by llvm::DivergenceInfo::DivergenceInfo().
bool TargetTransformInfo::isElementTypeLegalForScalableVector | ( | Type * | Ty | ) | const |
Definition at line 1064 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::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.
Targets should override this if materializing a 0.0 for comparison is generally as cheap as checking for ordered/unordered.
Definition at line 565 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 543 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 288 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isIndexedLoadLegal | ( | enum MemIndexedMode | Mode, |
Type * | Ty | ||
) | const |
Definition at line 1025 of file TargetTransformInfo.cpp.
References Mode.
Referenced by mayUsePostIncMode().
bool TargetTransformInfo::isIndexedStoreLegal | ( | enum MemIndexedMode | Mode, |
Type * | Ty | ||
) | const |
Definition at line 1030 of file TargetTransformInfo.cpp.
References Mode.
Referenced by 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 339 of file TargetTransformInfo.cpp.
References llvm::RISCVMatInt::Imm.
bool TargetTransformInfo::isLegalAddressingMode | ( | Type * | Ty, |
GlobalValue * | BaseGV, | ||
int64_t | BaseOffset, | ||
bool | HasBaseReg, | ||
int64_t | Scale, | ||
unsigned | AddrSpace = 0 , |
||
Instruction * | I = nullptr |
||
) | 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. TODO: Handle pre/postinc as well.
Definition at line 347 of file TargetTransformInfo.cpp.
References I.
Referenced by isAddFoldable(), and isAMCompletelyFolded().
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 415 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::reorderTopToBottom().
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 405 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 343 of file TargetTransformInfo.cpp.
References llvm::RISCVMatInt::Imm.
Referenced by isAMCompletelyFolded().
bool TargetTransformInfo::isLegalMaskedCompressStore | ( | Type * | DataType | ) | const |
Return true if the target supports masked compress store.
Definition at line 436 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
bool TargetTransformInfo::isLegalMaskedExpandLoad | ( | Type * | DataType | ) | const |
Return true if the target supports masked expand load.
Definition at line 440 of file TargetTransformInfo.cpp.
Referenced by optimizeCallInst().
Return true if the target supports masked gather.
Definition at line 410 of file TargetTransformInfo.cpp.
Referenced by canVectorizeLoads(), llvm::LoopVectorizationCostModel::isLegalGatherOrScatter(), llvm::LoopVectorizationCostModel::isScalarWithPredication(), and optimizeCallInst().
Return true if the target supports masked load.
Definition at line 391 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::interleavedAccessCanBeWidened(), llvm::LoopVectorizationCostModel::isLegalMaskedLoad(), and optimizeCallInst().
Return true if the target supports masked scatter.
Definition at line 421 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isLegalGatherOrScatter(), llvm::LoopVectorizationCostModel::isScalarWithPredication(), and optimizeCallInst().
Return true if the target supports masked store.
Definition at line 386 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::interleavedAccessCanBeWidened(), llvm::LoopVectorizationCostModel::isLegalMaskedStore(), and optimizeCallInst().
Return true if the target supports nontemporal load.
Definition at line 401 of file TargetTransformInfo.cpp.
Return true if the target supports nontemporal store.
Definition at line 396 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isLegalToVectorizeLoad | ( | LoadInst * | LI | ) | const |
Definition at line 1039 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isLegalToVectorizeLoadChain | ( | unsigned | ChainSizeInBytes, |
Align | Alignment, | ||
unsigned | AddrSpace | ||
) | const |
Definition at line 1047 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isLegalToVectorizeReduction | ( | const RecurrenceDescriptor & | RdxDesc, |
ElementCount | VF | ||
) | const |
Definition at line 1059 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isLegalToVectorizeStore | ( | StoreInst * | SI | ) | const |
Definition at line 1043 of file TargetTransformInfo.cpp.
References SI.
bool TargetTransformInfo::isLegalToVectorizeStoreChain | ( | unsigned | ChainSizeInBytes, |
Align | Alignment, | ||
unsigned | AddrSpace | ||
) | const |
Definition at line 1053 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 284 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 C1.
Definition at line 356 of file TargetTransformInfo.cpp.
References C1.
bool TargetTransformInfo::isNoopAddrSpaceCast | ( | unsigned | FromAS, |
unsigned | ToAS | ||
) | const |
Definition at line 260 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 361 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::isProfitableLSRChainElement | ( | Instruction * | I | ) | const |
I
. Definition at line 365 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 478 of file TargetTransformInfo.cpp.
References I.
Returns whether V is a source of divergence.
This function provides the target-dependent information for the target-independent LegacyDivergenceAnalysis. LegacyDivergenceAnalysis first builds the dependency graph, and then runs the reachability algorithm starting with the sources of divergence.
Definition at line 243 of file TargetTransformInfo.cpp.
Referenced by llvm::DivergenceInfo::DivergenceInfo().
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 474 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::isOptimizableIVTruncate(), and llvm::SCEVExpander::replaceCongruentIVs().
bool TargetTransformInfo::isTypeLegal | ( | Type * | Ty | ) | const |
Return true if this type is legal.
Definition at line 484 of file TargetTransformInfo.cpp.
Referenced by llvm::computeMinimumValueSizes(), isLoadCombineCandidateImpl(), and isTypeLegalForLookupTable().
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 470 of file TargetTransformInfo.cpp.
Referenced by isAMCompletelyFolded().
TargetTransformInfo & TargetTransformInfo::operator= | ( | TargetTransformInfo && | RHS | ) |
Definition at line 190 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::preferInLoopReduction | ( | unsigned | Opcode, |
Type * | Ty, | ||
ReductionFlags | Flags | ||
) | const |
Definition at line 1082 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::collectElementTypesForWidening(), and llvm::LoopVectorizationCostModel::collectInLoopReductions().
bool TargetTransformInfo::preferPredicatedReductionSelect | ( | unsigned | Opcode, |
Type * | Ty, | ||
ReductionFlags | Flags | ||
) | 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 1087 of file TargetTransformInfo.cpp.
Referenced by llvm::InnerLoopVectorizer::fixReduction().
bool TargetTransformInfo::preferPredicateOverEpilogue | ( | Loop * | L, |
LoopInfo * | LI, | ||
ScalarEvolution & | SE, | ||
AssumptionCache & | AC, | ||
TargetLibraryInfo * | TLI, | ||
DominatorTree * | DT, | ||
const LoopAccessInfo * | LAI | ||
) | 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 294 of file TargetTransformInfo.cpp.
Referenced by getScalarEpilogueLowering().
bool TargetTransformInfo::prefersVectorizedAddressing | ( | ) | const |
Return true if target doesn't mind addresses in vectors.
Definition at line 457 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizationCostModel::setCostBasedWideningDecision().
|
inlinestatic |
A helper function to determine the type of reduction algorithm used for a given Opcode
and set of FastMathFlags FMF
.
Definition at line 1218 of file TargetTransformInfo.h.
References llvm::None.
Referenced by llvm::RISCVTTIImpl::getArithmeticReductionCost(), llvm::X86TTIImpl::getArithmeticReductionCost(), llvm::GCNTTIImpl::getArithmeticReductionCost(), llvm::ARMTTIImpl::getArithmeticReductionCost(), llvm::AArch64TTIImpl::getArithmeticReductionCost(), and llvm::BasicTTIImplBase< AMDGPUTTIImpl >::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 279 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::shouldBuildLookupTables | ( | ) | const |
Return true if switches should be turned into lookup tables for the target.
Definition at line 492 of file TargetTransformInfo.cpp.
Referenced by SwitchToLookupTable().
bool TargetTransformInfo::shouldBuildLookupTablesForConstant | ( | Constant * | C | ) | const |
Return true if switches should be turned into lookup tables containing this constant value for the target.
Definition at line 496 of file TargetTransformInfo.cpp.
Referenced by ValidLookupTableConstant().
bool TargetTransformInfo::shouldBuildRelLookupTables | ( | ) | const |
Return true if lookup tables should be turned into relative lookup tables.
Definition at line 501 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 661 of file TargetTransformInfo.cpp.
References I.
bool TargetTransformInfo::shouldExpandReduction | ( | const IntrinsicInst * | II | ) | const |
Definition at line 1097 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::shouldMaximizeVectorBandwidth | ( | TargetTransformInfo::RegisterKind | K | ) | const |
K
Register Kind for vectorization. Definition at line 641 of file TargetTransformInfo.cpp.
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 311 of file TargetTransformInfo.cpp.
Referenced by llvm::InstCombiner::targetSimplifyDemandedUseBitsIntrinsic().
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 318 of file TargetTransformInfo.cpp.
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 521 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::supportsScalableVectors | ( | ) | const |
Definition at line 1105 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::useAA | ( | ) | const |
Definition at line 482 of file TargetTransformInfo.cpp.
bool TargetTransformInfo::useColdCCForColdCall | ( | Function & | F | ) | const |
Return true if the input function which is cold at all call sites, should use coldcc calling convention.
Definition at line 505 of file TargetTransformInfo.cpp.
References F.
Referenced by OptimizeFunctions().
bool TargetTransformInfo::useGPUDivergenceAnalysis | ( | ) | const |
Return true if the target prefers to use GPU divergence analysis to replace the legacy version.
Definition at line 239 of file TargetTransformInfo.cpp.