diff --git a/llvm/include/llvm/Analysis/TargetTransformInfo.h b/llvm/include/llvm/Analysis/TargetTransformInfo.h index b5d766c34d09d..5a74523d37e81 100644 --- a/llvm/include/llvm/Analysis/TargetTransformInfo.h +++ b/llvm/include/llvm/Analysis/TargetTransformInfo.h @@ -1923,7 +1923,7 @@ class TargetTransformInfo { /// implementation in a type erased interface. template class Model; - std::unique_ptr TTIImpl; + std::unique_ptr TTIImpl; }; class TargetTransformInfo::Concept { @@ -1933,37 +1933,37 @@ class TargetTransformInfo::Concept { virtual InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr, ArrayRef Operands, Type *AccessType, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost getPointersChainCost(ArrayRef Ptrs, const Value *Base, const TTI::PointersChainInfo &Info, Type *AccessTy, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual unsigned getInliningThresholdMultiplier() const = 0; virtual unsigned getInliningCostBenefitAnalysisSavingsMultiplier() const = 0; virtual unsigned getInliningCostBenefitAnalysisProfitableMultiplier() const = 0; virtual int getInliningLastCallToStaticBonus() const = 0; - virtual unsigned adjustInliningThreshold(const CallBase *CB) = 0; + virtual unsigned adjustInliningThreshold(const CallBase *CB) const = 0; virtual int getInlinerVectorBonusPercent() const = 0; virtual unsigned getCallerAllocaCost(const CallBase *CB, const AllocaInst *AI) const = 0; - virtual InstructionCost getMemcpyCost(const Instruction *I) = 0; + virtual InstructionCost getMemcpyCost(const Instruction *I) const = 0; virtual uint64_t getMaxMemIntrinsicInlineSizeThreshold() const = 0; virtual unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI, - BlockFrequencyInfo *BFI) = 0; + BlockFrequencyInfo *BFI) const = 0; virtual InstructionCost getInstructionCost(const User *U, ArrayRef Operands, - TargetCostKind CostKind) = 0; - virtual BranchProbability getPredictableBranchThreshold() = 0; - virtual InstructionCost getBranchMispredictPenalty() = 0; - virtual bool hasBranchDivergence(const Function *F = nullptr) = 0; - virtual bool isSourceOfDivergence(const Value *V) = 0; - virtual bool isAlwaysUniform(const Value *V) = 0; + TargetCostKind CostKind) const = 0; + virtual BranchProbability getPredictableBranchThreshold() const = 0; + virtual InstructionCost getBranchMispredictPenalty() const = 0; + virtual bool hasBranchDivergence(const Function *F = nullptr) const = 0; + virtual bool isSourceOfDivergence(const Value *V) const = 0; + virtual bool isAlwaysUniform(const Value *V) const = 0; virtual bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const = 0; virtual bool addrspacesMayAlias(unsigned AS0, unsigned AS1) const = 0; - virtual unsigned getFlatAddressSpace() = 0; + virtual unsigned getFlatAddressSpace() const = 0; virtual bool collectFlatAddressOperands(SmallVectorImpl &OpIndexes, Intrinsic::ID IID) const = 0; virtual bool isNoopAddrSpaceCast(unsigned FromAS, unsigned ToAS) const = 0; @@ -1976,140 +1976,150 @@ class TargetTransformInfo::Concept { virtual Value *rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV, Value *NewV) const = 0; - virtual bool isLoweredToCall(const Function *F) = 0; - virtual void getUnrollingPreferences(Loop *L, ScalarEvolution &, - UnrollingPreferences &UP, - OptimizationRemarkEmitter *ORE) = 0; + virtual bool isLoweredToCall(const Function *F) const = 0; + virtual void + getUnrollingPreferences(Loop *L, ScalarEvolution &, UnrollingPreferences &UP, + OptimizationRemarkEmitter *ORE) const = 0; virtual void getPeelingPreferences(Loop *L, ScalarEvolution &SE, - PeelingPreferences &PP) = 0; + PeelingPreferences &PP) const = 0; virtual bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE, AssumptionCache &AC, TargetLibraryInfo *LibInfo, - HardwareLoopInfo &HWLoopInfo) = 0; - virtual unsigned getEpilogueVectorizationMinVF() = 0; - virtual bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) = 0; + HardwareLoopInfo &HWLoopInfo) const = 0; + virtual unsigned getEpilogueVectorizationMinVF() const = 0; + virtual bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const = 0; virtual TailFoldingStyle - getPreferredTailFoldingStyle(bool IVUpdateMayOverflow = true) = 0; - virtual std::optional instCombineIntrinsic( - InstCombiner &IC, IntrinsicInst &II) = 0; - virtual std::optional simplifyDemandedUseBitsIntrinsic( - InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, - KnownBits & Known, bool &KnownBitsComputed) = 0; + getPreferredTailFoldingStyle(bool IVUpdateMayOverflow = true) const = 0; + virtual std::optional + instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const = 0; + virtual std::optional + simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II, + APInt DemandedMask, KnownBits &Known, + bool &KnownBitsComputed) const = 0; virtual std::optional simplifyDemandedVectorEltsIntrinsic( - InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, - APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, + InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, + APInt &UndefElts2, APInt &UndefElts3, std::function - SimplifyAndSetOp) = 0; - virtual bool isLegalAddImmediate(int64_t Imm) = 0; - virtual bool isLegalAddScalableImmediate(int64_t Imm) = 0; - virtual bool isLegalICmpImmediate(int64_t Imm) = 0; + SimplifyAndSetOp) const = 0; + virtual bool isLegalAddImmediate(int64_t Imm) const = 0; + virtual bool isLegalAddScalableImmediate(int64_t Imm) const = 0; + virtual bool isLegalICmpImmediate(int64_t Imm) const = 0; virtual bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace, Instruction *I, - int64_t ScalableOffset) = 0; + int64_t ScalableOffset) const = 0; virtual bool isLSRCostLess(const TargetTransformInfo::LSRCost &C1, - const TargetTransformInfo::LSRCost &C2) = 0; - virtual bool isNumRegsMajorCostOfLSR() = 0; + const TargetTransformInfo::LSRCost &C2) const = 0; + virtual bool isNumRegsMajorCostOfLSR() const = 0; virtual bool shouldDropLSRSolutionIfLessProfitable() const = 0; - virtual bool isProfitableLSRChainElement(Instruction *I) = 0; - virtual bool canMacroFuseCmp() = 0; + virtual bool isProfitableLSRChainElement(Instruction *I) const = 0; + virtual bool canMacroFuseCmp() const = 0; virtual bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC, - TargetLibraryInfo *LibInfo) = 0; + TargetLibraryInfo *LibInfo) const = 0; virtual AddressingModeKind getPreferredAddressingMode(const Loop *L, ScalarEvolution *SE) const = 0; virtual bool isLegalMaskedStore(Type *DataType, Align Alignment, - unsigned AddressSpace) = 0; + unsigned AddressSpace) const = 0; virtual bool isLegalMaskedLoad(Type *DataType, Align Alignment, - unsigned AddressSpace) = 0; - virtual bool isLegalNTStore(Type *DataType, Align Alignment) = 0; - virtual bool isLegalNTLoad(Type *DataType, Align Alignment) = 0; + unsigned AddressSpace) const = 0; + virtual bool isLegalNTStore(Type *DataType, Align Alignment) const = 0; + virtual bool isLegalNTLoad(Type *DataType, Align Alignment) const = 0; virtual bool isLegalBroadcastLoad(Type *ElementTy, ElementCount NumElements) const = 0; - virtual bool isLegalMaskedScatter(Type *DataType, Align Alignment) = 0; - virtual bool isLegalMaskedGather(Type *DataType, Align Alignment) = 0; + virtual bool isLegalMaskedScatter(Type *DataType, Align Alignment) const = 0; + virtual bool isLegalMaskedGather(Type *DataType, Align Alignment) const = 0; virtual bool forceScalarizeMaskedGather(VectorType *DataType, - Align Alignment) = 0; + Align Alignment) const = 0; virtual bool forceScalarizeMaskedScatter(VectorType *DataType, - Align Alignment) = 0; - virtual bool isLegalMaskedCompressStore(Type *DataType, Align Alignment) = 0; - virtual bool isLegalMaskedExpandLoad(Type *DataType, Align Alignment) = 0; - virtual bool isLegalStridedLoadStore(Type *DataType, Align Alignment) = 0; + Align Alignment) const = 0; + virtual bool isLegalMaskedCompressStore(Type *DataType, + Align Alignment) const = 0; + virtual bool isLegalMaskedExpandLoad(Type *DataType, + Align Alignment) const = 0; + virtual bool isLegalStridedLoadStore(Type *DataType, + Align Alignment) const = 0; virtual bool isLegalInterleavedAccessType(VectorType *VTy, unsigned Factor, Align Alignment, - unsigned AddrSpace) = 0; + unsigned AddrSpace) const = 0; - virtual bool isLegalMaskedVectorHistogram(Type *AddrType, Type *DataType) = 0; + virtual bool isLegalMaskedVectorHistogram(Type *AddrType, + Type *DataType) const = 0; virtual bool isLegalAltInstr(VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask) const = 0; - virtual bool enableOrderedReductions() = 0; - virtual bool hasDivRemOp(Type *DataType, bool IsSigned) = 0; - virtual bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) = 0; - virtual bool prefersVectorizedAddressing() = 0; + virtual bool enableOrderedReductions() const = 0; + virtual bool hasDivRemOp(Type *DataType, bool IsSigned) const = 0; + virtual bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) const = 0; + virtual bool prefersVectorizedAddressing() const = 0; virtual InstructionCost getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg, int64_t Scale, - unsigned AddrSpace) = 0; - virtual bool LSRWithInstrQueries() = 0; - virtual bool isTruncateFree(Type *Ty1, Type *Ty2) = 0; - virtual bool isProfitableToHoist(Instruction *I) = 0; - virtual bool useAA() = 0; + unsigned AddrSpace) const = 0; + virtual bool LSRWithInstrQueries() const = 0; + virtual bool isTruncateFree(Type *Ty1, Type *Ty2) const = 0; + virtual bool isProfitableToHoist(Instruction *I) const = 0; + virtual bool useAA() const = 0; virtual bool isTypeLegal(Type *Ty) const = 0; virtual unsigned getRegUsageForType(Type *Ty) const = 0; - virtual bool shouldBuildLookupTables() = 0; - virtual bool shouldBuildLookupTablesForConstant(Constant *C) = 0; - virtual bool shouldBuildRelLookupTables() = 0; - virtual bool useColdCCForColdCall(Function &F) = 0; - virtual bool isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) = 0; - virtual bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, - unsigned ScalarOpdIdx) = 0; + virtual bool shouldBuildLookupTables() const = 0; + virtual bool shouldBuildLookupTablesForConstant(Constant *C) const = 0; + virtual bool shouldBuildRelLookupTables() const = 0; + virtual bool useColdCCForColdCall(Function &F) const = 0; + virtual bool + isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) const = 0; + virtual bool + isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, + unsigned ScalarOpdIdx) const = 0; virtual bool isTargetIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID, - int OpdIdx) = 0; + int OpdIdx) const = 0; virtual bool isTargetIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID, - int RetIdx) = 0; + int RetIdx) const = 0; virtual InstructionCost getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract, TargetCostKind CostKind, - ArrayRef VL = {}) = 0; + ArrayRef VL = {}) const = 0; virtual InstructionCost getOperandsScalarizationOverhead(ArrayRef Args, ArrayRef Tys, - TargetCostKind CostKind) = 0; - virtual bool supportsEfficientVectorElementLoadStore() = 0; - virtual bool supportsTailCalls() = 0; - virtual bool supportsTailCallFor(const CallBase *CB) = 0; - virtual bool enableAggressiveInterleaving(bool LoopHasReductions) = 0; + TargetCostKind CostKind) const = 0; + virtual bool supportsEfficientVectorElementLoadStore() const = 0; + virtual bool supportsTailCalls() const = 0; + virtual bool supportsTailCallFor(const CallBase *CB) const = 0; + virtual bool enableAggressiveInterleaving(bool LoopHasReductions) const = 0; virtual MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const = 0; - virtual bool enableSelectOptimize() = 0; - virtual bool shouldTreatInstructionLikeSelect(const Instruction *I) = 0; - virtual bool enableInterleavedAccessVectorization() = 0; - virtual bool enableMaskedInterleavedAccessVectorization() = 0; - virtual bool isFPVectorizationPotentiallyUnsafe() = 0; + virtual bool enableSelectOptimize() const = 0; + virtual bool shouldTreatInstructionLikeSelect(const Instruction *I) const = 0; + virtual bool enableInterleavedAccessVectorization() const = 0; + virtual bool enableMaskedInterleavedAccessVectorization() const = 0; + virtual bool isFPVectorizationPotentiallyUnsafe() const = 0; virtual bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace, Align Alignment, - unsigned *Fast) = 0; - virtual PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) = 0; - virtual bool haveFastSqrt(Type *Ty) = 0; - virtual bool isExpensiveToSpeculativelyExecute(const Instruction *I) = 0; - virtual bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) = 0; - virtual InstructionCost getFPOpCost(Type *Ty) = 0; + unsigned *Fast) const = 0; + virtual PopcntSupportKind + getPopcntSupport(unsigned IntTyWidthInBit) const = 0; + virtual bool haveFastSqrt(Type *Ty) const = 0; + virtual bool + isExpensiveToSpeculativelyExecute(const Instruction *I) const = 0; + virtual bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const = 0; + virtual InstructionCost getFPOpCost(Type *Ty) const = 0; virtual InstructionCost getIntImmCodeSizeCost(unsigned Opc, unsigned Idx, - const APInt &Imm, Type *Ty) = 0; + const APInt &Imm, + Type *Ty) const = 0; virtual InstructionCost getIntImmCost(const APInt &Imm, Type *Ty, - TargetCostKind CostKind) = 0; - virtual InstructionCost getIntImmCostInst(unsigned Opc, unsigned Idx, - const APInt &Imm, Type *Ty, - TargetCostKind CostKind, - Instruction *Inst = nullptr) = 0; - virtual InstructionCost getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, - const APInt &Imm, Type *Ty, - TargetCostKind CostKind) = 0; + TargetCostKind CostKind) const = 0; + virtual InstructionCost + getIntImmCostInst(unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty, + TargetCostKind CostKind, + Instruction *Inst = nullptr) const = 0; + virtual InstructionCost + getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, + Type *Ty, TargetCostKind CostKind) const = 0; virtual bool preferToKeepConstantsAttached(const Instruction &Inst, const Function &Fn) const = 0; virtual unsigned getNumberOfRegisters(unsigned ClassID) const = 0; @@ -2130,7 +2140,7 @@ class TargetTransformInfo::Concept { virtual unsigned getStoreMinimumVF(unsigned VF, Type *ScalarMemTy, Type *ScalarValTy) const = 0; virtual bool shouldConsiderAddressTypePromotion( - const Instruction &I, bool &AllowPromotionWithoutCommonHeader) = 0; + const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const = 0; virtual unsigned getCacheLineSize() const = 0; virtual std::optional getCacheSize(CacheLevel Level) const = 0; virtual std::optional getCacheAssociativity(CacheLevel Level) @@ -2178,39 +2188,43 @@ class TargetTransformInfo::Concept { PartialReductionExtendKind OpBExtend, std::optional BinOp) const = 0; - virtual unsigned getMaxInterleaveFactor(ElementCount VF) = 0; - virtual InstructionCost getArithmeticInstrCost( - unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind, - OperandValueInfo Opd1Info, OperandValueInfo Opd2Info, - ArrayRef Args, const Instruction *CxtI = nullptr) = 0; + virtual unsigned getMaxInterleaveFactor(ElementCount VF) const = 0; + virtual InstructionCost + getArithmeticInstrCost(unsigned Opcode, Type *Ty, + TTI::TargetCostKind CostKind, + OperandValueInfo Opd1Info, OperandValueInfo Opd2Info, + ArrayRef Args, + const Instruction *CxtI = nullptr) const = 0; virtual InstructionCost getAltInstrCost( VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask, TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const = 0; - virtual InstructionCost - getShuffleCost(ShuffleKind Kind, VectorType *Tp, ArrayRef Mask, - TTI::TargetCostKind CostKind, int Index, VectorType *SubTp, - ArrayRef Args, const Instruction *CxtI) = 0; + virtual InstructionCost getShuffleCost(ShuffleKind Kind, VectorType *Tp, + ArrayRef Mask, + TTI::TargetCostKind CostKind, + int Index, VectorType *SubTp, + ArrayRef Args, + const Instruction *CxtI) const = 0; virtual InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src, CastContextHint CCH, TTI::TargetCostKind CostKind, - const Instruction *I) = 0; + const Instruction *I) const = 0; virtual InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy, - unsigned Index) = 0; - virtual InstructionCost getCFInstrCost(unsigned Opcode, - TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) = 0; + unsigned Index) const = 0; + virtual InstructionCost + getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind, + const Instruction *I = nullptr) const = 0; virtual InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred, TTI::TargetCostKind CostKind, OperandValueInfo Op1Info, OperandValueInfo Op2Info, - const Instruction *I) = 0; + const Instruction *I) const = 0; virtual InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, Value *Op0, - Value *Op1) = 0; + Value *Op1) const = 0; /// \param ScalarUserAndIdx encodes the information about extracts from a /// vector with 'Scalar' being the value being extracted,'User' being the user @@ -2219,81 +2233,84 @@ class TargetTransformInfo::Concept { virtual InstructionCost getVectorInstrCost( unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, Value *Scalar, - ArrayRef> ScalarUserAndIdx) = 0; + ArrayRef> ScalarUserAndIdx) const = 0; virtual InstructionCost getVectorInstrCost(const Instruction &I, Type *Val, TTI::TargetCostKind CostKind, - unsigned Index) = 0; + unsigned Index) const = 0; virtual InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF, const APInt &DemandedDstElts, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost - getInsertExtractValueCost(unsigned Opcode, TTI::TargetCostKind CostKind) = 0; + getInsertExtractValueCost(unsigned Opcode, + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, - OperandValueInfo OpInfo, const Instruction *I) = 0; + OperandValueInfo OpInfo, const Instruction *I) const = 0; virtual InstructionCost getVPMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, - const Instruction *I) = 0; + const Instruction *I) const = 0; virtual InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost getGatherScatterOpCost(unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask, Align Alignment, TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) = 0; + const Instruction *I = nullptr) const = 0; virtual InstructionCost getExpandCompressMemoryOpCost( unsigned Opcode, Type *DataTy, bool VariableMask, Align Alignment, - TTI::TargetCostKind CostKind, const Instruction *I = nullptr) = 0; + TTI::TargetCostKind CostKind, const Instruction *I = nullptr) const = 0; virtual InstructionCost getStridedMemoryOpCost(unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask, Align Alignment, TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) = 0; + const Instruction *I = nullptr) const = 0; virtual InstructionCost getInterleavedMemoryOpCost( unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef Indices, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, - bool UseMaskForCond = false, bool UseMaskForGaps = false) = 0; + bool UseMaskForCond = false, bool UseMaskForGaps = false) const = 0; virtual InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *Ty, std::optional FMF, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost getMinMaxReductionCost(Intrinsic::ID IID, VectorType *Ty, FastMathFlags FMF, - TTI::TargetCostKind CostKind) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost getExtendedReductionCost( unsigned Opcode, bool IsUnsigned, Type *ResTy, VectorType *Ty, std::optional FMF, - TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) = 0; + TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const = 0; virtual InstructionCost getMulAccReductionCost( bool IsUnsigned, Type *ResTy, VectorType *Ty, - TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) = 0; + TTI::TargetCostKind CostKind = TTI::TCK_RecipThroughput) const = 0; virtual InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA, - TTI::TargetCostKind CostKind) = 0; - virtual InstructionCost getCallInstrCost(Function *F, Type *RetTy, - ArrayRef Tys, - TTI::TargetCostKind CostKind) = 0; - virtual unsigned getNumberOfParts(Type *Tp) = 0; + TTI::TargetCostKind CostKind) const = 0; virtual InstructionCost - getAddressComputationCost(Type *Ty, ScalarEvolution *SE, const SCEV *Ptr) = 0; + getCallInstrCost(Function *F, Type *RetTy, ArrayRef Tys, + TTI::TargetCostKind CostKind) const = 0; + virtual unsigned getNumberOfParts(Type *Tp) const = 0; + virtual InstructionCost getAddressComputationCost(Type *Ty, + ScalarEvolution *SE, + const SCEV *Ptr) const = 0; virtual InstructionCost - getCostOfKeepingLiveOverCall(ArrayRef Tys) = 0; + getCostOfKeepingLiveOverCall(ArrayRef Tys) const = 0; virtual bool getTgtMemIntrinsic(IntrinsicInst *Inst, - MemIntrinsicInfo &Info) = 0; + MemIntrinsicInfo &Info) const = 0; virtual unsigned getAtomicMemIntrinsicMaxElementSize() const = 0; - virtual Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst, - Type *ExpectedType) = 0; + virtual Value * + getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst, + Type *ExpectedType) const = 0; virtual Type *getMemcpyLoopLoweringType( LLVMContext &Context, Value *Length, unsigned SrcAddrSpace, unsigned DestAddrSpace, Align SrcAlign, Align DestAlign, @@ -2380,20 +2397,20 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr, ArrayRef Operands, Type *AccessType, - TargetTransformInfo::TargetCostKind CostKind) override { + TargetTransformInfo::TargetCostKind CostKind) const override { return Impl.getGEPCost(PointeeType, Ptr, Operands, AccessType, CostKind); } InstructionCost getPointersChainCost(ArrayRef Ptrs, const Value *Base, const PointersChainInfo &Info, Type *AccessTy, - TargetCostKind CostKind) override { + TargetCostKind CostKind) const override { return Impl.getPointersChainCost(Ptrs, Base, Info, AccessTy, CostKind); } unsigned getInliningThresholdMultiplier() const override { return Impl.getInliningThresholdMultiplier(); } - unsigned adjustInliningThreshold(const CallBase *CB) override { + unsigned adjustInliningThreshold(const CallBase *CB) const override { return Impl.adjustInliningThreshold(CB); } unsigned getInliningCostBenefitAnalysisSavingsMultiplier() const override { @@ -2412,7 +2429,7 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { const AllocaInst *AI) const override { return Impl.getCallerAllocaCost(CB, AI); } - InstructionCost getMemcpyCost(const Instruction *I) override { + InstructionCost getMemcpyCost(const Instruction *I) const override { return Impl.getMemcpyCost(I); } @@ -2422,23 +2439,23 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { InstructionCost getInstructionCost(const User *U, ArrayRef Operands, - TargetCostKind CostKind) override { + TargetCostKind CostKind) const override { return Impl.getInstructionCost(U, Operands, CostKind); } - BranchProbability getPredictableBranchThreshold() override { + BranchProbability getPredictableBranchThreshold() const override { return Impl.getPredictableBranchThreshold(); } - InstructionCost getBranchMispredictPenalty() override { + InstructionCost getBranchMispredictPenalty() const override { return Impl.getBranchMispredictPenalty(); } - bool hasBranchDivergence(const Function *F = nullptr) override { + bool hasBranchDivergence(const Function *F = nullptr) const override { return Impl.hasBranchDivergence(F); } - bool isSourceOfDivergence(const Value *V) override { + bool isSourceOfDivergence(const Value *V) const override { return Impl.isSourceOfDivergence(V); } - bool isAlwaysUniform(const Value *V) override { + bool isAlwaysUniform(const Value *V) const override { return Impl.isAlwaysUniform(V); } @@ -2450,7 +2467,9 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { return Impl.addrspacesMayAlias(AS0, AS1); } - unsigned getFlatAddressSpace() override { return Impl.getFlatAddressSpace(); } + unsigned getFlatAddressSpace() const override { + return Impl.getFlatAddressSpace(); + } bool collectFlatAddressOperands(SmallVectorImpl &OpIndexes, Intrinsic::ID IID) const override { @@ -2482,41 +2501,41 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { return Impl.rewriteIntrinsicWithAddressSpace(II, OldV, NewV); } - bool isLoweredToCall(const Function *F) override { + bool isLoweredToCall(const Function *F) const override { return Impl.isLoweredToCall(F); } void getUnrollingPreferences(Loop *L, ScalarEvolution &SE, UnrollingPreferences &UP, - OptimizationRemarkEmitter *ORE) override { + OptimizationRemarkEmitter *ORE) const override { return Impl.getUnrollingPreferences(L, SE, UP, ORE); } void getPeelingPreferences(Loop *L, ScalarEvolution &SE, - PeelingPreferences &PP) override { + PeelingPreferences &PP) const override { return Impl.getPeelingPreferences(L, SE, PP); } bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE, AssumptionCache &AC, TargetLibraryInfo *LibInfo, - HardwareLoopInfo &HWLoopInfo) override { + HardwareLoopInfo &HWLoopInfo) const override { return Impl.isHardwareLoopProfitable(L, SE, AC, LibInfo, HWLoopInfo); } - unsigned getEpilogueVectorizationMinVF() override { + unsigned getEpilogueVectorizationMinVF() const override { return Impl.getEpilogueVectorizationMinVF(); } - bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) override { + bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const override { return Impl.preferPredicateOverEpilogue(TFI); } TailFoldingStyle - getPreferredTailFoldingStyle(bool IVUpdateMayOverflow = true) override { + getPreferredTailFoldingStyle(bool IVUpdateMayOverflow = true) const override { return Impl.getPreferredTailFoldingStyle(IVUpdateMayOverflow); } std::optional - instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) override { + instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const override { return Impl.instCombineIntrinsic(IC, II); } std::optional simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, KnownBits &Known, - bool &KnownBitsComputed) override { + bool &KnownBitsComputed) const override { return Impl.simplifyDemandedUseBitsIntrinsic(IC, II, DemandedMask, Known, KnownBitsComputed); } @@ -2524,43 +2543,44 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, std::function - SimplifyAndSetOp) override { + SimplifyAndSetOp) const override { return Impl.simplifyDemandedVectorEltsIntrinsic( IC, II, DemandedElts, UndefElts, UndefElts2, UndefElts3, SimplifyAndSetOp); } - bool isLegalAddImmediate(int64_t Imm) override { + bool isLegalAddImmediate(int64_t Imm) const override { return Impl.isLegalAddImmediate(Imm); } - bool isLegalAddScalableImmediate(int64_t Imm) override { + bool isLegalAddScalableImmediate(int64_t Imm) const override { return Impl.isLegalAddScalableImmediate(Imm); } - bool isLegalICmpImmediate(int64_t Imm) override { + bool isLegalICmpImmediate(int64_t Imm) const override { return Impl.isLegalICmpImmediate(Imm); } bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace, - Instruction *I, int64_t ScalableOffset) override { + Instruction *I, + int64_t ScalableOffset) const override { return Impl.isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, Scale, AddrSpace, I, ScalableOffset); } bool isLSRCostLess(const TargetTransformInfo::LSRCost &C1, - const TargetTransformInfo::LSRCost &C2) override { + const TargetTransformInfo::LSRCost &C2) const override { return Impl.isLSRCostLess(C1, C2); } - bool isNumRegsMajorCostOfLSR() override { + bool isNumRegsMajorCostOfLSR() const override { return Impl.isNumRegsMajorCostOfLSR(); } bool shouldDropLSRSolutionIfLessProfitable() const override { return Impl.shouldDropLSRSolutionIfLessProfitable(); } - bool isProfitableLSRChainElement(Instruction *I) override { + bool isProfitableLSRChainElement(Instruction *I) const override { return Impl.isProfitableLSRChainElement(I); } - bool canMacroFuseCmp() override { return Impl.canMacroFuseCmp(); } + bool canMacroFuseCmp() const override { return Impl.canMacroFuseCmp(); } bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC, - TargetLibraryInfo *LibInfo) override { + TargetLibraryInfo *LibInfo) const override { return Impl.canSaveCmp(L, BI, SE, LI, DT, AC, LibInfo); } AddressingModeKind @@ -2569,206 +2589,212 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { return Impl.getPreferredAddressingMode(L, SE); } bool isLegalMaskedStore(Type *DataType, Align Alignment, - unsigned AddressSpace) override { + unsigned AddressSpace) const override { return Impl.isLegalMaskedStore(DataType, Alignment, AddressSpace); } bool isLegalMaskedLoad(Type *DataType, Align Alignment, - unsigned AddressSpace) override { + unsigned AddressSpace) const override { return Impl.isLegalMaskedLoad(DataType, Alignment, AddressSpace); } - bool isLegalNTStore(Type *DataType, Align Alignment) override { + bool isLegalNTStore(Type *DataType, Align Alignment) const override { return Impl.isLegalNTStore(DataType, Alignment); } - bool isLegalNTLoad(Type *DataType, Align Alignment) override { + bool isLegalNTLoad(Type *DataType, Align Alignment) const override { return Impl.isLegalNTLoad(DataType, Alignment); } bool isLegalBroadcastLoad(Type *ElementTy, ElementCount NumElements) const override { return Impl.isLegalBroadcastLoad(ElementTy, NumElements); } - bool isLegalMaskedScatter(Type *DataType, Align Alignment) override { + bool isLegalMaskedScatter(Type *DataType, Align Alignment) const override { return Impl.isLegalMaskedScatter(DataType, Alignment); } - bool isLegalMaskedGather(Type *DataType, Align Alignment) override { + bool isLegalMaskedGather(Type *DataType, Align Alignment) const override { return Impl.isLegalMaskedGather(DataType, Alignment); } bool forceScalarizeMaskedGather(VectorType *DataType, - Align Alignment) override { + Align Alignment) const override { return Impl.forceScalarizeMaskedGather(DataType, Alignment); } bool forceScalarizeMaskedScatter(VectorType *DataType, - Align Alignment) override { + Align Alignment) const override { return Impl.forceScalarizeMaskedScatter(DataType, Alignment); } - bool isLegalMaskedCompressStore(Type *DataType, Align Alignment) override { + bool isLegalMaskedCompressStore(Type *DataType, + Align Alignment) const override { return Impl.isLegalMaskedCompressStore(DataType, Alignment); } - bool isLegalMaskedExpandLoad(Type *DataType, Align Alignment) override { + bool isLegalMaskedExpandLoad(Type *DataType, Align Alignment) const override { return Impl.isLegalMaskedExpandLoad(DataType, Alignment); } - bool isLegalStridedLoadStore(Type *DataType, Align Alignment) override { + bool isLegalStridedLoadStore(Type *DataType, Align Alignment) const override { return Impl.isLegalStridedLoadStore(DataType, Alignment); } bool isLegalInterleavedAccessType(VectorType *VTy, unsigned Factor, Align Alignment, - unsigned AddrSpace) override { + unsigned AddrSpace) const override { return Impl.isLegalInterleavedAccessType(VTy, Factor, Alignment, AddrSpace); } - bool isLegalMaskedVectorHistogram(Type *AddrType, Type *DataType) override { + bool isLegalMaskedVectorHistogram(Type *AddrType, + Type *DataType) const override { return Impl.isLegalMaskedVectorHistogram(AddrType, DataType); } bool isLegalAltInstr(VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask) const override { return Impl.isLegalAltInstr(VecTy, Opcode0, Opcode1, OpcodeMask); } - bool enableOrderedReductions() override { + bool enableOrderedReductions() const override { return Impl.enableOrderedReductions(); } - bool hasDivRemOp(Type *DataType, bool IsSigned) override { + bool hasDivRemOp(Type *DataType, bool IsSigned) const override { return Impl.hasDivRemOp(DataType, IsSigned); } - bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) override { + bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) const override { return Impl.hasVolatileVariant(I, AddrSpace); } - bool prefersVectorizedAddressing() override { + bool prefersVectorizedAddressing() const override { return Impl.prefersVectorizedAddressing(); } InstructionCost getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg, int64_t Scale, - unsigned AddrSpace) override { + unsigned AddrSpace) const override { return Impl.getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg, Scale, AddrSpace); } - bool LSRWithInstrQueries() override { return Impl.LSRWithInstrQueries(); } - bool isTruncateFree(Type *Ty1, Type *Ty2) override { + bool LSRWithInstrQueries() const override { + return Impl.LSRWithInstrQueries(); + } + bool isTruncateFree(Type *Ty1, Type *Ty2) const override { return Impl.isTruncateFree(Ty1, Ty2); } - bool isProfitableToHoist(Instruction *I) override { + bool isProfitableToHoist(Instruction *I) const override { return Impl.isProfitableToHoist(I); } - bool useAA() override { return Impl.useAA(); } + bool useAA() const override { return Impl.useAA(); } bool isTypeLegal(Type *Ty) const override { return Impl.isTypeLegal(Ty); } unsigned getRegUsageForType(Type *Ty) const override { return Impl.getRegUsageForType(Ty); } - bool shouldBuildLookupTables() override { + bool shouldBuildLookupTables() const override { return Impl.shouldBuildLookupTables(); } - bool shouldBuildLookupTablesForConstant(Constant *C) override { + bool shouldBuildLookupTablesForConstant(Constant *C) const override { return Impl.shouldBuildLookupTablesForConstant(C); } - bool shouldBuildRelLookupTables() override { + bool shouldBuildRelLookupTables() const override { return Impl.shouldBuildRelLookupTables(); } - bool useColdCCForColdCall(Function &F) override { + bool useColdCCForColdCall(Function &F) const override { return Impl.useColdCCForColdCall(F); } - bool isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) override { + bool isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) const override { return Impl.isTargetIntrinsicTriviallyScalarizable(ID); } - bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, - unsigned ScalarOpdIdx) override { + bool + isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, + unsigned ScalarOpdIdx) const override { return Impl.isTargetIntrinsicWithScalarOpAtArg(ID, ScalarOpdIdx); } bool isTargetIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID, - int OpdIdx) override { + int OpdIdx) const override { return Impl.isTargetIntrinsicWithOverloadTypeAtArg(ID, OpdIdx); } - bool isTargetIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID, - int RetIdx) override { + bool + isTargetIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID, + int RetIdx) const override { return Impl.isTargetIntrinsicWithStructReturnOverloadAtField(ID, RetIdx); } - InstructionCost getScalarizationOverhead(VectorType *Ty, - const APInt &DemandedElts, - bool Insert, bool Extract, - TargetCostKind CostKind, - ArrayRef VL = {}) override { + InstructionCost + getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts, + bool Insert, bool Extract, TargetCostKind CostKind, + ArrayRef VL = {}) const override { return Impl.getScalarizationOverhead(Ty, DemandedElts, Insert, Extract, CostKind, VL); } InstructionCost getOperandsScalarizationOverhead(ArrayRef Args, ArrayRef Tys, - TargetCostKind CostKind) override { + TargetCostKind CostKind) const override { return Impl.getOperandsScalarizationOverhead(Args, Tys, CostKind); } - bool supportsEfficientVectorElementLoadStore() override { + bool supportsEfficientVectorElementLoadStore() const override { return Impl.supportsEfficientVectorElementLoadStore(); } - bool supportsTailCalls() override { return Impl.supportsTailCalls(); } - bool supportsTailCallFor(const CallBase *CB) override { + bool supportsTailCalls() const override { return Impl.supportsTailCalls(); } + bool supportsTailCallFor(const CallBase *CB) const override { return Impl.supportsTailCallFor(CB); } - bool enableAggressiveInterleaving(bool LoopHasReductions) override { + bool enableAggressiveInterleaving(bool LoopHasReductions) const override { return Impl.enableAggressiveInterleaving(LoopHasReductions); } MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const override { return Impl.enableMemCmpExpansion(OptSize, IsZeroCmp); } - bool enableSelectOptimize() override { + bool enableSelectOptimize() const override { return Impl.enableSelectOptimize(); } - bool shouldTreatInstructionLikeSelect(const Instruction *I) override { + bool shouldTreatInstructionLikeSelect(const Instruction *I) const override { return Impl.shouldTreatInstructionLikeSelect(I); } - bool enableInterleavedAccessVectorization() override { + bool enableInterleavedAccessVectorization() const override { return Impl.enableInterleavedAccessVectorization(); } - bool enableMaskedInterleavedAccessVectorization() override { + bool enableMaskedInterleavedAccessVectorization() const override { return Impl.enableMaskedInterleavedAccessVectorization(); } - bool isFPVectorizationPotentiallyUnsafe() override { + bool isFPVectorizationPotentiallyUnsafe() const override { return Impl.isFPVectorizationPotentiallyUnsafe(); } bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace, Align Alignment, - unsigned *Fast) override { + unsigned *Fast) const override { return Impl.allowsMisalignedMemoryAccesses(Context, BitWidth, AddressSpace, Alignment, Fast); } - PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) override { + PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const override { return Impl.getPopcntSupport(IntTyWidthInBit); } - bool haveFastSqrt(Type *Ty) override { return Impl.haveFastSqrt(Ty); } + bool haveFastSqrt(Type *Ty) const override { return Impl.haveFastSqrt(Ty); } - bool isExpensiveToSpeculativelyExecute(const Instruction* I) override { + bool isExpensiveToSpeculativelyExecute(const Instruction *I) const override { return Impl.isExpensiveToSpeculativelyExecute(I); } - bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) override { + bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const override { return Impl.isFCmpOrdCheaperThanFCmpZero(Ty); } - InstructionCost getFPOpCost(Type *Ty) override { + InstructionCost getFPOpCost(Type *Ty) const override { return Impl.getFPOpCost(Ty); } InstructionCost getIntImmCodeSizeCost(unsigned Opc, unsigned Idx, - const APInt &Imm, Type *Ty) override { + const APInt &Imm, + Type *Ty) const override { return Impl.getIntImmCodeSizeCost(Opc, Idx, Imm, Ty); } InstructionCost getIntImmCost(const APInt &Imm, Type *Ty, - TargetCostKind CostKind) override { + TargetCostKind CostKind) const override { return Impl.getIntImmCost(Imm, Ty, CostKind); } - InstructionCost getIntImmCostInst(unsigned Opc, unsigned Idx, - const APInt &Imm, Type *Ty, - TargetCostKind CostKind, - Instruction *Inst = nullptr) override { + InstructionCost + getIntImmCostInst(unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty, + TargetCostKind CostKind, + Instruction *Inst = nullptr) const override { return Impl.getIntImmCostInst(Opc, Idx, Imm, Ty, CostKind, Inst); } InstructionCost getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty, - TargetCostKind CostKind) override { + TargetCostKind CostKind) const override { return Impl.getIntImmCostIntrin(IID, Idx, Imm, Ty, CostKind); } bool preferToKeepConstantsAttached(const Instruction &Inst, @@ -2819,7 +2845,8 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { return Impl.getStoreMinimumVF(VF, ScalarMemTy, ScalarValTy); } bool shouldConsiderAddressTypePromotion( - const Instruction &I, bool &AllowPromotionWithoutCommonHeader) override { + const Instruction &I, + bool &AllowPromotionWithoutCommonHeader) const override { return Impl.shouldConsiderAddressTypePromotion( I, AllowPromotionWithoutCommonHeader); } @@ -2880,20 +2907,21 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { BinOp); } - unsigned getMaxInterleaveFactor(ElementCount VF) override { + unsigned getMaxInterleaveFactor(ElementCount VF) const override { return Impl.getMaxInterleaveFactor(VF); } - unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI, - unsigned &JTSize, - ProfileSummaryInfo *PSI, - BlockFrequencyInfo *BFI) override { + unsigned + getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize, + ProfileSummaryInfo *PSI, + BlockFrequencyInfo *BFI) const override { return Impl.getEstimatedNumberOfCaseClusters(SI, JTSize, PSI, BFI); } - InstructionCost getArithmeticInstrCost( - unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind, - OperandValueInfo Opd1Info, OperandValueInfo Opd2Info, - ArrayRef Args, - const Instruction *CxtI = nullptr) override { + InstructionCost + getArithmeticInstrCost(unsigned Opcode, Type *Ty, + TTI::TargetCostKind CostKind, + OperandValueInfo Opd1Info, OperandValueInfo Opd2Info, + ArrayRef Args, + const Instruction *CxtI = nullptr) const override { return Impl.getArithmeticInstrCost(Opcode, Ty, CostKind, Opd1Info, Opd2Info, Args, CxtI); } @@ -2909,23 +2937,24 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { TTI::TargetCostKind CostKind, int Index, VectorType *SubTp, ArrayRef Args, - const Instruction *CxtI) override { + const Instruction *CxtI) const override { return Impl.getShuffleCost(Kind, Tp, Mask, CostKind, Index, SubTp, Args, CxtI); } InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src, CastContextHint CCH, TTI::TargetCostKind CostKind, - const Instruction *I) override { + const Instruction *I) const override { return Impl.getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I); } InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy, - unsigned Index) override { + unsigned Index) const override { return Impl.getExtractWithExtendCost(Opcode, Dst, VecTy, Index); } - InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) override { + InstructionCost + getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind, + const Instruction *I = nullptr) const override { return Impl.getCFInstrCost(Opcode, CostKind, I); } InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, @@ -2933,58 +2962,60 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { TTI::TargetCostKind CostKind, OperandValueInfo Op1Info, OperandValueInfo Op2Info, - const Instruction *I) override { + const Instruction *I) const override { return Impl.getCmpSelInstrCost(Opcode, ValTy, CondTy, VecPred, CostKind, Op1Info, Op2Info, I); } InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, Value *Op0, - Value *Op1) override { + Value *Op1) const override { return Impl.getVectorInstrCost(Opcode, Val, CostKind, Index, Op0, Op1); } - InstructionCost getVectorInstrCost( - unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, - Value *Scalar, - ArrayRef> ScalarUserAndIdx) override { + InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, + TTI::TargetCostKind CostKind, + unsigned Index, Value *Scalar, + ArrayRef> + ScalarUserAndIdx) const override { return Impl.getVectorInstrCost(Opcode, Val, CostKind, Index, Scalar, ScalarUserAndIdx); } InstructionCost getVectorInstrCost(const Instruction &I, Type *Val, TTI::TargetCostKind CostKind, - unsigned Index) override { + unsigned Index) const override { return Impl.getVectorInstrCost(I, Val, CostKind, Index); } InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF, const APInt &DemandedDstElts, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getReplicationShuffleCost(EltTy, ReplicationFactor, VF, DemandedDstElts, CostKind); } InstructionCost getInsertExtractValueCost(unsigned Opcode, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getInsertExtractValueCost(Opcode, CostKind); } InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, OperandValueInfo OpInfo, - const Instruction *I) override { + const Instruction *I) const override { return Impl.getMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind, OpInfo, I); } InstructionCost getVPMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, - const Instruction *I) override { + const Instruction *I) const override { return Impl.getVPMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind, I); } - InstructionCost getMaskedMemoryOpCost(unsigned Opcode, Type *Src, - Align Alignment, unsigned AddressSpace, - TTI::TargetCostKind CostKind) override { + InstructionCost + getMaskedMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, + unsigned AddressSpace, + TTI::TargetCostKind CostKind) const override { return Impl.getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace, CostKind); } @@ -2992,13 +3023,15 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { getGatherScatterOpCost(unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask, Align Alignment, TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) override { + const Instruction *I = nullptr) const override { return Impl.getGatherScatterOpCost(Opcode, DataTy, Ptr, VariableMask, Alignment, CostKind, I); } - InstructionCost getExpandCompressMemoryOpCost( - unsigned Opcode, Type *DataTy, bool VariableMask, Align Alignment, - TTI::TargetCostKind CostKind, const Instruction *I = nullptr) override { + InstructionCost + getExpandCompressMemoryOpCost(unsigned Opcode, Type *DataTy, + bool VariableMask, Align Alignment, + TTI::TargetCostKind CostKind, + const Instruction *I = nullptr) const override { return Impl.getExpandCompressMemoryOpCost(Opcode, DataTy, VariableMask, Alignment, CostKind, I); } @@ -3006,14 +3039,14 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { getStridedMemoryOpCost(unsigned Opcode, Type *DataTy, const Value *Ptr, bool VariableMask, Align Alignment, TTI::TargetCostKind CostKind, - const Instruction *I = nullptr) override { + const Instruction *I = nullptr) const override { return Impl.getStridedMemoryOpCost(Opcode, DataTy, Ptr, VariableMask, Alignment, CostKind, I); } InstructionCost getInterleavedMemoryOpCost( unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef Indices, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, - bool UseMaskForCond, bool UseMaskForGaps) override { + bool UseMaskForCond, bool UseMaskForGaps) const override { return Impl.getInterleavedMemoryOpCost(Opcode, VecTy, Factor, Indices, Alignment, AddressSpace, CostKind, UseMaskForCond, UseMaskForGaps); @@ -3021,54 +3054,56 @@ class TargetTransformInfo::Model final : public TargetTransformInfo::Concept { InstructionCost getArithmeticReductionCost(unsigned Opcode, VectorType *Ty, std::optional FMF, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getArithmeticReductionCost(Opcode, Ty, FMF, CostKind); } InstructionCost getMinMaxReductionCost(Intrinsic::ID IID, VectorType *Ty, FastMathFlags FMF, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getMinMaxReductionCost(IID, Ty, FMF, CostKind); } InstructionCost getExtendedReductionCost(unsigned Opcode, bool IsUnsigned, Type *ResTy, VectorType *Ty, std::optional FMF, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getExtendedReductionCost(Opcode, IsUnsigned, ResTy, Ty, FMF, CostKind); } InstructionCost getMulAccReductionCost(bool IsUnsigned, Type *ResTy, VectorType *Ty, - TTI::TargetCostKind CostKind) override { + TTI::TargetCostKind CostKind) const override { return Impl.getMulAccReductionCost(IsUnsigned, ResTy, Ty, CostKind); } - InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA, - TTI::TargetCostKind CostKind) override { + InstructionCost + getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA, + TTI::TargetCostKind CostKind) const override { return Impl.getIntrinsicInstrCost(ICA, CostKind); } - InstructionCost getCallInstrCost(Function *F, Type *RetTy, - ArrayRef Tys, - TTI::TargetCostKind CostKind) override { + InstructionCost + getCallInstrCost(Function *F, Type *RetTy, ArrayRef Tys, + TTI::TargetCostKind CostKind) const override { return Impl.getCallInstrCost(F, RetTy, Tys, CostKind); } - unsigned getNumberOfParts(Type *Tp) override { + unsigned getNumberOfParts(Type *Tp) const override { return Impl.getNumberOfParts(Tp); } InstructionCost getAddressComputationCost(Type *Ty, ScalarEvolution *SE, - const SCEV *Ptr) override { + const SCEV *Ptr) const override { return Impl.getAddressComputationCost(Ty, SE, Ptr); } - InstructionCost getCostOfKeepingLiveOverCall(ArrayRef Tys) override { + InstructionCost + getCostOfKeepingLiveOverCall(ArrayRef Tys) const override { return Impl.getCostOfKeepingLiveOverCall(Tys); } bool getTgtMemIntrinsic(IntrinsicInst *Inst, - MemIntrinsicInfo &Info) override { + MemIntrinsicInfo &Info) const override { return Impl.getTgtMemIntrinsic(Inst, Info); } unsigned getAtomicMemIntrinsicMaxElementSize() const override { return Impl.getAtomicMemIntrinsicMaxElementSize(); } Value *getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst, - Type *ExpectedType) override { + Type *ExpectedType) const override { return Impl.getOrCreateResultFromMemIntrinsic(Inst, ExpectedType); } Type *getMemcpyLoopLoweringType(