///
virtual float getInlineFudgeFactor(CallSite CS) = 0;
+ /// resetCachedCostInfo - erase any cached cost data from the derived class.
+ /// If the derived class has no such data this can be empty.
+ ///
+ virtual void resetCachedCostInfo(Function* Caller) = 0;
+
/// removeDeadFunctions - Remove dead functions that are not included in
/// DNR (Do Not Remove) list.
bool removeDeadFunctions(CallGraph &CG,
/// getInlineFudgeFactor - Return a > 1.0 factor if the inliner should use a
/// higher threshold to determine if the function call should be inlined.
float getInlineFudgeFactor(CallSite CS);
+
+ /// resetCachedFunctionInfo - erase any cached cost info for this function.
+ void resetCachedCostInfo(Function* Caller) {
+ CachedFunctionInfo[Caller].NumBlocks = 0;
+ }
};
}
float getInlineFudgeFactor(CallSite CS) {
return CA.getInlineFudgeFactor(CS);
}
+ void resetCachedCostInfo(Function *Caller) {
+ return CA.resetCachedCostInfo(Caller);
+ }
virtual bool doFinalization(CallGraph &CG) {
return removeDeadFunctions(CG, &NeverInline);
}
float getInlineFudgeFactor(CallSite CS) {
return CA.getInlineFudgeFactor(CS);
}
+ void resetCachedCostInfo(Function *Caller) {
+ CA.resetCachedCostInfo(Caller);
+ }
virtual bool doInitialization(CallGraph &CG);
};
}
// try to do so.
CallSite CS = CallSites[CSi];
if (shouldInline(CS)) {
+ Function *Caller = CS.getCaller();
// Attempt to inline the function...
if (InlineCallIfPossible(CS, CG, SCCFunctions,
getAnalysis<TargetData>())) {
+ // Remove any cached cost info for this caller, as inlining the callee
+ // has increased the size of the caller.
+ resetCachedCostInfo(Caller);
+
// Remove this call site from the list. If possible, use
// swap/pop_back for efficiency, but do not use it if doing so would
// move a call site to a function in this SCC before the
}
if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
- if (!isa<ConstantInt>(AI->getArraySize()))
+ if (!AI->isStaticAlloca())
this->usesDynamicAlloca = true;
}
if (CalleeFI.NeverInline)
return InlineCost::getNever();
- // Get infomation about the caller...
- FunctionInfo &CallerFI = CachedFunctionInfo[Caller];
+ 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);
+ // 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 (CalleeFI.usesDynamicAlloca && !CallerFI.usesDynamicAlloca)
- return InlineCost::getNever();
+ // 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();
+ }
// FIXME: It would be nice to kill off CalleeFI.NeverInline. Then we
// could move this up and avoid computing the FunctionInfo for