|
LLVM
4.0.0
|
This pass provides access to the codegen interfaces that are needed for IR-level transformations. More...
#include <TargetTransformInfo.h>
Classes | |
| class | Concept |
| struct | UnrollingPreferences |
| Parameters that control the generic loop unrolling transformation. More... | |
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... | |
Generic Target Information | |
| enum | TargetCostConstants { TCC_Free = 0, TCC_Basic = 1, TCC_Expensive = 4 } |
| Underlying constants for 'cost' values in this interface. More... | |
| int | getOperationCost (unsigned Opcode, Type *Ty, Type *OpTy=nullptr) const |
| Estimate the cost of a specific operation when lowered. More... | |
| int | getGEPCost (Type *PointeeType, const Value *Ptr, ArrayRef< const Value * > Operands) const |
| Estimate the cost of a GEP operation when lowered. More... | |
| int | getCallCost (FunctionType *FTy, int NumArgs=-1) const |
| Estimate the cost of a function call when lowered. More... | |
| int | getCallCost (const Function *F, int NumArgs=-1) const |
| Estimate the cost of calling a specific function when lowered. More... | |
| int | getCallCost (const Function *F, ArrayRef< const Value * > Arguments) const |
| Estimate the cost of calling a specific function when lowered. More... | |
| unsigned | getInliningThresholdMultiplier () const |
| int | getIntrinsicCost (Intrinsic::ID IID, Type *RetTy, ArrayRef< Type * > ParamTys) const |
| Estimate the cost of an intrinsic when lowered. More... | |
| int | getIntrinsicCost (Intrinsic::ID IID, Type *RetTy, ArrayRef< const Value * > Arguments) const |
| Estimate the cost of an intrinsic when lowered. More... | |
| int | getUserCost (const User *U) const |
| Estimate the cost of a given IR user when lowered. More... | |
| bool | hasBranchDivergence () const |
| Return true if branch divergence exists. More... | |
| bool | isSourceOfDivergence (const Value *V) const |
| Returns whether V is a source of divergence. More... | |
| bool | isLoweredToCall (const Function *F) const |
| Test whether calls to a function lower to actual program function calls. More... | |
| void | getUnrollingPreferences (Loop *L, UnrollingPreferences &UP) const |
| Get target-customized preferences for the generic loop unrolling transformation. More... | |
Scalar Target Information | |
| enum | PopcntSupportKind { PSK_Software, PSK_SlowHardware, PSK_FastHardware } |
| Flags indicating the kind of support for population count. More... | |
| 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) 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 | isLegalMaskedStore (Type *DataType) const |
| Return true if the target supports masked load/store AVX2 and AVX-512 targets allow masks for consecutive load and store. More... | |
| bool | isLegalMaskedLoad (Type *DataType) const |
| bool | isLegalMaskedScatter (Type *DataType) const |
| Return true if the target supports masked gather/scatter AVX-512 fully supports gather and scatter for vectors with 32 and 64 bits scalar type. More... | |
| bool | isLegalMaskedGather (Type *DataType) const |
| int | 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 | isFoldableMemAccessOffset (Instruction *I, int64_t Offset) const |
| Return true if target supports the load / store instruction with the given Offset on the form reg + Offset. 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 | isTypeLegal (Type *Ty) const |
| Return true if this type is legal. More... | |
| unsigned | getJumpBufAlignment () const |
| Returns the target's jmp_buf alignment in bytes. More... | |
| unsigned | getJumpBufSize () const |
| Returns the target's jmp_buf size in bytes. 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 | enableAggressiveInterleaving (bool LoopHasReductions) const |
| Don't restrict interleaved unrolling to small loops. More... | |
| bool | enableInterleavedAccessVectorization () const |
| Enable matching of interleaved access groups. 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, unsigned Alignment=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... | |
| int | getFPOpCost (Type *Ty) const |
| Return the expected cost of supporting the floating point operation of the specified type. More... | |
| int | getIntImmCost (const APInt &Imm, Type *Ty) const |
| Return the expected cost of materializing for the given integer immediate of the specified type. More... | |
| int | getIntImmCost (unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty) const |
| Return the expected cost of materialization for the given integer immediate of the specified type for a given instruction. More... | |
| int | getIntImmCost (Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty) const |
| int | 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 68 of file TargetTransformInfo.h.
Additional information about an operand's possible values.
| Enumerator | |
|---|---|
| OK_AnyValue | |
| OK_UniformValue | |
| OK_UniformConstantValue | |
| OK_NonUniformConstantValue | |
Definition at line 485 of file TargetTransformInfo.h.
Additional properties of an operand's values.
| Enumerator | |
|---|---|
| OP_None | |
| OP_PowerOf2 | |
Definition at line 493 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 339 of file TargetTransformInfo.h.
The various kinds of shuffle patterns for vector queries.
Definition at line 472 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 125 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 implementaion that encodes appropriate costs for their target.
Definition at line 1115 of file TargetTransformInfo.h.
|
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 37 of file TargetTransformInfo.cpp.
| TargetTransformInfo::TargetTransformInfo | ( | TargetTransformInfo && | Arg | ) |
Definition at line 42 of file TargetTransformInfo.cpp.
| TargetTransformInfo::~TargetTransformInfo | ( | ) |
Definition at line 40 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::allowsMisalignedMemoryAccesses | ( | LLVMContext & | Context, |
| unsigned | BitWidth, | ||
| unsigned | AddressSpace = 0, |
||
| unsigned | Alignment = 1, |
||
| bool * | Fast = nullptr |
||
| ) | const |
Determine if the target supports unaligned memory accesses.
Definition at line 197 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::areInlineCompatible | ( | const Function * | Caller, |
| const Function * | Callee | ||
| ) | const |
Definition at line 422 of file TargetTransformInfo.cpp.
Referenced by functionsHaveCompatibleAttributes().
Don't restrict interleaved unrolling to small loops.
Definition at line 185 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::enableInterleavedAccessVectorization | ( | ) | const |
Enable matching of interleaved access groups.
Definition at line 189 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getAddressComputationCost | ( | Type * | Ty, |
| ScalarEvolution * | SE = nullptr, |
||
| const SCEV * | Ptr = nullptr |
||
| ) | const |
Definition at line 392 of file TargetTransformInfo.cpp.
References assert().
Referenced by chainToBasePointerCost().
| int TargetTransformInfo::getArithmeticInstrCost | ( | unsigned | Opcode, |
| Type * | Ty, | ||
| OperandValueKind | Opd1Info = OK_AnyValue, |
||
| OperandValueKind | Opd2Info = OK_AnyValue, |
||
| OperandValueProperties | Opd1PropInfo = OP_None, |
||
| OperandValueProperties | Opd2PropInfo = OP_None, |
||
| ArrayRef< const Value * > | Args = ArrayRef<const Value *>() |
||
| ) | const |
Args is an optional argument which holds the instruction operands values so the TTI can analyize those values searching for special cases based on those values. Definition at line 277 of file TargetTransformInfo.cpp.
References assert().
Referenced by visitIVCast().
| unsigned TargetTransformInfo::getCacheLineSize | ( | ) | const |
Definition at line 257 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getCallCost | ( | FunctionType * | FTy, |
| int | NumArgs = -1 |
||
| ) | const |
Estimate the cost of a function call when lowered.
The contract for this is the same as getOperationCost except that it supports an interface that provides extra information specific to call instructions.
This is the most basic query for estimating call cost: it only knows the function type and (potentially) the number of arguments at the call site. The latter is only interesting for varargs function types.
Definition at line 57 of file TargetTransformInfo.cpp.
References assert().
Estimate the cost of calling a specific function when lowered.
This overload adds the ability to reason about the particular function being called in the event it is a library call with special lowering.
| int TargetTransformInfo::getCallCost | ( | const Function * | F, |
| ArrayRef< const Value * > | Arguments | ||
| ) | const |
Estimate the cost of calling a specific function when lowered.
This overload allows specifying a set of candidate argument values.
Definition at line 63 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getCallInstrCost | ( | Function * | F, |
| Type * | RetTy, | ||
| ArrayRef< Type * > | Tys | ||
| ) | const |
Definition at line 381 of file TargetTransformInfo.cpp.
References assert().
Referenced by getVectorCallCost().
Definition at line 295 of file TargetTransformInfo.cpp.
References assert().
Referenced by chainToBasePointerCost().
| int TargetTransformInfo::getCFInstrCost | ( | unsigned | Opcode | ) | const |
Definition at line 310 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getCmpSelInstrCost | ( | unsigned | Opcode, |
| Type * | ValTy, | ||
| Type * | CondTy = nullptr |
||
| ) | const |
Definition at line 316 of file TargetTransformInfo.cpp.
References assert().
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 408 of file TargetTransformInfo.cpp.
Referenced by llvm::slpvectorizer::BoUpSLP::getSpillCost().
| int TargetTransformInfo::getExtractWithExtendCost | ( | unsigned | Opcode, |
| Type * | Dst, | ||
| VectorType * | VecTy, | ||
| unsigned | Index = -1 |
||
| ) | const |
Definition at line 302 of file TargetTransformInfo.cpp.
References assert().
Referenced by llvm::slpvectorizer::BoUpSLP::getTreeCost().
| int TargetTransformInfo::getFPOpCost | ( | Type * | Ty | ) | const |
Return the expected cost of supporting the floating point operation of the specified type.
Definition at line 215 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getGatherScatterOpCost | ( | unsigned | Opcode, |
| Type * | DataTy, | ||
| Value * | Ptr, | ||
| bool | VariableMask, | ||
| unsigned | Alignment | ||
| ) | 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 Definition at line 347 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getGEPCost | ( | Type * | PointeeType, |
| const Value * | Ptr, | ||
| ArrayRef< const Value * > | Operands | ||
| ) | const |
Estimate the cost of a GEP operation when lowered.
The contract for this function is the same as getOperationCost except that it supports an interface that provides extra information specific to the GEP operation.
Definition at line 74 of file TargetTransformInfo.cpp.
Referenced by isGEPFoldable().
| 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 70 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getInterleavedMemoryOpCost | ( | unsigned | Opcode, |
| Type * | VecTy, | ||
| unsigned | Factor, | ||
| ArrayRef< unsigned > | Indices, | ||
| unsigned | Alignment, | ||
| unsigned | AddressSpace | ||
| ) | 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. Definition at line 356 of file TargetTransformInfo.cpp.
References assert().
| int 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 221 of file TargetTransformInfo.cpp.
References assert().
Return the expected cost of materializing for the given integer immediate of the specified type.
Definition at line 229 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getIntImmCost | ( | unsigned | Opc, |
| unsigned | Idx, | ||
| const APInt & | Imm, | ||
| Type * | Ty | ||
| ) | 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 235 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getIntImmCost | ( | Intrinsic::ID | IID, |
| unsigned | Idx, | ||
| const APInt & | Imm, | ||
| Type * | Ty | ||
| ) | const |
Definition at line 242 of file TargetTransformInfo.cpp.
References assert().
| int llvm::TargetTransformInfo::getIntrinsicCost | ( | Intrinsic::ID | IID, |
| Type * | RetTy, | ||
| ArrayRef< Type * > | ParamTys | ||
| ) | const |
Estimate the cost of an intrinsic when lowered.
Mirrors the getCallCost method but uses an intrinsic identifier.
| int TargetTransformInfo::getIntrinsicCost | ( | Intrinsic::ID | IID, |
| Type * | RetTy, | ||
| ArrayRef< const Value * > | Arguments | ||
| ) | const |
Estimate the cost of an intrinsic when lowered.
Mirrors the getCallCost method but uses an intrinsic identifier.
Definition at line 79 of file TargetTransformInfo.cpp.
References assert().
| int TargetTransformInfo::getIntrinsicInstrCost | ( | Intrinsic::ID | ID, |
| Type * | RetTy, | ||
| ArrayRef< Type * > | Tys, | ||
| FastMathFlags | FMF | ||
| ) | const |
Definition at line 365 of file TargetTransformInfo.cpp.
References assert().
Referenced by getVectorIntrinsicCost().
| int TargetTransformInfo::getIntrinsicInstrCost | ( | Intrinsic::ID | ID, |
| Type * | RetTy, | ||
| ArrayRef< Value * > | Args, | ||
| FastMathFlags | FMF | ||
| ) | const |
Definition at line 373 of file TargetTransformInfo.cpp.
References assert().
| unsigned TargetTransformInfo::getJumpBufAlignment | ( | ) | const |
Returns the target's jmp_buf alignment in bytes.
Definition at line 170 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getJumpBufSize | ( | ) | const |
Returns the target's jmp_buf size in bytes.
Definition at line 174 of file TargetTransformInfo.cpp.
Definition at line 427 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 451 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getMaskedMemoryOpCost | ( | unsigned | Opcode, |
| Type * | Src, | ||
| unsigned | Alignment, | ||
| unsigned | AddressSpace | ||
| ) | const |
Definition at line 338 of file TargetTransformInfo.cpp.
References assert().
Definition at line 273 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::runImpl().
| unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead | ( | ) | const |
Definition at line 269 of file TargetTransformInfo.cpp.
| int TargetTransformInfo::getMemoryOpCost | ( | unsigned | Opcode, |
| Type * | Src, | ||
| unsigned | Alignment, | ||
| unsigned | AddressSpace | ||
| ) | const |
Definition at line 330 of file TargetTransformInfo.cpp.
References assert().
| unsigned TargetTransformInfo::getMinPrefetchStride | ( | ) | const |
Definition at line 265 of file TargetTransformInfo.cpp.
Definition at line 388 of file TargetTransformInfo.cpp.
Definition at line 249 of file TargetTransformInfo.cpp.
Referenced by llvm::SLPVectorizerPass::runImpl(), and llvm::LoopVectorizePass::runImpl().
| int TargetTransformInfo::getOperationCost | ( | unsigned | Opcode, |
| Type * | Ty, | ||
| Type * | OpTy = nullptr |
||
| ) | const |
Estimate the cost of a specific operation when lowered.
Note that this is designed to work on an arbitrary synthetic opcode, and thus work for hypothetical queries before an instruction has even been formed. However, this does not work for GEPs, and must not be called for a GEP instruction. Instead, use the dedicated getGEPCost interface as analyzing a GEP's cost required more information.
Typically only the result type is required, and the operand type can be omitted. However, if the opcode is one of the cast instructions, the operand type is required.
The returned cost is defined in terms of TargetCostConstants, see its comments for a detailed explanation of the cost values.
Definition at line 50 of file TargetTransformInfo.cpp.
References assert().
| Value * TargetTransformInfo::getOrCreateResultFromMemIntrinsic | ( | IntrinsicInst * | Inst, |
| Type * | ExpectedType | ||
| ) | const |
Definition at line 417 of file TargetTransformInfo.cpp.
| TargetTransformInfo::PopcntSupportKind TargetTransformInfo::getPopcntSupport | ( | unsigned | IntTyWidthInBit | ) | const |
Return hardware support for population count.
Definition at line 207 of file TargetTransformInfo.cpp.
| unsigned TargetTransformInfo::getPrefetchDistance | ( | ) | const |
Definition at line 261 of file TargetTransformInfo.cpp.
Calculate the cost of performing a vector reduction.
This is the cost of reducing the vector value of type Ty to a scalar value using the operation denoted by Opcode. The form of the reduction can either be a pairwise reduction or a reduction that splits the vector at every reduction level.
Pairwise: (v0, v1, v2, v3) ((v0+v1), (v2, v3), undef, undef) Split: (v0, v1, v2, v3) ((v0+v2), (v1+v3), undef, undef)
Definition at line 400 of file TargetTransformInfo.cpp.
References assert().
Definition at line 253 of file TargetTransformInfo.cpp.
| int 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 142 of file TargetTransformInfo.cpp.
References assert().
Referenced by getScalingFactorCost().
| int TargetTransformInfo::getShuffleCost | ( | ShuffleKind | Kind, |
| Type * | Tp, | ||
| int | Index = 0, |
||
| Type * | SubTp = nullptr |
||
| ) | const |
Definition at line 288 of file TargetTransformInfo.cpp.
References assert().
| unsigned TargetTransformInfo::getStoreVectorFactor | ( | unsigned | VF, |
| unsigned | StoreSize, | ||
| unsigned | ChainSizeInBytes, | ||
| VectorType * | VecTy | ||
| ) | const |
SizeInBytes stores or has a better vector factor. Definition at line 458 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::getTgtMemIntrinsic | ( | IntrinsicInst * | Inst, |
| MemIntrinsicInfo & | Info | ||
| ) | const |
Definition at line 412 of file TargetTransformInfo.cpp.
| void TargetTransformInfo::getUnrollingPreferences | ( | Loop * | L, |
| UnrollingPreferences & | UP | ||
| ) | 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 104 of file TargetTransformInfo.cpp.
Referenced by gatherUnrollingPreferences().
Estimate the cost of a given IR user when lowered.
This can estimate the cost of either a ConstantExpr or Instruction when lowered. It has two primary advantages over the getOperationCost and getGEPCost above, and one significant disadvantage: it can only be used when the IR construct has already been formed.
The advantages are that it can inspect the SSA use graph to reason more accurately about the cost. For example, all-constant-GEPs can often be folded into a load or other instruction, but if they are used in some other context they may not be folded. This routine can distinguish such cases.
The returned cost is defined in terms of TargetCostConstants, see its comments for a detailed explanation of the cost values.
Definition at line 86 of file TargetTransformInfo.cpp.
References assert().
Referenced by llvm::CodeMetrics::analyzeBasicBlock(), analyzeLoopUnrollCost(), llvm::ComputeSpeculationCost(), and ComputeSpeculationCost().
| int TargetTransformInfo::getVectorInstrCost | ( | unsigned | Opcode, |
| Type * | Val, | ||
| unsigned | Index = -1 |
||
| ) | const |
Definition at line 323 of file TargetTransformInfo.cpp.
References assert().
Referenced by getScalarizationOverhead(), and llvm::slpvectorizer::BoUpSLP::getTreeCost().
| 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 92 of file TargetTransformInfo.cpp.
Referenced by llvm::SpeculativeExecutionPass::runImpl(), and llvm::DivergenceAnalysis::runOnFunction().
Return true if the hardware has a fast square-root instruction.
Definition at line 211 of file TargetTransformInfo.cpp.
Referenced by runPartiallyInlineLibCalls().
|
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 97 of file TargetTransformInfo.h.
| bool TargetTransformInfo::isFoldableMemAccessOffset | ( | Instruction * | I, |
| int64_t | Offset | ||
| ) | const |
Return true if target supports the load / store instruction with the given Offset on the form reg + Offset.
It may be that Offset is too big for a certain type (register class).
Definition at line 153 of file TargetTransformInfo.cpp.
| 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 193 of file TargetTransformInfo.cpp.
Referenced by llvm::LoopVectorizePass::processLoop().
| 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 109 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalAddressingMode | ( | Type * | Ty, |
| GlobalValue * | BaseGV, | ||
| int64_t | BaseOffset, | ||
| bool | HasBaseReg, | ||
| int64_t | Scale, | ||
| unsigned | AddrSpace = 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. TODO: Handle pre/postinc as well.
Definition at line 117 of file TargetTransformInfo.cpp.
Referenced by isAddFoldable(), and isAMCompletelyFolded().
| 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 113 of file TargetTransformInfo.cpp.
Referenced by isAMCompletelyFolded().
Definition at line 134 of file TargetTransformInfo.cpp.
Definition at line 130 of file TargetTransformInfo.cpp.
Return true if the target supports masked gather/scatter AVX-512 fully supports gather and scatter for vectors with 32 and 64 bits scalar type.
Definition at line 138 of file TargetTransformInfo.cpp.
Return true if the target supports masked load/store AVX2 and AVX-512 targets allow masks for consecutive load and store.
Definition at line 126 of file TargetTransformInfo.cpp.
Definition at line 431 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalToVectorizeLoadChain | ( | unsigned | ChainSizeInBytes, |
| unsigned | Alignment, | ||
| unsigned | AddrSpace | ||
| ) | const |
Definition at line 439 of file TargetTransformInfo.cpp.
Definition at line 435 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::isLegalToVectorizeStoreChain | ( | unsigned | ChainSizeInBytes, |
| unsigned | Alignment, | ||
| unsigned | AddrSpace | ||
| ) | const |
Definition at line 445 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 100 of file TargetTransformInfo.cpp.
Referenced by llvm::CodeMetrics::analyzeBasicBlock(), and findTRECandidate().
| 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 162 of file TargetTransformInfo.cpp.
Referenced by HoistThenElseCodeToIf().
Returns whether V is a source of divergence.
This function provides the target-dependent information for the target-independent DivergenceAnalysis. DivergenceAnalysis first builds the dependency graph, and then runs the reachability algorithm starting with the sources of divergence.
Definition at line 96 of file TargetTransformInfo.cpp.
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 158 of file TargetTransformInfo.cpp.
Referenced by llvm::SCEVExpander::replaceCongruentIVs().
Return true if this type is legal.
Definition at line 166 of file TargetTransformInfo.cpp.
Referenced by llvm::computeMinimumValueSizes(), and ShouldBuildLookupTable().
| TargetTransformInfo & TargetTransformInfo::operator= | ( | TargetTransformInfo && | RHS | ) |
Definition at line 45 of file TargetTransformInfo.cpp.
| bool TargetTransformInfo::shouldBuildLookupTables | ( | ) | const |
Return true if switches should be turned into lookup tables for the target.
Definition at line 178 of file TargetTransformInfo.cpp.
Referenced by SwitchToLookupTable().
Return true if switches should be turned into lookup tables containing this constant value for the target.
Definition at line 181 of file TargetTransformInfo.cpp.
Referenced by ValidLookupTableConstant().
1.8.6