CodeMetrics.h revision 6f130bf368ab082ab87bafaee9bf4e1a78acc669 
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 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    /// CountBonusForConstant - Figure out an approximation for how much
85    /// per-call performance boost we can expect if the specified value is
86    /// constant.
87    unsigned CountBonusForConstant(Value *V);
88  };
89}
90
91#endif
92