93 lines
3.2 KiB
C++
93 lines
3.2 KiB
C++
//===-- GlobalDCE.cpp - DCE unreachable internal functions ----------------===//
|
|
//
|
|
// This transform is designed to eliminate unreachable internal globals
|
|
// FIXME: GlobalDCE should update the callgraph, not destroy it!
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Function.h"
|
|
#include "llvm/GlobalVariable.h"
|
|
#include "llvm/Analysis/CallGraph.h"
|
|
#include "Support/DepthFirstIterator.h"
|
|
#include "Support/StatisticReporter.h"
|
|
|
|
static Statistic<> NumFunctions("globaldce\t- Number of functions removed");
|
|
static Statistic<> NumVariables("globaldce\t- Number of global variables removed");
|
|
|
|
static bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
|
|
// Calculate which functions are reachable from the external functions in the
|
|
// call graph.
|
|
//
|
|
std::set<CallGraphNode*> ReachableNodes(df_begin(&CallGraph),
|
|
df_end(&CallGraph));
|
|
|
|
// Loop over the functions in the module twice. The first time is used to
|
|
// drop references that functions have to each other before they are deleted.
|
|
// The second pass removes the functions that need to be removed.
|
|
//
|
|
std::vector<CallGraphNode*> FunctionsToDelete; // Track unused functions
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
|
CallGraphNode *N = CallGraph[I];
|
|
|
|
if (!ReachableNodes.count(N)) { // Not reachable??
|
|
I->dropAllReferences();
|
|
N->removeAllCalledFunctions();
|
|
FunctionsToDelete.push_back(N);
|
|
++NumFunctions;
|
|
}
|
|
}
|
|
|
|
// Nothing to do if no unreachable functions have been found...
|
|
if (FunctionsToDelete.empty()) return false;
|
|
|
|
// Unreachables functions have been found and should have no references to
|
|
// them, delete them now.
|
|
//
|
|
for (std::vector<CallGraphNode*>::iterator I = FunctionsToDelete.begin(),
|
|
E = FunctionsToDelete.end(); I != E; ++I)
|
|
delete CallGraph.removeFunctionFromModule(*I);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool RemoveUnreachableGlobalVariables(Module &M) {
|
|
bool Changed = false;
|
|
// Eliminate all global variables that are unused, and that are internal, or
|
|
// do not have an initializer.
|
|
//
|
|
for (Module::giterator I = M.gbegin(); I != M.gend(); )
|
|
if (!I->use_empty() || (I->hasExternalLinkage() && I->hasInitializer()))
|
|
++I; // Cannot eliminate global variable
|
|
else {
|
|
I = M.getGlobalList().erase(I);
|
|
++NumVariables;
|
|
Changed = true;
|
|
}
|
|
return Changed;
|
|
}
|
|
|
|
namespace {
|
|
struct GlobalDCE : public Pass {
|
|
// run - Do the GlobalDCE pass on the specified module, optionally updating
|
|
// the specified callgraph to reflect the changes.
|
|
//
|
|
bool run(Module &M) {
|
|
return RemoveUnreachableFunctions(M, getAnalysis<CallGraph>()) |
|
|
RemoveUnreachableGlobalVariables(M);
|
|
}
|
|
|
|
// getAnalysisUsage - This function works on the call graph of a module.
|
|
// It is capable of updating the call graph to reflect the new state of the
|
|
// module.
|
|
//
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.addRequired(CallGraph::ID);
|
|
}
|
|
};
|
|
RegisterPass<GlobalDCE> X("globaldce", "Dead Global Elimination");
|
|
}
|
|
|
|
Pass *createGlobalDCEPass() { return new GlobalDCE(); }
|