Concrete BasicTTIImpl that can be used if no further customization is needed.
Synopsis
Declared in <llvm/CodeGen/BasicTTIImpl.h>
class BasicTTIImpl
: public BasicTTIImplBase<BasicTTIImpl>Base Classes
Name |
Description |
Base class which can be used to help build a TTI implementation. |
Member Functions
Name |
Description |
|
Construct a BasicTTIImpl for function |
|
Return false if an |
|
Return an additive adjustment to the inlining threshold for call |
|
Return true if the target supports misaligned memory accesses. |
|
Return true if |
|
Collect flat‐address operand indexes of intrinsic |
|
Return true if prefetching should also be done for writes. |
|
Return the cost of address computation for a memory access. |
|
Approximate the reciprocal throughput of an arithmetic or logic op. |
|
Calculate the cost of a vector arithmetic reduction. |
|
Return an address space the target assumes for pointer value |
|
Return the estimated latency penalty of a branch misprediction. |
|
Return the expected cost of a control‐flow instruction. |
|
Return the associativity of cache level |
|
Return the size of a cache line in bytes. |
|
Return the size of cache level |
|
Compute the cost of a call with the given signature. |
|
Return the extra inlining threshold cost of leaving alloca |
|
Return the expected cost of a cast instruction. |
|
Return the expected cost of a compare or select instruction. |
|
Return the minimum VF for which epilogue vectorization should be considered. |
|
Estimate how many case clusters |
|
Return the cost of an extended reduction pattern. |
|
Return the expected cost of a sign‐ or zero‐extended vector extract. |
|
Return the expected cost of supporting floating‐point ops of type |
|
Return the flat address space used to optimize addrspacecasts, or ~0u. |
|
Estimate the cost of a GEP when lowered. |
|
Return the cost of insert/extract Index lanes from the end of a vector. |
|
Return the inliner bonus percent for vector‐dense callers/callees. |
|
Return a multiplier applied to the inlining threshold for this target. |
|
Return the cost of an interleaved memory operation. |
|
Return the cost of an intrinsic, analyzing real arguments when present. |
|
Return the maximum interleave factor transforms should try for this target. |
|
Return the maximum number of iterations to prefetch ahead. |
|
Return the architectural maximum vscale, if the target specifies one. |
|
Return the cost of a memory intrinsic described by |
|
Return the cost of a load or store of type |
|
Calculate the cost of min/max reduction operations. |
|
Return the minimum stride in bytes where software prefetching helps. |
|
Return the cost of a multiply‐accumulate reduction pattern. |
|
Return how many pieces |
|
Estimate the overhead of scalarizing an instruction's operands. |
Estimate the cost of a strict in‐order (ordered) reduction. |
|
|
Return the cost of a partial reduction to a narrower vector. |
|
Fill |
|
Return a predicate value and address space assumed for pointer |
Return a preferred large GEP base offset within []`MinOffset,` |
|
|
Return the preferred style of tail folding for this target. |
|
Return how far before a load to place a prefetch, in instructions. |
|
Return the estimated number of registers required to represent |
|
Return the bit width of the largest register of kind |
|
Return the cost of replicating |
|
|
|
Return the cost of the scaling factor in addressing mode for type |
|
Return the cost of a shuffle producing |
|
Return a smaller store VF that may still be profitable to vectorize. |
Estimate arithmetic and shuffle costs for a tree‐wise reduction. |
|
Return an intrinsic cost based on argument types only. |
|
Estimate the cost of type‐legalization and the legalized type. |
|
|
Fill |
|
Return the vscale value to use when tuning the cost model. |
|
|
Return the cost of splitting a vector into legal parts. |
|
|
Return true if branch divergence exists for threads executing |
|
Return true if the hardware has a fast carry‐less multiply for |
|
Return true if the hardware has a fast square‐root for type |
Refine |
|
|
Attempt target‐specific InstCombine folds for intrinsic |
|
Return true if an ordered FP compare is cheaper than comparing against zero. |
|
Return true if converting loop |
|
Return true if an indexed load of mode |
|
Return true if an indexed store of mode |
|
Return true if LSR cost |
|
Return true if |
|
Return true if adding scalable immediate |
|
Return true if the described addressing mode is legal for type |
|
Return true if |
|
Return true if casting from |
|
Return true if register count is the major cost metric for LSR. |
|
Return true if LSR should keep optimizing a chain that includes |
|
Return true if it is profitable to hoist |
|
Return true if the target is configured for a single‐threaded model. |
|
Return true if the vector intrinsic overloads on the type at |
|
Return true if the vector form of the intrinsic has a scalar at |
Return true if a struct‐returning target intrinsic overloads field |
|
|
Return true if truncating |
|
Return true if |
|
Return true if casting from |
|
Return true if a tail‐folded vector loop is preferred over a scalar epilogue. |
|
Return true if constants should stay attached to |
|
Rewrite intrinsic |
|
Return true if switches should be turned into lookup tables on this target. |
|
Return true if lookup tables should use relative offsets on this target. |
|
Return true if LSR should drop solutions worse than the baseline. |
|
Return true if the target wants a prefetch in address space |
|
Simplify a target intrinsic using demanded result bits. |
|
Simplify a target intrinsic using demanded vector elements. |
|
Return true if the target benefits from alias‐analysis in codegen. |
Protected Using Declarations
Name |
Description |
Data layout associated with this TTI implementation. |
|
Expose base‐class scalarization overhead helpers. |
Friends
Name |
Description |
Base class which can be used to help build a TTI implementation. |
Created with MrDocs