From 44b04a5f4ac8a2b9b3208a937f2ba36bcf7aa40f Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 17 Apr 2010 17:55:00 +0000 Subject: [PATCH] a bunch of cleanups and tweaks, no functionality changes. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@101657 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/InlineCost.cpp | 86 ++++++++++++++++++++----------------- 1 file changed, 46 insertions(+), 40 deletions(-) diff --git a/lib/Analysis/InlineCost.cpp b/lib/Analysis/InlineCost.cpp index b3ce42c8597..acc3f202f27 100644 --- a/lib/Analysis/InlineCost.cpp +++ b/lib/Analysis/InlineCost.cpp @@ -250,7 +250,7 @@ void InlineCostAnalyzer::FunctionInfo::analyzeFunction(Function *F) { // function call or not. // InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS, - SmallPtrSet &NeverInline) { + SmallPtrSet &NeverInline) { Instruction *TheCall = CS.getInstruction(); Function *Callee = CS.getCalledFunction(); Function *Caller = TheCall->getParent()->getParent(); @@ -296,26 +296,26 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS, } else if (isa(++BasicBlock::iterator(TheCall))) InlineCost += InlineConstants::NoreturnPenalty; - // Get information about the callee... - FunctionInfo &CalleeFI = CachedFunctionInfo[Callee]; + // Get information about the callee. + FunctionInfo *CalleeFI = &CachedFunctionInfo[Callee]; // If we haven't calculated this information yet, do so now. - if (CalleeFI.Metrics.NumBlocks == 0) - CalleeFI.analyzeFunction(Callee); + if (CalleeFI->Metrics.NumBlocks == 0) + CalleeFI->analyzeFunction(Callee); // If we should never inline this, return a huge cost. - if (CalleeFI.Metrics.NeverInline) + if (CalleeFI->Metrics.NeverInline) 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 // things we are going to just return always inline for. This // requires handling setjmp somewhere else, however. if (!Callee->isDeclaration() && Callee->hasFnAttr(Attribute::AlwaysInline)) return InlineCost::getAlways(); - if (CalleeFI.Metrics.usesDynamicAlloca) { - // Get infomation about the caller... + if (CalleeFI->Metrics.usesDynamicAlloca) { + // Get infomation about the caller. FunctionInfo &CallerFI = CachedFunctionInfo[Caller]; // 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. // if (isa(I)) { - if (ArgNo < CalleeFI.ArgumentWeights.size()) - InlineCost -= CalleeFI.ArgumentWeights[ArgNo].AllocaWeight; + if (ArgNo < CalleeFI->ArgumentWeights.size()) + InlineCost -= CalleeFI->ArgumentWeights[ArgNo].AllocaWeight; // 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 // away with this information. } else if (isa(I)) { - if (ArgNo < CalleeFI.ArgumentWeights.size()) - InlineCost -= CalleeFI.ArgumentWeights[ArgNo].ConstantWeight; + if (ArgNo < CalleeFI->ArgumentWeights.size()) + 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. // 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. - InlineCost += CalleeFI.Metrics.NumInsts*InlineConstants::InstrCost; + InlineCost += CalleeFI->Metrics.NumInsts*InlineConstants::InstrCost; return llvm::InlineCost::get(InlineCost); } @@ -376,7 +376,7 @@ InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS, float InlineCostAnalyzer::getInlineFudgeFactor(CallSite CS) { Function *Callee = CS.getCalledFunction(); - // Get information about the callee... + // Get information about the callee. FunctionInfo &CalleeFI = CachedFunctionInfo[Callee]; // 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 /// been inlined. void -InlineCostAnalyzer::growCachedCostInfo(Function* Caller, Function* Callee) { - FunctionInfo &CallerFI = CachedFunctionInfo[Caller]; +InlineCostAnalyzer::growCachedCostInfo(Function *Caller, Function *Callee) { + CodeMetrics &CallerMetrics = CachedFunctionInfo[Caller].Metrics; // 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); return; } // For large functions, we can save a lot of computation time by skipping // recalculations. - if (CallerFI.Metrics.NumCalls > 0) - --CallerFI.Metrics.NumCalls; + if (CallerMetrics.NumCalls > 0) + --CallerMetrics.NumCalls; - if (Callee) { - FunctionInfo &CalleeFI = CachedFunctionInfo[Callee]; - if (!CalleeFI.Metrics.NumBlocks) { - resetCachedCostInfo(Caller); - return; - } - CallerFI.Metrics.NeverInline |= CalleeFI.Metrics.NeverInline; - CallerFI.Metrics.usesDynamicAlloca |= CalleeFI.Metrics.usesDynamicAlloca; + if (Callee == 0) return; + + CodeMetrics &CalleeMetrics = CachedFunctionInfo[Callee].Metrics; - CallerFI.Metrics.NumInsts += CalleeFI.Metrics.NumInsts; - CallerFI.Metrics.NumBlocks += CalleeFI.Metrics.NumBlocks; - CallerFI.Metrics.NumCalls += CalleeFI.Metrics.NumCalls; - CallerFI.Metrics.NumVectorInsts += CalleeFI.Metrics.NumVectorInsts; - CallerFI.Metrics.NumRets += CalleeFI.Metrics.NumRets; - - // analyzeBasicBlock counts each function argument as an inst. - if (CallerFI.Metrics.NumInsts >= Callee->arg_size()) - CallerFI.Metrics.NumInsts -= Callee->arg_size(); - else - CallerFI.Metrics.NumInsts = 0; + // 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); + return; } + + CallerMetrics.NeverInline |= CalleeMetrics.NeverInline; + CallerMetrics.usesDynamicAlloca |= CalleeMetrics.usesDynamicAlloca; + + CallerMetrics.NumInsts += CalleeMetrics.NumInsts; + CallerMetrics.NumBlocks += CalleeMetrics.NumBlocks; + CallerMetrics.NumCalls += CalleeMetrics.NumCalls; + CallerMetrics.NumVectorInsts += CalleeMetrics.NumVectorInsts; + CallerMetrics.NumRets += CalleeMetrics.NumRets; + + // analyzeBasicBlock counts each function argument as an inst. + if (CallerMetrics.NumInsts >= Callee->arg_size()) + CallerMetrics.NumInsts -= Callee->arg_size(); + else + CallerMetrics.NumInsts = 0; + // We are not updating the argumentweights. We have already determined that // Caller is a fairly large function, so we accept the loss of precision. }