NumInsts += 5;
}
+ if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
+ if (!AI->isStaticAlloca())
+ this->usesDynamicAlloca = true;
+ }
+
if (isa<ExtractElementInst>(II) || isa<VectorType>(II->getType()))
++NumVectorInsts;
// 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();
-
+ 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;
-
+ Callee->hasFnAttr(Attribute::NoInline) || NeverInline.count(Callee))
+ 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.
// If we haven't calculated this information yet, do so now.
if (CalleeFI.NumBlocks == 0)
CalleeFI.analyzeFunction(Callee);
-
+
// If we should never inline this, return a huge cost.
if (CalleeFI.NeverInline)
- return 2000000000;
+ return InlineCost::getNever();
+
+ if (CalleeFI.usesDynamicAlloca) {
+ // Get infomation about the caller...
+ FunctionInfo &CallerFI = CachedFunctionInfo[Caller];
+
+ // If we haven't calculated this information yet, do so now.
+ if (CallerFI.NumBlocks == 0)
+ CallerFI.analyzeFunction(Caller);
+
+ // Don't inline a callee with dynamic alloca into a caller without them.
+ // Functions containing dynamic alloca's are inefficient in various ways;
+ // don't create more inefficiency.
+ if (!CallerFI.usesDynamicAlloca)
+ return InlineCost::getNever();
+ }
- if (Callee->hasNote(ParamAttr::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
// 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