RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity

Use names instead of numbers for some of the magic

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

llvm-svn: 83675
This commit is contained in:
Dale Johannesen 2009-10-09 21:42:02 +00:00
parent 430e05312d
commit 7691b73da0
3 changed files with 18 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/llvm/Transforms/Utils/InlineCost.h
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

7
lib/Transforms/IPO/Inliner.cpp
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) {

12
lib/Transforms/Utils/InlineCost.cpp
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];