From 6f130bf368ab082ab87bafaee9bf4e1a78acc669 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Thu, 8 Mar 2012 02:04:19 +0000 Subject: [PATCH] Rotate two of the functions used to count bonuses for the inline cost analysis to be methods on the cost analysis's function info object instead of the code metrics object. These really are just users of the code metrics, they're building the information for the function's analysis. This is the first step of growing the amount of information we collect about a function in order to cope with pair-wise simplifications due to allocas. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@152283 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/CodeMetrics.h | 11 ----------- include/llvm/Analysis/InlineCost.h | 12 ++++++++++++ lib/Analysis/InlineCost.cpp | 24 ++++++++++-------------- 3 files changed, 22 insertions(+), 25 deletions(-) diff --git a/include/llvm/Analysis/CodeMetrics.h b/include/llvm/Analysis/CodeMetrics.h index 6d34781fb2e..cf92642d2f2 100644 --- a/include/llvm/Analysis/CodeMetrics.h +++ b/include/llvm/Analysis/CodeMetrics.h @@ -81,21 +81,10 @@ namespace llvm { /// to the current structure. void analyzeFunction(Function *F, const TargetData *TD = 0); - /// CountCodeReductionForConstant - Figure out an approximation for how - /// many instructions will be constant folded if the specified value is - /// constant. - unsigned CountCodeReductionForConstant(Value *V); - /// CountBonusForConstant - Figure out an approximation for how much /// per-call performance boost we can expect if the specified value is /// constant. unsigned CountBonusForConstant(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(Value *V); }; } diff --git a/include/llvm/Analysis/InlineCost.h b/include/llvm/Analysis/InlineCost.h index fdcd5a82c5b..e3d526e7431 100644 --- a/include/llvm/Analysis/InlineCost.h +++ b/include/llvm/Analysis/InlineCost.h @@ -110,6 +110,18 @@ namespace llvm { /// entry here. std::vector ArgumentWeights; + /// 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); + /// analyzeFunction - Add information about the specified function /// to the current structure. void analyzeFunction(Function *F, const TargetData *TD); diff --git a/lib/Analysis/InlineCost.cpp b/lib/Analysis/InlineCost.cpp index b326ba76893..dfe4b97812c 100644 --- a/lib/Analysis/InlineCost.cpp +++ b/lib/Analysis/InlineCost.cpp @@ -162,10 +162,8 @@ void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB, NumBBInsts[BB] = NumInsts - NumInstsBeforeThisBB; } -// CountCodeReductionForConstant - Figure out an approximation for how many -// instructions will be constant folded if the specified value is constant. -// -unsigned CodeMetrics::CountCodeReductionForConstant(Value *V) { +unsigned InlineCostAnalyzer::FunctionInfo::countCodeReductionForConstant( + const CodeMetrics &Metrics, Value *V) { unsigned Reduction = 0; for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E;++UI){ User *U = *UI; @@ -175,7 +173,7 @@ unsigned CodeMetrics::CountCodeReductionForConstant(Value *V) { const unsigned NumSucc = TI.getNumSuccessors(); unsigned Instrs = 0; for (unsigned I = 0; I != NumSucc; ++I) - Instrs += NumBBInsts[TI.getSuccessor(I)]; + Instrs += Metrics.NumBBInsts.lookup(TI.getSuccessor(I)); // We don't know which blocks will be eliminated, so use the average size. Reduction += InlineConstants::InstrCost*Instrs*(NumSucc-1)/NumSucc; } else { @@ -207,18 +205,15 @@ unsigned CodeMetrics::CountCodeReductionForConstant(Value *V) { // And any other instructions that use it which become constants // themselves. - Reduction += CountCodeReductionForConstant(&Inst); + Reduction += countCodeReductionForConstant(Metrics, &Inst); } } } return Reduction; } -// 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 CodeMetrics::CountCodeReductionForAlloca(Value *V) { +unsigned InlineCostAnalyzer::FunctionInfo::countCodeReductionForAlloca( + const CodeMetrics &Metrics, Value *V) { if (!V->getType()->isPointerTy()) return 0; // Not a pointer unsigned Reduction = 0; @@ -331,7 +326,8 @@ unsigned CodeMetrics::CountCodeReductionForAlloca(Value *V) { if (BranchInst *BI = dyn_cast(I)) { BasicBlock *BB = BI->getSuccessor(Result ? 0 : 1); if (BB->getSinglePredecessor()) - Reduction += InlineConstants::InstrCost * NumBBInsts[BB]; + Reduction + += InlineConstants::InstrCost * Metrics.NumBBInsts.lookup(BB); } } } while (!Worklist.empty()); @@ -372,8 +368,8 @@ void InlineCostAnalyzer::FunctionInfo::analyzeFunction(Function *F, // code can be eliminated if one of the arguments is a constant. ArgumentWeights.reserve(F->arg_size()); for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) - ArgumentWeights.push_back(ArgInfo(Metrics.CountCodeReductionForConstant(I), - Metrics.CountCodeReductionForAlloca(I))); + ArgumentWeights.push_back(ArgInfo(countCodeReductionForConstant(Metrics, I), + countCodeReductionForAlloca(Metrics, I))); } /// NeverInline - returns true if the function should never be inlined into