22 #ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
23 #define LLVM_ANALYSIS_TARGETTRANSFORMINFO_H
29 #include "llvm/Support/DataTypes.h"
37 class PreservedAnalyses;
132 Type *OpTy =
nullptr)
const;
308 bool HasBaseReg, int64_t Scale,
309 unsigned AddrSpace = 0)
const;
325 bool HasBaseReg, int64_t Scale,
326 unsigned AddrSpace = 0)
const;
424 Type *SubTp =
nullptr)
const;
436 Type *CondTy =
nullptr)
const;
441 unsigned Index = -1)
const;
479 bool IsPairwiseForm)
const;
520 Type *ExpectedType)
const;
536 template <
typename T>
class Model;
538 std::unique_ptr<Concept> TTIImpl;
564 int64_t BaseOffset,
bool HasBaseReg,
566 unsigned AddrSpace) = 0;
570 int64_t BaseOffset,
bool HasBaseReg,
571 int64_t Scale,
unsigned AddrSpace) = 0;
608 unsigned AddressSpace) = 0;
613 unsigned AddressSpace) = 0;
615 bool IsPairwiseForm) = 0;
626 Type *ExpectedType) = 0;
631 template <
typename T>
636 Model(
T Impl) : Impl(std::move(Impl)) {}
639 const DataLayout &getDataLayout()
const override {
640 return Impl.getDataLayout();
644 return Impl.getOperationCost(Opcode, Ty, OpTy);
647 ArrayRef<const Value *>
Operands)
override {
648 return Impl.getGEPCost(Ptr, Operands);
650 unsigned getCallCost(FunctionType *FTy,
int NumArgs)
override {
651 return Impl.getCallCost(FTy, NumArgs);
654 return Impl.getCallCost(F, NumArgs);
657 ArrayRef<const Value *> Arguments)
override {
658 return Impl.getCallCost(F, Arguments);
661 ArrayRef<Type *> ParamTys)
override {
662 return Impl.getIntrinsicCost(IID, RetTy, ParamTys);
665 ArrayRef<const Value *> Arguments)
override {
666 return Impl.getIntrinsicCost(IID, RetTy, Arguments);
668 unsigned getUserCost(
const User *U)
override {
return Impl.getUserCost(U); }
671 return Impl.isSourceOfDivergence(V);
674 return Impl.isLoweredToCall(F);
677 return Impl.getUnrollingPreferences(L, UP);
680 return Impl.isLegalAddImmediate(Imm);
683 return Impl.isLegalICmpImmediate(Imm);
686 bool HasBaseReg, int64_t Scale,
687 unsigned AddrSpace)
override {
688 return Impl.isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
692 return Impl.isLegalMaskedStore(DataType, Consecutive);
695 return Impl.isLegalMaskedLoad(DataType, Consecutive);
698 bool HasBaseReg, int64_t Scale,
699 unsigned AddrSpace)
override {
700 return Impl.getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg,
704 return Impl.isTruncateFree(Ty1, Ty2);
707 return Impl.isProfitableToHoist(I);
711 unsigned getJumpBufSize()
override {
return Impl.getJumpBufSize(); }
713 return Impl.shouldBuildLookupTables();
716 return Impl.enableAggressiveInterleaving(LoopHasReductions);
719 return Impl.getPopcntSupport(IntTyWidthInBit);
724 return Impl.getFPOpCost(Ty);
728 return Impl.getIntImmCost(Imm, Ty);
730 unsigned getIntImmCost(
unsigned Opc,
unsigned Idx,
const APInt &Imm,
732 return Impl.getIntImmCost(Opc, Idx, Imm, Ty);
736 return Impl.getIntImmCost(IID, Idx, Imm, Ty);
739 return Impl.getNumberOfRegisters(Vector);
742 return Impl.getRegisterBitWidth(Vector);
745 return Impl.getMaxInterleaveFactor(VF);
752 return Impl.getArithmeticInstrCost(Opcode, Ty, Opd1Info, Opd2Info,
753 Opd1PropInfo, Opd2PropInfo);
756 Type *SubTp)
override {
757 return Impl.getShuffleCost(Kind, Tp, Index, SubTp);
760 return Impl.getCastInstrCost(Opcode, Dst, Src);
763 return Impl.getCFInstrCost(Opcode);
766 Type *CondTy)
override {
767 return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy);
770 unsigned Index)
override {
771 return Impl.getVectorInstrCost(Opcode, Val, Index);
775 return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace);
778 unsigned AddressSpace)
override {
779 return Impl.getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace);
783 ArrayRef<unsigned> Indices,
785 unsigned AddressSpace)
override {
786 return Impl.getInterleavedMemoryOpCost(Opcode, VecTy, Factor, Indices,
787 Alignment, AddressSpace);
790 bool IsPairwiseForm)
override {
791 return Impl.getReductionCost(Opcode, Ty, IsPairwiseForm);
794 ArrayRef<Type *> Tys)
override {
795 return Impl.getIntrinsicInstrCost(ID, RetTy, Tys);
798 ArrayRef<Type *> Tys)
override {
799 return Impl.getCallInstrCost(F, RetTy, Tys);
802 return Impl.getNumberOfParts(Tp);
805 return Impl.getAddressComputationCost(Ty, IsComplex);
808 return Impl.getCostOfKeepingLiveOverCall(Tys);
811 MemIntrinsicInfo &Info)
override {
812 return Impl.getTgtMemIntrinsic(Inst, Info);
815 Type *ExpectedType)
override {
816 return Impl.getOrCreateResultFromMemIntrinsic(Inst, ExpectedType);
819 const Function *Callee)
const override {
820 return Impl.hasCompatibleFunctionAttributes(Caller, Callee);
824 template <
typename T>
826 : TTIImpl(new
Model<
T>(Impl)) {}
844 static void *
ID() {
return (
void *)&PassID; }
863 : TTICallback(Arg.TTICallback) {}
865 : TTICallback(std::move(Arg.TTICallback)) {}
867 TTICallback = RHS.TTICallback;
871 TTICallback = std::move(RHS.TTICallback);
890 std::function<Result(Function &)> TTICallback;
904 virtual void anchor();
A parsed version of the target data layout string in and methods for querying it. ...
TargetIRAnalysis & operator=(const TargetIRAnalysis &RHS)
ImmutablePass * createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA)
Create an analysis pass wrapper around a TTI object.
Analysis pass providing the TargetTransformInfo.
TargetIRAnalysis & operator=(TargetIRAnalysis &&RHS)
unsigned short MatchingId
static void * ID()
Opaque, unique identifier for this analysis pass.
FunctionType - Class to represent function types.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
An abstract set of preserved analyses following a transformation pass run.
The instances of the Type class are immutable: once they are created, they are never changed...
TargetIRAnalysis()
Default construct a target IR analysis.
TargetIRAnalysis(const TargetIRAnalysis &Arg)
static StringRef name()
Provide access to a name for this pass for debugging purposes.
ImmutablePass class - This class is used to provide information that does not need to be run...
Class for arbitrary precision integers.
TargetIRAnalysis(TargetIRAnalysis &&Arg)
const ARM::ArchExtKind Kind
TargetTransformInfo Result
LLVM Value Representation.
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Information about a load/store intrinsic defined by the target.
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.