1 //===- CodeMetrics.h - Measures the weight of a function---------*- C++ -*-===// 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 // This file implements various weight measurements for code, helping 11 // the Inliner and other passes decide whether to duplicate its contents. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_ANALYSIS_CODEMETRICS_H 16 #define LLVM_ANALYSIS_CODEMETRICS_H 17 18 #include "llvm/ADT/DenseMap.h" 19 20 namespace llvm { 21 22 class TargetData; 23 24 // CodeMetrics - Calculate size and a few similar metrics for a set of 25 // basic blocks. 26 struct CodeMetrics { 27 /// NeverInline - True if this callee should never be inlined into a 28 /// caller. 29 // bool NeverInline; 30 31 // True if this function contains a call to setjmp or _setjmp 32 bool callsSetJmp; 33 34 // True if this function calls itself 35 bool isRecursive; 36 37 // True if this function contains one or more indirect branches 38 bool containsIndirectBr; 39 40 /// usesDynamicAlloca - True if this function calls alloca (in the C sense). 41 bool usesDynamicAlloca; 42 43 /// NumInsts, NumBlocks - Keep track of how large each function is, which 44 /// is used to estimate the code size cost of inlining it. 45 unsigned NumInsts, NumBlocks; 46 47 /// NumBBInsts - Keeps track of basic block code size estimates. 48 DenseMap<const BasicBlock *, unsigned> NumBBInsts; 49 50 /// NumCalls - Keep track of the number of calls to 'big' functions. 51 unsigned NumCalls; 52 53 /// NumInlineCandidates - Keep track of the number of calls to internal 54 /// functions with only a single caller. These are likely targets for 55 /// future inlining, likely exposed by interleaved devirtualization. 56 unsigned NumInlineCandidates; 57 58 /// NumVectorInsts - Keep track of how many instructions produce vector 59 /// values. The inliner is being more aggressive with inlining vector 60 /// kernels. 61 unsigned NumVectorInsts; 62 63 /// NumRets - Keep track of how many Ret instructions the block contains. 64 unsigned NumRets; 65 CodeMetricsCodeMetrics66 CodeMetrics() : callsSetJmp(false), isRecursive(false), 67 containsIndirectBr(false), usesDynamicAlloca(false), 68 NumInsts(0), NumBlocks(0), NumCalls(0), 69 NumInlineCandidates(0), NumVectorInsts(0), 70 NumRets(0) {} 71 72 /// analyzeBasicBlock - Add information about the specified basic block 73 /// to the current structure. 74 void analyzeBasicBlock(const BasicBlock *BB, const TargetData *TD = 0); 75 76 /// analyzeFunction - Add information about the specified function 77 /// to the current structure. 78 void analyzeFunction(Function *F, const TargetData *TD = 0); 79 80 /// CountCodeReductionForConstant - Figure out an approximation for how 81 /// many instructions will be constant folded if the specified value is 82 /// constant. 83 unsigned CountCodeReductionForConstant(Value *V); 84 85 /// CountBonusForConstant - Figure out an approximation for how much 86 /// per-call performance boost we can expect if the specified value is 87 /// constant. 88 unsigned CountBonusForConstant(Value *V); 89 90 /// CountCodeReductionForAlloca - Figure out an approximation of how much 91 /// smaller the function will be if it is inlined into a context where an 92 /// argument becomes an alloca. 93 /// 94 unsigned CountCodeReductionForAlloca(Value *V); 95 }; 96 } 97 98 #endif 99