Use names instead of numbers for some of the magic

constants used in inlining heuristics (especially
those used in more than one file).  No functional change.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@83675 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dale Johannesen 2009-10-09 21:42:02 +00:00
parent d7894f105a
commit bdb984bc27
3 changed files with 18 additions and 9 deletions

View File

@ -27,6 +27,14 @@ namespace llvm {
template<class PtrType, unsigned SmallSize>
class SmallPtrSet;
namespace InlineConstants {
// Various magic constants used to adjust heuristics.
const int CallPenalty = 5;
const int LastCallToStaticBonus = -15000;
const int ColdccPenalty = 2000;
const int NoreturnPenalty = 10000;
}
/// 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

View File

@ -243,10 +243,11 @@ bool Inliner::shouldInline(CallSite CS) {
if (Cost2 >= (int)(CurrentThreshold2 * FudgeFactor2))
allOuterCallsWillBeInlined = false;
// See if we have this case. The magic 6 is what InlineCost assigns
// See if we have this case. We subtract off the penalty
// for the call instruction, which we would be deleting.
if (Cost2 < (int)(CurrentThreshold2 * FudgeFactor2) &&
Cost2 + Cost - 6 >= (int)(CurrentThreshold2 * FudgeFactor2)) {
Cost2 + Cost - (InlineConstants::CallPenalty + 1) >=
(int)(CurrentThreshold2 * FudgeFactor2)) {
someOuterCallWouldNotBeInlined = true;
TotalSecondaryCost += Cost2;
}
@ -256,7 +257,7 @@ bool Inliner::shouldInline(CallSite CS) {
// be removed entirely. We did not account for this above unless there
// is only one caller of Caller.
if (allOuterCallsWillBeInlined && Caller->use_begin() != Caller->use_end())
TotalSecondaryCost -= 15000;
TotalSecondaryCost += InlineConstants::LastCallToStaticBonus;
if (outerCallsFound && someOuterCallWouldNotBeInlined &&
TotalSecondaryCost < Cost) {

View File

@ -132,12 +132,12 @@ void InlineCostAnalyzer::FunctionInfo::analyzeFunction(Function *F) {
// Calls often compile into many machine instructions. Bump up their
// cost to reflect this.
if (!isa<IntrinsicInst>(II))
NumInsts += 5;
NumInsts += InlineConstants::CallPenalty;
}
// These, too, are calls.
if (isa<MallocInst>(II) || isa<FreeInst>(II))
NumInsts += 5;
NumInsts += InlineConstants::CallPenalty;
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
if (!AI->isStaticAlloca())
@ -212,21 +212,21 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
// make it almost guaranteed to be inlined.
//
if (Callee->hasLocalLinkage() && Callee->hasOneUse())
InlineCost -= 15000;
InlineCost += InlineConstants::LastCallToStaticBonus;
// If this function uses the coldcc calling convention, prefer not to inline
// it.
if (Callee->getCallingConv() == CallingConv::Cold)
InlineCost += 2000;
InlineCost += InlineConstants::ColdccPenalty;
// If the instruction after the call, or if the normal destination of the
// invoke is an unreachable instruction, the function is noreturn. As such,
// there is little point in inlining this.
if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall)) {
if (isa<UnreachableInst>(II->getNormalDest()->begin()))
InlineCost += 10000;
InlineCost += InlineConstants::NoreturnPenalty;
} else if (isa<UnreachableInst>(++BasicBlock::iterator(TheCall)))
InlineCost += 10000;
InlineCost += InlineConstants::NoreturnPenalty;
// Get information about the callee...
FunctionInfo &CalleeFI = CachedFunctionInfo[Callee];