14#ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H
15#define LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H
55 if (!isa<Constant>(Operand))
68 return SI.getNumCases();
131 std::pair<const Value *, unsigned>
133 return std::make_pair(
nullptr, -1);
142 assert(
F &&
"A concrete function must be provided to this routine.");
149 if (
F->isIntrinsic())
152 if (
F->hasLocalLinkage() || !
F->hasName())
158 if (
Name ==
"copysign" ||
Name ==
"copysignf" ||
Name ==
"copysignl" ||
168 Name ==
"exp2l" ||
Name ==
"exp2f" ||
Name ==
"floor" ||
169 Name ==
"floorf" ||
Name ==
"ceil" ||
Name ==
"round" ||
195 std::optional<Value *>
198 bool &KnownBitsComputed)
const {
206 SimplifyAndSetOp)
const {
224 bool HasBaseReg, int64_t Scale,
unsigned AddrSpace,
226 int64_t ScalableOffset = 0)
const {
229 return !BaseGV && BaseOffset == 0 && (Scale == 0 || Scale == 1);
297 Align Alignment)
const {
329 int64_t BaseOffset,
bool HasBaseReg,
331 unsigned AddrSpace)
const {
345 bool useAA()
const {
return false; }
360 const APInt &DemandedElts,
361 bool Insert,
bool Extract,
382 bool IsZeroCmp)
const {
392 return isa<SelectInst>(
I) &&
405 unsigned *
Fast)
const {
460 return "Generic::Unknown Register Class";
462 return "Generic::ScalarRC";
464 return "Generic::VectorRC";
487 unsigned getMaximumVF(
unsigned ElemWidth,
unsigned Opcode)
const {
return 0; }
491 const Instruction &
I,
bool &AllowPromotionWithoutCommonHeader)
const {
492 AllowPromotionWithoutCommonHeader =
false;
497 std::optional<unsigned>
508 std::optional<unsigned>
524 unsigned NumStridedMemAccesses,
525 unsigned NumPrefetches,
bool HasCall)
const {
541 auto IsWidenableCondition = [](
const Value *V) {
542 if (
auto *II = dyn_cast<IntrinsicInst>(V))
543 if (II->
getIntrinsicID() == Intrinsic::experimental_widenable_condition)
552 case Instruction::FDiv:
553 case Instruction::FRem:
554 case Instruction::SDiv:
555 case Instruction::SRem:
556 case Instruction::UDiv:
557 case Instruction::URem:
560 case Instruction::And:
561 case Instruction::Or:
562 if (
any_of(Args, IsWidenableCondition))
598 case Instruction::IntToPtr: {
599 unsigned SrcSize = Src->getScalarSizeInBits();
605 case Instruction::PtrToInt: {
606 unsigned DstSize = Dst->getScalarSizeInBits();
612 case Instruction::BitCast:
613 if (Dst == Src || (Dst->isPointerTy() && Src->isPointerTy()))
617 case Instruction::Trunc: {
631 unsigned Index)
const {
660 unsigned Index)
const {
665 const APInt &DemandedDstElts,
692 const Value *
Ptr,
bool VariableMask,
700 const Value *
Ptr,
bool VariableMask,
710 bool UseMaskForCond,
bool UseMaskForGaps)
const {
716 switch (ICA.
getID()) {
719 case Intrinsic::allow_runtime_check:
720 case Intrinsic::allow_ubsan_check:
721 case Intrinsic::annotation:
722 case Intrinsic::assume:
723 case Intrinsic::sideeffect:
724 case Intrinsic::pseudoprobe:
725 case Intrinsic::arithmetic_fence:
726 case Intrinsic::dbg_assign:
727 case Intrinsic::dbg_declare:
728 case Intrinsic::dbg_value:
729 case Intrinsic::dbg_label:
730 case Intrinsic::invariant_start:
731 case Intrinsic::invariant_end:
732 case Intrinsic::launder_invariant_group:
733 case Intrinsic::strip_invariant_group:
734 case Intrinsic::is_constant:
735 case Intrinsic::lifetime_start:
736 case Intrinsic::lifetime_end:
737 case Intrinsic::experimental_noalias_scope_decl:
738 case Intrinsic::objectsize:
739 case Intrinsic::ptr_annotation:
740 case Intrinsic::var_annotation:
741 case Intrinsic::experimental_gc_result:
742 case Intrinsic::experimental_gc_relocate:
743 case Intrinsic::coro_alloc:
744 case Intrinsic::coro_begin:
745 case Intrinsic::coro_free:
746 case Intrinsic::coro_end:
747 case Intrinsic::coro_frame:
748 case Intrinsic::coro_size:
749 case Intrinsic::coro_align:
750 case Intrinsic::coro_suspend:
751 case Intrinsic::coro_subfn_addr:
752 case Intrinsic::threadlocal_address:
753 case Intrinsic::experimental_widenable_condition:
754 case Intrinsic::ssa_copy:
771 const SCEV *)
const {
776 std::optional<FastMathFlags> FMF,
818 Type *ExpectedType)
const {
824 unsigned SrcAddrSpace,
unsigned DestAddrSpace,
825 unsigned SrcAlign,
unsigned DestAlign,
826 std::optional<uint32_t> AtomicElementSize)
const {
833 unsigned RemainingBytes,
unsigned SrcAddrSpace,
unsigned DestAddrSpace,
834 unsigned SrcAlign,
unsigned DestAlign,
835 std::optional<uint32_t> AtomicCpySize)
const {
836 unsigned OpSizeInBytes = AtomicCpySize ? *AtomicCpySize : 1;
838 for (
unsigned i = 0; i != RemainingBytes; i += OpSizeInBytes)
844 return (Caller->getFnAttribute(
"target-cpu") ==
845 Callee->getFnAttribute(
"target-cpu")) &&
846 (Caller->getFnAttribute(
"target-features") ==
847 Callee->getFnAttribute(
"target-features"));
851 unsigned DefaultCallPenalty)
const {
852 return DefaultCallPenalty;
857 return (Caller->getFnAttribute(
"target-cpu") ==
858 Callee->getFnAttribute(
"target-cpu")) &&
859 (Caller->getFnAttribute(
"target-features") ==
860 Callee->getFnAttribute(
"target-features"));
880 unsigned AddrSpace)
const {
885 unsigned AddrSpace)
const {
897 unsigned ChainSizeInBytes,
903 unsigned ChainSizeInBytes,
933 Align Alignment)
const {
952 if (isa<ConstantDataVector>(Val) || isa<ConstantVector>(Val)) {
953 const auto *VectorValue = cast<Constant>(Val);
957 auto *VT = cast<FixedVectorType>(Val->
getType());
963 unsigned MaxRequiredSize =
964 VT->getElementType()->getPrimitiveSizeInBits().getFixedValue();
966 unsigned MinRequiredSize = 0;
967 for (
unsigned i = 0, e = VT->getNumElements(); i < e; ++i) {
968 if (
auto *IntElement =
969 dyn_cast<ConstantInt>(VectorValue->getAggregateElement(i))) {
970 bool signedElement = IntElement->getValue().isNegative();
972 unsigned ElementMinRequiredSize =
973 IntElement->getValue().getSignificantBits() - 1;
977 MinRequiredSize = std::max(MinRequiredSize, ElementMinRequiredSize);
980 return MaxRequiredSize;
983 return MinRequiredSize;
986 if (
const auto *CI = dyn_cast<ConstantInt>(Val)) {
987 isSigned = CI->getValue().isNegative();
988 return CI->getValue().getSignificantBits() - 1;
991 if (
const auto *Cast = dyn_cast<SExtInst>(Val)) {
993 return Cast->getSrcTy()->getScalarSizeInBits() - 1;
996 if (
const auto *Cast = dyn_cast<ZExtInst>(Val)) {
998 return Cast->getSrcTy()->getScalarSizeInBits();
1006 return Ptr && isa<SCEVAddRecExpr>(
Ptr);
1018 int64_t MergeDistance)
const {
1032template <
typename T>
1046 assert(PointeeType &&
Ptr &&
"can't get GEPCost of nullptr");
1047 auto *BaseGV = dyn_cast<GlobalValue>(
Ptr->stripPointerCasts());
1048 bool HasBaseReg = (BaseGV ==
nullptr);
1051 APInt BaseOffset(PtrSizeBits, 0);
1055 Type *TargetType =
nullptr;
1063 TargetType = GTI.getIndexedType();
1066 const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*
I);
1069 ConstIdx = dyn_cast<ConstantInt>(
Splat);
1070 if (
StructType *STy = GTI.getStructTypeOrNull()) {
1072 assert(ConstIdx &&
"Unexpected GEP index");
1080 int64_t ElementSize =
1081 GTI.getSequentialElementStride(
DL).getFixedValue();
1090 Scale = ElementSize;
1105 AccessType = TargetType;
1112 Ptr->getType()->getPointerAddressSpace()))
1137 for (
const Value *V : Ptrs) {
1138 const auto *
GEP = dyn_cast<GetElementPtrInst>(V);
1141 if (
Info.isSameBase() && V !=
Base) {
1142 if (
GEP->hasAllConstantIndices())
1151 GEP->getPointerOperand(),
1163 auto *TargetTTI =
static_cast<T *
>(
this);
1166 auto *CB = dyn_cast<CallBase>(U);
1167 if (CB && !isa<IntrinsicInst>(U)) {
1168 if (
const Function *
F = CB->getCalledFunction()) {
1169 if (!TargetTTI->isLoweredToCall(
F))
1178 Type *Ty = U->getType();
1180 auto *
I = dyn_cast<Instruction>(U);
1184 case Instruction::Call: {
1185 assert(isa<IntrinsicInst>(U) &&
"Unexpected non-intrinsic call");
1186 auto *Intrinsic = cast<IntrinsicInst>(U);
1188 return TargetTTI->getIntrinsicInstrCost(CostAttrs,
CostKind);
1190 case Instruction::Br:
1191 case Instruction::Ret:
1192 case Instruction::PHI:
1193 case Instruction::Switch:
1194 return TargetTTI->getCFInstrCost(Opcode,
CostKind,
I);
1195 case Instruction::ExtractValue:
1196 case Instruction::Freeze:
1198 case Instruction::Alloca:
1199 if (cast<AllocaInst>(U)->isStaticAlloca())
1202 case Instruction::GetElementPtr: {
1203 const auto *
GEP = cast<GEPOperator>(U);
1204 Type *AccessType =
nullptr;
1207 if (
GEP->hasOneUser() &&
I)
1208 AccessType =
I->user_back()->getAccessType();
1210 return TargetTTI->getGEPCost(
GEP->getSourceElementType(),
1214 case Instruction::Add:
1215 case Instruction::FAdd:
1216 case Instruction::Sub:
1217 case Instruction::FSub:
1218 case Instruction::Mul:
1219 case Instruction::FMul:
1220 case Instruction::UDiv:
1221 case Instruction::SDiv:
1222 case Instruction::FDiv:
1223 case Instruction::URem:
1224 case Instruction::SRem:
1225 case Instruction::FRem:
1226 case Instruction::Shl:
1227 case Instruction::LShr:
1228 case Instruction::AShr:
1229 case Instruction::And:
1230 case Instruction::Or:
1231 case Instruction::Xor:
1232 case Instruction::FNeg: {
1235 if (Opcode != Instruction::FNeg)
1237 return TargetTTI->getArithmeticInstrCost(Opcode, Ty,
CostKind, Op1Info,
1240 case Instruction::IntToPtr:
1241 case Instruction::PtrToInt:
1242 case Instruction::SIToFP:
1243 case Instruction::UIToFP:
1244 case Instruction::FPToUI:
1245 case Instruction::FPToSI:
1246 case Instruction::Trunc:
1247 case Instruction::FPTrunc:
1248 case Instruction::BitCast:
1249 case Instruction::FPExt:
1250 case Instruction::SExt:
1251 case Instruction::ZExt:
1252 case Instruction::AddrSpaceCast: {
1254 return TargetTTI->getCastInstrCost(
1257 case Instruction::Store: {
1258 auto *SI = cast<StoreInst>(U);
1261 return TargetTTI->getMemoryOpCost(Opcode, ValTy, SI->getAlign(),
1262 SI->getPointerAddressSpace(),
CostKind,
1265 case Instruction::Load: {
1269 auto *LI = cast<LoadInst>(U);
1270 Type *LoadType = U->getType();
1280 if (
const TruncInst *TI = dyn_cast<TruncInst>(*LI->user_begin()))
1281 LoadType = TI->getDestTy();
1283 return TargetTTI->getMemoryOpCost(Opcode, LoadType, LI->getAlign(),
1285 {TTI::OK_AnyValue, TTI::OP_None},
I);
1287 case Instruction::Select: {
1288 const Value *Op0, *Op1;
1299 return TargetTTI->getArithmeticInstrCost(
1304 return TargetTTI->getCmpSelInstrCost(Opcode, U->getType(), CondTy,
1308 case Instruction::ICmp:
1309 case Instruction::FCmp: {
1312 return TargetTTI->getCmpSelInstrCost(Opcode, ValTy, U->getType(),
1313 I ? cast<CmpInst>(
I)->getPredicate()
1317 case Instruction::InsertElement: {
1318 auto *IE = dyn_cast<InsertElementInst>(U);
1322 if (
auto *CI = dyn_cast<ConstantInt>(
Operands[2]))
1323 if (CI->getValue().getActiveBits() <= 32)
1324 Idx = CI->getZExtValue();
1325 return TargetTTI->getVectorInstrCost(*IE, Ty,
CostKind,
Idx);
1327 case Instruction::ShuffleVector: {
1328 auto *Shuffle = dyn_cast<ShuffleVectorInst>(U);
1332 auto *VecTy = cast<VectorType>(U->getType());
1335 int NumSubElts, SubIndex;
1338 if (Shuffle->changesLength()) {
1340 if (Shuffle->increasesLength() && Shuffle->isIdentityWithPadding())
1343 if (Shuffle->isExtractSubvectorMask(SubIndex))
1348 if (Shuffle->isInsertSubvectorMask(NumSubElts, SubIndex))
1349 return TargetTTI->getShuffleCost(
1354 int ReplicationFactor, VF;
1355 if (Shuffle->isReplicationMask(ReplicationFactor, VF)) {
1359 DemandedDstElts.
setBit(
I.index());
1361 return TargetTTI->getReplicationShuffleCost(
1362 VecSrcTy->getElementType(), ReplicationFactor, VF,
1366 bool IsUnary = isa<UndefValue>(
Operands[1]);
1367 NumSubElts = VecSrcTy->getElementCount().getKnownMinValue();
1373 if (Shuffle->increasesLength()) {
1374 for (
int &M : AdjustMask)
1375 M = M >= NumSubElts ? (M + (Mask.size() - NumSubElts)) : M;
1377 return TargetTTI->getShuffleCost(
1391 std::iota(ExtractMask.
begin(), ExtractMask.
end(), 0);
1392 return ShuffleCost + TargetTTI->getShuffleCost(
1394 ExtractMask,
CostKind, 0, VecTy, {}, Shuffle);
1397 if (Shuffle->isIdentity())
1400 if (Shuffle->isReverse())
1404 if (Shuffle->isSelect())
1408 if (Shuffle->isTranspose())
1413 if (Shuffle->isZeroEltSplat())
1418 if (Shuffle->isSingleSource())
1423 if (Shuffle->isInsertSubvectorMask(NumSubElts, SubIndex))
1424 return TargetTTI->getShuffleCost(
1429 if (Shuffle->isSplice(SubIndex))
1431 SubIndex,
nullptr,
Operands, Shuffle);
1436 case Instruction::ExtractElement: {
1437 auto *EEI = dyn_cast<ExtractElementInst>(U);
1441 if (
auto *CI = dyn_cast<ConstantInt>(
Operands[1]))
1442 if (CI->getValue().getActiveBits() <= 32)
1443 Idx = CI->getZExtValue();
1445 return TargetTTI->getVectorInstrCost(*EEI, DstTy,
CostKind,
Idx);
1455 auto *TargetTTI =
static_cast<T *
>(
this);
Analysis containing CSE Info
static cl::opt< TargetTransformInfo::TargetCostKind > CostKind("cost-kind", cl::desc("Target cost kind"), cl::init(TargetTransformInfo::TCK_RecipThroughput), cl::values(clEnumValN(TargetTransformInfo::TCK_RecipThroughput, "throughput", "Reciprocal throughput"), clEnumValN(TargetTransformInfo::TCK_Latency, "latency", "Instruction latency"), clEnumValN(TargetTransformInfo::TCK_CodeSize, "code-size", "Code size"), clEnumValN(TargetTransformInfo::TCK_SizeAndLatency, "size-latency", "Code size and latency")))
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static bool isSigned(unsigned int Opcode)
mir Rename Register Operands
static cl::opt< RegAllocEvictionAdvisorAnalysis::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysis::AdvisorMode::Development, "development", "for training")))
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SymbolRef::Type getType(const Symbol *Sym)
Class for arbitrary precision integers.
void setBit(unsigned BitPosition)
Set the given bit to 1 whose position is given as "bitPosition".
unsigned getBitWidth() const
Return the number of bits in the APInt.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
A cache of @llvm.assume calls within a function.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Conditional or Unconditional Branch instruction.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
This is the shared class of boolean and integer constants.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
const APInt & getValue() const
Return the constant as an APInt value reference.
This is an important base class in LLVM.
A parsed version of the target data layout string in and methods for querying it.
bool isLegalInteger(uint64_t Width) const
Returns true if the specified type is known to be a native integer type supported by the CPU.
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)
Convenience struct for specifying and reasoning about fast-math flags.
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
The core instruction combiner logic.
static InstructionCost getInvalid(CostType Val=0)
Intrinsic::ID getID() const
A wrapper class for inspecting calls to intrinsic functions.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Represents a single loop in the control flow graph.
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Analysis providing profile information.
The RecurrenceDescriptor is used to identify recurrences variables in a loop.
This node represents a polynomial recurrence on the trip count of the specified loop.
const SCEV * getStepRecurrence(ScalarEvolution &SE) const
Constructs and returns the recurrence indicating how much this expression steps by.
This class represents a constant integer value.
const APInt & getAPInt() const
This class represents an analyzed expression in the program.
The main scalar evolution driver.
This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
TypeSize getElementOffset(unsigned Idx) const
Class to represent struct types.
Provides information about what library functions are available for the current target.
This class represents a truncation of integer types.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static IntegerType * getIntNTy(LLVMContext &C, unsigned N)
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
static IntegerType * getInt8Ty(LLVMContext &C)
bool isFloatingPointTy() const
Return true if this is one of the floating-point types.
bool isScalableTy() const
Return true if this is a type whose size is a known multiple of vscale.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
This is the common base class for vector predication intrinsics.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
Base class of all SIMD vector types.
constexpr ScalarTy getFixedValue() const
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ Fast
Attempts to make calls as fast as possible (e.g.
@ C
The default llvm calling convention, compatible with C.
bool match(Val *V, const Pattern &P)
auto m_LogicalOr()
Matches L || R where L and R are arbitrary values.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
auto m_LogicalAnd()
Matches L && R where L and R are arbitrary values.
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
This is an optimization pass for GlobalISel generic memory operations.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
constexpr int PoisonMaskElem
constexpr unsigned BitWidth
gep_type_iterator gep_type_begin(const User *GEP)
@ DataWithoutLaneMask
Same as Data, but avoids using the get.active.lane.mask intrinsic to calculate the mask and instead i...
This struct is a compact representation of a valid (non-zero power of two) alignment.
Attributes of a target dependent hardware loop.
Information about a load/store intrinsic defined by the target.