From 96a5b87ae21c9692432863ca574ecbd0fb204c7f Mon Sep 17 00:00:00 2001
From: Dale Johannesen <dalej@apple.com>
Date: Fri, 9 Oct 2009 21:42:02 +0000
Subject: [PATCH] Use names instead of numbers for some of the magic constants
 used in inlining heuristics (especially those used in more than one file). 
 No functional change.

llvm-svn: 83675
---
 llvm/include/llvm/Transforms/Utils/InlineCost.h |  8 ++++++++
 llvm/lib/Transforms/IPO/Inliner.cpp             |  7 ++++---
 llvm/lib/Transforms/Utils/InlineCost.cpp        | 12 ++++++------
 3 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/llvm/include/llvm/Transforms/Utils/InlineCost.h b/llvm/include/llvm/Transforms/Utils/InlineCost.h
index 2d0c397227bd..bfcb546978ec 100644
--- a/llvm/include/llvm/Transforms/Utils/InlineCost.h
+++ b/llvm/include/llvm/Transforms/Utils/InlineCost.h
@@ -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
diff --git a/llvm/lib/Transforms/IPO/Inliner.cpp b/llvm/lib/Transforms/IPO/Inliner.cpp
index 7b512d60d97f..1780480cd9d5 100644
--- a/llvm/lib/Transforms/IPO/Inliner.cpp
+++ b/llvm/lib/Transforms/IPO/Inliner.cpp
@@ -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) {
diff --git a/llvm/lib/Transforms/Utils/InlineCost.cpp b/llvm/lib/Transforms/Utils/InlineCost.cpp
index df03b378f07b..496f2e445e9f 100644
--- a/llvm/lib/Transforms/Utils/InlineCost.cpp
+++ b/llvm/lib/Transforms/Utils/InlineCost.cpp
@@ -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];