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