6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-03 13:31:05 +00:00
Code Issues Projects Releases Wiki Activity

a bunch of cleanups and tweaks, no functionality changes.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@101657 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2010-04-17 17:55:00 +00:00
parent 43bc70ebef
commit 44b04a5f4a
1 changed files with 46 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
lib/Analysis/InlineCost.cpp
View File

@ -250,7 +250,7 @@ void InlineCostAnalyzer::FunctionInfo::analyzeFunction(Function *F) {
// function call or not. // function call or not.
// //
InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS, InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
SmallPtrSet<const Function *, 16> &NeverInline) { SmallPtrSet<const Function*, 16> &NeverInline) {
Instruction *TheCall = CS.getInstruction(); Instruction *TheCall = CS.getInstruction();
Function *Callee = CS.getCalledFunction(); Function *Callee = CS.getCalledFunction();
Function *Caller = TheCall->getParent()->getParent(); Function *Caller = TheCall->getParent()->getParent();
@ -296,26 +296,26 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
} else if (isa<UnreachableInst>(++BasicBlock::iterator(TheCall))) } else if (isa<UnreachableInst>(++BasicBlock::iterator(TheCall)))
InlineCost += InlineConstants::NoreturnPenalty; InlineCost += InlineConstants::NoreturnPenalty;
// Get information about the callee... // Get information about the callee.
FunctionInfo &CalleeFI = CachedFunctionInfo[Callee]; FunctionInfo *CalleeFI = &CachedFunctionInfo[Callee];
// If we haven't calculated this information yet, do so now. // If we haven't calculated this information yet, do so now.
if (CalleeFI.Metrics.NumBlocks == 0) if (CalleeFI->Metrics.NumBlocks == 0)
CalleeFI.analyzeFunction(Callee); CalleeFI->analyzeFunction(Callee);
// If we should never inline this, return a huge cost. // If we should never inline this, return a huge cost.
if (CalleeFI.Metrics.NeverInline) if (CalleeFI->Metrics.NeverInline)
return InlineCost::getNever(); return InlineCost::getNever();
// FIXME: It would be nice to kill off CalleeFI.NeverInline. Then we // FIXME: It would be nice to kill off CalleeFI->NeverInline. Then we
// could move this up and avoid computing the FunctionInfo for // could move this up and avoid computing the FunctionInfo for
// things we are going to just return always inline for. This // things we are going to just return always inline for. This
// requires handling setjmp somewhere else, however. // requires handling setjmp somewhere else, however.
if (!Callee->isDeclaration() && Callee->hasFnAttr(Attribute::AlwaysInline)) if (!Callee->isDeclaration() && Callee->hasFnAttr(Attribute::AlwaysInline))
return InlineCost::getAlways(); return InlineCost::getAlways();
if (CalleeFI.Metrics.usesDynamicAlloca) { if (CalleeFI->Metrics.usesDynamicAlloca) {
// Get infomation about the caller... // Get infomation about the caller.
FunctionInfo &CallerFI = CachedFunctionInfo[Caller]; FunctionInfo &CallerFI = CachedFunctionInfo[Caller];
// If we haven't calculated this information yet, do so now. // If we haven't calculated this information yet, do so now.
@ -347,15 +347,15 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
// scalarization), so encourage the inlining of the function. // scalarization), so encourage the inlining of the function.
// //
if (isa<AllocaInst>(I)) { if (isa<AllocaInst>(I)) {
if (ArgNo < CalleeFI.ArgumentWeights.size()) if (ArgNo < CalleeFI->ArgumentWeights.size())
InlineCost -= CalleeFI.ArgumentWeights[ArgNo].AllocaWeight; InlineCost -= CalleeFI->ArgumentWeights[ArgNo].AllocaWeight;
// If this is a constant being passed into the function, use the argument // If this is a constant being passed into the function, use the argument
// weights calculated for the callee to determine how much will be folded // weights calculated for the callee to determine how much will be folded
// away with this information. // away with this information.
} else if (isa<Constant>(I)) { } else if (isa<Constant>(I)) {
if (ArgNo < CalleeFI.ArgumentWeights.size()) if (ArgNo < CalleeFI->ArgumentWeights.size())
InlineCost -= CalleeFI.ArgumentWeights[ArgNo].ConstantWeight; InlineCost -= CalleeFI->ArgumentWeights[ArgNo].ConstantWeight;
} }
} }
@ -363,10 +363,10 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
// likely to be inlined, look at factors that make us not want to inline it. // likely to be inlined, look at factors that make us not want to inline it.
// Calls usually take a long time, so they make the inlining gain smaller. // Calls usually take a long time, so they make the inlining gain smaller.
InlineCost += CalleeFI.Metrics.NumCalls * InlineConstants::CallPenalty; InlineCost += CalleeFI->Metrics.NumCalls * InlineConstants::CallPenalty;
// Look at the size of the callee. Each instruction counts as 5. // Look at the size of the callee. Each instruction counts as 5.
InlineCost += CalleeFI.Metrics.NumInsts*InlineConstants::InstrCost; InlineCost += CalleeFI->Metrics.NumInsts*InlineConstants::InstrCost;
return llvm::InlineCost::get(InlineCost); return llvm::InlineCost::get(InlineCost);
} }
@ -376,7 +376,7 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
float InlineCostAnalyzer::getInlineFudgeFactor(CallSite CS) { float InlineCostAnalyzer::getInlineFudgeFactor(CallSite CS) {
Function *Callee = CS.getCalledFunction(); Function *Callee = CS.getCalledFunction();
// Get information about the callee... // Get information about the callee.
FunctionInfo &CalleeFI = CachedFunctionInfo[Callee]; FunctionInfo &CalleeFI = CachedFunctionInfo[Callee];
// If we haven't calculated this information yet, do so now. // If we haven't calculated this information yet, do so now.
@ -400,41 +400,47 @@ float InlineCostAnalyzer::getInlineFudgeFactor(CallSite CS) {
/// growCachedCostInfo - update the cached cost info for Caller after Callee has /// growCachedCostInfo - update the cached cost info for Caller after Callee has
/// been inlined. /// been inlined.
void void
InlineCostAnalyzer::growCachedCostInfo(Function* Caller, Function* Callee) { InlineCostAnalyzer::growCachedCostInfo(Function *Caller, Function *Callee) {
FunctionInfo &CallerFI = CachedFunctionInfo[Caller]; CodeMetrics &CallerMetrics = CachedFunctionInfo[Caller].Metrics;
// For small functions we prefer to recalculate the cost for better accuracy. // For small functions we prefer to recalculate the cost for better accuracy.
if (CallerFI.Metrics.NumBlocks < 10 || CallerFI.Metrics.NumInsts < 1000) { if (CallerMetrics.NumBlocks < 10 || CallerMetrics.NumInsts < 1000) {
resetCachedCostInfo(Caller); resetCachedCostInfo(Caller);
return; return;
} }
// For large functions, we can save a lot of computation time by skipping // For large functions, we can save a lot of computation time by skipping
// recalculations. // recalculations.
if (CallerFI.Metrics.NumCalls > 0) if (CallerMetrics.NumCalls > 0)
--CallerFI.Metrics.NumCalls; --CallerMetrics.NumCalls;
if (Callee) { if (Callee == 0) return;
FunctionInfo &CalleeFI = CachedFunctionInfo[Callee];
if (!CalleeFI.Metrics.NumBlocks) { CodeMetrics &CalleeMetrics = CachedFunctionInfo[Callee].Metrics;
// If we don't have metrics for the callee, don't recalculate them just to
// update an approximation in the caller. Instead, just recalculate the
// caller info from scratch.
if (CalleeMetrics.NumBlocks == 0) {
resetCachedCostInfo(Caller); resetCachedCostInfo(Caller);
return; return;
} }
CallerFI.Metrics.NeverInline |= CalleeFI.Metrics.NeverInline;
CallerFI.Metrics.usesDynamicAlloca |= CalleeFI.Metrics.usesDynamicAlloca;
CallerFI.Metrics.NumInsts += CalleeFI.Metrics.NumInsts; CallerMetrics.NeverInline |= CalleeMetrics.NeverInline;
CallerFI.Metrics.NumBlocks += CalleeFI.Metrics.NumBlocks; CallerMetrics.usesDynamicAlloca |= CalleeMetrics.usesDynamicAlloca;
CallerFI.Metrics.NumCalls += CalleeFI.Metrics.NumCalls;
CallerFI.Metrics.NumVectorInsts += CalleeFI.Metrics.NumVectorInsts; CallerMetrics.NumInsts += CalleeMetrics.NumInsts;
CallerFI.Metrics.NumRets += CalleeFI.Metrics.NumRets; CallerMetrics.NumBlocks += CalleeMetrics.NumBlocks;
CallerMetrics.NumCalls += CalleeMetrics.NumCalls;
CallerMetrics.NumVectorInsts += CalleeMetrics.NumVectorInsts;
CallerMetrics.NumRets += CalleeMetrics.NumRets;
// analyzeBasicBlock counts each function argument as an inst. // analyzeBasicBlock counts each function argument as an inst.
if (CallerFI.Metrics.NumInsts >= Callee->arg_size()) if (CallerMetrics.NumInsts >= Callee->arg_size())
CallerFI.Metrics.NumInsts -= Callee->arg_size(); CallerMetrics.NumInsts -= Callee->arg_size();
else else
CallerFI.Metrics.NumInsts = 0; CallerMetrics.NumInsts = 0;
}
// We are not updating the argumentweights. We have already determined that // We are not updating the argumentweights. We have already determined that
// Caller is a fairly large function, so we accept the loss of precision. // Caller is a fairly large function, so we accept the loss of precision.
} }