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/Analysis/TargetTransformInfoImpl.h" 12 #include "llvm/IR/CallSite.h" 13 #include "llvm/IR/DataLayout.h" 14 #include "llvm/IR/Instruction.h" 15 #include "llvm/IR/Instructions.h" 16 #include "llvm/IR/IntrinsicInst.h" 17 #include "llvm/IR/Module.h" 18 #include "llvm/IR/Operator.h" 19 #include "llvm/Support/ErrorHandling.h" 20 #include <utility> 21 22 using namespace llvm; 23 24 #define DEBUG_TYPE "tti" 25 26 namespace { 27 /// \brief No-op implementation of the TTI interface using the utility base 28 /// classes. 29 /// 30 /// This is used when no target specific information is available. 31 struct NoTTIImpl : TargetTransformInfoImplCRTPBase<NoTTIImpl> { 32 explicit NoTTIImpl(const DataLayout &DL) 33 : TargetTransformInfoImplCRTPBase<NoTTIImpl>(DL) {} 34 }; 35 } 36 37 TargetTransformInfo::TargetTransformInfo(const DataLayout &DL) 38 : TTIImpl(new Model<NoTTIImpl>(NoTTIImpl(DL))) {} 39 40 TargetTransformInfo::~TargetTransformInfo() {} 41 42 TargetTransformInfo::TargetTransformInfo(TargetTransformInfo &&Arg) 43 : TTIImpl(std::move(Arg.TTIImpl)) {} 44 45 TargetTransformInfo &TargetTransformInfo::operator=(TargetTransformInfo &&RHS) { 46 TTIImpl = std::move(RHS.TTIImpl); 47 return *this; 48 } 49 50 int TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty, 51 Type *OpTy) const { 52 int Cost = TTIImpl->getOperationCost(Opcode, Ty, OpTy); 53 assert(Cost >= 0 && "TTI should not produce negative costs!"); 54 return Cost; 55 } 56 57 int TargetTransformInfo::getCallCost(FunctionType *FTy, int NumArgs) const { 58 int Cost = TTIImpl->getCallCost(FTy, NumArgs); 59 assert(Cost >= 0 && "TTI should not produce negative costs!"); 60 return Cost; 61 } 62 63 int TargetTransformInfo::getCallCost(const Function *F, 64 ArrayRef<const Value *> Arguments) const { 65 int Cost = TTIImpl->getCallCost(F, Arguments); 66 assert(Cost >= 0 && "TTI should not produce negative costs!"); 67 return Cost; 68 } 69 70 unsigned TargetTransformInfo::getInliningThresholdMultiplier() const { 71 return TTIImpl->getInliningThresholdMultiplier(); 72 } 73 74 int TargetTransformInfo::getGEPCost(Type *PointeeType, const Value *Ptr, 75 ArrayRef<const Value *> Operands) const { 76 return TTIImpl->getGEPCost(PointeeType, Ptr, Operands); 77 } 78 79 int TargetTransformInfo::getIntrinsicCost( 80 Intrinsic::ID IID, Type *RetTy, ArrayRef<const Value *> Arguments) const { 81 int Cost = TTIImpl->getIntrinsicCost(IID, RetTy, Arguments); 82 assert(Cost >= 0 && "TTI should not produce negative costs!"); 83 return Cost; 84 } 85 86 int TargetTransformInfo::getUserCost(const User *U) const { 87 int Cost = TTIImpl->getUserCost(U); 88 assert(Cost >= 0 && "TTI should not produce negative costs!"); 89 return Cost; 90 } 91 92 bool TargetTransformInfo::hasBranchDivergence() const { 93 return TTIImpl->hasBranchDivergence(); 94 } 95 96 bool TargetTransformInfo::isSourceOfDivergence(const Value *V) const { 97 return TTIImpl->isSourceOfDivergence(V); 98 } 99 100 bool TargetTransformInfo::isLoweredToCall(const Function *F) const { 101 return TTIImpl->isLoweredToCall(F); 102 } 103 104 void TargetTransformInfo::getUnrollingPreferences( 105 Loop *L, UnrollingPreferences &UP) const { 106 return TTIImpl->getUnrollingPreferences(L, UP); 107 } 108 109 bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const { 110 return TTIImpl->isLegalAddImmediate(Imm); 111 } 112 113 bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const { 114 return TTIImpl->isLegalICmpImmediate(Imm); 115 } 116 117 bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, 118 int64_t BaseOffset, 119 bool HasBaseReg, 120 int64_t Scale, 121 unsigned AddrSpace) const { 122 return TTIImpl->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, 123 Scale, AddrSpace); 124 } 125 126 bool TargetTransformInfo::isLegalMaskedStore(Type *DataType) const { 127 return TTIImpl->isLegalMaskedStore(DataType); 128 } 129 130 bool TargetTransformInfo::isLegalMaskedLoad(Type *DataType) const { 131 return TTIImpl->isLegalMaskedLoad(DataType); 132 } 133 134 bool TargetTransformInfo::isLegalMaskedGather(Type *DataType) const { 135 return TTIImpl->isLegalMaskedGather(DataType); 136 } 137 138 bool TargetTransformInfo::isLegalMaskedScatter(Type *DataType) const { 139 return TTIImpl->isLegalMaskedGather(DataType); 140 } 141 142 int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, 143 int64_t BaseOffset, 144 bool HasBaseReg, 145 int64_t Scale, 146 unsigned AddrSpace) const { 147 int Cost = TTIImpl->getScalingFactorCost(Ty, BaseGV, BaseOffset, HasBaseReg, 148 Scale, AddrSpace); 149 assert(Cost >= 0 && "TTI should not produce negative costs!"); 150 return Cost; 151 } 152 153 bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const { 154 return TTIImpl->isTruncateFree(Ty1, Ty2); 155 } 156 157 bool TargetTransformInfo::isProfitableToHoist(Instruction *I) const { 158 return TTIImpl->isProfitableToHoist(I); 159 } 160 161 bool TargetTransformInfo::isTypeLegal(Type *Ty) const { 162 return TTIImpl->isTypeLegal(Ty); 163 } 164 165 unsigned TargetTransformInfo::getJumpBufAlignment() const { 166 return TTIImpl->getJumpBufAlignment(); 167 } 168 169 unsigned TargetTransformInfo::getJumpBufSize() const { 170 return TTIImpl->getJumpBufSize(); 171 } 172 173 bool TargetTransformInfo::shouldBuildLookupTables() const { 174 return TTIImpl->shouldBuildLookupTables(); 175 } 176 177 bool TargetTransformInfo::enableAggressiveInterleaving(bool LoopHasReductions) const { 178 return TTIImpl->enableAggressiveInterleaving(LoopHasReductions); 179 } 180 181 bool TargetTransformInfo::enableInterleavedAccessVectorization() const { 182 return TTIImpl->enableInterleavedAccessVectorization(); 183 } 184 185 bool TargetTransformInfo::isFPVectorizationPotentiallyUnsafe() const { 186 return TTIImpl->isFPVectorizationPotentiallyUnsafe(); 187 } 188 189 bool TargetTransformInfo::allowsMisalignedMemoryAccesses(unsigned BitWidth, 190 unsigned AddressSpace, 191 unsigned Alignment, 192 bool *Fast) const { 193 return TTIImpl->allowsMisalignedMemoryAccesses(BitWidth, AddressSpace, 194 Alignment, Fast); 195 } 196 197 TargetTransformInfo::PopcntSupportKind 198 TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const { 199 return TTIImpl->getPopcntSupport(IntTyWidthInBit); 200 } 201 202 bool TargetTransformInfo::haveFastSqrt(Type *Ty) const { 203 return TTIImpl->haveFastSqrt(Ty); 204 } 205 206 int TargetTransformInfo::getFPOpCost(Type *Ty) const { 207 int Cost = TTIImpl->getFPOpCost(Ty); 208 assert(Cost >= 0 && "TTI should not produce negative costs!"); 209 return Cost; 210 } 211 212 int TargetTransformInfo::getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx, 213 const APInt &Imm, 214 Type *Ty) const { 215 int Cost = TTIImpl->getIntImmCodeSizeCost(Opcode, Idx, Imm, Ty); 216 assert(Cost >= 0 && "TTI should not produce negative costs!"); 217 return Cost; 218 } 219 220 int TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const { 221 int Cost = TTIImpl->getIntImmCost(Imm, Ty); 222 assert(Cost >= 0 && "TTI should not produce negative costs!"); 223 return Cost; 224 } 225 226 int TargetTransformInfo::getIntImmCost(unsigned Opcode, unsigned Idx, 227 const APInt &Imm, Type *Ty) const { 228 int Cost = TTIImpl->getIntImmCost(Opcode, Idx, Imm, Ty); 229 assert(Cost >= 0 && "TTI should not produce negative costs!"); 230 return Cost; 231 } 232 233 int TargetTransformInfo::getIntImmCost(Intrinsic::ID IID, unsigned Idx, 234 const APInt &Imm, Type *Ty) const { 235 int Cost = TTIImpl->getIntImmCost(IID, Idx, Imm, Ty); 236 assert(Cost >= 0 && "TTI should not produce negative costs!"); 237 return Cost; 238 } 239 240 unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const { 241 return TTIImpl->getNumberOfRegisters(Vector); 242 } 243 244 unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const { 245 return TTIImpl->getRegisterBitWidth(Vector); 246 } 247 248 unsigned TargetTransformInfo::getLoadStoreVecRegBitWidth(unsigned AS) const { 249 return TTIImpl->getLoadStoreVecRegBitWidth(AS); 250 } 251 252 unsigned TargetTransformInfo::getCacheLineSize() const { 253 return TTIImpl->getCacheLineSize(); 254 } 255 256 unsigned TargetTransformInfo::getPrefetchDistance() const { 257 return TTIImpl->getPrefetchDistance(); 258 } 259 260 unsigned TargetTransformInfo::getMinPrefetchStride() const { 261 return TTIImpl->getMinPrefetchStride(); 262 } 263 264 unsigned TargetTransformInfo::getMaxPrefetchIterationsAhead() const { 265 return TTIImpl->getMaxPrefetchIterationsAhead(); 266 } 267 268 unsigned TargetTransformInfo::getMaxInterleaveFactor(unsigned VF) const { 269 return TTIImpl->getMaxInterleaveFactor(VF); 270 } 271 272 int TargetTransformInfo::getArithmeticInstrCost( 273 unsigned Opcode, Type *Ty, OperandValueKind Opd1Info, 274 OperandValueKind Opd2Info, OperandValueProperties Opd1PropInfo, 275 OperandValueProperties Opd2PropInfo) const { 276 int Cost = TTIImpl->getArithmeticInstrCost(Opcode, Ty, Opd1Info, Opd2Info, 277 Opd1PropInfo, Opd2PropInfo); 278 assert(Cost >= 0 && "TTI should not produce negative costs!"); 279 return Cost; 280 } 281 282 int TargetTransformInfo::getShuffleCost(ShuffleKind Kind, Type *Ty, int Index, 283 Type *SubTp) const { 284 int Cost = TTIImpl->getShuffleCost(Kind, Ty, Index, SubTp); 285 assert(Cost >= 0 && "TTI should not produce negative costs!"); 286 return Cost; 287 } 288 289 int TargetTransformInfo::getCastInstrCost(unsigned Opcode, Type *Dst, 290 Type *Src) const { 291 int Cost = TTIImpl->getCastInstrCost(Opcode, Dst, Src); 292 assert(Cost >= 0 && "TTI should not produce negative costs!"); 293 return Cost; 294 } 295 296 int TargetTransformInfo::getExtractWithExtendCost(unsigned Opcode, Type *Dst, 297 VectorType *VecTy, 298 unsigned Index) const { 299 int Cost = TTIImpl->getExtractWithExtendCost(Opcode, Dst, VecTy, Index); 300 assert(Cost >= 0 && "TTI should not produce negative costs!"); 301 return Cost; 302 } 303 304 int TargetTransformInfo::getCFInstrCost(unsigned Opcode) const { 305 int Cost = TTIImpl->getCFInstrCost(Opcode); 306 assert(Cost >= 0 && "TTI should not produce negative costs!"); 307 return Cost; 308 } 309 310 int TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, 311 Type *CondTy) const { 312 int Cost = TTIImpl->getCmpSelInstrCost(Opcode, ValTy, CondTy); 313 assert(Cost >= 0 && "TTI should not produce negative costs!"); 314 return Cost; 315 } 316 317 int TargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val, 318 unsigned Index) const { 319 int Cost = TTIImpl->getVectorInstrCost(Opcode, Val, Index); 320 assert(Cost >= 0 && "TTI should not produce negative costs!"); 321 return Cost; 322 } 323 324 int TargetTransformInfo::getMemoryOpCost(unsigned Opcode, Type *Src, 325 unsigned Alignment, 326 unsigned AddressSpace) const { 327 int Cost = TTIImpl->getMemoryOpCost(Opcode, Src, Alignment, AddressSpace); 328 assert(Cost >= 0 && "TTI should not produce negative costs!"); 329 return Cost; 330 } 331 332 int TargetTransformInfo::getMaskedMemoryOpCost(unsigned Opcode, Type *Src, 333 unsigned Alignment, 334 unsigned AddressSpace) const { 335 int Cost = 336 TTIImpl->getMaskedMemoryOpCost(Opcode, Src, Alignment, AddressSpace); 337 assert(Cost >= 0 && "TTI should not produce negative costs!"); 338 return Cost; 339 } 340 341 int TargetTransformInfo::getGatherScatterOpCost(unsigned Opcode, Type *DataTy, 342 Value *Ptr, bool VariableMask, 343 unsigned Alignment) const { 344 int Cost = TTIImpl->getGatherScatterOpCost(Opcode, DataTy, Ptr, VariableMask, 345 Alignment); 346 assert(Cost >= 0 && "TTI should not produce negative costs!"); 347 return Cost; 348 } 349 350 int TargetTransformInfo::getInterleavedMemoryOpCost( 351 unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices, 352 unsigned Alignment, unsigned AddressSpace) const { 353 int Cost = TTIImpl->getInterleavedMemoryOpCost(Opcode, VecTy, Factor, Indices, 354 Alignment, AddressSpace); 355 assert(Cost >= 0 && "TTI should not produce negative costs!"); 356 return Cost; 357 } 358 359 int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, 360 ArrayRef<Type *> Tys, 361 FastMathFlags FMF) const { 362 int Cost = TTIImpl->getIntrinsicInstrCost(ID, RetTy, Tys, FMF); 363 assert(Cost >= 0 && "TTI should not produce negative costs!"); 364 return Cost; 365 } 366 367 int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, 368 ArrayRef<Value *> Args, 369 FastMathFlags FMF) const { 370 int Cost = TTIImpl->getIntrinsicInstrCost(ID, RetTy, Args, FMF); 371 assert(Cost >= 0 && "TTI should not produce negative costs!"); 372 return Cost; 373 } 374 375 int TargetTransformInfo::getCallInstrCost(Function *F, Type *RetTy, 376 ArrayRef<Type *> Tys) const { 377 int Cost = TTIImpl->getCallInstrCost(F, RetTy, Tys); 378 assert(Cost >= 0 && "TTI should not produce negative costs!"); 379 return Cost; 380 } 381 382 unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const { 383 return TTIImpl->getNumberOfParts(Tp); 384 } 385 386 int TargetTransformInfo::getAddressComputationCost(Type *Tp, 387 bool IsComplex) const { 388 int Cost = TTIImpl->getAddressComputationCost(Tp, IsComplex); 389 assert(Cost >= 0 && "TTI should not produce negative costs!"); 390 return Cost; 391 } 392 393 int TargetTransformInfo::getReductionCost(unsigned Opcode, Type *Ty, 394 bool IsPairwiseForm) const { 395 int Cost = TTIImpl->getReductionCost(Opcode, Ty, IsPairwiseForm); 396 assert(Cost >= 0 && "TTI should not produce negative costs!"); 397 return Cost; 398 } 399 400 unsigned 401 TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const { 402 return TTIImpl->getCostOfKeepingLiveOverCall(Tys); 403 } 404 405 bool TargetTransformInfo::getTgtMemIntrinsic(IntrinsicInst *Inst, 406 MemIntrinsicInfo &Info) const { 407 return TTIImpl->getTgtMemIntrinsic(Inst, Info); 408 } 409 410 Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic( 411 IntrinsicInst *Inst, Type *ExpectedType) const { 412 return TTIImpl->getOrCreateResultFromMemIntrinsic(Inst, ExpectedType); 413 } 414 415 bool TargetTransformInfo::areInlineCompatible(const Function *Caller, 416 const Function *Callee) const { 417 return TTIImpl->areInlineCompatible(Caller, Callee); 418 } 419 420 TargetTransformInfo::Concept::~Concept() {} 421 422 TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {} 423 424 TargetIRAnalysis::TargetIRAnalysis( 425 std::function<Result(const Function &)> TTICallback) 426 : TTICallback(std::move(TTICallback)) {} 427 428 TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F, 429 AnalysisManager<Function> &) { 430 return TTICallback(F); 431 } 432 433 char TargetIRAnalysis::PassID; 434 435 TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) { 436 return Result(F.getParent()->getDataLayout()); 437 } 438 439 // Register the basic pass. 440 INITIALIZE_PASS(TargetTransformInfoWrapperPass, "tti", 441 "Target Transform Information", false, true) 442 char TargetTransformInfoWrapperPass::ID = 0; 443 444 void TargetTransformInfoWrapperPass::anchor() {} 445 446 TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass() 447 : ImmutablePass(ID) { 448 initializeTargetTransformInfoWrapperPassPass( 449 *PassRegistry::getPassRegistry()); 450 } 451 452 TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass( 453 TargetIRAnalysis TIRA) 454 : ImmutablePass(ID), TIRA(std::move(TIRA)) { 455 initializeTargetTransformInfoWrapperPassPass( 456 *PassRegistry::getPassRegistry()); 457 } 458 459 TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) { 460 AnalysisManager<Function> DummyFAM; 461 TTI = TIRA.run(F, DummyFAM); 462 return *TTI; 463 } 464 465 ImmutablePass * 466 llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) { 467 return new TargetTransformInfoWrapperPass(std::move(TIRA)); 468 } 469