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