6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

Revert r98089, it was breaking a clang test.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98094 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakob Stoklund Olesen 2010-03-09 22:43:37 +00:00
parent 9e5d87d568
commit b5a158bab8
6 changed files with 6 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Analysis/InlineCost.h
View File

@ -179,11 +179,6 @@ namespace llvm {
void resetCachedCostInfo(Function* Caller) {
CachedFunctionInfo[Caller] = FunctionInfo();
}
/// growCachedCostInfo - update the cached cost info for Caller after Callee
/// has been inlined. If Callee is NULL it means a dead call has been
/// eliminated.
void growCachedCostInfo(Function* Caller, Function* Callee);
};
}

4
include/llvm/Transforms/IPO/InlinerPass.h
View File

@ -75,10 +75,6 @@ struct Inliner : public CallGraphSCCPass {
///
virtual void resetCachedCostInfo(Function* Caller) = 0;
/// growCachedCostInfo - update the cached cost info for Caller after Callee
/// has been inlined.
virtual void growCachedCostInfo(Function* Caller, Function* Callee) = 0;
/// removeDeadFunctions - Remove dead functions that are not included in
/// DNR (Do Not Remove) list.
bool removeDeadFunctions(CallGraph &CG,

36
lib/Analysis/InlineCost.cpp
View File

@ -383,39 +383,3 @@ float InlineCostAnalyzer::getInlineFudgeFactor(CallSite CS) {
Factor += 1.5f;
return Factor;
}
/// growCachedCostInfo - update the cached cost info for Caller after Callee has
/// been inlined.
void
InlineCostAnalyzer::growCachedCostInfo(Function* Caller, Function* Callee) {
FunctionInfo &CallerFI = CachedFunctionInfo[Caller];
// For small functions we prefer to recalculate the cost for better accuracy.
if (!CallerFI.Metrics.NumBlocks || CallerFI.Metrics.NumInsts < 100) {
resetCachedCostInfo(Caller);
return;
}
// For large functions, we can save a lot of computation time by skipping
// recalculations.
if (CallerFI.Metrics.NumCalls > 0)
--CallerFI.Metrics.NumCalls;
if (Callee) {
FunctionInfo &CalleeFI = CachedFunctionInfo[Callee];
if (!CalleeFI.Metrics.NumBlocks) {
resetCachedCostInfo(Caller);
return;
}
CallerFI.Metrics.NeverInline |= CalleeFI.Metrics.NeverInline;
CallerFI.Metrics.usesDynamicAlloca |= CalleeFI.Metrics.usesDynamicAlloca;
CallerFI.Metrics.NumInsts += CalleeFI.Metrics.NumInsts;
CallerFI.Metrics.NumBlocks += CalleeFI.Metrics.NumBlocks;
CallerFI.Metrics.NumCalls += CalleeFI.Metrics.NumCalls;
CallerFI.Metrics.NumVectorInsts += CalleeFI.Metrics.NumVectorInsts;
CallerFI.Metrics.NumRets += CalleeFI.Metrics.NumRets;
}
// We are not updating the argumentweights. We have already determined that
// Caller is a fairly large function, so we accept the loss of precision.
}

5
lib/Transforms/IPO/InlineAlways.cpp
View File

@ -45,10 +45,7 @@ namespace {
return CA.getInlineFudgeFactor(CS);
}
void resetCachedCostInfo(Function *Caller) {
CA.resetCachedCostInfo(Caller);
}
void growCachedCostInfo(Function* Caller, Function* Callee) {
CA.growCachedCostInfo(Caller, Callee);
return CA.resetCachedCostInfo(Caller);
}
virtual bool doFinalization(CallGraph &CG) {
return removeDeadFunctions(CG, &NeverInline);

3
lib/Transforms/IPO/InlineSimple.cpp
View File

@ -45,9 +45,6 @@ namespace {
void resetCachedCostInfo(Function *Caller) {
CA.resetCachedCostInfo(Caller);
}
void growCachedCostInfo(Function* Caller, Function* Callee) {
CA.growCachedCostInfo(Caller, Callee);
}
virtual bool doInitialization(CallGraph &CG);
};
}

10
lib/Transforms/IPO/Inliner.cpp
View File

@ -369,8 +369,6 @@ bool Inliner::runOnSCC(std::vector<CallGraphNode*> &SCC) {
CG[Caller]->removeCallEdgeFor(CS);
CS.getInstruction()->eraseFromParent();
++NumCallsDeleted;
// Update the cached cost info with the missing call
growCachedCostInfo(Caller, NULL);
} else {
// We can only inline direct calls to non-declarations.
if (Callee == 0 || Callee->isDeclaration()) continue;
@ -384,9 +382,6 @@ bool Inliner::runOnSCC(std::vector<CallGraphNode*> &SCC) {
if (!InlineCallIfPossible(CS, CG, TD, InlinedArrayAllocas))
continue;
++NumInlined;
// Update the cached cost info with the inlined call.
growCachedCostInfo(Caller, Callee);
}
// If we inlined or deleted the last possible call site to the function,
@ -412,6 +407,11 @@ bool Inliner::runOnSCC(std::vector<CallGraphNode*> &SCC) {
delete CG.removeFunctionFromModule(CalleeNode);
++NumDeleted;
}
// Remove any cached cost info for this caller, as inlining the
// callee has increased the size of the caller (which may be the
// same as the callee).
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