1 //===- llvm/Analysis/TargetTransformInfo.cpp ------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/Analysis/TargetTransformInfo.h"
11 #include "llvm/IR/CallSite.h"
12 #include "llvm/IR/DataLayout.h"
13 #include "llvm/IR/Instruction.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/IntrinsicInst.h"
16 #include "llvm/IR/Operator.h"
17 #include "llvm/Support/ErrorHandling.h"
18
19 using namespace llvm;
20
21 #define DEBUG_TYPE "tti"
22
23 // Setup the analysis group to manage the TargetTransformInfo passes.
24 INITIALIZE_ANALYSIS_GROUP(TargetTransformInfo, "Target Information", NoTTI)
25 char TargetTransformInfo::ID = 0;
26
~TargetTransformInfo()27 TargetTransformInfo::~TargetTransformInfo() {
28 }
29
pushTTIStack(Pass * P)30 void TargetTransformInfo::pushTTIStack(Pass *P) {
31 TopTTI = this;
32 PrevTTI = &P->getAnalysis<TargetTransformInfo>();
33
34 // Walk up the chain and update the top TTI pointer.
35 for (TargetTransformInfo *PTTI = PrevTTI; PTTI; PTTI = PTTI->PrevTTI)
36 PTTI->TopTTI = this;
37 }
38
getAnalysisUsage(AnalysisUsage & AU) const39 void TargetTransformInfo::getAnalysisUsage(AnalysisUsage &AU) const {
40 AU.addRequired<TargetTransformInfo>();
41 }
42
getOperationCost(unsigned Opcode,Type * Ty,Type * OpTy) const43 unsigned TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty,
44 Type *OpTy) const {
45 return PrevTTI->getOperationCost(Opcode, Ty, OpTy);
46 }
47
getGEPCost(const Value * Ptr,ArrayRef<const Value * > Operands) const48 unsigned TargetTransformInfo::getGEPCost(
49 const Value *Ptr, ArrayRef<const Value *> Operands) const {
50 return PrevTTI->getGEPCost(Ptr, Operands);
51 }
52
getCallCost(FunctionType * FTy,int NumArgs) const53 unsigned TargetTransformInfo::getCallCost(FunctionType *FTy,
54 int NumArgs) const {
55 return PrevTTI->getCallCost(FTy, NumArgs);
56 }
57
getCallCost(const Function * F,int NumArgs) const58 unsigned TargetTransformInfo::getCallCost(const Function *F,
59 int NumArgs) const {
60 return PrevTTI->getCallCost(F, NumArgs);
61 }
62
getCallCost(const Function * F,ArrayRef<const Value * > Arguments) const63 unsigned TargetTransformInfo::getCallCost(
64 const Function *F, ArrayRef<const Value *> Arguments) const {
65 return PrevTTI->getCallCost(F, Arguments);
66 }
67
getIntrinsicCost(Intrinsic::ID IID,Type * RetTy,ArrayRef<Type * > ParamTys) const68 unsigned TargetTransformInfo::getIntrinsicCost(
69 Intrinsic::ID IID, Type *RetTy, ArrayRef<Type *> ParamTys) const {
70 return PrevTTI->getIntrinsicCost(IID, RetTy, ParamTys);
71 }
72
getIntrinsicCost(Intrinsic::ID IID,Type * RetTy,ArrayRef<const Value * > Arguments) const73 unsigned TargetTransformInfo::getIntrinsicCost(
74 Intrinsic::ID IID, Type *RetTy, ArrayRef<const Value *> Arguments) const {
75 return PrevTTI->getIntrinsicCost(IID, RetTy, Arguments);
76 }
77
getUserCost(const User * U) const78 unsigned TargetTransformInfo::getUserCost(const User *U) const {
79 return PrevTTI->getUserCost(U);
80 }
81
hasBranchDivergence() const82 bool TargetTransformInfo::hasBranchDivergence() const {
83 return PrevTTI->hasBranchDivergence();
84 }
85
isLoweredToCall(const Function * F) const86 bool TargetTransformInfo::isLoweredToCall(const Function *F) const {
87 return PrevTTI->isLoweredToCall(F);
88 }
89
90 void
getUnrollingPreferences(const Function * F,Loop * L,UnrollingPreferences & UP) const91 TargetTransformInfo::getUnrollingPreferences(const Function *F, Loop *L,
92 UnrollingPreferences &UP) const {
93 PrevTTI->getUnrollingPreferences(F, L, UP);
94 }
95
isLegalAddImmediate(int64_t Imm) const96 bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const {
97 return PrevTTI->isLegalAddImmediate(Imm);
98 }
99
isLegalICmpImmediate(int64_t Imm) const100 bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const {
101 return PrevTTI->isLegalICmpImmediate(Imm);
102 }
103
isLegalMaskedLoad(Type * DataType,int Consecutive) const104 bool TargetTransformInfo::isLegalMaskedLoad(Type *DataType,
105 int Consecutive) const {
106 return false;
107 }
108
isLegalMaskedStore(Type * DataType,int Consecutive) const109 bool TargetTransformInfo::isLegalMaskedStore(Type *DataType,
110 int Consecutive) const {
111 return false;
112 }
113
114
isLegalAddressingMode(Type * Ty,GlobalValue * BaseGV,int64_t BaseOffset,bool HasBaseReg,int64_t Scale) const115 bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
116 int64_t BaseOffset,
117 bool HasBaseReg,
118 int64_t Scale) const {
119 return PrevTTI->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg,
120 Scale);
121 }
122
getScalingFactorCost(Type * Ty,GlobalValue * BaseGV,int64_t BaseOffset,bool HasBaseReg,int64_t Scale) const123 int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV,
124 int64_t BaseOffset,
125 bool HasBaseReg,
126 int64_t Scale) const {
127 return PrevTTI->getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg,
128 Scale);
129 }
130
isTruncateFree(Type * Ty1,Type * Ty2) const131 bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const {
132 return PrevTTI->isTruncateFree(Ty1, Ty2);
133 }
134
isTypeLegal(Type * Ty) const135 bool TargetTransformInfo::isTypeLegal(Type *Ty) const {
136 return PrevTTI->isTypeLegal(Ty);
137 }
138
getJumpBufAlignment() const139 unsigned TargetTransformInfo::getJumpBufAlignment() const {
140 return PrevTTI->getJumpBufAlignment();
141 }
142
getJumpBufSize() const143 unsigned TargetTransformInfo::getJumpBufSize() const {
144 return PrevTTI->getJumpBufSize();
145 }
146
shouldBuildLookupTables() const147 bool TargetTransformInfo::shouldBuildLookupTables() const {
148 return PrevTTI->shouldBuildLookupTables();
149 }
150
151 TargetTransformInfo::PopcntSupportKind
getPopcntSupport(unsigned IntTyWidthInBit) const152 TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const {
153 return PrevTTI->getPopcntSupport(IntTyWidthInBit);
154 }
155
haveFastSqrt(Type * Ty) const156 bool TargetTransformInfo::haveFastSqrt(Type *Ty) const {
157 return PrevTTI->haveFastSqrt(Ty);
158 }
159
getIntImmCost(const APInt & Imm,Type * Ty) const160 unsigned TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const {
161 return PrevTTI->getIntImmCost(Imm, Ty);
162 }
163
getIntImmCost(unsigned Opc,unsigned Idx,const APInt & Imm,Type * Ty) const164 unsigned TargetTransformInfo::getIntImmCost(unsigned Opc, unsigned Idx,
165 const APInt &Imm, Type *Ty) const {
166 return PrevTTI->getIntImmCost(Opc, Idx, Imm, Ty);
167 }
168
getIntImmCost(Intrinsic::ID IID,unsigned Idx,const APInt & Imm,Type * Ty) const169 unsigned TargetTransformInfo::getIntImmCost(Intrinsic::ID IID, unsigned Idx,
170 const APInt &Imm, Type *Ty) const {
171 return PrevTTI->getIntImmCost(IID, Idx, Imm, Ty);
172 }
173
getNumberOfRegisters(bool Vector) const174 unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const {
175 return PrevTTI->getNumberOfRegisters(Vector);
176 }
177
getRegisterBitWidth(bool Vector) const178 unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const {
179 return PrevTTI->getRegisterBitWidth(Vector);
180 }
181
getMaxInterleaveFactor() const182 unsigned TargetTransformInfo::getMaxInterleaveFactor() const {
183 return PrevTTI->getMaxInterleaveFactor();
184 }
185
getArithmeticInstrCost(unsigned Opcode,Type * Ty,OperandValueKind Op1Info,OperandValueKind Op2Info,OperandValueProperties Opd1PropInfo,OperandValueProperties Opd2PropInfo) const186 unsigned TargetTransformInfo::getArithmeticInstrCost(
187 unsigned Opcode, Type *Ty, OperandValueKind Op1Info,
188 OperandValueKind Op2Info, OperandValueProperties Opd1PropInfo,
189 OperandValueProperties Opd2PropInfo) const {
190 return PrevTTI->getArithmeticInstrCost(Opcode, Ty, Op1Info, Op2Info,
191 Opd1PropInfo, Opd2PropInfo);
192 }
193
getShuffleCost(ShuffleKind Kind,Type * Tp,int Index,Type * SubTp) const194 unsigned TargetTransformInfo::getShuffleCost(ShuffleKind Kind, Type *Tp,
195 int Index, Type *SubTp) const {
196 return PrevTTI->getShuffleCost(Kind, Tp, Index, SubTp);
197 }
198
getCastInstrCost(unsigned Opcode,Type * Dst,Type * Src) const199 unsigned TargetTransformInfo::getCastInstrCost(unsigned Opcode, Type *Dst,
200 Type *Src) const {
201 return PrevTTI->getCastInstrCost(Opcode, Dst, Src);
202 }
203
getCFInstrCost(unsigned Opcode) const204 unsigned TargetTransformInfo::getCFInstrCost(unsigned Opcode) const {
205 return PrevTTI->getCFInstrCost(Opcode);
206 }
207
getCmpSelInstrCost(unsigned Opcode,Type * ValTy,Type * CondTy) const208 unsigned TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
209 Type *CondTy) const {
210 return PrevTTI->getCmpSelInstrCost(Opcode, ValTy, CondTy);
211 }
212
getVectorInstrCost(unsigned Opcode,Type * Val,unsigned Index) const213 unsigned TargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val,
214 unsigned Index) const {
215 return PrevTTI->getVectorInstrCost(Opcode, Val, Index);
216 }
217
getMemoryOpCost(unsigned Opcode,Type * Src,unsigned Alignment,unsigned AddressSpace) const218 unsigned TargetTransformInfo::getMemoryOpCost(unsigned Opcode, Type *Src,
219 unsigned Alignment,
220 unsigned AddressSpace) const {
221 return PrevTTI->getMemoryOpCost(Opcode, Src, Alignment, AddressSpace);
222 }
223
224 unsigned
getIntrinsicInstrCost(Intrinsic::ID ID,Type * RetTy,ArrayRef<Type * > Tys) const225 TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID,
226 Type *RetTy,
227 ArrayRef<Type *> Tys) const {
228 return PrevTTI->getIntrinsicInstrCost(ID, RetTy, Tys);
229 }
230
getNumberOfParts(Type * Tp) const231 unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const {
232 return PrevTTI->getNumberOfParts(Tp);
233 }
234
getAddressComputationCost(Type * Tp,bool IsComplex) const235 unsigned TargetTransformInfo::getAddressComputationCost(Type *Tp,
236 bool IsComplex) const {
237 return PrevTTI->getAddressComputationCost(Tp, IsComplex);
238 }
239
getReductionCost(unsigned Opcode,Type * Ty,bool IsPairwise) const240 unsigned TargetTransformInfo::getReductionCost(unsigned Opcode, Type *Ty,
241 bool IsPairwise) const {
242 return PrevTTI->getReductionCost(Opcode, Ty, IsPairwise);
243 }
244
getCostOfKeepingLiveOverCall(ArrayRef<Type * > Tys) const245 unsigned TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type*> Tys)
246 const {
247 return PrevTTI->getCostOfKeepingLiveOverCall(Tys);
248 }
249
250 namespace {
251
252 struct NoTTI final : ImmutablePass, TargetTransformInfo {
253 const DataLayout *DL;
254
NoTTI__anondf0fc33d0111::NoTTI255 NoTTI() : ImmutablePass(ID), DL(nullptr) {
256 initializeNoTTIPass(*PassRegistry::getPassRegistry());
257 }
258
initializePass__anondf0fc33d0111::NoTTI259 void initializePass() override {
260 // Note that this subclass is special, and must *not* call initializeTTI as
261 // it does not chain.
262 TopTTI = this;
263 PrevTTI = nullptr;
264 DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
265 DL = DLP ? &DLP->getDataLayout() : nullptr;
266 }
267
getAnalysisUsage__anondf0fc33d0111::NoTTI268 void getAnalysisUsage(AnalysisUsage &AU) const override {
269 // Note that this subclass is special, and must *not* call
270 // TTI::getAnalysisUsage as it breaks the recursion.
271 }
272
273 /// Pass identification.
274 static char ID;
275
276 /// Provide necessary pointer adjustments for the two base classes.
getAdjustedAnalysisPointer__anondf0fc33d0111::NoTTI277 void *getAdjustedAnalysisPointer(const void *ID) override {
278 if (ID == &TargetTransformInfo::ID)
279 return (TargetTransformInfo*)this;
280 return this;
281 }
282
getOperationCost__anondf0fc33d0111::NoTTI283 unsigned getOperationCost(unsigned Opcode, Type *Ty,
284 Type *OpTy) const override {
285 switch (Opcode) {
286 default:
287 // By default, just classify everything as 'basic'.
288 return TCC_Basic;
289
290 case Instruction::GetElementPtr:
291 llvm_unreachable("Use getGEPCost for GEP operations!");
292
293 case Instruction::BitCast:
294 assert(OpTy && "Cast instructions must provide the operand type");
295 if (Ty == OpTy || (Ty->isPointerTy() && OpTy->isPointerTy()))
296 // Identity and pointer-to-pointer casts are free.
297 return TCC_Free;
298
299 // Otherwise, the default basic cost is used.
300 return TCC_Basic;
301
302 case Instruction::IntToPtr: {
303 if (!DL)
304 return TCC_Basic;
305
306 // An inttoptr cast is free so long as the input is a legal integer type
307 // which doesn't contain values outside the range of a pointer.
308 unsigned OpSize = OpTy->getScalarSizeInBits();
309 if (DL->isLegalInteger(OpSize) &&
310 OpSize <= DL->getPointerTypeSizeInBits(Ty))
311 return TCC_Free;
312
313 // Otherwise it's not a no-op.
314 return TCC_Basic;
315 }
316 case Instruction::PtrToInt: {
317 if (!DL)
318 return TCC_Basic;
319
320 // A ptrtoint cast is free so long as the result is large enough to store
321 // the pointer, and a legal integer type.
322 unsigned DestSize = Ty->getScalarSizeInBits();
323 if (DL->isLegalInteger(DestSize) &&
324 DestSize >= DL->getPointerTypeSizeInBits(OpTy))
325 return TCC_Free;
326
327 // Otherwise it's not a no-op.
328 return TCC_Basic;
329 }
330 case Instruction::Trunc:
331 // trunc to a native type is free (assuming the target has compare and
332 // shift-right of the same width).
333 if (DL && DL->isLegalInteger(DL->getTypeSizeInBits(Ty)))
334 return TCC_Free;
335
336 return TCC_Basic;
337 }
338 }
339
getGEPCost__anondf0fc33d0111::NoTTI340 unsigned getGEPCost(const Value *Ptr,
341 ArrayRef<const Value *> Operands) const override {
342 // In the basic model, we just assume that all-constant GEPs will be folded
343 // into their uses via addressing modes.
344 for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx)
345 if (!isa<Constant>(Operands[Idx]))
346 return TCC_Basic;
347
348 return TCC_Free;
349 }
350
getCallCost__anondf0fc33d0111::NoTTI351 unsigned getCallCost(FunctionType *FTy, int NumArgs = -1) const override
352 {
353 assert(FTy && "FunctionType must be provided to this routine.");
354
355 // The target-independent implementation just measures the size of the
356 // function by approximating that each argument will take on average one
357 // instruction to prepare.
358
359 if (NumArgs < 0)
360 // Set the argument number to the number of explicit arguments in the
361 // function.
362 NumArgs = FTy->getNumParams();
363
364 return TCC_Basic * (NumArgs + 1);
365 }
366
getCallCost__anondf0fc33d0111::NoTTI367 unsigned getCallCost(const Function *F, int NumArgs = -1) const override
368 {
369 assert(F && "A concrete function must be provided to this routine.");
370
371 if (NumArgs < 0)
372 // Set the argument number to the number of explicit arguments in the
373 // function.
374 NumArgs = F->arg_size();
375
376 if (Intrinsic::ID IID = (Intrinsic::ID)F->getIntrinsicID()) {
377 FunctionType *FTy = F->getFunctionType();
378 SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end());
379 return TopTTI->getIntrinsicCost(IID, FTy->getReturnType(), ParamTys);
380 }
381
382 if (!TopTTI->isLoweredToCall(F))
383 return TCC_Basic; // Give a basic cost if it will be lowered directly.
384
385 return TopTTI->getCallCost(F->getFunctionType(), NumArgs);
386 }
387
getCallCost__anondf0fc33d0111::NoTTI388 unsigned getCallCost(const Function *F,
389 ArrayRef<const Value *> Arguments) const override {
390 // Simply delegate to generic handling of the call.
391 // FIXME: We should use instsimplify or something else to catch calls which
392 // will constant fold with these arguments.
393 return TopTTI->getCallCost(F, Arguments.size());
394 }
395
getIntrinsicCost__anondf0fc33d0111::NoTTI396 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
397 ArrayRef<Type *> ParamTys) const override {
398 switch (IID) {
399 default:
400 // Intrinsics rarely (if ever) have normal argument setup constraints.
401 // Model them as having a basic instruction cost.
402 // FIXME: This is wrong for libc intrinsics.
403 return TCC_Basic;
404
405 case Intrinsic::annotation:
406 case Intrinsic::assume:
407 case Intrinsic::dbg_declare:
408 case Intrinsic::dbg_value:
409 case Intrinsic::invariant_start:
410 case Intrinsic::invariant_end:
411 case Intrinsic::lifetime_start:
412 case Intrinsic::lifetime_end:
413 case Intrinsic::objectsize:
414 case Intrinsic::ptr_annotation:
415 case Intrinsic::var_annotation:
416 case Intrinsic::experimental_gc_result_int:
417 case Intrinsic::experimental_gc_result_float:
418 case Intrinsic::experimental_gc_result_ptr:
419 case Intrinsic::experimental_gc_relocate:
420 // These intrinsics don't actually represent code after lowering.
421 return TCC_Free;
422 }
423 }
424
425 unsigned
getIntrinsicCost__anondf0fc33d0111::NoTTI426 getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
427 ArrayRef<const Value *> Arguments) const override {
428 // Delegate to the generic intrinsic handling code. This mostly provides an
429 // opportunity for targets to (for example) special case the cost of
430 // certain intrinsics based on constants used as arguments.
431 SmallVector<Type *, 8> ParamTys;
432 ParamTys.reserve(Arguments.size());
433 for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx)
434 ParamTys.push_back(Arguments[Idx]->getType());
435 return TopTTI->getIntrinsicCost(IID, RetTy, ParamTys);
436 }
437
getUserCost__anondf0fc33d0111::NoTTI438 unsigned getUserCost(const User *U) const override {
439 if (isa<PHINode>(U))
440 return TCC_Free; // Model all PHI nodes as free.
441
442 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
443 SmallVector<const Value *, 4> Indices(GEP->idx_begin(), GEP->idx_end());
444 return TopTTI->getGEPCost(GEP->getPointerOperand(), Indices);
445 }
446
447 if (ImmutableCallSite CS = U) {
448 const Function *F = CS.getCalledFunction();
449 if (!F) {
450 // Just use the called value type.
451 Type *FTy = CS.getCalledValue()->getType()->getPointerElementType();
452 return TopTTI->getCallCost(cast<FunctionType>(FTy), CS.arg_size());
453 }
454
455 SmallVector<const Value *, 8> Arguments(CS.arg_begin(), CS.arg_end());
456 return TopTTI->getCallCost(F, Arguments);
457 }
458
459 if (const CastInst *CI = dyn_cast<CastInst>(U)) {
460 // Result of a cmp instruction is often extended (to be used by other
461 // cmp instructions, logical or return instructions). These are usually
462 // nop on most sane targets.
463 if (isa<CmpInst>(CI->getOperand(0)))
464 return TCC_Free;
465 }
466
467 // Otherwise delegate to the fully generic implementations.
468 return getOperationCost(Operator::getOpcode(U), U->getType(),
469 U->getNumOperands() == 1 ?
470 U->getOperand(0)->getType() : nullptr);
471 }
472
hasBranchDivergence__anondf0fc33d0111::NoTTI473 bool hasBranchDivergence() const override { return false; }
474
isLoweredToCall__anondf0fc33d0111::NoTTI475 bool isLoweredToCall(const Function *F) const override {
476 // FIXME: These should almost certainly not be handled here, and instead
477 // handled with the help of TLI or the target itself. This was largely
478 // ported from existing analysis heuristics here so that such refactorings
479 // can take place in the future.
480
481 if (F->isIntrinsic())
482 return false;
483
484 if (F->hasLocalLinkage() || !F->hasName())
485 return true;
486
487 StringRef Name = F->getName();
488
489 // These will all likely lower to a single selection DAG node.
490 if (Name == "copysign" || Name == "copysignf" || Name == "copysignl" ||
491 Name == "fabs" || Name == "fabsf" || Name == "fabsl" || Name == "sin" ||
492 Name == "fmin" || Name == "fminf" || Name == "fminl" ||
493 Name == "fmax" || Name == "fmaxf" || Name == "fmaxl" ||
494 Name == "sinf" || Name == "sinl" || Name == "cos" || Name == "cosf" ||
495 Name == "cosl" || Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl")
496 return false;
497
498 // These are all likely to be optimized into something smaller.
499 if (Name == "pow" || Name == "powf" || Name == "powl" || Name == "exp2" ||
500 Name == "exp2l" || Name == "exp2f" || Name == "floor" || Name ==
501 "floorf" || Name == "ceil" || Name == "round" || Name == "ffs" ||
502 Name == "ffsl" || Name == "abs" || Name == "labs" || Name == "llabs")
503 return false;
504
505 return true;
506 }
507
getUnrollingPreferences__anondf0fc33d0111::NoTTI508 void getUnrollingPreferences(const Function *, Loop *,
509 UnrollingPreferences &) const override {}
510
isLegalAddImmediate__anondf0fc33d0111::NoTTI511 bool isLegalAddImmediate(int64_t Imm) const override {
512 return false;
513 }
514
isLegalICmpImmediate__anondf0fc33d0111::NoTTI515 bool isLegalICmpImmediate(int64_t Imm) const override {
516 return false;
517 }
518
isLegalAddressingMode__anondf0fc33d0111::NoTTI519 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
520 bool HasBaseReg, int64_t Scale) const override
521 {
522 // Guess that reg+reg addressing is allowed. This heuristic is taken from
523 // the implementation of LSR.
524 return !BaseGV && BaseOffset == 0 && Scale <= 1;
525 }
526
getScalingFactorCost__anondf0fc33d0111::NoTTI527 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
528 bool HasBaseReg, int64_t Scale) const override {
529 // Guess that all legal addressing mode are free.
530 if(isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, Scale))
531 return 0;
532 return -1;
533 }
534
isTruncateFree__anondf0fc33d0111::NoTTI535 bool isTruncateFree(Type *Ty1, Type *Ty2) const override {
536 return false;
537 }
538
isTypeLegal__anondf0fc33d0111::NoTTI539 bool isTypeLegal(Type *Ty) const override {
540 return false;
541 }
542
getJumpBufAlignment__anondf0fc33d0111::NoTTI543 unsigned getJumpBufAlignment() const override {
544 return 0;
545 }
546
getJumpBufSize__anondf0fc33d0111::NoTTI547 unsigned getJumpBufSize() const override {
548 return 0;
549 }
550
shouldBuildLookupTables__anondf0fc33d0111::NoTTI551 bool shouldBuildLookupTables() const override {
552 return true;
553 }
554
555 PopcntSupportKind
getPopcntSupport__anondf0fc33d0111::NoTTI556 getPopcntSupport(unsigned IntTyWidthInBit) const override {
557 return PSK_Software;
558 }
559
haveFastSqrt__anondf0fc33d0111::NoTTI560 bool haveFastSqrt(Type *Ty) const override {
561 return false;
562 }
563
getIntImmCost__anondf0fc33d0111::NoTTI564 unsigned getIntImmCost(const APInt &Imm, Type *Ty) const override {
565 return TCC_Basic;
566 }
567
getIntImmCost__anondf0fc33d0111::NoTTI568 unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
569 Type *Ty) const override {
570 return TCC_Free;
571 }
572
getIntImmCost__anondf0fc33d0111::NoTTI573 unsigned getIntImmCost(Intrinsic::ID IID, unsigned Idx, const APInt &Imm,
574 Type *Ty) const override {
575 return TCC_Free;
576 }
577
getNumberOfRegisters__anondf0fc33d0111::NoTTI578 unsigned getNumberOfRegisters(bool Vector) const override {
579 return 8;
580 }
581
getRegisterBitWidth__anondf0fc33d0111::NoTTI582 unsigned getRegisterBitWidth(bool Vector) const override {
583 return 32;
584 }
585
getMaxInterleaveFactor__anondf0fc33d0111::NoTTI586 unsigned getMaxInterleaveFactor() const override {
587 return 1;
588 }
589
getArithmeticInstrCost__anondf0fc33d0111::NoTTI590 unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind,
591 OperandValueKind, OperandValueProperties,
592 OperandValueProperties) const override {
593 return 1;
594 }
595
getShuffleCost__anondf0fc33d0111::NoTTI596 unsigned getShuffleCost(ShuffleKind Kind, Type *Ty,
597 int Index = 0, Type *SubTp = nullptr) const override {
598 return 1;
599 }
600
getCastInstrCost__anondf0fc33d0111::NoTTI601 unsigned getCastInstrCost(unsigned Opcode, Type *Dst,
602 Type *Src) const override {
603 return 1;
604 }
605
getCFInstrCost__anondf0fc33d0111::NoTTI606 unsigned getCFInstrCost(unsigned Opcode) const override {
607 return 1;
608 }
609
getCmpSelInstrCost__anondf0fc33d0111::NoTTI610 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
611 Type *CondTy = nullptr) const override {
612 return 1;
613 }
614
getVectorInstrCost__anondf0fc33d0111::NoTTI615 unsigned getVectorInstrCost(unsigned Opcode, Type *Val,
616 unsigned Index = -1) const override {
617 return 1;
618 }
619
getMemoryOpCost__anondf0fc33d0111::NoTTI620 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
621 unsigned AddressSpace) const override {
622 return 1;
623 }
624
getIntrinsicInstrCost__anondf0fc33d0111::NoTTI625 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
626 ArrayRef<Type*> Tys) const override {
627 return 1;
628 }
629
getNumberOfParts__anondf0fc33d0111::NoTTI630 unsigned getNumberOfParts(Type *Tp) const override {
631 return 0;
632 }
633
getAddressComputationCost__anondf0fc33d0111::NoTTI634 unsigned getAddressComputationCost(Type *Tp, bool) const override {
635 return 0;
636 }
637
getReductionCost__anondf0fc33d0111::NoTTI638 unsigned getReductionCost(unsigned, Type *, bool) const override {
639 return 1;
640 }
641
getCostOfKeepingLiveOverCall__anondf0fc33d0111::NoTTI642 unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type*> Tys) const override {
643 return 0;
644 }
645
646 };
647
648 } // end anonymous namespace
649
650 INITIALIZE_AG_PASS(NoTTI, TargetTransformInfo, "notti",
651 "No target information", true, true, true)
652 char NoTTI::ID = 0;
653
createNoTargetTransformInfoPass()654 ImmutablePass *llvm::createNoTargetTransformInfoPass() {
655 return new NoTTI();
656 }
657