2010-04-22 05:33:15 +00:00
|
|
|
//===- InlineCost.h - Cost analysis for inliner -----------------*- C++ -*-===//
|
2007-07-25 18:00:25 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-07-25 18:00:25 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2008-07-16 16:03:31 +00:00
|
|
|
// This file implements heuristics for inlining decisions.
|
2007-07-25 18:00:25 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-10-13 18:30:07 +00:00
|
|
|
#ifndef LLVM_ANALYSIS_INLINECOST_H
|
|
|
|
#define LLVM_ANALYSIS_INLINECOST_H
|
2007-07-25 18:00:25 +00:00
|
|
|
|
2011-11-14 17:45:03 +00:00
|
|
|
#include "llvm/Function.h"
|
2010-03-13 00:10:20 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2010-04-17 00:08:21 +00:00
|
|
|
#include "llvm/ADT/ValueMap.h"
|
2010-06-09 15:11:37 +00:00
|
|
|
#include "llvm/Analysis/CodeMetrics.h"
|
2011-11-14 17:45:03 +00:00
|
|
|
#include <cassert>
|
|
|
|
#include <climits>
|
|
|
|
#include <vector>
|
2007-07-25 18:00:25 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
class CallSite;
|
2009-08-27 04:32:07 +00:00
|
|
|
template<class PtrType, unsigned SmallSize>
|
|
|
|
class SmallPtrSet;
|
2011-10-01 01:39:05 +00:00
|
|
|
class TargetData;
|
2007-07-25 18:00:25 +00:00
|
|
|
|
2009-10-09 21:42:02 +00:00
|
|
|
namespace InlineConstants {
|
|
|
|
// Various magic constants used to adjust heuristics.
|
2010-01-26 23:21:56 +00:00
|
|
|
const int InstrCost = 5;
|
2011-02-05 00:49:15 +00:00
|
|
|
const int IndirectCallBonus = -100;
|
2010-02-05 23:21:18 +00:00
|
|
|
const int CallPenalty = 25;
|
2009-10-09 21:42:02 +00:00
|
|
|
const int LastCallToStaticBonus = -15000;
|
|
|
|
const int ColdccPenalty = 2000;
|
|
|
|
const int NoreturnPenalty = 10000;
|
|
|
|
}
|
|
|
|
|
2008-10-30 19:26:59 +00:00
|
|
|
/// InlineCost - Represent the cost of inlining a function. This
|
|
|
|
/// supports special values for functions which should "always" or
|
|
|
|
/// "never" be inlined. Otherwise, the cost represents a unitless
|
2011-04-15 05:18:47 +00:00
|
|
|
/// amount; smaller values increase the likelihood of the function
|
2008-10-30 19:26:59 +00:00
|
|
|
/// being inlined.
|
|
|
|
class InlineCost {
|
|
|
|
enum Kind {
|
|
|
|
Value,
|
|
|
|
Always,
|
|
|
|
Never
|
|
|
|
};
|
|
|
|
|
2009-04-20 16:03:21 +00:00
|
|
|
// This is a do-it-yourself implementation of
|
|
|
|
// int Cost : 30;
|
|
|
|
// unsigned Type : 2;
|
|
|
|
// We used to use bitfields, but they were sometimes miscompiled (PR3822).
|
|
|
|
enum { TYPE_BITS = 2 };
|
|
|
|
enum { COST_BITS = unsigned(sizeof(unsigned)) * CHAR_BIT - TYPE_BITS };
|
|
|
|
unsigned TypedCost; // int Cost : COST_BITS; unsigned Type : TYPE_BITS;
|
2008-10-30 19:26:59 +00:00
|
|
|
|
2009-04-20 16:03:21 +00:00
|
|
|
Kind getType() const {
|
|
|
|
return Kind(TypedCost >> COST_BITS);
|
|
|
|
}
|
|
|
|
|
|
|
|
int getCost() const {
|
|
|
|
// Sign-extend the bottom COST_BITS bits.
|
|
|
|
return (int(TypedCost << TYPE_BITS)) >> TYPE_BITS;
|
|
|
|
}
|
|
|
|
|
|
|
|
InlineCost(int C, int T) {
|
|
|
|
TypedCost = (unsigned(C << TYPE_BITS) >> TYPE_BITS) | (T << COST_BITS);
|
|
|
|
assert(getCost() == C && "Cost exceeds InlineCost precision");
|
2008-10-30 19:26:59 +00:00
|
|
|
}
|
|
|
|
public:
|
|
|
|
static InlineCost get(int Cost) { return InlineCost(Cost, Value); }
|
|
|
|
static InlineCost getAlways() { return InlineCost(0, Always); }
|
2009-04-20 16:03:21 +00:00
|
|
|
static InlineCost getNever() { return InlineCost(0, Never); }
|
2008-10-30 19:26:59 +00:00
|
|
|
|
2009-04-20 16:03:21 +00:00
|
|
|
bool isVariable() const { return getType() == Value; }
|
|
|
|
bool isAlways() const { return getType() == Always; }
|
|
|
|
bool isNever() const { return getType() == Never; }
|
2008-10-30 19:26:59 +00:00
|
|
|
|
|
|
|
/// getValue() - Return a "variable" inline cost's amount. It is
|
|
|
|
/// an error to call this on an "always" or "never" InlineCost.
|
2009-04-20 16:03:21 +00:00
|
|
|
int getValue() const {
|
|
|
|
assert(getType() == Value && "Invalid access of InlineCost");
|
|
|
|
return getCost();
|
2008-10-30 19:26:59 +00:00
|
|
|
}
|
|
|
|
};
|
2010-02-05 23:21:18 +00:00
|
|
|
|
2007-07-25 18:00:25 +00:00
|
|
|
/// InlineCostAnalyzer - Cost analyzer used by inliner.
|
|
|
|
class InlineCostAnalyzer {
|
|
|
|
struct ArgInfo {
|
|
|
|
public:
|
|
|
|
unsigned ConstantWeight;
|
|
|
|
unsigned AllocaWeight;
|
2010-02-05 23:21:18 +00:00
|
|
|
|
2011-02-01 01:16:32 +00:00
|
|
|
ArgInfo(unsigned CWeight, unsigned AWeight)
|
|
|
|
: ConstantWeight(CWeight), AllocaWeight(AWeight)
|
2010-10-08 13:57:31 +00:00
|
|
|
{}
|
2007-07-25 18:00:25 +00:00
|
|
|
};
|
2010-02-05 23:21:18 +00:00
|
|
|
|
2009-10-13 19:58:07 +00:00
|
|
|
struct FunctionInfo {
|
|
|
|
CodeMetrics Metrics;
|
2009-10-13 18:24:11 +00:00
|
|
|
|
2008-07-14 00:27:31 +00:00
|
|
|
/// ArgumentWeights - Each formal argument of the function is inspected to
|
|
|
|
/// see if it is used in any contexts where making it a constant or alloca
|
|
|
|
/// would reduce the code size. If so, we add some value to the argument
|
|
|
|
/// entry here.
|
2007-07-25 18:00:25 +00:00
|
|
|
std::vector<ArgInfo> ArgumentWeights;
|
2010-02-05 23:21:18 +00:00
|
|
|
|
2012-03-14 23:19:53 +00:00
|
|
|
/// PointerArgPairWeights - Weights to use when giving an inline bonus to
|
|
|
|
/// a call site due to correlated pairs of pointers.
|
|
|
|
DenseMap<std::pair<unsigned, unsigned>, unsigned> PointerArgPairWeights;
|
|
|
|
|
2012-03-08 02:04:19 +00:00
|
|
|
/// countCodeReductionForConstant - Figure out an approximation for how
|
|
|
|
/// many instructions will be constant folded if the specified value is
|
|
|
|
/// constant.
|
|
|
|
unsigned countCodeReductionForConstant(const CodeMetrics &Metrics,
|
|
|
|
Value *V);
|
|
|
|
|
|
|
|
/// countCodeReductionForAlloca - Figure out an approximation of how much
|
|
|
|
/// smaller the function will be if it is inlined into a context where an
|
|
|
|
/// argument becomes an alloca.
|
|
|
|
unsigned countCodeReductionForAlloca(const CodeMetrics &Metrics,
|
|
|
|
Value *V);
|
|
|
|
|
2012-03-14 23:19:53 +00:00
|
|
|
/// countCodeReductionForPointerPair - Count the bonus to apply to an
|
|
|
|
/// inline call site where a pair of arguments are pointers and one
|
|
|
|
/// argument is a constant offset from the other. The idea is to
|
|
|
|
/// recognize a common C++ idiom where a begin and end iterator are
|
|
|
|
/// actually pointers, and many operations on the pair of them will be
|
|
|
|
/// constants if the function is called with arguments that have
|
|
|
|
/// a constant offset.
|
|
|
|
void countCodeReductionForPointerPair(
|
|
|
|
const CodeMetrics &Metrics,
|
|
|
|
DenseMap<Value *, unsigned> &PointerArgs,
|
|
|
|
Value *V, unsigned ArgIdx);
|
|
|
|
|
2009-10-13 19:58:07 +00:00
|
|
|
/// analyzeFunction - Add information about the specified function
|
|
|
|
/// to the current structure.
|
2011-10-01 01:39:05 +00:00
|
|
|
void analyzeFunction(Function *F, const TargetData *TD);
|
2010-06-09 15:11:37 +00:00
|
|
|
|
|
|
|
/// NeverInline - Returns true if the function should never be
|
|
|
|
/// inlined into any caller.
|
|
|
|
bool NeverInline();
|
2007-07-25 18:00:25 +00:00
|
|
|
};
|
|
|
|
|
2010-04-17 19:56:46 +00:00
|
|
|
// The Function* for a function can be changed (by ArgumentPromotion);
|
|
|
|
// the ValueMap will update itself when this happens.
|
2010-04-17 00:08:21 +00:00
|
|
|
ValueMap<const Function *, FunctionInfo> CachedFunctionInfo;
|
2007-07-25 18:00:25 +00:00
|
|
|
|
2011-10-01 01:39:05 +00:00
|
|
|
// TargetData if available, or null.
|
|
|
|
const TargetData *TD;
|
|
|
|
|
2011-02-05 00:49:15 +00:00
|
|
|
int CountBonusForConstant(Value *V, Constant *C = NULL);
|
|
|
|
int ConstantFunctionBonus(CallSite CS, Constant *C);
|
|
|
|
int getInlineSize(CallSite CS, Function *Callee);
|
|
|
|
int getInlineBonuses(CallSite CS, Function *Callee);
|
2007-07-25 18:00:25 +00:00
|
|
|
public:
|
2011-10-01 01:39:05 +00:00
|
|
|
InlineCostAnalyzer(): TD(0) {}
|
|
|
|
|
|
|
|
void setTargetData(const TargetData *TData) { TD = TData; }
|
2007-07-25 18:00:25 +00:00
|
|
|
|
2008-07-14 00:27:31 +00:00
|
|
|
/// getInlineCost - The heuristic used to determine if we should inline the
|
|
|
|
/// function call or not.
|
|
|
|
///
|
Start removing the use of an ad-hoc 'never inline' set and instead
directly query the function information which this set was representing.
This simplifies the interface of the inline cost analysis, and makes the
always-inline pass significantly more efficient.
Previously, always-inline would first make a single set of every
function in the module *except* those marked with the always-inline
attribute. It would then query this set at every call site to see if the
function was a member of the set, and if so, refuse to inline it. This
is quite wasteful. Instead, simply check the function attribute directly
when looking at the callsite.
The normal inliner also had similar redundancy. It added every function
in the module with the noinline attribute to its set to ignore, even
though inside the cost analysis function we *already tested* the
noinline attribute and produced the same result.
The only tricky part of removing this is that we have to be able to
correctly remove only the functions inlined by the always-inline pass
when finalizing, which requires a bit of a hack. Still, much less of
a hack than the set of all non-always-inline functions was. While I was
touching this function, I switched a heavy-weight set to a vector with
sort+unique. The algorithm already had a two-phase insert and removal
pattern, we were just needlessly paying the uniquing cost on every
insert.
This probably speeds up some compiles by a small amount (-O0 compiles
with lots of always-inline, so potentially heavy libc++ users), but I've
not tried to measure it.
I believe there is no functional change here, but yell if you spot one.
None are intended.
Finally, the direction this is going in is to greatly simplify the
inline cost query interface so that we can replace its implementation
with a much more clever one. Along the way, all the APIs get simplified,
so it seems incrementally good.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@152903 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-16 06:10:13 +00:00
|
|
|
InlineCost getInlineCost(CallSite CS);
|
2010-05-01 15:47:41 +00:00
|
|
|
/// getCalledFunction - The heuristic used to determine if we should inline
|
|
|
|
/// the function call or not. The callee is explicitly specified, to allow
|
|
|
|
/// you to calculate the cost of inlining a function via a pointer. The
|
|
|
|
/// result assumes that the inlined version will always be used. You should
|
|
|
|
/// weight it yourself in cases where this callee will not always be called.
|
Start removing the use of an ad-hoc 'never inline' set and instead
directly query the function information which this set was representing.
This simplifies the interface of the inline cost analysis, and makes the
always-inline pass significantly more efficient.
Previously, always-inline would first make a single set of every
function in the module *except* those marked with the always-inline
attribute. It would then query this set at every call site to see if the
function was a member of the set, and if so, refuse to inline it. This
is quite wasteful. Instead, simply check the function attribute directly
when looking at the callsite.
The normal inliner also had similar redundancy. It added every function
in the module with the noinline attribute to its set to ignore, even
though inside the cost analysis function we *already tested* the
noinline attribute and produced the same result.
The only tricky part of removing this is that we have to be able to
correctly remove only the functions inlined by the always-inline pass
when finalizing, which requires a bit of a hack. Still, much less of
a hack than the set of all non-always-inline functions was. While I was
touching this function, I switched a heavy-weight set to a vector with
sort+unique. The algorithm already had a two-phase insert and removal
pattern, we were just needlessly paying the uniquing cost on every
insert.
This probably speeds up some compiles by a small amount (-O0 compiles
with lots of always-inline, so potentially heavy libc++ users), but I've
not tried to measure it.
I believe there is no functional change here, but yell if you spot one.
None are intended.
Finally, the direction this is going in is to greatly simplify the
inline cost query interface so that we can replace its implementation
with a much more clever one. Along the way, all the APIs get simplified,
so it seems incrementally good.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@152903 91177308-0d34-0410-b5e6-96231b3b80d8
2012-03-16 06:10:13 +00:00
|
|
|
InlineCost getInlineCost(CallSite CS, Function *Callee);
|
2008-03-24 06:37:48 +00:00
|
|
|
|
2008-07-14 00:27:31 +00:00
|
|
|
/// getInlineFudgeFactor - Return a > 1.0 factor if the inliner should use a
|
|
|
|
/// higher threshold to determine if the function call should be inlined.
|
2008-05-30 22:47:19 +00:00
|
|
|
float getInlineFudgeFactor(CallSite CS);
|
2009-01-09 01:30:11 +00:00
|
|
|
|
|
|
|
/// resetCachedFunctionInfo - erase any cached cost info for this function.
|
|
|
|
void resetCachedCostInfo(Function* Caller) {
|
2009-10-13 23:36:36 +00:00
|
|
|
CachedFunctionInfo[Caller] = FunctionInfo();
|
2009-01-09 01:30:11 +00:00
|
|
|
}
|
2010-03-09 23:02:17 +00:00
|
|
|
|
|
|
|
/// growCachedCostInfo - update the cached cost info for Caller after Callee
|
|
|
|
/// has been inlined. If Callee is NULL it means a dead call has been
|
|
|
|
/// eliminated.
|
|
|
|
void growCachedCostInfo(Function* Caller, Function* Callee);
|
2010-05-12 21:48:15 +00:00
|
|
|
|
|
|
|
/// clear - empty the cache of inline costs
|
|
|
|
void clear();
|
2007-07-25 18:00:25 +00:00
|
|
|
};
|
2010-04-16 15:14:50 +00:00
|
|
|
|
|
|
|
/// callIsSmall - If a call is likely to lower to a single target instruction,
|
|
|
|
/// or is otherwise deemed small return true.
|
|
|
|
bool callIsSmall(const Function *Callee);
|
2007-07-25 18:00:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|