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