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