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