1//===- llvm/Analysis/TargetTransformInfo.cpp ------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/Analysis/TargetTransformInfo.h"
10#include "llvm/ADT/Sequence.h"
11#include "llvm/ADT/SmallVector.h"
12#include "llvm/Analysis/CFG.h"
13#include "llvm/Analysis/LoopIterator.h"
14#include "llvm/Analysis/TargetLibraryInfo.h"
15#include "llvm/Analysis/TargetTransformInfoImpl.h"
16#include "llvm/IR/CFG.h"
17#include "llvm/IR/Dominators.h"
18#include "llvm/IR/Instruction.h"
19#include "llvm/IR/Instructions.h"
20#include "llvm/IR/IntrinsicInst.h"
21#include "llvm/IR/Module.h"
22#include "llvm/IR/Operator.h"
23#include "llvm/InitializePasses.h"
24#include "llvm/Support/CommandLine.h"
25#include <optional>
26#include <utility>
27
28using namespace llvm;
29using namespace PatternMatch;
30
31#define DEBUG_TYPE "tti"
32
33static cl::opt<unsigned> CacheLineSize(
34 "cache-line-size", cl::init(Val: 0), cl::Hidden,
35 cl::desc("Use this to override the target cache line size when "
36 "specified by the user."));
37
38static cl::opt<unsigned> MinPageSize(
39 "min-page-size", cl::init(Val: 0), cl::Hidden,
40 cl::desc("Use this to override the target's minimum page size."));
41
42static cl::opt<unsigned> PredictableBranchThreshold(
43 "predictable-branch-threshold", cl::init(Val: 99), cl::Hidden,
44 cl::desc(
45 "Use this to override the target's predictable branch threshold (%)."));
46
47namespace {
48/// No-op implementation of the TTI interface using the utility base
49/// classes.
50///
51/// This is used when no target specific information is available.
52struct NoTTIImpl : TargetTransformInfoImplCRTPBase<NoTTIImpl> {
53 explicit NoTTIImpl(const DataLayout &DL)
54 : TargetTransformInfoImplCRTPBase<NoTTIImpl>(DL) {}
55};
56} // namespace
57
58TargetTransformInfo::TargetTransformInfo(
59 std::unique_ptr<const TargetTransformInfoImplBase> Impl)
60 : TTIImpl(std::move(Impl)) {}
61
62bool HardwareLoopInfo::canAnalyze(LoopInfo &LI) {
63 // If the loop has irreducible control flow, it can not be converted to
64 // Hardware loop.
65 LoopBlocksRPO RPOT(L);
66 RPOT.perform(LI: &LI);
67 if (containsIrreducibleCFG<const BasicBlock *>(RPOTraversal&: RPOT, LI))
68 return false;
69 return true;
70}
71
72IntrinsicCostAttributes::IntrinsicCostAttributes(
73 Intrinsic::ID Id, const CallBase &CI, InstructionCost ScalarizationCost,
74 bool TypeBasedOnly)
75 : II(dyn_cast<IntrinsicInst>(Val: &CI)), RetTy(CI.getType()), IID(Id),
76 ScalarizationCost(ScalarizationCost) {
77
78 if (const auto *FPMO = dyn_cast<FPMathOperator>(Val: &CI))
79 FMF = FPMO->getFastMathFlags();
80
81 if (!TypeBasedOnly)
82 Arguments.insert(I: Arguments.begin(), From: CI.arg_begin(), To: CI.arg_end());
83 for (const Value *Arg : CI.args())
84 ParamTys.push_back(Elt: Arg->getType());
85}
86
87IntrinsicCostAttributes::IntrinsicCostAttributes(Intrinsic::ID Id, Type *RTy,
88 ArrayRef<Type *> Tys,
89 FastMathFlags Flags,
90 const IntrinsicInst *I,
91 InstructionCost ScalarCost)
92 : II(I), RetTy(RTy), IID(Id), FMF(Flags), ScalarizationCost(ScalarCost) {
93 ParamTys.insert(I: ParamTys.begin(), From: Tys.begin(), To: Tys.end());
94}
95
96IntrinsicCostAttributes::IntrinsicCostAttributes(Intrinsic::ID Id, Type *Ty,
97 ArrayRef<const Value *> Args)
98 : RetTy(Ty), IID(Id) {
99
100 Arguments.insert(I: Arguments.begin(), From: Args.begin(), To: Args.end());
101 ParamTys.reserve(N: Arguments.size());
102 for (const Value *Argument : Arguments)
103 ParamTys.push_back(Elt: Argument->getType());
104}
105
106IntrinsicCostAttributes::IntrinsicCostAttributes(
107 Intrinsic::ID Id, Type *RTy, ArrayRef<const Value *> Args,
108 ArrayRef<Type *> Tys, FastMathFlags Flags, const IntrinsicInst *I,
109 InstructionCost ScalarCost, VectorInstrContext VIC)
110 : II(I), RetTy(RTy), IID(Id), FMF(Flags), ScalarizationCost(ScalarCost),
111 VIC(VIC) {
112 ParamTys.insert(I: ParamTys.begin(), From: Tys.begin(), To: Tys.end());
113 Arguments.insert(I: Arguments.begin(), From: Args.begin(), To: Args.end());
114}
115
116HardwareLoopInfo::HardwareLoopInfo(Loop *L) : L(L) {
117 // Match default options:
118 // - hardware-loop-counter-bitwidth = 32
119 // - hardware-loop-decrement = 1
120 CountType = Type::getInt32Ty(C&: L->getHeader()->getContext());
121 LoopDecrement = ConstantInt::get(Ty: CountType, V: 1);
122}
123
124bool HardwareLoopInfo::isHardwareLoopCandidate(ScalarEvolution &SE,
125 LoopInfo &LI, DominatorTree &DT,
126 bool ForceNestedLoop,
127 bool ForceHardwareLoopPHI) {
128 SmallVector<BasicBlock *, 4> ExitingBlocks;
129 L->getExitingBlocks(ExitingBlocks);
130
131 for (BasicBlock *BB : ExitingBlocks) {
132 // If we pass the updated counter back through a phi, we need to know
133 // which latch the updated value will be coming from.
134 if (!L->isLoopLatch(BB)) {
135 if (ForceHardwareLoopPHI || CounterInReg)
136 continue;
137 }
138
139 const SCEV *EC = SE.getExitCount(L, ExitingBlock: BB);
140 if (isa<SCEVCouldNotCompute>(Val: EC))
141 continue;
142 if (const SCEVConstant *ConstEC = dyn_cast<SCEVConstant>(Val: EC)) {
143 if (ConstEC->getValue()->isZero())
144 continue;
145 } else if (!SE.isLoopInvariant(S: EC, L))
146 continue;
147
148 if (SE.getTypeSizeInBits(Ty: EC->getType()) > CountType->getBitWidth())
149 continue;
150
151 // If this exiting block is contained in a nested loop, it is not eligible
152 // for insertion of the branch-and-decrement since the inner loop would
153 // end up messing up the value in the CTR.
154 if (!IsNestingLegal && LI.getLoopFor(BB) != L && !ForceNestedLoop)
155 continue;
156
157 // We now have a loop-invariant count of loop iterations (which is not the
158 // constant zero) for which we know that this loop will not exit via this
159 // existing block.
160
161 // We need to make sure that this block will run on every loop iteration.
162 // For this to be true, we must dominate all blocks with backedges. Such
163 // blocks are in-loop predecessors to the header block.
164 bool NotAlways = false;
165 for (BasicBlock *Pred : predecessors(BB: L->getHeader())) {
166 if (!L->contains(BB: Pred))
167 continue;
168
169 if (!DT.dominates(A: BB, B: Pred)) {
170 NotAlways = true;
171 break;
172 }
173 }
174
175 if (NotAlways)
176 continue;
177
178 // Make sure this blocks ends with a conditional branch.
179 if (CondBrInst *BI = dyn_cast<CondBrInst>(Val: BB->getTerminator()))
180 ExitBranch = BI;
181 else
182 continue;
183
184 // Note that this block may not be the loop latch block, even if the loop
185 // has a latch block.
186 ExitBlock = BB;
187 ExitCount = EC;
188 break;
189 }
190
191 if (!ExitBlock)
192 return false;
193 return true;
194}
195
196TargetTransformInfo::TargetTransformInfo(const DataLayout &DL)
197 : TTIImpl(std::make_unique<NoTTIImpl>(args: DL)) {}
198
199TargetTransformInfo::~TargetTransformInfo() = default;
200
201TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg)
202 : TTIImpl(std::move(Arg.TTIImpl)) {}
203
204TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) {
205 TTIImpl = std::move(RHS.TTIImpl);
206 return *this;
207}
208
209unsigned TargetTransformInfo::getInliningThresholdMultiplier() const {
210 return TTIImpl->getInliningThresholdMultiplier();
211}
212
213unsigned
214TargetTransformInfo::getInliningCostBenefitAnalysisSavingsMultiplier() const {
215 return TTIImpl->getInliningCostBenefitAnalysisSavingsMultiplier();
216}
217
218unsigned
219TargetTransformInfo::getInliningCostBenefitAnalysisProfitableMultiplier()
220 const {
221 return TTIImpl->getInliningCostBenefitAnalysisProfitableMultiplier();
222}
223
224int TargetTransformInfo::getInliningLastCallToStaticBonus() const {
225 return TTIImpl->getInliningLastCallToStaticBonus();
226}
227
228unsigned
229TargetTransformInfo::adjustInliningThreshold(const CallBase *CB) const {
230 return TTIImpl->adjustInliningThreshold(CB);
231}
232
233unsigned TargetTransformInfo::getCallerAllocaCost(const CallBase *CB,
234 const AllocaInst *AI) const {
235 return TTIImpl->getCallerAllocaCost(CB, AI);
236}
237
238int TargetTransformInfo::getInlinerVectorBonusPercent() const {
239 return TTIImpl->getInlinerVectorBonusPercent();
240}
241
242InstructionCost TargetTransformInfo::getGEPCost(
243 Type *PointeeType, const Value *Ptr, ArrayRef<const Value *> Operands,
244 TTI::TargetCostKind CostKind, Type *AccessType) const {
245 return TTIImpl->getGEPCost(PointeeType, Ptr, Operands, CostKind, AccessType);
246}
247
248InstructionCost TargetTransformInfo::getPointersChainCost(
249 ArrayRef<const Value *> Ptrs, const Value *Base,
250 const TTI::PointersChainInfo &Info, Type *AccessTy,
251 TTI::TargetCostKind CostKind) const {
252 assert((Base || !Info.isSameBase()) &&
253 "If pointers have same base address it has to be provided.");
254 return TTIImpl->getPointersChainCost(Ptrs, Base, Info, AccessTy, CostKind);
255}
256
257unsigned TargetTransformInfo::getEstimatedNumberOfCaseClusters(
258 const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI,
259 BlockFrequencyInfo *BFI) const {
260 return TTIImpl->getEstimatedNumberOfCaseClusters(SI, JTSize, PSI, BFI);
261}
262
263InstructionCost
264TargetTransformInfo::getInstructionCost(const User *U,
265 ArrayRef<const Value *> Operands,
266 enum TargetCostKind CostKind) const {
267 InstructionCost Cost = TTIImpl->getInstructionCost(U, Operands, CostKind);
268 assert((CostKind == TTI::TCK_RecipThroughput || Cost >= 0) &&
269 "TTI should not produce negative costs!");
270 return Cost;
271}
272
273BranchProbability TargetTransformInfo::getPredictableBranchThreshold() const {
274 return PredictableBranchThreshold.getNumOccurrences() > 0
275 ? BranchProbability(PredictableBranchThreshold, 100)
276 : TTIImpl->getPredictableBranchThreshold();
277}
278
279InstructionCost TargetTransformInfo::getBranchMispredictPenalty() const {
280 return TTIImpl->getBranchMispredictPenalty();
281}
282
283bool TargetTransformInfo::hasBranchDivergence(const Function *F) const {
284 return TTIImpl->hasBranchDivergence(F);
285}
286
287ValueUniformity
288llvm::TargetTransformInfo::getValueUniformity(const Value *V) const {
289 ValueUniformity VU = TTIImpl->getValueUniformity(V);
290 if (const auto *Call = dyn_cast<CallBase>(Val: V)) {
291 if (VU == ValueUniformity::NeverUniform &&
292 Call->hasFnAttr(Kind: Attribute::NoDivergenceSource))
293 return ValueUniformity::Default;
294 }
295 return VU;
296}
297
298bool llvm::TargetTransformInfo::isValidAddrSpaceCast(unsigned FromAS,
299 unsigned ToAS) const {
300 return TTIImpl->isValidAddrSpaceCast(FromAS, ToAS);
301}
302
303bool llvm::TargetTransformInfo::addrspacesMayAlias(unsigned FromAS,
304 unsigned ToAS) const {
305 return TTIImpl->addrspacesMayAlias(AS0: FromAS, AS1: ToAS);
306}
307
308unsigned TargetTransformInfo::getFlatAddressSpace() const {
309 return TTIImpl->getFlatAddressSpace();
310}
311
312unsigned TargetTransformInfo::getAddressSpaceJoin(unsigned AS1,
313 unsigned AS2) const {
314 assert(AS1 != AS2 && "Expected distinct address spaces");
315 return TTIImpl->getAddressSpaceJoin(AS1, AS2);
316}
317
318bool TargetTransformInfo::collectFlatAddressOperands(
319 SmallVectorImpl<int> &OpIndexes, Intrinsic::ID IID) const {
320 return TTIImpl->collectFlatAddressOperands(OpIndexes, IID);
321}
322
323bool TargetTransformInfo::isNoopAddrSpaceCast(unsigned FromAS,
324 unsigned ToAS) const {
325 return TTIImpl->isNoopAddrSpaceCast(FromAS, ToAS);
326}
327
328std::pair<KnownBits, KnownBits>
329TargetTransformInfo::computeKnownBitsAddrSpaceCast(unsigned ToAS,
330 const Value &PtrOp) const {
331 return TTIImpl->computeKnownBitsAddrSpaceCast(ToAS, PtrOp);
332}
333
334KnownBits TargetTransformInfo::computeKnownBitsAddrSpaceCast(
335 unsigned FromAS, unsigned ToAS, const KnownBits &FromPtrBits) const {
336 return TTIImpl->computeKnownBitsAddrSpaceCast(FromAS, ToAS, FromPtrBits);
337}
338
339APInt TargetTransformInfo::getAddrSpaceCastPreservedPtrMask(
340 unsigned SrcAS, unsigned DstAS) const {
341 return TTIImpl->getAddrSpaceCastPreservedPtrMask(SrcAS, DstAS);
342}
343
344bool TargetTransformInfo::canHaveNonUndefGlobalInitializerInAddressSpace(
345 unsigned AS) const {
346 return TTIImpl->canHaveNonUndefGlobalInitializerInAddressSpace(AS);
347}
348
349unsigned TargetTransformInfo::getAssumedAddrSpace(const Value *V) const {
350 return TTIImpl->getAssumedAddrSpace(V);
351}
352
353std::pair<const Value *, unsigned>
354TargetTransformInfo::getPredicatedAddrSpace(const Value *V) const {
355 return TTIImpl->getPredicatedAddrSpace(V);
356}
357
358Value *TargetTransformInfo::rewriteIntrinsicWithAddressSpace(
359 IntrinsicInst *II, Value *OldV, Value *NewV) const {
360 return TTIImpl->rewriteIntrinsicWithAddressSpace(II, OldV, NewV);
361}
362
363bool TargetTransformInfo::isLoweredToCall(const Function *F) const {
364 return TTIImpl->isLoweredToCall(F);
365}
366
367bool TargetTransformInfo::isHardwareLoopProfitable(
368 Loop *L, ScalarEvolution &SE, AssumptionCache &AC,
369 TargetLibraryInfo *LibInfo, HardwareLoopInfo &HWLoopInfo) const {
370 return TTIImpl->isHardwareLoopProfitable(L, SE, AC, LibInfo, HWLoopInfo);
371}
372
373unsigned TargetTransformInfo::getEpilogueVectorizationMinVF() const {
374 return TTIImpl->getEpilogueVectorizationMinVF();
375}
376
377bool TargetTransformInfo::preferTailFoldingOverEpilogue(
378 TailFoldingInfo *TFI) const {
379 return TTIImpl->preferTailFoldingOverEpilogue(TFI);
380}
381
382TailFoldingStyle TargetTransformInfo::getPreferredTailFoldingStyle() const {
383 return TTIImpl->getPreferredTailFoldingStyle();
384}
385
386std::optional<Instruction *>
387TargetTransformInfo::instCombineIntrinsic(InstCombiner &IC,
388 IntrinsicInst &II) const {
389 return TTIImpl->instCombineIntrinsic(IC, II);
390}
391
392std::optional<Value *> TargetTransformInfo::simplifyDemandedUseBitsIntrinsic(
393 InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, KnownBits &Known,
394 bool &KnownBitsComputed) const {
395 return TTIImpl->simplifyDemandedUseBitsIntrinsic(IC, II, DemandedMask, Known,
396 KnownBitsComputed);
397}
398
399std::optional<Value *> TargetTransformInfo::simplifyDemandedVectorEltsIntrinsic(
400 InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
401 APInt &UndefElts2, APInt &UndefElts3,
402 std::function<void(Instruction *, unsigned, APInt, APInt &)>
403 SimplifyAndSetOp) const {
404 return TTIImpl->simplifyDemandedVectorEltsIntrinsic(
405 IC, II, DemandedElts, UndefElts, UndefElts2, UndefElts3,
406 SimplifyAndSetOp);
407}
408
409void TargetTransformInfo::getUnrollingPreferences(
410 Loop *L, ScalarEvolution &SE, UnrollingPreferences &UP,
411 OptimizationRemarkEmitter *ORE) const {
412 return TTIImpl->getUnrollingPreferences(L, SE, UP, ORE);
413}
414
415void TargetTransformInfo::getPeelingPreferences(Loop *L, ScalarEvolution &SE,
416 PeelingPreferences &PP) const {
417 return TTIImpl->getPeelingPreferences(L, SE, PP);
418}
419
420bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const {
421 return TTIImpl->isLegalAddImmediate(Imm);
422}
423
424bool TargetTransformInfo::isLegalAddScalableImmediate(int64_t Imm) const {
425 return TTIImpl->isLegalAddScalableImmediate(Imm);
426}
427
428bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const {
429 return TTIImpl->isLegalICmpImmediate(Imm);
430}
431
432bool TargetTransformInfo::preferLoopExitWithEqualityComparison(
433 const ICmpInst &Cond, const APInt &PostIncExitValue) const {
434 return TTIImpl->preferLoopExitWithEqualityComparison(Cond, PostIncExitValue);
435}
436
437bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
438 int64_t BaseOffset,
439 bool HasBaseReg, int64_t Scale,
440 unsigned AddrSpace,
441 Instruction *I,
442 int64_t ScalableOffset) const {
443 return TTIImpl->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
444 Scale, AddrSpace, I, ScalableOffset);
445}
446
447bool TargetTransformInfo::isLSRCostLess(const LSRCost &C1,
448 const LSRCost &C2) const {
449 return TTIImpl->isLSRCostLess(C1, C2);
450}
451
452bool TargetTransformInfo::isNumRegsMajorCostOfLSR() const {
453 return TTIImpl->isNumRegsMajorCostOfLSR();
454}
455
456bool TargetTransformInfo::shouldDropLSRSolutionIfLessProfitable() const {
457 return TTIImpl->shouldDropLSRSolutionIfLessProfitable();
458}
459
460bool TargetTransformInfo::isProfitableLSRChainElement(Instruction *I) const {
461 return TTIImpl->isProfitableLSRChainElement(I);
462}
463
464bool TargetTransformInfo::canMacroFuseCmp() const {
465 return TTIImpl->canMacroFuseCmp();
466}
467
468bool TargetTransformInfo::canSaveCmp(Loop *L, CondBrInst **BI,
469 ScalarEvolution *SE, LoopInfo *LI,
470 DominatorTree *DT, AssumptionCache *AC,
471 TargetLibraryInfo *LibInfo) const {
472 return TTIImpl->canSaveCmp(L, BI, SE, LI, DT, AC, LibInfo);
473}
474
475TTI::AddressingModeKind
476TargetTransformInfo::getPreferredAddressingMode(const Loop *L,
477 ScalarEvolution *SE) const {
478 return TTIImpl->getPreferredAddressingMode(L, SE);
479}
480
481bool TargetTransformInfo::isLegalMaskedStore(Type *DataType, Align Alignment,
482 unsigned AddressSpace,
483 TTI::MaskKind MaskKind) const {
484 return TTIImpl->isLegalMaskedStore(DataType, Alignment, AddressSpace,
485 MaskKind);
486}
487
488bool TargetTransformInfo::isLegalMaskedLoad(Type *DataType, Align Alignment,
489 unsigned AddressSpace,
490 TTI::MaskKind MaskKind) const {
491 return TTIImpl->isLegalMaskedLoad(DataType, Alignment, AddressSpace,
492 MaskKind);
493}
494
495bool TargetTransformInfo::isLegalSpeculativeLoad(Type *DataType,
496 unsigned AddressSpace) const {
497 return TTIImpl->isLegalSpeculativeLoad(DataType, AddressSpace);
498}
499
500bool TargetTransformInfo::isLegalNTStore(Type *DataType,
501 Align Alignment) const {
502 return TTIImpl->isLegalNTStore(DataType, Alignment);
503}
504
505bool TargetTransformInfo::isLegalNTLoad(Type *DataType, Align Alignment) const {
506 return TTIImpl->isLegalNTLoad(DataType, Alignment);
507}
508
509bool TargetTransformInfo::isLegalBroadcastLoad(Type *ElementTy,
510 ElementCount NumElements) const {
511 return TTIImpl->isLegalBroadcastLoad(ElementTy, NumElements);
512}
513
514bool TargetTransformInfo::isLegalMaskedGather(Type *DataType,
515 Align Alignment) const {
516 return TTIImpl->isLegalMaskedGather(DataType, Alignment);
517}
518
519bool TargetTransformInfo::isLegalAltInstr(
520 VectorType *VecTy, unsigned Opcode0, unsigned Opcode1,
521 const SmallBitVector &OpcodeMask, ArrayRef<const Value *> Scalars) const {
522 return TTIImpl->isLegalAltInstr(VecTy, Opcode0, Opcode1, OpcodeMask, Scalars);
523}
524
525bool TargetTransformInfo::isLegalMaskedScatter(Type *DataType,
526 Align Alignment) const {
527 return TTIImpl->isLegalMaskedScatter(DataType, Alignment);
528}
529
530bool TargetTransformInfo::forceScalarizeMaskedGather(VectorType *DataType,
531 Align Alignment) const {
532 return TTIImpl->forceScalarizeMaskedGather(DataType, Alignment);
533}
534
535bool TargetTransformInfo::forceScalarizeMaskedScatter(VectorType *DataType,
536 Align Alignment) const {
537 return TTIImpl->forceScalarizeMaskedScatter(DataType, Alignment);
538}
539
540bool TargetTransformInfo::isLegalMaskedCompressStore(Type *DataType,
541 Align Alignment) const {
542 return TTIImpl->isLegalMaskedCompressStore(DataType, Alignment);
543}
544
545bool TargetTransformInfo::isLegalMaskedExpandLoad(Type *DataType,
546 Align Alignment) const {
547 return TTIImpl->isLegalMaskedExpandLoad(DataType, Alignment);
548}
549
550bool TargetTransformInfo::isLegalStridedLoadStore(Type *DataType,
551 Align Alignment) const {
552 return TTIImpl->isLegalStridedLoadStore(DataType, Alignment);
553}
554
555bool TargetTransformInfo::hasMultiVectorLoadStore(
556 unsigned NumVectors, TTI::MaskSource Mask, VectorType *VectorTy,
557 bool IsStore, std::optional<Instruction::CastOps> CastHint) const {
558 return TTIImpl->hasMultiVectorLoadStore(NumVectors, Mask, VectorTy, IsStore,
559 CastHint);
560}
561
562bool TargetTransformInfo::isLegalInterleavedAccessType(
563 VectorType *VTy, unsigned Factor, Align Alignment,
564 unsigned AddrSpace) const {
565 return TTIImpl->isLegalInterleavedAccessType(VTy, Factor, Alignment,
566 AddrSpace);
567}
568
569bool TargetTransformInfo::isLegalMaskedVectorHistogram(Type *AddrType,
570 Type *DataType) const {
571 return TTIImpl->isLegalMaskedVectorHistogram(AddrType, DataType);
572}
573
574bool TargetTransformInfo::enableOrderedReductions() const {
575 return TTIImpl->enableOrderedReductions();
576}
577
578bool TargetTransformInfo::hasDivRemOp(Type *DataType, bool IsSigned) const {
579 return TTIImpl->hasDivRemOp(DataType, IsSigned);
580}
581
582bool TargetTransformInfo::hasVolatileVariant(Instruction *I,
583 unsigned AddrSpace) const {
584 return TTIImpl->hasVolatileVariant(I, AddrSpace);
585}
586
587bool TargetTransformInfo::prefersVectorizedAddressing() const {
588 return TTIImpl->prefersVectorizedAddressing();
589}
590
591InstructionCost TargetTransformInfo::getScalingFactorCost(
592 Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg,
593 int64_t Scale, unsigned AddrSpace) const {
594 InstructionCost Cost = TTIImpl->getScalingFactorCost(
595 Ty, BaseGV, BaseOffset, HasBaseReg, Scale, AddrSpace);
596 assert(Cost >= 0 && "TTI should not produce negative costs!");
597 return Cost;
598}
599
600bool TargetTransformInfo::LSRWithInstrQueries() const {
601 return TTIImpl->LSRWithInstrQueries();
602}
603
604bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const {
605 return TTIImpl->isTruncateFree(Ty1, Ty2);
606}
607
608bool TargetTransformInfo::isProfitableToHoist(Instruction *I) const {
609 return TTIImpl->isProfitableToHoist(I);
610}
611
612bool TargetTransformInfo::useAA() const { return TTIImpl->useAA(); }
613
614bool TargetTransformInfo::isTypeLegal(Type *Ty) const {
615 return TTIImpl->isTypeLegal(Ty);
616}
617
618unsigned TargetTransformInfo::getRegUsageForType(Type *Ty) const {
619 return TTIImpl->getRegUsageForType(Ty);
620}
621
622bool TargetTransformInfo::shouldBuildLookupTables() const {
623 return TTIImpl->shouldBuildLookupTables();
624}
625
626bool TargetTransformInfo::shouldBuildLookupTablesForConstant(
627 Constant *C) const {
628 return TTIImpl->shouldBuildLookupTablesForConstant(C);
629}
630
631unsigned TargetTransformInfo::getMinimumLookupTableEntryBitWidth() const {
632 return TTIImpl->getMinimumLookupTableEntryBitWidth();
633}
634
635bool TargetTransformInfo::shouldBuildRelLookupTables() const {
636 return TTIImpl->shouldBuildRelLookupTables();
637}
638
639bool TargetTransformInfo::useColdCCForColdCall(Function &F) const {
640 return TTIImpl->useColdCCForColdCall(F);
641}
642
643bool TargetTransformInfo::useFastCCForInternalCall(Function &F) const {
644 return TTIImpl->useFastCCForInternalCall(F);
645}
646
647bool TargetTransformInfo::isTargetIntrinsicWithScalarOpAtArg(
648 Intrinsic::ID ID, unsigned ScalarOpdIdx) const {
649 return TTIImpl->isTargetIntrinsicWithScalarOpAtArg(ID, ScalarOpdIdx);
650}
651
652bool TargetTransformInfo::isTargetIntrinsicWithOverloadTypeAtArg(
653 Intrinsic::ID ID, int OpdIdx) const {
654 return TTIImpl->isTargetIntrinsicWithOverloadTypeAtArg(ID, OpdIdx);
655}
656
657bool TargetTransformInfo::isTargetIntrinsicWithStructReturnOverloadAtField(
658 Intrinsic::ID ID, int RetIdx) const {
659 return TTIImpl->isTargetIntrinsicWithStructReturnOverloadAtField(ID, RetIdx);
660}
661
662TargetTransformInfo::VectorInstrContext
663TargetTransformInfo::combineVectorInstrContexts(
664 TargetTransformInfo::VectorInstrContext Ctx1,
665 TargetTransformInfo::VectorInstrContext Ctx2) {
666 return Ctx1 == Ctx2 ? Ctx1 : TargetTransformInfo::VectorInstrContext::None;
667}
668
669TargetTransformInfo::VectorInstrContext
670TargetTransformInfo::getVectorInstrContextHint(const Instruction *I) {
671 if (!I)
672 return VectorInstrContext::None;
673
674 // For inserts, check if the value being inserted comes from a single-use
675 // load.
676 if (isa<InsertElementInst>(Val: I) && isa<LoadInst>(Val: I->getOperand(i: 1)) &&
677 I->getOperand(i: 1)->hasOneUse())
678 return VectorInstrContext::Load;
679
680 // For extracts, check if it has a single use that is a store.
681 if (isa<ExtractElementInst>(Val: I) && I->hasOneUse() &&
682 isa<StoreInst>(Val: *I->user_begin()))
683 return VectorInstrContext::Store;
684
685 return VectorInstrContext::None;
686}
687
688TargetTransformInfo::VectorInstrContext
689TargetTransformInfo::getVectorInstrContextHint(ArrayRef<Value *> VL,
690 const APInt &DemandedElts) {
691 VectorInstrContext VIC = VectorInstrContext::None;
692 for (unsigned I : seq(Size: VL.size())) {
693 if (!DemandedElts[I])
694 continue;
695 Value *V = VL[I];
696 if (isa<UndefValue>(Val: V))
697 continue;
698 auto *Inst = dyn_cast<Instruction>(Val: V);
699 if (!Inst)
700 return VectorInstrContext::None;
701 VectorInstrContext IVIC = getVectorInstrContextHint(I: Inst);
702 if (VIC == VectorInstrContext::None) {
703 VIC = IVIC;
704 continue;
705 }
706 if (VIC != IVIC)
707 return VectorInstrContext::None;
708 }
709 return VIC;
710}
711
712TargetTransformInfo::VectorInstrContext
713TargetTransformInfo::getBuildVectorContextHint(
714 ArrayRef<int> Mask, ArrayRef<Value *> Scalars,
715 function_ref<bool(SmallVectorImpl<BuildVectorUseOp> &)> GatherUseOps)
716 const {
717 return TTIImpl->getBuildVectorContextHint(Mask, Scalars, GatherUseOps);
718}
719
720InstructionCost TargetTransformInfo::getScalarizationOverhead(
721 VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,
722 TTI::TargetCostKind CostKind, bool ForPoisonSrc, ArrayRef<Value *> VL,
723 TTI::VectorInstrContext VIC) const {
724 return TTIImpl->getScalarizationOverhead(Ty, DemandedElts, Insert, Extract,
725 CostKind, ForPoisonSrc, VL, VIC);
726}
727
728InstructionCost TargetTransformInfo::getOperandsScalarizationOverhead(
729 ArrayRef<Type *> Tys, TTI::TargetCostKind CostKind,
730 TTI::VectorInstrContext VIC) const {
731 return TTIImpl->getOperandsScalarizationOverhead(Tys, CostKind, VIC);
732}
733
734bool TargetTransformInfo::supportsEfficientVectorElementLoadStore() const {
735 return TTIImpl->supportsEfficientVectorElementLoadStore();
736}
737
738bool TargetTransformInfo::supportsTailCalls() const {
739 return TTIImpl->supportsTailCalls();
740}
741
742bool TargetTransformInfo::supportsTailCallFor(const CallBase *CB) const {
743 return TTIImpl->supportsTailCallFor(CB);
744}
745
746bool TargetTransformInfo::enableAggressiveInterleaving(
747 bool LoopHasReductions) const {
748 return TTIImpl->enableAggressiveInterleaving(LoopHasReductions);
749}
750
751TargetTransformInfo::MemCmpExpansionOptions
752TargetTransformInfo::enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const {
753 return TTIImpl->enableMemCmpExpansion(OptSize, IsZeroCmp);
754}
755
756bool TargetTransformInfo::enableSelectOptimize() const {
757 return TTIImpl->enableSelectOptimize();
758}
759
760bool TargetTransformInfo::shouldTreatInstructionLikeSelect(
761 const Instruction *I) const {
762 return TTIImpl->shouldTreatInstructionLikeSelect(I);
763}
764
765bool TargetTransformInfo::enableInterleavedAccessVectorization() const {
766 return TTIImpl->enableInterleavedAccessVectorization();
767}
768
769bool TargetTransformInfo::enableMaskedInterleavedAccessVectorization() const {
770 return TTIImpl->enableMaskedInterleavedAccessVectorization();
771}
772
773bool TargetTransformInfo::isFPVectorizationPotentiallyUnsafe() const {
774 return TTIImpl->isFPVectorizationPotentiallyUnsafe();
775}
776
777bool
778TargetTransformInfo::allowsMisalignedMemoryAccesses(LLVMContext &Context,
779 unsigned BitWidth,
780 unsigned AddressSpace,
781 Align Alignment,
782 unsigned *Fast) const {
783 return TTIImpl->allowsMisalignedMemoryAccesses(Context, BitWidth,
784 AddressSpace, Alignment, Fast);
785}
786
787TargetTransformInfo::PopcntSupportKind
788TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const {
789 return TTIImpl->getPopcntSupport(IntTyWidthInBit);
790}
791
792bool TargetTransformInfo::haveFastSqrt(Type *Ty) const {
793 return TTIImpl->haveFastSqrt(Ty);
794}
795
796bool TargetTransformInfo::isExpensiveToSpeculativelyExecute(
797 const Instruction *I) const {
798 return TTIImpl->isExpensiveToSpeculativelyExecute(I);
799}
800
801bool TargetTransformInfo::isFCmpOrdCheaperThanFCmpZero(Type *Ty) const {
802 return TTIImpl->isFCmpOrdCheaperThanFCmpZero(Ty);
803}
804
805InstructionCost TargetTransformInfo::getFPOpCost(Type *Ty) const {
806 InstructionCost Cost = TTIImpl->getFPOpCost(Ty);
807 assert(Cost >= 0 && "TTI should not produce negative costs!");
808 return Cost;
809}
810
811InstructionCost TargetTransformInfo::getIntImmCodeSizeCost(unsigned Opcode,
812 unsigned Idx,
813 const APInt &Imm,
814 Type *Ty) const {
815 InstructionCost Cost = TTIImpl->getIntImmCodeSizeCost(Opcode, Idx, Imm, Ty);
816 assert(Cost >= 0 && "TTI should not produce negative costs!");
817 return Cost;
818}
819
820InstructionCost
821TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty,
822 TTI::TargetCostKind CostKind) const {
823 InstructionCost Cost = TTIImpl->getIntImmCost(Imm, Ty, CostKind);
824 assert(Cost >= 0 && "TTI should not produce negative costs!");
825 return Cost;
826}
827
828InstructionCost TargetTransformInfo::getIntImmCostInst(
829 unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty,
830 TTI::TargetCostKind CostKind, Instruction *Inst) const {
831 InstructionCost Cost =
832 TTIImpl->getIntImmCostInst(Opcode, Idx, Imm, Ty, CostKind, Inst);
833 assert(Cost >= 0 && "TTI should not produce negative costs!");
834 return Cost;
835}
836
837InstructionCost
838TargetTransformInfo::getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx,
839 const APInt &Imm, Type *Ty,
840 TTI::TargetCostKind CostKind) const {
841 InstructionCost Cost =
842 TTIImpl->getIntImmCostIntrin(IID, Idx, Imm, Ty, CostKind);
843 assert(Cost >= 0 && "TTI should not produce negative costs!");
844 return Cost;
845}
846
847bool TargetTransformInfo::preferToKeepConstantsAttached(
848 const Instruction &Inst, const Function &Fn) const {
849 return TTIImpl->preferToKeepConstantsAttached(Inst, Fn);
850}
851
852unsigned TargetTransformInfo::getNumberOfRegisters(unsigned ClassID) const {
853 return TTIImpl->getNumberOfRegisters(ClassID);
854}
855
856bool TargetTransformInfo::hasConditionalLoadStoreForType(Type *Ty,
857 bool IsStore) const {
858 return TTIImpl->hasConditionalLoadStoreForType(Ty, IsStore);
859}
860
861unsigned TargetTransformInfo::getRegisterClassForType(bool Vector,
862 Type *Ty) const {
863 return TTIImpl->getRegisterClassForType(Vector, Ty);
864}
865
866const char *TargetTransformInfo::getRegisterClassName(unsigned ClassID) const {
867 return TTIImpl->getRegisterClassName(ClassID);
868}
869
870InstructionCost TargetTransformInfo::getRegisterClassSpillCost(
871 unsigned ClassID, TTI::TargetCostKind CostKind) const {
872 return TTIImpl->getRegisterClassSpillCost(ClassID, CostKind);
873}
874
875InstructionCost TargetTransformInfo::getRegisterClassReloadCost(
876 unsigned ClassID, TTI::TargetCostKind CostKind) const {
877 return TTIImpl->getRegisterClassReloadCost(ClassID, CostKind);
878}
879
880TypeSize TargetTransformInfo::getRegisterBitWidth(
881 TargetTransformInfo::RegisterKind K) const {
882 return TTIImpl->getRegisterBitWidth(K);
883}
884
885unsigned TargetTransformInfo::getMinVectorRegisterBitWidth() const {
886 return TTIImpl->getMinVectorRegisterBitWidth();
887}
888
889std::optional<unsigned> TargetTransformInfo::getVScaleForTuning() const {
890 return TTIImpl->getVScaleForTuning();
891}
892
893bool TargetTransformInfo::shouldMaximizeVectorBandwidth(
894 TargetTransformInfo::VectorKind K, Type *ElementTy) const {
895 return TTIImpl->shouldMaximizeVectorBandwidth(K, ElementTy);
896}
897
898ElementCount TargetTransformInfo::getMinimumVF(unsigned ElemWidth,
899 bool IsScalable) const {
900 return TTIImpl->getMinimumVF(ElemWidth, IsScalable);
901}
902
903unsigned TargetTransformInfo::getMaximumVF(unsigned ElemWidth,
904 unsigned Opcode) const {
905 return TTIImpl->getMaximumVF(ElemWidth, Opcode);
906}
907
908unsigned TargetTransformInfo::getStoreMinimumVF(unsigned VF, Type *ScalarMemTy,
909 Type *ScalarValTy,
910 Align Alignment,
911 unsigned AddrSpace) const {
912 return TTIImpl->getStoreMinimumVF(VF, ScalarMemTy, ScalarValTy, Alignment,
913 AddrSpace);
914}
915
916bool TargetTransformInfo::shouldConsiderAddressTypePromotion(
917 const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const {
918 return TTIImpl->shouldConsiderAddressTypePromotion(
919 I, AllowPromotionWithoutCommonHeader);
920}
921
922unsigned TargetTransformInfo::getCacheLineSize() const {
923 return CacheLineSize.getNumOccurrences() > 0 ? CacheLineSize
924 : TTIImpl->getCacheLineSize();
925}
926
927std::optional<unsigned>
928TargetTransformInfo::getCacheSize(CacheLevel Level) const {
929 return TTIImpl->getCacheSize(Level);
930}
931
932std::optional<unsigned>
933TargetTransformInfo::getCacheAssociativity(CacheLevel Level) const {
934 return TTIImpl->getCacheAssociativity(Level);
935}
936
937std::optional<unsigned> TargetTransformInfo::getMinPageSize() const {
938 return MinPageSize.getNumOccurrences() > 0 ? MinPageSize
939 : TTIImpl->getMinPageSize();
940}
941
942unsigned TargetTransformInfo::getPrefetchDistance() const {
943 return TTIImpl->getPrefetchDistance();
944}
945
946unsigned TargetTransformInfo::getMinPrefetchStride(
947 unsigned NumMemAccesses, unsigned NumStridedMemAccesses,
948 unsigned NumPrefetches, bool HasCall) const {
949 return TTIImpl->getMinPrefetchStride(NumMemAccesses, NumStridedMemAccesses,
950 NumPrefetches, HasCall);
951}
952
953unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead() const {
954 return TTIImpl->getMaxPrefetchIterationsAhead();
955}
956
957bool TargetTransformInfo::enableWritePrefetching() const {
958 return TTIImpl->enableWritePrefetching();
959}
960
961bool TargetTransformInfo::shouldPrefetchAddressSpace(unsigned AS) const {
962 return TTIImpl->shouldPrefetchAddressSpace(AS);
963}
964
965InstructionCost TargetTransformInfo::getPartialReductionCost(
966 unsigned Opcode, Type *InputTypeA, Type *InputTypeB, Type *AccumType,
967 ElementCount VF, PartialReductionExtendKind OpAExtend,
968 PartialReductionExtendKind OpBExtend, std::optional<unsigned> BinOp,
969 TTI::TargetCostKind CostKind, std::optional<FastMathFlags> FMF) const {
970 return TTIImpl->getPartialReductionCost(Opcode, InputTypeA, InputTypeB,
971 AccumType, VF, OpAExtend, OpBExtend,
972 BinOp, CostKind, FMF);
973}
974
975unsigned
976TargetTransformInfo::getMaxInterleaveFactor(ElementCount VF,
977 bool HasUnorderedReductions) const {
978 return TTIImpl->getMaxInterleaveFactor(VF, HasUnorderedReductions);
979}
980
981TargetTransformInfo::OperandValueInfo
982TargetTransformInfo::getOperandInfo(const Value *V) {
983 OperandValueKind OpInfo = OK_AnyValue;
984 OperandValueProperties OpProps = OP_None;
985
986 // undef/poison don't materialize constants.
987 if (isa<UndefValue>(Val: V))
988 return {.Kind: OK_AnyValue, .Properties: OP_None};
989
990 if (isa<ConstantInt>(Val: V) || isa<ConstantFP>(Val: V)) {
991 if (const auto *CI = dyn_cast<ConstantInt>(Val: V)) {
992 if (CI->getValue().isPowerOf2())
993 OpProps = OP_PowerOf2;
994 else if (CI->getValue().isNegatedPowerOf2())
995 OpProps = OP_NegatedPowerOf2;
996 }
997 return {.Kind: OK_UniformConstantValue, .Properties: OpProps};
998 }
999
1000 // A broadcast shuffle creates a uniform value.
1001 // TODO: Add support for non-zero index broadcasts.
1002 // TODO: Add support for different source vector width.
1003 if (const auto *ShuffleInst = dyn_cast<ShuffleVectorInst>(Val: V))
1004 if (ShuffleInst->isZeroEltSplat())
1005 OpInfo = OK_UniformValue;
1006
1007 const Value *Splat = getSplatValue(V);
1008
1009 // Check for a splat of a constant or for a non uniform vector of constants
1010 // and check if the constant(s) are all powers of two.
1011 if (Splat) {
1012 // Check for a splat of a uniform value. This is not loop aware, so return
1013 // true only for the obviously uniform cases (argument, globalvalue)
1014 if (isa<Argument>(Val: Splat) || isa<GlobalValue>(Val: Splat)) {
1015 OpInfo = OK_UniformValue;
1016 } else if (isa<Constant>(Val: Splat)) {
1017 OpInfo = OK_UniformConstantValue;
1018 if (auto *CI = dyn_cast<ConstantInt>(Val: Splat)) {
1019 if (CI->getValue().isPowerOf2())
1020 OpProps = OP_PowerOf2;
1021 else if (CI->getValue().isNegatedPowerOf2())
1022 OpProps = OP_NegatedPowerOf2;
1023 }
1024 }
1025 } else if (const auto *CDS = dyn_cast<ConstantDataSequential>(Val: V)) {
1026 OpInfo = OK_NonUniformConstantValue;
1027 bool AllPow2 = true, AllNegPow2 = true;
1028 for (uint64_t I = 0, E = CDS->getNumElements(); I != E; ++I) {
1029 if (auto *CI = dyn_cast<ConstantInt>(Val: CDS->getElementAsConstant(i: I))) {
1030 AllPow2 &= CI->getValue().isPowerOf2();
1031 AllNegPow2 &= CI->getValue().isNegatedPowerOf2();
1032 if (AllPow2 || AllNegPow2)
1033 continue;
1034 }
1035 AllPow2 = AllNegPow2 = false;
1036 break;
1037 }
1038 OpProps = AllPow2 ? OP_PowerOf2 : OpProps;
1039 OpProps = AllNegPow2 ? OP_NegatedPowerOf2 : OpProps;
1040 } else if (isa<ConstantVector>(Val: V) || isa<ConstantDataVector>(Val: V)) {
1041 OpInfo = OK_NonUniformConstantValue;
1042 }
1043
1044 return {.Kind: OpInfo, .Properties: OpProps};
1045}
1046
1047TargetTransformInfo::OperandValueInfo
1048TargetTransformInfo::getOperandInfo(ArrayRef<Value *> Ops) {
1049 assert(!Ops.empty());
1050 const auto *Op0 = Ops.front();
1051
1052 const bool IsConstant = all_of(Range&: Ops, P: [](Value *V) {
1053 // TODO: We should allow undef elements here
1054 return isa<Constant>(Val: V) && !isa<ConstantExpr, GlobalValue>(Val: V) &&
1055 !isa<UndefValue>(Val: V);
1056 });
1057 const bool IsUniform = all_of(Range&: Ops, P: [=](Value *V) {
1058 // TODO: We should allow undef elements here
1059 return V == Op0;
1060 });
1061 const bool IsPowerOfTwo = all_of(Range&: Ops, P: [](Value *V) {
1062 // TODO: We should allow undef elements here
1063 if (auto *CI = dyn_cast<ConstantInt>(Val: V))
1064 return CI->getValue().isPowerOf2();
1065 return false;
1066 });
1067 const bool IsNegatedPowerOfTwo = all_of(Range&: Ops, P: [](Value *V) {
1068 // TODO: We should allow undef elements here
1069 if (auto *CI = dyn_cast<ConstantInt>(Val: V))
1070 return CI->getValue().isNegatedPowerOf2();
1071 return false;
1072 });
1073
1074 TTI::OperandValueKind VK = TTI::OK_AnyValue;
1075 if (IsConstant && IsUniform)
1076 VK = TTI::OK_UniformConstantValue;
1077 else if (IsConstant)
1078 VK = TTI::OK_NonUniformConstantValue;
1079 else if (IsUniform)
1080 VK = TTI::OK_UniformValue;
1081
1082 TTI::OperandValueProperties VP = TTI::OP_None;
1083 VP = IsPowerOfTwo ? TTI::OP_PowerOf2 : VP;
1084 VP = IsNegatedPowerOfTwo ? TTI::OP_NegatedPowerOf2 : VP;
1085
1086 return {.Kind: VK, .Properties: VP};
1087}
1088
1089TargetTransformInfo::OperandValueInfo
1090TargetTransformInfo::commonOperandInfo(const Value *X, const Value *Y) {
1091 OperandValueInfo OpInfoX = getOperandInfo(V: X);
1092 if (X == Y)
1093 return OpInfoX;
1094 return OpInfoX.mergeWith(OpInfoY: getOperandInfo(V: Y));
1095}
1096
1097InstructionCost TargetTransformInfo::getArithmeticInstrCost(
1098 unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind,
1099 OperandValueInfo Op1Info, OperandValueInfo Op2Info,
1100 ArrayRef<const Value *> Args, const Instruction *CtxI,
1101 const TargetLibraryInfo *TLibInfo) const {
1102
1103 // Use call cost for frem instructions that have platform specific vector math
1104 // functions, as those will be replaced with calls later by SelectionDAG or
1105 // ReplaceWithVecLib pass.
1106 if (TLibInfo && Opcode == Instruction::FRem) {
1107 VectorType *VecTy = dyn_cast<VectorType>(Val: Ty);
1108 LibFunc Func = TLibInfo->getLibFunc(Opcode: Instruction::FRem, Ty: Ty->getScalarType());
1109 if (VecTy && Func != NotLibFunc &&
1110 TLibInfo->isFunctionVectorizable(F: TLibInfo->getName(F: Func),
1111 VF: VecTy->getElementCount()))
1112 return getCallInstrCost(F: nullptr, RetTy: VecTy, Tys: {VecTy, VecTy}, CostKind);
1113 }
1114
1115 InstructionCost Cost = TTIImpl->getArithmeticInstrCost(
1116 Opcode, Ty, CostKind, Opd1Info: Op1Info, Opd2Info: Op2Info, Args, CtxI);
1117 assert(Cost >= 0 && "TTI should not produce negative costs!");
1118 return Cost;
1119}
1120
1121InstructionCost TargetTransformInfo::getAltInstrCost(
1122 VectorType *VecTy, unsigned Opcode0, unsigned Opcode1,
1123 const SmallBitVector &OpcodeMask, TTI::TargetCostKind CostKind,
1124 ArrayRef<const Value *> Scalars) const {
1125 InstructionCost Cost = TTIImpl->getAltInstrCost(
1126 VecTy, Opcode0, Opcode1, OpcodeMask, CostKind, Scalars);
1127 assert(Cost >= 0 && "TTI should not produce negative costs!");
1128 return Cost;
1129}
1130
1131InstructionCost TargetTransformInfo::getShuffleCost(
1132 ShuffleKind Kind, VectorType *DstTy, VectorType *SrcTy,
1133 TTI::TargetCostKind CostKind, ArrayRef<int> Mask, int Index,
1134 VectorType *SubTp, ArrayRef<const Value *> Args, const Instruction *CtxI,
1135 TTI::VectorInstrContext VIC) const {
1136 assert((Mask.empty() || DstTy->isScalableTy() ||
1137 Mask.size() == DstTy->getElementCount().getKnownMinValue()) &&
1138 "Expected the Mask to match the return size if given");
1139 assert(SrcTy->getScalarType() == DstTy->getScalarType() &&
1140 "Expected the same scalar types");
1141 InstructionCost Cost = TTIImpl->getShuffleCost(
1142 Kind, DstTy, SrcTy, CostKind, Mask, Index, SubTp, Args, CtxI, VIC);
1143 assert(Cost >= 0 && "TTI should not produce negative costs!");
1144 return Cost;
1145}
1146
1147TargetTransformInfo::PartialReductionExtendKind
1148TargetTransformInfo::getPartialReductionExtendKind(Instruction *I) {
1149 if (auto *Cast = dyn_cast<CastInst>(Val: I))
1150 return getPartialReductionExtendKind(CastOpc: Cast->getOpcode());
1151 return PR_None;
1152}
1153
1154Instruction::CastOps
1155TargetTransformInfo::getOpcodeForPartialReductionExtendKind(
1156 TargetTransformInfo::PartialReductionExtendKind Kind) {
1157 switch (Kind) {
1158 case TargetTransformInfo::PR_ZeroExtend:
1159 return Instruction::CastOps::ZExt;
1160 case TargetTransformInfo::PR_SignExtend:
1161 return Instruction::CastOps::SExt;
1162 case TargetTransformInfo::PR_FPExtend:
1163 return Instruction::CastOps::FPExt;
1164 default:
1165 break;
1166 }
1167 llvm_unreachable("Unhandled partial reduction extend kind");
1168}
1169
1170TargetTransformInfo::PartialReductionExtendKind
1171TargetTransformInfo::getPartialReductionExtendKind(
1172 Instruction::CastOps CastOpc) {
1173 switch (CastOpc) {
1174 case Instruction::CastOps::ZExt:
1175 return PR_ZeroExtend;
1176 case Instruction::CastOps::SExt:
1177 return PR_SignExtend;
1178 case Instruction::CastOps::FPExt:
1179 return PR_FPExtend;
1180 default:
1181 return PR_None;
1182 }
1183 llvm_unreachable("Unhandled cast opcode");
1184}
1185
1186TTI::CastContextHint
1187TargetTransformInfo::getCastContextHint(const Instruction *I) {
1188 if (!I)
1189 return CastContextHint::None;
1190
1191 auto getLoadStoreKind = [](const Value *V, unsigned LdStOp, unsigned MaskedOp,
1192 unsigned GatScatOp) {
1193 const Instruction *I = dyn_cast<Instruction>(Val: V);
1194 if (!I)
1195 return CastContextHint::None;
1196
1197 if (I->getOpcode() == LdStOp)
1198 return CastContextHint::Normal;
1199
1200 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Val: I)) {
1201 if (II->getIntrinsicID() == MaskedOp)
1202 return TTI::CastContextHint::Masked;
1203 if (II->getIntrinsicID() == GatScatOp)
1204 return TTI::CastContextHint::GatherScatter;
1205 }
1206
1207 return TTI::CastContextHint::None;
1208 };
1209
1210 switch (I->getOpcode()) {
1211 case Instruction::ZExt:
1212 case Instruction::SExt:
1213 case Instruction::FPExt:
1214 return getLoadStoreKind(I->getOperand(i: 0), Instruction::Load,
1215 Intrinsic::masked_load, Intrinsic::masked_gather);
1216 case Instruction::Trunc:
1217 case Instruction::FPTrunc:
1218 if (I->hasOneUse())
1219 return getLoadStoreKind(*I->user_begin(), Instruction::Store,
1220 Intrinsic::masked_store,
1221 Intrinsic::masked_scatter);
1222 break;
1223 default:
1224 return CastContextHint::None;
1225 }
1226
1227 return TTI::CastContextHint::None;
1228}
1229
1230InstructionCost TargetTransformInfo::getCastInstrCost(
1231 unsigned Opcode, Type *Dst, Type *Src, CastContextHint CCH,
1232 TTI::TargetCostKind CostKind, const Instruction *I) const {
1233 assert((I == nullptr || I->getOpcode() == Opcode) &&
1234 "Opcode should reflect passed instruction.");
1235 InstructionCost Cost =
1236 TTIImpl->getCastInstrCost(Opcode, Dst, Src, CCH, CostKind, I);
1237 assert(Cost >= 0 && "TTI should not produce negative costs!");
1238 return Cost;
1239}
1240
1241InstructionCost TargetTransformInfo::getExtractWithExtendCost(
1242 unsigned Opcode, Type *Dst, VectorType *VecTy, unsigned Index,
1243 TTI::TargetCostKind CostKind) const {
1244 InstructionCost Cost =
1245 TTIImpl->getExtractWithExtendCost(Opcode, Dst, VecTy, Index, CostKind);
1246 assert(Cost >= 0 && "TTI should not produce negative costs!");
1247 return Cost;
1248}
1249
1250InstructionCost TargetTransformInfo::getCFInstrCost(
1251 unsigned Opcode, TTI::TargetCostKind CostKind, const Instruction *I) const {
1252 assert((I == nullptr || I->getOpcode() == Opcode) &&
1253 "Opcode should reflect passed instruction.");
1254 InstructionCost Cost = TTIImpl->getCFInstrCost(Opcode, CostKind, I);
1255 assert(Cost >= 0 && "TTI should not produce negative costs!");
1256 return Cost;
1257}
1258
1259InstructionCost TargetTransformInfo::getCmpSelInstrCost(
1260 unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred,
1261 TTI::TargetCostKind CostKind, OperandValueInfo Op1Info,
1262 OperandValueInfo Op2Info, const Instruction *I) const {
1263 assert((I == nullptr || I->getOpcode() == Opcode) &&
1264 "Opcode should reflect passed instruction.");
1265 InstructionCost Cost = TTIImpl->getCmpSelInstrCost(
1266 Opcode, ValTy, CondTy, VecPred, CostKind, Op1Info, Op2Info, I);
1267 assert(Cost >= 0 && "TTI should not produce negative costs!");
1268 return Cost;
1269}
1270
1271InstructionCost TargetTransformInfo::getVectorInstrCost(
1272 unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index,
1273 const Value *Op0, const Value *Op1, TTI::VectorInstrContext VIC) const {
1274 assert((Opcode == Instruction::InsertElement ||
1275 Opcode == Instruction::ExtractElement) &&
1276 "Expecting Opcode to be insertelement/extractelement.");
1277 InstructionCost Cost =
1278 TTIImpl->getVectorInstrCost(Opcode, Val, CostKind, Index, Op0, Op1, VIC);
1279 assert(Cost >= 0 && "TTI should not produce negative costs!");
1280 return Cost;
1281}
1282
1283InstructionCost TargetTransformInfo::getVectorInstrCost(
1284 unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index,
1285 Value *Scalar, ArrayRef<std::tuple<Value *, User *, int>> ScalarUserAndIdx,
1286 TTI::VectorInstrContext VIC) const {
1287 assert((Opcode == Instruction::InsertElement ||
1288 Opcode == Instruction::ExtractElement) &&
1289 "Expecting Opcode to be insertelement/extractelement.");
1290 InstructionCost Cost = TTIImpl->getVectorInstrCost(
1291 Opcode, Val, CostKind, Index, Scalar, ScalarUserAndIdx, VIC);
1292 assert(Cost >= 0 && "TTI should not produce negative costs!");
1293 return Cost;
1294}
1295
1296InstructionCost TargetTransformInfo::getVectorInstrCost(
1297 const Instruction &I, Type *Val, TTI::TargetCostKind CostKind,
1298 unsigned Index, TTI::VectorInstrContext VIC) const {
1299 // FIXME: Assert that Opcode is either InsertElement or ExtractElement.
1300 // This is mentioned in the interface description and respected by all
1301 // callers, but never asserted upon.
1302 InstructionCost Cost =
1303 TTIImpl->getVectorInstrCost(I, Val, CostKind, Index, VIC);
1304 assert(Cost >= 0 && "TTI should not produce negative costs!");
1305 return Cost;
1306}
1307
1308InstructionCost TargetTransformInfo::getIndexedVectorInstrCostFromEnd(
1309 unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind,
1310 unsigned Index) const {
1311 InstructionCost Cost =
1312 TTIImpl->getIndexedVectorInstrCostFromEnd(Opcode, Val, CostKind, Index);
1313 assert(Cost >= 0 && "TTI should not produce negative costs!");
1314 return Cost;
1315}
1316
1317InstructionCost TargetTransformInfo::getInsertExtractValueCost(
1318 unsigned Opcode, TTI::TargetCostKind CostKind) const {
1319 assert((Opcode == Instruction::InsertValue ||
1320 Opcode == Instruction::ExtractValue) &&
1321 "Expecting Opcode to be insertvalue/extractvalue.");
1322 InstructionCost Cost = TTIImpl->getInsertExtractValueCost(Opcode, CostKind);
1323 assert(Cost >= 0 && "TTI should not produce negative costs!");
1324 return Cost;
1325}
1326
1327InstructionCost TargetTransformInfo::getReplicationShuffleCost(
1328 Type *EltTy, int ReplicationFactor, int VF, const APInt &DemandedDstElts,
1329 TTI::TargetCostKind CostKind) const {
1330 InstructionCost Cost = TTIImpl->getReplicationShuffleCost(
1331 EltTy, ReplicationFactor, VF, DemandedDstElts, CostKind);
1332 assert(Cost >= 0 && "TTI should not produce negative costs!");
1333 return Cost;
1334}
1335
1336InstructionCost TargetTransformInfo::getMemoryOpCost(
1337 unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace,
1338 TTI::TargetCostKind CostKind, TTI::OperandValueInfo OpInfo,
1339 const Instruction *I) const {
1340 assert((I == nullptr || I->getOpcode() == Opcode) &&
1341 "Opcode should reflect passed instruction.");
1342 InstructionCost Cost = TTIImpl->getMemoryOpCost(
1343 Opcode, Src, Alignment, AddressSpace, CostKind, OpInfo, I);
1344 assert(Cost >= 0 && "TTI should not produce negative costs!");
1345 return Cost;
1346}
1347
1348InstructionCost TargetTransformInfo::getInterleavedMemoryOpCost(
1349 unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
1350 Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind,
1351 bool UseMaskForCond, bool UseMaskForGaps) const {
1352 InstructionCost Cost = TTIImpl->getInterleavedMemoryOpCost(
1353 Opcode, VecTy, Factor, Indices, Alignment, AddressSpace, CostKind,
1354 UseMaskForCond, UseMaskForGaps);
1355 assert(Cost >= 0 && "TTI should not produce negative costs!");
1356 return Cost;
1357}
1358
1359InstructionCost
1360TargetTransformInfo::getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA,
1361 TTI::TargetCostKind CostKind) const {
1362 InstructionCost Cost = TTIImpl->getIntrinsicInstrCost(ICA, CostKind);
1363 assert(Cost >= 0 && "TTI should not produce negative costs!");
1364 return Cost;
1365}
1366
1367InstructionCost TargetTransformInfo::getMemIntrinsicInstrCost(
1368 const MemIntrinsicCostAttributes &MICA,
1369 TTI::TargetCostKind CostKind) const {
1370 InstructionCost Cost = TTIImpl->getMemIntrinsicInstrCost(MICA, CostKind);
1371 assert(Cost >= 0 && "TTI should not produce negative costs!");
1372 return Cost;
1373}
1374
1375InstructionCost
1376TargetTransformInfo::getCallInstrCost(Function *F, Type *RetTy,
1377 ArrayRef<Type *> Tys,
1378 TTI::TargetCostKind CostKind) const {
1379 InstructionCost Cost = TTIImpl->getCallInstrCost(F, RetTy, Tys, CostKind);
1380 assert(Cost >= 0 && "TTI should not produce negative costs!");
1381 return Cost;
1382}
1383
1384unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const {
1385 return TTIImpl->getNumberOfParts(Tp);
1386}
1387
1388InstructionCost TargetTransformInfo::getAddressComputationCost(
1389 Type *PtrTy, ScalarEvolution *SE, const SCEV *Ptr,
1390 TTI::TargetCostKind CostKind) const {
1391 InstructionCost Cost =
1392 TTIImpl->getAddressComputationCost(PtrTy, SE, Ptr, CostKind);
1393 assert(Cost >= 0 && "TTI should not produce negative costs!");
1394 return Cost;
1395}
1396
1397InstructionCost TargetTransformInfo::getMemcpyCost(const Instruction *I) const {
1398 InstructionCost Cost = TTIImpl->getMemcpyCost(I);
1399 assert(Cost >= 0 && "TTI should not produce negative costs!");
1400 return Cost;
1401}
1402
1403uint64_t TargetTransformInfo::getMaxMemIntrinsicInlineSizeThreshold() const {
1404 return TTIImpl->getMaxMemIntrinsicInlineSizeThreshold();
1405}
1406
1407uint64_t TargetTransformInfo::getMaxBoundedMemSetInlineSize() const {
1408 return TTIImpl->getMaxBoundedMemSetInlineSize();
1409}
1410
1411InstructionCost TargetTransformInfo::getArithmeticReductionCost(
1412 unsigned Opcode, VectorType *Ty, std::optional<FastMathFlags> FMF,
1413 TTI::TargetCostKind CostKind) const {
1414 InstructionCost Cost =
1415 TTIImpl->getArithmeticReductionCost(Opcode, Ty, FMF, CostKind);
1416 assert(Cost >= 0 && "TTI should not produce negative costs!");
1417 return Cost;
1418}
1419
1420InstructionCost TargetTransformInfo::getMinMaxReductionCost(
1421 Intrinsic::ID IID, VectorType *Ty, FastMathFlags FMF,
1422 TTI::TargetCostKind CostKind) const {
1423 InstructionCost Cost =
1424 TTIImpl->getMinMaxReductionCost(IID, Ty, FMF, CostKind);
1425 assert(Cost >= 0 && "TTI should not produce negative costs!");
1426 return Cost;
1427}
1428
1429InstructionCost TargetTransformInfo::getExtendedReductionCost(
1430 unsigned Opcode, bool IsUnsigned, Type *ResTy, VectorType *Ty,
1431 std::optional<FastMathFlags> FMF, TTI::TargetCostKind CostKind) const {
1432 return TTIImpl->getExtendedReductionCost(Opcode, IsUnsigned, ResTy, Ty, FMF,
1433 CostKind);
1434}
1435
1436InstructionCost TargetTransformInfo::getMulAccReductionCost(
1437 bool IsUnsigned, unsigned RedOpcode, Type *ResTy, VectorType *Ty,
1438 TTI::TargetCostKind CostKind) const {
1439 return TTIImpl->getMulAccReductionCost(IsUnsigned, RedOpcode, ResTy, Ty,
1440 CostKind);
1441}
1442
1443InstructionCost
1444TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const {
1445 return TTIImpl->getCostOfKeepingLiveOverCall(Tys);
1446}
1447
1448bool TargetTransformInfo::getTgtMemIntrinsic(IntrinsicInst *Inst,
1449 MemIntrinsicInfo &Info) const {
1450 return TTIImpl->getTgtMemIntrinsic(Inst, Info);
1451}
1452
1453unsigned TargetTransformInfo::getAtomicMemIntrinsicMaxElementSize() const {
1454 return TTIImpl->getAtomicMemIntrinsicMaxElementSize();
1455}
1456
1457Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic(
1458 IntrinsicInst *Inst, Type *ExpectedType, bool CanCreate) const {
1459 return TTIImpl->getOrCreateResultFromMemIntrinsic(Inst, ExpectedType,
1460 CanCreate);
1461}
1462
1463Type *TargetTransformInfo::getMemcpyLoopLoweringType(
1464 LLVMContext &Context, Value *Length, unsigned SrcAddrSpace,
1465 unsigned DestAddrSpace, Align SrcAlign, Align DestAlign,
1466 std::optional<uint32_t> AtomicElementSize) const {
1467 return TTIImpl->getMemcpyLoopLoweringType(Context, Length, SrcAddrSpace,
1468 DestAddrSpace, SrcAlign, DestAlign,
1469 AtomicElementSize);
1470}
1471
1472void TargetTransformInfo::getMemcpyLoopResidualLoweringType(
1473 SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
1474 unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,
1475 Align SrcAlign, Align DestAlign,
1476 std::optional<uint32_t> AtomicCpySize) const {
1477 TTIImpl->getMemcpyLoopResidualLoweringType(
1478 OpsOut, Context, RemainingBytes, SrcAddrSpace, DestAddrSpace, SrcAlign,
1479 DestAlign, AtomicCpySize);
1480}
1481
1482bool TargetTransformInfo::areInlineCompatible(const Function *Caller,
1483 const Function *Callee) const {
1484 return TTIImpl->areInlineCompatible(Caller, Callee);
1485}
1486
1487unsigned
1488TargetTransformInfo::getInlineCallPenalty(const Function *F,
1489 const CallBase &Call,
1490 unsigned DefaultCallPenalty) const {
1491 return TTIImpl->getInlineCallPenalty(F, Call, DefaultCallPenalty);
1492}
1493
1494bool TargetTransformInfo::shouldCopyAttributeWhenOutliningFrom(
1495 const Function *Caller, const Attribute &Attr) const {
1496 return TTIImpl->shouldCopyAttributeWhenOutliningFrom(Caller, Attr);
1497}
1498bool TargetTransformInfo::areTypesABICompatible(const Function *Caller,
1499 const Function *Callee,
1500 ArrayRef<Type *> Types) const {
1501 return TTIImpl->areTypesABICompatible(Caller, Callee, Types);
1502}
1503
1504bool TargetTransformInfo::isIndexedLoadLegal(MemIndexedMode Mode,
1505 Type *Ty) const {
1506 return TTIImpl->isIndexedLoadLegal(Mode, Ty);
1507}
1508
1509bool TargetTransformInfo::isIndexedStoreLegal(MemIndexedMode Mode,
1510 Type *Ty) const {
1511 return TTIImpl->isIndexedStoreLegal(Mode, Ty);
1512}
1513
1514unsigned TargetTransformInfo::getLoadStoreVecRegBitWidth(unsigned AS) const {
1515 return TTIImpl->getLoadStoreVecRegBitWidth(AddrSpace: AS);
1516}
1517
1518bool TargetTransformInfo::isLegalToVectorizeLoad(LoadInst *LI) const {
1519 return TTIImpl->isLegalToVectorizeLoad(LI);
1520}
1521
1522bool TargetTransformInfo::isLegalToVectorizeStore(StoreInst *SI) const {
1523 return TTIImpl->isLegalToVectorizeStore(SI);
1524}
1525
1526bool TargetTransformInfo::isLegalToVectorizeLoadChain(
1527 unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const {
1528 return TTIImpl->isLegalToVectorizeLoadChain(ChainSizeInBytes, Alignment,
1529 AddrSpace);
1530}
1531
1532bool TargetTransformInfo::isLegalToVectorizeStoreChain(
1533 unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const {
1534 return TTIImpl->isLegalToVectorizeStoreChain(ChainSizeInBytes, Alignment,
1535 AddrSpace);
1536}
1537
1538bool TargetTransformInfo::isLegalToVectorizeReduction(
1539 const RecurrenceDescriptor &RdxDesc, ElementCount VF) const {
1540 return TTIImpl->isLegalToVectorizeReduction(RdxDesc, VF);
1541}
1542
1543bool TargetTransformInfo::isElementTypeLegalForScalableVector(Type *Ty) const {
1544 return TTIImpl->isElementTypeLegalForScalableVector(Ty);
1545}
1546
1547unsigned TargetTransformInfo::getLoadVectorFactor(unsigned VF,
1548 unsigned LoadSize,
1549 unsigned ChainSizeInBytes,
1550 VectorType *VecTy) const {
1551 return TTIImpl->getLoadVectorFactor(VF, LoadSize, ChainSizeInBytes, VecTy);
1552}
1553
1554unsigned TargetTransformInfo::getStoreVectorFactor(unsigned VF,
1555 unsigned StoreSize,
1556 unsigned ChainSizeInBytes,
1557 VectorType *VecTy) const {
1558 return TTIImpl->getStoreVectorFactor(VF, StoreSize, ChainSizeInBytes, VecTy);
1559}
1560
1561bool TargetTransformInfo::preferFixedOverScalableIfEqualCost() const {
1562 return TTIImpl->preferFixedOverScalableIfEqualCost();
1563}
1564
1565bool TargetTransformInfo::preferInLoopReduction(RecurKind Kind,
1566 Type *Ty) const {
1567 return TTIImpl->preferInLoopReduction(Kind, Ty);
1568}
1569
1570bool TargetTransformInfo::preferAlternateOpcodeVectorization() const {
1571 return TTIImpl->preferAlternateOpcodeVectorization();
1572}
1573
1574bool TargetTransformInfo::preferSLPInstCountCheck() const {
1575 return TTIImpl->preferSLPInstCountCheck();
1576}
1577
1578bool TargetTransformInfo::preferPredicatedReductionSelect() const {
1579 return TTIImpl->preferPredicatedReductionSelect();
1580}
1581
1582bool TargetTransformInfo::preferEpilogueVectorization(
1583 ElementCount Iters) const {
1584 return TTIImpl->preferEpilogueVectorization(Iters);
1585}
1586
1587bool TargetTransformInfo::shouldConsiderVectorizationRegPressure() const {
1588 return TTIImpl->shouldConsiderVectorizationRegPressure();
1589}
1590
1591TargetTransformInfo::VPLegalization
1592TargetTransformInfo::getVPLegalizationStrategy(const VPIntrinsic &VPI) const {
1593 return TTIImpl->getVPLegalizationStrategy(PI: VPI);
1594}
1595
1596bool TargetTransformInfo::hasArmWideBranch(bool Thumb) const {
1597 return TTIImpl->hasArmWideBranch(Thumb);
1598}
1599
1600APInt TargetTransformInfo::getFeatureMask(const Function &F) const {
1601 return TTIImpl->getFeatureMask(F);
1602}
1603
1604APInt TargetTransformInfo::getPriorityMask(const Function &F) const {
1605 return TTIImpl->getPriorityMask(F);
1606}
1607
1608bool TargetTransformInfo::isMultiversionedFunction(const Function &F) const {
1609 return TTIImpl->isMultiversionedFunction(F);
1610}
1611
1612unsigned TargetTransformInfo::getMaxNumArgs() const {
1613 return TTIImpl->getMaxNumArgs();
1614}
1615
1616bool TargetTransformInfo::shouldExpandReduction(const IntrinsicInst *II) const {
1617 return TTIImpl->shouldExpandReduction(II);
1618}
1619
1620TargetTransformInfo::ReductionShuffle
1621TargetTransformInfo::getPreferredExpandedReductionShuffle(
1622 const IntrinsicInst *II) const {
1623 return TTIImpl->getPreferredExpandedReductionShuffle(II);
1624}
1625
1626unsigned TargetTransformInfo::getGISelRematGlobalCost() const {
1627 return TTIImpl->getGISelRematGlobalCost();
1628}
1629
1630unsigned TargetTransformInfo::getMinTripCountTailFoldingThreshold() const {
1631 return TTIImpl->getMinTripCountTailFoldingThreshold();
1632}
1633
1634bool TargetTransformInfo::supportsScalableVectors() const {
1635 return TTIImpl->supportsScalableVectors();
1636}
1637
1638bool TargetTransformInfo::enableScalableVectorization() const {
1639 return TTIImpl->enableScalableVectorization();
1640}
1641
1642bool TargetTransformInfo::hasActiveVectorLength() const {
1643 return TTIImpl->hasActiveVectorLength();
1644}
1645
1646bool TargetTransformInfo::isProfitableToSinkOperands(
1647 Instruction *I, SmallVectorImpl<Use *> &OpsToSink,
1648 const LoopInfo *LI) const {
1649 return TTIImpl->isProfitableToSinkOperands(I, Ops&: OpsToSink, LI);
1650}
1651
1652bool TargetTransformInfo::isVectorShiftByScalarCheap(Type *Ty) const {
1653 return TTIImpl->isVectorShiftByScalarCheap(Ty);
1654}
1655
1656void TargetTransformInfo::collectKernelLaunchBounds(
1657 const Function &F,
1658 SmallVectorImpl<std::pair<StringRef, int64_t>> &LB) const {
1659 return TTIImpl->collectKernelLaunchBounds(F, LB);
1660}
1661
1662bool TargetTransformInfo::allowVectorElementIndexingUsingGEP() const {
1663 return TTIImpl->allowVectorElementIndexingUsingGEP();
1664}
1665
1666bool TargetTransformInfo::isUniform(const Instruction *I,
1667 const SmallBitVector &UniformArgs) const {
1668 return TTIImpl->isUniform(I, UniformArgs);
1669}
1670
1671TargetTransformInfoImplBase::~TargetTransformInfoImplBase() = default;
1672
1673TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {}
1674
1675TargetIRAnalysis::TargetIRAnalysis(
1676 std::function<Result(const Function &)> TTICallback)
1677 : TTICallback(std::move(TTICallback)) {}
1678
1679TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F,
1680 FunctionAnalysisManager &) {
1681 assert(!F.isIntrinsic() && "Should not request TTI for intrinsics");
1682 return TTICallback(F);
1683}
1684
1685AnalysisKey TargetIRAnalysis::Key;
1686
1687TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
1688 return Result(F.getDataLayout());
1689}
1690
1691// Register the basic pass.
1692INITIALIZE_PASS(TargetTransformInfoWrapperPass, "tti",
1693 "Target Transform Information", false, true)
1694char TargetTransformInfoWrapperPass::ID = 0;
1695
1696void TargetTransformInfoWrapperPass::anchor() {}
1697
1698TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass()
1699 : ImmutablePass(ID) {}
1700
1701TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass(
1702 TargetIRAnalysis TIRA)
1703 : ImmutablePass(ID), TIRA(std::move(TIRA)) {}
1704
1705TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) {
1706 FunctionAnalysisManager DummyFAM;
1707 TTI = TIRA.run(F, DummyFAM);
1708 return *TTI;
1709}
1710
1711ImmutablePass *
1712llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) {
1713 return new TargetTransformInfoWrapperPass(std::move(TIRA));
1714}
1715