1//===- InlineCost.h - Cost analysis for inliner -----------------*- 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 heuristics for inlining decisions.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ANALYSIS_INLINECOST_H
15#define LLVM_ANALYSIS_INLINECOST_H
16
17#include "llvm/Analysis/CallGraphSCCPass.h"
18#include <cassert>
19#include <climits>
20
21namespace llvm {
22class AssumptionCacheTracker;
23class CallSite;
24class DataLayout;
25class Function;
26class TargetTransformInfo;
27
28namespace InlineConstants {
29  // Various magic constants used to adjust heuristics.
30  const int InstrCost = 5;
31  const int IndirectCallThreshold = 100;
32  const int CallPenalty = 25;
33  const int LastCallToStaticBonus = -15000;
34  const int ColdccPenalty = 2000;
35  const int NoreturnPenalty = 10000;
36  /// Do not inline functions which allocate this many bytes on the stack
37  /// when the caller is recursive.
38  const unsigned TotalAllocaSizeRecursiveCaller = 1024;
39}
40
41/// \brief Represents the cost of inlining a function.
42///
43/// This supports special values for functions which should "always" or
44/// "never" be inlined. Otherwise, the cost represents a unitless amount;
45/// smaller values increase the likelihood of the function being inlined.
46///
47/// Objects of this type also provide the adjusted threshold for inlining
48/// based on the information available for a particular callsite. They can be
49/// directly tested to determine if inlining should occur given the cost and
50/// threshold for this cost metric.
51class InlineCost {
52  enum SentinelValues {
53    AlwaysInlineCost = INT_MIN,
54    NeverInlineCost = INT_MAX
55  };
56
57  /// \brief The estimated cost of inlining this callsite.
58  const int Cost;
59
60  /// \brief The adjusted threshold against which this cost was computed.
61  const int Threshold;
62
63  // Trivial constructor, interesting logic in the factory functions below.
64  InlineCost(int Cost, int Threshold) : Cost(Cost), Threshold(Threshold) {}
65
66public:
67  static InlineCost get(int Cost, int Threshold) {
68    assert(Cost > AlwaysInlineCost && "Cost crosses sentinel value");
69    assert(Cost < NeverInlineCost && "Cost crosses sentinel value");
70    return InlineCost(Cost, Threshold);
71  }
72  static InlineCost getAlways() {
73    return InlineCost(AlwaysInlineCost, 0);
74  }
75  static InlineCost getNever() {
76    return InlineCost(NeverInlineCost, 0);
77  }
78
79  /// \brief Test whether the inline cost is low enough for inlining.
80  explicit operator bool() const {
81    return Cost < Threshold;
82  }
83
84  bool isAlways() const { return Cost == AlwaysInlineCost; }
85  bool isNever() const { return Cost == NeverInlineCost; }
86  bool isVariable() const { return !isAlways() && !isNever(); }
87
88  /// \brief Get the inline cost estimate.
89  /// It is an error to call this on an "always" or "never" InlineCost.
90  int getCost() const {
91    assert(isVariable() && "Invalid access of InlineCost");
92    return Cost;
93  }
94
95  /// \brief Get the cost delta from the threshold for inlining.
96  /// Only valid if the cost is of the variable kind. Returns a negative
97  /// value if the cost is too high to inline.
98  int getCostDelta() const { return Threshold - getCost(); }
99};
100
101/// \brief Get an InlineCost object representing the cost of inlining this
102/// callsite.
103///
104/// Note that threshold is passed into this function. Only costs below the
105/// threshold are computed with any accuracy. The threshold can be used to
106/// bound the computation necessary to determine whether the cost is
107/// sufficiently low to warrant inlining.
108///
109/// Also note that calling this function *dynamically* computes the cost of
110/// inlining the callsite. It is an expensive, heavyweight call.
111InlineCost getInlineCost(CallSite CS, int Threshold,
112                         TargetTransformInfo &CalleeTTI,
113                         AssumptionCacheTracker *ACT);
114
115/// \brief Get an InlineCost with the callee explicitly specified.
116/// This allows you to calculate the cost of inlining a function via a
117/// pointer. This behaves exactly as the version with no explicit callee
118/// parameter in all other respects.
119//
120InlineCost getInlineCost(CallSite CS, Function *Callee, int Threshold,
121                         TargetTransformInfo &CalleeTTI,
122                         AssumptionCacheTracker *ACT);
123
124/// \brief Minimal filter to detect invalid constructs for inlining.
125bool isInlineViable(Function &Callee);
126}
127
128#endif
129