Chandler Carruth | be04929 | 2013-01-07 03:08:10 +0000 | [diff] [blame] | 1 | //===- llvm/Analysis/TargetTransformInfo.cpp ------------------------------===// |
Nadav Rotem | cbd9a19 | 2012-10-18 23:22:48 +0000 | [diff] [blame] | 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 | |
Chandler Carruth | be04929 | 2013-01-07 03:08:10 +0000 | [diff] [blame] | 10 | #include "llvm/Analysis/TargetTransformInfo.h" |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 11 | #include "llvm/Analysis/TargetTransformInfoImpl.h" |
Stephen Hines | 36b5688 | 2014-04-23 16:57:46 -0700 | [diff] [blame] | 12 | #include "llvm/IR/CallSite.h" |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 13 | #include "llvm/IR/DataLayout.h" |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 14 | #include "llvm/IR/Instruction.h" |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 15 | #include "llvm/IR/Instructions.h" |
Stephen Hines | 36b5688 | 2014-04-23 16:57:46 -0700 | [diff] [blame] | 16 | #include "llvm/IR/IntrinsicInst.h" |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 17 | #include "llvm/IR/Module.h" |
Stephen Hines | 36b5688 | 2014-04-23 16:57:46 -0700 | [diff] [blame] | 18 | #include "llvm/IR/Operator.h" |
Nadav Rotem | cbd9a19 | 2012-10-18 23:22:48 +0000 | [diff] [blame] | 19 | #include "llvm/Support/ErrorHandling.h" |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 20 | #include <utility> |
Nadav Rotem | cbd9a19 | 2012-10-18 23:22:48 +0000 | [diff] [blame] | 21 | |
| 22 | using namespace llvm; |
| 23 | |
Stephen Hines | dce4a40 | 2014-05-29 02:49:00 -0700 | [diff] [blame] | 24 | #define DEBUG_TYPE "tti" |
| 25 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 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> { |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 32 | explicit NoTTIImpl(const DataLayout &DL) |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 33 | : TargetTransformInfoImplCRTPBase<NoTTIImpl>(DL) {} |
| 34 | }; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 35 | } |
| 36 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 37 | TargetTransformInfo::TargetTransformInfo(const DataLayout &DL) |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 38 | : TTIImpl(new Model<NoTTIImpl>(NoTTIImpl(DL))) {} |
Chandler Carruth | aeef83c | 2013-01-07 01:37:14 +0000 | [diff] [blame] | 39 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 40 | TargetTransformInfo::~TargetTransformInfo() {} |
Chandler Carruth | aeef83c | 2013-01-07 01:37:14 +0000 | [diff] [blame] | 41 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 48 | } |
| 49 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 55 | } |
| 56 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 13086a6 | 2013-01-22 11:26:02 +0000 | [diff] [blame] | 61 | } |
| 62 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 13086a6 | 2013-01-22 11:26:02 +0000 | [diff] [blame] | 68 | } |
| 69 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 13086a6 | 2013-01-22 11:26:02 +0000 | [diff] [blame] | 84 | } |
| 85 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 90 | } |
| 91 | |
Tom Stellard | 57e6b2d | 2013-07-27 00:01:07 +0000 | [diff] [blame] | 92 | bool TargetTransformInfo::hasBranchDivergence() const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 93 | return TTIImpl->hasBranchDivergence(); |
Tom Stellard | 57e6b2d | 2013-07-27 00:01:07 +0000 | [diff] [blame] | 94 | } |
| 95 | |
Pirama Arumuga Nainar | 0c7f116 | 2015-05-06 11:46:36 -0700 | [diff] [blame] | 96 | bool TargetTransformInfo::isSourceOfDivergence(const Value *V) const { |
| 97 | return TTIImpl->isSourceOfDivergence(V); |
| 98 | } |
| 99 | |
Chandler Carruth | 13086a6 | 2013-01-22 11:26:02 +0000 | [diff] [blame] | 100 | bool TargetTransformInfo::isLoweredToCall(const Function *F) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 101 | return TTIImpl->isLoweredToCall(F); |
Chandler Carruth | 13086a6 | 2013-01-22 11:26:02 +0000 | [diff] [blame] | 102 | } |
| 103 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 104 | void TargetTransformInfo::getUnrollingPreferences( |
| 105 | Loop *L, UnrollingPreferences &UP) const { |
| 106 | return TTIImpl->getUnrollingPreferences(L, UP); |
Hal Finkel | 4f7e2c3 | 2013-09-11 19:25:43 +0000 | [diff] [blame] | 107 | } |
| 108 | |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 109 | bool TargetTransformInfo::isLegalAddImmediate(int64_t Imm) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 110 | return TTIImpl->isLegalAddImmediate(Imm); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | bool TargetTransformInfo::isLegalICmpImmediate(int64_t Imm) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 114 | return TTIImpl->isLegalICmpImmediate(Imm); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, |
| 118 | int64_t BaseOffset, |
| 119 | bool HasBaseReg, |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 120 | int64_t Scale, |
| 121 | unsigned AddrSpace) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 122 | return TTIImpl->isLegalAddressingMode(Ty, BaseGV, BaseOffset, HasBaseReg, |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 123 | Scale, AddrSpace); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 124 | } |
| 125 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 126 | bool TargetTransformInfo::isLegalMaskedStore(Type *DataType) const { |
| 127 | return TTIImpl->isLegalMaskedStore(DataType); |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 128 | } |
| 129 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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); |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 140 | } |
| 141 | |
Quentin Colombet | 06f5ebc | 2013-05-31 21:29:03 +0000 | [diff] [blame] | 142 | int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, |
| 143 | int64_t BaseOffset, |
| 144 | bool HasBaseReg, |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 145 | int64_t Scale, |
| 146 | unsigned AddrSpace) const { |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Quentin Colombet | 06f5ebc | 2013-05-31 21:29:03 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 153 | bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 154 | return TTIImpl->isTruncateFree(Ty1, Ty2); |
| 155 | } |
| 156 | |
| 157 | bool TargetTransformInfo::isProfitableToHoist(Instruction *I) const { |
| 158 | return TTIImpl->isProfitableToHoist(I); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | bool TargetTransformInfo::isTypeLegal(Type *Ty) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 162 | return TTIImpl->isTypeLegal(Ty); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 163 | } |
| 164 | |
| 165 | unsigned TargetTransformInfo::getJumpBufAlignment() const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 166 | return TTIImpl->getJumpBufAlignment(); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | unsigned TargetTransformInfo::getJumpBufSize() const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 170 | return TTIImpl->getJumpBufSize(); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | bool TargetTransformInfo::shouldBuildLookupTables() const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 174 | return TTIImpl->shouldBuildLookupTables(); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 175 | } |
| 176 | |
Pirama Arumuga Nainar | 4c5e43d | 2015-04-08 08:55:49 -0700 | [diff] [blame] | 177 | bool TargetTransformInfo::enableAggressiveInterleaving(bool LoopHasReductions) const { |
| 178 | return TTIImpl->enableAggressiveInterleaving(LoopHasReductions); |
| 179 | } |
| 180 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 181 | bool TargetTransformInfo::enableInterleavedAccessVectorization() const { |
| 182 | return TTIImpl->enableInterleavedAccessVectorization(); |
| 183 | } |
| 184 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Chandler Carruth | d1b8ef9 | 2013-01-07 03:16:03 +0000 | [diff] [blame] | 197 | TargetTransformInfo::PopcntSupportKind |
| 198 | TargetTransformInfo::getPopcntSupport(unsigned IntTyWidthInBit) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 199 | return TTIImpl->getPopcntSupport(IntTyWidthInBit); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 200 | } |
| 201 | |
Richard Sandiford | a8a7099 | 2013-08-23 10:27:02 +0000 | [diff] [blame] | 202 | bool TargetTransformInfo::haveFastSqrt(Type *Ty) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 203 | return TTIImpl->haveFastSqrt(Ty); |
| 204 | } |
| 205 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Richard Sandiford | a8a7099 | 2013-08-23 10:27:02 +0000 | [diff] [blame] | 210 | } |
| 211 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 224 | } |
| 225 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Stephen Hines | 36b5688 | 2014-04-23 16:57:46 -0700 | [diff] [blame] | 231 | } |
| 232 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Stephen Hines | 36b5688 | 2014-04-23 16:57:46 -0700 | [diff] [blame] | 238 | } |
| 239 | |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 240 | unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 241 | return TTIImpl->getNumberOfRegisters(Vector); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 242 | } |
| 243 | |
Nadav Rotem | 14925e6 | 2013-01-09 22:29:00 +0000 | [diff] [blame] | 244 | unsigned TargetTransformInfo::getRegisterBitWidth(bool Vector) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 245 | return TTIImpl->getRegisterBitWidth(Vector); |
Nadav Rotem | 14925e6 | 2013-01-09 22:29:00 +0000 | [diff] [blame] | 246 | } |
| 247 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 268 | unsigned TargetTransformInfo::getMaxInterleaveFactor(unsigned VF) const { |
| 269 | return TTIImpl->getMaxInterleaveFactor(VF); |
Nadav Rotem | 83be7b0 | 2013-01-09 01:15:42 +0000 | [diff] [blame] | 270 | } |
| 271 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 272 | int TargetTransformInfo::getArithmeticInstrCost( |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 273 | unsigned Opcode, Type *Ty, OperandValueKind Opd1Info, |
| 274 | OperandValueKind Opd2Info, OperandValueProperties Opd1PropInfo, |
Stephen Hines | 37ed9c1 | 2014-12-01 14:51:49 -0800 | [diff] [blame] | 275 | OperandValueProperties Opd2PropInfo) const { |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 280 | } |
| 281 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 287 | } |
| 288 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 308 | } |
| 309 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 315 | } |
| 316 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 322 | } |
| 323 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 330 | } |
| 331 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 339 | } |
| 340 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 350 | int TargetTransformInfo::getInterleavedMemoryOpCost( |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 351 | unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices, |
| 352 | unsigned Alignment, unsigned AddressSpace) const { |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Pirama Arumuga Nainar | 6948897 | 2015-07-01 12:23:51 -0700 | [diff] [blame] | 357 | } |
| 358 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 359 | int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 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); |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Pirama Arumuga Nainar | 4c5e43d | 2015-04-08 08:55:49 -0700 | [diff] [blame] | 380 | } |
| 381 | |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 382 | unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 383 | return TTIImpl->getNumberOfParts(Tp); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 384 | } |
| 385 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Arnold Schwaighofer | fb55a8f | 2013-02-08 14:50:48 +0000 | [diff] [blame] | 391 | } |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 392 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 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; |
Arnold Schwaighofer | 65457b6 | 2013-09-17 18:06:50 +0000 | [diff] [blame] | 398 | } |
| 399 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 400 | unsigned |
| 401 | TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const { |
| 402 | return TTIImpl->getCostOfKeepingLiveOverCall(Tys); |
Stephen Hines | 37ed9c1 | 2014-12-01 14:51:49 -0800 | [diff] [blame] | 403 | } |
| 404 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 405 | bool TargetTransformInfo::getTgtMemIntrinsic(IntrinsicInst *Inst, |
| 406 | MemIntrinsicInfo &Info) const { |
| 407 | return TTIImpl->getTgtMemIntrinsic(Inst, Info); |
| 408 | } |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 409 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 410 | Value *TargetTransformInfo::getOrCreateResultFromMemIntrinsic( |
| 411 | IntrinsicInst *Inst, Type *ExpectedType) const { |
| 412 | return TTIImpl->getOrCreateResultFromMemIntrinsic(Inst, ExpectedType); |
| 413 | } |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 414 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 415 | bool TargetTransformInfo::areInlineCompatible(const Function *Caller, |
| 416 | const Function *Callee) const { |
| 417 | return TTIImpl->areInlineCompatible(Caller, Callee); |
| 418 | } |
| 419 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 420 | TargetTransformInfo::Concept::~Concept() {} |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 421 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 422 | TargetIRAnalysis::TargetIRAnalysis() : TTICallback(&getDefaultTTI) {} |
Chandler Carruth | aeef83c | 2013-01-07 01:37:14 +0000 | [diff] [blame] | 423 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 424 | TargetIRAnalysis::TargetIRAnalysis( |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 425 | std::function<Result(const Function &)> TTICallback) |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 426 | : TTICallback(std::move(TTICallback)) {} |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 427 | |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 428 | TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F, |
| 429 | AnalysisManager<Function> &) { |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 430 | return TTICallback(F); |
| 431 | } |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 432 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 433 | char TargetIRAnalysis::PassID; |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 434 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 435 | TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) { |
| 436 | return Result(F.getParent()->getDataLayout()); |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 437 | } |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 438 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 439 | // Register the basic pass. |
| 440 | INITIALIZE_PASS(TargetTransformInfoWrapperPass, "tti", |
| 441 | "Target Transform Information", false, true) |
| 442 | char TargetTransformInfoWrapperPass::ID = 0; |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 443 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 444 | void TargetTransformInfoWrapperPass::anchor() {} |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 445 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 446 | TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass() |
| 447 | : ImmutablePass(ID) { |
| 448 | initializeTargetTransformInfoWrapperPassPass( |
| 449 | *PassRegistry::getPassRegistry()); |
| 450 | } |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 451 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 452 | TargetTransformInfoWrapperPass::TargetTransformInfoWrapperPass( |
| 453 | TargetIRAnalysis TIRA) |
| 454 | : ImmutablePass(ID), TIRA(std::move(TIRA)) { |
| 455 | initializeTargetTransformInfoWrapperPassPass( |
| 456 | *PassRegistry::getPassRegistry()); |
| 457 | } |
Matt Arsenault | f9355c8 | 2013-08-28 22:41:57 +0000 | [diff] [blame] | 458 | |
Pirama Arumuga Nainar | f3ef533 | 2016-03-03 15:48:50 -0800 | [diff] [blame] | 459 | TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) { |
Pirama Arumuga Nainar | de2d869 | 2016-09-19 22:57:26 -0700 | [diff] [blame] | 460 | AnalysisManager<Function> DummyFAM; |
| 461 | TTI = TIRA.run(F, DummyFAM); |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 462 | return *TTI; |
| 463 | } |
Chandler Carruth | 1e05bd9 | 2013-01-21 01:27:39 +0000 | [diff] [blame] | 464 | |
Stephen Hines | ebe69fe | 2015-03-23 12:10:34 -0700 | [diff] [blame] | 465 | ImmutablePass * |
| 466 | llvm::createTargetTransformInfoWrapperPass(TargetIRAnalysis TIRA) { |
| 467 | return new TargetTransformInfoWrapperPass(std::move(TIRA)); |
Chandler Carruth | 7bdf6b0 | 2013-01-05 11:43:11 +0000 | [diff] [blame] | 468 | } |