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#define DEBUG_TYPE "tti" 11#include "llvm/Analysis/TargetTransformInfo.h" 12#include "llvm/IR/DataLayout.h" 13#include "llvm/IR/Operator.h" 14#include "llvm/IR/Instruction.h" 15#include "llvm/IR/IntrinsicInst.h" 16#include "llvm/IR/Instructions.h" 17#include "llvm/Support/CallSite.h" 18#include "llvm/Support/ErrorHandling.h" 19 20using namespace llvm; 21 22// Setup the analysis group to manage the TargetTransformInfo passes. 23INITIALIZE_ANALYSIS_GROUP(TargetTransformInfo, "Target Information", NoTTI) 24char TargetTransformInfo::ID = 0; 25 26TargetTransformInfo::~TargetTransformInfo() { 27} 28 29void TargetTransformInfo::pushTTIStack(Pass *P) { 30 TopTTI = this; 31 PrevTTI = &P->getAnalysis<TargetTransformInfo>(); 32 33 // Walk up the chain and update the top TTI pointer. 34 for (TargetTransformInfo *PTTI = PrevTTI; PTTI; PTTI = PTTI->PrevTTI) 35 PTTI->TopTTI = this; 36} 37 38void TargetTransformInfo::popTTIStack() { 39 TopTTI = 0; 40 41 // Walk up the chain and update the top TTI pointer. 42 for (TargetTransformInfo *PTTI = PrevTTI; PTTI; PTTI = PTTI->PrevTTI) 43 PTTI->TopTTI = PrevTTI; 44 45 PrevTTI = 0; 46} 47 48void TargetTransformInfo::getAnalysisUsage(AnalysisUsage &AU) const { 49 AU.addRequired<TargetTransformInfo>(); 50} 51 52unsigned TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty, 53 Type *OpTy) const { 54 return PrevTTI->getOperationCost(Opcode, Ty, OpTy); 55} 56 57unsigned TargetTransformInfo::getGEPCost( 58 const Value *Ptr, ArrayRef<const Value *> Operands) const { 59 return PrevTTI->getGEPCost(Ptr, Operands); 60} 61 62unsigned TargetTransformInfo::getCallCost(FunctionType *FTy, 63 int NumArgs) const { 64 return PrevTTI->getCallCost(FTy, NumArgs); 65} 66 67unsigned TargetTransformInfo::getCallCost(const Function *F, 68 int NumArgs) const { 69 return PrevTTI->getCallCost(F, NumArgs); 70} 71 72unsigned TargetTransformInfo::getCallCost( 73 const Function *F, ArrayRef<const Value *> Arguments) const { 74 return PrevTTI->getCallCost(F, Arguments); 75} 76 77unsigned TargetTransformInfo::getIntrinsicCost( 78 Intrinsic::ID IID, Type *RetTy, ArrayRef<Type *> ParamTys) const { 79 return PrevTTI->getIntrinsicCost(IID, RetTy, ParamTys); 80} 81 82unsigned TargetTransformInfo::getIntrinsicCost( 83 Intrinsic::ID IID, Type *RetTy, ArrayRef<const Value *> Arguments) const { 84 return PrevTTI->getIntrinsicCost(IID, RetTy, Arguments); 85} 86 87unsigned TargetTransformInfo::getUserCost(const User *U) const { 88 return PrevTTI->getUserCost(U); 89} 90 91bool TargetTransformInfo::hasBranchDivergence() const { 92 return PrevTTI->hasBranchDivergence(); 93} 94 95bool TargetTransformInfo::isLoweredToCall(const Function *F) const { 96 return PrevTTI->isLoweredToCall(F); 97} 98 99void TargetTransformInfo::getUnrollingPreferences(Loop *L, 100 UnrollingPreferences &UP) const { 101 PrevTTI->getUnrollingPreferences(L, UP); 102} 103 104bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const { 105 return PrevTTI->isLegalAddImmediate(Imm); 106} 107 108bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const { 109 return PrevTTI->isLegalICmpImmediate(Imm); 110} 111 112bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, 113 int64_t BaseOffset, 114 bool HasBaseReg, 115 int64_t Scale) const { 116 return PrevTTI->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, 117 Scale); 118} 119 120int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, 121 int64_t BaseOffset, 122 bool HasBaseReg, 123 int64_t Scale) const { 124 return PrevTTI->getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg, 125 Scale); 126} 127 128bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const { 129 return PrevTTI->isTruncateFree(Ty1, Ty2); 130} 131 132bool TargetTransformInfo::isTypeLegal(Type *Ty) const { 133 return PrevTTI->isTypeLegal(Ty); 134} 135 136unsigned TargetTransformInfo::getJumpBufAlignment() const { 137 return PrevTTI->getJumpBufAlignment(); 138} 139 140unsigned TargetTransformInfo::getJumpBufSize() const { 141 return PrevTTI->getJumpBufSize(); 142} 143 144bool TargetTransformInfo::shouldBuildLookupTables() const { 145 return PrevTTI->shouldBuildLookupTables(); 146} 147 148TargetTransformInfo::PopcntSupportKind 149TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const { 150 return PrevTTI->getPopcntSupport(IntTyWidthInBit); 151} 152 153bool TargetTransformInfo::haveFastSqrt(Type *Ty) const { 154 return PrevTTI->haveFastSqrt(Ty); 155} 156 157unsigned TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const { 158 return PrevTTI->getIntImmCost(Imm, Ty); 159} 160 161unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const { 162 return PrevTTI->getNumberOfRegisters(Vector); 163} 164 165unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const { 166 return PrevTTI->getRegisterBitWidth(Vector); 167} 168 169unsigned TargetTransformInfo::getMaximumUnrollFactor() const { 170 return PrevTTI->getMaximumUnrollFactor(); 171} 172 173unsigned TargetTransformInfo::getArithmeticInstrCost(unsigned Opcode, 174 Type *Ty, 175 OperandValueKind Op1Info, 176 OperandValueKind Op2Info) const { 177 return PrevTTI->getArithmeticInstrCost(Opcode, Ty, Op1Info, Op2Info); 178} 179 180unsigned TargetTransformInfo::getShuffleCost(ShuffleKind Kind, Type *Tp, 181 int Index, Type *SubTp) const { 182 return PrevTTI->getShuffleCost(Kind, Tp, Index, SubTp); 183} 184 185unsigned TargetTransformInfo::getCastInstrCost(unsigned Opcode, Type *Dst, 186 Type *Src) const { 187 return PrevTTI->getCastInstrCost(Opcode, Dst, Src); 188} 189 190unsigned TargetTransformInfo::getCFInstrCost(unsigned Opcode) const { 191 return PrevTTI->getCFInstrCost(Opcode); 192} 193 194unsigned TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, 195 Type *CondTy) const { 196 return PrevTTI->getCmpSelInstrCost(Opcode, ValTy, CondTy); 197} 198 199unsigned TargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val, 200 unsigned Index) const { 201 return PrevTTI->getVectorInstrCost(Opcode, Val, Index); 202} 203 204unsigned TargetTransformInfo::getMemoryOpCost(unsigned Opcode, Type *Src, 205 unsigned Alignment, 206 unsigned AddressSpace) const { 207 return PrevTTI->getMemoryOpCost(Opcode, Src, Alignment, AddressSpace); 208 ; 209} 210 211unsigned 212TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, 213 Type *RetTy, 214 ArrayRef<Type *> Tys) const { 215 return PrevTTI->getIntrinsicInstrCost(ID, RetTy, Tys); 216} 217 218unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const { 219 return PrevTTI->getNumberOfParts(Tp); 220} 221 222unsigned TargetTransformInfo::getAddressComputationCost(Type *Tp, 223 bool IsComplex) const { 224 return PrevTTI->getAddressComputationCost(Tp, IsComplex); 225} 226 227unsigned TargetTransformInfo::getReductionCost(unsigned Opcode, Type *Ty, 228 bool IsPairwise) const { 229 return PrevTTI->getReductionCost(Opcode, Ty, IsPairwise); 230} 231 232namespace { 233 234struct NoTTI : ImmutablePass, TargetTransformInfo { 235 const DataLayout *DL; 236 237 NoTTI() : ImmutablePass(ID), DL(0) { 238 initializeNoTTIPass(*PassRegistry::getPassRegistry()); 239 } 240 241 virtual void initializePass() { 242 // Note that this subclass is special, and must *not* call initializeTTI as 243 // it does not chain. 244 TopTTI = this; 245 PrevTTI = 0; 246 DL = getAnalysisIfAvailable<DataLayout>(); 247 } 248 249 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 250 // Note that this subclass is special, and must *not* call 251 // TTI::getAnalysisUsage as it breaks the recursion. 252 } 253 254 /// Pass identification. 255 static char ID; 256 257 /// Provide necessary pointer adjustments for the two base classes. 258 virtual void *getAdjustedAnalysisPointer(const void *ID) { 259 if (ID == &TargetTransformInfo::ID) 260 return (TargetTransformInfo*)this; 261 return this; 262 } 263 264 unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) const { 265 switch (Opcode) { 266 default: 267 // By default, just classify everything as 'basic'. 268 return TCC_Basic; 269 270 case Instruction::GetElementPtr: 271 llvm_unreachable("Use getGEPCost for GEP operations!"); 272 273 case Instruction::BitCast: 274 assert(OpTy && "Cast instructions must provide the operand type"); 275 if (Ty == OpTy || (Ty->isPointerTy() && OpTy->isPointerTy())) 276 // Identity and pointer-to-pointer casts are free. 277 return TCC_Free; 278 279 // Otherwise, the default basic cost is used. 280 return TCC_Basic; 281 282 case Instruction::IntToPtr: { 283 if (!DL) 284 return TCC_Basic; 285 286 // An inttoptr cast is free so long as the input is a legal integer type 287 // which doesn't contain values outside the range of a pointer. 288 unsigned OpSize = OpTy->getScalarSizeInBits(); 289 if (DL->isLegalInteger(OpSize) && 290 OpSize <= DL->getPointerTypeSizeInBits(Ty)) 291 return TCC_Free; 292 293 // Otherwise it's not a no-op. 294 return TCC_Basic; 295 } 296 case Instruction::PtrToInt: { 297 if (!DL) 298 return TCC_Basic; 299 300 // A ptrtoint cast is free so long as the result is large enough to store 301 // the pointer, and a legal integer type. 302 unsigned DestSize = Ty->getScalarSizeInBits(); 303 if (DL->isLegalInteger(DestSize) && 304 DestSize >= DL->getPointerTypeSizeInBits(OpTy)) 305 return TCC_Free; 306 307 // Otherwise it's not a no-op. 308 return TCC_Basic; 309 } 310 case Instruction::Trunc: 311 // trunc to a native type is free (assuming the target has compare and 312 // shift-right of the same width). 313 if (DL && DL->isLegalInteger(DL->getTypeSizeInBits(Ty))) 314 return TCC_Free; 315 316 return TCC_Basic; 317 } 318 } 319 320 unsigned getGEPCost(const Value *Ptr, 321 ArrayRef<const Value *> Operands) const { 322 // In the basic model, we just assume that all-constant GEPs will be folded 323 // into their uses via addressing modes. 324 for (unsigned Idx = 0, Size = Operands.size(); Idx != Size; ++Idx) 325 if (!isa<Constant>(Operands[Idx])) 326 return TCC_Basic; 327 328 return TCC_Free; 329 } 330 331 unsigned getCallCost(FunctionType *FTy, int NumArgs = -1) const { 332 assert(FTy && "FunctionType must be provided to this routine."); 333 334 // The target-independent implementation just measures the size of the 335 // function by approximating that each argument will take on average one 336 // instruction to prepare. 337 338 if (NumArgs < 0) 339 // Set the argument number to the number of explicit arguments in the 340 // function. 341 NumArgs = FTy->getNumParams(); 342 343 return TCC_Basic * (NumArgs + 1); 344 } 345 346 unsigned getCallCost(const Function *F, int NumArgs = -1) const { 347 assert(F && "A concrete function must be provided to this routine."); 348 349 if (NumArgs < 0) 350 // Set the argument number to the number of explicit arguments in the 351 // function. 352 NumArgs = F->arg_size(); 353 354 if (Intrinsic::ID IID = (Intrinsic::ID)F->getIntrinsicID()) { 355 FunctionType *FTy = F->getFunctionType(); 356 SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end()); 357 return TopTTI->getIntrinsicCost(IID, FTy->getReturnType(), ParamTys); 358 } 359 360 if (!TopTTI->isLoweredToCall(F)) 361 return TCC_Basic; // Give a basic cost if it will be lowered directly. 362 363 return TopTTI->getCallCost(F->getFunctionType(), NumArgs); 364 } 365 366 unsigned getCallCost(const Function *F, 367 ArrayRef<const Value *> Arguments) const { 368 // Simply delegate to generic handling of the call. 369 // FIXME: We should use instsimplify or something else to catch calls which 370 // will constant fold with these arguments. 371 return TopTTI->getCallCost(F, Arguments.size()); 372 } 373 374 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy, 375 ArrayRef<Type *> ParamTys) const { 376 switch (IID) { 377 default: 378 // Intrinsics rarely (if ever) have normal argument setup constraints. 379 // Model them as having a basic instruction cost. 380 // FIXME: This is wrong for libc intrinsics. 381 return TCC_Basic; 382 383 case Intrinsic::dbg_declare: 384 case Intrinsic::dbg_value: 385 case Intrinsic::invariant_start: 386 case Intrinsic::invariant_end: 387 case Intrinsic::lifetime_start: 388 case Intrinsic::lifetime_end: 389 case Intrinsic::objectsize: 390 case Intrinsic::ptr_annotation: 391 case Intrinsic::var_annotation: 392 // These intrinsics don't actually represent code after lowering. 393 return TCC_Free; 394 } 395 } 396 397 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy, 398 ArrayRef<const Value *> Arguments) const { 399 // Delegate to the generic intrinsic handling code. This mostly provides an 400 // opportunity for targets to (for example) special case the cost of 401 // certain intrinsics based on constants used as arguments. 402 SmallVector<Type *, 8> ParamTys; 403 ParamTys.reserve(Arguments.size()); 404 for (unsigned Idx = 0, Size = Arguments.size(); Idx != Size; ++Idx) 405 ParamTys.push_back(Arguments[Idx]->getType()); 406 return TopTTI->getIntrinsicCost(IID, RetTy, ParamTys); 407 } 408 409 unsigned getUserCost(const User *U) const { 410 if (isa<PHINode>(U)) 411 return TCC_Free; // Model all PHI nodes as free. 412 413 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) 414 // In the basic model we just assume that all-constant GEPs will be 415 // folded into their uses via addressing modes. 416 return GEP->hasAllConstantIndices() ? TCC_Free : TCC_Basic; 417 418 if (ImmutableCallSite CS = U) { 419 const Function *F = CS.getCalledFunction(); 420 if (!F) { 421 // Just use the called value type. 422 Type *FTy = CS.getCalledValue()->getType()->getPointerElementType(); 423 return TopTTI->getCallCost(cast<FunctionType>(FTy), CS.arg_size()); 424 } 425 426 SmallVector<const Value *, 8> Arguments; 427 for (ImmutableCallSite::arg_iterator AI = CS.arg_begin(), 428 AE = CS.arg_end(); 429 AI != AE; ++AI) 430 Arguments.push_back(*AI); 431 432 return TopTTI->getCallCost(F, Arguments); 433 } 434 435 if (const CastInst *CI = dyn_cast<CastInst>(U)) { 436 // Result of a cmp instruction is often extended (to be used by other 437 // cmp instructions, logical or return instructions). These are usually 438 // nop on most sane targets. 439 if (isa<CmpInst>(CI->getOperand(0))) 440 return TCC_Free; 441 } 442 443 // Otherwise delegate to the fully generic implementations. 444 return getOperationCost(Operator::getOpcode(U), U->getType(), 445 U->getNumOperands() == 1 ? 446 U->getOperand(0)->getType() : 0); 447 } 448 449 bool hasBranchDivergence() const { return false; } 450 451 bool isLoweredToCall(const Function *F) const { 452 // FIXME: These should almost certainly not be handled here, and instead 453 // handled with the help of TLI or the target itself. This was largely 454 // ported from existing analysis heuristics here so that such refactorings 455 // can take place in the future. 456 457 if (F->isIntrinsic()) 458 return false; 459 460 if (F->hasLocalLinkage() || !F->hasName()) 461 return true; 462 463 StringRef Name = F->getName(); 464 465 // These will all likely lower to a single selection DAG node. 466 if (Name == "copysign" || Name == "copysignf" || Name == "copysignl" || 467 Name == "fabs" || Name == "fabsf" || Name == "fabsl" || Name == "sin" || 468 Name == "sinf" || Name == "sinl" || Name == "cos" || Name == "cosf" || 469 Name == "cosl" || Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl") 470 return false; 471 472 // These are all likely to be optimized into something smaller. 473 if (Name == "pow" || Name == "powf" || Name == "powl" || Name == "exp2" || 474 Name == "exp2l" || Name == "exp2f" || Name == "floor" || Name == 475 "floorf" || Name == "ceil" || Name == "round" || Name == "ffs" || 476 Name == "ffsl" || Name == "abs" || Name == "labs" || Name == "llabs") 477 return false; 478 479 return true; 480 } 481 482 void getUnrollingPreferences(Loop *, UnrollingPreferences &) const { } 483 484 bool isLegalAddImmediate(int64_t Imm) const { 485 return false; 486 } 487 488 bool isLegalICmpImmediate(int64_t Imm) const { 489 return false; 490 } 491 492 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, 493 bool HasBaseReg, int64_t Scale) const { 494 // Guess that reg+reg addressing is allowed. This heuristic is taken from 495 // the implementation of LSR. 496 return !BaseGV && BaseOffset == 0 && Scale <= 1; 497 } 498 499 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, 500 bool HasBaseReg, int64_t Scale) const { 501 // Guess that all legal addressing mode are free. 502 if(isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, Scale)) 503 return 0; 504 return -1; 505 } 506 507 508 bool isTruncateFree(Type *Ty1, Type *Ty2) const { 509 return false; 510 } 511 512 bool isTypeLegal(Type *Ty) const { 513 return false; 514 } 515 516 unsigned getJumpBufAlignment() const { 517 return 0; 518 } 519 520 unsigned getJumpBufSize() const { 521 return 0; 522 } 523 524 bool shouldBuildLookupTables() const { 525 return true; 526 } 527 528 PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const { 529 return PSK_Software; 530 } 531 532 bool haveFastSqrt(Type *Ty) const { 533 return false; 534 } 535 536 unsigned getIntImmCost(const APInt &Imm, Type *Ty) const { 537 return 1; 538 } 539 540 unsigned getNumberOfRegisters(bool Vector) const { 541 return 8; 542 } 543 544 unsigned getRegisterBitWidth(bool Vector) const { 545 return 32; 546 } 547 548 unsigned getMaximumUnrollFactor() const { 549 return 1; 550 } 551 552 unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind, 553 OperandValueKind) const { 554 return 1; 555 } 556 557 unsigned getShuffleCost(ShuffleKind Kind, Type *Tp, 558 int Index = 0, Type *SubTp = 0) const { 559 return 1; 560 } 561 562 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, 563 Type *Src) const { 564 return 1; 565 } 566 567 unsigned getCFInstrCost(unsigned Opcode) const { 568 return 1; 569 } 570 571 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, 572 Type *CondTy = 0) const { 573 return 1; 574 } 575 576 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, 577 unsigned Index = -1) const { 578 return 1; 579 } 580 581 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, 582 unsigned Alignment, 583 unsigned AddressSpace) const { 584 return 1; 585 } 586 587 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, 588 Type *RetTy, 589 ArrayRef<Type*> Tys) const { 590 return 1; 591 } 592 593 unsigned getNumberOfParts(Type *Tp) const { 594 return 0; 595 } 596 597 unsigned getAddressComputationCost(Type *Tp, bool) const { 598 return 0; 599 } 600 601 unsigned getReductionCost(unsigned, Type *, bool) const { 602 return 1; 603 } 604}; 605 606} // end anonymous namespace 607 608INITIALIZE_AG_PASS(NoTTI, TargetTransformInfo, "notti", 609 "No target information", true, true, true) 610char NoTTI::ID = 0; 611 612ImmutablePass *llvm::createNoTargetTransformInfoPass() { 613 return new NoTTI(); 614} 615