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 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
66    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