mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 04:29:21 +00:00
- Made GlobalDCE worklist driven, making it more successful. Now can handle
cases like: test/Regression/Transforms/GlobalDCE/2002-08-17-WorkListTest.ll git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3381 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
09540e2cc5
commit
0bfb6ba3e3
@ -7,14 +7,18 @@
|
|||||||
|
|
||||||
#include "llvm/Transforms/IPO.h"
|
#include "llvm/Transforms/IPO.h"
|
||||||
#include "llvm/Module.h"
|
#include "llvm/Module.h"
|
||||||
#include "llvm/Function.h"
|
#include "llvm/Constants.h"
|
||||||
|
#include "llvm/DerivedTypes.h"
|
||||||
#include "llvm/GlobalVariable.h"
|
#include "llvm/GlobalVariable.h"
|
||||||
#include "llvm/Analysis/CallGraph.h"
|
#include "llvm/Analysis/CallGraph.h"
|
||||||
#include "Support/DepthFirstIterator.h"
|
#include "Support/DepthFirstIterator.h"
|
||||||
#include "Support/StatisticReporter.h"
|
#include "Support/StatisticReporter.h"
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
static Statistic<> NumFunctions("globaldce\t- Number of functions removed");
|
static Statistic<> NumFunctions("globaldce\t- Number of functions removed");
|
||||||
static Statistic<> NumVariables("globaldce\t- Number of global variables removed");
|
static Statistic<> NumVariables("globaldce\t- Number of global variables removed");
|
||||||
|
static Statistic<> NumCPRs("globaldce\t- Number of const pointer refs removed");
|
||||||
|
static Statistic<> NumConsts("globaldce\t- Number of init constants removed");
|
||||||
|
|
||||||
static bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
|
static bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
|
||||||
// Calculate which functions are reachable from the external functions in the
|
// Calculate which functions are reachable from the external functions in the
|
||||||
@ -52,22 +56,6 @@ static bool RemoveUnreachableFunctions(Module &M, CallGraph &CallGraph) {
|
|||||||
return true;
|
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 {
|
namespace {
|
||||||
struct GlobalDCE : public Pass {
|
struct GlobalDCE : public Pass {
|
||||||
// run - Do the GlobalDCE pass on the specified module, optionally updating
|
// run - Do the GlobalDCE pass on the specified module, optionally updating
|
||||||
@ -85,8 +73,179 @@ namespace {
|
|||||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||||
AU.addRequired<CallGraph>();
|
AU.addRequired<CallGraph>();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::vector<GlobalValue*> WorkList;
|
||||||
|
|
||||||
|
inline bool RemoveIfDead(GlobalValue *GV);
|
||||||
|
void DestroyInitializer(Constant *C);
|
||||||
|
|
||||||
|
bool RemoveUnreachableGlobalVariables(Module &M);
|
||||||
|
bool RemoveUnusedConstantPointerRef(GlobalValue &GV);
|
||||||
|
bool SafeToDestroyConstant(Constant *C);
|
||||||
};
|
};
|
||||||
RegisterOpt<GlobalDCE> X("globaldce", "Dead Global Elimination");
|
RegisterOpt<GlobalDCE> X("globaldce", "Dead Global Elimination");
|
||||||
}
|
}
|
||||||
|
|
||||||
Pass *createGlobalDCEPass() { return new GlobalDCE(); }
|
Pass *createGlobalDCEPass() { return new GlobalDCE(); }
|
||||||
|
|
||||||
|
|
||||||
|
// RemoveIfDead - If this global value is dead, remove it from the current
|
||||||
|
// module and return true.
|
||||||
|
//
|
||||||
|
bool GlobalDCE::RemoveIfDead(GlobalValue *GV) {
|
||||||
|
// If there is only one use of the global value, it might be a
|
||||||
|
// ConstantPointerRef... which means that this global might actually be
|
||||||
|
// dead.
|
||||||
|
if (GV->use_size() == 1)
|
||||||
|
RemoveUnusedConstantPointerRef(*GV);
|
||||||
|
|
||||||
|
if (!GV->use_empty()) return false;
|
||||||
|
|
||||||
|
if (GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
|
||||||
|
// Eliminate all global variables that are unused, and that are internal, or
|
||||||
|
// do not have an initializer.
|
||||||
|
//
|
||||||
|
if (!GVar->hasExternalLinkage() || !GVar->hasInitializer()) {
|
||||||
|
Constant *Init = GVar->hasInitializer() ? GVar->getInitializer() : 0;
|
||||||
|
GV->getParent()->getGlobalList().erase(GVar);
|
||||||
|
++NumVariables;
|
||||||
|
|
||||||
|
// If there was an initializer for the global variable, try to destroy it
|
||||||
|
// now.
|
||||||
|
if (Init) DestroyInitializer(Init);
|
||||||
|
|
||||||
|
// If the global variable is still on the worklist, remove it now.
|
||||||
|
std::vector<GlobalValue*>::iterator I = std::find(WorkList.begin(),
|
||||||
|
WorkList.end(), GV);
|
||||||
|
while (I != WorkList.end())
|
||||||
|
I = std::find(WorkList.erase(I), WorkList.end(), GV);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Function *F = cast<Function>(GV);
|
||||||
|
// FIXME: TODO
|
||||||
|
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// DestroyInitializer - A global variable was just destroyed and C is its
|
||||||
|
// initializer. If we can, destroy C and all of the constants it refers to.
|
||||||
|
//
|
||||||
|
void GlobalDCE::DestroyInitializer(Constant *C) {
|
||||||
|
// Cannot destroy constants still being used, and cannot destroy primitive
|
||||||
|
// types.
|
||||||
|
if (!C->use_empty() || C->getType()->isPrimitiveType()) return;
|
||||||
|
|
||||||
|
// If this is a CPR, the global value referred to may be dead now! Add it to
|
||||||
|
// the worklist.
|
||||||
|
//
|
||||||
|
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C)) {
|
||||||
|
WorkList.push_back(CPR->getValue());
|
||||||
|
C->destroyConstant();
|
||||||
|
++NumCPRs;
|
||||||
|
} else {
|
||||||
|
bool DestroyContents = true;
|
||||||
|
|
||||||
|
// As an optimization to the GlobalDCE algorithm, do attempt to destroy the
|
||||||
|
// contents of an array of primitive types, because we know that this will
|
||||||
|
// never succeed, and there could be a lot of them.
|
||||||
|
//
|
||||||
|
if (ConstantArray *CA = dyn_cast<ConstantArray>(C))
|
||||||
|
if (CA->getType()->getElementType()->isPrimitiveType())
|
||||||
|
DestroyContents = false; // Nothing we can do with the subcontents
|
||||||
|
|
||||||
|
// All other constants refer to other constants. Destroy them if possible
|
||||||
|
// as well.
|
||||||
|
//
|
||||||
|
std::vector<Value*> SubConstants;
|
||||||
|
if (DestroyContents) SubConstants.insert(SubConstants.end(),
|
||||||
|
C->op_begin(), C->op_end());
|
||||||
|
|
||||||
|
// Destroy the actual constant...
|
||||||
|
C->destroyConstant();
|
||||||
|
++NumConsts;
|
||||||
|
|
||||||
|
if (DestroyContents) {
|
||||||
|
// Remove duplicates from SubConstants, so that we do not call
|
||||||
|
// DestroyInitializer on the same constant twice (the first call might
|
||||||
|
// delete it, so this would be bad)
|
||||||
|
//
|
||||||
|
std::sort(SubConstants.begin(), SubConstants.end());
|
||||||
|
SubConstants.erase(std::unique(SubConstants.begin(), SubConstants.end()),
|
||||||
|
SubConstants.end());
|
||||||
|
|
||||||
|
// Loop over the subconstants, destroying them as well.
|
||||||
|
for (unsigned i = 0, e = SubConstants.size(); i != e; ++i)
|
||||||
|
DestroyInitializer(cast<Constant>(SubConstants[i]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool GlobalDCE::RemoveUnreachableGlobalVariables(Module &M) {
|
||||||
|
bool Changed = false;
|
||||||
|
WorkList.reserve(M.gsize());
|
||||||
|
|
||||||
|
// Insert all of the globals into the WorkList, making sure to run
|
||||||
|
// RemoveUnusedConstantPointerRef at least once on all globals...
|
||||||
|
//
|
||||||
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
||||||
|
Changed |= RemoveUnusedConstantPointerRef(*I);
|
||||||
|
WorkList.push_back(I);
|
||||||
|
}
|
||||||
|
for (Module::giterator I = M.gbegin(), E = M.gend(); I != E; ++I) {
|
||||||
|
Changed |= RemoveUnusedConstantPointerRef(*I);
|
||||||
|
WorkList.push_back(I);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Loop over the worklist, deleting global objects that we can. Whenever we
|
||||||
|
// delete something that might make something else dead, it gets added to the
|
||||||
|
// worklist.
|
||||||
|
//
|
||||||
|
while (!WorkList.empty()) {
|
||||||
|
GlobalValue *GV = WorkList.back();
|
||||||
|
WorkList.pop_back();
|
||||||
|
|
||||||
|
Changed |= RemoveIfDead(GV);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make sure that all memory is free'd from the worklist...
|
||||||
|
std::vector<GlobalValue*>().swap(WorkList);
|
||||||
|
return Changed;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// RemoveUnusedConstantPointerRef - Loop over all of the uses of the specified
|
||||||
|
// GlobalValue, looking for the constant pointer ref that may be pointing to it.
|
||||||
|
// If found, check to see if the constant pointer ref is safe to destroy, and if
|
||||||
|
// so, nuke it. This will reduce the reference count on the global value, which
|
||||||
|
// might make it deader.
|
||||||
|
//
|
||||||
|
bool GlobalDCE::RemoveUnusedConstantPointerRef(GlobalValue &GV) {
|
||||||
|
for (Value::use_iterator I = GV.use_begin(), E = GV.use_end(); I != E; ++I)
|
||||||
|
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(*I))
|
||||||
|
if (SafeToDestroyConstant(CPR)) { // Only if unreferenced...
|
||||||
|
CPR->destroyConstant();
|
||||||
|
++NumCPRs;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// SafeToDestroyConstant - It is safe to destroy a constant iff it is only used
|
||||||
|
// by constants itself. Note that constants cannot be cyclic, so this test is
|
||||||
|
// pretty easy to implement recursively.
|
||||||
|
//
|
||||||
|
bool GlobalDCE::SafeToDestroyConstant(Constant *C) {
|
||||||
|
for (Value::use_iterator I = C->use_begin(), E = C->use_end(); I != E; ++I)
|
||||||
|
if (Constant *User = dyn_cast<Constant>(*I)) {
|
||||||
|
if (!SafeToDestroyConstant(User)) return false;
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
Loading…
Reference in New Issue
Block a user