From cbd056074cfcd79265ee1e04e83f347355e9ad61 Mon Sep 17 00:00:00 2001
From: Devang Patel <dpatel@apple.com>
Date: Sat, 13 Mar 2010 00:10:20 +0000
Subject: [PATCH] Do not overestimate code size reduction in presense of debug
 info. Use CodeMetrics.analyzeBasicBlock() to estimate BB size.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98401 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/Analysis/InlineCost.h |  6 +++++-
 lib/Analysis/InlineCost.cpp        | 17 +++++++++++------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/include/llvm/Analysis/InlineCost.h b/include/llvm/Analysis/InlineCost.h
index f0e97d7a181..ea76ec11bda 100644
--- a/include/llvm/Analysis/InlineCost.h
+++ b/include/llvm/Analysis/InlineCost.h
@@ -18,6 +18,7 @@
 #include <climits>
 #include <map>
 #include <vector>
+#include "llvm/ADT/DenseMap.h"
 
 namespace llvm {
 
@@ -42,6 +43,9 @@ namespace llvm {
     /// is used to estimate the code size cost of inlining it.
     unsigned NumInsts, NumBlocks;
 
+    /// NumBBInsts - Keeps track of basic block code size estimates.
+    DenseMap<const BasicBlock *, unsigned> NumBBInsts;
+
     /// NumCalls - Keep track of the number of calls to 'big' functions.
     unsigned NumCalls;
 
@@ -148,7 +152,7 @@ namespace llvm {
       /// CountCodeReductionForConstant - Figure out an approximation for how
       /// many instructions will be constant folded if the specified value is
       /// constant.
-      unsigned CountCodeReductionForConstant(Value *V);
+      unsigned CountCodeReductionForConstant(Value *V, CodeMetrics &M);
 
       /// CountCodeReductionForAlloca - Figure out an approximation of how much
       /// smaller the function will be if it is inlined into a context where an
diff --git a/lib/Analysis/InlineCost.cpp b/lib/Analysis/InlineCost.cpp
index 0f1f93b66b0..280f5f596f8 100644
--- a/lib/Analysis/InlineCost.cpp
+++ b/lib/Analysis/InlineCost.cpp
@@ -22,7 +22,7 @@ using namespace llvm;
 // instructions will be constant folded if the specified value is constant.
 //
 unsigned InlineCostAnalyzer::FunctionInfo::
-         CountCodeReductionForConstant(Value *V) {
+CountCodeReductionForConstant(Value *V, CodeMetrics &Metrics) {
   unsigned Reduction = 0;
   for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ++UI)
     if (isa<BranchInst>(*UI) || isa<SwitchInst>(*UI)) {
@@ -31,7 +31,7 @@ unsigned InlineCostAnalyzer::FunctionInfo::
       const unsigned NumSucc = TI.getNumSuccessors();
       unsigned Instrs = 0;
       for (unsigned I = 0; I != NumSucc; ++I)
-        Instrs += TI.getSuccessor(I)->size();
+        Instrs += Metrics.NumBBInsts[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 if (CallInst *CI = dyn_cast<CallInst>(*UI)) {
@@ -71,7 +71,7 @@ unsigned InlineCostAnalyzer::FunctionInfo::
 
         // And any other instructions that use it which become constants
         // themselves.
-        Reduction += CountCodeReductionForConstant(&Inst);
+        Reduction += CountCodeReductionForConstant(&Inst, Metrics);
       }
     }
 
@@ -142,7 +142,7 @@ static bool callIsSmall(const Function *F) {
 /// from the specified block.
 void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB) {
   ++NumBlocks;
-
+  unsigned NumInstsInThisBB = 0;
   for (BasicBlock::const_iterator II = BB->begin(), E = BB->end();
        II != E; ++II) {
     if (isa<PHINode>(II)) continue;           // PHI nodes don't count.
@@ -196,6 +196,7 @@ void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB) {
     }
 
     ++NumInsts;
+    ++NumInstsInThisBB;
   }
   
   if (isa<ReturnInst>(BB->getTerminator()))
@@ -208,6 +209,9 @@ void CodeMetrics::analyzeBasicBlock(const BasicBlock *BB) {
   // function which is extremely undefined behavior.
   if (isa<IndirectBrInst>(BB->getTerminator()))
     NeverInline = true;
+
+  // Remember NumInsts for this BB.
+  NumBBInsts[BB] = NumInstsInThisBB;
 }
 
 /// analyzeFunction - Fill in the current structure with information gleaned
@@ -238,8 +242,9 @@ 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(CountCodeReductionForConstant(I),
-                                      CountCodeReductionForAlloca(I)));
+    ArgumentWeights.
+      push_back(ArgInfo(CountCodeReductionForConstant(I, Metrics),
+                        CountCodeReductionForAlloca(I)));
 }
 
 // getInlineCost - The heuristic used to determine if we should inline the