6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-22 09:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Rangify for loops in GlobalDCE, NFC.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@242619 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Yaron Keren 2015-07-18 19:57:34 +00:00
parent 7e320cc2c8
commit 3171fba5b2
1 changed files with 49 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
lib/Transforms/IPO/GlobalDCE.cpp
View File

@ -92,33 +92,28 @@ bool GlobalDCE::runOnModule(Module &M) {
ComdatMembers.insert(std::make_pair(C, &GA)); ComdatMembers.insert(std::make_pair(C, &GA));
// Loop over the module, adding globals which are obviously necessary. // Loop over the module, adding globals which are obviously necessary.
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { for (Function &F : M) {
Changed |= RemoveUnusedGlobalValue(*I); Changed |= RemoveUnusedGlobalValue(F);
// Functions with external linkage are needed if they have a body // Functions with external linkage are needed if they have a body
if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage()) { if (!F.isDeclaration() && !F.hasAvailableExternallyLinkage())
if (!I->isDiscardableIfUnused()) if (!F.isDiscardableIfUnused())
GlobalIsNeeded(I); GlobalIsNeeded(&F);
}
} }
for (Module::global_iterator I = M.global_begin(), E = M.global_end(); for (GlobalVariable &GV : M.globals()) {
I != E; ++I) { Changed |= RemoveUnusedGlobalValue(GV);
Changed |= RemoveUnusedGlobalValue(*I);
// Externally visible & appending globals are needed, if they have an // Externally visible & appending globals are needed, if they have an
// initializer. // initializer.
if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage()) { if (!GV.isDeclaration() && !GV.hasAvailableExternallyLinkage())
if (!I->isDiscardableIfUnused()) if (!GV.isDiscardableIfUnused())
GlobalIsNeeded(I); GlobalIsNeeded(&GV);
}
} }
for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); for (GlobalAlias &GA : M.aliases()) {
I != E; ++I) { Changed |= RemoveUnusedGlobalValue(GA);
Changed |= RemoveUnusedGlobalValue(*I);
// Externally visible aliases are needed. // Externally visible aliases are needed.
if (!I->isDiscardableIfUnused()) { if (!GA.isDiscardableIfUnused())
GlobalIsNeeded(I); GlobalIsNeeded(&GA);
}
} }
// Now that all globals which are needed are in the AliveGlobals set, we loop // Now that all globals which are needed are in the AliveGlobals set, we loop
@ -126,52 +121,50 @@ bool GlobalDCE::runOnModule(Module &M) {
// //
// The first pass is to drop initializers of global variables which are dead. // The first pass is to drop initializers of global variables which are dead.
std::vector<GlobalVariable*> DeadGlobalVars; // Keep track of dead globals std::vector<GlobalVariable *> DeadGlobalVars; // Keep track of dead globals
for (Module::global_iterator I = M.global_begin(), E = M.global_end(); for (GlobalVariable &GV : M.globals())
I != E; ++I) if (!AliveGlobals.count(&GV)) {
if (!AliveGlobals.count(I)) { DeadGlobalVars.push_back(&GV); // Keep track of dead globals
DeadGlobalVars.push_back(I); // Keep track of dead globals if (GV.hasInitializer()) {
if (I->hasInitializer()) { Constant *Init = GV.getInitializer();
Constant *Init = I->getInitializer(); GV.setInitializer(nullptr);
I->setInitializer(nullptr);
if (isSafeToDestroyConstant(Init)) if (isSafeToDestroyConstant(Init))
Init->destroyConstant(); Init->destroyConstant();
} }
} }
// The second pass drops the bodies of functions which are dead... // The second pass drops the bodies of functions which are dead...
std::vector<Function*> DeadFunctions; std::vector<Function *> DeadFunctions;
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) for (Function &F : M)
if (!AliveGlobals.count(I)) { if (!AliveGlobals.count(&F)) {
DeadFunctions.push_back(I); // Keep track of dead globals DeadFunctions.push_back(&F); // Keep track of dead globals
if (!I->isDeclaration()) if (!F.isDeclaration())
I->deleteBody(); F.deleteBody();
} }
// The third pass drops targets of aliases which are dead... // The third pass drops targets of aliases which are dead...
std::vector<GlobalAlias*> DeadAliases; std::vector<GlobalAlias*> DeadAliases;
for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end(); I != E; for (GlobalAlias &GA : M.aliases())
++I) if (!AliveGlobals.count(&GA)) {
if (!AliveGlobals.count(I)) { DeadAliases.push_back(&GA);
DeadAliases.push_back(I); GA.setAliasee(nullptr);
I->setAliasee(nullptr);
} }
if (!DeadFunctions.empty()) { if (!DeadFunctions.empty()) {
// Now that all interferences have been dropped, delete the actual objects // Now that all interferences have been dropped, delete the actual objects
// themselves. // themselves.
for (unsigned i = 0, e = DeadFunctions.size(); i != e; ++i) { for (Function *F : DeadFunctions) {
RemoveUnusedGlobalValue(*DeadFunctions[i]); RemoveUnusedGlobalValue(*F);
M.getFunctionList().erase(DeadFunctions[i]); M.getFunctionList().erase(F);
} }
NumFunctions += DeadFunctions.size(); NumFunctions += DeadFunctions.size();
Changed = true; Changed = true;
} }
if (!DeadGlobalVars.empty()) { if (!DeadGlobalVars.empty()) {
for (unsigned i = 0, e = DeadGlobalVars.size(); i != e; ++i) { for (GlobalVariable *GV : DeadGlobalVars) {
RemoveUnusedGlobalValue(*DeadGlobalVars[i]); RemoveUnusedGlobalValue(*GV);
M.getGlobalList().erase(DeadGlobalVars[i]); M.getGlobalList().erase(GV);
} }
NumVariables += DeadGlobalVars.size(); NumVariables += DeadGlobalVars.size();
Changed = true; Changed = true;
@ -179,9 +172,9 @@ bool GlobalDCE::runOnModule(Module &M) {
// Now delete any dead aliases. // Now delete any dead aliases.
if (!DeadAliases.empty()) { if (!DeadAliases.empty()) {
for (unsigned i = 0, e = DeadAliases.size(); i != e; ++i) { for (GlobalAlias *GA : DeadAliases) {
RemoveUnusedGlobalValue(*DeadAliases[i]); RemoveUnusedGlobalValue(*GA);
M.getAliasList().erase(DeadAliases[i]); M.getAliasList().erase(GA);
} }
NumAliases += DeadAliases.size(); NumAliases += DeadAliases.size();
Changed = true; Changed = true;
@ -231,12 +224,12 @@ void GlobalDCE::GlobalIsNeeded(GlobalValue *G) {
if (F->hasPersonalityFn()) if (F->hasPersonalityFn())
MarkUsedGlobalsAsNeeded(F->getPersonalityFn()); MarkUsedGlobalsAsNeeded(F->getPersonalityFn());
for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) for (BasicBlock &BB : *F)
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) for (Instruction &I : BB)
for (User::op_iterator U = I->op_begin(), E = I->op_end(); U != E; ++U) for (Use &U : I.operands())
if (GlobalValue *GV = dyn_cast<GlobalValue>(*U)) if (GlobalValue *GV = dyn_cast<GlobalValue>(U))
GlobalIsNeeded(GV); GlobalIsNeeded(GV);
else if (Constant *C = dyn_cast<Constant>(*U)) else if (Constant *C = dyn_cast<Constant>(U))
MarkUsedGlobalsAsNeeded(C); MarkUsedGlobalsAsNeeded(C);
} }
} }
@ -247,9 +240,9 @@ void GlobalDCE::MarkUsedGlobalsAsNeeded(Constant *C) {
// Loop over all of the operands of the constant, adding any globals they // Loop over all of the operands of the constant, adding any globals they
// use to the list of needed globals. // use to the list of needed globals.
for (User::op_iterator I = C->op_begin(), E = C->op_end(); I != E; ++I) { for (Use &U : C->operands()) {
// If we've already processed this constant there's no need to do it again. // If we've already processed this constant there's no need to do it again.
Constant *Op = dyn_cast<Constant>(*I); Constant *Op = dyn_cast<Constant>(U);
if (Op && SeenConstants.insert(Op).second) if (Op && SeenConstants.insert(Op).second)
MarkUsedGlobalsAsNeeded(Op); MarkUsedGlobalsAsNeeded(Op);
} }
@ -262,7 +255,8 @@ void GlobalDCE::MarkUsedGlobalsAsNeeded(Constant *C) {
// might make it deader. // might make it deader.
// //
bool GlobalDCE::RemoveUnusedGlobalValue(GlobalValue &GV) { bool GlobalDCE::RemoveUnusedGlobalValue(GlobalValue &GV) {
if (GV.use_empty()) return false; if (GV.use_empty())
return false;
GV.removeDeadConstantUsers(); GV.removeDeadConstantUsers();
return GV.use_empty(); return GV.use_empty();
} }