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