Add InlineCost class for represent the estimated cost of inlining a

[oota-llvm.git] / lib / Transforms / Utils / InlineCost.cpp

diff --git a/lib/Transforms/Utils/InlineCost.cpp b/lib/Transforms/Utils/InlineCost.cpp
index 2a39158d24ec46888b2134f6c0a0346bec84b0f0..b85a45590cb60230979332707ef3390ed9ae40b7 100644 (file)
--- a/lib/Transforms/Utils/InlineCost.cpp
+++ b/lib/Transforms/Utils/InlineCost.cpp
@@ -169,22 +169,26 @@ void InlineCostAnalyzer::FunctionInfo::analyzeFunction(Function *F) {
 // getInlineCost - The heuristic used to determine if we should inline the
 // function call or not.
 //
-int InlineCostAnalyzer::getInlineCost(CallSite CS,
+InlineCost InlineCostAnalyzer::getInlineCost(CallSite CS,
                                SmallPtrSet<const Function *, 16> &NeverInline) {
   Instruction *TheCall = CS.getInstruction();
   Function *Callee = CS.getCalledFunction();
   const Function *Caller = TheCall->getParent()->getParent();
-  
+
   // Don't inline a directly recursive call.
   if (Caller == Callee ||
       // Don't inline functions which can be redefined at link-time to mean
-      // something else.  link-once linkage is ok though.
-      Callee->hasWeakLinkage() ||
-      
+      // something else.
+      // FIXME: We allow link-once linkage since in practice all versions of
+      // the function have the same body (C++ ODR) - but the LLVM definition
+      // of LinkOnceLinkage doesn't require this.
+      (Callee->mayBeOverridden() && !Callee->hasLinkOnceLinkage()
+       ) ||
+
       // Don't inline functions marked noinline.
       NeverInline.count(Callee))
-    return 2000000000;
-  
+    return llvm::InlineCost::getNever();
+
   // InlineCost - This value measures how good of an inline candidate this call
   // site is to inline.  A lower inline cost make is more likely for the call to
   // be inlined.  This value may go negative.
@@ -220,10 +224,14 @@ int InlineCostAnalyzer::getInlineCost(CallSite CS,
   
   // If we should never inline this, return a huge cost.
   if (CalleeFI.NeverInline)
-    return 2000000000;
+    return InlineCost::getNever();
 
-  if (Callee->hasNote(FN_NOTE_AlwaysInline))
-    return -2000000000;
+  // 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();
     
   // Add to the inline quality for properties that make the call valuable to
   // inline.  This includes factors that indicate that the result of inlining
@@ -270,7 +278,7 @@ int InlineCostAnalyzer::getInlineCost(CallSite CS,
   // Look at the size of the callee. Each instruction counts as 5.
   InlineCost += CalleeFI.NumInsts*5;
 
-  return InlineCost;
+  return llvm::InlineCost::get(InlineCost);
 }
 
 // getInlineFudgeFactor - Return a > 1.0 factor if the inliner should use a